@cdktn/provider-generator 0.25.0-pre.6 → 0.25.0-pre.61

package/src/__tests__/provider.test.ts

@@ -70,6 +70,27 @@ function resourceTypesPresentInSnapshot(
   return resources;
 }
 
+/**
+ * Rewrites the registry host in any fully-qualified-name key. The host records
+ * which CLI fetched the schema - terraform's or tofu's - rather than anything
+ * about the generated code, so one snapshot serves both.
+ */
+function stubRegistryHosts(value: any): any {
+  if (Array.isArray(value)) return value.map(stubRegistryHosts);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [
+        k.replace(
+          /^registry\.(?:terraform\.io|opentofu\.org)\//,
+          "STUBBED_REGISTRY/",
+        ),
+        stubRegistryHosts(v),
+      ]),
+    );
+  }
+  return value;
+}
+
 describe("Provider", () => {
   it("generates a provider", async () => {
     const constraint = new TerraformProviderConstraint(
@@ -86,7 +107,7 @@ describe("Provider", () => {
         process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH,
       );
       await maker.generate([constraint]);
-      const snapshot = directorySnapshot(workdir);
+      const snapshot = stubRegistryHosts(directorySnapshot(workdir));
       expect(snapshot).toMatchSnapshot();
     });
   }, 600_000);
@@ -103,7 +124,7 @@ describe("Provider", () => {
         targetLanguage: Language.TYPESCRIPT,
       });
       await maker.generate([constraint]);
-      const snapshot = directorySnapshot(workdir);
+      const snapshot = stubRegistryHosts(directorySnapshot(workdir));
 
       const terraformResourceTypesPresent: string[] =
         resourceTypesPresentInSnapshot(snapshot, "datadog");
@@ -127,7 +148,7 @@ describe("Provider", () => {
     const constraint = new TerraformProviderConstraint({
       name: "dockerr",
       source: "registry.terraform.io/kreuzwerker/docker",
-      version: "3.0.2",
+      version: "3.9.0",
     });
     return await mkdtemp(async (workdir) => {
       const jsiiPath = path.join(workdir, ".jsii");
@@ -140,7 +161,7 @@ describe("Provider", () => {
         process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH,
       );
       await maker.generate([constraint]);
-      const snapshot = directorySnapshot(workdir);
+      const snapshot = stubRegistryHosts(directorySnapshot(workdir));
 
       const terraformResourceTypesPresent: string[] =
         resourceTypesPresentInSnapshot(snapshot, "dockerr");
@@ -160,11 +181,13 @@ describe("Provider", () => {
       version: "2.51.0",
       source: "DrFaust92/bitbucket",
     });
+    // andsafe-AG/bitbucket is Terraform-registry only; zahiar/bitbucket is
+    // mirrored on both, so this runs under either CLI.
     const constraint2 = new TerraformProviderConstraint({
       name: "abitbucket",
-      namespace: "andsafe-AG",
-      version: "2.5.0",
-      source: "andsafe-AG/bitbucket",
+      namespace: "zahiar",
+      version: "0.3.0",
+      source: "zahiar/bitbucket",
     });
     return await mkdtemp(async (workdir) => {
       const jsiiPath = path.join(workdir, ".jsii");
@@ -178,7 +201,7 @@ describe("Provider", () => {
       );
       await maker.generate([constraint, constraint2]);
       console.log("workdir", workdir);
-      const snapshot = directorySnapshot(workdir);
+      const snapshot = stubRegistryHosts(directorySnapshot(workdir));
       expect(snapshot).toMatchSnapshot();
     });
   }, 600_000);

package/src/get/__tests__/constructs-maker.test.ts

@@ -8,7 +8,7 @@ import {
   ConstructsMakerModuleTarget,
   ConstructsMakerProviderTarget,
 } from "@cdktn/commons";
-import { determineGoModuleName } from "../constructs-maker";
+import { ConstructsMaker, determineGoModuleName } from "../constructs-maker";
 
 describe("constructsMaker", () => {
   describe("determineGoModuleName", () => {
@@ -115,4 +115,128 @@ describe("constructsMaker", () => {
       expect(target.srcMakName).toEqual("security_group");
     });
   });
+
+  describe("removeOrphanedResourceFolders", () => {
+    let tmpDir: string;
+
+    const providerDir = (provider: string) =>
+      path.join(tmpDir, "providers", provider);
+
+    /**
+     * Lay out a provider folder containing the given resource directories plus
+     * the provider-level index files a real generation run writes.
+     */
+    const seedProvider = async (provider: string, resources: string[]) => {
+      for (const resource of resources) {
+        await fs.mkdirs(path.join(providerDir(provider), resource));
+        await fs.writeFile(
+          path.join(providerDir(provider), resource, "index.ts"),
+          "// generated\n",
+        );
+      }
+      await fs.writeFile(
+        path.join(providerDir(provider), "index.ts"),
+        "// generated by cdktn get\n",
+      );
+      await fs.writeFile(
+        path.join(providerDir(provider), "lazy-index.ts"),
+        "// generated by cdktn get\n",
+      );
+    };
+
+    const makeMaker = (targetLanguage: Language) =>
+      new ConstructsMaker({
+        codeMakerOutput: tmpDir,
+        targetLanguage,
+      });
+
+    beforeEach(async () => {
+      tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "cdktf.orphans"));
+    });
+
+    afterEach(async () => {
+      await fs.remove(tmpDir);
+    });
+
+    it("removes resource folders the current run did not emit", async () => {
+      // 'teams' and 'data-lake-pipeline' exist only in the previously generated
+      // provider version; the new schema no longer produces them.
+      await seedProvider("mongodbatlas", [
+        "cluster",
+        "teams",
+        "data-lake-pipeline",
+      ]);
+
+      const maker = makeMaker(Language.TYPESCRIPT);
+      maker.emittedResourceFolders = { mongodbatlas: ["cluster"] };
+      await maker.removeOrphanedResourceFolders();
+
+      expect(
+        await fs.pathExists(path.join(providerDir("mongodbatlas"), "cluster")),
+      ).toBe(true);
+      expect(
+        await fs.pathExists(path.join(providerDir("mongodbatlas"), "teams")),
+      ).toBe(false);
+      expect(
+        await fs.pathExists(
+          path.join(providerDir("mongodbatlas"), "data-lake-pipeline"),
+        ),
+      ).toBe(false);
+    });
+
+    it("keeps provider-level files", async () => {
+      await seedProvider("mongodbatlas", ["cluster", "teams"]);
+
+      const maker = makeMaker(Language.TYPESCRIPT);
+      maker.emittedResourceFolders = { mongodbatlas: ["cluster"] };
+      await maker.removeOrphanedResourceFolders();
+
+      expect(
+        await fs.pathExists(path.join(providerDir("mongodbatlas"), "index.ts")),
+      ).toBe(true);
+      expect(
+        await fs.pathExists(
+          path.join(providerDir("mongodbatlas"), "lazy-index.ts"),
+        ),
+      ).toBe(true);
+    });
+
+    it("leaves providers that were not regenerated untouched", async () => {
+      // filterAlreadyGenerated can skip a provider entirely, in which case it
+      // has no entry in emittedResourceFolders and must not be pruned.
+      await seedProvider("mongodbatlas", ["cluster"]);
+      await seedProvider("onepassword", ["item"]);
+
+      const maker = makeMaker(Language.TYPESCRIPT);
+      maker.emittedResourceFolders = { mongodbatlas: ["cluster"] };
+      await maker.removeOrphanedResourceFolders();
+
+      expect(
+        await fs.pathExists(path.join(providerDir("onepassword"), "item")),
+      ).toBe(true);
+    });
+
+    it("is a no-op for non-TypeScript targets", async () => {
+      // Other languages co-locate providers and modules, so a dropped resource
+      // is indistinguishable from a hand-written construct.
+      await seedProvider("mongodbatlas", ["cluster", "teams"]);
+
+      const maker = makeMaker(Language.PYTHON);
+      maker.emittedResourceFolders = { mongodbatlas: ["cluster"] };
+      await maker.removeOrphanedResourceFolders();
+
+      expect(
+        await fs.pathExists(path.join(providerDir("mongodbatlas"), "teams")),
+      ).toBe(true);
+    });
+
+    it("does not throw when the provider folder is missing", async () => {
+      const maker = makeMaker(Language.TYPESCRIPT);
+      maker.emittedResourceFolders = { mongodbatlas: ["cluster"] };
+
+      await expect(
+        maker.removeOrphanedResourceFolders(),
+      ).resolves.not.toThrow();
+    });
+  });
 });

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/__tests__/generator/versions-file.test.ts

@@ -33,7 +33,8 @@ describe("versions.json file generation", () => {
       fqn: "kreuzwerker/docker",
       name: "docker",
       source: "kreuzwerker/docker",
-      version: "2.16.0",
+      // OpenTofu rejects everything below 3.7.0 as unsigned; see #440.
+      version: "3.9.0",
     },
   ];
 
@@ -62,10 +63,14 @@ describe("versions.json file generation", () => {
         path.join(workdir, "versions.json"),
         "utf-8",
       );
-      expect(Object.keys(JSON.parse(output))).toEqual(
-        expect.arrayContaining(
-          constraints.map((c) => `registry.terraform.io/${c.fqn}`),
-        ),
+      // versions.json is keyed by fully qualified name, and the host is
+      // whichever registry the fetching CLI used - terraform's or tofu's - so
+      // assert on the provider part rather than pinning one registry.
+      const keys = Object.keys(JSON.parse(output)).map((k) =>
+        k.split("/").slice(1).join("/"),
+      );
+      expect(keys).toEqual(
+        expect.arrayContaining(constraints.map((c) => c.fqn)),
       );
     },
   );

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/emitter/struct-emitter.ts

@@ -61,13 +61,13 @@ export class StructEmitter {
         comment.line(att.description);
         comment.line(``);
         comment.line(
-          `Docs at Terraform Registry: {@link ${resource.linkToDocs}#${att.terraformName} ${resource.className}#${att.terraformName}}`,
+          `Docs at ${resource.docsRegistryName}: {@link ${resource.linkToDocs}#${att.terraformName} ${resource.className}#${att.terraformName}}`,
         );
         this.warnAboutIdField(att);
         comment.end();
       } else {
         comment.line(
-          `Docs at Terraform Registry: {@link ${resource.linkToDocs}#${att.terraformName} ${resource.className}#${att.terraformName}}`,
+          `Docs at ${resource.docsRegistryName}: {@link ${resource.linkToDocs}#${att.terraformName} ${resource.className}#${att.terraformName}}`,
         );
         this.warnAboutIdField(att);
         comment.end();

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;
@@ -108,16 +115,32 @@ export class ResourceModel {
     return this.escapeSchema(JSON.stringify(this.schema, undefined, 2));
   }
 
+  /** Registry that linkToDocs points at, for use in the surrounding prose. */
+  public get docsRegistryName(): string {
+    return registryForTargetVersions(this.targetVersions).displayName;
+  }
+
   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(
@@ -322,7 +345,7 @@ export class TerraformProviderGenerator {
       ? resource.provider
       : resource.terraformType;
     this.code.line(
-      `Refer to the Terraform Registry for docs: [\`${type}\`](${resource.linkToDocs}).`,
+      `Refer to the ${resource.docsRegistryName} for docs: [\`${type}\`](${resource.linkToDocs}).`,
     );
     this.code.closeFile(filePath);
   }
@@ -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,