tfts 0.2.13 → 0.3.1

package/dist/codegen/fetch-schema.spec.js

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parseProviderVersionFromLockFile } from "./fetch-schema.js";
+describe("parseProviderVersionFromLockFile", () => {
+    const testDir = join(tmpdir(), `tfts-test-lock-${Date.now()}`);
+    const lockFilePath = join(testDir, ".terraform.lock.hcl");
+    test("extracts version from single provider lock file", () => {
+        mkdirSync(testDir, { recursive: true });
+        writeFileSync(lockFilePath, `provider "registry.terraform.io/hashicorp/google" {
+  version = "6.49.2"
+  hashes = [
+    "h1:abc123",
+  ]
+}
+`);
+        const version = parseProviderVersionFromLockFile(lockFilePath, "registry.terraform.io/hashicorp/google");
+        expect(version).toBe("6.49.2");
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    test("extracts version from multi-provider lock file", () => {
+        mkdirSync(testDir, { recursive: true });
+        writeFileSync(lockFilePath, `provider "registry.terraform.io/hashicorp/aws" {
+  version = "5.0.0"
+  hashes = [
+    "h1:def456",
+  ]
+}
+
+provider "registry.terraform.io/hashicorp/google" {
+  version = "7.16.0"
+  hashes = [
+    "h1:abc123",
+  ]
+}
+`);
+        const version = parseProviderVersionFromLockFile(lockFilePath, "registry.terraform.io/hashicorp/google");
+        expect(version).toBe("7.16.0");
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    test("returns undefined for non-existent provider", () => {
+        mkdirSync(testDir, { recursive: true });
+        writeFileSync(lockFilePath, `provider "registry.terraform.io/hashicorp/aws" {
+  version = "5.0.0"
+}
+`);
+        const version = parseProviderVersionFromLockFile(lockFilePath, "registry.terraform.io/hashicorp/google");
+        expect(version).toBeUndefined();
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    test("handles provider name with special regex characters", () => {
+        mkdirSync(testDir, { recursive: true });
+        writeFileSync(lockFilePath, `provider "registry.terraform.io/some-org/some.provider" {
+  version = "1.2.3"
+}
+`);
+        const version = parseProviderVersionFromLockFile(lockFilePath, "registry.terraform.io/some-org/some.provider");
+        expect(version).toBe("1.2.3");
+        rmSync(testDir, { recursive: true, force: true });
+    });
+});
+//# sourceMappingURL=fetch-schema.spec.js.map

package/dist/codegen/fetch-schema.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-schema.spec.js","sourceRoot":"","sources":["../../src/codegen/fetch-schema.spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAErE,QAAQ,CAAC,kCAAkC,EAAE,GAAG,EAAE;IAChD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,EAAE,kBAAkB,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC/D,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC;IAE1D,IAAI,CAAC,iDAAiD,EAAE,GAAG,EAAE;QAC3D,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACxC,aAAa,CACX,YAAY,EACZ;;;;;;CAML,CACI,CAAC;QAEF,MAAM,OAAO,GAAG,gCAAgC,CAC9C,YAAY,EACZ,wCAAwC,CACzC,CAAC;QAEF,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,gDAAgD,EAAE,GAAG,EAAE;QAC1D,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACxC,aAAa,CACX,YAAY,EACZ;;;;;;;;;;;;;CAaL,CACI,CAAC;QAEF,MAAM,OAAO,GAAG,gCAAgC,CAC9C,YAAY,EACZ,wCAAwC,CACzC,CAAC;QAEF,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACvD,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACxC,aAAa,CACX,YAAY,EACZ;;;CAGL,CACI,CAAC;QAEF,MAAM,OAAO,GAAG,gCAAgC,CAC9C,YAAY,EACZ,wCAAwC,CACzC,CAAC;QAEF,MAAM,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,CAAC;QAChC,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,qDAAqD,EAAE,GAAG,EAAE;QAC/D,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACxC,aAAa,CACX,YAAY,EACZ;;;CAGL,CACI,CAAC;QAEF,MAAM,OAAO,GAAG,gCAAgC,CAC9C,YAAY,EACZ,8CAA8C,CAC/C,CAAC;QAEF,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9B,MAAM,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/codegen/generator.d.ts

@@ -0,0 +1,8 @@
+import { type Result } from "neverthrow";
+import type { ProviderConstraint, TerraformSchema } from "./schema.js";
+export type GeneratedFile = {
+    path: string;
+    content: string;
+};
+export declare function generateProviderBindings(constraint: ProviderConstraint, schema: TerraformSchema): Result<GeneratedFile[], Error>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/codegen/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/codegen/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAGV,kBAAkB,EAGlB,eAAe,EAChB,MAAM,aAAa,CAAC;AAqDrB,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,eAAe,GACtB,MAAM,CAAC,aAAa,EAAE,EAAE,KAAK,CAAC,CA2BhC"}

package/dist/codegen/generator.js

@@ -0,0 +1,582 @@
+import { err, ok } from "neverthrow";
+import { attributeTypeToTS, generateBlockInterface, safeCamelName, toPascalCase, } from "./type-mapper.js";
+function isBlockTypeArray(blockType) {
+    const isListOrSet = blockType.nesting_mode === "list" || blockType.nesting_mode === "set";
+    return isListOrSet && blockType.max_items !== 1;
+}
+function isComputedListOfObjects(attr) {
+    if (attr.computed !== true)
+        return false;
+    if (attr.required === true || attr.optional === true)
+        return false;
+    if (attr.type === undefined)
+        return false;
+    if (!Array.isArray(attr.type))
+        return false;
+    if (attr.type[0] !== "list")
+        return false;
+    const inner = attr.type[1];
+    if (!Array.isArray(inner))
+        return false;
+    if (inner[0] !== "object")
+        return false;
+    return true;
+}
+function extractObjectFieldsFromListType(type) {
+    if (type === undefined)
+        return undefined;
+    if (!Array.isArray(type))
+        return undefined;
+    if (type[0] !== "list")
+        return undefined;
+    const inner = type[1];
+    if (!Array.isArray(inner))
+        return undefined;
+    if (inner[0] !== "object")
+        return undefined;
+    return inner[1];
+}
+export function generateProviderBindings(constraint, schema) {
+    const providerFqn = `registry.terraform.io/${constraint.fqn}`;
+    const providerSchema = schema.provider_schemas?.[providerFqn];
+    if (providerSchema === undefined) {
+        const available = Object.keys(schema.provider_schemas ?? {});
+        return err(new Error(`Provider schema not found for ${providerFqn}. Available: ${available.join(", ")}`));
+    }
+    const resourceFiles = Object.entries(providerSchema.resource_schemas ?? {}).map(([resourceType, resourceSchema]) => generateResourceClass(constraint, resourceType, resourceSchema, false));
+    const dataSourceFiles = Object.entries(providerSchema.data_source_schemas ?? {}).map(([dataType, dataSchema]) => generateResourceClass(constraint, dataType, dataSchema, true));
+    return ok([
+        generateProviderClass(constraint, providerSchema),
+        ...resourceFiles,
+        ...dataSourceFiles,
+        generateIndexFile(constraint, providerSchema),
+        generatePackageJson(constraint),
+    ]);
+}
+function generateProviderClass(constraint, schema) {
+    const className = `${toPascalCase(constraint.name)}Provider`;
+    const configName = `${className}Config`;
+    const configProps = generateConfigProperties(schema.provider?.block);
+    const { privateFields, assignments, synthesizeBody } = generateProviderConfigStorage(schema.provider?.block);
+    const hasVersion = constraint.version !== undefined &&
+        constraint.version !== "latest" &&
+        constraint.version !== "";
+    const versionLine = hasVersion ? `\n        providerVersion: "${constraint.version}",` : "";
+    const content = `import { TerraformProvider } from "tfts";
+import type { Construct } from "tfts";
+
+export type ${configName} = {
+  readonly alias?: string;
+${configProps}
+};
+
+export class ${className} extends TerraformProvider {
+  static readonly tfResourceType = "${constraint.name}";
+
+${privateFields}
+
+  constructor(scope: Construct, id: string, config: ${configName} = {}) {
+    super(scope, id, {
+      terraformResourceType: "${constraint.name}",
+      terraformGeneratorMetadata: {
+        providerName: "${constraint.name}",${versionLine}
+      },
+      terraformProviderSource: "${constraint.fqn}",
+      alias: config.alias,
+    });
+${assignments}
+  }
+
+  protected override synthesizeAttributes(): Record<string, unknown> {
+    return {
+${synthesizeBody}
+    };
+  }
+}
+`;
+    return {
+        path: `providers/${constraint.namespace}/${constraint.name}/lib/provider/index.ts`,
+        content,
+    };
+}
+function generateResourceClass(constraint, resourceType, schema, isDataSource) {
+    const shortName = resourceType.replace(`${constraint.name}_`, "");
+    const className = isDataSource ? toPascalCase(resourceType) : toPascalCase(shortName);
+    const prefix = isDataSource ? "Data" : "";
+    const fullClassName = `${prefix}${className}`;
+    const configName = `${fullClassName}Config`;
+    const configProps = generateConfigProperties(schema.block);
+    const nestedInterfaces = generateNestedInterfaces(schema.block);
+    const toTerraformFunctions = generateToTerraformFunctions(schema.block);
+    const complexClasses = generateComplexClasses(schema.block, className);
+    const hasComplexClasses = complexClasses.length > 0;
+    const baseClass = isDataSource ? "TerraformDataSource" : "TerraformResource";
+    const baseImport = isDataSource ? "TerraformDataSource" : "TerraformResource";
+    const complexImports = hasComplexClasses ? ", ComplexList, ComplexObject" : "";
+    const { privateFields, assignments, synthesizeBody, configGetters } = generateConfigStorage(schema.block, className);
+    const computedGetters = generateComputedGetters(schema.block);
+    const computedBlockGetters = generateComputedBlockGetters(schema.block, className);
+    const complexTypeImports = hasComplexClasses ? ", IInterpolatingParent" : "";
+    const metaArgsImport = isDataSource
+        ? "TerraformDataSourceMetaArguments"
+        : "TerraformMetaArguments";
+    const content = `import { ${baseImport}${complexImports} } from "tfts";
+import type { Construct${complexTypeImports}, ${metaArgsImport} } from "tfts";
+
+${nestedInterfaces}
+
+${toTerraformFunctions}
+
+${complexClasses}
+
+export type ${configName} = ${metaArgsImport} & {
+${configProps}
+};
+
+export class ${fullClassName} extends ${baseClass} {
+  static readonly tfResourceType = "${resourceType}";
+
+${privateFields}
+
+  constructor(scope: Construct, id: string, config: ${configName}) {
+    super(scope, id, {
+      terraformResourceType: "${resourceType}",
+      terraformGeneratorMetadata: {
+        providerName: "${constraint.name}",
+      },
+      dependsOn: config.dependsOn,
+      count: config.count,
+      provider: config.provider,${isDataSource ? "" : "\n      lifecycle: config.lifecycle,"}
+      forEach: config.forEach,
+    });
+${assignments}
+  }
+
+${configGetters}
+
+${computedGetters}
+
+${computedBlockGetters}
+
+  protected override synthesizeAttributes(): Record<string, unknown> {
+    return {
+${synthesizeBody}
+    };
+  }
+}
+`;
+    const kebabName = shortName.replace(/_/g, "-");
+    const pathPrefix = isDataSource ? `data-${constraint.name}-` : "";
+    return {
+        path: `providers/${constraint.namespace}/${constraint.name}/lib/${pathPrefix}${kebabName}/index.ts`,
+        content,
+    };
+}
+function generateComplexClasses(block, resourceClassName) {
+    const classes = [];
+    if (block.attributes !== undefined) {
+        for (const [name, attr] of Object.entries(block.attributes)) {
+            if (!isComputedListOfObjects(attr))
+                continue;
+            const blockClassName = toPascalCase(name);
+            const outputRefName = `${resourceClassName}${blockClassName}OutputReference`;
+            const listName = `${resourceClassName}${blockClassName}List`;
+            const fields = extractObjectFieldsFromListType(attr.type);
+            if (fields === undefined)
+                continue;
+            const getters = generateOutputReferenceGettersFromFields(fields);
+            classes.push(`export class ${outputRefName} extends ComplexObject {
+  constructor(terraformResource: IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean) {
+    super(terraformResource, terraformAttribute, complexObjectIsFromSet, complexObjectIndex);
+  }
+
+${getters}
+}
+
+export class ${listName} extends ComplexList {
+  get(index: number): ${outputRefName} {
+    return new ${outputRefName}(this.terraformResource, this.terraformAttribute, index, this.wrapsSet);
+  }
+}`);
+        }
+    }
+    if (block.block_types !== undefined) {
+        for (const [name, blockType] of Object.entries(block.block_types)) {
+            const blockClassName = toPascalCase(name);
+            const outputRefName = `${resourceClassName}${blockClassName}OutputReference`;
+            const listName = `${resourceClassName}${blockClassName}List`;
+            const isArray = isBlockTypeArray(blockType);
+            const getters = generateOutputReferenceGetters(blockType.block);
+            classes.push(`export class ${outputRefName} extends ComplexObject {
+  constructor(terraformResource: IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean) {
+    super(terraformResource, terraformAttribute, complexObjectIsFromSet, complexObjectIndex);
+  }
+
+${getters}
+}`);
+            if (isArray) {
+                classes.push(`export class ${listName} extends ComplexList {
+  get(index: number): ${outputRefName} {
+    return new ${outputRefName}(this.terraformResource, this.terraformAttribute, index, this.wrapsSet);
+  }
+}`);
+            }
+        }
+    }
+    return classes.join("\n\n");
+}
+function generateOutputReferenceGettersFromFields(fields) {
+    return Object.entries(fields)
+        .flatMap(([name, fieldType]) => {
+        const camelName = toCamelCase(name.replace(/_/g, "-"));
+        const tsType = attributeTypeToTS(fieldType);
+        const getter = generateComplexObjectGetter(name, camelName, tsType);
+        return getter !== undefined ? [getter] : [];
+    })
+        .join("\n\n");
+}
+function generateOutputReferenceGetters(block) {
+    return Object.entries(block.attributes ?? {})
+        .flatMap(([name, attr]) => {
+        const camelName = toCamelCase(name.replace(/_/g, "-"));
+        const tsType = attributeTypeToTS(attr.type);
+        const getter = generateComplexObjectGetter(name, camelName, tsType);
+        return getter !== undefined ? [getter] : [];
+    })
+        .join("\n\n");
+}
+function generateComplexObjectGetter(attrName, safePropName, tsType) {
+    const stringTypes = new Set(["string", "string | undefined"]);
+    const numberTypes = new Set(["number", "number | undefined"]);
+    const booleanTypes = new Set(["boolean", "boolean | undefined"]);
+    if (stringTypes.has(tsType)) {
+        return `  get ${safePropName}(): string {
+    return this.getStringAttribute("${attrName}");
+  }`;
+    }
+    if (numberTypes.has(tsType)) {
+        return `  get ${safePropName}(): number {
+    return this.getNumberAttribute("${attrName}");
+  }`;
+    }
+    if (booleanTypes.has(tsType)) {
+        return `  get ${safePropName}(): boolean {
+    return this.getBooleanAttribute("${attrName}");
+  }`;
+    }
+    return undefined;
+}
+function generateComputedBlockGetters(block, resourceClassName) {
+    const getters = [];
+    if (block.attributes !== undefined) {
+        for (const [name, attr] of Object.entries(block.attributes)) {
+            if (!isComputedListOfObjects(attr))
+                continue;
+            const camelName = toCamelCase(name.replace(/_/g, "-"));
+            const blockClassName = toPascalCase(name);
+            const listName = `${resourceClassName}${blockClassName}List`;
+            getters.push(`  private _${camelName}Output = new ${listName}(this, "${name}", false);
+  get ${camelName}(): ${listName} {
+    return this._${camelName}Output;
+  }`);
+        }
+    }
+    if (block.block_types !== undefined) {
+        for (const [name, blockType] of Object.entries(block.block_types)) {
+            const camelName = toCamelCase(name.replace(/_/g, "-"));
+            const blockClassName = toPascalCase(name);
+            const isArray = isBlockTypeArray(blockType);
+            if (isArray) {
+                const listName = `${resourceClassName}${blockClassName}List`;
+                getters.push(`  private _${camelName}Output = new ${listName}(this, "${name}", false);
+  get ${camelName}(): ${listName} {
+    return this._${camelName}Output;
+  }`);
+            }
+            else {
+                const outputRefName = `${resourceClassName}${blockClassName}OutputReference`;
+                getters.push(`  private _${camelName}Output = new ${outputRefName}(this, "${name}", 0, false);
+  get ${camelName}(): ${outputRefName} {
+    return this._${camelName}Output;
+  }`);
+            }
+        }
+    }
+    return getters.join("\n\n");
+}
+function generateProviderConfigStorage(block) {
+    if (block === undefined) {
+        return { privateFields: "", assignments: "", synthesizeBody: "" };
+    }
+    const fields = [];
+    const assigns = [];
+    const synth = [];
+    if (block.attributes !== undefined) {
+        for (const [name, attr] of Object.entries(block.attributes)) {
+            const tsType = attributeTypeToTS(attr.type);
+            const camelPropName = safeCamelName(name);
+            const fieldName = `_${camelPropName}`;
+            fields.push(`  private ${fieldName}?: ${tsType};`);
+            assigns.push(`    this.${fieldName} = config.${camelPropName};`);
+            synth.push(`      ${name}: this.${fieldName},`);
+        }
+    }
+    if (block.block_types !== undefined) {
+        for (const [name, blockType] of Object.entries(block.block_types)) {
+            const interfaceName = toPascalCase(name);
+            const isArray = isBlockTypeArray(blockType);
+            const camelPropName = safeCamelName(name);
+            const fieldName = `_${camelPropName}`;
+            const tsType = isArray ? `${interfaceName}[]` : interfaceName;
+            fields.push(`  private ${fieldName}?: ${tsType};`);
+            assigns.push(`    this.${fieldName} = config.${camelPropName};`);
+            synth.push(`      ${name}: this.${fieldName},`);
+        }
+    }
+    return {
+        privateFields: fields.join("\n"),
+        assignments: assigns.join("\n"),
+        synthesizeBody: synth.join("\n"),
+    };
+}
+const isConfigurableAttr = (attr) => !(attr.computed === true && attr.optional !== true && attr.required !== true);
+function generateConfigStorage(block, _resourceClassName) {
+    if (block === undefined) {
+        return { privateFields: "", assignments: "", synthesizeBody: "", configGetters: "" };
+    }
+    const attrEntries = Object.entries(block.attributes ?? {})
+        .filter(([, attr]) => isConfigurableAttr(attr) && !isComputedListOfObjects(attr))
+        .map(([name, attr]) => {
+        const tsType = attributeTypeToTS(attr.type);
+        const camelPropName = safeCamelName(name);
+        const fieldName = `_${camelPropName}`;
+        return {
+            field: `  private ${fieldName}?: ${tsType};`,
+            assign: `    this.${fieldName} = config.${camelPropName};`,
+            synth: `      ${name}: this.${fieldName},`,
+            getter: generateConfigGetter(name, camelPropName, tsType),
+        };
+    });
+    const blockEntries = Object.entries(block.block_types ?? {}).map(([name, blockType]) => {
+        const interfaceName = toPascalCase(name);
+        const isArray = isBlockTypeArray(blockType);
+        const camelPropName = safeCamelName(name);
+        const fieldName = `_${camelPropName}`;
+        const tsType = isArray ? `${interfaceName}[]` : interfaceName;
+        const toTerraformFunc = `${camelPropName}ToTerraform`;
+        const synthExpr = isArray
+            ? `this.${fieldName}?.map(${toTerraformFunc})`
+            : `${toTerraformFunc}(this.${fieldName})`;
+        return {
+            field: `  private ${fieldName}?: ${tsType};`,
+            assign: `    this.${fieldName} = config.${camelPropName};`,
+            synth: `      ${name}: ${synthExpr},`,
+        };
+    });
+    return {
+        privateFields: [...attrEntries.map((e) => e.field), ...blockEntries.map((e) => e.field)].join("\n"),
+        assignments: [...attrEntries.map((e) => e.assign), ...blockEntries.map((e) => e.assign)].join("\n"),
+        synthesizeBody: [...attrEntries.map((e) => e.synth), ...blockEntries.map((e) => e.synth)].join("\n"),
+        configGetters: attrEntries
+            .map((e) => e.getter)
+            .filter((g) => g !== undefined)
+            .join("\n\n"),
+    };
+}
+function generateConfigGetter(attrName, safePropName, tsType) {
+    const stringTypes = new Set(["string", "string | undefined"]);
+    const numberTypes = new Set(["number", "number | undefined"]);
+    const booleanTypes = new Set(["boolean", "boolean | undefined"]);
+    if (stringTypes.has(tsType)) {
+        return `  get ${safePropName}(): string {
+    return this.getStringAttribute("${attrName}");
+  }`;
+    }
+    if (numberTypes.has(tsType)) {
+        return `  get ${safePropName}(): number {
+    return this.getNumberAttribute("${attrName}");
+  }`;
+    }
+    if (booleanTypes.has(tsType)) {
+        return `  get ${safePropName}(): boolean {
+    return this.getBooleanAttribute("${attrName}");
+  }`;
+    }
+    return undefined;
+}
+function generateComputedGetters(block) {
+    if (block === undefined)
+        return "";
+    const getters = [];
+    if (block.attributes !== undefined) {
+        for (const [name, attr] of Object.entries(block.attributes)) {
+            if (attr.computed !== true)
+                continue;
+            if (isComputedListOfObjects(attr))
+                continue;
+            const camelPropName = safeCamelName(name);
+            const tsType = attributeTypeToTS(attr.type);
+            const getter = generateGetterForType(name, camelPropName, tsType);
+            if (getter !== undefined) {
+                getters.push(getter);
+            }
+        }
+    }
+    return getters.join("\n\n");
+}
+function generateGetterForType(attrName, safePropName, tsType) {
+    const stringTypes = new Set(["string", "string | undefined"]);
+    const numberTypes = new Set(["number", "number | undefined"]);
+    const booleanTypes = new Set(["boolean", "boolean | undefined"]);
+    if (stringTypes.has(tsType)) {
+        return `  get ${safePropName}(): string {
+    return this.getStringAttribute("${attrName}");
+  }`;
+    }
+    if (numberTypes.has(tsType)) {
+        return `  get ${safePropName}(): number {
+    return this.getNumberAttribute("${attrName}");
+  }`;
+    }
+    if (booleanTypes.has(tsType)) {
+        return `  get ${safePropName}(): boolean {
+    return this.getBooleanAttribute("${attrName}");
+  }`;
+    }
+    if (tsType.endsWith("[]")) {
+        return `  get ${safePropName}(): string[] {
+    return this.getListAttribute("${attrName}");
+  }`;
+    }
+    if (tsType.startsWith("Record<string,")) {
+        return `  get ${safePropName}(): Record<string, string> {
+    return this.getStringMapAttribute("${attrName}");
+  }`;
+    }
+    return undefined;
+}
+function generateConfigProperties(block) {
+    if (block === undefined)
+        return "";
+    const lines = [];
+    if (block.attributes !== undefined) {
+        for (const [name, attr] of Object.entries(block.attributes)) {
+            if (isComputedListOfObjects(attr))
+                continue;
+            const tsType = attributeTypeToTS(attr.type);
+            const isOptional = attr.required !== true || attr.optional === true || attr.computed === true;
+            const optionalMark = isOptional ? "?" : "";
+            lines.push(`  readonly ${safeCamelName(name)}${optionalMark}: ${tsType};`);
+        }
+    }
+    if (block.block_types) {
+        for (const [name, blockType] of Object.entries(block.block_types)) {
+            const interfaceName = toPascalCase(name);
+            const isArray = isBlockTypeArray(blockType);
+            const isOptional = (blockType.min_items ?? 0) === 0;
+            const optionalMark = isOptional ? "?" : "";
+            const tsType = isArray ? `${interfaceName}[]` : interfaceName;
+            lines.push(`  readonly ${safeCamelName(name)}${optionalMark}: ${tsType};`);
+        }
+    }
+    return lines.join("\n");
+}
+function generateNestedInterfaces(block) {
+    const interfaces = [];
+    if (block.block_types) {
+        for (const [name, blockType] of Object.entries(block.block_types)) {
+            interfaces.push(generateBlockInterface(name, blockType.block));
+            interfaces.push(generateNestedInterfaces(blockType.block));
+        }
+    }
+    return interfaces.filter(Boolean).join("\n\n");
+}
+function generateToTerraformFunctions(block, prefix = "") {
+    const functions = [];
+    if (block.block_types) {
+        for (const [name, blockType] of Object.entries(block.block_types)) {
+            const funcPrefix = prefix ? `${prefix}${toPascalCase(name)}` : safeCamelName(name);
+            functions.push(generateSingleToTerraformFunction(name, blockType.block, funcPrefix));
+            functions.push(generateToTerraformFunctions(blockType.block, funcPrefix));
+        }
+    }
+    return functions.filter(Boolean).join("\n\n");
+}
+function generateSingleToTerraformFunction(name, block, funcPrefix) {
+    const funcName = `${funcPrefix}ToTerraform`;
+    const typeName = toPascalCase(name);
+    const body = [];
+    if (block.attributes) {
+        for (const [attrName, attr] of Object.entries(block.attributes)) {
+            if (attr.computed === true && attr.optional !== true && attr.required !== true) {
+                continue;
+            }
+            const camelAttrName = safeCamelName(attrName);
+            body.push(`    ${attrName}: config?.${camelAttrName},`);
+        }
+    }
+    if (block.block_types) {
+        for (const [blockName, blockType] of Object.entries(block.block_types)) {
+            const camelBlockName = safeCamelName(blockName);
+            const nestedFuncPrefix = `${funcPrefix}${toPascalCase(blockName)}`;
+            const nestedFuncName = `${nestedFuncPrefix}ToTerraform`;
+            const isArray = isBlockTypeArray(blockType);
+            if (isArray) {
+                body.push(`    ${blockName}: config?.${camelBlockName}?.map(${nestedFuncName}),`);
+            }
+            else {
+                body.push(`    ${blockName}: ${nestedFuncName}(config?.${camelBlockName}),`);
+            }
+        }
+    }
+    return `function ${funcName}(config: ${typeName} | undefined): Record<string, unknown> | undefined {
+  if (config === undefined) return undefined;
+  return {
+${body.join("\n")}
+  };
+}`;
+}
+function toCamelCase(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function generateIndexFile(constraint, schema) {
+    const exports = [];
+    exports.push(`export * from "./lib/provider/index.js";`);
+    if (schema.resource_schemas) {
+        for (const resourceType of Object.keys(schema.resource_schemas)) {
+            const shortName = resourceType.replace(`${constraint.name}_`, "");
+            const kebabName = shortName.replace(/_/g, "-");
+            const camelName = toCamelCase(kebabName);
+            exports.push(`export * as ${camelName} from "./lib/${kebabName}/index.js";`);
+        }
+    }
+    if (schema.data_source_schemas) {
+        for (const dataType of Object.keys(schema.data_source_schemas)) {
+            const shortName = dataType.replace(`${constraint.name}_`, "");
+            const kebabName = shortName.replace(/_/g, "-");
+            const camelName = `data${constraint.name.charAt(0).toUpperCase() + constraint.name.slice(1)}${toPascalCase(shortName)}`;
+            exports.push(`export * as ${camelName} from "./lib/data-${constraint.name}-${kebabName}/index.js";`);
+        }
+    }
+    return {
+        path: `providers/${constraint.namespace}/${constraint.name}/index.ts`,
+        content: exports.join("\n") + "\n",
+    };
+}
+function generatePackageJson(constraint) {
+    const content = JSON.stringify({
+        name: `@cdktf/provider-${constraint.name}`,
+        version: "0.0.0",
+        main: "./index.ts",
+        types: "./index.ts",
+        exports: {
+            ".": "./index.ts",
+            "./lib/*": "./lib/*/index.ts",
+        },
+    }, null, 2);
+    return {
+        path: `providers/${constraint.namespace}/${constraint.name}/package.json`,
+        content: content + "\n",
+    };
+}
+//# sourceMappingURL=generator.js.map