@cdktn/provider-schema 0.23.0-pre.4 → 0.23.0-pre.40

package/build/provider-schema.js

@@ -0,0 +1,278 @@
+"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 = exports.terraformInitWithRetry = 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";
+// Provider binaries are downloaded from GitHub release CDNs during
+// `terraform init`, which intermittently returns 5xx. Retry on those
+// signatures only — real config/schema errors should still fail fast.
+const TRANSIENT_INIT_ERROR_PATTERNS = [
+    /\b50[234]\b/,
+    /Bad Gateway/i,
+    /Service Unavailable/i,
+    /Gateway Timeout/i,
+    /ECONNRESET/i,
+    /ETIMEDOUT/i,
+    /EAI_AGAIN/i,
+    /unexpected EOF/i,
+];
+/**
+ * Runs `terraform init` and retries on transient HTTP/network failures.
+ *
+ * Provider binaries are pulled from GitHub's release CDN, which
+ * intermittently returns 5xx. The retry only fires when stderr matches a
+ * known transient pattern — real errors (bad version, schema parse, etc.)
+ * still fail on the first attempt.
+ *
+ * @param options - spawn options forwarded to `exec` (`cwd` is required so
+ *   `terraform init` runs inside the temp dir holding `main.tf.json`)
+ * @param maxAttempts - total attempts including the initial call; the number
+ *   of retries is `maxAttempts - 1`. Defaults to 3 (1 initial + 2 retries)
+ * @param baseDelayMs - delay before the first retry. Tests pass `0` to skip
+ *   waits. Defaults to 1000ms
+ * @param backoffMultiplier - factor applied to the delay on each subsequent
+ *   retry (so retries wait `baseDelayMs * multiplier^(attempt-1)`). Defaults
+ *   to 2 (1s → 2s → 4s …)
+ * @returns stdout from the successful `terraform init` invocation
+ * @internal exposed for testing
+ */
+async function terraformInitWithRetry(options, maxAttempts = 3, baseDelayMs = 1000, backoffMultiplier = 2) {
+    var _a;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await (0, commons_1.exec)(terraformBinaryName, ["init"], options);
+        }
+        catch (error) {
+            const stderr = (_a = error === null || error === void 0 ? void 0 : error.stderr) !== null && _a !== void 0 ? _a : "";
+            const transient = TRANSIENT_INIT_ERROR_PATTERNS.some((p) => p.test(stderr));
+            if (!transient || attempt === maxAttempts) {
+                throw error;
+            }
+            const delayMs = baseDelayMs * backoffMultiplier ** (attempt - 1);
+            console.error(`terraform init failed with a transient error, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts - 1})`);
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    throw new Error("unreachable");
+}
+exports.terraformInitWithRetry = terraformInitWithRetry;
+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 terraformInitWithRetry({ 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":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,mCAAmC;AACnC,6CAA+B;AAC/B,2CAA6B;AAE7B,8CAA+C;AAC/C,4CAewB;AAExB,MAAM,mBAAmB,GAAG,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,WAAW,CAAC;AAE7E,mEAAmE;AACnE,qEAAqE;AACrE,sEAAsE;AACtE,MAAM,6BAA6B,GAAG;IACpC,aAAa;IACb,cAAc;IACd,sBAAsB;IACtB,kBAAkB;IAClB,aAAa;IACb,YAAY;IACZ,YAAY;IACZ,iBAAiB;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACI,KAAK,UAAU,sBAAsB,CAC1C,OAAwB,EACxB,WAAW,GAAG,CAAC,EACf,WAAW,GAAG,IAAI,EAClB,iBAAiB,GAAG,CAAC;;IAErB,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;QACxD,IAAI,CAAC;YACH,OAAO,MAAM,IAAA,cAAI,EAAC,mBAAmB,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,MAAM,MAAM,GAAW,MAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,MAAM,mCAAI,EAAE,CAAC;YAC3C,MAAM,SAAS,GAAG,6BAA6B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CACzD,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CACf,CAAC;YACF,IAAI,CAAC,SAAS,IAAI,OAAO,KAAK,WAAW,EAAE,CAAC;gBAC1C,MAAM,KAAK,CAAC;YACd,CAAC;YACD,MAAM,OAAO,GAAG,WAAW,GAAG,iBAAiB,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;YACjE,OAAO,CAAC,KAAK,CACX,6DAA6D,OAAO,eAAe,OAAO,IAAI,WAAW,GAAG,CAAC,GAAG,CACjH,CAAC;YACF,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,aAAa,CAAC,CAAC;AACjC,CAAC;AAzBD,wDAyBC;AAWM,MAAM,SAAS,GAAG,CAAC,CAAO,EAAE,EAAE;IACnC,MAAM,CAAC,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACjD,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAIjC,CAAC;AACJ,CAAC,CAAC;AAVW,QAAA,SAAS,aAUpB;AAEF,MAAM,aAAa,GAAG,CAAI,IAAa,EAAK,EAAE,CAC5C,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAEvC,MAAM,kBAAkB,GAAG,CAAC,SAAc,EAAE,EAAE;IAC5C,MAAM,MAAM,GAAY,EAAE,CAAC;IAE3B,IAAI,CAAC,SAAS;QAAE,OAAO,MAAM,CAAC;IAE9B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QAC1C,MAAM,QAAQ,GAAG,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAChD,IAAI,YAAoB,CAAC;QAEzB;QACE,iDAAiD;QACjD,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,KAAK;YACxC,iDAAiD;YACjD,QAAQ,CAAC,cAAc,CAAC,SAAS,CAAC,IAAI,IAAI,EAC1C,CAAC;YACD,QAAQ,OAAO,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;gBACnC,KAAK,SAAS;oBACZ,YAAY,GAAG,MAAM,CAAC;oBACtB,MAAM;gBACR,KAAK,QAAQ;oBACX,YAAY,GAAG,QAAQ,CAAC;oBACxB,MAAM;gBACR;oBACE,YAAY,GAAG,KAAK,CAAC;YACzB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;YACzC,IACE,OAAO,eAAe,KAAK,QAAQ;gBACnC,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC;gBAChC,eAAe,CAAC,QAAQ,CAAC,GAAG,CAAC;gBAC7B,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,EAC/B,CAAC;gBACD,YAAY,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC9C,CAAC;iBAAM,CAAC;gBACN,YAAY,GAAG,KAAK,CAAC;YACvB,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAU;YAClB,IAAI;YACJ,IAAI,EAAE,YAAY;YAClB,WAAW,EAAE,QAAQ,CAAC,aAAa,CAAC;YACpC,iDAAiD;YACjD,QAAQ,EAAE,QAAQ,CAAC,cAAc,CAAC,SAAS,CAAC,IAAI,KAAK;SACtD,CAAC;QAEF,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;QACxC,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CAAC,OAAY,EAAE,EAAE;IACxC,MAAM,MAAM,GAAG,EAAE,CAAC;IAElB,IAAI,OAAO,EAAE,CAAC;QACZ,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;YAE5C,MAAM,IAAI,GAAQ;gBAChB,IAAI;gBACJ,WAAW,EAAE,MAAM,CAAC,aAAa,CAAC;aACnC,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,KAAK,EAC/B,gBAAwB,EACxB,OAAiB,EACa,EAAE;IAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CACxB,gBAAgB,EAChB,YAAY,EACZ,SAAS,EACT,cAAc,CACf,CAAC;IACF,MAAM,MAAM,GAAwB,EAAE,CAAC;IAEvC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,uDAAuD,QAAQ,EAAE,CAClE,CAAC;IACJ,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAC5B,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CACpB,CAAC;IAEjB,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,MAAM,CAAC,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,KAAK,KAAK,CAAC,GAAG,CAAC,CAAC;QAEjE,IAAI,CAAC,CAAC,EAAE,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;QACxC,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAA,uBAAY,EAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAEtE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CACb,wDAAwD,CAAC,CAAC,GAAG,EAAE,CAChE,CAAC;QACJ,CAAC;QAED,MAAM,MAAM,GAAiB;YAC3B,MAAM,EAAE,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC;YAC3C,OAAO,EAAE,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;YACxC,IAAI,EAAE,GAAG;SACV,CAAC;QAEF,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAYK,KAAK,UAAU,kBAAkB,CACtC,MAAqC;IAErC,MAAM,MAAM,GAAoB;QAC9B,QAAQ,EAAE,EAAE;QACZ,SAAS,EAAE;YACT,kBAAkB,EAAE,EAAE;SACvB;KACF,CAAC;IAEF,MAAM,CAAC,QAAS,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IACnC,MAAM,CAAC,SAAS,CAAC,kBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG;QAClD,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,MAAM,EAAE,MAAM,CAAC,MAAM;KACtB,CAAC;IAEF,IAAI,cAAc,GAAmB,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC;IAE/D,MAAM,IAAA,qBAAW,EAAC,qBAAqB,EAAE,KAAK,IAAI,EAAE;QAClD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QACnD,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAErD,MAAM,sBAAsB,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;QAC9C,cAAc,GAAG,IAAI,CAAC,KAAK,CACzB,MAAM,IAAA,cAAI,EAAC,mBAAmB,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE;YAChE,GAAG,EAAE,MAAM;SACZ,CAAC,CACe,CAAC;QAEpB,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAC9B,MAAM,IAAA,cAAI,EAAC,mBAAmB,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE;YACpD,GAAG,EAAE,MAAM;SACZ,CAAC,CACc,CAAC;QAEnB,cAAc,CAAC,iBAAiB,GAAG,aAAa,CAAC,mBAAmB,CAAC;IACvE,CAAC,CAAC,CAAC;IAEH,OAAO,sBAAsB,CAAC,cAAc,CAAC,CAAC;AAChD,CAAC;AAxCD,gDAwCC;AAED,sEAAsE;AACtE,wEAAwE;AACxE,SAAgB,sBAAsB,CAAC,MAAsB;IAC3D,kFAAkF;IAClF,gCAAgC;IAChC,SAAS,oBAAoB,CAAC,SAAoB;QAChD,IAAI,IAAA,+BAAqB,EAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YACvE,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,IAAI,GACR,SAAS,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;YACzB,CAAC,CAAC,SAAS,CAAC,IAAI;YAChB,CAAC,CAAE,SAAS,CAAC,IAAiB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,8DAA8D;QAE9G,SAAS,CAAC,IAAI,GAAG,IAAqB,CAAC;QACvC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,6BAA6B;IAC7B,SAAS,aAAa,CAAC,KAAY;QACjC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;QACpE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;YAC3D,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;QAChE,MAAM,QAAQ,GAAG;YACf,QAAQ,CAAC,QAAQ;YACjB,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,IAAI,EAAE,CAAC;YACjD,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,IAAI,EAAE,CAAC;SACrD,CAAC;QAEF,QAAQ,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC1B,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC;AAtCD,wDAsCC;AAEM,KAAK,UAAU,gBAAgB,CAAC,MAAmC;IACxE,IAAI,YAAY,GAAiC,EAAE,CAAC;IAEpD,MAAM,IAAA,qBAAW,EAAC,aAAa,EAAE,KAAK,IAAI,EAAE;QAC1C,MAAM,MAAM,GAAoB;YAC9B,SAAS,EAAE,EAAE;SACd,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,MAAM;YAAE,MAAM,CAAC,MAAM,GAAG,EAAE,CAAC;QACvC,IAAI,MAAM,GAAW,MAAM,CAAC,MAAM,CAAC;QAEnC,MAAM,WAAW,GAAI,MAAM,CAAC,UAAwC;aACjE,uBAAuB,CAAC;QAC3B,IAAI,WAAW,EAAE,CAAC;YAChB,qDAAqD;YACrD,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,WAAW,CAAC,CAAC;QACrD,CAAC;QAED,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QACrD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;QAC9D,CAAC;QAED,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QACnD,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAErD,MAAM,IAAA,cAAI,EAAC,mBAAmB,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;QAC1D,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,YAAY,GAAG,MAAM,mBAAmB,CACtC,MAAM,EACN,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAC3B,CAAC;QACJ,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC;AACtB,CAAC;AArCD,4CAqCC","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// Provider binaries are downloaded from GitHub release CDNs during\n// `terraform init`, which intermittently returns 5xx. Retry on those\n// signatures only — real config/schema errors should still fail fast.\nconst TRANSIENT_INIT_ERROR_PATTERNS = [\n  /\\b50[234]\\b/,\n  /Bad Gateway/i,\n  /Service Unavailable/i,\n  /Gateway Timeout/i,\n  /ECONNRESET/i,\n  /ETIMEDOUT/i,\n  /EAI_AGAIN/i,\n  /unexpected EOF/i,\n];\n\n/**\n * Runs `terraform init` and retries on transient HTTP/network failures.\n *\n * Provider binaries are pulled from GitHub's release CDN, which\n * intermittently returns 5xx. The retry only fires when stderr matches a\n * known transient pattern — real errors (bad version, schema parse, etc.)\n * still fail on the first attempt.\n *\n * @param options - spawn options forwarded to `exec` (`cwd` is required so\n *   `terraform init` runs inside the temp dir holding `main.tf.json`)\n * @param maxAttempts - total attempts including the initial call; the number\n *   of retries is `maxAttempts - 1`. Defaults to 3 (1 initial + 2 retries)\n * @param baseDelayMs - delay before the first retry. Tests pass `0` to skip\n *   waits. Defaults to 1000ms\n * @param backoffMultiplier - factor applied to the delay on each subsequent\n *   retry (so retries wait `baseDelayMs * multiplier^(attempt-1)`). Defaults\n *   to 2 (1s → 2s → 4s …)\n * @returns stdout from the successful `terraform init` invocation\n * @internal exposed for testing\n */\nexport async function terraformInitWithRetry(\n  options: { cwd: string },\n  maxAttempts = 3,\n  baseDelayMs = 1000,\n  backoffMultiplier = 2,\n): Promise<string> {\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    try {\n      return await exec(terraformBinaryName, [\"init\"], options);\n    } catch (error: any) {\n      const stderr: string = error?.stderr ?? \"\";\n      const transient = TRANSIENT_INIT_ERROR_PATTERNS.some((p) =>\n        p.test(stderr),\n      );\n      if (!transient || attempt === maxAttempts) {\n        throw error;\n      }\n      const delayMs = baseDelayMs * backoffMultiplier ** (attempt - 1);\n      console.error(\n        `terraform init failed with a transient error, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts - 1})`,\n      );\n      await new Promise((resolve) => setTimeout(resolve, delayMs));\n    }\n  }\n  throw new Error(\"unreachable\");\n}\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 terraformInitWithRetry({ 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"}

package/build/util.js

@@ -0,0 +1,89 @@
+"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.exec = exports.withTempDir = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs-extra"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+async function withTempDir(dirname, closure) {
+    const prevdir = process.cwd();
+    const parent = await fs.mkdtemp(path.join(os.tmpdir(), "cdktf."));
+    const workdir = path.join(parent, dirname);
+    await fs.mkdirp(workdir);
+    try {
+        process.chdir(workdir);
+        await closure();
+    }
+    finally {
+        process.chdir(prevdir);
+        await fs.remove(parent);
+    }
+}
+exports.withTempDir = withTempDir;
+const exec = async (command, args, options, stdout, stderr) => {
+    return new Promise((ok, ko) => {
+        var _a, _b, _c, _d;
+        const child = (0, child_process_1.spawn)(command, args, options);
+        const out = new Array();
+        const err = new Array();
+        if (stdout !== undefined) {
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
+                stdout(chunk);
+            });
+        }
+        else {
+            (_b = child.stdout) === null || _b === void 0 ? void 0 : _b.on("data", (chunk) => {
+                out.push(chunk);
+            });
+        }
+        if (stderr !== undefined) {
+            (_c = child.stderr) === null || _c === void 0 ? void 0 : _c.on("data", (chunk) => {
+                stderr(chunk);
+            });
+        }
+        else {
+            (_d = child.stderr) === null || _d === void 0 ? void 0 : _d.on("data", (chunk) => {
+                process.stderr.write(chunk);
+                err.push(chunk);
+            });
+        }
+        child.once("error", (err) => ko(err));
+        child.once("close", (code) => {
+            if (code !== 0) {
+                const error = new Error(`non-zero exit code ${code}`);
+                error.stderr = err.map((chunk) => chunk.toString()).join("");
+                return ko(error);
+            }
+            return ok(Buffer.concat(out).toString("utf-8"));
+        });
+    });
+};
+exports.exec = exec;
+//# sourceMappingURL=data:application/json;base64,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

package/eslint.config.mjs

@@ -3,73 +3,4 @@
  * SPDX-License-Identifier: MPL-2.0
  */
 
-import { fixupConfigRules } from "@eslint/compat";
-import eslint from "@eslint/js";
-import tseslint from "typescript-eslint";
-import tsParser from "@typescript-eslint/parser";
-import react from "eslint-plugin-react";
-import prettierConfig from "eslint-plugin-prettier/recommended";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all,
-});
-
-export default [
-  {
-    ignores: [
-      "**/node_modules",
-      "**/dist",
-      "**/coverage",
-      "**/*.d.ts",
-      "**/*.js",
-    ],
-  },
-  ...tseslint.config(eslint.configs.recommended, tseslint.configs.recommended),
-  {
-    settings: {
-      react: {
-        version: "detect",
-      },
-    },
-  },
-  react.configs.flat.recommended,
-  ...fixupConfigRules(compat.extends("plugin:react-hooks/recommended")).map(
-    (config) => ({
-      ...config,
-      files: ["**/*.ts", "**/*.tsx"],
-    }),
-  ),
-  {
-    files: ["**/*.ts", "**/*.tsx"],
-
-    languageOptions: {
-      parser: tsParser,
-    },
-
-    rules: {
-      "@typescript-eslint/no-explicit-any": 0,
-      "@typescript-eslint/explicit-function-return-type": 0,
-      "@typescript-eslint/no-use-before-define": 0,
-      "@typescript-eslint/explicit-module-boundary-types": 0,
-      "@typescript-eslint/no-var-requires": 0,
-      "react/no-unescaped-entities": 0,
-      "no-sequences": "error",
-
-      "no-irregular-whitespace": [
-        "error",
-        {
-          skipTemplates: true,
-        },
-      ],
-    },
-  },
-  prettierConfig,
-];
+export { default } from "../../../eslint.config.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cdktn/provider-schema",
-  "version": "0.23.0-pre.4",
+  "version": "0.23.0-pre.40",
   "publishConfig": {
     "access": "public"
   },
@@ -13,16 +13,16 @@
     "lint:fix": "eslint . --fix",
     "pretest": "yarn build",
     "pretest:ci": "yarn build",
-    "test": "yarn lint && jest",
-    "test:ci": "yarn lint && jest --ci",
+    "test": "jest",
+    "test:ci": "jest --ci",
     "test:update": "jest -u",
     "jest-watch": "jest --watch",
     "package": "./package.sh",
     "dist-clean": "rm -rf dist",
     "package:js": "./package.sh"
   },
-  "main": "src/index.js",
-  "types": "src/index.d.ts",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git://github.com/open-constructs/cdk-terrain.git",
@@ -40,30 +40,22 @@
   ],
   "license": "MPL-2.0",
   "dependencies": {
-    "@cdktn/commons": "0.23.0-pre.4",
-    "@cdktn/hcl2json": "0.23.0-pre.4",
+    "@cdktn/commons": "0.23.0-pre.40",
+    "@cdktn/hcl2json": "0.23.0-pre.40",
     "deepmerge": "4.3.1",
-    "fs-extra": "11.3.0"
+    "fs-extra": "11.3.4"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.2.9",
-    "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.27.0",
     "@types/follow-redirects": "1.14.4",
     "@types/fs-extra": "11.0.4",
     "@types/json-stable-stringify": "1.2.0",
     "@types/uuid": "9.0.8",
-    "@typescript-eslint/parser": "^8.32.1",
-    "eslint": "^9.27.0",
-    "eslint-plugin-prettier": "^5.4.0",
-    "eslint-plugin-react": "7.37.5",
-    "jest": "^29.7.0",
+    "jest": "^30.3.0",
     "json-stable-stringify": "1.3.0",
     "lint-staged": "^15.5.2",
-    "ts-jest": "29.3.4",
+    "ts-jest": "29.4.9",
     "tsc-files": "1.1.4",
-    "typescript": "5.4.5",
-    "typescript-eslint": "^8.32.1"
+    "typescript": "5.4.5"
   },
   "lint-staged": {
     "src/**/*.{ts,tsx}": "tsc-files ambient.d.ts --noEmit"