use std::collections::HashSet;
use std::fmt::Write as _;
use openapi_forge::Spec;
use crate::error::ForgeError;
use crate::resource_gen::render_read_mapping_code;
use crate::schema_gen::{TfAttribute, render_single_attribute};
use crate::spec::{DataSourceSpec, ProviderDefaults};
use crate::type_map::{
go_to_tf_attr, openapi_to_go, tf_value_type, to_go_public_name, to_tf_name, to_type_name,
};
#[derive(Debug, Clone, PartialEq, Eq)]
#[must_use]
pub struct GeneratedDataSource {
pub file_name: String,
pub go_code: String,
pub data_source_type_name: String,
}
pub fn generate_datasource_attributes(
ds: &DataSourceSpec,
api: &Spec,
defaults: &ProviderDefaults,
) -> Result<Vec<TfAttribute>, ForgeError> {
let read_fields = api.fields(&ds.read.schema)?;
let skip_fields: HashSet<&str> = defaults.skip_fields.iter().map(String::as_str).collect();
let mut attributes = Vec::new();
for field in &read_fields {
let tf_name = to_tf_name(&field.name);
if skip_fields.contains(field.name.as_str()) {
continue;
}
let override_cfg = ds.fields.get(&field.name);
if override_cfg.is_some_and(|o| o.skip) {
continue;
}
let computed = override_cfg.is_some_and(|o| o.computed);
let sensitive = override_cfg.is_some_and(|o| o.sensitive);
let type_override = override_cfg.and_then(|o| o.type_override.as_deref());
let go_type = openapi_to_go(&field.type_info, type_override);
let tf_type = go_to_tf_attr(&go_type);
let description = override_cfg
.and_then(|o| o.description.clone())
.or_else(|| field.description.clone())
.unwrap_or_default();
let default_value = field.default.as_ref().map(|v| format!("{v}"));
let (required, optional) = if computed {
(false, false) } else {
(false, true) };
attributes.push(TfAttribute {
tf_name,
go_name: to_go_public_name(&field.name),
description,
required,
optional,
computed: computed || !field.required,
sensitive,
force_new: false,
tf_type_expr: tf_type.to_string(),
tf_value_type: tf_value_type(&go_type).to_string(),
go_type: go_type.to_string(),
default_value,
});
}
Ok(attributes)
}
pub fn generate_datasource(
ds: &DataSourceSpec,
api: &Spec,
defaults: &ProviderDefaults,
sdk_import: &str,
) -> Result<GeneratedDataSource, ForgeError> {
let attrs = generate_datasource_attributes(ds, api, defaults)?;
let type_name = to_type_name(&ds.data_source.name);
let file_name = format!("datasource_{}.go", to_tf_name(&ds.data_source.name));
let mut code = String::new();
code.push_str(&render_ds_imports(&type_name, sdk_import));
code.push_str(&render_ds_type(&type_name));
code.push_str(&render_ds_model(&type_name, &attrs));
code.push('\n');
code.push_str(&render_ds_metadata(&ds.data_source.name));
code.push_str(&render_ds_schema(&attrs, &ds.data_source.description));
code.push('\n');
code.push_str(&render_ds_configure(&type_name));
code.push_str(&render_ds_read(
&type_name,
&ds.read.endpoint,
&attrs,
&ds.read_mapping,
));
Ok(GeneratedDataSource {
file_name,
go_code: code,
data_source_type_name: type_name,
})
}
fn render_ds_imports(type_name: &str, sdk_import: &str) -> String {
format!(
r#"// Code generated by terraform-forge. DO NOT EDIT.
package resources
import (
"context"
"fmt"
"github.com/hashicorp/terraform-plugin-framework/datasource"
"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
"github.com/hashicorp/terraform-plugin-framework/types"
"github.com/hashicorp/terraform-plugin-log/tflog"
akeyless_api "{sdk_import}"
)
var (
_ datasource.DataSource = &{type_name}DataSource{{}}
_ datasource.DataSourceWithConfigure = &{type_name}DataSource{{}}
)
"#
)
}
fn render_ds_type(type_name: &str) -> String {
format!(
r"type {type_name}DataSource struct {{
client *AkeylessClient
}}
func New{type_name}DataSource() datasource.DataSource {{
return &{type_name}DataSource{{}}
}}
"
)
}
fn render_ds_model(type_name: &str, attrs: &[TfAttribute]) -> String {
let struct_name = format!("{type_name}DataSourceModel");
let mut out = String::new();
let _ = writeln!(out, "type {struct_name} struct {{");
let fields: String = attrs
.iter()
.map(|a| format!("\t{} {} `tfsdk:\"{}\"`\n", a.go_name, a.tf_value_type, a.tf_name))
.collect();
out.push_str(&fields);
out.push_str("}\n");
out
}
fn render_ds_metadata(ds_name: &str) -> String {
let suffix = ds_name.strip_prefix("akeyless_").unwrap_or(ds_name);
let type_name = to_type_name(ds_name);
format!(
r#"func (d *{type_name}DataSource) Metadata(ctx context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {{
resp.TypeName = req.ProviderTypeName + "_{suffix}"
}}
"#,
)
}
fn render_ds_schema(attrs: &[TfAttribute], description: &str) -> String {
let mut out = String::new();
out.push_str("func (d *Resource) Schema(ctx context.Context, req datasource.SchemaRequest, resp *datasource.SchemaResponse) {\n");
out.push_str("\tresp.Schema = schema.Schema{\n");
let desc = description.replace('"', "\\\"");
let _ = writeln!(out, "\t\tDescription: \"{desc}\",");
out.push_str("\t\tAttributes: map[string]schema.Attribute{\n");
let attr_code: String = attrs.iter().map(render_single_attribute).collect();
out.push_str(&attr_code);
out.push_str("\t\t},\n");
out.push_str("\t}\n");
out.push_str("}\n");
out
}
fn render_ds_configure(type_name: &str) -> String {
format!(
r#"func (d *{type_name}DataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {{
if req.ProviderData == nil {{
return
}}
client, ok := req.ProviderData.(*AkeylessClient)
if !ok {{
resp.Diagnostics.AddError(
"Unexpected DataSource Configure Type",
fmt.Sprintf("Expected *AkeylessClient, got: %T", req.ProviderData),
)
return
}}
d.client = client
}}
"#
)
}
fn render_ds_read(
type_name: &str,
endpoint: &str,
attrs: &[TfAttribute],
read_mapping: &std::collections::BTreeMap<String, String>,
) -> String {
let field_reads = render_read_mapping_code(attrs, read_mapping);
let id_field = attrs.iter().find(|a| a.tf_name == "name").or_else(|| {
attrs
.iter()
.find(|a| a.optional && a.tf_value_type == "types.String")
});
let id_setup = if let Some(id_attr) = id_field {
let go_name = &id_attr.go_name;
format!(
r#" body := akeyless_api.NewReadBody("{endpoint}")
id := state.{go_name}.ValueString()
body.Set{go_name}(&id)
"#
)
} else {
format!("\tbody := akeyless_api.NewReadBody(\"{endpoint}\")\n")
};
format!(
r#"func (d *{type_name}DataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {{
var state {type_name}DataSourceModel
diags := req.Config.Get(ctx, &state)
resp.Diagnostics.Append(diags...)
if resp.Diagnostics.HasError() {{
return
}}
{id_setup}
tflog.Debug(ctx, "Reading {type_name} data source")
result, err := d.client.Call(ctx, body)
if err != nil {{
resp.Diagnostics.AddError("Error reading {type_name}", err.Error())
return
}}
{field_reads}
diags = resp.State.Set(ctx, &state)
resp.Diagnostics.Append(diags...)
}}
"#
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::spec::DataSourceSpec;
fn make_ds_test_data() -> (DataSourceSpec, Spec, ProviderDefaults) {
let toml_str = r#"
[data_source]
name = "akeyless_auth_method"
description = "Read an auth method"
[read]
endpoint = "/get-auth-method"
schema = "GetAuthMethod"
[fields]
token = { skip = true }
[read_mapping]
"auth_method_access_id" = "access_id"
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let api_str = r#"
openapi: "3.0.0"
info: { title: Test, version: "1.0" }
paths:
/get-auth-method:
post:
operationId: getAuthMethod
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/GetAuthMethod'
responses:
"200": { description: ok }
components:
schemas:
GetAuthMethod:
type: object
required: [name]
properties:
name: { type: string, description: "Auth method name" }
access_id: { type: string, description: "Access ID" }
token: { type: string }
"#;
let api = Spec::parse(api_str).expect("parse");
(ds, api, ProviderDefaults::default())
}
#[test]
fn generate_datasource_attributes_test() {
let (ds, api, defaults) = make_ds_test_data();
let attrs = generate_datasource_attributes(&ds, &api, &defaults).expect("gen");
assert!(attrs.iter().all(|a| a.tf_name != "token"));
let name_attr = attrs.iter().find(|a| a.tf_name == "name").expect("name");
assert!(!name_attr.required);
assert!(name_attr.optional);
let access = attrs
.iter()
.find(|a| a.tf_name == "access_id")
.expect("access_id");
assert!(access.computed);
}
#[test]
fn generate_full_datasource() {
let (ds, api, defaults) = make_ds_test_data();
let result = generate_datasource(
&ds,
&api,
&defaults,
"github.com/akeylesslabs/akeyless-go/v5",
)
.expect("gen");
assert_eq!(result.file_name, "datasource_akeyless_auth_method.go");
assert!(result.go_code.contains("AuthMethodDataSource"));
assert!(
result
.go_code
.contains("func (d *AuthMethodDataSource) Read")
);
assert!(
result
.go_code
.contains("func (d *AuthMethodDataSource) Configure")
);
assert!(result.go_code.contains("AuthMethodDataSourceModel"));
}
#[test]
fn datasource_read_mapping_generates_code() {
let (ds, api, defaults) = make_ds_test_data();
let result = generate_datasource(
&ds,
&api,
&defaults,
"github.com/akeylesslabs/akeyless-go/v5",
)
.expect("gen");
assert!(
result
.go_code
.contains("GetNestedString(result, \"auth_method_access_id\")")
);
assert!(
result
.go_code
.contains("state.AccessId = types.StringValue(v)")
);
}
#[test]
fn datasource_computed_only_field_not_optional() {
let toml_str = r#"
[data_source]
name = "akeyless_ds"
description = "DS"
[read]
endpoint = "/get"
schema = "GetDS"
[fields]
auto_field = { computed = true }
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let api_str = r#"
openapi: "3.0.0"
info: { title: T, version: "1" }
paths:
/get:
post:
operationId: get
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/GetDS'
responses:
"200": { description: ok }
components:
schemas:
GetDS:
type: object
required: [name, auto_field]
properties:
name: { type: string }
auto_field: { type: string }
"#;
let api = Spec::parse(api_str).expect("parse");
let attrs =
generate_datasource_attributes(&ds, &api, &ProviderDefaults::default()).expect("gen");
let auto = attrs
.iter()
.find(|a| a.tf_name == "auto_field")
.expect("auto_field");
assert!(!auto.required, "computed ds field should not be required");
assert!(!auto.optional, "computed-only ds field should not be optional");
assert!(auto.computed, "computed field should be computed");
}
#[test]
fn datasource_sensitive_field() {
let toml_str = r#"
[data_source]
name = "akeyless_ds"
description = "DS"
[read]
endpoint = "/get"
schema = "GetDS"
[fields]
secret = { sensitive = true }
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let api_str = r#"
openapi: "3.0.0"
info: { title: T, version: "1" }
paths:
/get:
post:
operationId: get
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/GetDS'
responses:
"200": { description: ok }
components:
schemas:
GetDS:
type: object
properties:
secret: { type: string }
"#;
let api = Spec::parse(api_str).expect("parse");
let attrs =
generate_datasource_attributes(&ds, &api, &ProviderDefaults::default()).expect("gen");
let secret = attrs
.iter()
.find(|a| a.tf_name == "secret")
.expect("secret");
assert!(secret.sensitive);
}
#[test]
fn datasource_schema_includes_description() {
let (ds, api, defaults) = make_ds_test_data();
let result = generate_datasource(
&ds,
&api,
&defaults,
"github.com/test/sdk",
)
.expect("gen");
assert!(result.go_code.contains("Description: \"Read an auth method\""));
}
#[test]
fn datasource_no_name_field_still_generates() {
let toml_str = r#"
[data_source]
name = "akeyless_no_name"
description = "No name field"
[read]
endpoint = "/get-thing"
schema = "GetThing"
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let api_str = r#"
openapi: "3.0.0"
info: { title: T, version: "1" }
paths:
/get-thing:
post:
operationId: getThing
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/GetThing'
responses:
"200": { description: ok }
components:
schemas:
GetThing:
type: object
properties:
count: { type: integer }
enabled: { type: boolean }
"#;
let api = Spec::parse(api_str).expect("parse");
let result = generate_datasource(
&ds,
&api,
&ProviderDefaults::default(),
"github.com/test/sdk",
)
.expect("gen");
assert!(result.go_code.contains("NoNameDataSource"));
assert!(!result.go_code.contains("body.SetName"), "No name field means no id setup");
}
#[test]
fn datasource_no_prefix() {
let toml_str = r#"
[data_source]
name = "custom_data"
description = "Custom"
[read]
endpoint = "/get-auth-method"
schema = "GetAuthMethod"
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let (_, api, defaults) = make_ds_test_data();
let result = generate_datasource(&ds, &api, &defaults, "github.com/test/sdk")
.expect("gen");
assert!(result.go_code.contains("CustomDataDataSource"));
assert_eq!(result.file_name, "datasource_custom_data.go");
}
#[test]
fn datasource_global_skip_fields() {
let (ds, api, _) = make_ds_test_data();
let defaults = ProviderDefaults {
skip_fields: vec!["access_id".to_string()],
};
let attrs = generate_datasource_attributes(&ds, &api, &defaults).expect("gen");
assert!(
attrs.iter().all(|a| a.tf_name != "access_id"),
"access_id should be skipped via global defaults"
);
}
#[test]
fn datasource_schema_sensitive_attribute() {
let toml_str = r#"
[data_source]
name = "akeyless_sens"
description = "Sensitive test"
[read]
endpoint = "/get-auth-method"
schema = "GetAuthMethod"
[fields]
access_id = { sensitive = true }
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let (_, api, defaults) = make_ds_test_data();
let result = generate_datasource(&ds, &api, &defaults, "github.com/test/sdk")
.expect("gen");
assert!(result.go_code.contains("Sensitive: true"));
}
#[test]
fn datasource_type_override() {
let toml_str = r#"
[data_source]
name = "akeyless_override"
description = "Override"
[read]
endpoint = "/get-auth-method"
schema = "GetAuthMethod"
[fields]
access_id = { type_override = "bool" }
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let (_, api, defaults) = make_ds_test_data();
let attrs = generate_datasource_attributes(&ds, &api, &defaults).expect("gen");
let access = attrs
.iter()
.find(|a| a.tf_name == "access_id")
.expect("access_id");
assert_eq!(access.go_type, "bool");
}
#[test]
fn datasource_read_uses_first_optional_string_when_no_name() {
let toml_str = r#"
[data_source]
name = "akeyless_alt_id"
description = "Alt ID"
[read]
endpoint = "/get-alt"
schema = "GetAlt"
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let api_str = r#"
openapi: "3.0.0"
info: { title: T, version: "1" }
paths:
/get-alt:
post:
operationId: getAlt
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/GetAlt'
responses:
"200": { description: ok }
components:
schemas:
GetAlt:
type: object
properties:
path: { type: string, description: "Path" }
count: { type: integer }
"#;
let api = Spec::parse(api_str).expect("parse");
let result = generate_datasource(
&ds,
&api,
&ProviderDefaults::default(),
"github.com/test/sdk",
)
.expect("gen");
assert!(
result.go_code.contains("body.SetPath"),
"Should use first optional string field 'path' as id"
);
}
#[test]
fn generate_datasource_attributes_missing_schema_errors() {
let toml_str = r#"
[data_source]
name = "test_ds"
description = "Test"
[read]
endpoint = "/get"
schema = "NonExistentSchema"
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let api_str = r#"
openapi: "3.0.0"
info: { title: T, version: "1" }
paths: {}
components:
schemas: {}
"#;
let api = Spec::parse(api_str).expect("parse");
let result = generate_datasource_attributes(&ds, &api, &ProviderDefaults::default());
assert!(result.is_err(), "Missing schema should error");
}
#[test]
fn generate_datasource_missing_schema_errors() {
let toml_str = r#"
[data_source]
name = "test_ds"
description = "Test"
[read]
endpoint = "/get"
schema = "NonExistentSchema"
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let api_str = r#"
openapi: "3.0.0"
info: { title: T, version: "1" }
paths: {}
components:
schemas: {}
"#;
let api = Spec::parse(api_str).expect("parse");
let result = generate_datasource(&ds, &api, &ProviderDefaults::default(), "sdk");
assert!(result.is_err(), "Missing schema should error");
}
#[test]
fn datasource_field_description_override() {
let toml_str = r#"
[data_source]
name = "akeyless_ds"
description = "DS"
[read]
endpoint = "/get-auth-method"
schema = "GetAuthMethod"
[fields]
name = { description = "Custom name desc" }
"#;
let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
let (_, api, defaults) = make_ds_test_data();
let attrs = generate_datasource_attributes(&ds, &api, &defaults).expect("gen");
let name_attr = attrs.iter().find(|a| a.tf_name == "name").expect("name");
assert_eq!(name_attr.description, "Custom name desc");
}
}