@cdktn/provider-generator 0.25.0-pre.4 → 0.25.0-pre.40

package/src/get/__tests__/generator/fixtures/provider-functions-name-collision.test.fixture.json

@@ -0,0 +1,42 @@
+{
+  "provider_schemas": {
+    "registry.terraform.io/hashicorp/example": {
+      "resource_schemas": {
+        "example_provider_functions": {
+          "version": 0,
+          "block": {
+            "attributes": {
+              "id": {
+                "type": "string",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "name": {
+                "type": "string",
+                "description_kind": "plain",
+                "optional": true
+              }
+            }
+          }
+        }
+      },
+      "functions": {
+        "sum": {
+          "description": "Adds up two numbers.",
+          "summary": "Sum numbers",
+          "return_type": "number",
+          "parameters": [
+            {
+              "name": "a",
+              "type": "number"
+            },
+            {
+              "name": "b",
+              "type": "number"
+            }
+          ]
+        }
+      }
+    }
+  }
+}

package/src/get/__tests__/generator/provider-functions-name-collision.test.ts

@@ -0,0 +1,84 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { CodeMaker } from "codemaker";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { sanitizeClassOrNamespaceName } from "../../generator/resource-parser";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+// A provider declaring provider-defined functions emits them to
+// providers/<provider>/provider-functions/index.ts. A resource named
+// <provider>_provider_functions maps to that same directory, so without a
+// guard the resource overwrites the functions wrapper and the provider index
+// exports the name twice.
+describe("resource named like the provider functions submodule", () => {
+  let workdir: string;
+
+  beforeAll(async () => {
+    const code = new CodeMaker();
+    workdir = tmp("provider-functions-name-collision.test");
+    const spec = JSON.parse(
+      fs.readFileSync(
+        path.join(
+          __dirname,
+          "fixtures",
+          "provider-functions-name-collision.test.fixture.json",
+        ),
+        "utf-8",
+      ),
+    );
+    new TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+  });
+
+  const read = (relPath: string) =>
+    fs.readFileSync(path.join(workdir, relPath), "utf-8");
+
+  test("the functions submodule holds the functions wrapper, not the resource", () => {
+    const output = read("providers/example/provider-functions/index.ts");
+    expect(output).toContain("class ExampleProviderFunctions");
+    expect(output).not.toContain("cdktn.TerraformResource");
+  });
+
+  test("the resource is emitted to its own directory", () => {
+    const output = read(
+      "providers/example/provider-functions-resource/index.ts",
+    );
+    expect(output).toContain("class ProviderFunctionsResource");
+    expect(output).toContain("cdktn.TerraformResource");
+  });
+
+  test("the provider index exports both, without duplicate names", () => {
+    const index = read("providers/example/index.ts");
+    expect(index).toContain(
+      "export * as providerFunctions from './provider-functions/index';",
+    );
+    expect(index).toContain(
+      "export * as providerFunctionsResource from './provider-functions-resource/index';",
+    );
+
+    const exportedNames = [...index.matchAll(/export \* as (\w+) from/g)].map(
+      (m) => m[1],
+    );
+    expect(new Set(exportedNames).size).toBe(exportedNames.length);
+  });
+});
+
+describe("sanitizeClassOrNamespaceName", () => {
+  test("suffixes a resource named provider_functions", () => {
+    expect(sanitizeClassOrNamespaceName("provider_functions")).toBe(
+      "provider_functions_resource",
+    );
+  });
+
+  test("still suffixes a resource named provider", () => {
+    expect(sanitizeClassOrNamespaceName("provider")).toBe("provider_resource");
+  });
+
+  test("leaves an unrelated resource name alone", () => {
+    expect(sanitizeClassOrNamespaceName("function_app")).toBe("function_app");
+  });
+});

package/src/get/constructs-maker.ts

@@ -315,6 +315,8 @@ export class ConstructsMaker {
   private readonly codeMakerOutdir: string;
   private readonly code: CodeMaker;
   private versions: { [providerName: string]: string | undefined };
+  /** Resource directory names emitted per provider folder during this run */
+  public emittedResourceFolders: { [providerName: string]: string[] };
 
   constructor(
     private readonly options: GetOptions,
@@ -328,6 +330,7 @@ export class ConstructsMaker {
     fs.mkdirpSync(this.codeMakerOutdir);
     this.code = new CodeMaker();
     this.versions = {};
+    this.emittedResourceFolders = {};
   }
   private async generateTypescriptProvider(
     target: ConstructsMakerProviderTarget,
@@ -336,10 +339,15 @@ export class ConstructsMaker {
     const endTSTimer = logTimespan(`Generate Typescript for ${target.name}`);
     const generator = new TerraformProviderGenerator(this.code, schema, {
       importExtension: this.options.languageOptions?.importExtension,
+      targetVersions: this.options.targetVersions,
     });
     generator.generate(target);
 
     this.versions = { ...this.versions, ...generator.versions };
+    this.emittedResourceFolders = {
+      ...this.emittedResourceFolders,
+      ...generator.emittedResourceFolders,
+    };
     endTSTimer();
   }
 
@@ -595,6 +603,62 @@ export class ConstructsMaker {
     });
   }
 
+  /**
+   * Delete resource directories under `providers/` that this run did not emit, so each provider folder holds
+   * exactly the resources in the version it was generated against.
+   *
+   * Walks only providers present in `emittedResourceFolders`, keeping any provider this run skipped. Within those,
+   * removes every subdirectory not emitted and leaves provider-level files (`index.ts`, `lazy-index.ts`) in place.
+   * Deletes files, so it must run after `save()` has written the current run's output.
+   *
+   * TypeScript only: `providers/<name>/<resource>/` maps one-to-one onto the emitted index exports. Other languages
+   * co-locate providers and modules in the same folders, which makes a dropped resource indistinguishable from a
+   * hand-written construct.
+   */
+  public async removeOrphanedResourceFolders() {
+    if (!this.isJavascriptTarget) {
+      return;
+    }
+
+    for (const [provider, emittedFolders] of Object.entries(
+      this.emittedResourceFolders,
+    )) {
+      const providerFolder = path.resolve(
+        this.codeMakerOutdir,
+        "providers",
+        provider,
+      );
+
+      let entries: string[] = [];
+      try {
+        entries = await fs.readdir(providerFolder);
+      } catch (e) {
+        logger.debug(
+          `Could not list resource folders in '${providerFolder}': ${e}`,
+        );
+        continue;
+      }
+
+      const expected = new Set(emittedFolders);
+      for (const entry of entries) {
+        if (expected.has(entry)) {
+          continue;
+        }
+
+        const entryPath = path.resolve(providerFolder, entry);
+        if (!fs.statSync(entryPath).isDirectory()) {
+          // Leave index.ts / lazy-index.ts and any other provider-level files alone.
+          continue;
+        }
+
+        logger.debug(
+          `Removing orphaned resource folder '${entry}' from provider '${provider}': it was not emitted for the current provider version`,
+        );
+        await fs.remove(entryPath);
+      }
+    }
+  }
+
   // emits a constraints.json file with a map of the used provider fqpns and version constraints
   // this is used for caching purposes
   private emitConstraintsFile(
@@ -757,6 +821,7 @@ a NODE_OPTIONS variable, we won't override it. Hence, the provider generation mi
 
     if (this.isJavascriptTarget) {
       await this.save();
+      await this.removeOrphanedResourceFolders();
     }
 
     if (!this.isJavascriptTarget || this.options.outputJsii) {

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

@@ -215,8 +215,7 @@ export interface CollectionAttributeTypeModel extends AttributeTypeModel {
   // into the nearest typed "Any"-wrapper. undefined only defensively - see
   // resolveStoredClassName in supported-stored-classes.ts.
   readonly resolvedStoredClass:
-    | { name: string; collapsed: boolean }
-    | undefined;
+    { name: string; collapsed: boolean } | undefined;
 }
 
 export class ListAttributeTypeModel implements CollectionAttributeTypeModel {

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

@@ -5,7 +5,11 @@ 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";
+import {
+  Schema,
+  TerraformTargetVersions,
+  registryForTargetVersions,
+} from "@cdktn/commons";
 import { ProviderFunctionsModel } from "./provider-function-model";
 
 // Limit is 1200 to prevent stack size error.
@@ -25,6 +29,7 @@ interface ResourceModelOptions {
   schema: Schema;
   terraformSchemaType: string;
   configStructName: string;
+  targetVersions?: TerraformTargetVersions;
 }
 
 type DefinitionPath = string;
@@ -35,6 +40,7 @@ export class ResourceModel {
   public baseName: string;
   public provider: ProviderName;
   public fqpn: FQPN;
+  private readonly targetVersions?: TerraformTargetVersions;
   public providerVersionConstraint?: string;
   public providerVersion?: string;
   public terraformProviderSource?: string;
@@ -68,6 +74,7 @@ export class ResourceModel {
     this.attributes = options.attributes;
     this.schema = options.schema;
     this.fqpn = options.fqpn;
+    this.targetVersions = options.targetVersions;
     this.provider = parseFQPN(options.fqpn).name;
     this.terraformProviderName = this.provider;
     this.fileName = options.fileName;
@@ -109,15 +116,26 @@ export class ResourceModel {
   }
 
   public get linkToDocs(): string {
-    const { hostname, namespace, name } = parseFQPN(this.fqpn);
+    // Keyed off the project's declared targets, not the FQPN hostname: that
+    // hostname reflects whichever CLI fetched the schema, which would make the
+    // generated link differ between a terraform and a tofu `cdktn get`.
+    const registry = registryForTargetVersions(this.targetVersions);
+    const { 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}`;
-    if (this.isEphemeralResource)
-      return `${base}/ephemeral-resources/${this.terraformDocName}`;
-    return `${base}/resources/${this.terraformDocName}`;
+    const kind = this.isProvider
+      ? "provider"
+      : this.isDataSource
+        ? "data-source"
+        : this.isEphemeralResource
+          ? "ephemeral-resource"
+          : "resource";
+    return registry.docsUrl(
+      namespace,
+      name,
+      version,
+      kind,
+      this.terraformDocName,
+    );
   }
 
   public get isProvider(): boolean {

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

@@ -8,6 +8,7 @@ import {
   logger,
   ProviderSchema,
   TerraformProviderConstraint,
+  TerraformTargetVersions,
 } from "@cdktn/commons";
 import { FQPN, parseFQPN, ProviderName } from "@cdktn/provider-schema";
 import {
@@ -29,6 +30,8 @@ export interface TerraformProviderGeneratorOptions {
    * Defaults to "" (CommonJS).
    */
   readonly importExtension?: string;
+  /** Project's declared targetVersions; selects the docs registry. */
+  readonly targetVersions?: TerraformTargetVersions;
 }
 
 interface ProviderData {
@@ -107,12 +110,17 @@ export interface ProviderConstraints {
 }
 
 export class TerraformProviderGenerator {
-  private resourceParser = new ResourceParser();
+  private resourceParser: ResourceParser;
   private resourceEmitter: ResourceEmitter;
   private structEmitter: StructEmitter;
   private providerFunctionsEmitter: ProviderFunctionsEmitter;
   private readonly importExtension: string;
   public versions: { [fqpn: string]: string | undefined } = {};
+  /**
+   * Resource directory names emitted per provider folder Used to prune directories
+   * left over from a previous provider version.
+   */
+  public emittedResourceFolders: { [provider: string]: string[] } = {};
 
   constructor(
     private readonly code: CodeMaker,
@@ -121,6 +129,7 @@ export class TerraformProviderGenerator {
   ) {
     this.code.indentation = 2;
     this.importExtension = options.importExtension ?? "";
+    this.resourceParser = new ResourceParser(options.targetVersions);
     this.resourceEmitter = new ResourceEmitter(this.code, this.importExtension);
     this.structEmitter = new StructEmitter(this.code, this.importExtension);
     this.providerFunctionsEmitter = new ProviderFunctionsEmitter(this.code);
@@ -298,6 +307,20 @@ export class TerraformProviderGenerator {
 
     this.emitIndexFile(name, files);
     this.emitLazyIndexFile(name, files);
+
+    // Record exactly what this run emitted, derived the same way the index
+    // files derive their exports, so pruning can never disagree with them.
+    this.emittedResourceFolders[name] = files.map((file) =>
+      this.resourceFolderName(name, file),
+    );
+  }
+
+  /**
+   * Map an emitted file path to the resource directory name it lives in, e.g.
+   * `providers/mongodbatlas/teams/index.ts` -> `teams`.
+   */
+  private resourceFolderName(provider: ProviderName, file: string): string {
+    return file.replace(`providers/${provider}/`, "").replace("/index.ts", "");
   }
 
   private emitProviderFunctions(
@@ -333,7 +356,7 @@ export class TerraformProviderGenerator {
     this.code.openFile(filePath);
     this.code.line("// generated by cdktn get");
     for (const file of files) {
-      const dirName = file.replace(`${folder}/`, "").replace("/index.ts", "");
+      const dirName = this.resourceFolderName(provider, file);
       this.code.line(
         `export * as ${toCamelCase(dirName)} from './${dirName}/index${this.importExtension}';`,
       );
@@ -348,7 +371,7 @@ export class TerraformProviderGenerator {
     this.code.openFile(filePath);
     this.code.line("// generated by cdktn get");
     for (const file of files) {
-      const dirName = file.replace(`${folder}/`, "").replace("/index.ts", "");
+      const dirName = this.resourceFolderName(provider, file);
       this.code.line(
         `Object.defineProperty(exports, '${toCamelCase(
           dirName,

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

@@ -11,6 +11,7 @@ import {
   isAttributeNestedType,
   isNestedTypeAttribute,
   Schema,
+  TerraformTargetVersions,
 } from "@cdktn/commons";
 import { ProviderName, FQPN, parseFQPN } from "@cdktn/provider-schema";
 import {
@@ -82,8 +83,17 @@ export function sanitizeClassOrNamespaceName(
   isProvider = false,
 ) {
   const resourceIsNamedProvider = !isProvider && baseName === "provider";
-
-  if (isReservedClassOrNamespaceName(baseName) || resourceIsNamedProvider) {
+  // A resource named `<provider>_provider_functions` maps to the same
+  // providers/<provider>/provider-functions/ directory that the provider's
+  // functions submodule is emitted to, and would silently overwrite it.
+  const resourceIsNamedProviderFunctions =
+    !isProvider && baseName === "provider_functions";
+
+  if (
+    isReservedClassOrNamespaceName(baseName) ||
+    resourceIsNamedProvider ||
+    resourceIsNamedProviderFunctions
+  ) {
     return `${baseName}_resource`;
   } else {
     return baseName;
@@ -114,6 +124,7 @@ class Parser {
   constructor(
     private classNames: string[],
     private usedBaseNames: Map<string, string>,
+    private targetVersions?: TerraformTargetVersions,
   ) {}
 
   private uniqueClassName(className: string): string {
@@ -285,6 +296,7 @@ class Parser {
       terraformSchemaType,
       structs: this.structs,
       configStructName,
+      targetVersions: this.targetVersions,
     });
 
     return resourceModel;
@@ -718,6 +730,8 @@ export class ResourceParser {
   private uniqueBaseNames: Map<string, string> = new Map();
   private resources: Record<string, ResourceModel> = {};
 
+  constructor(private readonly targetVersions?: TerraformTargetVersions) {}
+
   public parse(
     fqpn: FQPN,
     type: string,
@@ -729,7 +743,11 @@ export class ResourceParser {
       return this.resources[type];
     }
 
-    const parser = new Parser(this.uniqueClassnames, this.uniqueBaseNames);
+    const parser = new Parser(
+      this.uniqueClassnames,
+      this.uniqueBaseNames,
+      this.targetVersions,
+    );
     const resource = parser.resourceFrom(
       fqpn,
       type,

package/tsconfig.json

@@ -24,6 +24,10 @@
     "stripInternal": true,
     "skipLibCheck": true,
     "target": "ES2018",
+    "types": [
+      "node",
+      "jest"
+    ],
     "incremental": true,
     "esModuleInterop": true,
     "rootDir": "./src",