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#[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
23pub 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 let (required, optional) = if computed {
72 (false, false) } else {
74 (false, true) };
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
96pub 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 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 assert!(attrs.iter().all(|a| a.tf_name != "token"));
354
355 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 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 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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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}