@cdktn/provider-generator 0.23.0-pre.8 → 0.23.0

package/build/get/generator/models/struct.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigStruct = exports.Struct = void 0;
+const util_1 = require("../../../util");
+class Struct {
+    constructor(name, attributes, isClass = false, isAnonymous = false, isSingleItem = false, nestingMode = "") {
+        this.name = name;
+        this.attributes = attributes;
+        this.isClass = isClass;
+        this.isAnonymous = isAnonymous;
+        this.isSingleItem = isSingleItem;
+        this.nestingMode = nestingMode;
+    }
+    get assignableAttributes() {
+        return this.attributes.filter((attribute) => attribute.isAssignable);
+    }
+    get optionalAttributes() {
+        return this.attributes.filter((attribute) => attribute.optional);
+    }
+    get allOptional() {
+        return (this.attributes.filter((attribute) => !attribute.optional && !attribute.computed).length == 0);
+    }
+    get attributeType() {
+        return `${this.name}${this.allOptional ? " = {}" : ""}`;
+    }
+    get assignable() {
+        return !this.isClass || this.assignableAttributes.length > 0;
+    }
+    get extends() {
+        return "";
+    }
+    get mapperName() {
+        return `${(0, util_1.downcaseFirst)(this.name)}ToTerraform`;
+    }
+    get hclMapperName() {
+        return `${(0, util_1.downcaseFirst)(this.name)}ToHclTerraform`;
+    }
+    get outputReferenceName() {
+        return `${this.name}OutputReference`;
+    }
+    get listName() {
+        return `${this.name}List`;
+    }
+    get mapName() {
+        return `${this.name}Map`;
+    }
+    get mapListName() {
+        return `${this.name}MapList`;
+    }
+    get listMapName() {
+        return `${this.name}ListMap`;
+    }
+    get listListName() {
+        return `${this.name}ListList`;
+    }
+    get isProvider() {
+        return this.attributes.some((att) => att.isProvider);
+    }
+    get referencedTypes() {
+        const types = [];
+        this.attributes.forEach((att) => {
+            const attReferences = att.getReferencedTypes(false); // This may be a config struct, but still need the references in this context
+            if (attReferences) {
+                types.push(...attReferences);
+            }
+        });
+        return types;
+    }
+    get exportCount() {
+        let count = 1; // self
+        count += 1; // toTerraform function
+        if (this.nestingMode === "list" ||
+            this.nestingMode === "set" ||
+            this.nestingMode === "map") {
+            count += 1; // output reference
+            if (!this.isSingleItem) {
+                count += 1; // complex collection
+            }
+        }
+        return count;
+    }
+}
+exports.Struct = Struct;
+class ConfigStruct extends Struct {
+    get extends() {
+        return ` extends cdktn.TerraformMetaArguments`;
+    }
+}
+exports.ConfigStruct = ConfigStruct;
+//# sourceMappingURL=data:application/json;base64,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

package/{lib → build}/get/generator/module-generator.d.ts

@@ -6,3 +6,4 @@ export declare class ModuleGenerator {
     constructor(code: CodeMaker, targets: ConstructsMakerModuleTarget[]);
     private emitSubmodule;
 }
+//# sourceMappingURL=module-generator.d.ts.map

package/build/get/generator/module-generator.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleGenerator = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const codemaker_1 = require("codemaker");
+const models_1 = require("./models");
+const sanitized_comments_1 = require("./sanitized-comments");
+class ModuleGenerator {
+    constructor(code, targets) {
+        this.code = code;
+        this.targets = targets;
+        this.code.indentation = 2;
+        for (const target of this.targets) {
+            this.emitSubmodule(target);
+        }
+    }
+    emitSubmodule(target) {
+        const spec = target.spec;
+        if (!spec) {
+            throw new Error(`missing spec for ${target.fqn}`);
+        }
+        this.code.openFile(target.fileName);
+        this.code.line(`// generated by cdktn get`);
+        this.code.line(`// ${target.source}`);
+        this.code.line(`import { TerraformModule, type TerraformModuleUserConfig } from 'cdktn';`);
+        this.code.line(`import { Construct } from 'constructs';`);
+        const baseName = this.code.toPascalCase(target.name.replace(/[-/.]/g, "_"));
+        const configType = `${baseName}Config`;
+        this.code.openBlock(`export interface ${configType} extends TerraformModuleUserConfig`);
+        for (const input of spec.inputs) {
+            const optional = input.required && input.default === undefined ? "" : "?";
+            const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+            if (input.description) {
+                comment.line(input.description);
+            }
+            if (input.default) {
+                comment.line(input.default);
+            }
+            if (input.type.includes("map(")) {
+                comment.line(`The property type contains a map, they have special handling, please see {@link cdk.tf/module-map-inputs the docs}`);
+            }
+            comment.end();
+            this.code.line(`readonly ${models_1.AttributeModel.escapeName((0, codemaker_1.toCamelCase)(input.name))}${optional}: ${parseType(input.type)};`);
+        }
+        this.code.closeBlock();
+        // Add a link to the Terraform Registry if it is sourced from there
+        // https://developer.hashicorp.com/terraform/language/modules/sources
+        // Registry modules are referred to as <NAMESPACE>/<NAME>/<PROVIDER>
+        // Other sources contain dots, e.g.
+        // app.terraform.io/example-corp/k8s-cluster/azurerm (private registries)
+        // github.com/hashicorp/example (Github)
+        // git@github.com:hashicorp/example.git
+        // bitbucket.org/hashicorp/terraform-consul-aws (Bitbucket)
+        // ... and more
+        // ../module and ./module (local paths)
+        const isNonRegistryModule = target.source.includes(".");
+        let registryPath;
+        // Submodules also exist (e.g. terraform-aws-modules/vpc/aws//modules/vpc-endpoints)
+        // And linking directly to them in the Registry requires including the version
+        // like e.g. https://registry.terraform.io/modules/terraform-aws-modules/vpc/aws/latest/submodules/vpc-endpoints
+        if (target.source.includes("//")) {
+            registryPath = target.source.replace("//modules", `/${target.version || "latest"}/submodules`);
+            // terraform-aws-modules/vpc/aws//modules/vpc-endpoints
+            // ->
+            // terraform-aws-modules/vpc/aws/latest/submodules/vpc-endpoints
+        }
+        else {
+            // not submodule specified, just append the version
+            registryPath = `${target.source}/${target.version || "latest"}`;
+        }
+        const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        comment.line(`Defines an ${baseName} based on a Terraform module`);
+        comment.line(``);
+        comment.line(isNonRegistryModule
+            ? `Source at ${target.source}`
+            : `Docs at Terraform Registry: {@link https://registry.terraform.io/modules/${registryPath} ${target.source}}`);
+        comment.end();
+        this.code.openBlock(`export class ${baseName} extends TerraformModule`);
+        this.code.line(`private readonly inputs: { [name: string]: any } = { }`);
+        const allOptional = spec.inputs.find((x) => x.required) ? "" : " = {}";
+        this.code.open(`public constructor(scope: Construct, id: string, config: ${configType}${allOptional}) {`);
+        this.code.open(`super(scope, id, {`);
+        this.code.line("...config,");
+        this.code.line(`source: '${target.source}',`);
+        if (target.version) {
+            this.code.line(`version: '${target.version}',`);
+        }
+        this.code.close(`});`);
+        for (const input of spec.inputs) {
+            const inputName = models_1.AttributeModel.escapeName((0, codemaker_1.toCamelCase)(input.name));
+            this.code.line(`this.${inputName} = config.${inputName};`);
+        }
+        this.code.close(`}`); // ctor
+        for (const input of spec.inputs) {
+            const inputName = models_1.AttributeModel.escapeName((0, codemaker_1.toCamelCase)(input.name));
+            const inputType = parseType(input.type) +
+                (input.required && input.default === undefined ? "" : " | undefined");
+            this.code.openBlock(`public get ${inputName}(): ${inputType}`);
+            this.code.line(`return this.inputs['${input.name}'] as ${inputType};`);
+            this.code.closeBlock();
+            this.code.openBlock(`public set ${inputName}(value: ${inputType})`);
+            this.code.line(`this.inputs['${input.name}'] = value;`);
+            this.code.closeBlock();
+        }
+        for (const output of spec.outputs) {
+            const outputName = (0, codemaker_1.toCamelCase)(output.name);
+            this.code.openBlock(`public get ${outputName}Output()`);
+            this.code.line(`return this.getString('${output.name}')`);
+            this.code.closeBlock();
+        }
+        this.code.openBlock(`protected synthesizeAttributes()`);
+        this.code.line(`return this.inputs;`);
+        this.code.closeBlock();
+        this.code.openBlock(`protected synthesizeHclAttributes(): { [name: string]: any }`);
+        this.code.line(`return Object.fromEntries(`);
+        this.code.line(`  Object.entries(this.inputs)`);
+        this.code.line(`    .filter(([, val]) => val !== undefined)`);
+        this.code.line(`    .map(([key, val]) => {`);
+        this.code.line(`      return [`);
+        this.code.line(`        key,`);
+        this.code.line(`        {`);
+        this.code.line(`          value: val,`);
+        this.code.line(`          type: "any",`);
+        this.code.line(`        },`);
+        this.code.line(`      ];`);
+        this.code.line(`    })`);
+        this.code.line(`);`);
+        this.code.closeBlock();
+        this.code.closeBlock(); // class
+        this.code.closeFile(target.fileName);
+    }
+}
+exports.ModuleGenerator = ModuleGenerator;
+function parseType(type) {
+    if (type === "string") {
+        return "string";
+    }
+    if (type === "number") {
+        return "number";
+    }
+    if (type === "bool") {
+        return "boolean";
+    }
+    if (type === "list") {
+        return "string[]";
+    }
+    if (type === "map") {
+        return "{ [key: string]: string }";
+    }
+    if (type === "tuple") {
+        return "string[]";
+    }
+    if (type === "any") {
+        return "any";
+    }
+    const complexType = parseComplexType(type);
+    if (complexType) {
+        return complexType;
+    }
+    throw new Error(`unknown type ${type}`);
+}
+function parseComplexType(type) {
+    const complex = /^(object|list|map|set|tuple)\(([\s\S]+)\)/;
+    const match = complex.exec(type);
+    if (!match) {
+        return undefined;
+    }
+    const [, kind, innerType] = match;
+    if (kind === "object") {
+        return `any`;
+    }
+    if (kind === "list" || kind === "set") {
+        return `${parseType(innerType)}[]`;
+    }
+    if (kind === "tuple") {
+        return `any[]`;
+    }
+    if (kind === "map") {
+        return `{ [key: string]: ${parseType(innerType)} }`;
+    }
+    throw new Error(`unexpected kind ${kind}`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module-generator.js","sourceRoot":"","sources":["../../../src/get/generator/module-generator.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { CodeMaker, toCamelCase } from \"codemaker\";\nimport { AttributeModel } from \"./models\";\nimport { sanitizedComment } from \"./sanitized-comments\";\nimport { ConstructsMakerModuleTarget } from \"@cdktn/commons\";\n\nexport class ModuleGenerator {\n  constructor(\n    private readonly code: CodeMaker,\n    private readonly targets: ConstructsMakerModuleTarget[],\n  ) {\n    this.code.indentation = 2;\n\n    for (const target of this.targets) {\n      this.emitSubmodule(target);\n    }\n  }\n\n  private emitSubmodule(target: ConstructsMakerModuleTarget) {\n    const spec = target.spec;\n\n    if (!spec) {\n      throw new Error(`missing spec for ${target.fqn}`);\n    }\n\n    this.code.openFile(target.fileName);\n\n    this.code.line(`// generated by cdktn get`);\n    this.code.line(`// ${target.source}`);\n\n    this.code.line(\n      `import { TerraformModule, type TerraformModuleUserConfig } from 'cdktn';`,\n    );\n    this.code.line(`import { Construct } from 'constructs';`);\n\n    const baseName = this.code.toPascalCase(target.name.replace(/[-/.]/g, \"_\"));\n    const configType = `${baseName}Config`;\n\n    this.code.openBlock(\n      `export interface ${configType} extends TerraformModuleUserConfig`,\n    );\n    for (const input of spec.inputs) {\n      const optional = input.required && input.default === undefined ? \"\" : \"?\";\n\n      const comment = sanitizedComment(this.code);\n      if (input.description) {\n        comment.line(input.description);\n      }\n      if (input.default) {\n        comment.line(input.default);\n      }\n      if (input.type.includes(\"map(\")) {\n        comment.line(\n          `The property type contains a map, they have special handling, please see {@link cdk.tf/module-map-inputs the docs}`,\n        );\n      }\n      comment.end();\n\n      this.code.line(\n        `readonly ${AttributeModel.escapeName(\n          toCamelCase(input.name),\n        )}${optional}: ${parseType(input.type)};`,\n      );\n    }\n    this.code.closeBlock();\n\n    // Add a link to the Terraform Registry if it is sourced from there\n    // https://developer.hashicorp.com/terraform/language/modules/sources\n    // Registry modules are referred to as <NAMESPACE>/<NAME>/<PROVIDER>\n    // Other sources contain dots, e.g.\n    // app.terraform.io/example-corp/k8s-cluster/azurerm (private registries)\n    // github.com/hashicorp/example (Github)\n    // git@github.com:hashicorp/example.git\n    // bitbucket.org/hashicorp/terraform-consul-aws (Bitbucket)\n    // ... and more\n    // ../module and ./module (local paths)\n    const isNonRegistryModule = target.source.includes(\".\");\n    let registryPath;\n    // Submodules also exist (e.g. terraform-aws-modules/vpc/aws//modules/vpc-endpoints)\n    // And linking directly to them in the Registry requires including the version\n    // like e.g. https://registry.terraform.io/modules/terraform-aws-modules/vpc/aws/latest/submodules/vpc-endpoints\n    if (target.source.includes(\"//\")) {\n      registryPath = target.source.replace(\n        \"//modules\",\n        `/${target.version || \"latest\"}/submodules`,\n      );\n      // terraform-aws-modules/vpc/aws//modules/vpc-endpoints\n      // ->\n      // terraform-aws-modules/vpc/aws/latest/submodules/vpc-endpoints\n    } else {\n      // not submodule specified, just append the version\n      registryPath = `${target.source}/${target.version || \"latest\"}`;\n    }\n\n    const comment = sanitizedComment(this.code);\n    comment.line(`Defines an ${baseName} based on a Terraform module`);\n    comment.line(``);\n    comment.line(\n      isNonRegistryModule\n        ? `Source at ${target.source}`\n        : `Docs at Terraform Registry: {@link https://registry.terraform.io/modules/${registryPath} ${target.source}}`,\n    );\n    comment.end();\n    this.code.openBlock(`export class ${baseName} extends TerraformModule`);\n\n    this.code.line(`private readonly inputs: { [name: string]: any } = { }`);\n\n    const allOptional = spec.inputs.find((x) => x.required) ? \"\" : \" = {}\";\n\n    this.code.open(\n      `public constructor(scope: Construct, id: string, config: ${configType}${allOptional}) {`,\n    );\n    this.code.open(`super(scope, id, {`);\n    this.code.line(\"...config,\");\n    this.code.line(`source: '${target.source}',`);\n    if (target.version) {\n      this.code.line(`version: '${target.version}',`);\n    }\n    this.code.close(`});`);\n\n    for (const input of spec.inputs) {\n      const inputName = AttributeModel.escapeName(toCamelCase(input.name));\n      this.code.line(`this.${inputName} = config.${inputName};`);\n    }\n\n    this.code.close(`}`); // ctor\n\n    for (const input of spec.inputs) {\n      const inputName = AttributeModel.escapeName(toCamelCase(input.name));\n      const inputType =\n        parseType(input.type) +\n        (input.required && input.default === undefined ? \"\" : \" | undefined\");\n      this.code.openBlock(`public get ${inputName}(): ${inputType}`);\n      this.code.line(`return this.inputs['${input.name}'] as ${inputType};`);\n      this.code.closeBlock();\n\n      this.code.openBlock(`public set ${inputName}(value: ${inputType})`);\n      this.code.line(`this.inputs['${input.name}'] = value;`);\n      this.code.closeBlock();\n    }\n\n    for (const output of spec.outputs) {\n      const outputName = toCamelCase(output.name);\n      this.code.openBlock(`public get ${outputName}Output()`);\n      this.code.line(`return this.getString('${output.name}')`);\n      this.code.closeBlock();\n    }\n\n    this.code.openBlock(`protected synthesizeAttributes()`);\n    this.code.line(`return this.inputs;`);\n    this.code.closeBlock();\n\n    this.code.openBlock(\n      `protected synthesizeHclAttributes(): { [name: string]: any }`,\n    );\n    this.code.line(`return Object.fromEntries(`);\n    this.code.line(`  Object.entries(this.inputs)`);\n    this.code.line(`    .filter(([, val]) => val !== undefined)`);\n    this.code.line(`    .map(([key, val]) => {`);\n    this.code.line(`      return [`);\n    this.code.line(`        key,`);\n    this.code.line(`        {`);\n    this.code.line(`          value: val,`);\n    this.code.line(`          type: \"any\",`);\n    this.code.line(`        },`);\n    this.code.line(`      ];`);\n    this.code.line(`    })`);\n    this.code.line(`);`);\n    this.code.closeBlock();\n\n    this.code.closeBlock(); // class\n    this.code.closeFile(target.fileName);\n  }\n}\n\nfunction parseType(type: string) {\n  if (type === \"string\") {\n    return \"string\";\n  }\n  if (type === \"number\") {\n    return \"number\";\n  }\n  if (type === \"bool\") {\n    return \"boolean\";\n  }\n  if (type === \"list\") {\n    return \"string[]\";\n  }\n  if (type === \"map\") {\n    return \"{ [key: string]: string }\";\n  }\n  if (type === \"tuple\") {\n    return \"string[]\";\n  }\n  if (type === \"any\") {\n    return \"any\";\n  }\n\n  const complexType = parseComplexType(type);\n  if (complexType) {\n    return complexType;\n  }\n\n  throw new Error(`unknown type ${type}`);\n}\n\nfunction parseComplexType(type: string): string | undefined {\n  const complex = /^(object|list|map|set|tuple)\\(([\\s\\S]+)\\)/;\n  const match = complex.exec(type);\n  if (!match) {\n    return undefined;\n  }\n\n  const [, kind, innerType] = match;\n\n  if (kind === \"object\") {\n    return `any`;\n  }\n\n  if (kind === \"list\" || kind === \"set\") {\n    return `${parseType(innerType)}[]`;\n  }\n\n  if (kind === \"tuple\") {\n    return `any[]`;\n  }\n\n  if (kind === \"map\") {\n    return `{ [key: string]: ${parseType(innerType)} }`;\n  }\n\n  throw new Error(`unexpected kind ${kind}`);\n}\n"]}

package/{lib → build}/get/generator/provider-generator.d.ts

@@ -36,3 +36,4 @@ export declare class TerraformProviderGenerator {
     private emitFileHeader;
 }
 export {};
+//# sourceMappingURL=provider-generator.d.ts.map

package/build/get/generator/provider-generator.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformProviderGenerator = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const codemaker_1 = require("codemaker");
+const commons_1 = require("@cdktn/commons");
+const provider_schema_1 = require("@cdktn/provider-schema");
+const resource_parser_1 = require("./resource-parser");
+const emitter_1 = require("./emitter");
+const isMatching = (target, terraformSchemaName) => {
+    if (target.isModule)
+        return false;
+    const elements = terraformSchemaName.split("/");
+    if (elements.length === 1) {
+        return target.source === terraformSchemaName;
+    }
+    else {
+        const [hostname, namespace, provider] = elements;
+        if (!hostname || !namespace || !provider) {
+            throw new Error(`can't handle ${terraformSchemaName}`);
+        }
+        // If target.source is set, try to match it
+        if (target.source) {
+            const targetSource = {
+                // defaults
+                hostname: "registry.terraform.io",
+                namespace: "hashicorp",
+                name: "",
+            };
+            const targetElements = target.source.split("/");
+            switch (targetElements.length) {
+                case 1: // only name set
+                    targetSource.name = targetElements[0].toLowerCase();
+                    break;
+                case 2: // namespace and name set
+                    targetSource.namespace = targetElements[0].toLowerCase();
+                    targetSource.name = targetElements[1].toLowerCase();
+                    break;
+                case 3: // hostname, namespace and name set
+                    targetSource.hostname = targetElements[0].toLowerCase();
+                    targetSource.namespace = targetElements[1].toLowerCase();
+                    targetSource.name = targetElements[2].toLowerCase();
+                    break;
+                default:
+                    throw new Error(`can't handle ${target.source}. Expected string with 1, 2 or 3 elements separated by '/'`);
+            }
+            return (targetSource.hostname === hostname &&
+                targetSource.namespace === namespace &&
+                targetSource.name === provider);
+        }
+        // Else, try to match target.name to the provider name
+        return target.name === provider;
+    }
+};
+class TerraformProviderGenerator {
+    constructor(code, schema) {
+        this.code = code;
+        this.schema = schema;
+        this.resourceParser = new resource_parser_1.ResourceParser();
+        this.versions = {};
+        this.code.indentation = 2;
+        this.resourceEmitter = new emitter_1.ResourceEmitter(this.code);
+        this.structEmitter = new emitter_1.StructEmitter(this.code);
+    }
+    getProviderByConstraint(providerConstraint) {
+        return Object.keys(this.schema.provider_schemas || {}).find((fqpn) => isMatching(providerConstraint, fqpn));
+    }
+    generate(providerConstraint) {
+        var _a;
+        const fqpn = this.getProviderByConstraint(providerConstraint);
+        if (!fqpn) {
+            commons_1.logger.debug(`Could not find provider constraint for ${providerConstraint} in schema: ${JSON.stringify(this.schema, null, 2)}`);
+            throw new Error(`Could not find provider with constraint ${JSON.stringify(providerConstraint)}`);
+        }
+        const providerVersion = (_a = this.schema.provider_versions) === null || _a === void 0 ? void 0 : _a[fqpn];
+        this.emitProvider(fqpn, providerVersion, providerConstraint);
+        this.versions[fqpn] = providerVersion;
+    }
+    generateAll() {
+        for (const fqpn of Object.keys(this.schema.provider_schemas || {})) {
+            this.generate(new commons_1.ConstructsMakerProviderTarget(new commons_1.TerraformProviderConstraint(fqpn), commons_1.LANGUAGES[0]));
+        }
+    }
+    async save(outdir) {
+        await this.code.save(outdir);
+    }
+    buildResourceModels(fqpn, constraint) {
+        var _a;
+        const provider = (_a = this.schema.provider_schemas) === null || _a === void 0 ? void 0 : _a[fqpn];
+        if (!provider) {
+            throw new Error(`Can not find provider '${fqpn}' in schema`);
+        }
+        const resources = Object.entries(provider.resource_schemas || {}).map(([type, resource]) => this.resourceParser.parse(fqpn, type, resource, "resource", constraint));
+        const dataSources = Object.entries(provider.data_source_schemas || {}).map(([type, resource]) => this.resourceParser.parse(fqpn, `data_${type}`, resource, "data_source", constraint));
+        return [].concat(...resources, ...dataSources);
+    }
+    getClassNameForResource(terraformType) {
+        return this.resourceParser.getClassNameForResource(terraformType);
+    }
+    getNamespaceNameForResource(terraformType) {
+        return this.resourceParser.getNamespaceNameForResource(terraformType);
+    }
+    emitProvider(fqpn, providerVersion, constraint) {
+        var _a;
+        const name = (constraint === null || constraint === void 0 ? void 0 : constraint.name)
+            ? constraint.name
+            : (0, provider_schema_1.parseFQPN)(fqpn).name;
+        const provider = (_a = this.schema.provider_schemas) === null || _a === void 0 ? void 0 : _a[fqpn];
+        if (!provider) {
+            throw new Error(`Can not find provider '${fqpn}' in schema`);
+        }
+        const files = [];
+        this.buildResourceModels(fqpn, constraint).forEach((resourceModel) => {
+            if (constraint) {
+                resourceModel.providerVersionConstraint = constraint.version;
+                resourceModel.terraformProviderSource = constraint.source;
+            }
+            resourceModel.providerVersion = providerVersion;
+            if (resourceModel.structsRequireSharding) {
+                files.push(this.emitResourceWithComplexStruct(resourceModel));
+            }
+            else {
+                files.push(this.emitResource(resourceModel));
+            }
+            this.emitResourceReadme(resourceModel);
+        });
+        if (provider.provider) {
+            const providerResource = this.resourceParser.parse(fqpn, `provider`, provider.provider, "provider", constraint);
+            if (constraint) {
+                providerResource.providerVersionConstraint = constraint.version;
+                providerResource.terraformProviderSource = constraint.source;
+                providerResource.terraformProviderName = constraint.name;
+            }
+            providerResource.providerVersion = providerVersion;
+            files.push(this.emitResource(providerResource));
+            this.emitResourceReadme(providerResource);
+        }
+        this.emitIndexFile(name, files);
+        this.emitLazyIndexFile(name, files);
+    }
+    emitResourceReadme(resource) {
+        const filePath = `${resource.namespaceFolderPath}/README.md`;
+        this.code.openFile(filePath);
+        this.code.line(`# \`${resource.terraformType}\``);
+        this.code.line();
+        const type = resource.isProvider
+            ? resource.provider
+            : resource.terraformType;
+        this.code.line(`Refer to the Terraform Registry for docs: [\`${type}\`](${resource.linkToDocs}).`);
+        this.code.closeFile(filePath);
+    }
+    emitIndexFile(provider, files) {
+        const folder = `providers/${provider}`;
+        const filePath = `${folder}/index.ts`;
+        this.code.openFile(filePath);
+        this.code.line("// generated by cdktn get");
+        for (const file of files) {
+            const dirName = file.replace(`${folder}/`, "").replace("/index.ts", "");
+            this.code.line(`export * as ${(0, codemaker_1.toCamelCase)(dirName)} from './${dirName}';`);
+        }
+        this.code.line();
+        this.code.closeFile(filePath);
+    }
+    emitLazyIndexFile(provider, files) {
+        const folder = `providers/${provider}`;
+        const filePath = `${folder}/lazy-index.ts`;
+        this.code.openFile(filePath);
+        this.code.line("// generated by cdktn get");
+        for (const file of files) {
+            const dirName = file.replace(`${folder}/`, "").replace("/index.ts", "");
+            this.code.line(`Object.defineProperty(exports, '${(0, codemaker_1.toCamelCase)(dirName)}', { get: function () { return require('./${dirName}'); } });`);
+        }
+        this.code.line();
+        this.code.closeFile(filePath);
+    }
+    emitResource(resource) {
+        this.code.openFile(resource.filePath);
+        this.emitFileHeader(resource);
+        this.structEmitter.emit(resource);
+        this.resourceEmitter.emit(resource);
+        this.code.closeFile(resource.filePath);
+        return resource.filePath;
+    }
+    emitResourceWithComplexStruct(resource) {
+        const generatedFiles = [];
+        // drop the last segment of the filepath
+        const filePath = resource.filePath;
+        this.code.openFile(filePath);
+        this.code.line(`// generated from terraform resource schema`);
+        this.code.line();
+        if (resource.structsRequireSharding) {
+            if (resource.referencedTypes.length > 0) {
+                this.code.line(`import { ${resource.referencedTypes.join(", \n")}} from './${resource.structsFolderName}'`);
+            }
+            this.code.line(`export * from './${resource.structsFolderName}'`);
+            resource.importStatements.forEach((statement) => this.code.line(statement));
+            this.structEmitter.emitInterface(resource, resource.configStruct);
+            this.resourceEmitter.emit(resource);
+            this.code.closeFile(filePath);
+            this.structEmitter.emit(resource);
+            generatedFiles.push(resource.fileName);
+            generatedFiles.push(resource.structsFolderName);
+        }
+        else {
+            resource.importStatements.forEach((statement) => this.code.line(statement));
+            this.structEmitter.emit(resource);
+            this.resourceEmitter.emit(resource);
+            this.code.closeFile(filePath);
+            generatedFiles.push(resource.fileName);
+        }
+        return filePath;
+    }
+    emitFileHeader(resource) {
+        this.code.line(`// ${resource.linkToDocs}`);
+        this.code.line(`// generated from terraform resource schema`);
+        this.code.line();
+        resource.importStatements.forEach((statement) => this.code.line(statement));
+        this.code.line();
+        this.code.line("// Configuration");
+        this.code.line();
+    }
+}
+exports.TerraformProviderGenerator = TerraformProviderGenerator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-generator.js","sourceRoot":"","sources":["../../../src/get/generator/provider-generator.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { CodeMaker, toCamelCase } from \"codemaker\";\nimport {\n  ConstructsMakerProviderTarget,\n  ConstructsMakerTarget,\n  LANGUAGES,\n  logger,\n  ProviderSchema,\n  TerraformProviderConstraint,\n} from \"@cdktn/commons\";\nimport { FQPN, parseFQPN, ProviderName } from \"@cdktn/provider-schema\";\nimport { ResourceModel } from \"./models\";\nimport { ResourceParser } from \"./resource-parser\";\nimport { ResourceEmitter, StructEmitter } from \"./emitter\";\n\ninterface ProviderData {\n  name: string;\n  source: string;\n  version: string;\n}\n\nconst isMatching = (\n  target: ConstructsMakerTarget,\n  terraformSchemaName: string,\n): boolean => {\n  if (target.isModule) return false;\n\n  const elements = terraformSchemaName.split(\"/\");\n\n  if (elements.length === 1) {\n    return target.source === terraformSchemaName;\n  } else {\n    const [hostname, namespace, provider] = elements;\n\n    if (!hostname || !namespace || !provider) {\n      throw new Error(`can't handle ${terraformSchemaName}`);\n    }\n\n    // If target.source is set, try to match it\n    if (target.source) {\n      const targetSource = {\n        // defaults\n        hostname: \"registry.terraform.io\",\n        namespace: \"hashicorp\",\n        name: \"\",\n      };\n      const targetElements = target.source.split(\"/\");\n      switch (targetElements.length) {\n        case 1: // only name set\n          targetSource.name = targetElements[0].toLowerCase();\n          break;\n        case 2: // namespace and name set\n          targetSource.namespace = targetElements[0].toLowerCase();\n          targetSource.name = targetElements[1].toLowerCase();\n          break;\n        case 3: // hostname, namespace and name set\n          targetSource.hostname = targetElements[0].toLowerCase();\n          targetSource.namespace = targetElements[1].toLowerCase();\n          targetSource.name = targetElements[2].toLowerCase();\n          break;\n        default:\n          throw new Error(\n            `can't handle ${target.source}. Expected string with 1, 2 or 3 elements separated by '/'`,\n          );\n      }\n\n      return (\n        targetSource.hostname === hostname &&\n        targetSource.namespace === namespace &&\n        targetSource.name === provider\n      );\n    }\n\n    // Else, try to match target.name to the provider name\n\n    return target.name === provider;\n  }\n};\n\nexport interface ProviderConstraints {\n  [fqn: string]: ProviderData;\n}\n\nexport class TerraformProviderGenerator {\n  private resourceParser = new ResourceParser();\n  private resourceEmitter: ResourceEmitter;\n  private structEmitter: StructEmitter;\n  public versions: { [fqpn: string]: string | undefined } = {};\n\n  constructor(\n    private readonly code: CodeMaker,\n    private readonly schema: ProviderSchema,\n  ) {\n    this.code.indentation = 2;\n    this.resourceEmitter = new ResourceEmitter(this.code);\n    this.structEmitter = new StructEmitter(this.code);\n  }\n\n  private getProviderByConstraint(\n    providerConstraint: ConstructsMakerTarget,\n  ): FQPN | undefined {\n    return Object.keys(this.schema.provider_schemas || {}).find((fqpn) =>\n      isMatching(providerConstraint, fqpn),\n    ) as FQPN | undefined;\n  }\n\n  public generate(providerConstraint: ConstructsMakerTarget) {\n    const fqpn = this.getProviderByConstraint(providerConstraint);\n    if (!fqpn) {\n      logger.debug(\n        `Could not find provider constraint for ${providerConstraint} in schema: ${JSON.stringify(\n          this.schema,\n          null,\n          2,\n        )}`,\n      );\n      throw new Error(\n        `Could not find provider with constraint ${JSON.stringify(\n          providerConstraint,\n        )}`,\n      );\n    }\n\n    const providerVersion = this.schema.provider_versions?.[fqpn];\n    this.emitProvider(fqpn, providerVersion, providerConstraint);\n    this.versions[fqpn] = providerVersion;\n  }\n\n  public generateAll() {\n    for (const fqpn of Object.keys(this.schema.provider_schemas || {})) {\n      this.generate(\n        new ConstructsMakerProviderTarget(\n          new TerraformProviderConstraint(fqpn),\n          LANGUAGES[0],\n        ),\n      );\n    }\n  }\n\n  public async save(outdir: string) {\n    await this.code.save(outdir);\n  }\n\n  public buildResourceModels(\n    fqpn: FQPN,\n    constraint?: ConstructsMakerTarget,\n  ): ResourceModel[] {\n    const provider = this.schema.provider_schemas?.[fqpn];\n    if (!provider) {\n      throw new Error(`Can not find provider '${fqpn}' in schema`);\n    }\n\n    const resources = Object.entries(provider.resource_schemas || {}).map(\n      ([type, resource]) =>\n        this.resourceParser.parse(fqpn, type, resource, \"resource\", constraint),\n    );\n\n    const dataSources = Object.entries(provider.data_source_schemas || {}).map(\n      ([type, resource]) =>\n        this.resourceParser.parse(\n          fqpn,\n          `data_${type}`,\n          resource,\n          \"data_source\",\n          constraint,\n        ),\n    );\n\n    return ([] as ResourceModel[]).concat(...resources, ...dataSources);\n  }\n\n  public getClassNameForResource(terraformType: string) {\n    return this.resourceParser.getClassNameForResource(terraformType);\n  }\n\n  public getNamespaceNameForResource(terraformType: string) {\n    return this.resourceParser.getNamespaceNameForResource(terraformType);\n  }\n\n  private emitProvider(\n    fqpn: FQPN,\n    providerVersion?: string,\n    constraint?: ConstructsMakerTarget,\n  ) {\n    const name = constraint?.name\n      ? (constraint.name as ProviderName)\n      : parseFQPN(fqpn).name;\n    const provider = this.schema.provider_schemas?.[fqpn];\n    if (!provider) {\n      throw new Error(`Can not find provider '${fqpn}' in schema`);\n    }\n\n    const files: string[] = [];\n    this.buildResourceModels(fqpn, constraint).forEach((resourceModel) => {\n      if (constraint) {\n        resourceModel.providerVersionConstraint = constraint.version;\n        resourceModel.terraformProviderSource = constraint.source;\n      }\n      resourceModel.providerVersion = providerVersion;\n\n      if (resourceModel.structsRequireSharding) {\n        files.push(this.emitResourceWithComplexStruct(resourceModel));\n      } else {\n        files.push(this.emitResource(resourceModel));\n      }\n      this.emitResourceReadme(resourceModel);\n    });\n\n    if (provider.provider) {\n      const providerResource = this.resourceParser.parse(\n        fqpn,\n        `provider`,\n        provider.provider,\n        \"provider\",\n        constraint,\n      );\n      if (constraint) {\n        providerResource.providerVersionConstraint = constraint.version;\n        providerResource.terraformProviderSource = constraint.source;\n        providerResource.terraformProviderName = constraint.name;\n      }\n      providerResource.providerVersion = providerVersion;\n      files.push(this.emitResource(providerResource));\n      this.emitResourceReadme(providerResource);\n    }\n\n    this.emitIndexFile(name, files);\n    this.emitLazyIndexFile(name, files);\n  }\n\n  private emitResourceReadme(resource: ResourceModel): void {\n    const filePath = `${resource.namespaceFolderPath}/README.md`;\n    this.code.openFile(filePath);\n    this.code.line(`# \\`${resource.terraformType}\\``);\n    this.code.line();\n    const type = resource.isProvider\n      ? resource.provider\n      : resource.terraformType;\n    this.code.line(\n      `Refer to the Terraform Registry for docs: [\\`${type}\\`](${resource.linkToDocs}).`,\n    );\n    this.code.closeFile(filePath);\n  }\n\n  private emitIndexFile(provider: ProviderName, files: string[]): void {\n    const folder = `providers/${provider}`;\n    const filePath = `${folder}/index.ts`;\n    this.code.openFile(filePath);\n    this.code.line(\"// generated by cdktn get\");\n    for (const file of files) {\n      const dirName = file.replace(`${folder}/`, \"\").replace(\"/index.ts\", \"\");\n      this.code.line(\n        `export * as ${toCamelCase(dirName)} from './${dirName}';`,\n      );\n    }\n    this.code.line();\n    this.code.closeFile(filePath);\n  }\n\n  private emitLazyIndexFile(provider: ProviderName, files: string[]): void {\n    const folder = `providers/${provider}`;\n    const filePath = `${folder}/lazy-index.ts`;\n    this.code.openFile(filePath);\n    this.code.line(\"// generated by cdktn get\");\n    for (const file of files) {\n      const dirName = file.replace(`${folder}/`, \"\").replace(\"/index.ts\", \"\");\n      this.code.line(\n        `Object.defineProperty(exports, '${toCamelCase(\n          dirName,\n        )}', { get: function () { return require('./${dirName}'); } });`,\n      );\n    }\n    this.code.line();\n    this.code.closeFile(filePath);\n  }\n\n  private emitResource(resource: ResourceModel): string {\n    this.code.openFile(resource.filePath);\n    this.emitFileHeader(resource);\n    this.structEmitter.emit(resource);\n    this.resourceEmitter.emit(resource);\n    this.code.closeFile(resource.filePath);\n\n    return resource.filePath;\n  }\n\n  private emitResourceWithComplexStruct(resource: ResourceModel) {\n    const generatedFiles = [];\n\n    // drop the last segment of the filepath\n    const filePath = resource.filePath;\n    this.code.openFile(filePath);\n    this.code.line(`// generated from terraform resource schema`);\n    this.code.line();\n\n    if (resource.structsRequireSharding) {\n      if (resource.referencedTypes.length > 0) {\n        this.code.line(\n          `import { ${resource.referencedTypes.join(\", \\n\")}} from './${\n            resource.structsFolderName\n          }'`,\n        );\n      }\n\n      this.code.line(`export * from './${resource.structsFolderName}'`);\n\n      resource.importStatements.forEach((statement) =>\n        this.code.line(statement),\n      );\n\n      this.structEmitter.emitInterface(resource, resource.configStruct);\n      this.resourceEmitter.emit(resource);\n\n      this.code.closeFile(filePath);\n\n      this.structEmitter.emit(resource);\n      generatedFiles.push(resource.fileName);\n      generatedFiles.push(resource.structsFolderName);\n    } else {\n      resource.importStatements.forEach((statement) =>\n        this.code.line(statement),\n      );\n\n      this.structEmitter.emit(resource);\n      this.resourceEmitter.emit(resource);\n      this.code.closeFile(filePath);\n      generatedFiles.push(resource.fileName);\n    }\n\n    return filePath;\n  }\n\n  private emitFileHeader(resource: ResourceModel) {\n    this.code.line(`// ${resource.linkToDocs}`);\n    this.code.line(`// generated from terraform resource schema`);\n    this.code.line();\n    resource.importStatements.forEach((statement) => this.code.line(statement));\n    this.code.line();\n    this.code.line(\"// Configuration\");\n    this.code.line();\n  }\n}\n"]}

package/{lib → build}/get/generator/resource-parser.d.ts

@@ -9,3 +9,4 @@ export declare class ResourceParser {
     getClassNameForResource(terraformType: string): string;
     getNamespaceNameForResource(terraformType: string): string;
 }
+//# sourceMappingURL=resource-parser.d.ts.map