@cdktn/provider-schema 0.21.0

package/src/provider-schema.js

@@ -0,0 +1,218 @@
+"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) => {
+    var _a;
+    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 matched = (_a = variable["type"]) === null || _a === void 0 ? void 0 : _a.match(/\$\{(.*)\}/);
+            variableType = matched ? matched[1] : "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":["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 matched = (variable[\"type\"] as string)?.match(/\\$\\{(.*)\\}/);\n      variableType = matched ? matched[1] : \"any\";\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/src/read.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+export { isRegistryModule, TerraformModuleConstraint, TerraformProviderConstraint, isLocalModule, } from "@cdktn/commons";
+import { TerraformDependencyConstraint } from "@cdktn/commons";
+import { readModuleSchema, readProviderSchema } from "./provider-schema";
+export type Schema = {
+    providerSchema?: Awaited<ReturnType<typeof readProviderSchema>>;
+    moduleSchema?: Awaited<ReturnType<typeof readModuleSchema>>;
+};
+export declare function readSchema(constraints: TerraformDependencyConstraint[], cacheDir?: string): Promise<Schema>;
+//# sourceMappingURL=read.d.ts.map

package/src/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["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/src/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/src/util.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="ambient" />
+/// <reference types="node/child_process" />
+import { SpawnOptions } from "child_process";
+export declare function withTempDir(dirname: string, closure: () => Promise<void>): Promise<void>;
+export declare const exec: (command: string, args: string[], options: SpawnOptions, stdout?: (chunk: Buffer) => any, stderr?: (chunk: string | Uint8Array) => any) => Promise<string>;
+//# sourceMappingURL=util.d.ts.map

package/src/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["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/src/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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