@cdktn/provider-generator 0.25.0-pre.9 → 0.25.0

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/module-docs-registry.test.ts

@@ -0,0 +1,89 @@
+// 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 {
+  ConstructsMakerModuleTarget,
+  Language,
+  TerraformModuleConstraint,
+  TerraformTargetVersions,
+} from "@cdktn/commons";
+import { ModuleGenerator } from "../../generator/module-generator";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+async function docsComment(
+  source: string,
+  targetVersions?: TerraformTargetVersions,
+): Promise<string> {
+  const workdir = tmp("module-docs-registry");
+  const target = ConstructsMakerModuleTarget.from(
+    new TerraformModuleConstraint(source),
+    Language.TYPESCRIPT,
+  ) as ConstructsMakerModuleTarget;
+  target.spec = { name: target.name, inputs: [], outputs: [] };
+
+  const code = new CodeMaker();
+  new ModuleGenerator(code, [target], targetVersions);
+  await code.save(workdir);
+
+  const emitted = fs.readFileSync(path.join(workdir, target.fileName), "utf-8");
+  const line = emitted
+    .split("\n")
+    .find((l) => l.includes("Docs at") || l.includes("Source at"));
+  return (line ?? "").trim();
+}
+
+describe("generated module docs links", () => {
+  const module = "terraform-aws-modules/vpc/aws@3.19.0";
+  const submodule =
+    "terraform-aws-modules/vpc/aws//modules/vpc-endpoints@3.19.0";
+
+  it("uses the Terraform Registry when nothing is declared", async () => {
+    expect(await docsComment(module)).toContain(
+      "https://registry.terraform.io/modules/terraform-aws-modules/vpc/aws/3.19.0",
+    );
+  });
+
+  it("uses the OpenTofu Registry when only OpenTofu is declared", async () => {
+    const comment = await docsComment(module, { opentofu: ">=1.6.0" });
+    expect(comment).toContain("Docs at OpenTofu Registry");
+    expect(comment).toContain(
+      "https://search.opentofu.org/module/terraform-aws-modules/vpc/aws/v3.19.0",
+    );
+  });
+
+  it("links an OpenTofu submodule with the singular segment", async () => {
+    expect(await docsComment(submodule, { opentofu: ">=1.6.0" })).toContain(
+      "https://search.opentofu.org/module/terraform-aws-modules/vpc/aws/v3.19.0/submodule/vpc-endpoints",
+    );
+  });
+
+  // Registries serve submodule pages only for a direct child of `modules/`
+  // (checked against rendered pages); anything else links to the module.
+  it.each([
+    [
+      "an examples path",
+      "terraform-aws-modules/vpc/aws//examples/complete@3.19.0",
+    ],
+    [
+      "a nested modules path",
+      "terraform-aws-modules/vpc/aws//modules/x/y@3.19.0",
+    ],
+  ])("links %s to the module page", async (_name, source) => {
+    expect(await docsComment(source)).toContain(
+      "{@link https://registry.terraform.io/modules/terraform-aws-modules/vpc/aws/3.19.0 ",
+    );
+    expect(await docsComment(source, { opentofu: ">=1.6.0" })).toContain(
+      "{@link https://search.opentofu.org/module/terraform-aws-modules/vpc/aws/v3.19.0 ",
+    );
+  });
+
+  it("keeps the Terraform submodule shape unchanged", async () => {
+    expect(await docsComment(submodule)).toContain(
+      "https://registry.terraform.io/modules/terraform-aws-modules/vpc/aws/3.19.0/submodules/vpc-endpoints",
+    );
+  });
+});

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/__tests__/registry-class-invalidation.test.ts

@@ -0,0 +1,123 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs-extra";
+import * as path from "path";
+import {
+  Language,
+  TerraformProviderConstraint,
+  TerraformTargetVersions,
+} from "@cdktn/commons";
+import { createTmpHelper } from "./util";
+
+const mockReadSchema = jest.fn();
+jest.mock("@cdktn/provider-schema", () => ({
+  readSchema: (...args: unknown[]) => mockReadSchema(...args),
+}));
+
+// Imported after the mock so ConstructsMaker picks up the mocked readSchema.
+import { ConstructsMaker } from "../constructs-maker";
+
+const tmp = createTmpHelper();
+
+// No resources, so generation stays in TypeScript emission.
+const fakeSchema = {
+  providerSchema: {
+    format_version: "0.2" as const,
+    provider_schemas: {
+      "registry.terraform.io/hashicorp/random": {
+        resource_schemas: null,
+        data_source_schemas: null,
+      },
+    },
+    provider_versions: { "registry.terraform.io/hashicorp/random": "3.2.0" },
+    cli_name: "terraform",
+    cli_version: "1.7.5",
+  },
+};
+
+describe("filterAlreadyGenerated: registry class", () => {
+  const constraint = new TerraformProviderConstraint("hashicorp/random@=3.2.0");
+  let outdir: string;
+
+  const maker = (targetVersions?: TerraformTargetVersions) =>
+    new ConstructsMaker({
+      codeMakerOutput: outdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    });
+
+  /** A real previous `cdktn get`, so constraints.json is what generation writes. */
+  const generateWith = (targetVersions?: TerraformTargetVersions) =>
+    maker(targetVersions).generate([constraint]);
+
+  beforeEach(() => {
+    mockReadSchema.mockReset();
+    mockReadSchema.mockResolvedValue(fakeSchema);
+    outdir = tmp("registry-class");
+  });
+
+  it.each<
+    [
+      string,
+      TerraformTargetVersions | undefined,
+      TerraformTargetVersions | undefined,
+    ]
+  >([
+    ["nothing changed", undefined, undefined],
+    [
+      "both products declared, the same class as nothing",
+      undefined,
+      { terraform: ">=1.5.7", opentofu: ">=1.6.0" },
+    ],
+    [
+      "a range moving within the OpenTofu class",
+      { opentofu: ">=1.6.0" },
+      { opentofu: ">=1.8.0" },
+    ],
+  ])("skips regeneration: %s", async (_name, before, after) => {
+    await generateWith(before);
+
+    await expect(
+      maker(after).filterAlreadyGenerated([constraint]),
+    ).resolves.toEqual([]);
+  });
+
+  it("regenerates when the project switches to OpenTofu-only", async () => {
+    await generateWith(undefined);
+
+    await expect(
+      maker({ opentofu: ">=1.6.0" }).filterAlreadyGenerated([constraint]),
+    ).resolves.toEqual([constraint]);
+  });
+
+  it("regenerates when the project switches away from OpenTofu-only", async () => {
+    await generateWith({ opentofu: ">=1.6.0" });
+
+    await expect(
+      maker({ terraform: ">=1.5.7" }).filterAlreadyGenerated([constraint]),
+    ).resolves.toEqual([constraint]);
+  });
+
+  // constraints.json written before targetVersions was stamped has no such field;
+  // it must read as the Terraform class, which is what it was generated for.
+  describe("constraints.json from before targetVersions was recorded", () => {
+    beforeEach(async () => {
+      await generateWith({ terraform: ">=1.5.7" });
+      const file = path.join(outdir, "constraints.json");
+      const { targetVersions: _dropped, ...older } = fs.readJsonSync(file);
+      fs.writeJsonSync(file, older);
+    });
+
+    it("is fresh for a Terraform project", async () => {
+      await expect(
+        maker().filterAlreadyGenerated([constraint]),
+      ).resolves.toEqual([]);
+    });
+
+    it("is stale for an OpenTofu-only project", async () => {
+      await expect(
+        maker({ opentofu: ">=1.6.0" }).filterAlreadyGenerated([constraint]),
+      ).resolves.toEqual([constraint]);
+    });
+  });
+});

package/src/get/__tests__/target-versions.test.ts

@@ -3,8 +3,10 @@
 import * as fs from "fs-extra";
 import * as path from "path";
 import {
+  ConstructsMakerModuleTarget,
   Language,
   TerraformDependencyConstraint,
+  TerraformModuleConstraint,
   TerraformTargetVersions,
 } from "@cdktn/commons";
 import { createTmpHelper } from "./util";
@@ -204,3 +206,44 @@ describe("targetVersions threading through 'cdktn get'", () => {
     expect(toGenerate).toEqual([]);
   });
 });
+
+describe("targetVersions reaching generated module bindings", () => {
+  const moduleConstraint = new TerraformModuleConstraint(
+    "terraform-aws-modules/vpc/aws@3.19.0",
+  );
+
+  const emittedSources = (dir: string): string[] =>
+    fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) return emittedSources(full);
+      return entry.name.endsWith(".ts") ? [fs.readFileSync(full, "utf8")] : [];
+    });
+
+  beforeEach(() => {
+    mockReadSchema.mockReset();
+    const target = ConstructsMakerModuleTarget.from(
+      moduleConstraint,
+      Language.TYPESCRIPT,
+    ) as ConstructsMakerModuleTarget;
+    mockReadSchema.mockResolvedValue({
+      moduleSchema: {
+        [target.moduleKey]: { name: target.name, inputs: [], outputs: [] },
+      },
+    });
+  });
+
+  it("links an OpenTofu-only project's modules to the OpenTofu registry", async () => {
+    const workdir = tmp("target-versions-module.test");
+    const maker = new ConstructsMaker({
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions: { opentofu: ">=1.6.0" },
+    });
+
+    await maker.generate([moduleConstraint]);
+
+    expect(emittedSources(workdir).join("\n")).toContain(
+      "https://search.opentofu.org/module/terraform-aws-modules/vpc/aws/v3.19.0",
+    );
+  });
+});