terraform-forge 0.1.6

Terraform provider code generator from OpenAPI specs
Documentation
use std::fmt::Write as _;

use crate::spec::ProviderSpec;

/// Generate the provider.go file that registers all resources and data sources.
#[must_use]
pub fn generate_provider(
    provider: &ProviderSpec,
    resource_type_names: &[String],
    _resource_tf_names: &[String],
    data_source_type_names: &[String],
) -> String {
    let name = capitalize(&provider.provider.name);
    let mut code = String::new();

    render_provider_imports(&mut code, &provider.provider.name);
    render_provider_type(&mut code, &name);
    render_provider_metadata(&mut code, &name, &provider.provider.name);
    render_provider_schema(&mut code, &name, &provider.provider.description);
    render_provider_configure(&mut code, &name, &provider.auth);
    render_provider_resources(&mut code, &name, resource_type_names);
    render_provider_data_sources(&mut code, &name, data_source_type_names);

    code
}

fn render_provider_imports(code: &mut String, provider_name: &str) {
    code.push_str("// Code generated by terraform-forge. DO NOT EDIT.\n\n");
    code.push_str("package provider\n\n");
    code.push_str("import (\n");
    code.push_str("\t\"context\"\n");
    code.push_str("\t\"os\"\n\n");
    code.push_str("\t\"github.com/hashicorp/terraform-plugin-framework/datasource\"\n");
    code.push_str("\t\"github.com/hashicorp/terraform-plugin-framework/provider\"\n");
    code.push_str("\t\"github.com/hashicorp/terraform-plugin-framework/provider/schema\"\n");
    code.push_str("\t\"github.com/hashicorp/terraform-plugin-framework/resource\"\n");
    code.push_str("\t\"github.com/hashicorp/terraform-plugin-framework/types\"\n\n");
    let _ = writeln!(
        code,
        "\t\"terraform-provider-{provider_name}-gen/internal/resources\""
    );
    code.push_str(")\n\n");
}

fn render_provider_type(code: &mut String, name: &str) {
    let _ = write!(
        code,
        r#"var _ provider.Provider = &{name}Provider{{}}

type {name}Provider struct {{
	version string
}}

type {name}ProviderModel struct {{
	ApiGatewayAddress types.String `tfsdk:"api_gateway_address"`
	AccessToken       types.String `tfsdk:"access_token"`
}}

func New(version string) func() provider.Provider {{
	return func() provider.Provider {{
		return &{name}Provider{{
			version: version,
		}}
	}}
}}

"#,
    );
}

fn render_provider_metadata(code: &mut String, pascal_name: &str, raw_name: &str) {
    let _ = write!(
        code,
        r#"func (p *{pascal_name}Provider) Metadata(ctx context.Context, req provider.MetadataRequest, resp *provider.MetadataResponse) {{
	resp.TypeName = "{raw_name}"
	resp.Version = p.version
}}

"#,
    );
}

fn render_provider_schema(code: &mut String, name: &str, description: &str) {
    let desc = description.replace('"', "\\\"");
    let _ = write!(
        code,
        r#"func (p *{name}Provider) Schema(ctx context.Context, req provider.SchemaRequest, resp *provider.SchemaResponse) {{
	resp.Schema = schema.Schema{{
		Description: "{desc}",
		Attributes: map[string]schema.Attribute{{
			"api_gateway_address": schema.StringAttribute{{
				Description: "Akeyless API gateway URL",
				Optional:    true,
			}},
			"access_token": schema.StringAttribute{{
				Description: "Akeyless access token",
				Optional:    true,
				Sensitive:   true,
			}},
		}},
	}}
}}

"#,
    );
}

fn render_provider_configure(
    code: &mut String,
    name: &str,
    auth: &crate::spec::AuthConfig,
) {
    let _ = write!(
        code,
        r#"func (p *{name}Provider) Configure(ctx context.Context, req provider.ConfigureRequest, resp *provider.ConfigureResponse) {{
	var config {name}ProviderModel
	diags := req.Config.Get(ctx, &config)
	resp.Diagnostics.Append(diags...)
	if resp.Diagnostics.HasError() {{
		return
	}}

	gatewayURL := config.ApiGatewayAddress.ValueString()
	if gatewayURL == "" {{
		gatewayURL = os.Getenv("{gw_env}")
	}}
	if gatewayURL == "" {{
		gatewayURL = "https://api.akeyless.io"
	}}

	token := config.AccessToken.ValueString()
	if token == "" {{
		token = os.Getenv("{token_env}")
	}}

	client := resources.NewAkeylessClient(gatewayURL, token)
	resp.DataSourceData = client
	resp.ResourceData = client
}}

"#,
        gw_env = auth.gateway_env_var,
        token_env = auth.env_var,
    );
}

fn render_provider_resources(code: &mut String, name: &str, resource_type_names: &[String]) {
    let _ = writeln!(
        code,
        "func (p *{name}Provider) Resources(ctx context.Context) []func() resource.Resource {{"
    );
    code.push_str("\treturn []func() resource.Resource{\n");
    for type_name in resource_type_names {
        let _ = writeln!(code, "\t\tresources.New{type_name}Resource,");
    }
    code.push_str("\t}\n");
    code.push_str("}\n\n");
}

fn render_provider_data_sources(
    code: &mut String,
    name: &str,
    data_source_type_names: &[String],
) {
    let _ = writeln!(
        code,
        "func (p *{name}Provider) DataSources(ctx context.Context) []func() datasource.DataSource {{"
    );
    if data_source_type_names.is_empty() {
        code.push_str("\treturn []func() datasource.DataSource{}\n");
    } else {
        code.push_str("\treturn []func() datasource.DataSource{\n");
        for type_name in data_source_type_names {
            let _ = writeln!(code, "\t\tresources.New{type_name}DataSource,");
        }
        code.push_str("\t}\n");
    }
    code.push_str("}\n");
}

fn capitalize(s: &str) -> String {
    let mut chars = s.chars();
    match chars.next() {
        Some(c) => {
            let upper: String = c.to_uppercase().collect();
            format!("{upper}{}", chars.as_str())
        }
        None => String::new(),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn make_provider_spec() -> ProviderSpec {
        let toml_str = r#"
[provider]
name = "akeyless"
description = "Akeyless Vault Provider"
version = "1.0.0"
sdk_import = "github.com/akeylesslabs/akeyless-go/v5"

[auth]
token_field = "token"
env_var = "AKEYLESS_ACCESS_TOKEN"
gateway_url_field = "api_gateway_address"
gateway_env_var = "AKEYLESS_GATEWAY"
"#;
        toml::from_str(toml_str).expect("parse")
    }

    #[test]
    fn generate_provider_code() {
        let provider = make_provider_spec();
        let type_names = vec!["StaticSecret".to_string()];
        let tf_names = vec!["akeyless_static_secret".to_string()];

        let ds_type_names: Vec<String> = vec![];
        let code = generate_provider(&provider, &type_names, &tf_names, &ds_type_names);
        assert!(code.contains("AkeylessProvider"));
        assert!(code.contains("resources.NewStaticSecretResource"));
        assert!(code.contains("api_gateway_address"));
    }

    #[test]
    fn generate_provider_with_data_sources() {
        let provider = make_provider_spec();
        let type_names = vec!["StaticSecret".to_string()];
        let tf_names = vec!["akeyless_static_secret".to_string()];
        let ds_type_names = vec!["AuthMethod".to_string()];

        let code = generate_provider(&provider, &type_names, &tf_names, &ds_type_names);
        assert!(code.contains("resources.NewAuthMethodDataSource"));
        assert!(code.contains("resources.NewStaticSecretResource"));
    }

    // --- Empty resources list ---

    #[test]
    fn generate_provider_empty_resources() {
        let provider = make_provider_spec();
        let code = generate_provider(&provider, &[], &[], &[]);
        assert!(code.contains("AkeylessProvider"));
        assert!(code.contains("return []func() resource.Resource{"));
        assert!(code.contains("return []func() datasource.DataSource{}"));
    }

    // --- Multiple resources ---

    #[test]
    fn generate_provider_multiple_resources() {
        let provider = make_provider_spec();
        let type_names = vec![
            "StaticSecret".to_string(),
            "DynamicSecret".to_string(),
            "AuthMethod".to_string(),
        ];
        let tf_names = vec![
            "akeyless_static_secret".to_string(),
            "akeyless_dynamic_secret".to_string(),
            "akeyless_auth_method".to_string(),
        ];
        let code = generate_provider(&provider, &type_names, &tf_names, &[]);
        assert!(code.contains("resources.NewStaticSecretResource"));
        assert!(code.contains("resources.NewDynamicSecretResource"));
        assert!(code.contains("resources.NewAuthMethodResource"));
    }

    // --- Description escaping ---

    #[test]
    fn generate_provider_description_escapes_quotes() {
        let toml_str = r#"
[provider]
name = "test"
description = 'Provider with "quotes" inside'
version = "1"
sdk_import = "sdk"

[auth]
token_field = "t"
env_var = "E"
gateway_url_field = "g"
gateway_env_var = "G"
"#;
        let provider: ProviderSpec = toml::from_str(toml_str).expect("parse");
        let code = generate_provider(&provider, &[], &[], &[]);
        assert!(
            code.contains(r#"Provider with \"quotes\" inside"#),
            "Quotes in description should be escaped"
        );
    }

    // --- capitalize helper ---

    #[test]
    fn capitalize_normal() {
        assert_eq!(capitalize("akeyless"), "Akeyless");
    }

    #[test]
    fn capitalize_single_char() {
        assert_eq!(capitalize("a"), "A");
    }

    #[test]
    fn capitalize_empty() {
        assert_eq!(capitalize(""), "");
    }

    #[test]
    fn capitalize_already_upper() {
        assert_eq!(capitalize("Akeyless"), "Akeyless");
    }

    // --- Provider code structure ---

    #[test]
    fn generate_provider_has_package_declaration() {
        let provider = make_provider_spec();
        let code = generate_provider(&provider, &[], &[], &[]);
        assert!(code.contains("package provider"));
    }

    #[test]
    fn generate_provider_has_configure_with_env_vars() {
        let provider = make_provider_spec();
        let code = generate_provider(&provider, &[], &[], &[]);
        assert!(code.contains("AKEYLESS_ACCESS_TOKEN"));
        assert!(code.contains("AKEYLESS_GATEWAY"));
        assert!(code.contains("os.Getenv"));
    }

    #[test]
    fn generate_provider_has_default_gateway() {
        let provider = make_provider_spec();
        let code = generate_provider(&provider, &[], &[], &[]);
        assert!(code.contains("https://api.akeyless.io"));
    }

    #[test]
    fn generate_provider_has_metadata() {
        let provider = make_provider_spec();
        let code = generate_provider(&provider, &[], &[], &[]);
        assert!(code.contains("resp.TypeName = \"akeyless\""));
        assert!(code.contains("resp.Version = p.version"));
    }

    #[test]
    fn generate_provider_internal_import_path() {
        let provider = make_provider_spec();
        let code = generate_provider(&provider, &[], &[], &[]);
        assert!(code.contains("terraform-provider-akeyless-gen/internal/resources"));
    }

    #[test]
    fn generate_provider_new_factory() {
        let provider = make_provider_spec();
        let code = generate_provider(&provider, &[], &[], &[]);
        assert!(code.contains("func New(version string) func() provider.Provider"));
    }
}