@cdktn/provider-generator 0.23.0-pre.8 → 0.23.1

package/build/get/__tests__/generator/types.test.js

@@ -0,0 +1,312 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const provider_generator_1 = require("../../generator/provider-generator");
+const codemaker_1 = require("codemaker");
+const util_1 = require("../util");
+const tmp = (0, util_1.createTmpHelper)();
+test("computed optional complex attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("computed-complex-option.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "computed-optional-complex.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/computed-optional-complex/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("computed complex attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("computed-complex.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "computed-complex.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/computed-complex/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("computed complex nested attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("computed-complex-nested.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "computed-complex-nested.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/computed-complex-nested/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("string list attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("string-list.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "string-list.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/string-list/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("number list attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("number-list.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "number-list.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/number-list/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("boolean list attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("boolean-list.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "boolean-list.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/boolean-list/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("string map attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("string-map.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "string-map.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/string-map/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("number map attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("number-map.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "number-map.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/number-map/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("boolean map attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("boolean-map.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "boolean-map.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/boolean-map/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("deeply nested block types", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("block-types.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "deeply-nested-block-types.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/deeply-nested-block-types/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("single block type", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("single-block-type.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "single-block-type.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/single-block-type/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("set / list block type", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("set-list-block.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "block-type-set-list.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/block-type-set-list/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("computed nested complex list block type", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("nested-computed-list-block.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "block-type-nested-computed-list.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/block-type-nested-computed-list/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("primitive string", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("primitive-string.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "primitive-string.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/primitive-string/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("primitive number", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("primitive-number.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "primitive-number.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/primitive-number/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("primitive boolean", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("primitive-boolean.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "primitive-boolean.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/primitive-boolean/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("primitive dynamic", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("primitive-dynamic.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "primitive-dynamic.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/primitive-dynamic/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("ignored attributes", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("ignored-attributes.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "ignored-attributes.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/ignored-attributes/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("incompatible attribute names", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("incompatible-attribute-names.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "incompatible-attribute-names.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/incompatible-attribute-names/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("incompatible resource names", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("incompatible-resource-names.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "incompatible-resource-names.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const files = fs.readdirSync(path.join(workdir, "providers/test"));
+    const topLevelFiles = ["index.ts", "lazy-index.ts"];
+    expect(files).toMatchInlineSnapshot(`
+    [
+      "function-resource",
+      "index.ts",
+      "lazy-index.ts",
+      "license-resource",
+      "object-resource",
+      "provider-resource",
+      "static-resource",
+      "string-resource",
+      "version-resource",
+    ]
+  `);
+    for (const file of files) {
+        const output = fs.readFileSync(path.join(workdir, "providers/test/", file, topLevelFiles.includes(file) ? "" : "index.ts"), "utf-8");
+        expect(output).toMatchSnapshot(file); // use filename as snapshot indicator to not depend on order of files (e.g. if new file appears)
+    }
+});
+test("list of string map attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("list-of-string-map.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "list-of-string-map.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/list-of-string-map/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("map of string list attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("map-of-string-list.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "map-of-string-list.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/map-of-string-list/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("reset and input name conflicts", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("name-conflict.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "name-conflict.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/name-conflict/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("list of list attributes", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("list-list-object.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "list-list-object.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/test/complex/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("list of list of strings", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("list-list-string.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "list-list-string.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    // const resourceOutput = fs.readFileSync(
+    //   path.join(workdir, "providers/test/airbyte-connection/index.ts"),
+    //   "utf-8"
+    // );
+    // expect(resourceOutput).toMatchSnapshot();
+    const datasourceOutput = fs.readFileSync(path.join(workdir, "providers/test/data-airbyte-source-schema-catalog/index.ts"), "utf-8");
+    expect(datasourceOutput).toMatchSnapshot();
+});
+test("map of map of string attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("map-of-map-of-string.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "map-of-map-of-string.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/aws/map-of-map-of-string/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+});
+test("case-insensitive base name collision", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("case-insensitive-base-name-collision.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "case-insensitive-base-name-collision.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const files = fs.readdirSync(path.join(workdir, "providers/oci"));
+    const topLevelFiles = ["index.ts", "lazy-index.ts"];
+    // Verify that colliding base names are disambiguated with a "-a" suffix.
+    expect(files).toContain("load-balancer-backend-set");
+    expect(files).toContain("load-balancer-backendset-a");
+    expect(files).toContain("data-oci-load-balancer-backend-sets");
+    expect(files).toContain("data-oci-load-balancer-backendsets-a");
+    // No two directories should collide case-insensitively
+    const lowercaseFiles = files.map((f) => f.toLowerCase());
+    const uniqueLowercaseFiles = [...new Set(lowercaseFiles)];
+    expect(lowercaseFiles).toEqual(uniqueLowercaseFiles);
+    for (const file of files) {
+        const output = fs.readFileSync(path.join(workdir, "providers/oci/", file, topLevelFiles.includes(file) ? "" : "index.ts"), "utf-8");
+        expect(output).toMatchSnapshot(file);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.test.js","sourceRoot":"","sources":["../../../../src/get/__tests__/generator/types.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { TerraformProviderGenerator } from \"../../generator/provider-generator\";\nimport { CodeMaker } from \"codemaker\";\nimport { createTmpHelper } from \"../util\";\n\nconst tmp = createTmpHelper();\n\ntest(\"computed optional complex attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"computed-complex-option.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"computed-optional-complex.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/computed-optional-complex/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"computed complex attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"computed-complex.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"computed-complex.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/computed-complex/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"computed complex nested attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"computed-complex-nested.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"computed-complex-nested.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/computed-complex-nested/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"string list attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"string-list.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"string-list.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/string-list/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"number list attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"number-list.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"number-list.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/number-list/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"boolean list attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"boolean-list.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"boolean-list.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/boolean-list/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"string map attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"string-map.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"string-map.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/string-map/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"number map attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"number-map.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"number-map.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/number-map/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"boolean map attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"boolean-map.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"boolean-map.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/boolean-map/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"deeply nested block types\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"block-types.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"deeply-nested-block-types.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/deeply-nested-block-types/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"single block type\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"single-block-type.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"single-block-type.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/single-block-type/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"set / list block type\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"set-list-block.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"block-type-set-list.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/block-type-set-list/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"computed nested complex list block type\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"nested-computed-list-block.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"block-type-nested-computed-list.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(\n      workdir,\n      \"providers/aws/block-type-nested-computed-list/index.ts\",\n    ),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"primitive string\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"primitive-string.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"primitive-string.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/primitive-string/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"primitive number\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"primitive-number.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"primitive-number.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/primitive-number/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"primitive boolean\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"primitive-boolean.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"primitive-boolean.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/primitive-boolean/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"primitive dynamic\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"primitive-dynamic.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"primitive-dynamic.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/primitive-dynamic/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"ignored attributes\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"ignored-attributes.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"ignored-attributes.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/ignored-attributes/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"incompatible attribute names\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"incompatible-attribute-names.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"incompatible-attribute-names.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/incompatible-attribute-names/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"incompatible resource names\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"incompatible-resource-names.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"incompatible-resource-names.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const files = fs.readdirSync(path.join(workdir, \"providers/test\"));\n  const topLevelFiles = [\"index.ts\", \"lazy-index.ts\"];\n  expect(files).toMatchInlineSnapshot(`\n    [\n      \"function-resource\",\n      \"index.ts\",\n      \"lazy-index.ts\",\n      \"license-resource\",\n      \"object-resource\",\n      \"provider-resource\",\n      \"static-resource\",\n      \"string-resource\",\n      \"version-resource\",\n    ]\n  `);\n\n  for (const file of files) {\n    const output = fs.readFileSync(\n      path.join(\n        workdir,\n        \"providers/test/\",\n        file,\n        topLevelFiles.includes(file) ? \"\" : \"index.ts\",\n      ),\n      \"utf-8\",\n    );\n    expect(output).toMatchSnapshot(file); // use filename as snapshot indicator to not depend on order of files (e.g. if new file appears)\n  }\n});\n\ntest(\"list of string map attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"list-of-string-map.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"list-of-string-map.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/list-of-string-map/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"map of string list attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"map-of-string-list.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"map-of-string-list.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/map-of-string-list/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"reset and input name conflicts\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"name-conflict.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"name-conflict.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/name-conflict/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"list of list attributes\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"list-list-object.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"list-list-object.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/test/complex/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"list of list of strings\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"list-list-string.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"list-list-string.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  // const resourceOutput = fs.readFileSync(\n  //   path.join(workdir, \"providers/test/airbyte-connection/index.ts\"),\n  //   \"utf-8\"\n  // );\n  // expect(resourceOutput).toMatchSnapshot();\n\n  const datasourceOutput = fs.readFileSync(\n    path.join(\n      workdir,\n      \"providers/test/data-airbyte-source-schema-catalog/index.ts\",\n    ),\n    \"utf-8\",\n  );\n  expect(datasourceOutput).toMatchSnapshot();\n});\n\ntest(\"map of map of string attribute\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"map-of-map-of-string.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"map-of-map-of-string.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const output = fs.readFileSync(\n    path.join(workdir, \"providers/aws/map-of-map-of-string/index.ts\"),\n    \"utf-8\",\n  );\n  expect(output).toMatchSnapshot();\n});\n\ntest(\"case-insensitive base name collision\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"case-insensitive-base-name-collision.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"case-insensitive-base-name-collision.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const files = fs.readdirSync(path.join(workdir, \"providers/oci\"));\n  const topLevelFiles = [\"index.ts\", \"lazy-index.ts\"];\n\n  // Verify that colliding base names are disambiguated with a \"-a\" suffix.\n  expect(files).toContain(\"load-balancer-backend-set\");\n  expect(files).toContain(\"load-balancer-backendset-a\");\n\n  expect(files).toContain(\"data-oci-load-balancer-backend-sets\");\n  expect(files).toContain(\"data-oci-load-balancer-backendsets-a\");\n\n  // No two directories should collide case-insensitively\n  const lowercaseFiles = files.map((f) => f.toLowerCase());\n  const uniqueLowercaseFiles = [...new Set(lowercaseFiles)];\n  expect(lowercaseFiles).toEqual(uniqueLowercaseFiles);\n\n  for (const file of files) {\n    const output = fs.readFileSync(\n      path.join(\n        workdir,\n        \"providers/oci/\",\n        file,\n        topLevelFiles.includes(file) ? \"\" : \"index.ts\",\n      ),\n      \"utf-8\",\n    );\n    expect(output).toMatchSnapshot(file);\n  }\n});\n"]}

package/build/get/__tests__/generator/versions-file.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=versions-file.test.d.ts.map

package/build/get/__tests__/generator/versions-file.test.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const commons_1 = require("@cdktn/commons");
+const constructs_maker_1 = require("../../constructs-maker");
+const util_1 = require("../util");
+const tmp = (0, util_1.createTmpHelper)();
+jest.setTimeout(600000);
+global.setImmediate =
+    global.setImmediate ||
+        ((fn, ...args) => global.setTimeout(fn, 0, ...args));
+describe("versions.json file generation", () => {
+    const languages = [commons_1.Language.TYPESCRIPT, commons_1.Language.PYTHON];
+    const constraints = [
+        {
+            fqn: "hashicorp/aws",
+            name: "aws",
+            source: "hashicorp/aws",
+            version: "4.0.0",
+        },
+        {
+            fqn: "hashicorp/random",
+            name: "random",
+            source: "hashicorp/random",
+            version: "3.1.3",
+        },
+        {
+            fqn: "kreuzwerker/docker",
+            name: "docker",
+            source: "kreuzwerker/docker",
+            version: "2.16.0",
+        },
+    ];
+    beforeAll(() => { });
+    test.each(languages)("generates a file for the %s language", async (language) => {
+        const workdir = tmp("versions-file.test");
+        const options = {
+            codeMakerOutput: workdir,
+            targetLanguage: language,
+        };
+        // Ignore warnings to pop up from the generate function
+        process.env.NODE_OPTIONS = "--max-old-space-size=16384";
+        const constructMaker = new constructs_maker_1.ConstructsMaker(options, process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH);
+        await constructMaker.generate(constraints);
+        const output = fs.readFileSync(path.join(workdir, "versions.json"), "utf-8");
+        expect(Object.keys(JSON.parse(output))).toEqual(expect.arrayContaining(constraints.map((c) => `registry.terraform.io/${c.fqn}`)));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/get/__tests__/util.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a per-test-file temp-dir helper.
+ *
+ * Returns a `tmp(prefix)` function that creates a uniquely-named directory
+ * under `os.tmpdir()` and tracks it. An `afterAll` hook is registered on
+ * the calling test file's scope; when the file finishes running, every
+ * tracked directory is removed (recursively, force).
+ */
+export declare function createTmpHelper(): (prefix: string) => string;
+export declare function expectModuleToMatchSnapshot(testName: string, testCategory: string, fixtureNames: string[]): void;
+//# sourceMappingURL=util.d.ts.map

package/build/get/__tests__/util.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectModuleToMatchSnapshot = exports.createTmpHelper = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const commons_1 = require("@cdktn/commons");
+const constructs_maker_1 = require("../constructs-maker");
+const path = __importStar(require("path"));
+/**
+ * Creates a per-test-file temp-dir helper.
+ *
+ * Returns a `tmp(prefix)` function that creates a uniquely-named directory
+ * under `os.tmpdir()` and tracks it. An `afterAll` hook is registered on
+ * the calling test file's scope; when the file finishes running, every
+ * tracked directory is removed (recursively, force).
+ */
+function createTmpHelper() {
+    const dirs = [];
+    afterAll(() => {
+        for (const d of dirs)
+            fs.rmSync(d, { recursive: true, force: true });
+    });
+    return (prefix) => {
+        const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+        dirs.push(d);
+        return d;
+    };
+}
+exports.createTmpHelper = createTmpHelper;
+function expectModuleToMatchSnapshot(testName, testCategory, fixtureNames) {
+    test(testName, async () => {
+        await (0, commons_1.withTempDir)(`${testName.replace(/\s*/, "-")}.test`, async () => {
+            const curdir = process.cwd();
+            fs.mkdirSync("module");
+            fixtureNames.forEach((fixtureName) => {
+                fs.copyFileSync(path.join(__dirname, testCategory, "fixtures", fixtureName), path.join(curdir, "module", fixtureName));
+            });
+            const constraint = new commons_1.TerraformModuleConstraint({
+                source: "./module",
+                name: "module",
+                fqn: "module",
+            });
+            fs.mkdirSync("work");
+            const workdir = path.join(curdir, "work");
+            const maker = new constructs_maker_1.ConstructsMaker({
+                codeMakerOutput: workdir,
+                targetLanguage: commons_1.Language.TYPESCRIPT,
+            }, process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH);
+            await maker.generate([constraint]);
+            const output = fs.readFileSync(path.join(workdir, "modules/module.ts"), "utf-8");
+            expect(output).toMatchSnapshot();
+        });
+    });
+}
+exports.expectModuleToMatchSnapshot = expectModuleToMatchSnapshot;
+//# sourceMappingURL=data:application/json;base64,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

package/{lib → build}/get/constructs-maker.d.ts

@@ -71,7 +71,7 @@ export declare class ConstructsMaker {
     removeFoldersThatShouldNotExist(constraintsThatShouldExist: TerraformDependencyConstraint[]): Promise<void>;
     private emitConstraintsFile;
     private generateJsiiLanguage;
-    getSchemas(targets: TerraformDependencyConstraint[]): Promise<import("@cdktn/provider-schema/src/read").Schema>;
+    getSchemas(targets: TerraformDependencyConstraint[]): Promise<import("@cdktn/provider-schema/build/read").Schema>;
     generate(allConstraints: TerraformDependencyConstraint[], constraintsToGenerate?: TerraformDependencyConstraint[]): Promise<void>;
     private save;
     private get isJavascriptTarget();
@@ -89,3 +89,4 @@ export declare class ConstructsMaker {
  * @throws an Error if no go.mod was found
  */
 export declare const determineGoModuleName: (dir: string) => Promise<string>;
+//# sourceMappingURL=constructs-maker.d.ts.map