Skip to main content

terraform_forge/
datasource_gen.rs

1use std::collections::HashSet;
2use std::fmt::Write as _;
3
4use openapi_forge::Spec;
5
6use crate::error::ForgeError;
7use crate::resource_gen::render_read_mapping_code;
8use crate::schema_gen::{TfAttribute, render_single_attribute};
9use crate::spec::{DataSourceSpec, ProviderDefaults};
10use crate::type_map::{
11    go_to_tf_attr, openapi_to_go, tf_value_type, to_go_public_name, to_tf_name, to_type_name,
12};
13
14/// Generated Go source for a complete TF data source.
15#[derive(Debug, Clone, PartialEq, Eq)]
16#[must_use]
17pub struct GeneratedDataSource {
18    pub file_name: String,
19    pub go_code: String,
20    pub data_source_type_name: String,
21}
22
23/// Generate TF schema attributes for a data source.
24///
25/// All fields are either Optional or Computed (no Required), since a data
26/// source is read-only.
27///
28/// # Errors
29///
30/// Returns an error if referenced schemas are missing.
31pub fn generate_datasource_attributes(
32    ds: &DataSourceSpec,
33    api: &Spec,
34    defaults: &ProviderDefaults,
35) -> Result<Vec<TfAttribute>, ForgeError> {
36    let read_fields = api.fields(&ds.read.schema)?;
37
38    let skip_fields: HashSet<&str> = defaults.skip_fields.iter().map(String::as_str).collect();
39
40    let mut attributes = Vec::new();
41
42    for field in &read_fields {
43        let tf_name = to_tf_name(&field.name);
44
45        if skip_fields.contains(field.name.as_str()) {
46            continue;
47        }
48
49        let override_cfg = ds.fields.get(&field.name);
50        if override_cfg.is_some_and(|o| o.skip) {
51            continue;
52        }
53
54        let computed = override_cfg.is_some_and(|o| o.computed);
55        let sensitive = override_cfg.is_some_and(|o| o.sensitive);
56
57        let type_override = override_cfg.and_then(|o| o.type_override.as_deref());
58        let go_type = openapi_to_go(&field.type_info, type_override);
59        let tf_type = go_to_tf_attr(&go_type);
60
61        let description = override_cfg
62            .and_then(|o| o.description.clone())
63            .or_else(|| field.description.clone())
64            .unwrap_or_default();
65
66        let default_value = field.default.as_ref().map(|v| format!("{v}"));
67
68        // Data source fields: if originally required, make them Optional (input params).
69        // If computed, make them Computed-only (output from API).
70        // Otherwise Optional.
71        let (required, optional) = if computed {
72            (false, false) // Computed-only
73        } else {
74            (false, true) // Optional input param
75        };
76
77        attributes.push(TfAttribute {
78            tf_name,
79            go_name: to_go_public_name(&field.name),
80            description,
81            required,
82            optional,
83            computed: computed || !field.required,
84            sensitive,
85            force_new: false,
86            tf_type_expr: tf_type.to_string(),
87            tf_value_type: tf_value_type(&go_type).to_string(),
88            go_type: go_type.to_string(),
89            default_value,
90        });
91    }
92
93    Ok(attributes)
94}
95
96/// Generate a complete terraform-plugin-framework data source Go file.
97///
98/// # Errors
99///
100/// Returns an error if schema generation fails.
101pub fn generate_datasource(
102    ds: &DataSourceSpec,
103    api: &Spec,
104    defaults: &ProviderDefaults,
105    sdk_import: &str,
106) -> Result<GeneratedDataSource, ForgeError> {
107    let attrs = generate_datasource_attributes(ds, api, defaults)?;
108
109    let type_name = to_type_name(&ds.data_source.name);
110
111    let file_name = format!("datasource_{}.go", to_tf_name(&ds.data_source.name));
112
113    let mut code = String::new();
114
115    code.push_str(&render_ds_imports(&type_name, sdk_import));
116    code.push_str(&render_ds_type(&type_name));
117    code.push_str(&render_ds_model(&type_name, &attrs));
118    code.push('\n');
119    code.push_str(&render_ds_metadata(&ds.data_source.name));
120    code.push_str(&render_ds_schema(&attrs, &ds.data_source.description));
121    code.push('\n');
122    code.push_str(&render_ds_configure(&type_name));
123    code.push_str(&render_ds_read(
124        &type_name,
125        &ds.read.endpoint,
126        &attrs,
127        &ds.read_mapping,
128    ));
129
130    Ok(GeneratedDataSource {
131        file_name,
132        go_code: code,
133        data_source_type_name: type_name,
134    })
135}
136
137fn render_ds_imports(type_name: &str, sdk_import: &str) -> String {
138    format!(
139        r#"// Code generated by terraform-forge. DO NOT EDIT.
140
141package resources
142
143import (
144	"context"
145	"fmt"
146
147	"github.com/hashicorp/terraform-plugin-framework/datasource"
148	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
149	"github.com/hashicorp/terraform-plugin-framework/types"
150	"github.com/hashicorp/terraform-plugin-log/tflog"
151
152	akeyless_api "{sdk_import}"
153)
154
155var (
156	_ datasource.DataSource              = &{type_name}DataSource{{}}
157	_ datasource.DataSourceWithConfigure = &{type_name}DataSource{{}}
158)
159
160"#
161    )
162}
163
164fn render_ds_type(type_name: &str) -> String {
165    format!(
166        r"type {type_name}DataSource struct {{
167	client *AkeylessClient
168}}
169
170func New{type_name}DataSource() datasource.DataSource {{
171	return &{type_name}DataSource{{}}
172}}
173
174"
175    )
176}
177
178fn render_ds_model(type_name: &str, attrs: &[TfAttribute]) -> String {
179    let struct_name = format!("{type_name}DataSourceModel");
180    let mut out = String::new();
181    let _ = writeln!(out, "type {struct_name} struct {{");
182    let fields: String = attrs
183        .iter()
184        .map(|a| format!("\t{} {} `tfsdk:\"{}\"`\n", a.go_name, a.tf_value_type, a.tf_name))
185        .collect();
186    out.push_str(&fields);
187    out.push_str("}\n");
188    out
189}
190
191fn render_ds_metadata(ds_name: &str) -> String {
192    let suffix = ds_name.strip_prefix("akeyless_").unwrap_or(ds_name);
193    let type_name = to_type_name(ds_name);
194    format!(
195        r#"func (d *{type_name}DataSource) Metadata(ctx context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {{
196	resp.TypeName = req.ProviderTypeName + "_{suffix}"
197}}
198
199"#,
200    )
201}
202
203fn render_ds_schema(attrs: &[TfAttribute], description: &str) -> String {
204    let mut out = String::new();
205    out.push_str("func (d *Resource) Schema(ctx context.Context, req datasource.SchemaRequest, resp *datasource.SchemaResponse) {\n");
206    out.push_str("\tresp.Schema = schema.Schema{\n");
207    let desc = description.replace('"', "\\\"");
208    let _ = writeln!(out, "\t\tDescription: \"{desc}\",");
209    out.push_str("\t\tAttributes: map[string]schema.Attribute{\n");
210
211    let attr_code: String = attrs.iter().map(render_single_attribute).collect();
212    out.push_str(&attr_code);
213
214    out.push_str("\t\t},\n");
215    out.push_str("\t}\n");
216    out.push_str("}\n");
217    out
218}
219
220fn render_ds_configure(type_name: &str) -> String {
221    format!(
222        r#"func (d *{type_name}DataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {{
223	if req.ProviderData == nil {{
224		return
225	}}
226
227	client, ok := req.ProviderData.(*AkeylessClient)
228	if !ok {{
229		resp.Diagnostics.AddError(
230			"Unexpected DataSource Configure Type",
231			fmt.Sprintf("Expected *AkeylessClient, got: %T", req.ProviderData),
232		)
233		return
234	}}
235
236	d.client = client
237}}
238
239"#
240    )
241}
242
243fn render_ds_read(
244    type_name: &str,
245    endpoint: &str,
246    attrs: &[TfAttribute],
247    read_mapping: &std::collections::BTreeMap<String, String>,
248) -> String {
249    let field_reads = render_read_mapping_code(attrs, read_mapping);
250
251    // Find a suitable id field: prefer "name", otherwise first Optional string field
252    let id_field = attrs.iter().find(|a| a.tf_name == "name").or_else(|| {
253        attrs
254            .iter()
255            .find(|a| a.optional && a.tf_value_type == "types.String")
256    });
257
258    let id_setup = if let Some(id_attr) = id_field {
259        let go_name = &id_attr.go_name;
260        format!(
261            r#"	body := akeyless_api.NewReadBody("{endpoint}")
262	id := state.{go_name}.ValueString()
263	body.Set{go_name}(&id)
264"#
265        )
266    } else {
267        format!("\tbody := akeyless_api.NewReadBody(\"{endpoint}\")\n")
268    };
269
270    format!(
271        r#"func (d *{type_name}DataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {{
272	var state {type_name}DataSourceModel
273	diags := req.Config.Get(ctx, &state)
274	resp.Diagnostics.Append(diags...)
275	if resp.Diagnostics.HasError() {{
276		return
277	}}
278
279{id_setup}
280	tflog.Debug(ctx, "Reading {type_name} data source")
281
282	result, err := d.client.Call(ctx, body)
283	if err != nil {{
284		resp.Diagnostics.AddError("Error reading {type_name}", err.Error())
285		return
286	}}
287
288{field_reads}
289	diags = resp.State.Set(ctx, &state)
290	resp.Diagnostics.Append(diags...)
291}}
292"#
293    )
294}
295
296#[cfg(test)]
297mod tests {
298    use super::*;
299    use crate::spec::DataSourceSpec;
300
301    fn make_ds_test_data() -> (DataSourceSpec, Spec, ProviderDefaults) {
302        let toml_str = r#"
303[data_source]
304name = "akeyless_auth_method"
305description = "Read an auth method"
306
307[read]
308endpoint = "/get-auth-method"
309schema = "GetAuthMethod"
310
311[fields]
312token = { skip = true }
313
314[read_mapping]
315"auth_method_access_id" = "access_id"
316"#;
317        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
318
319        let api_str = r#"
320openapi: "3.0.0"
321info: { title: Test, version: "1.0" }
322paths:
323  /get-auth-method:
324    post:
325      operationId: getAuthMethod
326      requestBody:
327        content:
328          application/json:
329            schema:
330              $ref: '#/components/schemas/GetAuthMethod'
331      responses:
332        "200": { description: ok }
333components:
334  schemas:
335    GetAuthMethod:
336      type: object
337      required: [name]
338      properties:
339        name: { type: string, description: "Auth method name" }
340        access_id: { type: string, description: "Access ID" }
341        token: { type: string }
342"#;
343        let api = Spec::parse(api_str).expect("parse");
344        (ds, api, ProviderDefaults::default())
345    }
346
347    #[test]
348    fn generate_datasource_attributes_test() {
349        let (ds, api, defaults) = make_ds_test_data();
350        let attrs = generate_datasource_attributes(&ds, &api, &defaults).expect("gen");
351
352        // token should be skipped
353        assert!(attrs.iter().all(|a| a.tf_name != "token"));
354
355        // name should be Optional (data sources don't have Required)
356        let name_attr = attrs.iter().find(|a| a.tf_name == "name").expect("name");
357        assert!(!name_attr.required);
358        assert!(name_attr.optional);
359
360        // access_id should exist
361        let access = attrs
362            .iter()
363            .find(|a| a.tf_name == "access_id")
364            .expect("access_id");
365        assert!(access.computed);
366    }
367
368    #[test]
369    fn generate_full_datasource() {
370        let (ds, api, defaults) = make_ds_test_data();
371        let result = generate_datasource(
372            &ds,
373            &api,
374            &defaults,
375            "github.com/akeylesslabs/akeyless-go/v5",
376        )
377        .expect("gen");
378
379        assert_eq!(result.file_name, "datasource_akeyless_auth_method.go");
380        assert!(result.go_code.contains("AuthMethodDataSource"));
381        assert!(
382            result
383                .go_code
384                .contains("func (d *AuthMethodDataSource) Read")
385        );
386        assert!(
387            result
388                .go_code
389                .contains("func (d *AuthMethodDataSource) Configure")
390        );
391        assert!(result.go_code.contains("AuthMethodDataSourceModel"));
392    }
393
394    #[test]
395    fn datasource_read_mapping_generates_code() {
396        let (ds, api, defaults) = make_ds_test_data();
397        let result = generate_datasource(
398            &ds,
399            &api,
400            &defaults,
401            "github.com/akeylesslabs/akeyless-go/v5",
402        )
403        .expect("gen");
404
405        // Should have GetNestedString call for the mapped field
406        assert!(
407            result
408                .go_code
409                .contains("GetNestedString(result, \"auth_method_access_id\")")
410        );
411        assert!(
412            result
413                .go_code
414                .contains("state.AccessId = types.StringValue(v)")
415        );
416    }
417
418    // --- Computed-only field (not Optional) ---
419
420    #[test]
421    fn datasource_computed_only_field_not_optional() {
422        let toml_str = r#"
423[data_source]
424name = "akeyless_ds"
425description = "DS"
426
427[read]
428endpoint = "/get"
429schema = "GetDS"
430
431[fields]
432auto_field = { computed = true }
433"#;
434        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
435        let api_str = r#"
436openapi: "3.0.0"
437info: { title: T, version: "1" }
438paths:
439  /get:
440    post:
441      operationId: get
442      requestBody:
443        content:
444          application/json:
445            schema:
446              $ref: '#/components/schemas/GetDS'
447      responses:
448        "200": { description: ok }
449components:
450  schemas:
451    GetDS:
452      type: object
453      required: [name, auto_field]
454      properties:
455        name: { type: string }
456        auto_field: { type: string }
457"#;
458        let api = Spec::parse(api_str).expect("parse");
459        let attrs =
460            generate_datasource_attributes(&ds, &api, &ProviderDefaults::default()).expect("gen");
461
462        let auto = attrs
463            .iter()
464            .find(|a| a.tf_name == "auto_field")
465            .expect("auto_field");
466        assert!(!auto.required, "computed ds field should not be required");
467        assert!(!auto.optional, "computed-only ds field should not be optional");
468        assert!(auto.computed, "computed field should be computed");
469    }
470
471    // --- Sensitive data source field ---
472
473    #[test]
474    fn datasource_sensitive_field() {
475        let toml_str = r#"
476[data_source]
477name = "akeyless_ds"
478description = "DS"
479
480[read]
481endpoint = "/get"
482schema = "GetDS"
483
484[fields]
485secret = { sensitive = true }
486"#;
487        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
488        let api_str = r#"
489openapi: "3.0.0"
490info: { title: T, version: "1" }
491paths:
492  /get:
493    post:
494      operationId: get
495      requestBody:
496        content:
497          application/json:
498            schema:
499              $ref: '#/components/schemas/GetDS'
500      responses:
501        "200": { description: ok }
502components:
503  schemas:
504    GetDS:
505      type: object
506      properties:
507        secret: { type: string }
508"#;
509        let api = Spec::parse(api_str).expect("parse");
510        let attrs =
511            generate_datasource_attributes(&ds, &api, &ProviderDefaults::default()).expect("gen");
512        let secret = attrs
513            .iter()
514            .find(|a| a.tf_name == "secret")
515            .expect("secret");
516        assert!(secret.sensitive);
517    }
518
519    // --- Data source schema rendering ---
520
521    #[test]
522    fn datasource_schema_includes_description() {
523        let (ds, api, defaults) = make_ds_test_data();
524        let result = generate_datasource(
525            &ds,
526            &api,
527            &defaults,
528            "github.com/test/sdk",
529        )
530        .expect("gen");
531        assert!(result.go_code.contains("Description: \"Read an auth method\""));
532    }
533
534    // --- Data source without name field: no id setup ---
535
536    #[test]
537    fn datasource_no_name_field_still_generates() {
538        let toml_str = r#"
539[data_source]
540name = "akeyless_no_name"
541description = "No name field"
542
543[read]
544endpoint = "/get-thing"
545schema = "GetThing"
546"#;
547        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
548        let api_str = r#"
549openapi: "3.0.0"
550info: { title: T, version: "1" }
551paths:
552  /get-thing:
553    post:
554      operationId: getThing
555      requestBody:
556        content:
557          application/json:
558            schema:
559              $ref: '#/components/schemas/GetThing'
560      responses:
561        "200": { description: ok }
562components:
563  schemas:
564    GetThing:
565      type: object
566      properties:
567        count: { type: integer }
568        enabled: { type: boolean }
569"#;
570        let api = Spec::parse(api_str).expect("parse");
571        let result = generate_datasource(
572            &ds,
573            &api,
574            &ProviderDefaults::default(),
575            "github.com/test/sdk",
576        )
577        .expect("gen");
578        assert!(result.go_code.contains("NoNameDataSource"));
579        assert!(!result.go_code.contains("body.SetName"), "No name field means no id setup");
580    }
581
582    // --- Data source without akeyless_ prefix ---
583
584    #[test]
585    fn datasource_no_prefix() {
586        let toml_str = r#"
587[data_source]
588name = "custom_data"
589description = "Custom"
590
591[read]
592endpoint = "/get-auth-method"
593schema = "GetAuthMethod"
594"#;
595        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
596        let (_, api, defaults) = make_ds_test_data();
597        let result = generate_datasource(&ds, &api, &defaults, "github.com/test/sdk")
598            .expect("gen");
599        assert!(result.go_code.contains("CustomDataDataSource"));
600        assert_eq!(result.file_name, "datasource_custom_data.go");
601    }
602
603    // --- Global skip in data source ---
604
605    #[test]
606    fn datasource_global_skip_fields() {
607        let (ds, api, _) = make_ds_test_data();
608        let defaults = ProviderDefaults {
609            skip_fields: vec!["access_id".to_string()],
610        };
611        let attrs = generate_datasource_attributes(&ds, &api, &defaults).expect("gen");
612        assert!(
613            attrs.iter().all(|a| a.tf_name != "access_id"),
614            "access_id should be skipped via global defaults"
615        );
616    }
617
618    // --- Data source schema attribute rendering: sensitive ---
619
620    #[test]
621    fn datasource_schema_sensitive_attribute() {
622        let toml_str = r#"
623[data_source]
624name = "akeyless_sens"
625description = "Sensitive test"
626
627[read]
628endpoint = "/get-auth-method"
629schema = "GetAuthMethod"
630
631[fields]
632access_id = { sensitive = true }
633"#;
634        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
635        let (_, api, defaults) = make_ds_test_data();
636        let result = generate_datasource(&ds, &api, &defaults, "github.com/test/sdk")
637            .expect("gen");
638        assert!(result.go_code.contains("Sensitive: true"));
639    }
640
641    // --- Data source type_override ---
642
643    #[test]
644    fn datasource_type_override() {
645        let toml_str = r#"
646[data_source]
647name = "akeyless_override"
648description = "Override"
649
650[read]
651endpoint = "/get-auth-method"
652schema = "GetAuthMethod"
653
654[fields]
655access_id = { type_override = "bool" }
656"#;
657        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
658        let (_, api, defaults) = make_ds_test_data();
659        let attrs = generate_datasource_attributes(&ds, &api, &defaults).expect("gen");
660        let access = attrs
661            .iter()
662            .find(|a| a.tf_name == "access_id")
663            .expect("access_id");
664        assert_eq!(access.go_type, "bool");
665    }
666
667    // --- Data source Read with first optional string field as ID ---
668
669    #[test]
670    fn datasource_read_uses_first_optional_string_when_no_name() {
671        let toml_str = r#"
672[data_source]
673name = "akeyless_alt_id"
674description = "Alt ID"
675
676[read]
677endpoint = "/get-alt"
678schema = "GetAlt"
679"#;
680        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
681        let api_str = r#"
682openapi: "3.0.0"
683info: { title: T, version: "1" }
684paths:
685  /get-alt:
686    post:
687      operationId: getAlt
688      requestBody:
689        content:
690          application/json:
691            schema:
692              $ref: '#/components/schemas/GetAlt'
693      responses:
694        "200": { description: ok }
695components:
696  schemas:
697    GetAlt:
698      type: object
699      properties:
700        path: { type: string, description: "Path" }
701        count: { type: integer }
702"#;
703        let api = Spec::parse(api_str).expect("parse");
704        let result = generate_datasource(
705            &ds,
706            &api,
707            &ProviderDefaults::default(),
708            "github.com/test/sdk",
709        )
710        .expect("gen");
711        assert!(
712            result.go_code.contains("body.SetPath"),
713            "Should use first optional string field 'path' as id"
714        );
715    }
716
717    // --- Error paths ---
718
719    #[test]
720    fn generate_datasource_attributes_missing_schema_errors() {
721        let toml_str = r#"
722[data_source]
723name = "test_ds"
724description = "Test"
725
726[read]
727endpoint = "/get"
728schema = "NonExistentSchema"
729"#;
730        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
731        let api_str = r#"
732openapi: "3.0.0"
733info: { title: T, version: "1" }
734paths: {}
735components:
736  schemas: {}
737"#;
738        let api = Spec::parse(api_str).expect("parse");
739        let result = generate_datasource_attributes(&ds, &api, &ProviderDefaults::default());
740        assert!(result.is_err(), "Missing schema should error");
741    }
742
743    #[test]
744    fn generate_datasource_missing_schema_errors() {
745        let toml_str = r#"
746[data_source]
747name = "test_ds"
748description = "Test"
749
750[read]
751endpoint = "/get"
752schema = "NonExistentSchema"
753"#;
754        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
755        let api_str = r#"
756openapi: "3.0.0"
757info: { title: T, version: "1" }
758paths: {}
759components:
760  schemas: {}
761"#;
762        let api = Spec::parse(api_str).expect("parse");
763        let result = generate_datasource(&ds, &api, &ProviderDefaults::default(), "sdk");
764        assert!(result.is_err(), "Missing schema should error");
765    }
766
767    // --- Data source description override ---
768
769    #[test]
770    fn datasource_field_description_override() {
771        let toml_str = r#"
772[data_source]
773name = "akeyless_ds"
774description = "DS"
775
776[read]
777endpoint = "/get-auth-method"
778schema = "GetAuthMethod"
779
780[fields]
781name = { description = "Custom name desc" }
782"#;
783        let ds: DataSourceSpec = toml::from_str(toml_str).expect("parse");
784        let (_, api, defaults) = make_ds_test_data();
785        let attrs = generate_datasource_attributes(&ds, &api, &defaults).expect("gen");
786        let name_attr = attrs.iter().find(|a| a.tf_name == "name").expect("name");
787        assert_eq!(name_attr.description, "Custom name desc");
788    }
789}