@cdktn/provider-generator 0.24.0-pre.87 → 0.24.0-pre.89

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

@@ -6,6 +6,7 @@ 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;
@@ -42,6 +43,13 @@ export class ResourceModel {
    * 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;
@@ -81,7 +89,11 @@ export class ResourceModel {
   }
 
   public get configStruct() {
-    return new ConfigStruct(this.configStructName, this.attributes);
+    return new ConfigStruct(
+      this.configStructName,
+      this.attributes,
+      this.isEphemeralResource ? "TerraformEphemeralMetaArguments" : undefined,
+    );
   }
 
   public get synthesizableAttributes(): AttributeModel[] {
@@ -103,6 +115,8 @@ export class ResourceModel {
     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}`;
   }
 
@@ -114,12 +128,18 @@ export class ResourceModel {
     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"
-        : "TerraformResource";
+        : this.isEphemeralResource
+          ? "TerraformEphemeralResource"
+          : "TerraformResource";
   }
 
   public get terraformResourceType(): string {
@@ -127,7 +147,9 @@ export class ResourceModel {
       ? this.terraformProviderName
       : this.isDataSource
         ? this.terraformType.replace(/^data_/, "")
-        : this.terraformType;
+        : this.isEphemeralResource
+          ? this.terraformType.replace(/^ephemeral_/, "")
+          : this.terraformType;
   }
 
   public get terraformDocName(): string {

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

@@ -110,7 +110,15 @@ export class Struct {
 }
 
 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.TerraformMetaArguments`;
+    return ` extends cdktn.${this.extendsClass}`;
   }
 }

package/src/get/generator/provider-generator.ts

@@ -10,9 +10,18 @@ import {
   TerraformProviderConstraint,
 } from "@cdktn/commons";
 import { FQPN, parseFQPN, ProviderName } from "@cdktn/provider-schema";
-import { ResourceModel } from "./models";
+import {
+  ProviderFunctionsModel,
+  ResourceModel,
+  assertNoFunctionsGetterCollision,
+  buildProviderFunctionsModel,
+} from "./models";
 import { ResourceParser } from "./resource-parser";
-import { ResourceEmitter, StructEmitter } from "./emitter";
+import {
+  ProviderFunctionsEmitter,
+  ResourceEmitter,
+  StructEmitter,
+} from "./emitter";
 
 export interface TerraformProviderGeneratorOptions {
   /**
@@ -101,6 +110,7 @@ export class TerraformProviderGenerator {
   private resourceParser = new ResourceParser();
   private resourceEmitter: ResourceEmitter;
   private structEmitter: StructEmitter;
+  private providerFunctionsEmitter: ProviderFunctionsEmitter;
   private readonly importExtension: string;
   public versions: { [fqpn: string]: string | undefined } = {};
 
@@ -111,8 +121,9 @@ export class TerraformProviderGenerator {
   ) {
     this.code.indentation = 2;
     this.importExtension = options.importExtension ?? "";
-    this.resourceEmitter = new ResourceEmitter(this.code);
+    this.resourceEmitter = new ResourceEmitter(this.code, this.importExtension);
     this.structEmitter = new StructEmitter(this.code, this.importExtension);
+    this.providerFunctionsEmitter = new ProviderFunctionsEmitter(this.code);
   }
 
   private getProviderByConstraint(
@@ -185,7 +196,26 @@ export class TerraformProviderGenerator {
         ),
     );
 
-    return ([] as ResourceModel[]).concat(...resources, ...dataSources);
+    const ephemeralResources = Object.entries(
+      provider.ephemeral_resource_schemas || {},
+    ).map(([type, resource]) =>
+      this.resourceParser.parse(
+        fqpn,
+        `ephemeral_${type}`,
+        resource,
+        "ephemeral_resource",
+        constraint,
+      ),
+    );
+
+    // CRITICAL: ephemeral resources must be appended AFTER resources and data
+    // sources - uniqueClassName dedup is order-dependent and existing
+    // prebuilt snapshots must not churn.
+    return ([] as ResourceModel[]).concat(
+      ...resources,
+      ...dataSources,
+      ...ephemeralResources,
+    );
   }
 
   public getClassNameForResource(terraformType: string) {
@@ -225,6 +255,16 @@ export class TerraformProviderGenerator {
       this.emitResourceReadme(resourceModel);
     });
 
+    // Built before the provider class is emitted (rather than after, as
+    // resources/data sources/ephemeral resources above already are) so that
+    // the model can be attached to providerResource and picked up by
+    // ResourceEmitter while it still emits the provider class file below -
+    // see the engineering brief for why this ordering matters.
+    const providerFunctionsModel = buildProviderFunctionsModel(
+      name,
+      provider.functions,
+    );
+
     if (provider.provider) {
       const providerResource = this.resourceParser.parse(
         fqpn,
@@ -239,14 +279,40 @@ export class TerraformProviderGenerator {
         providerResource.terraformProviderName = constraint.name;
       }
       providerResource.providerVersion = providerVersion;
+
+      if (providerFunctionsModel) {
+        assertNoFunctionsGetterCollision(
+          name,
+          providerResource.attributes.map((att) => att.name),
+        );
+        providerResource.providerFunctionsModel = providerFunctionsModel;
+      }
+
       files.push(this.emitResource(providerResource));
       this.emitResourceReadme(providerResource);
     }
 
+    if (providerFunctionsModel) {
+      files.push(this.emitProviderFunctions(name, providerFunctionsModel));
+    }
+
     this.emitIndexFile(name, files);
     this.emitLazyIndexFile(name, files);
   }
 
+  private emitProviderFunctions(
+    provider: ProviderName,
+    model: ProviderFunctionsModel,
+  ): string {
+    const filePath = `providers/${provider}/provider-functions/index.ts`;
+    this.code.openFile(filePath);
+    this.code.line(`// generated from provider function schema`);
+    this.code.line();
+    this.providerFunctionsEmitter.emit(model);
+    this.code.closeFile(filePath);
+    return filePath;
+  }
+
   private emitResourceReadme(resource: ResourceModel): void {
     const filePath = `${resource.namespaceFolderPath}/README.md`;
     this.code.openFile(filePath);

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

@@ -463,6 +463,7 @@ class Parser {
           provider: parentType.isProvider,
           required: !!att.required,
           forcePlainGetterType,
+          isWriteOnly: !!att.write_only,
         }),
       );
     }
@@ -669,6 +670,7 @@ class Parser {
             type,
             provider: parent.isProvider,
             required: required,
+            isWriteOnly: !!att.write_only,
           }),
         );
       }