@cdktn/provider-schema 0.23.0-pre.36 → 0.23.0-pre.39

package/build/__tests__/provider-schema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-schema.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/provider-schema.test.ts"],"names":[],"mappings":""}

package/build/__tests__/provider-schema.test.js

@@ -0,0 +1,180 @@
+"use strict";
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
+const commons_1 = require("@cdktn/commons");
+const provider_schema_1 = require("../provider-schema");
+function sanitizeJson(value) {
+    value["format_version"] = "STUBBED VERSION";
+    return (0, json_stable_stringify_1.default)(value, {
+        space: 2,
+    });
+}
+describe("readSchema", () => {
+    it("generates a single provider schema", async () => {
+        const provider = new commons_1.TerraformProviderConstraint("hashicorp/null@3.1.0");
+        const target = new commons_1.ConstructsMakerProviderTarget(provider, commons_1.Language.TYPESCRIPT);
+        const result = await (0, provider_schema_1.readProviderSchema)(target);
+        expect(sanitizeJson(result)).toMatchSnapshot();
+    }, 120000);
+    it("generates a single module schema", async () => {
+        const module = new commons_1.TerraformModuleConstraint("terraform-aws-modules/iam/aws//modules/iam-account@3.12.0");
+        const target = new commons_1.ConstructsMakerModuleTarget(module, commons_1.Language.TYPESCRIPT);
+        const result = await (0, provider_schema_1.readModuleSchema)(target);
+        expect(sanitizeJson(result)).toMatchSnapshot();
+    }, 120000);
+    it("generates a more complex schema", async () => {
+        const module = new commons_1.TerraformModuleConstraint("terraform-aws-modules/eks/aws@7.0.1");
+        const target = new commons_1.ConstructsMakerModuleTarget(module, commons_1.Language.TYPESCRIPT);
+        const result = await (0, provider_schema_1.readModuleSchema)(target);
+        expect(sanitizeJson(result)).toMatchSnapshot();
+    }, 120000);
+    it("generates a local module", async () => {
+        const module = new commons_1.TerraformModuleConstraint({
+            name: "local_module",
+            fqn: "local_module",
+            source: path.resolve(__dirname, "fixtures", "local-module"),
+        });
+        const target = new commons_1.ConstructsMakerModuleTarget(module, commons_1.Language.TYPESCRIPT);
+        const result = await (0, provider_schema_1.readModuleSchema)(target);
+        expect(sanitizeJson(result)).toMatchSnapshot();
+    }, 120000);
+    it("generates a local module with inline comments in type constraints", async () => {
+        const module = new commons_1.TerraformModuleConstraint({
+            name: "local_module",
+            fqn: "local_module",
+            source: path.resolve(__dirname, "fixtures", "local-module-inline-comments"),
+        });
+        const target = new commons_1.ConstructsMakerModuleTarget(module, commons_1.Language.TYPESCRIPT);
+        const result = await (0, provider_schema_1.readModuleSchema)(target);
+        expect(sanitizeJson(result)).toMatchSnapshot();
+    }, 120000);
+    it("generates a local json module", async () => {
+        const module = new commons_1.TerraformModuleConstraint({
+            name: "local_module",
+            fqn: "local_module",
+            source: path.resolve(__dirname, "fixtures", "local-json-module"),
+        });
+        const target = new commons_1.ConstructsMakerModuleTarget(module, commons_1.Language.TYPESCRIPT);
+        const result = await (0, provider_schema_1.readModuleSchema)(target);
+        expect(sanitizeJson(result)).toMatchSnapshot();
+    }, 120000);
+});
+describe("sanitizeProviderSchema", () => {
+    it("sanitizes a provider schema", () => {
+        const schema = {
+            format_version: "0.1",
+            provider_versions: {
+                "registry.terraform.io/hashicorp/null": "3.1.0",
+            },
+            provider_schemas: {
+                "registry.terraform.io/hashicorp/null": {
+                    provider: {
+                        version: 0,
+                        block: {
+                            attributes: {
+                                version: {
+                                    type: "string",
+                                    required: true,
+                                },
+                                correct: {
+                                    type: ["list", "string"],
+                                },
+                                incorrect: {
+                                    type: ["list", "string", "list", "string"],
+                                },
+                            },
+                            block_types: {
+                                triggers: {
+                                    nesting_mode: "single",
+                                    block: {
+                                        attributes: {
+                                            correct: {
+                                                type: ["list", "string"],
+                                            },
+                                            incorrect: {
+                                                type: ["list", "string", "list", "string"],
+                                            },
+                                        },
+                                        block_types: {},
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    resource_schemas: {
+                        null_resource: {
+                            version: 0,
+                            block: {
+                                attributes: {
+                                    id: {
+                                        type: "string",
+                                        computed: true,
+                                    },
+                                    correct: {
+                                        type: ["list", "string"],
+                                    },
+                                    incorrect: {
+                                        type: ["list", "string", "list", "string"],
+                                    },
+                                },
+                                block_types: {
+                                    triggers: {
+                                        nesting_mode: "single",
+                                        block: {
+                                            attributes: {
+                                                triggers: {
+                                                    type: "string",
+                                                    optional: true,
+                                                },
+                                                correct: {
+                                                    type: ["list", "string"],
+                                                },
+                                                incorrect: {
+                                                    type: ["list", "string", "list", "string"],
+                                                },
+                                            },
+                                            block_types: {},
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    data_source_schemas: {},
+                },
+            },
+        };
+        const result = (0, provider_schema_1.sanitizeProviderSchema)(schema);
+        expect(result).toMatchSnapshot();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-schema.test.js","sourceRoot":"","sources":["../../src/__tests__/provider-schema.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\n\nimport * as path from \"path\";\nimport stableStringify from \"json-stable-stringify\";\nimport {\n  TerraformModuleConstraint,\n  TerraformProviderConstraint,\n  ConstructsMakerModuleTarget,\n  ConstructsMakerProviderTarget,\n  Language,\n  ProviderSchema,\n} from \"@cdktn/commons\";\nimport {\n  readModuleSchema,\n  readProviderSchema,\n  sanitizeProviderSchema,\n} from \"../provider-schema\";\n\nfunction sanitizeJson(value: any) {\n  value[\"format_version\"] = \"STUBBED VERSION\";\n  return stableStringify(value, {\n    space: 2,\n  });\n}\n\ndescribe(\"readSchema\", () => {\n  it(\"generates a single provider schema\", async () => {\n    const provider = new TerraformProviderConstraint(\"hashicorp/null@3.1.0\");\n    const target = new ConstructsMakerProviderTarget(\n      provider,\n      Language.TYPESCRIPT,\n    );\n    const result = await readProviderSchema(target);\n    expect(sanitizeJson(result)).toMatchSnapshot();\n  }, 120000);\n\n  it(\"generates a single module schema\", async () => {\n    const module = new TerraformModuleConstraint(\n      \"terraform-aws-modules/iam/aws//modules/iam-account@3.12.0\",\n    );\n    const target = new ConstructsMakerModuleTarget(module, Language.TYPESCRIPT);\n    const result = await readModuleSchema(target);\n    expect(sanitizeJson(result)).toMatchSnapshot();\n  }, 120000);\n\n  it(\"generates a more complex schema\", async () => {\n    const module = new TerraformModuleConstraint(\n      \"terraform-aws-modules/eks/aws@7.0.1\",\n    );\n    const target = new ConstructsMakerModuleTarget(module, Language.TYPESCRIPT);\n    const result = await readModuleSchema(target);\n    expect(sanitizeJson(result)).toMatchSnapshot();\n  }, 120000);\n\n  it(\"generates a local module\", async () => {\n    const module = new TerraformModuleConstraint({\n      name: \"local_module\",\n      fqn: \"local_module\",\n      source: path.resolve(__dirname, \"fixtures\", \"local-module\"),\n    });\n    const target = new ConstructsMakerModuleTarget(module, Language.TYPESCRIPT);\n    const result = await readModuleSchema(target);\n    expect(sanitizeJson(result)).toMatchSnapshot();\n  }, 120000);\n\n  it(\"generates a local module with inline comments in type constraints\", async () => {\n    const module = new TerraformModuleConstraint({\n      name: \"local_module\",\n      fqn: \"local_module\",\n      source: path.resolve(\n        __dirname,\n        \"fixtures\",\n        \"local-module-inline-comments\",\n      ),\n    });\n    const target = new ConstructsMakerModuleTarget(module, Language.TYPESCRIPT);\n    const result = await readModuleSchema(target);\n    expect(sanitizeJson(result)).toMatchSnapshot();\n  }, 120000);\n\n  it(\"generates a local json module\", async () => {\n    const module = new TerraformModuleConstraint({\n      name: \"local_module\",\n      fqn: \"local_module\",\n      source: path.resolve(__dirname, \"fixtures\", \"local-json-module\"),\n    });\n    const target = new ConstructsMakerModuleTarget(module, Language.TYPESCRIPT);\n    const result = await readModuleSchema(target);\n    expect(sanitizeJson(result)).toMatchSnapshot();\n  }, 120000);\n});\n\ndescribe(\"sanitizeProviderSchema\", () => {\n  it(\"sanitizes a provider schema\", () => {\n    const schema: ProviderSchema = {\n      format_version: \"0.1\" as const,\n      provider_versions: {\n        \"registry.terraform.io/hashicorp/null\": \"3.1.0\",\n      },\n      provider_schemas: {\n        \"registry.terraform.io/hashicorp/null\": {\n          provider: {\n            version: 0,\n            block: {\n              attributes: {\n                version: {\n                  type: \"string\",\n                  required: true,\n                },\n                correct: {\n                  type: [\"list\", \"string\"],\n                },\n                incorrect: {\n                  type: [\"list\", \"string\", \"list\", \"string\"] as any,\n                },\n              },\n              block_types: {\n                triggers: {\n                  nesting_mode: \"single\",\n                  block: {\n                    attributes: {\n                      correct: {\n                        type: [\"list\", \"string\"],\n                      },\n                      incorrect: {\n                        type: [\"list\", \"string\", \"list\", \"string\"] as any,\n                      },\n                    },\n                    block_types: {},\n                  },\n                },\n              },\n            },\n          },\n          resource_schemas: {\n            null_resource: {\n              version: 0,\n              block: {\n                attributes: {\n                  id: {\n                    type: \"string\",\n                    computed: true,\n                  },\n                  correct: {\n                    type: [\"list\", \"string\"],\n                  },\n                  incorrect: {\n                    type: [\"list\", \"string\", \"list\", \"string\"] as any,\n                  },\n                },\n                block_types: {\n                  triggers: {\n                    nesting_mode: \"single\",\n                    block: {\n                      attributes: {\n                        triggers: {\n                          type: \"string\",\n                          optional: true,\n                        },\n                        correct: {\n                          type: [\"list\", \"string\"],\n                        },\n                        incorrect: {\n                          type: [\"list\", \"string\", \"list\", \"string\"] as any,\n                        },\n                      },\n                      block_types: {},\n                    },\n                  },\n                },\n              },\n            },\n          },\n          data_source_schemas: {},\n        },\n      },\n    };\n\n    const result = sanitizeProviderSchema(schema);\n    expect(result).toMatchSnapshot();\n  });\n});\n"]}

package/build/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,qBAAqB,EAAkB,MAAM,gBAAgB,CAAC;AAYvE,wBAAgB,YAAY,CAAC,CAAC,SAAS,qBAAqB,EAAE,CAAC,EAC7D,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GACvB,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CA+B1B"}

package/build/cache.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+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.cachedAccess = void 0;
+const commons_1 = require("@cdktn/commons");
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+// We keep this very simple since the caching feature is experimental
+// we might need to do housekeeping / include terraform / cdktf version in the future
+function cacheKey(input) {
+    return `${encodeURIComponent(input.fqn)}@${encodeURIComponent(input.version || "")}`;
+}
+function cachedAccess(producer, cacheDir) {
+    const cacheEnabled = typeof cacheDir === "string" && cacheDir.length > 0;
+    if (cacheEnabled && !fs.lstatSync(cacheDir).isDirectory()) {
+        throw commons_1.Errors.Usage(`Provider Schema Cache directory '${cacheDir}' is not a directory`);
+    }
+    if (!cacheEnabled) {
+        commons_1.logger.debug(`Provider Schema Cache disabled`);
+        return (input) => {
+            return producer(input);
+        };
+    }
+    commons_1.logger.debug(`Provider Schema Cache enabled, caching at ${cacheDir}`);
+    return async (input) => {
+        const key = cacheKey(input);
+        const cachePath = path.join(cacheDir, `${key}.json`);
+        if (fs.existsSync(cachePath)) {
+            commons_1.logger.debug(`Cache hit for ${key}`);
+            return JSON.parse(await fs.readFile(cachePath, "utf-8"));
+        }
+        commons_1.logger.debug(`Cache miss for ${key}, generating schema`);
+        const result = await producer(input);
+        await fs.writeFile(cachePath, JSON.stringify(result));
+        commons_1.logger.debug(`Write cache for ${key}`);
+        return result;
+    };
+}
+exports.cachedAccess = cachedAccess;
+//# sourceMappingURL=data:application/json;base64,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

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/{src → build}/index.js

@@ -9,4 +9,4 @@ var read_1 = require("./read");
 Object.defineProperty(exports, "readSchema", { enumerable: true, get: function () { return read_1.readSchema; } });
 var provider_schema_1 = require("./provider-schema");
 Object.defineProperty(exports, "parseFQPN", { enumerable: true, get: function () { return provider_schema_1.parseFQPN; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7OztHQUdHOzs7QUFFSCwrQkFBb0M7QUFBM0Isa0dBQUEsVUFBVSxPQUFBO0FBQ25CLHFEQUFrRTtBQUFuRCw0R0FBQSxTQUFTLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmMuXG4gKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTVBMLTIuMFxuICovXG5cbmV4cG9ydCB7IHJlYWRTY2hlbWEgfSBmcm9tIFwiLi9yZWFkXCI7XG5leHBvcnQgeyBGUVBOLCBwYXJzZUZRUE4sIFByb3ZpZGVyTmFtZSB9IGZyb20gXCIuL3Byb3ZpZGVyLXNjaGVtYVwiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7R0FHRzs7O0FBRUgsK0JBQW9DO0FBQTNCLGtHQUFBLFVBQVUsT0FBQTtBQUNuQixxREFBa0U7QUFBbkQsNEdBQUEsU0FBUyxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIEhhc2hpQ29ycCwgSW5jLlxuICogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1QTC0yLjBcbiAqL1xuXG5leHBvcnQgeyByZWFkU2NoZW1hIH0gZnJvbSBcIi4vcmVhZFwiO1xuZXhwb3J0IHsgRlFQTiwgcGFyc2VGUVBOLCBQcm92aWRlck5hbWUgfSBmcm9tIFwiLi9wcm92aWRlci1zY2hlbWFcIjtcbiJdfQ==

package/build/provider-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-schema.d.ts","sourceRoot":"","sources":["../src/provider-schema.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,2BAA2B,EAC3B,6BAA6B,EAG7B,YAAY,EACZ,cAAc,EAMf,MAAM,gBAAgB,CAAC;AAIxB;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,4BAA4B,CAAA;CAAE,CAAC;AACrE,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC;AACzE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,CAAC;AAE/D,eAAO,MAAM,SAAS,MAAO,IAAI;cAMnB,gBAAgB;eACf,iBAAiB;UACtB,YAAY;CAErB,CAAC;AAkIF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAC;IACnD,SAAS,EAAE;QACT,kBAAkB,CAAC,EAAE;YACnB,CAAC,IAAI,EAAE,MAAM,GAAG;gBAAE,MAAM,CAAC,EAAE,MAAM,CAAC;gBAAC,OAAO,CAAC,EAAE,MAAM,CAAA;aAAE,CAAC;SACvD,CAAC;KACH,CAAC;IACF,MAAM,CAAC,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;CACnE;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,6BAA6B,2BAuCtC;AAID,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAsC7E;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,2BAA2B,yCAqCzE"}

package/build/provider-schema.js

@@ -0,0 +1,225 @@
+"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.readModuleSchema = exports.sanitizeProviderSchema = exports.readProviderSchema = exports.parseFQPN = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const hcl2json_1 = require("@cdktn/hcl2json");
+const commons_1 = require("@cdktn/commons");
+const terraformBinaryName = process.env.TERRAFORM_BINARY_NAME || "terraform";
+const parseFQPN = (f) => {
+    const [hostname, namespace, name] = f.split("/");
+    if (!name) {
+        throw new Error(`can't handle ${f}`);
+    }
+    return { hostname, namespace, name };
+};
+exports.parseFQPN = parseFQPN;
+const unwrapIfArray = (item) => Array.isArray(item) ? item[0] : item;
+const transformVariables = (variables) => {
+    const result = [];
+    if (!variables)
+        return result;
+    for (const name of Object.keys(variables)) {
+        const variable = unwrapIfArray(variables[name]);
+        let variableType;
+        if (
+        // eslint-disable-next-line no-prototype-builtins
+        variable.hasOwnProperty("type") == false &&
+            // eslint-disable-next-line no-prototype-builtins
+            variable.hasOwnProperty("default") == true) {
+            switch (typeof variable["default"]) {
+                case "boolean":
+                    variableType = "bool";
+                    break;
+                case "number":
+                    variableType = "number";
+                    break;
+                default:
+                    variableType = "any";
+            }
+        }
+        else {
+            const rawVariableType = variable["type"];
+            if (typeof rawVariableType === "string" &&
+                rawVariableType.startsWith("${") &&
+                rawVariableType.endsWith("}") &&
+                !rawVariableType.includes("\n")) {
+                variableType = rawVariableType.slice(2, -1);
+            }
+            else {
+                variableType = "any";
+            }
+        }
+        const item = {
+            name,
+            type: variableType,
+            description: variable["description"],
+            // eslint-disable-next-line no-prototype-builtins
+            required: variable.hasOwnProperty("default") == false,
+        };
+        if (!item.required) {
+            item["default"] = variable["default"];
+        }
+        result.push(item);
+    }
+    return result;
+};
+const transformOutputs = (outputs) => {
+    const result = [];
+    if (outputs) {
+        for (const name of Object.keys(outputs)) {
+            const output = unwrapIfArray(outputs[name]);
+            const item = {
+                name,
+                description: output["description"],
+            };
+            result.push(item);
+        }
+    }
+    return result;
+};
+const harvestModuleSchema = async (workingDirectory, modules) => {
+    const fileName = path.join(workingDirectory, ".terraform", "modules", "modules.json");
+    const result = {};
+    if (!fs.existsSync(fileName)) {
+        throw new Error(`Modules were not generated properly - couldn't find ${fileName}`);
+    }
+    const moduleIndex = JSON.parse(fs.readFileSync(fileName, "utf-8"));
+    for (const mod of modules) {
+        const m = moduleIndex.Modules.find((other) => mod === other.Key);
+        if (!m) {
+            throw new Error(`Couldn't find ${m}`);
+        }
+        const parsed = await (0, hcl2json_1.convertFiles)(path.join(workingDirectory, m.Dir));
+        if (!parsed) {
+            throw new Error(`Modules were not generated properly - couldn't parse ${m.Dir}`);
+        }
+        const schema = {
+            inputs: transformVariables(parsed.variable),
+            outputs: transformOutputs(parsed.output),
+            name: mod,
+        };
+        result[mod] = schema;
+    }
+    return result;
+};
+async function readProviderSchema(target) {
+    const config = {
+        provider: {},
+        terraform: {
+            required_providers: {},
+        },
+    };
+    config.provider[target.name] = {};
+    config.terraform.required_providers[target.name] = {
+        version: target.version,
+        source: target.source,
+    };
+    let providerSchema = { format_version: "0.1" };
+    await (0, commons_1.withTempDir)("fetchProviderSchema", async () => {
+        const outdir = process.cwd();
+        const filePath = path.join(outdir, "main.tf.json");
+        await fs.writeFile(filePath, JSON.stringify(config));
+        await (0, commons_1.exec)(terraformBinaryName, ["init"], { cwd: outdir });
+        providerSchema = JSON.parse(await (0, commons_1.exec)(terraformBinaryName, ["providers", "schema", "-json"], {
+            cwd: outdir,
+        }));
+        const versionSchema = JSON.parse(await (0, commons_1.exec)(terraformBinaryName, ["version", "-json"], {
+            cwd: outdir,
+        }));
+        providerSchema.provider_versions = versionSchema.provider_selections;
+    });
+    return sanitizeProviderSchema(providerSchema);
+}
+exports.readProviderSchema = readProviderSchema;
+// The providers have some potential bugs that we want to pro-actively
+// fix here so that the rest of the code can assume a consistent schema.
+function sanitizeProviderSchema(schema) {
+    // Mainly some attributes are "doubled", e.g. ["list", "string", "list", "string"]
+    // instead of ["list", "string"]
+    function attributeDoublingFix(attribute) {
+        if ((0, commons_1.isNestedTypeAttribute)(attribute) || !Array.isArray(attribute.type)) {
+            return attribute;
+        }
+        const type = attribute.type.length === 2
+            ? attribute.type
+            : attribute.type.slice(0, 2); // The types tell us this can't happen, reality begs to differ
+        attribute.type = type;
+        return attribute;
+    }
+    // Mutates block with the fix
+    function sanitizeBlock(block) {
+        Object.values(block.attributes || {}).forEach(attributeDoublingFix);
+        Object.values(block.block_types || {}).forEach((blockType) => {
+            sanitizeBlock(blockType.block);
+        });
+    }
+    Object.values(schema.provider_schemas || {}).forEach((provider) => {
+        const entities = [
+            provider.provider,
+            ...Object.values(provider.resource_schemas || {}),
+            ...Object.values(provider.data_source_schemas || {}),
+        ];
+        entities.forEach((entity) => {
+            sanitizeBlock(entity.block);
+        });
+    });
+    return schema;
+}
+exports.sanitizeProviderSchema = sanitizeProviderSchema;
+async function readModuleSchema(target) {
+    let moduleSchema = {};
+    await (0, commons_1.withTempDir)("fetchSchema", async () => {
+        const config = {
+            terraform: {},
+        };
+        if (!config.module)
+            config.module = {};
+        let source = target.source;
+        const localSource = target.constraint
+            .localSourceAbsolutePath;
+        if (localSource) {
+            // create relative path to module in the user project
+            source = path.relative(process.cwd(), localSource);
+        }
+        config.module[target.moduleKey] = { source: source };
+        if (target.version) {
+            config.module[target.moduleKey]["version"] = target.version;
+        }
+        const outdir = process.cwd();
+        const filePath = path.join(outdir, "main.tf.json");
+        await fs.writeFile(filePath, JSON.stringify(config));
+        await (0, commons_1.exec)(terraformBinaryName, ["get"], { cwd: outdir });
+        if (config.module) {
+            moduleSchema = await harvestModuleSchema(outdir, Object.keys(config.module));
+        }
+    });
+    return moduleSchema;
+}
+exports.readModuleSchema = readModuleSchema;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-schema.js","sourceRoot":"","sources":["../src/provider-schema.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs-extra\";\nimport * as path from \"path\";\n\nimport { convertFiles } from \"@cdktn/hcl2json\";\nimport {\n  Attribute,\n  AttributeType,\n  Block,\n  ConstructsMakerModuleTarget,\n  ConstructsMakerProviderTarget,\n  Input,\n  ModuleIndex,\n  ModuleSchema,\n  ProviderSchema,\n  TerraformModuleConstraint,\n  VersionSchema,\n  exec,\n  isNestedTypeAttribute,\n  withTempDir,\n} from \"@cdktn/commons\";\n\nconst terraformBinaryName = process.env.TERRAFORM_BINARY_NAME || \"terraform\";\n\n/**\n * Fully Qualified provider name in the format:\n * like e.g. registry.terraform.io/hashicorp/aws\n */\nexport type FQPN = string & { __type: \"FullyQualifiedProviderName\" };\nexport type ProviderHostname = string & { __type: \"ProviderHostname\" };\nexport type ProviderNamespace = string & { __type: \"ProviderNamespace\" };\nexport type ProviderName = string & { __type: \"ProviderName\" };\n\nexport const parseFQPN = (f: FQPN) => {\n  const [hostname, namespace, name] = f.split(\"/\");\n  if (!name) {\n    throw new Error(`can't handle ${f}`);\n  }\n  return { hostname, namespace, name } as {\n    hostname: ProviderHostname;\n    namespace: ProviderNamespace;\n    name: ProviderName;\n  };\n};\n\nconst unwrapIfArray = <T>(item: T | T[]): T =>\n  Array.isArray(item) ? item[0] : item;\n\nconst transformVariables = (variables: any) => {\n  const result: Input[] = [];\n\n  if (!variables) return result;\n\n  for (const name of Object.keys(variables)) {\n    const variable = unwrapIfArray(variables[name]);\n    let variableType: string;\n\n    if (\n      // eslint-disable-next-line no-prototype-builtins\n      variable.hasOwnProperty(\"type\") == false &&\n      // eslint-disable-next-line no-prototype-builtins\n      variable.hasOwnProperty(\"default\") == true\n    ) {\n      switch (typeof variable[\"default\"]) {\n        case \"boolean\":\n          variableType = \"bool\";\n          break;\n        case \"number\":\n          variableType = \"number\";\n          break;\n        default:\n          variableType = \"any\";\n      }\n    } else {\n      const rawVariableType = variable[\"type\"];\n      if (\n        typeof rawVariableType === \"string\" &&\n        rawVariableType.startsWith(\"${\") &&\n        rawVariableType.endsWith(\"}\") &&\n        !rawVariableType.includes(\"\\n\")\n      ) {\n        variableType = rawVariableType.slice(2, -1);\n      } else {\n        variableType = \"any\";\n      }\n    }\n\n    const item: Input = {\n      name,\n      type: variableType,\n      description: variable[\"description\"],\n      // eslint-disable-next-line no-prototype-builtins\n      required: variable.hasOwnProperty(\"default\") == false,\n    };\n\n    if (!item.required) {\n      item[\"default\"] = variable[\"default\"];\n    }\n\n    result.push(item);\n  }\n\n  return result;\n};\n\nconst transformOutputs = (outputs: any) => {\n  const result = [];\n\n  if (outputs) {\n    for (const name of Object.keys(outputs)) {\n      const output = unwrapIfArray(outputs[name]);\n\n      const item: any = {\n        name,\n        description: output[\"description\"],\n      };\n\n      result.push(item);\n    }\n  }\n\n  return result;\n};\n\nconst harvestModuleSchema = async (\n  workingDirectory: string,\n  modules: string[],\n): Promise<Record<string, any>> => {\n  const fileName = path.join(\n    workingDirectory,\n    \".terraform\",\n    \"modules\",\n    \"modules.json\",\n  );\n  const result: Record<string, any> = {};\n\n  if (!fs.existsSync(fileName)) {\n    throw new Error(\n      `Modules were not generated properly - couldn't find ${fileName}`,\n    );\n  }\n\n  const moduleIndex = JSON.parse(\n    fs.readFileSync(fileName, \"utf-8\"),\n  ) as ModuleIndex;\n\n  for (const mod of modules) {\n    const m = moduleIndex.Modules.find((other) => mod === other.Key);\n\n    if (!m) {\n      throw new Error(`Couldn't find ${m}`);\n    }\n\n    const parsed = await convertFiles(path.join(workingDirectory, m.Dir));\n\n    if (!parsed) {\n      throw new Error(\n        `Modules were not generated properly - couldn't parse ${m.Dir}`,\n      );\n    }\n\n    const schema: ModuleSchema = {\n      inputs: transformVariables(parsed.variable),\n      outputs: transformOutputs(parsed.output),\n      name: mod,\n    };\n\n    result[mod] = schema;\n  }\n\n  return result;\n};\n\nexport interface TerraformConfig {\n  provider?: { [name: string]: Record<string, any> };\n  terraform: {\n    required_providers?: {\n      [name: string]: { source?: string; version?: string };\n    };\n  };\n  module?: { [name: string]: { source: string; version?: string } };\n}\n\nexport async function readProviderSchema(\n  target: ConstructsMakerProviderTarget,\n) {\n  const config: TerraformConfig = {\n    provider: {},\n    terraform: {\n      required_providers: {},\n    },\n  };\n\n  config.provider![target.name] = {};\n  config.terraform.required_providers![target.name] = {\n    version: target.version,\n    source: target.source,\n  };\n\n  let providerSchema: ProviderSchema = { format_version: \"0.1\" };\n\n  await withTempDir(\"fetchProviderSchema\", async () => {\n    const outdir = process.cwd();\n    const filePath = path.join(outdir, \"main.tf.json\");\n    await fs.writeFile(filePath, JSON.stringify(config));\n\n    await exec(terraformBinaryName, [\"init\"], { cwd: outdir });\n    providerSchema = JSON.parse(\n      await exec(terraformBinaryName, [\"providers\", \"schema\", \"-json\"], {\n        cwd: outdir,\n      }),\n    ) as ProviderSchema;\n\n    const versionSchema = JSON.parse(\n      await exec(terraformBinaryName, [\"version\", \"-json\"], {\n        cwd: outdir,\n      }),\n    ) as VersionSchema;\n\n    providerSchema.provider_versions = versionSchema.provider_selections;\n  });\n\n  return sanitizeProviderSchema(providerSchema);\n}\n\n// The providers have some potential bugs that we want to pro-actively\n// fix here so that the rest of the code can assume a consistent schema.\nexport function sanitizeProviderSchema(schema: ProviderSchema): ProviderSchema {\n  // Mainly some attributes are \"doubled\", e.g. [\"list\", \"string\", \"list\", \"string\"]\n  // instead of [\"list\", \"string\"]\n  function attributeDoublingFix(attribute: Attribute): Attribute {\n    if (isNestedTypeAttribute(attribute) || !Array.isArray(attribute.type)) {\n      return attribute;\n    }\n\n    const type =\n      attribute.type.length === 2\n        ? attribute.type\n        : (attribute.type as string[]).slice(0, 2); // The types tell us this can't happen, reality begs to differ\n\n    attribute.type = type as AttributeType;\n    return attribute;\n  }\n\n  // Mutates block with the fix\n  function sanitizeBlock(block: Block) {\n    Object.values(block.attributes || {}).forEach(attributeDoublingFix);\n    Object.values(block.block_types || {}).forEach((blockType) => {\n      sanitizeBlock(blockType.block);\n    });\n  }\n\n  Object.values(schema.provider_schemas || {}).forEach((provider) => {\n    const entities = [\n      provider.provider,\n      ...Object.values(provider.resource_schemas || {}),\n      ...Object.values(provider.data_source_schemas || {}),\n    ];\n\n    entities.forEach((entity) => {\n      sanitizeBlock(entity.block);\n    });\n  });\n\n  return schema;\n}\n\nexport async function readModuleSchema(target: ConstructsMakerModuleTarget) {\n  let moduleSchema: Record<string, ModuleSchema> = {};\n\n  await withTempDir(\"fetchSchema\", async () => {\n    const config: TerraformConfig = {\n      terraform: {},\n    };\n\n    if (!config.module) config.module = {};\n    let source: string = target.source;\n\n    const localSource = (target.constraint as TerraformModuleConstraint)\n      .localSourceAbsolutePath;\n    if (localSource) {\n      // create relative path to module in the user project\n      source = path.relative(process.cwd(), localSource);\n    }\n\n    config.module[target.moduleKey] = { source: source };\n    if (target.version) {\n      config.module[target.moduleKey][\"version\"] = target.version;\n    }\n\n    const outdir = process.cwd();\n    const filePath = path.join(outdir, \"main.tf.json\");\n    await fs.writeFile(filePath, JSON.stringify(config));\n\n    await exec(terraformBinaryName, [\"get\"], { cwd: outdir });\n    if (config.module) {\n      moduleSchema = await harvestModuleSchema(\n        outdir,\n        Object.keys(config.module),\n      );\n    }\n  });\n\n  return moduleSchema;\n}\n"]}

package/build/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../src/read.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,2BAA2B,EAC3B,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,6BAA6B,EAK9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGzE,MAAM,MAAM,MAAM,GAAG;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC;IAChE,YAAY,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC;CAC7D,CAAC;AAEF,wBAAsB,UAAU,CAC9B,WAAW,EAAE,6BAA6B,EAAE,EAC5C,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,CA6BjB"}

package/build/read.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSchema = exports.isLocalModule = exports.TerraformProviderConstraint = exports.TerraformModuleConstraint = exports.isRegistryModule = void 0;
+var commons_1 = require("@cdktn/commons");
+Object.defineProperty(exports, "isRegistryModule", { enumerable: true, get: function () { return commons_1.isRegistryModule; } });
+Object.defineProperty(exports, "TerraformModuleConstraint", { enumerable: true, get: function () { return commons_1.TerraformModuleConstraint; } });
+Object.defineProperty(exports, "TerraformProviderConstraint", { enumerable: true, get: function () { return commons_1.TerraformProviderConstraint; } });
+Object.defineProperty(exports, "isLocalModule", { enumerable: true, get: function () { return commons_1.isLocalModule; } });
+const commons_2 = require("@cdktn/commons");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const provider_schema_1 = require("./provider-schema");
+const cache_1 = require("./cache");
+async function readSchema(constraints, cacheDir) {
+    const cachedReadProviderSchema = (0, cache_1.cachedAccess)(provider_schema_1.readProviderSchema, cacheDir);
+    const targets = constraints.map((constraint) => commons_2.ConstructsMakerProviderTarget.from(constraint, commons_2.LANGUAGES[0]));
+    throwIfTargetsConflict(targets);
+    const schemas = await Promise.all(targets.map((t) => t.isModule
+        ? (0, provider_schema_1.readModuleSchema)(t).then((s) => ({ moduleSchema: s }))
+        : cachedReadProviderSchema(t).then((s) => ({ providerSchema: s }))));
+    // ensure we have a schema for each target type
+    schemas.unshift({
+        providerSchema: {
+            format_version: "0.1",
+        },
+        moduleSchema: {},
+    });
+    return deepmerge_1.default.all(schemas);
+}
+exports.readSchema = readSchema;
+function throwIfTargetsConflict(targets) {
+    const modules = targets.filter((t) => t.isModule);
+    modules.forEach((moduleA) => {
+        modules.forEach((moduleB) => {
+            if (moduleA !== moduleB && moduleA.name === moduleB.name) {
+                throw commons_2.Errors.Usage(`Found two modules with the same name "${moduleA.name}" which is not supported. Please rename one of the modules in your cdktf.json config. For more information on how to set the name refer to https://cdk.tf/adding-modules`);
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA;;;GAGG;;;;;AAEH,OAAO,EAAS,YAAY,EAAE,MAAM,eAAe,CAAC;AAKpD,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,iBAa7B;AAED,eAAO,MAAM,IAAI,YACN,MAAM,QACT,MAAM,EAAE,WACL,YAAY,WACZ,CAAC,KAAK,EAAE,MAAM,KAAK,GAAG,WACtB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,GAAG,KAC3C,QAAQ,MAAM,CAkChB,CAAC"}