use std::fmt::Write as _;
use crate::spec::ProviderSpec;
#[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"));
}
#[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{}"));
}
#[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"));
}
#[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"
);
}
#[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");
}
#[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"));
}
}