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

package/src/get/generator/models/attribute-type-model.ts

@@ -0,0 +1,448 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { Struct } from "./struct";
+import { uppercaseFirst, downcaseFirst } from "../../../util";
+
+export interface AttributeTypeModel {
+  readonly struct?: Struct; // complex object type contained within the type
+  readonly isComplex: boolean; // basically the same as having a struct
+  getStoredClassInitializer(name: string): string; // initializer for keeping class needed to keep track of reference access
+  readonly storedClassType: string; // used mainly by collection types to generate their stored class initializer
+  readonly inputTypeDefinition: string; // this is the type used for inputting values
+  getAttributeAccessFunction(name: string): string; // this is for getting reference for simple types
+  readonly toTerraformFunction: string; // this is for converting input values to Terraform syntax
+  readonly toHclTerraformFunction: string; // this is for converting input values to Terraform syntax in HCL
+  readonly typeModelType: string; // so we don't need to use instanceof
+  readonly hasReferenceClass: boolean; // used to determine if a stored_class getter should be used
+  readonly isTokenizable: boolean; // can the type be represented by a token type
+}
+
+export class SkippedAttributeTypeModel implements AttributeTypeModel {
+  constructor() {}
+
+  get typeModelType() {
+    return "simple";
+  }
+
+  get struct() {
+    return undefined;
+  }
+
+  get isComplex() {
+    return false;
+  }
+
+  getStoredClassInitializer(_name: string) {
+    // not used
+    return "";
+  }
+
+  get storedClassType() {
+    return "any";
+  }
+
+  get inputTypeDefinition() {
+    return "any";
+  }
+
+  getAttributeAccessFunction(name: string) {
+    return `this.interpolationForAttribute('${name}')`;
+  }
+
+  get toTerraformFunction() {
+    return `cdktn.anyToTerraform`;
+  }
+
+  get toHclTerraformFunction() {
+    return `cdktn.anyToHclTerraform`;
+  }
+
+  get hasReferenceClass() {
+    return false;
+  }
+
+  get isTokenizable() {
+    return false;
+  }
+}
+
+export class SimpleAttributeTypeModel implements AttributeTypeModel {
+  constructor(public readonly type: string) {}
+
+  get typeModelType() {
+    return "simple";
+  }
+
+  get struct() {
+    return undefined;
+  }
+
+  get isComplex() {
+    return false;
+  }
+
+  getStoredClassInitializer(_name: string) {
+    // not used
+    return "";
+  }
+
+  get storedClassType() {
+    return this.type;
+  }
+
+  get inputTypeDefinition() {
+    if (this.type === "boolean") {
+      return "boolean | cdktn.IResolvable";
+    } else {
+      return this.type;
+    }
+  }
+
+  getAttributeAccessFunction(name: string) {
+    return `this.get${uppercaseFirst(this.type)}Attribute('${name}')`;
+  }
+
+  get toTerraformFunction() {
+    return `cdktn.${this.type}ToTerraform`;
+  }
+
+  get toHclTerraformFunction() {
+    return `cdktn.${this.type}ToHclTerraform`;
+  }
+
+  get hasReferenceClass() {
+    return false;
+  }
+
+  get isTokenizable() {
+    return true;
+  }
+}
+
+export class StructAttributeTypeModel implements AttributeTypeModel {
+  constructor(public readonly struct: Struct) {}
+
+  get typeModelType() {
+    return "struct";
+  }
+
+  get isComplex() {
+    return true;
+  }
+
+  getStoredClassInitializer(name: string) {
+    return `new ${this.struct.outputReferenceName}(this, "${name}")`;
+  }
+
+  get storedClassType() {
+    return this.struct.name;
+  }
+
+  get inputTypeDefinition() {
+    return this.struct.name;
+  }
+
+  getAttributeAccessFunction(name: string) {
+    // This shouln't actually be called
+    return `this.interpolationForAttribute('${name}')`;
+  }
+
+  get toTerraformFunction() {
+    return `${downcaseFirst(this.struct.name)}ToTerraform`;
+  }
+
+  get toHclTerraformFunction() {
+    return `${downcaseFirst(this.struct.name)}ToHclTerraform`;
+  }
+
+  get hasReferenceClass() {
+    return true;
+  }
+
+  get isTokenizable() {
+    return false;
+  }
+}
+
+export interface CollectionAttributeTypeModel extends AttributeTypeModel {
+  elementType: AttributeTypeModel;
+}
+
+export class ListAttributeTypeModel implements CollectionAttributeTypeModel {
+  constructor(
+    public readonly elementType: AttributeTypeModel,
+    public readonly isSingleItem: boolean,
+    private readonly isBlock: boolean,
+  ) {
+    if (this.struct) {
+      this.struct.isSingleItem = this.isSingleItem || false;
+    }
+  }
+
+  get typeModelType() {
+    return "list";
+  }
+
+  get struct() {
+    return this.elementType.struct;
+  }
+
+  get isComplex() {
+    return this.elementType.isComplex;
+  }
+
+  getStoredClassInitializer(name: string) {
+    if (this.isSingleItem) {
+      return `new ${this.elementType.storedClassType}OutputReference(this, "${name}")`;
+    } else {
+      if (this.isComplex) {
+        return `new ${this.storedClassType}(this, "${name}", false)`;
+      } else {
+        return `new cdktn.${uppercaseFirst(
+          this.storedClassType,
+        )}(this, "${name}", false)`;
+      }
+    }
+  }
+
+  get storedClassType() {
+    return `${this.elementType.storedClassType}List`;
+  }
+
+  get inputTypeDefinition() {
+    if (this.isSingleItem) {
+      return this.elementType.inputTypeDefinition;
+    } else if (this.elementType.storedClassType === "boolean") {
+      return "Array<boolean | cdktn.IResolvable> | cdktn.IResolvable";
+    } else if (this.isComplex) {
+      return `${this.elementType.storedClassType}[] | cdktn.IResolvable`;
+    } else if (this.elementType.typeModelType !== "simple") {
+      return `${this.elementType.inputTypeDefinition}[] | cdktn.IResolvable`;
+    } else {
+      return `${this.elementType.inputTypeDefinition}[]`;
+    }
+  }
+
+  getAttributeAccessFunction(name: string) {
+    switch (this.elementType.storedClassType) {
+      case "string":
+        return `this.getListAttribute('${name}')`;
+      case "number":
+        return `this.getNumberListAttribute('${name}')`;
+    }
+
+    return `this.interpolationForAttribute('${name}')`;
+  }
+
+  get toTerraformFunction() {
+    if (this.isSingleItem) {
+      return this.elementType.toTerraformFunction;
+    }
+    return `cdktn.listMapper(${this.elementType.toTerraformFunction}, ${this.isBlock})`;
+  }
+
+  get toHclTerraformFunction() {
+    if (this.isSingleItem) {
+      return this.elementType.toHclTerraformFunction;
+    }
+
+    return `cdktn.listMapperHcl(${this.elementType.toHclTerraformFunction}, ${this.isBlock})`;
+  }
+
+  get hasReferenceClass() {
+    return this.isSingleItem || this.isComplex;
+  }
+
+  get isTokenizable() {
+    switch (this.elementType.storedClassType) {
+      case "string":
+        return true;
+      case "number":
+        return true;
+      default:
+        return false;
+    }
+  }
+}
+
+export class SetAttributeTypeModel implements CollectionAttributeTypeModel {
+  constructor(
+    public readonly elementType: AttributeTypeModel,
+    public readonly isSingleItem: boolean,
+    private readonly isBlock: boolean,
+  ) {
+    if (this.struct) {
+      this.struct.isSingleItem = this.isSingleItem || false;
+    }
+  }
+
+  get typeModelType() {
+    return "set";
+  }
+
+  get struct() {
+    return this.elementType.struct;
+  }
+
+  get isComplex() {
+    return this.elementType.isComplex;
+  }
+
+  getStoredClassInitializer(name: string) {
+    if (this.isSingleItem) {
+      return `new ${this.elementType.storedClassType}OutputReference(this, "${name}")`;
+    } else {
+      if (this.isComplex) {
+        return `new ${this.storedClassType}(this, "${name}", true)`;
+      } else {
+        return `new cdktn.${uppercaseFirst(
+          this.storedClassType,
+        )}(this, "${name}", true)`;
+      }
+    }
+  }
+
+  get storedClassType() {
+    return `${this.elementType.storedClassType}List`;
+  }
+
+  get inputTypeDefinition() {
+    if (this.isSingleItem) {
+      return this.elementType.inputTypeDefinition;
+    } else if (this.elementType.storedClassType === "boolean") {
+      return "Array<boolean | cdktn.IResolvable> | cdktn.IResolvable";
+    } else if (this.isComplex) {
+      return `${this.elementType.storedClassType}[] | cdktn.IResolvable`;
+    } else if (this.elementType.typeModelType !== "simple") {
+      return `${this.elementType.inputTypeDefinition}[] | cdktn.IResolvable`;
+    } else {
+      return `${this.elementType.inputTypeDefinition}[]`;
+    }
+  }
+
+  getAttributeAccessFunction(name: string) {
+    switch (this.elementType.storedClassType) {
+      case "string":
+        return `cdktn.Fn.tolist(this.getListAttribute('${name}'))`;
+      case "number":
+        return `cdktn.Token.asNumberList(cdktn.Fn.tolist(this.getNumberListAttribute('${name}')))`;
+    }
+
+    // Token.asAny is required because tolist returns an Array encoded token which the listMapper
+    // would try to map over when this is passed to another resource. With Token.asAny() it is left
+    // as is by the listMapper and is later properly resolved to a reference
+    // (this only works in TypeScript currently, same as for referencing lists
+    // [see "interpolationForAttribute(...)" further below])
+    return `cdktn.Token.asAny(cdktn.Fn.tolist(this.interpolationForAttribute('${name}')))`;
+  }
+
+  get toTerraformFunction() {
+    if (this.isSingleItem) {
+      return this.elementType.toTerraformFunction;
+    } else {
+      return `cdktn.listMapper(${this.elementType.toTerraformFunction}, ${this.isBlock})`;
+    }
+  }
+
+  get toHclTerraformFunction() {
+    if (this.isSingleItem) {
+      return this.elementType.toHclTerraformFunction;
+    }
+    return `cdktn.listMapperHcl(${this.elementType.toHclTerraformFunction}, ${this.isBlock})`;
+  }
+
+  get hasReferenceClass() {
+    return this.isSingleItem || this.isComplex;
+  }
+
+  get isTokenizable() {
+    switch (this.elementType.storedClassType) {
+      case "string":
+        return true;
+      case "number":
+        return true;
+      default:
+        return false;
+    }
+  }
+}
+
+export class MapAttributeTypeModel implements CollectionAttributeTypeModel {
+  constructor(public readonly elementType: AttributeTypeModel) {}
+
+  get typeModelType() {
+    return "map";
+  }
+
+  get struct() {
+    return this.elementType.struct;
+  }
+
+  get isComplex() {
+    return this.elementType.isComplex;
+  }
+
+  getStoredClassInitializer(name: string) {
+    if (this.isComplex) {
+      return `new ${this.storedClassType}(this, "${name}")`;
+    } else {
+      return `new cdktn.${uppercaseFirst(
+        this.storedClassType,
+      )}(this, "${name}")`;
+    }
+  }
+
+  get storedClassType() {
+    return `${this.elementType.storedClassType}Map`;
+  }
+
+  get inputTypeDefinition() {
+    // map of booleans has token support, but booleans don't
+    if (this.elementType.storedClassType === "boolean") {
+      return `{ [key: string]: (${this.elementType.storedClassType} | cdktn.IResolvable) }`;
+    } else if (this.isComplex) {
+      return `{ [key: string]: ${this.elementType.storedClassType} } | cdktn.IResolvable`;
+    } else if (this.elementType.typeModelType !== "simple") {
+      return `{ [key: string]: ${this.elementType.inputTypeDefinition} } | cdktn.IResolvable`;
+    } else {
+      return `{ [key: string]: ${this.elementType.storedClassType} }`;
+    }
+  }
+
+  getAttributeAccessFunction(name: string) {
+    if (!this.isComplex && this.elementType.typeModelType !== "simple") {
+      return `this.interpolationForAttribute('${name}')`;
+    }
+
+    return `this.get${uppercaseFirst(
+      this.storedClassType,
+    )}Attribute('${name}')`;
+  }
+
+  get toTerraformFunction() {
+    return `cdktn.hashMapper(${this.elementType.toTerraformFunction})`;
+  }
+
+  get toHclTerraformFunction() {
+    return `cdktn.hashMapperHcl(${this.elementType.toHclTerraformFunction})`;
+  }
+
+  get hasReferenceClass() {
+    return this.isComplex;
+  }
+
+  get isTokenizable() {
+    switch (this.elementType.storedClassType) {
+      case "string":
+        return true;
+      case "number":
+        return true;
+      case "boolean":
+        return true;
+      case "any":
+        return true;
+      default:
+        return false;
+    }
+  }
+}

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

@@ -0,0 +1,7 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+export * from "./attribute-model";
+export * from "./attribute-type-model";
+export * from "./resource-model";
+export * from "./scope";
+export * from "./struct";

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

@@ -0,0 +1,161 @@
+// 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";
+
+// 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;
+  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);
+  }
+
+  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}`;
+    return `${base}/resources/${this.terraformDocName}`;
+  }
+
+  public get isProvider(): boolean {
+    return this.terraformSchemaType === "provider";
+  }
+
+  public get isDataSource(): boolean {
+    return this.terraformSchemaType === "data_source";
+  }
+
+  public get parentClassName(): string {
+    return this.isProvider
+      ? "TerraformProvider"
+      : this.isDataSource
+        ? "TerraformDataSource"
+        : "TerraformResource";
+  }
+
+  public get terraformResourceType(): string {
+    return this.isProvider
+      ? this.terraformProviderName
+      : this.isDataSource
+        ? this.terraformType.replace(/^data_/, "")
+        : 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;
+  }
+}