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

package/src/get/generator/emitter/attributes-emitter.ts

@@ -0,0 +1,225 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { CodeMaker } from "codemaker";
+import { AttributeModel } from "../models";
+import { CUSTOM_DEFAULTS } from "../custom-defaults";
+
+function titleCase(value: string) {
+  return value[0].toUpperCase() + value.slice(1);
+}
+
+export class AttributesEmitter {
+  constructor(private code: CodeMaker) {}
+
+  public emit(att: AttributeModel, escapeReset: boolean, escapeInput: boolean) {
+    this.code.line();
+    this.code.line(
+      `// ${att.terraformName} - computed: ${att.computed}, optional: ${att.isOptional}, required: ${att.isRequired}`,
+    );
+
+    const isStored = att.isStored;
+    const hasResetMethod =
+      isStored && !att.isRequired && att.setterType._type !== "none";
+    const hasInputMethod = isStored && att.setterType._type !== "none";
+
+    const getterType = att.getterType;
+
+    if (getterType._type === "stored_class") {
+      this.code.line(
+        `private ${att.storageName} = ${this.storedClassInit(att)};`,
+      );
+    } else if (isStored) {
+      this.code.line(
+        `private ${att.storageName}?: ${att.type.inputTypeDefinition}; `,
+      );
+    }
+
+    switch (getterType._type) {
+      case "plain":
+        this.code.openBlock(`public get ${att.name}()`);
+        this.code.line(`return ${this.determineGetAttCall(att)};`);
+        this.code.closeBlock();
+        break;
+
+      case "args":
+        this.code.openBlock(
+          `public ${att.name}(${getterType.args})${
+            getterType.returnType ? ": " + getterType.returnType : ""
+          }`,
+        );
+        this.code.line(`return ${getterType.returnStatement};`);
+        this.code.closeBlock();
+        break;
+
+      case "stored_class":
+        this.code.openBlock(`public get ${att.name}()`);
+        this.code.line(`return this.${att.storageName};`);
+        this.code.closeBlock();
+        break;
+    }
+
+    const setterType = att.setterType;
+
+    switch (setterType._type) {
+      case "set":
+        this.code.openBlock(
+          `public set ${att.name}(value: ${setterType.type})`,
+        );
+        this.code.line(`this.${att.storageName} = value;`);
+        this.code.closeBlock();
+        break;
+
+      case "put":
+        this.code.openBlock(
+          `public put${titleCase(att.name)}(value: ${setterType.type})`,
+        );
+        this.code.line(`this.${att.storageName} = value;`);
+        this.code.closeBlock();
+        break;
+
+      case "stored_class":
+        this.code.openBlock(
+          `public put${titleCase(att.name)}(value: ${setterType.type})`,
+        );
+        this.code.line(`this.${att.storageName}.internalValue = value;`);
+        this.code.closeBlock();
+        break;
+    }
+
+    if (hasResetMethod) {
+      this.code.openBlock(
+        `public ${this.getResetName(att.name, escapeReset)}()`,
+      );
+
+      if (setterType._type === "stored_class") {
+        this.code.line(`this.${att.storageName}.internalValue = undefined;`);
+      } else {
+        this.code.line(`this.${att.storageName} = undefined;`);
+      }
+
+      this.code.closeBlock();
+    }
+
+    if (hasInputMethod) {
+      this.code.line(`// Temporarily expose input value. Use with caution.`);
+      this.code.openBlock(
+        `public get ${this.getInputName(att, escapeInput)}()`,
+      );
+
+      if (setterType._type === "stored_class") {
+        this.code.line(`return this.${att.storageName}.internalValue;`);
+      } else {
+        this.code.line(`return this.${att.storageName};`);
+      }
+
+      this.code.closeBlock();
+    }
+  }
+
+  // returns an invocation of a stored class, e.g. 'new DeplotmentMetadataOutputReference(this, "metadata")'
+  private storedClassInit(att: AttributeModel) {
+    return att.type.getStoredClassInitializer(att.terraformName);
+  }
+
+  public determineGetAttCall(att: AttributeModel): string {
+    if (att.isProvider) {
+      return `this.${att.storageName}`;
+    }
+
+    return att.type.getAttributeAccessFunction(att.terraformName);
+  }
+
+  public needsInputEscape(
+    att: AttributeModel,
+    attributes: AttributeModel[],
+  ): boolean {
+    return (
+      attributes.find((a) =>
+        a.terraformName.match(`^${att.terraformName}_input$`),
+      ) instanceof AttributeModel
+    );
+  }
+
+  public getInputName(att: AttributeModel, escape: boolean) {
+    if (escape) {
+      return `${att.name}TfInput`;
+    } else {
+      return `${att.name}Input`;
+    }
+  }
+
+  public needsResetEscape(
+    att: AttributeModel,
+    attributes: AttributeModel[],
+  ): boolean {
+    return (
+      attributes.find((a) =>
+        a.terraformName.match(`^reset_${att.terraformName}$`),
+      ) instanceof AttributeModel
+    );
+  }
+
+  public getResetName(name: string, escape: boolean) {
+    if (!name) return name;
+    if (escape) {
+      return `resetTf${titleCase(name)}`;
+    } else {
+      return `reset${titleCase(name)}`;
+    }
+  }
+
+  public emitToHclTerraform(att: AttributeModel, isStruct: boolean) {
+    const type = att.type;
+    const context = isStruct ? "struct!" : "this";
+    const name = isStruct ? att.name : att.storageName;
+    const customDefault = CUSTOM_DEFAULTS[att.terraformFullName];
+
+    const varReference = `${context}.${name}${
+      !isStruct &&
+      type.isComplex &&
+      !att.isProvider &&
+      (type.struct?.isClass || att.getterType._type === "stored_class")
+        ? ".internalValue"
+        : ""
+    }`;
+    const defaultCheck =
+      customDefault !== undefined
+        ? `${varReference} === undefined ? ${customDefault} : `
+        : "";
+
+    const value = `${defaultCheck}${type.toHclTerraformFunction}(${varReference})`;
+    const isBlock = att.type.isComplex;
+    const tt = att.type.typeModelType;
+
+    this.code.open(`${att.terraformName}: {`);
+    this.code.line(`value: ${value},`);
+    this.code.line(`isBlock: ${isBlock},`);
+    this.code.line(`type: "${tt}",`);
+    this.code.line(`storageClassType: "${att.type.storedClassType}",`);
+    this.code.close("},");
+  }
+
+  public emitToTerraform(att: AttributeModel, isStruct: boolean) {
+    const type = att.type;
+    const context = isStruct ? "struct!" : "this";
+    const name = isStruct ? att.name : att.storageName;
+    const customDefault = CUSTOM_DEFAULTS[att.terraformFullName];
+
+    const varReference = `${context}.${name}${
+      !isStruct &&
+      type.isComplex &&
+      !att.isProvider &&
+      (type.struct?.isClass || att.getterType._type === "stored_class")
+        ? ".internalValue"
+        : ""
+    }`;
+    const defaultCheck =
+      customDefault !== undefined
+        ? `${varReference} === undefined ? ${customDefault} : `
+        : "";
+
+    this.code.line(
+      `${att.terraformName}: ${defaultCheck}${type.toTerraformFunction}(${varReference}),`,
+    );
+  }
+}

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

@@ -0,0 +1,5 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+export * from "./attributes-emitter";
+export * from "./resource-emitter";
+export * from "./struct-emitter";

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

@@ -0,0 +1,226 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { CodeMaker } from "codemaker";
+import { ResourceModel } from "../models";
+import { AttributesEmitter } from "./attributes-emitter";
+import { sanitizedComment } from "../sanitized-comments";
+
+export class ResourceEmitter {
+  attributesEmitter: AttributesEmitter;
+
+  constructor(private readonly code: CodeMaker) {
+    this.attributesEmitter = new AttributesEmitter(this.code);
+  }
+
+  public emit(resource: ResourceModel) {
+    this.code.line();
+    const comment = sanitizedComment(this.code);
+    comment.line(
+      `Represents a {@link ${resource.linkToDocs} ${resource.terraformResourceType}}`,
+    );
+    comment.end();
+    this.code.openBlock(
+      `export class ${resource.className} extends cdktn.${resource.parentClassName}`,
+    );
+
+    this.emitHeader("STATIC PROPERTIES");
+    this.emitStaticProperties(resource);
+
+    this.emitHeader("STATIC Methods");
+    this.emitStaticMethods(resource);
+
+    this.emitHeader("INITIALIZER");
+    this.emitInitializer(resource);
+
+    this.emitHeader("ATTRIBUTES");
+    this.emitResourceAttributes(resource);
+
+    // synthesis
+    this.emitHeader("SYNTHESIS");
+    this.emitResourceSynthesis(resource);
+    this.emitHclResourceSynthesis(resource);
+
+    this.code.closeBlock(); // construct
+  }
+
+  private emitHeader(title: string) {
+    this.code.line();
+    this.code.line("// " + "=".repeat(title.length));
+    this.code.line(`// ${title}`);
+    this.code.line("// " + "=".repeat(title.length));
+  }
+
+  private emitStaticProperties(resource: ResourceModel) {
+    this.code.line(
+      `public static readonly tfResourceType = "${resource.terraformResourceType}";`,
+    );
+  }
+
+  private emitStaticMethods(resource: ResourceModel) {
+    const comment = sanitizedComment(this.code);
+    comment.line(
+      `Generates CDKTN code for importing a ${resource.className} resource upon running "cdktn plan <stack-name>"`,
+    );
+    comment.line(`@param scope The scope in which to define this construct`);
+    comment.line(
+      `@param importToId The construct id used in the generated config for the ${resource.className} to import`,
+    );
+    comment.line(
+      `@param importFromId The id of the existing ${resource.className} that should be imported. Refer to the {@link ${resource.linkToDocs}#import import section} in the documentation of this resource for the id to use`,
+    );
+    comment.line(
+      `@param provider? Optional instance of the provider where the ${resource.className} to import is found`,
+    );
+    comment.end();
+    this.code.line(
+      `public static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktn.TerraformProvider) {
+        return new cdktn.ImportableResource(scope, importToId, { terraformResourceType: "${resource.terraformResourceType}", importId: importFromId, provider });
+      }`,
+    );
+  }
+
+  private emitHclResourceSynthesis(resource: ResourceModel) {
+    this.code.line();
+    this.code.openBlock(
+      `protected synthesizeHclAttributes(): { [name: string]: any }`,
+    );
+    this.code.open(`const attrs = {`);
+
+    for (const att of resource.synthesizableAttributes) {
+      this.attributesEmitter.emitToHclTerraform(att, false);
+    }
+
+    this.code.close(`};`);
+
+    if (resource.synthesizableAttributes.length > 0) {
+      this.code.line();
+      this.code.line(`// remove undefined attributes`);
+      this.code.line(
+        `return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined ))`,
+      );
+    } else {
+      this.code.line(`return attrs;`);
+    }
+
+    this.code.closeBlock();
+  }
+
+  private emitResourceSynthesis(resource: ResourceModel) {
+    this.code.line();
+    this.code.openBlock(
+      `protected synthesizeAttributes(): { [name: string]: any }`,
+    );
+    this.code.open(`return {`);
+
+    for (const att of resource.synthesizableAttributes) {
+      this.attributesEmitter.emitToTerraform(att, false);
+    }
+
+    this.code.close(`};`);
+    this.code.closeBlock();
+  }
+
+  private emitResourceAttributes(resource: ResourceModel) {
+    for (const att of resource.attributes) {
+      this.attributesEmitter.emit(
+        att,
+        this.attributesEmitter.needsResetEscape(att, resource.attributes),
+        this.attributesEmitter.needsInputEscape(att, resource.attributes),
+      );
+    }
+  }
+
+  private emitInitializer(resource: ResourceModel) {
+    this.code.line();
+    const comment = sanitizedComment(this.code);
+    comment.line(
+      `Create a new {@link ${resource.linkToDocs} ${
+        resource.terraformResourceType
+      }} ${resource.isDataSource ? "Data Source" : "Resource"}`,
+    );
+    comment.line(``);
+    comment.line(`@param scope The scope in which to define this construct`);
+    comment.line(
+      `@param id The scoped construct ID. Must be unique amongst siblings in the same scope`,
+    );
+    comment.line(`@param options ${resource.configStruct.attributeType}`);
+    comment.end();
+    this.code.openBlock(
+      `public constructor(scope: Construct, id: string, config: ${resource.configStruct.attributeType})`,
+    );
+
+    if (resource.isProvider) {
+      this.emitProviderSuper(resource);
+    } else {
+      this.emitResourceSuper(resource);
+    }
+
+    // initialize config properties
+    for (const att of resource.configStruct.assignableAttributes) {
+      if (att.setterType._type === "stored_class") {
+        this.code.line(
+          `this.${att.storageName}.internalValue = config.${att.name};`,
+        );
+      } else {
+        this.code.line(`this.${att.storageName} = config.${att.name};`);
+      }
+    }
+
+    this.code.closeBlock();
+  }
+
+  private emitResourceSuper(resource: ResourceModel) {
+    this.code.open(`super(scope, id, {`);
+    this.code.line(
+      `terraformResourceType: '${resource.terraformResourceType}',`,
+    );
+    this.emitTerraformGeneratorMetadata(resource);
+    this.code.line(`provider: config.provider,`);
+    this.code.line(`dependsOn: config.dependsOn,`);
+    this.code.line(`count: config.count,`);
+    this.code.line(`lifecycle: config.lifecycle,`);
+    this.code.line(`provisioners: config.provisioners,`);
+    this.code.line(`connection: config.connection,`);
+    this.code.line(`forEach: config.forEach`);
+    this.code.close(`});`);
+  }
+
+  private emitProviderSuper(resource: ResourceModel) {
+    this.code.open(`super(scope, id, {`);
+    this.code.line(
+      `terraformResourceType: '${resource.terraformResourceType}',`,
+    );
+    this.emitTerraformGeneratorMetadata(resource);
+    this.code.line(
+      `terraformProviderSource: '${resource.terraformProviderSource}'`,
+    );
+    this.code.close(`});`);
+  }
+
+  private emitTerraformGeneratorMetadata(resource: ResourceModel) {
+    this.code.open(`terraformGeneratorMetadata: {`);
+    this.code.line(
+      `providerName: '${resource.provider}'${
+        resource.providerVersion || resource.providerVersionConstraint
+          ? ","
+          : ""
+      }`,
+    );
+
+    if (resource.providerVersion) {
+      this.code.line(
+        `providerVersion: '${resource.providerVersion}'${
+          resource.providerVersionConstraint ? "," : ""
+        }`,
+      );
+    }
+
+    if (resource.providerVersionConstraint) {
+      this.code.line(
+        `providerVersionConstraint: '${resource.providerVersionConstraint}'`,
+      );
+    }
+
+    this.code.close(`},`);
+  }
+}