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

package/src/get/generator/loop-detection.ts

@@ -0,0 +1,81 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { AttributeModel } from "./models/attribute-model";
+
+type AttributeIdentifier = [string, Set<string>];
+const equalAttributeIdentifiers = (
+  x: AttributeIdentifier,
+  y: AttributeIdentifier,
+) =>
+  x[0] === y[0] &&
+  x[1].size === y[1].size &&
+  [...x[1]].every((x) => y[1].has(x));
+
+function typeStructure(model: AttributeModel) {
+  if (!model.type.isComplex) {
+    return model.type.storedClassType;
+  }
+
+  return `<complex:{${model.type.struct?.attributes
+    .map((att) => att.name)
+    .sort()}}${model.type.typeModelType}>`;
+}
+
+function getAttributeIdentifier(model: AttributeModel): AttributeIdentifier {
+  return [
+    model.terraformName,
+    new Set(
+      model.type.struct!.attributes.map((a) => `${a.name}:${typeStructure(a)}`),
+    ),
+  ];
+}
+
+/**
+ * Detects recursive attribute schemas and returns an Object
+ * describing what property should be linking to which class
+ */
+export function detectAttributeLoops(attributes: AttributeModel[]): {
+  [loopEntrypoint: string]: string; // attribute path to be replaced -> attribute path of the type to replace with
+} {
+  // We aproximate a class as a set of attributes names
+  // This is not a perfect approximation, but it's good enough for our purposes
+  const redirects: Record<string, string> = {};
+
+  function depthFirstSearch(
+    attribute: AttributeModel,
+    path: string[] = [],
+    knownStructs: { [attributePath: string]: AttributeIdentifier } = {},
+  ) {
+    const name = attribute.terraformName;
+    const struct = attribute.type.struct;
+    if (!struct) {
+      return;
+    }
+
+    const structIdentifier = getAttributeIdentifier(attribute);
+    // Detect if we visited this already
+    const visited = Object.entries(knownStructs).find(([, attrIdentifier]) =>
+      equalAttributeIdentifiers(structIdentifier, attrIdentifier),
+    );
+
+    if (visited) {
+      // We have a loop, we don't need to search deeper
+      const toBeReplacedWith = visited[0];
+      const toReplace = [...path, name].join(".");
+      redirects[toReplace] = toBeReplacedWith;
+    } else {
+      // Search deeper
+      struct.attributes.forEach((a) =>
+        depthFirstSearch(a, [...path, name], {
+          ...knownStructs,
+          // We haven't visited this yet, add it to the list of known structs
+          [[...path, name].join(".")]: structIdentifier,
+        }),
+      );
+    }
+  }
+
+  attributes.forEach((attr) => depthFirstSearch(attr));
+
+  return redirects;
+}

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

@@ -0,0 +1,273 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { logger } from "@cdktn/commons";
+import {
+  AttributeTypeModel,
+  CollectionAttributeTypeModel,
+} from "./attribute-type-model";
+
+export type GetterType =
+  | { _type: "plain" }
+  | {
+      _type: "args";
+      args: string;
+      returnType?: string;
+      returnStatement: string;
+    }
+  | {
+      _type: "stored_class";
+    };
+
+export type SetterType =
+  | { _type: "none" }
+  | { _type: "set"; type: string }
+  | { _type: "put"; type: string }
+  | { _type: "stored_class"; type: string };
+
+export interface AttributeModelOptions {
+  storageName: string; // private property
+  name: string;
+  type: AttributeTypeModel;
+  optional: boolean;
+  computed: boolean;
+  terraformName: string;
+  terraformFullName: string;
+  description?: string;
+  getAttCall?: string;
+  provider: boolean;
+  required: boolean;
+  forcePlainGetterType?: boolean; // used for skipping attribute type attributes that use the SkippedAttributeTypeModel which returns an interpolation and has no stored type
+  isWriteOnly?: boolean; // provider protocol write-only attribute: providers never persist/return its value, see RFC-04
+}
+
+export function escapeAttributeName(name: string) {
+  // `self` and `build` doesn't work in as property name in Python
+  if (name === "self" || name === "build") return `${name}Attribute`;
+  // jsii can't handle `getFoo` properties, since it's incompatible with Java
+  if (name.match(/^get[A-Za-z]+/)) return name.replace("get", "fetch");
+  // `equals` is a prohibited name in jsii
+  if (name === "equals") return "equalTo";
+  // `node` is already used by the Constructs base class
+  if (name === "node") return "nodeAttribute";
+  // `System` shadows built-in types in CSharp (see #1420)
+  if (name === "system") return "systemAttribute";
+  // `tfResourceType` is already used by resources to distinguish between different resource types
+  if (name === "tfResourceType") return `${name}Attribute`;
+  // `importFrom` has potential for common name collision with providers
+  if (name === "importFrom") return `${name}Attribute`;
+  // `move` could have common name collision with providers
+  if (name === "moveTo") return `${name}Attribute`;
+  // `software` attribute can be confused with the JSII Java runtime package (see #3115)
+  if (name === "software") return `${name}Attribute`;
+  return name;
+}
+
+export class AttributeModel {
+  public storageName: string; // private property
+  private _name: string;
+  public type: AttributeTypeModel;
+  public optional: boolean;
+  public computed: boolean;
+  public terraformName: string;
+  public terraformFullName: string;
+  private _description?: string;
+  public provider: boolean;
+  public required: boolean;
+  public forcePlainGetterType?: boolean;
+  private loggedStoredClassUnavailable = false;
+  public isWriteOnly: boolean;
+
+  constructor(options: AttributeModelOptions) {
+    this.storageName = options.storageName;
+    this._name = options.name;
+    this.type = options.type;
+    this.optional = options.optional;
+    this.computed = options.computed;
+    this.terraformName = options.terraformName;
+    this.terraformFullName = options.terraformFullName;
+    this._description = options.description;
+    this.provider = options.provider;
+    this.required = options.required;
+    this.forcePlainGetterType = options.forcePlainGetterType;
+    this.isWriteOnly = !!options.isWriteOnly;
+  }
+
+  public get typeDefinition() {
+    const optional = this.optional ? "?" : "";
+    return `${this.name}${optional}: ${this.type.inputTypeDefinition}`;
+  }
+
+  public get isAssignable() {
+    return this.required || this.optional;
+  }
+
+  public get isOptional(): boolean {
+    return this.optional;
+  }
+
+  public get isRequired(): boolean {
+    return this.required;
+  }
+
+  public get isProvider(): boolean {
+    return this.provider;
+  }
+
+  public get getterType(): GetterType {
+    let getterType: GetterType = { _type: "plain" };
+
+    if (this.forcePlainGetterType) {
+      return getterType;
+    }
+
+    if (this.isProvider) {
+      return getterType;
+    }
+
+    if (this.type.hasReferenceClass) {
+      getterType = {
+        _type: "stored_class",
+      };
+    } else if (
+      this.computed &&
+      !this.isAssignable &&
+      (!this.type.isTokenizable || this.type.typeModelType === "map")
+    ) {
+      if (this.type.isStoredClassUnavailable) {
+        // Defensive fallback: neither the composed stored class name (e.g.
+        // "StringListMapMap") nor a collapsed nearest-Any wrapper (e.g. "AnyMapMap")
+        // exists in the core cdktn package for this type. This should be rare - see
+        // resolveStoredClassName in supported-stored-classes.ts - so log it loudly to
+        // make regressions in the collapse logic visible.
+        if (!this.loggedStoredClassUnavailable) {
+          this.loggedStoredClassUnavailable = true;
+          logger.debug(
+            `No stored class (not even a collapsed nearest-Any wrapper) is available for computed attribute "${this.terraformFullName}" (composed storedClassType: "${this.type.storedClassType}"). Falling back to a plain, untyped getter.`,
+          );
+        }
+      } else {
+        getterType = {
+          _type: "stored_class",
+        };
+      }
+    }
+
+    return getterType;
+  }
+
+  // Reports whether this attribute's getter sits at a "stored class boundary" that is
+  // worth documenting: "collapsed" when a deeper, unsupported nesting was collapsed into
+  // the nearest typed "Any"-wrapper (e.g. "AnyMapMap"), or "fallback" when no stored class
+  // at all is available and a plain, untyped getter is emitted instead. Mirrors the same
+  // condition tree as getterType above, so it only ever reports a boundary for attributes
+  // that actually went through that computed-collection branch - plain getters for
+  // ordinary tokenizable types (e.g. list(string)) are never flagged.
+  public get storedClassBoundaryKind(): "collapsed" | "fallback" | undefined {
+    if (this.forcePlainGetterType || this.isProvider) {
+      return undefined;
+    }
+
+    if (this.type.hasReferenceClass) {
+      return undefined;
+    }
+
+    if (
+      this.computed &&
+      !this.isAssignable &&
+      (!this.type.isTokenizable || this.type.typeModelType === "map")
+    ) {
+      if (this.type.isStoredClassUnavailable) {
+        return "fallback";
+      }
+
+      const resolvedStoredClass = (this.type as CollectionAttributeTypeModel)
+        .resolvedStoredClass;
+      if (resolvedStoredClass?.collapsed) {
+        return "collapsed";
+      }
+    }
+
+    return undefined;
+  }
+
+  public get isStored(): boolean {
+    return this.isAssignable;
+  }
+
+  public get setterType(): SetterType {
+    if (!this.isStored) {
+      return { _type: "none" };
+    }
+
+    if (this.getterType._type === "stored_class") {
+      return {
+        _type: "stored_class",
+        type: this.type.inputTypeDefinition,
+      };
+    }
+
+    return {
+      _type: "set",
+      type: `${this.type.inputTypeDefinition}${
+        this.isProvider ? " | undefined" : ""
+      }`,
+    };
+  }
+
+  public get name(): string {
+    return AttributeModel.escapeName(this._name);
+  }
+
+  public static escapeName(name: string): string {
+    return escapeAttributeName(name);
+  }
+
+  public get description(): string | undefined {
+    return this._description?.replace(/'''/gi, "```");
+  }
+
+  public getReferencedTypes(isConfigStruct: boolean): string[] | undefined {
+    const attTypeStruct = this.type.struct;
+    if (!attTypeStruct) {
+      return undefined;
+    }
+
+    const types: string[] = [];
+
+    if (this.isAssignable) {
+      types.push(attTypeStruct.name);
+      types.push(attTypeStruct.mapperName);
+      types.push(attTypeStruct.hclMapperName);
+    }
+
+    if (
+      !attTypeStruct.isSingleItem &&
+      (attTypeStruct.nestingMode === "list" ||
+        attTypeStruct.nestingMode === "set")
+    ) {
+      types.push(attTypeStruct.listName);
+    } else if (attTypeStruct.nestingMode === "map") {
+      types.push(attTypeStruct.mapName);
+    } else if (attTypeStruct.nestingMode === "maplist") {
+      types.push(attTypeStruct.mapListName);
+    } else if (attTypeStruct.nestingMode === "mapset") {
+      types.push(attTypeStruct.mapListName);
+    } else if (attTypeStruct.nestingMode === "listmap") {
+      types.push(attTypeStruct.listMapName);
+    } else if (attTypeStruct.nestingMode === "setmap") {
+      types.push(attTypeStruct.listMapName);
+    } else if (
+      attTypeStruct.nestingMode === "listlist" ||
+      attTypeStruct.nestingMode === "listset" ||
+      attTypeStruct.nestingMode === "setlist" ||
+      attTypeStruct.nestingMode == "setset"
+    ) {
+      types.push(attTypeStruct.listListName);
+    } else if (!isConfigStruct) {
+      types.push(attTypeStruct.outputReferenceName);
+    }
+    // other types of nested collections aren't supported
+
+    return types;
+  }
+}