@cdktn/provider-generator 0.24.0-pre.43 → 0.24.0-pre.47

package/src/get/generator/resource-parser.ts

@@ -0,0 +1,762 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { toCamelCase, toPascalCase, toSnakeCase } from "codemaker";
+import {
+  Attribute,
+  AttributeNestedType,
+  AttributeType,
+  Block,
+  BlockType,
+  ConstructsMakerTarget,
+  isAttributeNestedType,
+  isNestedTypeAttribute,
+  Schema,
+} from "@cdktn/commons";
+import { ProviderName, FQPN, parseFQPN } from "@cdktn/provider-schema";
+import {
+  ResourceModel,
+  AttributeTypeModel,
+  Struct,
+  Scope,
+  AttributeModel,
+  SimpleAttributeTypeModel,
+  ListAttributeTypeModel,
+  SetAttributeTypeModel,
+  MapAttributeTypeModel,
+  StructAttributeTypeModel,
+  SkippedAttributeTypeModel,
+} from "./models";
+import { detectAttributeLoops } from "./loop-detection";
+import { shouldSkipAttribute } from "./skipped-attributes";
+
+// Can't be used in expressions like "export * as <keyword> from ... "
+// filtered from all keywords from: https://github.com/microsoft/TypeScript/blob/503604c884bd0557c851b11b699ef98cdb65b93b/src/compiler/types.ts#L114-L197
+const RESERVED_KEYWORDS_FOR_NAMESPACES = [
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield",
+  "await",
+];
+
+const COLLIDING_NAMESPACE_NAMES = [
+  // e.g. hashicorp/consul – collides with the LICENSE file on case-insensitive filesystems in the Go package (#2627)
+  "license",
+  // collides for Go packages
+  "version",
+];
+
+const isReservedClassOrNamespaceName = (className: string): boolean => {
+  return [
+    "string",
+    "object",
+    "function",
+    ...RESERVED_KEYWORDS_FOR_NAMESPACES,
+    ...COLLIDING_NAMESPACE_NAMES,
+  ].includes(className.toLowerCase());
+};
+
+const isReservedStructClassName = (className: string): boolean => {
+  return className.toLowerCase().endsWith("list");
+};
+
+const getFileName = (provider: ProviderName, baseName: string): string => {
+  if (baseName === "index") {
+    return "index-resource/index.ts";
+  }
+
+  if (baseName === `${provider}_provider`) {
+    return "provider/index.ts";
+  }
+
+  return `${toSnakeCase(baseName).replace(/_/g, "-")}/index.ts`;
+};
+
+export function sanitizeClassOrNamespaceName(
+  baseName: string,
+  isProvider = false,
+) {
+  const resourceIsNamedProvider = !isProvider && baseName === "provider";
+
+  if (isReservedClassOrNamespaceName(baseName) || resourceIsNamedProvider) {
+    return `${baseName}_resource`;
+  } else {
+    return baseName;
+  }
+}
+
+/**
+ * Remove attributes that may conflict after being snake cased
+ * Example: oci_core_ipsec_connection_tunnel_management (hashicorp/oci@=5.21.0) has bgp_ipv6_state and bgp_ipv6state
+ * (which both result in "bgpIpv6State" when camel-cased, with the second one being deprecated: true)
+ * As we currently don't handle any deprecated ones at all, we'll just delete one of the two attributes for now
+ * @param attributes
+ */
+function deduplicateAttributesWithSameName(
+  attributes: AttributeModel[],
+): AttributeModel[] {
+  return attributes.filter((attr, idx) => {
+    const hasOtherWithSameName = attributes
+      .slice(idx + 1) // only search after the index of the current attribute to avoid deleting both
+      .some((other) => other.name === attr.name && other !== attr);
+    return !hasOtherWithSameName;
+  });
+}
+
+class Parser {
+  private structs = new Array<Struct>();
+
+  constructor(
+    private classNames: string[],
+    private usedBaseNames: Map<string, string>,
+  ) {}
+
+  private uniqueClassName(className: string): string {
+    if (this.classNames.includes(className)) {
+      className = `${className}A`;
+    }
+    this.classNames.push(className);
+    return className;
+  }
+
+  /**
+   * Ensure base names are unique case-insensitively.
+   *
+   * Affected languages:
+   * - Go: JSII-generated Go package names are fully lowercased, so
+   *   `load-balancer-backendset` and `load-balancer-backend-set` both
+   *   become package `loadbalancerbackendset`, causing a hard build failure:
+   *   "case-insensitive file name collision".
+   * - C#: JSII generates PascalCase directories like
+   *   `LoadBalancerBackendset/` and `LoadBalancerBackendSet/` which the C#
+   *   compiler treats case-insensitively, causing CS2002 and CS0234 errors.
+   */
+  private uniqueBaseName(baseName: string): string {
+    const pascalName = toPascalCase(baseName);
+    const key = pascalName.toLowerCase();
+    const existing = this.usedBaseNames.get(key);
+
+    if (existing !== undefined && existing !== pascalName) {
+      baseName = `${baseName}A`;
+      return this.uniqueBaseName(baseName);
+    }
+
+    this.usedBaseNames.set(key, pascalName);
+    return baseName;
+  }
+
+  public resourceFrom(
+    fqpn: FQPN,
+    type: string,
+    schema: Schema,
+    terraformSchemaType: string,
+    constraint?: ConstructsMakerTarget,
+  ): ResourceModel {
+    let baseName = type;
+
+    const providerNameFromConstraint = constraint
+      ? (constraint.name as ProviderName)
+      : undefined;
+    const providerNameFromFQPN = parseFQPN(fqpn).name;
+
+    if (baseName.startsWith(`${providerNameFromFQPN}_`)) {
+      baseName = baseName.substr(providerNameFromFQPN.length + 1);
+    }
+
+    const providerName = providerNameFromConstraint
+      ? providerNameFromConstraint
+      : providerNameFromFQPN;
+
+    const isProvider = terraformSchemaType === "provider";
+    if (isProvider) {
+      baseName = `${providerName}_${baseName}`;
+      if (!("attributes" in schema.block)) {
+        schema.block = {
+          attributes: {},
+          block_types: (schema.block as Block).block_types || {},
+        };
+      }
+      // somehow missing from provider schema
+      schema.block.attributes["alias"] = {
+        type: "string",
+        description: "Alias name",
+        optional: true,
+        computed: false,
+      };
+    }
+
+    baseName = sanitizeClassOrNamespaceName(baseName, isProvider);
+    baseName = this.uniqueBaseName(baseName);
+
+    const className = this.uniqueClassName(toPascalCase(baseName));
+    // avoid naming collision - see https://github.com/hashicorp/terraform-cdk/issues/299
+    const configStructName = this.uniqueClassName(`${className}Config`);
+    const fileName = getFileName(providerName, baseName);
+
+    const filePath = `providers/${toSnakeCase(providerName)}/${fileName}`;
+    let attributes = this.renderAttributesForBlock(
+      new Scope({
+        name: baseName,
+        isProvider,
+        parent: isProvider
+          ? undefined
+          : new Scope({ name: providerName, isProvider: true }),
+      }),
+      schema.block,
+    );
+
+    function getStructAttribute(
+      attributes: AttributeModel[],
+      path: string,
+    ): AttributeModel {
+      const [first, ...rest] = path.split(".");
+      const attribute = attributes.find((att) => {
+        return att.terraformName === first;
+      });
+      if (!attribute)
+        throw new Error(
+          `Expected to find recursive attribute at path: ${path}`,
+        );
+      if (!attribute.type.struct)
+        throw new Error(
+          `Expected to find struct type attribute at path: ${path} but got ${attribute.type.storedClassType}`,
+        );
+      if (rest.length === 0) return attribute;
+      return getStructAttribute(
+        attribute.type.struct.attributes,
+        rest.join("."),
+      );
+    }
+
+    // Introduce recursion for some attributes
+    const recursiveAttributePaths = detectAttributeLoops(attributes);
+
+    Object.entries(recursiveAttributePaths).forEach(
+      ([attributePath, structPath]) => {
+        // TODO: build this to be a bit more defensive (e.g. remove ! operator)
+        const recursionTargetStructAttribute = getStructAttribute(
+          attributes,
+          structPath,
+        );
+        const parts = attributePath.split(".");
+        const attributeName = parts.pop();
+        const parentAttribute = getStructAttribute(attributes, parts.join("."));
+        const indexToReplace =
+          parentAttribute.type.struct!.attributes.findIndex(
+            (att) => att.terraformName === attributeName,
+          );
+        if (indexToReplace === -1)
+          throw new Error("Can't find attribute at path " + attributePath);
+        const previousAttribute =
+          parentAttribute.type.struct!.attributes[indexToReplace];
+
+        parentAttribute.type.struct!.attributes[indexToReplace] =
+          recursionTargetStructAttribute; // introduce recursion
+
+        // ugly, pls c̶a̶l̶l̶ refactor me maybe
+        // we store all structs in this.structs – now we need to dispose all structs that are part of previousAttribute
+        const disposeStructs = (attr: AttributeModel) => {
+          if (attr.type.struct) {
+            attr.type.struct.attributes.forEach(disposeStructs);
+            this.structs = this.structs.filter((s) => s !== attr.type.struct);
+          }
+        };
+
+        disposeStructs(previousAttribute);
+      },
+    );
+
+    attributes = deduplicateAttributesWithSameName(attributes);
+
+    const resourceModel = new ResourceModel({
+      terraformType: type,
+      baseName,
+      fileName,
+      filePath,
+      className,
+      schema,
+      fqpn,
+      attributes,
+      terraformSchemaType,
+      structs: this.structs,
+      configStructName,
+    });
+
+    return resourceModel;
+  }
+
+  private renderAttributeType(
+    scope: Scope[],
+    attributeType: AttributeType | AttributeNestedType,
+    parentKind?: string,
+  ): AttributeTypeModel {
+    const parent = scope[scope.length - 1];
+    if (shouldSkipAttribute(parent.baseName)) {
+      return new MapAttributeTypeModel(new SimpleAttributeTypeModel("any"));
+    }
+
+    if (typeof attributeType === "string") {
+      switch (attributeType) {
+        case "bool":
+          return new SimpleAttributeTypeModel("boolean");
+        case "string":
+          return new SimpleAttributeTypeModel("string");
+        case "number":
+          return new SimpleAttributeTypeModel("number");
+        case "dynamic":
+          return new MapAttributeTypeModel(new SimpleAttributeTypeModel("any"));
+        default:
+          throw new Error(`invalid primitive type ${attributeType}`);
+      }
+    }
+
+    if (Array.isArray(attributeType)) {
+      if (attributeType.length !== 2) {
+        throw new Error(`unexpected array`);
+      }
+
+      const [kind, type] = attributeType;
+
+      if (kind === "set" || kind === "list") {
+        const elementType = this.renderAttributeType(
+          scope,
+          type as AttributeType,
+          [kind, parentKind].join(""),
+        );
+        return kind === "list"
+          ? new ListAttributeTypeModel(elementType, false, false)
+          : new SetAttributeTypeModel(elementType, false, false);
+      }
+
+      if (kind === "map") {
+        const valueType = this.renderAttributeType(
+          scope,
+          type as AttributeType,
+          [kind, parentKind].join(""),
+        );
+        return new MapAttributeTypeModel(valueType);
+      }
+
+      if (kind === "object") {
+        const objAttributes = type as { [name: string]: AttributeType };
+        const attributes: { [name: string]: Attribute } = {};
+        for (const [name, type] of Object.entries(objAttributes)) {
+          attributes[name] = { type };
+        }
+        const struct = this.addAnonymousStruct(
+          scope,
+          attributes,
+          parentKind ?? kind,
+        );
+        return new StructAttributeTypeModel(struct);
+      }
+    }
+
+    if (isAttributeNestedType(attributeType)) {
+      let struct = undefined;
+      let typeModel = undefined;
+      switch (attributeType.nesting_mode) {
+        case "list":
+          struct = this.addAnonymousStruct(
+            scope,
+            attributeType.attributes,
+            attributeType.nesting_mode,
+          );
+          typeModel = new ListAttributeTypeModel(
+            new StructAttributeTypeModel(struct),
+            false,
+            false,
+          );
+          break;
+        case "set":
+          struct = this.addAnonymousStruct(
+            scope,
+            attributeType.attributes,
+            attributeType.nesting_mode,
+          );
+          typeModel = new SetAttributeTypeModel(
+            new StructAttributeTypeModel(struct),
+            false,
+            false,
+          );
+          break;
+        case "map":
+          struct = this.addAnonymousStruct(
+            scope,
+            attributeType.attributes,
+            attributeType.nesting_mode,
+          );
+          typeModel = new MapAttributeTypeModel(
+            new StructAttributeTypeModel(struct),
+          );
+          break;
+        case "single":
+          struct = this.addAnonymousStruct(
+            scope,
+            attributeType.attributes,
+            attributeType.nesting_mode,
+          );
+          typeModel = new StructAttributeTypeModel(struct);
+          break;
+        default: {
+          throw new Error(
+            `nested_type with nesting_mode "${
+              attributeType.nesting_mode
+            }" not supported (attribute scope: ${scope
+              .map((s) => s.fullName)
+              .join(",")}`,
+          );
+        }
+      }
+      return typeModel;
+    }
+
+    throw new Error(`unknown type ${JSON.stringify(attributeType)}`);
+  }
+
+  public renderAttributesForBlock(parentType: Scope, block: Block) {
+    const attributes = new Array<AttributeModel>();
+
+    for (const [terraformAttributeName, att] of Object.entries(
+      block.attributes || {},
+    )) {
+      let type: AttributeTypeModel;
+      let forcePlainGetterType = false;
+      if (shouldSkipAttribute(parentType.fullName(terraformAttributeName))) {
+        type = new SkippedAttributeTypeModel();
+        forcePlainGetterType = true;
+      } else {
+        type = this.renderAttributeType(
+          [
+            parentType,
+            new Scope({
+              name: terraformAttributeName,
+              parent: parentType,
+              isProvider: parentType.isProvider,
+              isComputed: !!att.computed,
+              isOptional: !!att.optional,
+              isRequired: !!att.required,
+              isNestedType: isNestedTypeAttribute(att),
+            }),
+          ],
+          att.type || att.nested_type,
+        );
+      }
+
+      const name = toCamelCase(terraformAttributeName);
+
+      attributes.push(
+        new AttributeModel({
+          terraformFullName: parentType.fullName(terraformAttributeName),
+          description: att.description,
+          name,
+          storageName: `_${name}`,
+          computed: !!att.computed,
+          optional: !!att.optional,
+          terraformName: terraformAttributeName,
+          type,
+          provider: parentType.isProvider,
+          required: !!att.required,
+          forcePlainGetterType,
+        }),
+      );
+    }
+
+    for (const [blockTypeName, blockType] of Object.entries(
+      block.block_types || {},
+    )) {
+      if (shouldSkipAttribute(parentType.fullName(blockTypeName))) {
+        const name = toCamelCase(blockTypeName);
+        const parent = new Scope({
+          name: blockTypeName,
+          parent: parentType,
+          isProvider: parentType.isProvider,
+        });
+        attributes.push(
+          new AttributeModel({
+            name,
+            terraformName: blockTypeName,
+            terraformFullName: parent.fullName(blockTypeName),
+            type: new SkippedAttributeTypeModel(),
+            description: `${blockTypeName} block`,
+            storageName: `_${name}`,
+            optional: true,
+            computed: false,
+            provider: parentType.isProvider,
+            required: false,
+          }),
+        );
+        continue;
+      }
+      // create a struct for this block
+      let blockAttributes = this.renderAttributesForBlock(
+        new Scope({
+          name: `${parentType.name}_${blockTypeName}`,
+          parent: parentType,
+          isProvider: parentType.isProvider,
+          inBlockType: true,
+        }),
+        blockType.block,
+      );
+
+      blockAttributes = deduplicateAttributesWithSameName(blockAttributes);
+
+      const blockStruct = this.addStruct(
+        [
+          parentType,
+          new Scope({
+            name: blockTypeName,
+            parent: parentType,
+            isProvider: parentType.isProvider,
+          }),
+        ],
+        blockAttributes,
+        blockType.nesting_mode,
+        (blockType.nesting_mode === "list" ||
+          blockType.nesting_mode === "set") &&
+          blockType.max_items === 1,
+      );
+
+      // define the attribute
+      attributes.push(
+        attributeForBlockType(
+          blockTypeName,
+          blockType,
+          blockStruct,
+          parentType.isProvider,
+          parentType,
+        ),
+      );
+    }
+
+    return attributes;
+
+    function attributeForBlockType(
+      terraformName: string,
+      blockType: BlockType,
+      struct: Struct,
+      isProvider: boolean,
+      parent: Scope,
+    ): AttributeModel {
+      const name = toCamelCase(terraformName);
+      let optional: boolean;
+      let required: boolean;
+
+      switch (blockType.nesting_mode) {
+        case "single":
+          optional = !struct.attributes.some((x) => !x.optional);
+          required = !struct.attributes.some((x) => !x.required);
+
+          // This is for bug #3570 as both optional and required evaluate to false under some circumstances
+          // (this then causes the computed block to not be part of assignableAttributes and thus skipped in the generated code)
+          // Hence: If both optional and required are false, set optional to true IF at least one
+          // attribute in the block has optional = true or required = true, as this would mean that at least something can be set
+          // and the block is not all computed.
+          if (!optional && !required) {
+            optional = struct.attributes.some((x) => x.optional || x.required);
+          }
+
+          return new AttributeModel({
+            name,
+            terraformName,
+            terraformFullName: parent.fullName(terraformName),
+            type: new StructAttributeTypeModel(struct),
+            description: `${terraformName} block`,
+            storageName: `_${name}`,
+            optional,
+            computed: false,
+            provider: isProvider,
+            required,
+          });
+
+        case "map":
+          return new AttributeModel({
+            name,
+            terraformName,
+            terraformFullName: parent.fullName(terraformName),
+            type: new MapAttributeTypeModel(
+              new StructAttributeTypeModel(struct),
+            ),
+            description: `${terraformName} block`,
+            storageName: `_${name}`,
+            optional: false,
+            computed: false,
+            provider: isProvider,
+            required: false,
+          });
+
+        case "list":
+        case "set":
+          optional =
+            blockType.min_items === undefined ? true : blockType.min_items < 1;
+          required =
+            blockType.min_items === undefined ? false : blockType.min_items > 0;
+          return new AttributeModel({
+            name,
+            terraformName: terraformName,
+            terraformFullName: parent.fullName(terraformName),
+            type:
+              blockType.nesting_mode === "list"
+                ? new ListAttributeTypeModel(
+                    new StructAttributeTypeModel(struct),
+                    blockType.max_items === 1,
+                    true,
+                  )
+                : new SetAttributeTypeModel(
+                    new StructAttributeTypeModel(struct),
+                    blockType.max_items === 1,
+                    true,
+                  ),
+            description: `${terraformName} block`,
+            storageName: `_${name}`,
+            optional,
+            computed: false,
+            provider: isProvider,
+            required,
+          });
+      }
+    }
+  }
+  private addAnonymousStruct(
+    scope: Scope[],
+    attrs: { [name: string]: Attribute } | undefined,
+    nesting_mode: string,
+  ) {
+    let attributes = new Array<AttributeModel>();
+    const parent = scope[scope.length - 1];
+    if (attrs) {
+      for (const [terraformName, att] of Object.entries(attrs || {})) {
+        // nested types support computed, optional and required on attribute level
+        // if parent is computed, child always is computed as well
+        const computed =
+          !!parent.isComputed || (parent.isNestedType && !!att.computed);
+        const optional = parent.isNestedType
+          ? !!att.optional
+          : !!parent.isOptional;
+        const required = parent.isNestedType
+          ? !!att.required
+          : !!parent.isRequired;
+        const name = toCamelCase(terraformName);
+        const type = this.renderAttributeType(
+          [
+            ...scope,
+            new Scope({
+              name: terraformName,
+              parent,
+              isProvider: parent.isProvider,
+              isComputed: computed,
+              isOptional: optional,
+              isRequired: required,
+              isNestedType: parent.isNestedType,
+            }),
+          ],
+          att.type || att.nested_type,
+        );
+        attributes.push(
+          new AttributeModel({
+            name,
+            storageName: `_${name}`,
+            computed: computed,
+            description: att.description,
+            optional: optional,
+            terraformName,
+            terraformFullName: parent.fullName(terraformName),
+            type,
+            provider: parent.isProvider,
+            required: required,
+          }),
+        );
+      }
+    }
+
+    attributes = deduplicateAttributesWithSameName(attributes);
+
+    return this.addStruct(scope, attributes, nesting_mode);
+  }
+
+  private addStruct(
+    scope: Scope[],
+    attributes: AttributeModel[],
+    nesting_mode: string,
+    isSingleItem = false,
+  ) {
+    const possibleName = toPascalCase(
+      scope.map((x) => toSnakeCase(x.name)).join("_"),
+    );
+    const name = this.uniqueClassName(
+      isReservedStructClassName(possibleName)
+        ? `${possibleName}Struct`
+        : possibleName,
+    );
+
+    const parent = scope[scope.length - 1];
+    // blockType.nesting_mode => list/set & blockType.max_items === 1,
+    const isClass = (parent.isComputed && !parent.isOptional) || isSingleItem;
+    const isAnonymous = true;
+    const s = new Struct(
+      name,
+      attributes,
+      isClass,
+      isAnonymous,
+      isSingleItem,
+      nesting_mode,
+    );
+    this.structs.push(s);
+    return s;
+  }
+}
+
+export class ResourceParser {
+  private uniqueClassnames: string[] = [];
+  private uniqueBaseNames: Map<string, string> = new Map();
+  private resources: Record<string, ResourceModel> = {};
+
+  public parse(
+    fqpn: FQPN,
+    type: string,
+    schema: Schema,
+    terraformType: string,
+    constraint?: ConstructsMakerTarget,
+  ): ResourceModel {
+    if (this.resources[type]) {
+      return this.resources[type];
+    }
+
+    const parser = new Parser(this.uniqueClassnames, this.uniqueBaseNames);
+    const resource = parser.resourceFrom(
+      fqpn,
+      type,
+      schema,
+      terraformType,
+      constraint,
+    );
+    this.resources[type] = resource;
+    return resource;
+  }
+
+  // Used by convert to determine the right name for a class
+  public getClassNameForResource(terraformType: string) {
+    const resource = this.resources[terraformType];
+    return resource ? resource.className : "";
+  }
+
+  // Used by convert to determine the right name for a namespace
+  public getNamespaceNameForResource(terraformType: string) {
+    // Special case external provider since the name of resource doesn't have a prefix
+    if (terraformType === "data_external_") {
+      terraformType = "data_external";
+    }
+
+    const resource = this.resources[terraformType];
+    if (!resource) {
+      return "";
+    }
+    const folder = `providers/${resource.provider}`;
+    return resource.filePath.replace(`${folder}/`, "").replace("/index.ts", "");
+  }
+}