@cdktn/cli-core 0.23.0-pre.8 → 0.24.0-pre.1

package/build/lib/output.js

@@ -0,0 +1,211 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConstructIdsForOutputs = exports.parseOutput = exports.normalizeOutputPath = exports.saveOutputs = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const z = __importStar(require("zod"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const commons_1 = require("@cdktn/commons");
+const schema_1 = require("./models/schema");
+const terraform_1 = require("./models/terraform");
+function unpackTerraformOutput(outputs, includeSensitiveOutputs) {
+    return Object.entries(outputs).reduce((acc, [key, entry]) => ({
+        ...acc,
+        [key]: (0, terraform_1.isTerraformOutput)(entry)
+            ? !entry.sensitive || includeSensitiveOutputs
+                ? entry.value
+                : undefined
+            : unpackTerraformOutput(entry, includeSensitiveOutputs),
+    }), {});
+}
+async function saveOutputs(filePath, outputs, includeSensitiveOutputs) {
+    fs.writeFileSync(filePath, JSON.stringify(unpackTerraformOutput(outputs, includeSensitiveOutputs), null, 2));
+}
+exports.saveOutputs = saveOutputs;
+function normalizeOutputPath(filePath) {
+    return path.isAbsolute(filePath)
+        ? filePath
+        : path.join(process.cwd(), filePath);
+}
+exports.normalizeOutputPath = normalizeOutputPath;
+const mapActionToState = (action, done) => {
+    switch (action) {
+        case "create":
+        case "update":
+            return done
+                ? terraform_1.DeployingResourceApplyState.CREATED
+                : terraform_1.DeployingResourceApplyState.CREATING;
+        case "delete":
+            return done
+                ? terraform_1.DeployingResourceApplyState.DESTROYED
+                : terraform_1.DeployingResourceApplyState.DESTROYING;
+        default:
+            return terraform_1.DeployingResourceApplyState.WAITING;
+    }
+};
+// This is deprecated and will be removed in a future version.
+const parseJsonOutputLine = (line) => {
+    let json, message;
+    try {
+        json = JSON.parse(line);
+    }
+    catch (_a) {
+        commons_1.logger.trace(`Could not parse line as JSON: ${line}`);
+        return;
+    }
+    try {
+        message = schema_1.schema.parse(json);
+    }
+    catch (err) {
+        if (err instanceof z.ZodError) {
+            commons_1.logger.trace(`Error parsing line into schema: ${JSON.stringify(err.errors)} => ${line}`);
+        }
+        return;
+    }
+    switch (message.type) {
+        case "apply_start":
+        case "apply_progress":
+            return {
+                id: message.hook.resource.resource,
+                applyState: mapActionToState(message.hook.action, false),
+            };
+        case "apply_complete":
+            return {
+                id: message.hook.resource.resource,
+                applyState: mapActionToState(message.hook.action, true),
+            };
+        default:
+            return;
+    }
+};
+const parseTextOutputLine = (line) => {
+    if (/^Outputs:/.test(line)) {
+        return;
+    }
+    if (/^Plan:/.test(line)) {
+        return;
+    }
+    if (/^data\..*/.test(line)) {
+        return;
+    }
+    const resourceMatch = line.match(/^([a-zA-Z_][a-zA-Z\d_\-.]*):/);
+    let applyState;
+    switch (true) {
+        case /Creating.../.test(line):
+        case /Still creating.../.test(line):
+            applyState = terraform_1.DeployingResourceApplyState.CREATING;
+            break;
+        case /Creation complete/.test(line):
+            applyState = terraform_1.DeployingResourceApplyState.CREATED;
+            break;
+        case /Modifying.../.test(line):
+            applyState = terraform_1.DeployingResourceApplyState.UPDATING;
+            break;
+        case /Modifications complete/.test(line):
+            applyState = terraform_1.DeployingResourceApplyState.UPDATED;
+            break;
+        case /Destroying.../.test(line):
+        case /Still destroying.../.test(line):
+            applyState = terraform_1.DeployingResourceApplyState.DESTROYING;
+            break;
+        case /Destruction complete/.test(line):
+            applyState = terraform_1.DeployingResourceApplyState.DESTROYED;
+            break;
+        default:
+            return;
+    }
+    if (resourceMatch &&
+        resourceMatch.length >= 0 &&
+        resourceMatch[1] != "Warning") {
+        return {
+            id: resourceMatch[1],
+            applyState,
+        };
+    }
+    else {
+        return;
+    }
+};
+const parseOutput = (str) => {
+    const lines = (0, strip_ansi_1.default)(str.toString()).split("\n");
+    const resources = lines.map((line) => {
+        const parsed = parseJsonOutputLine(line) || parseTextOutputLine(line);
+        if (parsed === undefined) {
+            return;
+        }
+        const { id, applyState } = parsed;
+        return {
+            id,
+            applyState,
+            action: terraform_1.PlannedResourceAction.CREATE,
+        };
+    });
+    return resources.reduce((acc, resource) => {
+        if (resource) {
+            acc.push(resource);
+        }
+        return acc;
+        // eslint-disable-next-line @typescript-eslint/no-array-constructor
+    }, new Array());
+};
+exports.parseOutput = parseOutput;
+const isObjectEmpty = (obj) => {
+    if (typeof obj !== "object") {
+        return false;
+    }
+    return (Object.keys(obj).length === 0 ||
+        Object.values(obj).every((v) => v === undefined || v === null || isObjectEmpty(v)));
+};
+const getConstructIdsForOutputs = (stackContent, outputs) => {
+    // Older cdktf versions might not have the output metadata
+    if (!("//" in stackContent) || !("outputs" in stackContent["//"])) {
+        return outputs;
+    }
+    const outputsMapping = stackContent["//"].outputs;
+    const mapOutputs = (value) => {
+        return Object.entries(value).reduce((acc, [key, value]) => {
+            if (typeof value === "string") {
+                return { ...acc, [key]: outputs[value] };
+            }
+            const mapped = mapOutputs(value);
+            if (isObjectEmpty(mapped)) {
+                return acc;
+            }
+            return {
+                ...acc,
+                [key]: mapped,
+            };
+        }, {});
+    };
+    return mapOutputs(outputsMapping);
+};
+exports.getConstructIdsForOutputs = getConstructIdsForOutputs;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"output.js","sourceRoot":"","sources":["../../src/lib/output.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as z from \"zod\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport stripAnsi from \"strip-ansi\";\n\nimport { logger } from \"@cdktn/commons\";\nimport { ActionTypes, schema } from \"./models/schema\";\nimport {\n  DeployingResource,\n  DeployingResourceApplyState,\n  PlannedResourceAction,\n  TerraformOutput,\n  isTerraformOutput,\n} from \"./models/terraform\";\n\nexport type Outputs = { [key: string]: TerraformOutput };\nexport type OutputIdMapLeaf = { [constructId: string]: string };\nexport type OutputIdMapNode = { [stackOrConstructId: string]: OutputIdMap };\nexport type OutputIdMap = OutputIdMapLeaf | OutputIdMapNode;\n\nfunction unpackTerraformOutput(\n  outputs: NestedTerraformOutputs,\n  includeSensitiveOutputs: boolean,\n): Record<string, string> {\n  return Object.entries(outputs).reduce(\n    (acc, [key, entry]) => ({\n      ...acc,\n      [key]: isTerraformOutput(entry)\n        ? !entry.sensitive || includeSensitiveOutputs\n          ? entry.value\n          : undefined\n        : unpackTerraformOutput(entry, includeSensitiveOutputs),\n    }),\n    {},\n  );\n}\n\nexport async function saveOutputs(\n  filePath: string,\n  outputs: NestedTerraformOutputs,\n  includeSensitiveOutputs: boolean,\n) {\n  fs.writeFileSync(\n    filePath,\n    JSON.stringify(\n      unpackTerraformOutput(outputs, includeSensitiveOutputs),\n      null,\n      2,\n    ),\n  );\n}\n\nexport function normalizeOutputPath(filePath: string) {\n  return path.isAbsolute(filePath)\n    ? filePath\n    : path.join(process.cwd(), filePath);\n}\n\nexport type NestedTerraformOutputs =\n  | { [key: string]: TerraformOutput }\n  | { [key: string]: NestedTerraformOutputs };\n\nconst mapActionToState = (action: ActionTypes, done: boolean) => {\n  switch (action) {\n    case \"create\":\n    case \"update\":\n      return done\n        ? DeployingResourceApplyState.CREATED\n        : DeployingResourceApplyState.CREATING;\n    case \"delete\":\n      return done\n        ? DeployingResourceApplyState.DESTROYED\n        : DeployingResourceApplyState.DESTROYING;\n    default:\n      return DeployingResourceApplyState.WAITING;\n  }\n};\n// This is deprecated and will be removed in a future version.\nconst parseJsonOutputLine = (\n  line: string,\n): Omit<DeployingResource, \"action\"> | undefined => {\n  let json, message;\n  try {\n    json = JSON.parse(line);\n  } catch {\n    logger.trace(`Could not parse line as JSON: ${line}`);\n    return;\n  }\n\n  try {\n    message = schema.parse(json);\n  } catch (err) {\n    if (err instanceof z.ZodError) {\n      logger.trace(\n        `Error parsing line into schema: ${JSON.stringify(\n          err.errors,\n        )} => ${line}`,\n      );\n    }\n\n    return;\n  }\n\n  switch (message.type) {\n    case \"apply_start\":\n    case \"apply_progress\":\n      return {\n        id: message.hook.resource.resource,\n        applyState: mapActionToState(message.hook.action, false),\n      };\n\n    case \"apply_complete\":\n      return {\n        id: message.hook.resource.resource,\n        applyState: mapActionToState(message.hook.action, true),\n      };\n    default:\n      return;\n  }\n};\n\nconst parseTextOutputLine = (\n  line: string,\n): Omit<DeployingResource, \"action\"> | undefined => {\n  if (/^Outputs:/.test(line)) {\n    return;\n  }\n  if (/^Plan:/.test(line)) {\n    return;\n  }\n  if (/^data\\..*/.test(line)) {\n    return;\n  }\n\n  const resourceMatch = line.match(/^([a-zA-Z_][a-zA-Z\\d_\\-.]*):/);\n  let applyState: DeployingResourceApplyState;\n\n  switch (true) {\n    case /Creating.../.test(line):\n    case /Still creating.../.test(line):\n      applyState = DeployingResourceApplyState.CREATING;\n      break;\n    case /Creation complete/.test(line):\n      applyState = DeployingResourceApplyState.CREATED;\n      break;\n    case /Modifying.../.test(line):\n      applyState = DeployingResourceApplyState.UPDATING;\n      break;\n    case /Modifications complete/.test(line):\n      applyState = DeployingResourceApplyState.UPDATED;\n      break;\n    case /Destroying.../.test(line):\n    case /Still destroying.../.test(line):\n      applyState = DeployingResourceApplyState.DESTROYING;\n      break;\n    case /Destruction complete/.test(line):\n      applyState = DeployingResourceApplyState.DESTROYED;\n      break;\n    default:\n      return;\n  }\n\n  if (\n    resourceMatch &&\n    resourceMatch.length >= 0 &&\n    resourceMatch[1] != \"Warning\"\n  ) {\n    return {\n      id: resourceMatch[1],\n      applyState,\n    };\n  } else {\n    return;\n  }\n};\n\nexport const parseOutput = (str: string): DeployingResource[] => {\n  const lines = stripAnsi(str.toString()).split(\"\\n\");\n\n  const resources = lines.map((line) => {\n    const parsed = parseJsonOutputLine(line) || parseTextOutputLine(line);\n    if (parsed === undefined) {\n      return;\n    }\n\n    const { id, applyState } = parsed;\n    return {\n      id,\n      applyState,\n      action: PlannedResourceAction.CREATE,\n    };\n  });\n\n  return resources.reduce((acc, resource) => {\n    if (resource) {\n      acc.push(resource);\n    }\n    return acc;\n    // eslint-disable-next-line @typescript-eslint/no-array-constructor\n  }, new Array());\n};\n\nconst isObjectEmpty = (obj: Record<string, any>): boolean => {\n  if (typeof obj !== \"object\") {\n    return false;\n  }\n  return (\n    Object.keys(obj).length === 0 ||\n    Object.values(obj).every(\n      (v) => v === undefined || v === null || isObjectEmpty(v),\n    )\n  );\n};\n\nexport const getConstructIdsForOutputs = (\n  stackContent: Record<string, any>,\n  outputs: { [key: string]: TerraformOutput },\n): NestedTerraformOutputs => {\n  // Older cdktf versions might not have the output metadata\n  if (!(\"//\" in stackContent) || !(\"outputs\" in stackContent[\"//\"])) {\n    return outputs;\n  }\n  const outputsMapping = stackContent[\"//\"].outputs;\n\n  const mapOutputs = (value: OutputIdMap): NestedTerraformOutputs => {\n    return Object.entries(value).reduce((acc, [key, value]) => {\n      if (typeof value === \"string\") {\n        return { ...acc, [key]: outputs[value] };\n      }\n\n      const mapped = mapOutputs(value);\n      if (isObjectEmpty(mapped)) {\n        return acc;\n      }\n\n      return {\n        ...acc,\n        [key]: mapped,\n      };\n    }, {});\n  };\n\n  return mapOutputs(outputsMapping);\n};\n"]}

package/build/lib/provider-add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-add.d.ts","sourceRoot":"","sources":["../../src/lib/provider-add.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAO1C,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,wBAAsB,WAAW,CAAC,EAChC,SAAS,EACT,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACZ,IAAI,EACJ,UAAU,GACX,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAsBpC"}

package/build/lib/provider-add.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerAdd = void 0;
+const dependency_manager_1 = require("./dependencies/dependency-manager");
+const init_1 = require("./init");
+async function providerAdd({ providers, language, projectDirectory, cdktfVersion, dist, forceLocal, }) {
+    const version = cdktfVersion || (await (0, init_1.determineDeps)(cdktfVersion, dist)).cdktf_version;
+    const manager = new dependency_manager_1.DependencyManager(language, version, projectDirectory);
+    let needsGet = false;
+    for (const provider of providers) {
+        const constraint = dependency_manager_1.ProviderConstraint.fromConfigEntry(provider);
+        if (forceLocal) {
+            needsGet = true;
+            await manager.addLocalProvider(constraint);
+        }
+        else {
+            const { addedLocalProvider } = await manager.addProvider(constraint);
+            if (addedLocalProvider) {
+                needsGet = true;
+            }
+        }
+    }
+    return needsGet;
+}
+exports.providerAdd = providerAdd;
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/server/terraform-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terraform-logs.d.ts","sourceRoot":"","sources":["../../../src/lib/server/terraform-logs.ts"],"names":[],"mappings":"AAWA,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEhE"}

package/build/lib/server/terraform-logs.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJsonLogIfPresent = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+function extractJsonLogLineIfPresent(logLine) {
+    try {
+        const extractedMessage = JSON.parse(logLine)["@message"];
+        return extractedMessage ? extractedMessage.trim() : logLine;
+    }
+    catch (_a) {
+        return logLine;
+    }
+}
+function extractJsonLogIfPresent(logLines) {
+    return logLines.split("\n").map(extractJsonLogLineIfPresent).join("\n");
+}
+exports.extractJsonLogIfPresent = extractJsonLogIfPresent;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVycmFmb3JtLWxvZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3NlcnZlci90ZXJyYWZvcm0tbG9ncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrQkFBK0I7QUFDL0IsbUNBQW1DO0FBQ25DLFNBQVMsMkJBQTJCLENBQUMsT0FBZTtJQUNsRCxJQUFJLENBQUM7UUFDSCxNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDekQsT0FBTyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQztJQUM5RCxDQUFDO0lBQUMsV0FBTSxDQUFDO1FBQ1AsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztBQUNILENBQUM7QUFFRCxTQUFnQix1QkFBdUIsQ0FBQyxRQUFnQjtJQUN0RCxPQUFPLFFBQVEsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLDJCQUEyQixDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQzFFLENBQUM7QUFGRCwwREFFQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG5mdW5jdGlvbiBleHRyYWN0SnNvbkxvZ0xpbmVJZlByZXNlbnQobG9nTGluZTogc3RyaW5nKTogc3RyaW5nIHtcbiAgdHJ5IHtcbiAgICBjb25zdCBleHRyYWN0ZWRNZXNzYWdlID0gSlNPTi5wYXJzZShsb2dMaW5lKVtcIkBtZXNzYWdlXCJdO1xuICAgIHJldHVybiBleHRyYWN0ZWRNZXNzYWdlID8gZXh0cmFjdGVkTWVzc2FnZS50cmltKCkgOiBsb2dMaW5lO1xuICB9IGNhdGNoIHtcbiAgICByZXR1cm4gbG9nTGluZTtcbiAgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gZXh0cmFjdEpzb25Mb2dJZlByZXNlbnQobG9nTGluZXM6IHN0cmluZyk6IHN0cmluZyB7XG4gIHJldHVybiBsb2dMaW5lcy5zcGxpdChcIlxcblwiKS5tYXAoZXh0cmFjdEpzb25Mb2dMaW5lSWZQcmVzZW50KS5qb2luKFwiXFxuXCIpO1xufVxuIl19

package/{src → build}/lib/synth-stack.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { StackManifest, TerraformStackMetadata } from "cdktn";
 export interface SynthesizedStackMetadata {
     "//"?: {

package/build/lib/synth-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synth-stack.d.ts","sourceRoot":"","sources":["../../src/lib/synth-stack.ts"],"names":[],"mappings":";AAMA,OAAO,EAGL,aAAa,EACb,sBAAsB,EACvB,MAAM,OAAO,CAAC;AAQf,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,sBAAsB,CAAA;KAAE,CAAC;CAClD;AAED,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACrD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,iBAAiB;IAKhB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJ5B,aAAa,EAAE,gBAAgB,EAAE,CAAM;IACvC,cAAc,EAAE,gBAAgB,EAAE,CAAM;IACxC,cAAc,EAAE,gBAAgB,EAAE,CAAM;gBAElB,MAAM,EAAE,gBAAgB,EAAE;IAIhD,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAOvC,SAAS,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAO/C,IAAW,uBAAuB,IAAI,gBAAgB,EAAE,CAYvD;CACF;AAOD,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC;AAElC,qBAAa,UAAU;WACD,KAAK,CACvB,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,gBAAgB,SAAgB,EAChC,QAAQ,UAAQ,EAAE,0DAA0D;IAC5E,OAAO,UAAQ,EACf,WAAW,CAAC,EAAE,WAAW,EACzB,GAAG,UAAQ,GACV,OAAO,CAAC,gBAAgB,EAAE,CAAC;WAmIV,cAAc,CAAC,MAAM,EAAE,MAAM;WAsB7B,qBAAqB,CACvC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,gBAAgB,EAAE,CAAC;WAkCV,cAAc,CAChC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,gBAAgB,EAAE,EAC1B,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,IAAI,CAAC;WAiBI,mBAAmB,CAAC,WAAW,CAAC,EAAE,WAAW;CAGlE"}

package/build/lib/synth-stack.js

@@ -0,0 +1,251 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynthStack = exports.StackDependencies = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const chalk = __importStar(require("chalk"));
+const indent_string_1 = __importDefault(require("indent-string"));
+const cdktn_1 = require("cdktn");
+const perf_hooks_1 = require("perf_hooks");
+const commons_1 = require("@cdktn/commons");
+const cdktf_config_1 = require("./cdktf-config");
+const hcl_tools_1 = require("@cdktn/hcl-tools");
+const chalkColour = new chalk.Instance();
+class StackDependencies {
+    constructor(stacks) {
+        this.stacks = stacks;
+        this.pendingStacks = [];
+        this.inflightStacks = [];
+        this.deployedStacks = [];
+        this.pendingStacks = [...this.stacks];
+    }
+    startRun(stack) {
+        this.pendingStacks = this.pendingStacks.filter((item) => item.name !== stack.name);
+        this.inflightStacks.push(stack);
+    }
+    finishRun(stack) {
+        this.inflightStacks = this.inflightStacks.filter((item) => item.name !== stack.name);
+        this.deployedStacks.push(stack);
+    }
+    get pendingDeployableStacks() {
+        return this.pendingStacks.filter((pendingStack) => {
+            const unmetDependencies = pendingStack.dependencies.filter((dependency) => {
+                return !this.deployedStacks.some((deployedStack) => {
+                    return deployedStack.name === dependency;
+                });
+            });
+            return unmetDependencies.length === 0;
+        });
+    }
+}
+exports.StackDependencies = StackDependencies;
+class SynthStack {
+    static async synth(abortSignal, command, outdir, workingDirectory = process.cwd(), graceful = false, // will not exit the process but rethrow the error instead
+    noColor = false, synthOrigin, hcl = false) {
+        // start performance timer
+        const startTime = perf_hooks_1.performance.now();
+        const isDirectory = (source) => fs.lstatSync(source).isDirectory();
+        const getDirectories = (source) => {
+            if (!fs.existsSync(source))
+                return [];
+            return fs
+                .readdirSync(source)
+                .map((name) => path.join(source, name))
+                .filter(isDirectory);
+        };
+        const existingDirectories = getDirectories(path.join(outdir, cdktn_1.Manifest.stacksFolder));
+        const env = Object.fromEntries(Object.entries(process.env).filter(
+        // We don't want to pass Terraform variables to the synth command since they should only be used at execution time
+        ([key]) => !key.startsWith("TF_VAR_")));
+        // Increases the default memory available to Node.js when synthesizing a TypeScript CDK project.
+        const nodeOptsSwitch = "--max-old-space-size";
+        const nodeOptsSetting = `${nodeOptsSwitch}=4096`;
+        if (env.NODE_OPTIONS && !env.NODE_OPTIONS.includes(nodeOptsSwitch)) {
+            commons_1.logger.warn(`WARNING: Found NODE_OPTIONS environment variable without a setting for ${nodeOptsSwitch}
+The synthesizing step for TypeScript may need an increased amount of memory if multiple large providers
+are used with locally generated bindings. You can ignore this if you don't use CDKTN with TypeScript.
+If not present, the cdktn-cli sets it to NODE_OPTIONS="${nodeOptsSetting}" by default. But as
+your environment already contains a NODE_OPTIONS variable, we won't override it. Hence, the app command
+might fail while synthesizing with an out of memory error.`);
+        }
+        else if (!env.NODE_OPTIONS) {
+            // increase memory to allow ts-node (when using TypeScript) to handle large amounts of generated code in memory
+            env.NODE_OPTIONS = `${env.NODE_OPTIONS || ""} ${nodeOptsSetting}`.trim();
+        }
+        const currentContext = process.env[cdktn_1.CONTEXT_ENV]
+            ? JSON.parse(process.env.CDKTF_CONTEXT_JSON)
+            : {};
+        const relativeModules = getRelativeTerraformModules();
+        try {
+            await (0, commons_1.shell)(command, [], {
+                shell: true,
+                env: {
+                    ...env,
+                    CDKTF_OUTDIR: outdir,
+                    CDKTF_CONTINUE_SYNTH_ON_ERROR_ANNOTATIONS: "true", // we want to display the errors ourselves
+                    [cdktn_1.CONTEXT_ENV]: JSON.stringify({
+                        ...currentContext,
+                        cdktfRelativeModules: relativeModules,
+                    }),
+                    SYNTH_HCL_OUTPUT: hcl.toString(),
+                },
+                cwd: workingDirectory,
+                signal: abortSignal,
+                noColor: noColor,
+            });
+        }
+        catch (e) {
+            const errorOutput = chalkColour `{redBright cdktn encountered an error while synthesizing}
+
+Synth command: {blue ${command}}
+Error:         {redBright ${e.message}}
+${e.stderr
+                ? chalkColour `
+Command output on stderr:
+
+{dim ${(0, indent_string_1.default)(e.stderr, 4)}}
+`
+                : ""}
+${e.stdout
+                ? chalkColour `
+Command output on stdout:
+
+{dim ${(0, indent_string_1.default)(e.stdout, 4)}}
+`
+                : ""}`;
+            await this.synthErrorTelemetry(synthOrigin);
+            if (graceful) {
+                e.errorOutput = errorOutput;
+                throw e;
+            }
+            console.error(`ERROR: ${errorOutput}`);
+            process.exit(1);
+        }
+        // Apply formatting to HCL files if hcl output was selected
+        if (hcl) {
+            await SynthStack.formatHclFiles(outdir);
+        }
+        // end performance timer
+        const endTime = perf_hooks_1.performance.now();
+        let stacks = [];
+        try {
+            stacks = await SynthStack.readSynthesizedStacks(outdir);
+        }
+        catch (e) {
+            const errorMessage = `ERROR: synthesis failed, because app was expected to call 'synth()', but didn't. Thus "${outdir}/${cdktn_1.Manifest.fileName}"  was not created: ${e}`;
+            if (graceful) {
+                throw new Error(errorMessage);
+            }
+            commons_1.logger.error(errorMessage);
+            process.exit(1);
+        }
+        await this.synthTelemetry(endTime - startTime, stacks, synthOrigin);
+        if (stacks.length === 0) {
+            commons_1.logger.error("ERROR: No Terraform code synthesized.");
+        }
+        const stackNames = stacks.map((s) => s.name);
+        const orphanedDirectories = existingDirectories.filter((e) => !stackNames.includes(path.basename(e)));
+        for (const orphanedDirectory of orphanedDirectories) {
+            fs.rmSync(orphanedDirectory, { recursive: true });
+        }
+        return stacks;
+    }
+    static async formatHclFiles(outDir) {
+        const manifestPath = path.join(outDir, cdktn_1.Manifest.fileName);
+        if (!(await fs.pathExists(manifestPath))) {
+            throw new Error(`Could not find manifest file at ${manifestPath}. In case --skip-synth was passed, please try again without the flag.`);
+        }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath).toString());
+        for (const stackName in manifest.stacks) {
+            const stack = manifest.stacks[stackName];
+            const filePath = path.join(outDir, stack.synthesizedStackPath);
+            const hclContent = fs.readFileSync(filePath).toString();
+            const formattedHcl = await (0, hcl_tools_1.format)(hclContent);
+            fs.writeFileSync(filePath, formattedHcl);
+        }
+    }
+    static async readSynthesizedStacks(outdir) {
+        const manifestPath = path.join(outdir, cdktn_1.Manifest.fileName);
+        if (!(await fs.pathExists(manifestPath))) {
+            throw new Error(`Could not find manifest file at ${manifestPath}. In case --skip-synth was passed, please try again without the flag.`);
+        }
+        const stacks = [];
+        const manifest = JSON.parse(fs.readFileSync(manifestPath).toString());
+        for (const stackName in manifest.stacks) {
+            const stack = manifest.stacks[stackName];
+            const filePath = path.join(outdir, stack.synthesizedStackPath);
+            let jsonContent = {};
+            if (filePath.endsWith(".tf.json")) {
+                jsonContent = JSON.parse(fs.readFileSync(filePath).toString());
+            }
+            else {
+                const metadataPath = path.join(outdir, stack.stackMetadataPath);
+                jsonContent = JSON.parse(fs.readFileSync(metadataPath).toString());
+            }
+            stacks.push({
+                ...stack,
+                workingDirectory: path.join(outdir, stack.workingDirectory),
+                content: JSON.stringify(jsonContent, null, 2),
+            });
+        }
+        return stacks;
+    }
+    static async synthTelemetry(totalTime, stacks, synthOrigin) {
+        const config = (0, commons_1.readConfigSync)();
+        await (0, commons_1.sendTelemetry)("synth", {
+            totalTime: totalTime,
+            language: config.language,
+            synthOrigin,
+            stackMetadata: stacks.map((stack) => JSON.parse(stack.content)["//"].metadata),
+            requiredProviders: stacks.map((stack) => JSON.parse(stack.content)["terraform"].required_providers),
+        });
+    }
+    static async synthErrorTelemetry(synthOrigin) {
+        await (0, commons_1.sendTelemetry)("synth", { error: true, synthOrigin });
+    }
+}
+exports.SynthStack = SynthStack;
+function getRelativeTerraformModules() {
+    let cfg;
+    try {
+        cfg = cdktf_config_1.CdktfConfig.read();
+    }
+    catch (e) {
+        commons_1.logger.trace("Could not read cdktf.json: " + e);
+        return [];
+    }
+    return cfg.terraformModules.filter((mod) => {
+        return typeof mod === "string"
+            ? mod.startsWith("./") || mod.startsWith("../")
+            : mod.source.startsWith("./") || mod.source.startsWith("../");
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synth-stack.js","sourceRoot":"","sources":["../../src/lib/synth-stack.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\";\nimport * as chalk from \"chalk\";\nimport indentString from \"indent-string\";\nimport {\n  CONTEXT_ENV,\n  Manifest,\n  StackManifest,\n  TerraformStackMetadata,\n} from \"cdktn\";\nimport { performance } from \"perf_hooks\";\nimport { logger, readConfigSync, sendTelemetry, shell } from \"@cdktn/commons\";\nimport { CdktfConfig } from \"./cdktf-config\";\nimport { format } from \"@cdktn/hcl-tools\";\n\nconst chalkColour = new chalk.Instance();\n\nexport interface SynthesizedStackMetadata {\n  \"//\"?: { [key: string]: TerraformStackMetadata };\n}\n\nexport interface SynthesizedStack extends StackManifest {\n  content: string;\n}\n\nexport class StackDependencies {\n  public pendingStacks: SynthesizedStack[] = [];\n  public inflightStacks: SynthesizedStack[] = [];\n  public deployedStacks: SynthesizedStack[] = [];\n\n  constructor(private readonly stacks: SynthesizedStack[]) {\n    this.pendingStacks = [...this.stacks];\n  }\n\n  public startRun(stack: SynthesizedStack): void {\n    this.pendingStacks = this.pendingStacks.filter(\n      (item) => item.name !== stack.name,\n    );\n    this.inflightStacks.push(stack);\n  }\n\n  public finishRun(stack: SynthesizedStack): void {\n    this.inflightStacks = this.inflightStacks.filter(\n      (item) => item.name !== stack.name,\n    );\n    this.deployedStacks.push(stack);\n  }\n\n  public get pendingDeployableStacks(): SynthesizedStack[] {\n    return this.pendingStacks.filter((pendingStack) => {\n      const unmetDependencies = pendingStack.dependencies.filter(\n        (dependency) => {\n          return !this.deployedStacks.some((deployedStack) => {\n            return deployedStack.name === dependency;\n          });\n        },\n      );\n\n      return unmetDependencies.length === 0;\n    });\n  }\n}\n\ninterface ManifestJson {\n  version: string;\n  stacks: StackManifest[];\n}\n\nexport type SynthOrigin = \"watch\";\n\nexport class SynthStack {\n  public static async synth(\n    abortSignal: AbortSignal,\n    command: string,\n    outdir: string,\n    workingDirectory = process.cwd(),\n    graceful = false, // will not exit the process but rethrow the error instead\n    noColor = false,\n    synthOrigin?: SynthOrigin,\n    hcl = false,\n  ): Promise<SynthesizedStack[]> {\n    // start performance timer\n    const startTime = performance.now();\n\n    const isDirectory = (source: string) => fs.lstatSync(source).isDirectory();\n    const getDirectories = (source: string) => {\n      if (!fs.existsSync(source)) return [];\n      return fs\n        .readdirSync(source)\n        .map((name) => path.join(source, name))\n        .filter(isDirectory);\n    };\n\n    const existingDirectories = getDirectories(\n      path.join(outdir, Manifest.stacksFolder),\n    );\n\n    const env = Object.fromEntries(\n      Object.entries(process.env).filter(\n        // We don't want to pass Terraform variables to the synth command since they should only be used at execution time\n        ([key]) => !key.startsWith(\"TF_VAR_\"),\n      ),\n    );\n\n    // Increases the default memory available to Node.js when synthesizing a TypeScript CDK project.\n    const nodeOptsSwitch = \"--max-old-space-size\";\n    const nodeOptsSetting = `${nodeOptsSwitch}=4096`;\n    if (env.NODE_OPTIONS && !env.NODE_OPTIONS.includes(nodeOptsSwitch)) {\n      logger.warn(`WARNING: Found NODE_OPTIONS environment variable without a setting for ${nodeOptsSwitch}\nThe synthesizing step for TypeScript may need an increased amount of memory if multiple large providers\nare used with locally generated bindings. You can ignore this if you don't use CDKTN with TypeScript.\nIf not present, the cdktn-cli sets it to NODE_OPTIONS=\"${nodeOptsSetting}\" by default. But as\nyour environment already contains a NODE_OPTIONS variable, we won't override it. Hence, the app command\nmight fail while synthesizing with an out of memory error.`);\n    } else if (!env.NODE_OPTIONS) {\n      // increase memory to allow ts-node (when using TypeScript) to handle large amounts of generated code in memory\n      env.NODE_OPTIONS = `${env.NODE_OPTIONS || \"\"} ${nodeOptsSetting}`.trim();\n    }\n\n    const currentContext = process.env[CONTEXT_ENV]\n      ? JSON.parse(process.env.CDKTF_CONTEXT_JSON)\n      : {};\n    const relativeModules = getRelativeTerraformModules();\n\n    try {\n      await shell(command, [], {\n        shell: true,\n        env: {\n          ...env,\n          CDKTF_OUTDIR: outdir,\n          CDKTF_CONTINUE_SYNTH_ON_ERROR_ANNOTATIONS: \"true\", // we want to display the errors ourselves\n          [CONTEXT_ENV]: JSON.stringify({\n            ...currentContext,\n            cdktfRelativeModules: relativeModules,\n          }),\n          SYNTH_HCL_OUTPUT: hcl.toString(),\n        },\n        cwd: workingDirectory,\n        signal: abortSignal,\n        noColor: noColor,\n      });\n    } catch (e: any) {\n      const errorOutput = chalkColour`{redBright cdktn encountered an error while synthesizing}\n\nSynth command: {blue ${command}}\nError:         {redBright ${e.message}}\n${\n  e.stderr\n    ? chalkColour`\nCommand output on stderr:\n\n{dim ${indentString(e.stderr, 4)}}\n`\n    : \"\"\n}\n${\n  e.stdout\n    ? chalkColour`\nCommand output on stdout:\n\n{dim ${indentString(e.stdout, 4)}}\n`\n    : \"\"\n}`;\n      await this.synthErrorTelemetry(synthOrigin);\n      if (graceful) {\n        e.errorOutput = errorOutput;\n        throw e;\n      }\n      console.error(`ERROR: ${errorOutput}`);\n      process.exit(1);\n    }\n\n    // Apply formatting to HCL files if hcl output was selected\n    if (hcl) {\n      await SynthStack.formatHclFiles(outdir);\n    }\n\n    // end performance timer\n    const endTime = performance.now();\n\n    let stacks: SynthesizedStack[] = [];\n    try {\n      stacks = await SynthStack.readSynthesizedStacks(outdir);\n    } catch (e: any) {\n      const errorMessage = `ERROR: synthesis failed, because app was expected to call 'synth()', but didn't. Thus \"${outdir}/${Manifest.fileName}\"  was not created: ${e}`;\n      if (graceful) {\n        throw new Error(errorMessage);\n      }\n      logger.error(errorMessage);\n      process.exit(1);\n    }\n\n    await this.synthTelemetry(endTime - startTime, stacks, synthOrigin);\n\n    if (stacks.length === 0) {\n      logger.error(\"ERROR: No Terraform code synthesized.\");\n    }\n\n    const stackNames = stacks.map((s) => s.name);\n    const orphanedDirectories = existingDirectories.filter(\n      (e) => !stackNames.includes(path.basename(e)),\n    );\n\n    for (const orphanedDirectory of orphanedDirectories) {\n      fs.rmSync(orphanedDirectory, { recursive: true });\n    }\n\n    return stacks;\n  }\n\n  public static async formatHclFiles(outDir: string) {\n    const manifestPath = path.join(outDir, Manifest.fileName);\n    if (!(await fs.pathExists(manifestPath))) {\n      throw new Error(\n        `Could not find manifest file at ${manifestPath}. In case --skip-synth was passed, please try again without the flag.`,\n      );\n    }\n\n    const manifest = JSON.parse(\n      fs.readFileSync(manifestPath).toString(),\n    ) as ManifestJson;\n\n    for (const stackName in manifest.stacks) {\n      const stack = manifest.stacks[stackName];\n      const filePath = path.join(outDir, stack.synthesizedStackPath);\n\n      const hclContent = fs.readFileSync(filePath).toString();\n      const formattedHcl = await format(hclContent);\n      fs.writeFileSync(filePath, formattedHcl);\n    }\n  }\n\n  public static async readSynthesizedStacks(\n    outdir: string,\n  ): Promise<SynthesizedStack[]> {\n    const manifestPath = path.join(outdir, Manifest.fileName);\n    if (!(await fs.pathExists(manifestPath))) {\n      throw new Error(\n        `Could not find manifest file at ${manifestPath}. In case --skip-synth was passed, please try again without the flag.`,\n      );\n    }\n\n    const stacks: SynthesizedStack[] = [];\n    const manifest = JSON.parse(\n      fs.readFileSync(manifestPath).toString(),\n    ) as ManifestJson;\n\n    for (const stackName in manifest.stacks) {\n      const stack = manifest.stacks[stackName];\n      const filePath = path.join(outdir, stack.synthesizedStackPath);\n      let jsonContent: SynthesizedStackMetadata = {};\n      if (filePath.endsWith(\".tf.json\")) {\n        jsonContent = JSON.parse(fs.readFileSync(filePath).toString());\n      } else {\n        const metadataPath = path.join(outdir, stack.stackMetadataPath!);\n        jsonContent = JSON.parse(fs.readFileSync(metadataPath).toString());\n      }\n\n      stacks.push({\n        ...stack,\n        workingDirectory: path.join(outdir, stack.workingDirectory),\n        content: JSON.stringify(jsonContent, null, 2),\n      });\n    }\n\n    return stacks;\n  }\n\n  public static async synthTelemetry(\n    totalTime: number,\n    stacks: SynthesizedStack[],\n    synthOrigin?: SynthOrigin,\n  ): Promise<void> {\n    const config = readConfigSync();\n\n    await sendTelemetry(\"synth\", {\n      totalTime: totalTime,\n      language: config.language,\n      synthOrigin,\n      stackMetadata: stacks.map(\n        (stack) => JSON.parse(stack.content)[\"//\"].metadata,\n      ),\n      requiredProviders: stacks.map(\n        (stack: any) =>\n          JSON.parse(stack.content)[\"terraform\"].required_providers,\n      ),\n    });\n  }\n\n  public static async synthErrorTelemetry(synthOrigin?: SynthOrigin) {\n    await sendTelemetry(\"synth\", { error: true, synthOrigin });\n  }\n}\n\nfunction getRelativeTerraformModules() {\n  let cfg;\n\n  try {\n    cfg = CdktfConfig.read();\n  } catch (e) {\n    logger.trace(\"Could not read cdktf.json: \" + e);\n    return [];\n  }\n\n  return cfg.terraformModules.filter((mod) => {\n    return typeof mod === \"string\"\n      ? mod.startsWith(\"./\") || mod.startsWith(\"../\")\n      : mod.source.startsWith(\"./\") || mod.source.startsWith(\"../\");\n  });\n}\n"]}

package/build/lib/synth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synth.d.ts","sourceRoot":"","sources":["../../src/lib/synth.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMjD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,QA0C1D"}