@cdktn/provider-generator 0.24.0-pre.45 → 0.24.0-pre.48

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

@@ -0,0 +1,118 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs-extra";
+import * as os from "os";
+import * as path from "path";
+import {
+  Language,
+  ConstructsMakerModuleTarget,
+  ConstructsMakerProviderTarget,
+} from "@cdktn/commons";
+import { determineGoModuleName } from "../constructs-maker";
+
+describe("constructsMaker", () => {
+  describe("determineGoModuleName", () => {
+    let tmpDir: string;
+    let emptySubDir: string, validSubdir: string, invalidSubdir: string;
+
+    beforeAll(async () => {
+      tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "cdktf.test"));
+      /* test directory layout
+       * <tmpDir>
+       * ├── go.mod
+       * └── subdir
+       *     ├── empty
+       *     ├── valid
+       *     │   └── go.mod
+       *     └── invalid
+       *         └── go.mod
+       */
+      emptySubDir = path.join(tmpDir, "subdir", "empty");
+      validSubdir = path.join(tmpDir, "subdir", "valid");
+      invalidSubdir = path.join(tmpDir, "subdir", "invalid");
+
+      await fs.mkdirs(emptySubDir);
+      await fs.mkdirs(validSubdir);
+      await fs.mkdirs(invalidSubdir);
+
+      const root = `module cdk.tf/test/go`;
+      const valid = `module cdk.tf/test/go-valid-subdir`;
+      const invalid = `malformed go mod`;
+
+      await fs.writeFile(path.join(tmpDir, "go.mod"), root);
+      await fs.writeFile(path.join(validSubdir, "go.mod"), valid);
+      await fs.writeFile(path.join(invalidSubdir, "go.mod"), invalid);
+    });
+
+    afterAll(async () => {
+      await fs.remove(tmpDir);
+    });
+
+    it("works in root directory", async () => {
+      const moduleName = await determineGoModuleName(tmpDir);
+      expect(moduleName).toBe("cdk.tf/test/go");
+    });
+
+    it("can walk upwards from empty directory", async () => {
+      const moduleName = await determineGoModuleName(emptySubDir);
+      expect(moduleName).toBe("cdk.tf/test/go/subdir/empty");
+    });
+
+    it("works in subdirectory with go.mod", async () => {
+      const moduleName = await determineGoModuleName(validSubdir);
+      expect(moduleName).toBe("cdk.tf/test/go-valid-subdir");
+    });
+
+    it("throws if go.mod is invalid", async () => {
+      await expect(determineGoModuleName(invalidSubdir)).rejects.toThrow(
+        `Could not determine the root Go module name. Found ${path.join(
+          invalidSubdir,
+          "go.mod",
+        )} but failed to regex match the module name directive`,
+      );
+    });
+
+    it("works from subdirectory that does not exist yet", async () => {
+      const moduleName = await determineGoModuleName(
+        path.join(tmpDir, "subdir", "that", "does", "not", "exist", "yet"),
+      );
+      expect(moduleName).toBe("cdk.tf/test/go/subdir/that/does/not/exist/yet");
+    });
+
+    it("throws if nothing could be found", async () => {
+      const dir = "/cdktf-test/this/dir/does/not/exist"; //... and has no go.mod in any parent dir
+      await expect(determineGoModuleName(dir)).rejects.toThrow(
+        `Could not determine the root Go module name. No go.mod found in ${dir} and any parent directories`,
+      );
+    });
+  });
+  describe("ConstructsMakerProviderTarget", () => {
+    it("returns valid package name for Go", () => {
+      const target = new ConstructsMakerProviderTarget(
+        {
+          name: "google-beta",
+          fqn: "google-beta",
+          source: "google-beta",
+          version: "~> 4.0",
+        },
+        Language.GO,
+      );
+      expect(target.srcMakName).toEqual("google_beta");
+    });
+  });
+  describe("ConstructsMakerModuleTarget", () => {
+    it("returns valid package name for Go", () => {
+      const target = new ConstructsMakerModuleTarget(
+        {
+          name: "security-group",
+          source: "terraform-aws-modules/security-group/aws",
+          fqn: "terraform-aws-modules/security-group/aws",
+          version: "4.9.0",
+          namespace: "terraform-aws-modules/aws",
+        },
+        Language.GO,
+      );
+      expect(target.srcMakName).toEqual("security_group");
+    });
+  });
+});

package/src/get/__tests__/generator/complex-computed-types.test.ts

@@ -0,0 +1,28 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate an acm certifacte resource with complex computed types", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("complex-computed-types.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "aws_acm_certificate.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/acm-certificate/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot(`acm-certificate`);
+});

package/src/get/__tests__/generator/deep-nested-attributes.test.ts

@@ -0,0 +1,56 @@
+// Copyright (c) HashiCorp, Inc // SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate a resource with attribute that's a list of a map of an object", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("deep-nested-attributes.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "stripe-schema.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/stripe/invoiceitems/index.ts"),
+    "utf-8",
+  );
+
+  expect(output).toEqual(
+    expect.stringContaining(
+      `export class InvoiceitemsDiscountsMapList extends cdktn.MapList {`,
+    ),
+  );
+});
+
+test("generate a resource with attribute that's a map of a list of an object", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("deep-nested-attributes-list.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "deep-attributes.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/stripe/invoiceitems/index.ts"),
+    "utf-8",
+  );
+
+  expect(output).toEqual(
+    expect.stringContaining(
+      `export class InvoiceitemsDiscountsListMap extends cdktn.ComplexMap {`,
+    ),
+  );
+});

package/src/get/__tests__/generator/description-escaping.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 { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("broken attribute description comments", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("description-escaping.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "description-escaping.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/google/description-escaping/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+// That popped up in the google-beta provider which transforms markdown fenced
+// code blocks from the actual markdown docs to the provider schema (``` => ''')
+// see
+//  - https://raw.githubusercontent.com/hashicorp/terraform-provider-google-beta/4094e3bdd530ca853a046a6d938807f8a131c7c7/website/docs/r/iam_workload_identity_pool_provider.html.markdown
+//  - https://github.com/hashicorp/terraform-provider-google-beta/blob/4094e3bdd530ca853a046a6d938807f8a131c7c7/google-beta/resource_iam_beta_workload_identity_pool_provider.go
+
+test("malformed code blocks which break in python rst", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("markdown-description-with-code-blocks.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "markdown-description-with-code-blocks.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/code-blocks/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("comment ending sequence in comment", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("comment-ending-sequence.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "comment-ending-sequence.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/code-blocks/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});

package/src/get/__tests__/generator/empty-provider-resources.test.ts

@@ -0,0 +1,26 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("provider with no resources", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("empty-provider-resources.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "empty-provider-resources.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+});

package/src/get/__tests__/generator/export-sharding.test.ts

@@ -0,0 +1,169 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+// this is a workaround for a bug introduced in TS 3.9.x and seems to be unlikely to get fixed.
+// Since jsii relies on TS < 4 at the moment we can't use newer TS versions which have this fixed (^4.1).
+// see https://github.com/hashicorp/terraform-cdk/pull/1248 for more context
+test("shard exports across multiple files to avoid generating files with more than a 1000 exports", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("export-sharding.test");
+
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "aws_wafv2_web_acl.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/test/wafv2-web-acl/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot(`wafv2-web-acl-resource`);
+
+  const outputStructsIndex = fs.readFileSync(
+    path.join(workdir, "providers/test/wafv2-web-acl/index-structs/index.ts"),
+    "utf-8",
+  );
+  expect(outputStructsIndex).toMatchSnapshot(`structs-index`);
+
+  const outputStructs0 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs0.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs0).toMatchSnapshot(`structs0`);
+
+  const outputStructs400 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs400.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs400).toMatchSnapshot(`structs400`);
+
+  const outputStructs800 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs800.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs800).toMatchSnapshot(`structs800`);
+
+  const outputStructs1200 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs1200.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs1200).toMatchSnapshot(`structs1200`);
+
+  const outputStructs1600 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs1600.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs1600).toMatchSnapshot(`structs1600`);
+
+  const outputStructs2000 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs2000.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs2000).toMatchSnapshot(`structs2000`);
+
+  const outputStructs2400 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs2400.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs2400).toMatchSnapshot(`structs2400`);
+
+  const outputStructs2800 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs2800.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs2800).toMatchSnapshot(`structs2800`);
+
+  const outputStructs3200 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs3200.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs3200).toMatchSnapshot(`structs3200`);
+
+  const outputStructs3600 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/wafv2-web-acl/index-structs/structs3600.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs3600).toMatchSnapshot(`structs3600`);
+});
+
+test("shard exports across multiple files to avoid generating files with more than a 1000 exports in a provider without namespaces", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("export-sharding-no-namespace.test");
+
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "datadog_dashboard.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/datadog/dashboard/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot(`dashboard-resource`);
+
+  const outputStructsIndex = fs.readFileSync(
+    path.join(workdir, "providers/datadog/dashboard/index-structs/index.ts"),
+    "utf-8",
+  );
+  expect(outputStructsIndex).toMatchSnapshot(`structs-index`);
+
+  const outputStructs0 = fs.readFileSync(
+    path.join(workdir, "providers/datadog/dashboard/index-structs/structs0.ts"),
+    "utf-8",
+  );
+  expect(outputStructs0).toMatchSnapshot(`structs0`);
+
+  const outputStructs400 = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/datadog/dashboard/index-structs/structs400.ts",
+    ),
+    "utf-8",
+  );
+  expect(outputStructs400).toMatchSnapshot(`structs400`);
+});

package/src/get/__tests__/generator/import-style.test.ts

@@ -0,0 +1,129 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { CodeMaker } from "codemaker";
+import {
+  TerraformProviderGenerator,
+  type TerraformProviderGeneratorOptions,
+} from "../../generator/provider-generator";
+
+const fixture = JSON.parse(
+  fs.readFileSync(
+    path.join(__dirname, "fixtures", "aws_wafv2_web_acl.test.fixture.json"),
+    "utf-8",
+  ),
+);
+
+async function generate(options: TerraformProviderGeneratorOptions = {}) {
+  const code = new CodeMaker();
+  const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "import-style.test"));
+  new TerraformProviderGenerator(code, fixture, options).generateAll();
+  await code.save(workdir);
+  return workdir;
+}
+
+const RESOURCE_INDEX = "providers/test/wafv2-web-acl/index.ts";
+const STRUCTS_INDEX = "providers/test/wafv2-web-acl/index-structs/index.ts";
+const STRUCTS_DIR = "providers/test/wafv2-web-acl/index-structs";
+const PROVIDER_INDEX = "providers/test/index.ts";
+
+function readAllShards(workdir: string): string {
+  return fs
+    .readdirSync(path.join(workdir, STRUCTS_DIR))
+    .filter((f) => /^structs\d+\.ts$/.test(f))
+    .map((f) => fs.readFileSync(path.join(workdir, STRUCTS_DIR, f), "utf-8"))
+    .join("\n");
+}
+
+test("default (no importExtension): emits explicit /index for folders, bare for files", async () => {
+  const workdir = await generate();
+
+  const resource = fs.readFileSync(path.join(workdir, RESOURCE_INDEX), "utf-8");
+  expect(resource).toContain(`} from './index-structs/index'`);
+  expect(resource).toContain(`export * from './index-structs/index'`);
+  expect(resource).not.toMatch(/from '\.\/[^']*\.(js|ts)'/);
+
+  const structsIndex = fs.readFileSync(
+    path.join(workdir, STRUCTS_INDEX),
+    "utf-8",
+  );
+  expect(structsIndex).toContain(`export * from './structs0'`);
+  expect(structsIndex).not.toMatch(/from '\.\/[^']*\.(js|ts)'/);
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, PROVIDER_INDEX),
+    "utf-8",
+  );
+  expect(providerIndex).toMatch(/from '\.\/[^']+\/index';/);
+});
+
+test("importExtension '.js': emits fully-qualified ./<folder>/index.js and ./<file>.js", async () => {
+  const workdir = await generate({ importExtension: ".js" });
+
+  const resource = fs.readFileSync(path.join(workdir, RESOURCE_INDEX), "utf-8");
+  expect(resource).toContain(`} from './index-structs/index.js'`);
+  expect(resource).toContain(`export * from './index-structs/index.js'`);
+
+  const structsIndex = fs.readFileSync(
+    path.join(workdir, STRUCTS_INDEX),
+    "utf-8",
+  );
+  expect(structsIndex).toContain(`export * from './structs0.js'`);
+
+  const allShards = readAllShards(workdir);
+  expect(allShards).toMatch(/from '\.\/structs\d+\.js'/);
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, PROVIDER_INDEX),
+    "utf-8",
+  );
+  expect(providerIndex).toMatch(/from '\.\/[^']+\/index\.js';/);
+});
+
+test("importExtension '.ts': emits fully-qualified ./<folder>/index.ts and ./<file>.ts", async () => {
+  const workdir = await generate({ importExtension: ".ts" });
+
+  const resource = fs.readFileSync(path.join(workdir, RESOURCE_INDEX), "utf-8");
+  expect(resource).toContain(`} from './index-structs/index.ts'`);
+  expect(resource).toContain(`export * from './index-structs/index.ts'`);
+
+  const structsIndex = fs.readFileSync(
+    path.join(workdir, STRUCTS_INDEX),
+    "utf-8",
+  );
+  expect(structsIndex).toContain(`export * from './structs0.ts'`);
+
+  const allShards = readAllShards(workdir);
+  expect(allShards).toMatch(/from '\.\/structs\d+\.ts'/);
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, PROVIDER_INDEX),
+    "utf-8",
+  );
+  expect(providerIndex).toMatch(/from '\.\/[^']+\/index\.ts';/);
+});
+
+test("importExtension '': emits explicit /index for folders, bare for files", async () => {
+  const workdir = await generate({ importExtension: "" });
+
+  const resource = fs.readFileSync(path.join(workdir, RESOURCE_INDEX), "utf-8");
+  expect(resource).toContain(`} from './index-structs/index'`);
+  expect(resource).toContain(`export * from './index-structs/index'`);
+  expect(resource).not.toMatch(/from '\.\/[^']*\.(js|ts)'/);
+
+  const structsIndex = fs.readFileSync(
+    path.join(workdir, STRUCTS_INDEX),
+    "utf-8",
+  );
+  // file targets get the (empty) extension, so they stay bare
+  expect(structsIndex).toContain(`export * from './structs0'`);
+  expect(structsIndex).not.toMatch(/from '\.\/[^']*\.(js|ts)'/);
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, PROVIDER_INDEX),
+    "utf-8",
+  );
+  expect(providerIndex).toMatch(/from '\.\/[^']+\/index';/);
+});