@cdktn/provider-generator 0.25.0-pre.3 → 0.25.0-pre.30

package/build/util.js

@@ -2,7 +2,8 @@
 // Copyright (c) HashiCorp, Inc
 // SPDX-License-Identifier: MPL-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uppercaseFirst = exports.downcaseFirst = void 0;
+exports.downcaseFirst = downcaseFirst;
+exports.uppercaseFirst = uppercaseFirst;
 /**
  * Downcase the first character in a string.
  *
@@ -14,7 +15,6 @@ function downcaseFirst(str) {
     }
     return `${str[0].toLocaleLowerCase()}${str.slice(1)}`;
 }
-exports.downcaseFirst = downcaseFirst;
 /**
  * Uppercase the first character in a string.
  *
@@ -26,5 +26,4 @@ function uppercaseFirst(str) {
     }
     return `${str[0].toLocaleUpperCase()}${str.slice(1)}`;
 }
-exports.uppercaseFirst = uppercaseFirst;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwrQkFBK0I7QUFDL0IsbUNBQW1DOzs7QUFFbkM7Ozs7R0FJRztBQUNILFNBQWdCLGFBQWEsQ0FBQyxHQUFXO0lBQ3ZDLElBQUksR0FBRyxLQUFLLEVBQUUsRUFBRSxDQUFDO1FBQ2YsT0FBTyxHQUFHLENBQUM7SUFDYixDQUFDO0lBQ0QsT0FBTyxHQUFHLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxpQkFBaUIsRUFBRSxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztBQUN4RCxDQUFDO0FBTEQsc0NBS0M7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsY0FBYyxDQUFDLEdBQVc7SUFDeEMsSUFBSSxHQUFHLEtBQUssRUFBRSxFQUFFLENBQUM7UUFDZixPQUFPLEdBQUcsQ0FBQztJQUNiLENBQUM7SUFDRCxPQUFPLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLGlCQUFpQixFQUFFLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO0FBQ3hELENBQUM7QUFMRCx3Q0FLQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG5cbi8qKlxuICogRG93bmNhc2UgdGhlIGZpcnN0IGNoYXJhY3RlciBpbiBhIHN0cmluZy5cbiAqXG4gKiBAcGFyYW0gc3RyIHRoZSBzdHJpbmcgdG8gYmUgcHJvY2Vzc2VkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZG93bmNhc2VGaXJzdChzdHI6IHN0cmluZyk6IHN0cmluZyB7XG4gIGlmIChzdHIgPT09IFwiXCIpIHtcbiAgICByZXR1cm4gc3RyO1xuICB9XG4gIHJldHVybiBgJHtzdHJbMF0udG9Mb2NhbGVMb3dlckNhc2UoKX0ke3N0ci5zbGljZSgxKX1gO1xufVxuXG4vKipcbiAqIFVwcGVyY2FzZSB0aGUgZmlyc3QgY2hhcmFjdGVyIGluIGEgc3RyaW5nLlxuICpcbiAqIEBwYXJhbSBzdHIgdGhlIHN0cmluZyB0byBiZSBwcm9jZXNzZWQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB1cHBlcmNhc2VGaXJzdChzdHI6IHN0cmluZyk6IHN0cmluZyB7XG4gIGlmIChzdHIgPT09IFwiXCIpIHtcbiAgICByZXR1cm4gc3RyO1xuICB9XG4gIHJldHVybiBgJHtzdHJbMF0udG9Mb2NhbGVVcHBlckNhc2UoKX0ke3N0ci5zbGljZSgxKX1gO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwrQkFBK0I7QUFDL0IsbUNBQW1DOztBQU9uQyxzQ0FLQztBQU9ELHdDQUtDO0FBdEJEOzs7O0dBSUc7QUFDSCxTQUFnQixhQUFhLENBQUMsR0FBVztJQUN2QyxJQUFJLEdBQUcsS0FBSyxFQUFFLEVBQUUsQ0FBQztRQUNmLE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQztJQUNELE9BQU8sR0FBRyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsaUJBQWlCLEVBQUUsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7QUFDeEQsQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxTQUFnQixjQUFjLENBQUMsR0FBVztJQUN4QyxJQUFJLEdBQUcsS0FBSyxFQUFFLEVBQUUsQ0FBQztRQUNmLE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQztJQUNELE9BQU8sR0FBRyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsaUJBQWlCLEVBQUUsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7QUFDeEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG5cbi8qKlxuICogRG93bmNhc2UgdGhlIGZpcnN0IGNoYXJhY3RlciBpbiBhIHN0cmluZy5cbiAqXG4gKiBAcGFyYW0gc3RyIHRoZSBzdHJpbmcgdG8gYmUgcHJvY2Vzc2VkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZG93bmNhc2VGaXJzdChzdHI6IHN0cmluZyk6IHN0cmluZyB7XG4gIGlmIChzdHIgPT09IFwiXCIpIHtcbiAgICByZXR1cm4gc3RyO1xuICB9XG4gIHJldHVybiBgJHtzdHJbMF0udG9Mb2NhbGVMb3dlckNhc2UoKX0ke3N0ci5zbGljZSgxKX1gO1xufVxuXG4vKipcbiAqIFVwcGVyY2FzZSB0aGUgZmlyc3QgY2hhcmFjdGVyIGluIGEgc3RyaW5nLlxuICpcbiAqIEBwYXJhbSBzdHIgdGhlIHN0cmluZyB0byBiZSBwcm9jZXNzZWQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB1cHBlcmNhc2VGaXJzdChzdHI6IHN0cmluZyk6IHN0cmluZyB7XG4gIGlmIChzdHIgPT09IFwiXCIpIHtcbiAgICByZXR1cm4gc3RyO1xuICB9XG4gIHJldHVybiBgJHtzdHJbMF0udG9Mb2NhbGVVcHBlckNhc2UoKX0ke3N0ci5zbGljZSgxKX1gO1xufVxuIl19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cdktn/provider-generator",
-  "version": "0.25.0-pre.3",
+  "version": "0.25.0-pre.30",
   "description": "Exposes API to generate Terraform CDK provider bindings",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -29,20 +29,20 @@
   ],
   "license": "MPL-2.0",
   "dependencies": {
-    "codemaker": "1.128.0",
-    "constructs": "10.6.0",
+    "codemaker": "1.140.0",
+    "constructs": "10.8.1",
     "fs-extra": "11.3.6",
     "glob": "13.0.6",
-    "jsii": "~5.9.0",
-    "jsii-pacmak": "1.128.0",
-    "@cdktn/provider-schema": "0.25.0-pre.3",
-    "cdktn": "0.25.0-pre.3",
-    "@cdktn/commons": "0.25.0-pre.3"
+    "jsii": "~6.0.0",
+    "jsii-pacmak": "1.140.0",
+    "@cdktn/commons": "0.25.0-pre.30",
+    "@cdktn/provider-schema": "0.25.0-pre.30",
+    "cdktn": "0.25.0-pre.30"
   },
   "devDependencies": {
     "@types/fs-extra": "11.0.4",
     "@types/node": "22.20.1",
-    "typescript": "^5.0.4"
+    "typescript": "~6.0.0"
   },
   "scripts": {
     "build": "tsc",

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/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,
@@ -340,6 +343,10 @@ export class ConstructsMaker {
     generator.generate(target);
 
     this.versions = { ...this.versions, ...generator.versions };
+    this.emittedResourceFolders = {
+      ...this.emittedResourceFolders,
+      ...generator.emittedResourceFolders,
+    };
     endTSTimer();
   }
 
@@ -595,6 +602,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 +820,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/provider-generator.ts

@@ -113,6 +113,11 @@ export class TerraformProviderGenerator {
   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,
@@ -298,6 +303,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 +352,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 +367,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

@@ -82,8 +82,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;

package/tsconfig.json

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