@cdktn/provider-generator 0.24.0-pre.9 → 0.24.0-pre.91

package/src/get/generator/models/resource-model.ts

@@ -0,0 +1,183 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { toSnakeCase } from "codemaker";
+import path from "path";
+import { FQPN, parseFQPN, ProviderName } from "@cdktn/provider-schema";
+import { AttributeModel } from "./attribute-model";
+import { Struct, ConfigStruct } from "./struct";
+import { Schema } from "@cdktn/commons";
+import { ProviderFunctionsModel } from "./provider-function-model";
+
+// Limit is 1200 to prevent stack size error.
+// Could increase now that calculation is more accurate;
+// however, probably better to have smaller
+export const STRUCT_SHARDING_THRESHOLD = 400;
+
+interface ResourceModelOptions {
+  terraformType: string;
+  className: string;
+  baseName: string;
+  fileName: string;
+  filePath: string;
+  attributes: AttributeModel[];
+  structs: Struct[];
+  fqpn: FQPN;
+  schema: Schema;
+  terraformSchemaType: string;
+  configStructName: string;
+}
+
+type DefinitionPath = string;
+export class ResourceModel {
+  public className: string;
+  public filePath: string;
+  public terraformType: string;
+  public baseName: string;
+  public provider: ProviderName;
+  public fqpn: FQPN;
+  public providerVersionConstraint?: string;
+  public providerVersion?: string;
+  public terraformProviderSource?: string;
+  /*
+   * usually same as provider, but can be overridden if user picks a different name
+   * to be able to use two providers with the same name
+   */
+  public terraformProviderName: string;
+  /*
+   * Only set (by provider-generator.ts) when isProvider is true and the
+   * provider schema declares provider-defined functions - drives whether
+   * ResourceEmitter emits the memoized `functions` getter and its
+   * cross-directory import of the sibling provider-functions/index.ts file.
+   */
+  public providerFunctionsModel?: ProviderFunctionsModel;
+  public fileName: string;
+  public attributes: AttributeModel[];
+  public schema: Schema;
+  private _structs: Struct[];
+  private dependencies: string[];
+  private terraformSchemaType: string;
+  private configStructName: string;
+  public readonly structsRequireSharding: boolean;
+  public recursiveAttributePaths: { [usagePath: string]: DefinitionPath } = {};
+
+  constructor(options: ResourceModelOptions) {
+    this.className = options.className;
+    this.filePath = options.filePath;
+    this.terraformType = options.terraformType;
+    this.baseName = options.baseName;
+    this.attributes = options.attributes;
+    this.schema = options.schema;
+    this.fqpn = options.fqpn;
+    this.provider = parseFQPN(options.fqpn).name;
+    this.terraformProviderName = this.provider;
+    this.fileName = options.fileName;
+    this._structs = options.structs;
+    this.terraformSchemaType = options.terraformSchemaType;
+    this.configStructName = options.configStructName;
+    this.dependencies = [
+      `import { Construct } from 'constructs';`,
+      `import * as cdktn from 'cdktn';`,
+    ];
+
+    this.structsRequireSharding =
+      this._structs.reduce((partialSum, s) => partialSum + s.exportCount, 0) >
+      STRUCT_SHARDING_THRESHOLD;
+  }
+
+  public get structs(): Struct[] {
+    return [this.configStruct, ...this._structs];
+  }
+
+  public get configStruct() {
+    return new ConfigStruct(
+      this.configStructName,
+      this.attributes,
+      this.isEphemeralResource ? "TerraformEphemeralMetaArguments" : undefined,
+    );
+  }
+
+  public get synthesizableAttributes(): AttributeModel[] {
+    return this.configStruct.assignableAttributes;
+  }
+
+  public get importStatements(): string[] {
+    return this.dependencies;
+  }
+
+  public get schemaAsJson(): string {
+    return this.escapeSchema(JSON.stringify(this.schema, undefined, 2));
+  }
+
+  public get linkToDocs(): string {
+    const { hostname, namespace, name } = parseFQPN(this.fqpn);
+    const version = this.providerVersion || "latest";
+    const base = `https://${hostname}/providers/${namespace}/${name}/${version}/docs`;
+    if (this.isProvider) return base;
+    if (this.isDataSource)
+      return `${base}/data-sources/${this.terraformDocName}`;
+    if (this.isEphemeralResource)
+      return `${base}/ephemeral-resources/${this.terraformDocName}`;
+    return `${base}/resources/${this.terraformDocName}`;
+  }
+
+  public get isProvider(): boolean {
+    return this.terraformSchemaType === "provider";
+  }
+
+  public get isDataSource(): boolean {
+    return this.terraformSchemaType === "data_source";
+  }
+
+  public get isEphemeralResource(): boolean {
+    return this.terraformSchemaType === "ephemeral_resource";
+  }
+
+  public get parentClassName(): string {
+    return this.isProvider
+      ? "TerraformProvider"
+      : this.isDataSource
+        ? "TerraformDataSource"
+        : this.isEphemeralResource
+          ? "TerraformEphemeralResource"
+          : "TerraformResource";
+  }
+
+  public get terraformResourceType(): string {
+    return this.isProvider
+      ? this.terraformProviderName
+      : this.isDataSource
+        ? this.terraformType.replace(/^data_/, "")
+        : this.isEphemeralResource
+          ? this.terraformType.replace(/^ephemeral_/, "")
+          : this.terraformType;
+  }
+
+  public get terraformDocName(): string {
+    return toSnakeCase(
+      this.terraformResourceType.replace(
+        new RegExp(`^${this.provider}_`, "i"),
+        "",
+      ),
+    );
+  }
+
+  public get referencedTypes(): string[] {
+    return this.configStruct.referencedTypes;
+  }
+
+  public get structsFolderName(): string {
+    return `${path.basename(this.fileName, ".ts")}-structs`;
+  }
+
+  public get structsFolderPath(): string {
+    return path.join(this.namespaceFolderPath, this.structsFolderName);
+  }
+
+  public get namespaceFolderPath(): string {
+    return this.filePath.split("/").slice(0, -1).join("/");
+  }
+
+  private escapeSchema(schema: string): string {
+    return schema.replace(/(\*\/)/gi, `*\\/`);
+  }
+}

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

@@ -0,0 +1,54 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+export interface ScopeProps {
+  readonly name: string;
+  readonly isProvider: boolean;
+  readonly isComputed?: boolean;
+  readonly isOptional?: boolean;
+  readonly isRequired?: boolean;
+  readonly inBlockType?: boolean;
+  readonly isNestedType?: boolean;
+  readonly parent?: Scope;
+}
+
+export class Scope {
+  public readonly name: string;
+  public readonly provider?: string;
+  public readonly parent?: Scope;
+  public readonly isProvider: boolean;
+  public isComputed: boolean;
+  public isOptional: boolean;
+  public isRequired: boolean;
+  public inBlockType: boolean;
+  public isNestedType: boolean;
+
+  constructor(props: ScopeProps) {
+    this.name = props.name;
+    this.parent = props.parent;
+    this.isProvider = props.isProvider;
+    this.isComputed = props.isComputed ?? false;
+    this.isOptional = props.isOptional ?? true;
+    this.isRequired = props.isRequired ?? false;
+    this.inBlockType = props.inBlockType ?? false;
+    this.isNestedType = props.isNestedType ?? false;
+  }
+
+  public fullName(attributeName: string) {
+    return `${this.baseName}.${attributeName}`;
+  }
+
+  public get baseName() {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let scope: Scope | undefined = this;
+    let name = "";
+    while (scope) {
+      if (name === "") {
+        name = scope.name;
+      } else {
+        name = `${scope.name}.${name}`;
+      }
+      scope = scope.parent;
+    }
+    return name;
+  }
+}

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

@@ -0,0 +1,124 @@
+// 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 {
+  constructor(
+    name: string,
+    attributes: AttributeModel[],
+    private readonly extendsClass: string = "TerraformMetaArguments",
+  ) {
+    super(name, attributes);
+  }
+
+  public get extends(): string {
+    return ` extends cdktn.${this.extendsClass}`;
+  }
+}

package/src/get/generator/models/supported-stored-classes.ts

@@ -0,0 +1,88 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { uppercaseFirst } from "../../../util";
+
+// The core cdktn package (packages/cdktn/src/complex-computed-list.ts) only hand-writes
+// this fixed set of wrapper classes for computed, non-complex collection attributes.
+// Arbitrarily deep nestings of list/set/map (e.g. map(map(list(string)))) compose a
+// storedClassType (e.g. "stringListMapMap") that has no corresponding class. Rather than
+// falling back straight to a plain, untyped getter, resolveStoredClassName below first
+// looks for the nearest typed "Any"-wrapper that still exists in this set, collapsing the
+// unsupported inner shape into an untyped boundary while preserving typed navigation for
+// the outer layers (see https://github.com/open-constructs/cdk-terrain/issues/11).
+const SUPPORTED_STORED_CLASSES = new Set([
+  "StringMap",
+  "NumberMap",
+  "BooleanMap",
+  "AnyMap",
+  "StringMapMap",
+  "NumberMapMap",
+  "BooleanMapMap",
+  "AnyMapMap",
+  "BooleanList",
+  "StringListList",
+  "NumberListList",
+  "BooleanListList",
+  "AnyListList",
+  "StringMapList",
+  "NumberMapList",
+  "BooleanMapList",
+  "AnyMapList",
+  "StringListMap",
+  "NumberListMap",
+  "BooleanListMap",
+  "AnyListMap",
+]);
+
+// Resolves the composed stored class name to use for a collection attribute (list/set/map)
+// whose element is itself a non-complex collection (or simple type).
+//
+// `ownStoredClassType` is this type's own composed storedClassType (e.g. "stringListMapMap"
+// for map(map(list(string)))) and `elementTypeModelType` is the element's typeModelType
+// ("list" | "set" | "map" | "simple" | ...).
+//
+// Resolution order:
+//   1. The own composed name (e.g. "StringListMapMap") - used as-is when it refers to a
+//      class that is hand-written in the core package (not collapsed).
+//   2. Otherwise, the nearest typed "Any"-wrapper that still encodes the outer two layers
+//      (this type's own layer and its element's layer), e.g. "AnyMapMap" - collapsing the
+//      unsupported inner shape into an untyped boundary while preserving typed navigation
+//      for the outer layers.
+//   3. Otherwise (defensively; every depth should resolve via 1 or 2), undefined - the
+//      caller must fall back to a plain, untyped getter.
+export function resolveStoredClassName(
+  ownStoredClassType: string,
+  elementTypeModelType: string,
+): { name: string; collapsed: boolean } | undefined {
+  const candidate1 = uppercaseFirst(ownStoredClassType);
+  if (SUPPORTED_STORED_CLASSES.has(candidate1)) {
+    return { name: candidate1, collapsed: false };
+  }
+
+  let ownLayer: "List" | "Map" | undefined;
+  if (ownStoredClassType.endsWith("List")) {
+    ownLayer = "List";
+  } else if (ownStoredClassType.endsWith("Map")) {
+    ownLayer = "Map";
+  }
+  if (!ownLayer) {
+    return undefined;
+  }
+
+  let innerLayer: "List" | "Map" | undefined;
+  if (elementTypeModelType === "list" || elementTypeModelType === "set") {
+    innerLayer = "List";
+  } else if (elementTypeModelType === "map") {
+    innerLayer = "Map";
+  }
+  if (!innerLayer) {
+    return undefined;
+  }
+
+  const candidate2 = `Any${innerLayer}${ownLayer}`;
+  if (SUPPORTED_STORED_CLASSES.has(candidate2)) {
+    return { name: candidate2, collapsed: true };
+  }
+
+  return undefined;
+}

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}`);
+}