@cdktn/provider-generator 0.24.0-pre.5 → 0.24.0-pre.50

package/src/get/generator/models/struct.ts

@@ -0,0 +1,116 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { AttributeModel } from "./attribute-model";
+import { downcaseFirst } from "../../../util";
+export class Struct {
+  constructor(
+    public readonly name: string,
+    public readonly attributes: AttributeModel[],
+    public readonly isClass = false,
+    public readonly isAnonymous = false,
+    public isSingleItem = false,
+    public readonly nestingMode: string = "",
+  ) {}
+
+  public get assignableAttributes(): AttributeModel[] {
+    return this.attributes.filter((attribute) => attribute.isAssignable);
+  }
+
+  public get optionalAttributes(): AttributeModel[] {
+    return this.attributes.filter((attribute) => attribute.optional);
+  }
+
+  public get allOptional(): boolean {
+    return (
+      this.attributes.filter(
+        (attribute) => !attribute.optional && !attribute.computed,
+      ).length == 0
+    );
+  }
+
+  public get attributeType() {
+    return `${this.name}${this.allOptional ? " = {}" : ""}`;
+  }
+
+  public get assignable() {
+    return !this.isClass || this.assignableAttributes.length > 0;
+  }
+
+  public get extends(): string {
+    return "";
+  }
+
+  public get mapperName(): string {
+    return `${downcaseFirst(this.name)}ToTerraform`;
+  }
+
+  public get hclMapperName(): string {
+    return `${downcaseFirst(this.name)}ToHclTerraform`;
+  }
+
+  public get outputReferenceName(): string {
+    return `${this.name}OutputReference`;
+  }
+
+  public get listName(): string {
+    return `${this.name}List`;
+  }
+
+  public get mapName(): string {
+    return `${this.name}Map`;
+  }
+
+  public get mapListName(): string {
+    return `${this.name}MapList`;
+  }
+
+  public get listMapName(): string {
+    return `${this.name}ListMap`;
+  }
+
+  public get listListName(): string {
+    return `${this.name}ListList`;
+  }
+
+  public get isProvider(): boolean {
+    return this.attributes.some((att) => att.isProvider);
+  }
+
+  public get referencedTypes(): string[] {
+    const types: string[] = [];
+
+    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;
+  }
+
+  public get exportCount(): number {
+    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;
+  }
+}
+
+export class ConfigStruct extends Struct {
+  public get extends(): string {
+    return ` extends cdktn.TerraformMetaArguments`;
+  }
+}

package/src/get/generator/module-generator.ts

@@ -0,0 +1,234 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { CodeMaker, toCamelCase } from "codemaker";
+import { AttributeModel } from "./models";
+import { sanitizedComment } from "./sanitized-comments";
+import { ConstructsMakerModuleTarget } from "@cdktn/commons";
+
+export class ModuleGenerator {
+  constructor(
+    private readonly code: CodeMaker,
+    private readonly targets: ConstructsMakerModuleTarget[],
+  ) {
+    this.code.indentation = 2;
+
+    for (const target of this.targets) {
+      this.emitSubmodule(target);
+    }
+  }
+
+  private emitSubmodule(target: ConstructsMakerModuleTarget) {
+    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 = 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 ${AttributeModel.escapeName(
+          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 = 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 = AttributeModel.escapeName(toCamelCase(input.name));
+      this.code.line(`this.${inputName} = config.${inputName};`);
+    }
+
+    this.code.close(`}`); // ctor
+
+    for (const input of spec.inputs) {
+      const inputName = AttributeModel.escapeName(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 = 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);
+  }
+}
+
+function parseType(type: string) {
+  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: string): string | undefined {
+  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}`);
+}

package/src/get/generator/provider-generator.ts

@@ -0,0 +1,355 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { CodeMaker, toCamelCase } from "codemaker";
+import {
+  ConstructsMakerProviderTarget,
+  ConstructsMakerTarget,
+  LANGUAGES,
+  logger,
+  ProviderSchema,
+  TerraformProviderConstraint,
+} from "@cdktn/commons";
+import { FQPN, parseFQPN, ProviderName } from "@cdktn/provider-schema";
+import { ResourceModel } from "./models";
+import { ResourceParser } from "./resource-parser";
+import { ResourceEmitter, StructEmitter } from "./emitter";
+
+export interface TerraformProviderGeneratorOptions {
+  /**
+   * File extension to write on emitted relative imports.
+   * Defaults to "" (CommonJS).
+   */
+  readonly importExtension?: string;
+}
+
+interface ProviderData {
+  name: string;
+  source: string;
+  version: string;
+}
+
+const isMatching = (
+  target: ConstructsMakerTarget,
+  terraformSchemaName: string,
+): boolean => {
+  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;
+  }
+};
+
+export interface ProviderConstraints {
+  [fqn: string]: ProviderData;
+}
+
+export class TerraformProviderGenerator {
+  private resourceParser = new ResourceParser();
+  private resourceEmitter: ResourceEmitter;
+  private structEmitter: StructEmitter;
+  private readonly importExtension: string;
+  public versions: { [fqpn: string]: string | undefined } = {};
+
+  constructor(
+    private readonly code: CodeMaker,
+    private readonly schema: ProviderSchema,
+    options: TerraformProviderGeneratorOptions = {},
+  ) {
+    this.code.indentation = 2;
+    this.importExtension = options.importExtension ?? "";
+    this.resourceEmitter = new ResourceEmitter(this.code);
+    this.structEmitter = new StructEmitter(this.code, this.importExtension);
+  }
+
+  private getProviderByConstraint(
+    providerConstraint: ConstructsMakerTarget,
+  ): FQPN | undefined {
+    return Object.keys(this.schema.provider_schemas || {}).find((fqpn) =>
+      isMatching(providerConstraint, fqpn),
+    ) as FQPN | undefined;
+  }
+
+  public generate(providerConstraint: ConstructsMakerTarget) {
+    const fqpn = this.getProviderByConstraint(providerConstraint);
+    if (!fqpn) {
+      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 = this.schema.provider_versions?.[fqpn];
+    this.emitProvider(fqpn, providerVersion, providerConstraint);
+    this.versions[fqpn] = providerVersion;
+  }
+
+  public generateAll() {
+    for (const fqpn of Object.keys(this.schema.provider_schemas || {})) {
+      this.generate(
+        new ConstructsMakerProviderTarget(
+          new TerraformProviderConstraint(fqpn),
+          LANGUAGES[0],
+        ),
+      );
+    }
+  }
+
+  public async save(outdir: string) {
+    await this.code.save(outdir);
+  }
+
+  public buildResourceModels(
+    fqpn: FQPN,
+    constraint?: ConstructsMakerTarget,
+  ): ResourceModel[] {
+    const provider = this.schema.provider_schemas?.[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 ([] as ResourceModel[]).concat(...resources, ...dataSources);
+  }
+
+  public getClassNameForResource(terraformType: string) {
+    return this.resourceParser.getClassNameForResource(terraformType);
+  }
+
+  public getNamespaceNameForResource(terraformType: string) {
+    return this.resourceParser.getNamespaceNameForResource(terraformType);
+  }
+
+  private emitProvider(
+    fqpn: FQPN,
+    providerVersion?: string,
+    constraint?: ConstructsMakerTarget,
+  ) {
+    const name = constraint?.name
+      ? (constraint.name as ProviderName)
+      : parseFQPN(fqpn).name;
+    const provider = this.schema.provider_schemas?.[fqpn];
+    if (!provider) {
+      throw new Error(`Can not find provider '${fqpn}' in schema`);
+    }
+
+    const files: string[] = [];
+    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);
+  }
+
+  private emitResourceReadme(resource: ResourceModel): void {
+    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);
+  }
+
+  private emitIndexFile(provider: ProviderName, files: string[]): void {
+    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 ${toCamelCase(dirName)} from './${dirName}/index${this.importExtension}';`,
+      );
+    }
+    this.code.line();
+    this.code.closeFile(filePath);
+  }
+
+  private emitLazyIndexFile(provider: ProviderName, files: string[]): void {
+    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, '${toCamelCase(
+          dirName,
+        )}', { get: function () { return require('./${dirName}'); } });`,
+      );
+    }
+    this.code.line();
+    this.code.closeFile(filePath);
+  }
+
+  private emitResource(resource: ResourceModel): string {
+    this.code.openFile(resource.filePath);
+    this.emitFileHeader(resource);
+    this.structEmitter.emit(resource);
+    this.resourceEmitter.emit(resource);
+    this.code.closeFile(resource.filePath);
+
+    return resource.filePath;
+  }
+
+  private emitResourceWithComplexStruct(resource: ResourceModel) {
+    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) {
+      const structsSpecifier = `./${resource.structsFolderName}/index${this.importExtension}`;
+      if (resource.referencedTypes.length > 0) {
+        this.code.line(
+          `import { ${resource.referencedTypes.join(
+            ", \n",
+          )}} from '${structsSpecifier}';`,
+        );
+      }
+
+      this.code.line(`export * from '${structsSpecifier}';`);
+
+      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;
+  }
+
+  private emitFileHeader(resource: ResourceModel) {
+    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();
+  }
+}