@cdktn/cli-core 0.23.0-pre.8 → 0.23.1

package/build/lib/synth.js

@@ -0,0 +1,67 @@
+"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.printAnnotations = void 0;
+const cdktn_1 = require("cdktn");
+const chalk = __importStar(require("chalk"));
+const chalkColour = new chalk.Instance();
+/**
+ * prints annotations via console
+ * @throws Error if an Annotation with level === ERROR has been encountered
+ */
+function printAnnotations(stacks) {
+    let encounteredAnnotationError = false;
+    stacks.forEach((stack) => (stack.annotations || []).forEach((annotation) => {
+        if (annotation.level === cdktn_1.AnnotationMetadataEntryType.ERROR)
+            encounteredAnnotationError = true;
+        let color = chalkColour.whiteBright;
+        let level = annotation.level;
+        switch (annotation.level) {
+            case cdktn_1.AnnotationMetadataEntryType.INFO: {
+                level = "INFO";
+                break;
+            }
+            case cdktn_1.AnnotationMetadataEntryType.WARN: {
+                color = chalkColour.hex("#FFA500"); // orange
+                level = "WARN";
+                break;
+            }
+            case cdktn_1.AnnotationMetadataEntryType.ERROR: {
+                color = chalkColour.redBright;
+                level = "ERROR";
+                break;
+            }
+        }
+        console.log(color(`${level} [${annotation.constructPath}]: ${annotation.message}`));
+        if (annotation.level === cdktn_1.AnnotationMetadataEntryType.ERROR &&
+            annotation.stacktrace)
+            console.log(chalkColour.gray(annotation.stacktrace.join("\n")));
+    }));
+    if (encounteredAnnotationError) {
+        throw new Error("While synthesizing one or more error annotations have been encountered. Please check the log output above.");
+    }
+}
+exports.printAnnotations = printAnnotations;
+//# sourceMappingURL=data:application/json;base64,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

package/{src → build}/lib/terraform-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terraform-json.d.ts","sourceRoot":"","sources":["terraform-json.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUI,CAAC;AAEjB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA0ClB,CAAC;AAEf,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACjE,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC"}
+{"version":3,"file":"terraform-json.d.ts","sourceRoot":"","sources":["../../src/lib/terraform-json.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUI,CAAC;AAEjB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA0ClB,CAAC;AAEf,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACjE,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC"}

package/build/lib/terraform-json.js

@@ -0,0 +1,82 @@
+"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.terraformJsonSchema = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const z = __importStar(require("zod"));
+const remote = z
+    .object({
+    organization: z.string(),
+    hostname: z.string().optional(),
+    token: z.string().optional(),
+    workspaces: z.object({
+        name: z.string().optional(),
+        prefix: z.string().optional(),
+    }),
+})
+    .deepPartial();
+exports.terraformJsonSchema = z
+    .object({
+    "//": z
+        .object({
+        metadata: z
+            .object({
+            version: z.string(),
+            stackName: z.string(),
+            backend: z.string(),
+        })
+            .nonstrict(),
+        outputs: z.record(z.any()),
+    })
+        .nonstrict(),
+    terraform: z.object({
+        backend: z
+            .object({
+            // All other backends are here as well, but we don't read them right now
+            remote,
+        })
+            .nonstrict(),
+        cloud: z
+            .object({
+            organization: z.string(),
+            hostname: z.string().optional(),
+            token: z.string().optional(),
+            workspaces: z.union([
+                z.object({ name: z.string() }),
+                z.object({ tags: z.array(z.string()) }),
+            ]),
+        })
+            .nonstrict(),
+        required_providers: z.record(z.object({ source: z.string(), version: z.string() }).nonstrict()),
+        required_version: z.string(),
+    }),
+    data: z.record(z.any()),
+    provider: z.record(z.any()),
+    resource: z.record(z.any()),
+})
+    .deepPartial()
+    .nonstrict();
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/terraform-provider-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terraform-provider-lock.d.ts","sourceRoot":"","sources":["../../src/lib/terraform-provider-lock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAKvE,KAAK,8BAA8B,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAQF,qBAAa,qBAAqB;IAEpB,OAAO,CAAC,qBAAqB;IADzC,OAAO,CAAC,iBAAiB,CAAuC;gBAC5C,qBAAqB,EAAE,MAAM;IAIjD,OAAO,KAAK,YAAY,GAEvB;IAEY,mBAAmB;YASlB,oBAAoB;IAYlC,OAAO,CAAC,qBAAqB;IAyChB,SAAS,CAAC,WAAW,UAAQ;;;IAS7B,mBAAmB,CAAC,UAAU,EAAE,kBAAkB;CAWhE"}

package/{src → build}/lib/terraform-provider-lock.js

@@ -26,7 +26,7 @@ class TerraformProviderLock {
             await promises_1.default.stat(this.lockFilePath);
             return true;
         }
-        catch (e) {
+        catch (_a) {
             return false;
         }
     }
@@ -92,4 +92,4 @@ class TerraformProviderLock {
     }
 }
 exports.TerraformProviderLock = TerraformProviderLock;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{src → build}/lib/watch.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { CdktfProjectOptions, MutationOptions } from "./cdktf-project";
 import { CdktfStack } from "./cdktf-stack";
 export type State = {

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

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/lib/watch.ts"],"names":[],"mappings":";AAGA,OAAO,EAEL,mBAAmB,EACnB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AA0E3C,MAAM,MAAM,KAAK,GACb;IACE,IAAI,EAAE,SAAS,CAAC;CACjB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB,GACD;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAExB,wBAAsB,KAAK,CACzB,cAAc,EAAE,mBAAmB,EACnC,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,CAAC,QAAQ,EAAE,KAAK,KAAK,IAAI,iBAiFzC"}

package/build/lib/watch.js

@@ -0,0 +1,155 @@
+"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.watch = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const path_1 = __importDefault(require("path"));
+const cdktf_project_1 = require("./cdktf-project");
+const fs = __importStar(require("fs"));
+const chokidar = __importStar(require("chokidar"));
+const commons_1 = require("@cdktn/commons");
+// In this very first iteration we will find out which files to watch by asking the user to provide the files
+// We default to something reasonable per language and write it into the cdkt.json file
+// Mid-Term we might want to add a WatchFile / WatchDir construct that we can use (e.g. in assets) and that a user can use to specify their watch behaviour
+// See https://github.com/hashicorp/terraform-cdk/issues/1668
+function getOrWriteDefaultWatchConfig(projectPath = process.cwd()) {
+    const cdktfJsonPath = path_1.default.resolve(projectPath, "cdktf.json");
+    commons_1.logger.debug(`Getting files to watch from cdktf.json at ${cdktfJsonPath}`);
+    let cdktfJson;
+    try {
+        cdktfJson = JSON.parse(fs.readFileSync(cdktfJsonPath, "utf-8"));
+    }
+    catch (err) {
+        throw commons_1.Errors.Internal(`Could not find cdktf.json file in ${projectPath}`, err);
+    }
+    if (cdktfJson.watchPattern) {
+        commons_1.logger.debug(`Found watchPattern in cdktf.json: ${cdktfJson.watchPattern}`);
+        return cdktfJson.watchPattern;
+    }
+    const language = cdktfJson.language;
+    if (!language) {
+        throw commons_1.Errors.Usage(`No language specified in cdktf.json, please either specify a language or watchPattern to use the watch command`);
+    }
+    const defaultWatchPattern = {
+        typescript: ["./**/*.ts"],
+        python: ["./**/*.py"],
+        java: ["src/**/*.java"],
+        csharp: ["./**/*.cs"],
+        go: ["./**/*.go"],
+    }[language];
+    fs.writeFileSync(cdktfJsonPath, JSON.stringify({ ...cdktfJson, watchPattern: defaultWatchPattern }, null, 2));
+    commons_1.logger.debug(`Write default watchPattern for ${language} in cdktf.json.`);
+    return defaultWatchPattern;
+}
+const projectStatus = (project) => {
+    if (!(project === null || project === void 0 ? void 0 : project.stacksToRun.length)) {
+        return {
+            inProgress: [],
+            finished: [],
+            pending: [],
+        };
+    }
+    const inProgress = project.stacksToRun.filter((s) => s.isRunning);
+    const finished = project.stacksToRun.filter((s) => s.isDone);
+    const pending = project.stacksToRun.filter((s) => s.isPending);
+    return { inProgress, finished, pending };
+};
+async function watch(projectOptions, mutationOptions, abortSignal, onStateChange) {
+    const patterns = getOrWriteDefaultWatchConfig();
+    const watcher = chokidar.watch(patterns, {
+        ignoreInitial: true,
+    });
+    let state = { type: "waiting" };
+    const changeState = (newState) => {
+        state = newState;
+        onStateChange(state);
+    };
+    async function run() {
+        commons_1.logger.debug("Running cdktn deploy");
+        const project = new cdktf_project_1.CdktfProject({
+            synthOrigin: "watch",
+            ...projectOptions,
+            onLog: (log) => {
+                if (projectOptions.onLog) {
+                    projectOptions.onLog(log);
+                }
+                if (state.type === "running") {
+                    changeState({ ...state, ...projectStatus(project) });
+                }
+            },
+        });
+        const abort = () => project.hardAbort();
+        abortSignal.addEventListener("abort", abort);
+        await project.deploy(mutationOptions);
+        abortSignal.removeEventListener("abort", abort);
+        commons_1.logger.debug("cdktn deploy finished");
+        if (state.type !== "running") {
+            throw commons_1.Errors.Internal("Watch was in a state where the state was not running in the run phase");
+        }
+        if (state.nextRunQueued) {
+            commons_1.logger.debug("Next run was queued, starting it now");
+            changeState({
+                ...state,
+                nextRunQueued: false,
+                currentRun: run(),
+                ...projectStatus(project),
+            });
+        }
+        else {
+            commons_1.logger.debug("Nothing queued, waiting for changes");
+            changeState({ type: "waiting" });
+        }
+    }
+    abortSignal.addEventListener("abort", () => {
+        commons_1.logger.debug("Abort signal received, stopping watch");
+        watcher.close();
+        changeState({ type: "stopped" });
+    });
+    const onFileChange = () => {
+        if (state.type === "stopped") {
+            return;
+        }
+        if (state.type === "running") {
+            changeState({ ...state, nextRunQueued: true });
+            return;
+        }
+        changeState({
+            type: "running",
+            nextRunQueued: false,
+            currentRun: run(),
+            ...projectStatus(),
+        });
+    };
+    watcher.on("all", onFileChange);
+    // initially run once
+    onFileChange();
+    await (0, commons_1.sendTelemetry)("watch", { event: "start" });
+}
+exports.watch = watch;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watch.js","sourceRoot":"","sources":["../../src/lib/watch.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,mCAAmC;AACnC,gDAAwB;AACxB,mDAIyB;AACzB,uCAAyB;AACzB,mDAAqC;AACrC,4CAA+D;AAG/D,6GAA6G;AAC7G,uFAAuF;AACvF,2JAA2J;AAC3J,6DAA6D;AAC7D,SAAS,4BAA4B,CAAC,WAAW,GAAG,OAAO,CAAC,GAAG,EAAE;IAC/D,MAAM,aAAa,GAAG,cAAI,CAAC,OAAO,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;IAC9D,gBAAM,CAAC,KAAK,CAAC,6CAA6C,aAAa,EAAE,CAAC,CAAC;IAE3E,IAAI,SAAS,CAAC;IACd,IAAI,CAAC;QACH,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC;IAClE,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,MAAM,gBAAM,CAAC,QAAQ,CACnB,qCAAqC,WAAW,EAAE,EAClD,GAAG,CACJ,CAAC;IACJ,CAAC;IAED,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;QAC3B,gBAAM,CAAC,KAAK,CAAC,qCAAqC,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC;QAC5E,OAAO,SAAS,CAAC,YAAY,CAAC;IAChC,CAAC;IACD,MAAM,QAAQ,GAME,SAAS,CAAC,QAAQ,CAAC;IAEnC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,gBAAM,CAAC,KAAK,CAChB,gHAAgH,CACjH,CAAC;IACJ,CAAC;IAED,MAAM,mBAAmB,GAAG;QAC1B,UAAU,EAAE,CAAC,WAAW,CAAC;QACzB,MAAM,EAAE,CAAC,WAAW,CAAC;QACrB,IAAI,EAAE,CAAC,eAAe,CAAC;QACvB,MAAM,EAAE,CAAC,WAAW,CAAC;QACrB,EAAE,EAAE,CAAC,WAAW,CAAC;KAClB,CAAC,QAAQ,CAAC,CAAC;IAEZ,EAAE,CAAC,aAAa,CACd,aAAa,EACb,IAAI,CAAC,SAAS,CACZ,EAAE,GAAG,SAAS,EAAE,YAAY,EAAE,mBAAmB,EAAE,EACnD,IAAI,EACJ,CAAC,CACF,CACF,CAAC;IACF,gBAAM,CAAC,KAAK,CAAC,kCAAkC,QAAQ,iBAAiB,CAAC,CAAC;IAE1E,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED,MAAM,aAAa,GAAG,CAAC,OAAsB,EAAE,EAAE;IAC/C,IAAI,CAAC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW,CAAC,MAAM,CAAA,EAAE,CAAC;QACjC,OAAO;YACL,UAAU,EAAE,EAAE;YACd,QAAQ,EAAE,EAAE;YACZ,OAAO,EAAE,EAAE;SACZ,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAClE,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAC7D,MAAM,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC/D,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AAC3C,CAAC,CAAC;AAgBK,KAAK,UAAU,KAAK,CACzB,cAAmC,EACnC,eAAgC,EAChC,WAAwB,EACxB,aAAwC;IAExC,MAAM,QAAQ,GAAG,4BAA4B,EAAE,CAAC;IAChD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE;QACvC,aAAa,EAAE,IAAI;KACpB,CAAC,CAAC;IACH,IAAI,KAAK,GAAU,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IACvC,MAAM,WAAW,GAAG,CAAC,QAAe,EAAE,EAAE;QACtC,KAAK,GAAG,QAAQ,CAAC;QACjB,aAAa,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC,CAAC;IAEF,KAAK,UAAU,GAAG;QAChB,gBAAM,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;QACrC,MAAM,OAAO,GAAG,IAAI,4BAAY,CAAC;YAC/B,WAAW,EAAE,OAAO;YACpB,GAAG,cAAc;YACjB,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;gBACb,IAAI,cAAc,CAAC,KAAK,EAAE,CAAC;oBACzB,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC5B,CAAC;gBACD,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;oBAC7B,WAAW,CAAC,EAAE,GAAG,KAAK,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;gBACvD,CAAC;YACH,CAAC;SACF,CAAC,CAAC;QACH,MAAM,KAAK,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;QACxC,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC7C,MAAM,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QACtC,WAAW,CAAC,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAChD,gBAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAEtC,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,gBAAM,CAAC,QAAQ,CACnB,uEAAuE,CACxE,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;YACxB,gBAAM,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACrD,WAAW,CAAC;gBACV,GAAG,KAAK;gBACR,aAAa,EAAE,KAAK;gBACpB,UAAU,EAAE,GAAG,EAAE;gBACjB,GAAG,aAAa,CAAC,OAAO,CAAC;aAC1B,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,gBAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;YACpD,WAAW,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAED,WAAW,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE;QACzC,gBAAM,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC;QACtD,OAAO,CAAC,KAAK,EAAE,CAAC;QAChB,WAAW,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;IAEH,MAAM,YAAY,GAAG,GAAG,EAAE;QACxB,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO;QACT,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,WAAW,CAAC,EAAE,GAAG,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;YAC/C,OAAO;QACT,CAAC;QAED,WAAW,CAAC;YACV,IAAI,EAAE,SAAS;YACf,aAAa,EAAE,KAAK;YACpB,UAAU,EAAE,GAAG,EAAE;YACjB,GAAG,aAAa,EAAE;SACnB,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IAChC,qBAAqB;IACrB,YAAY,EAAE,CAAC;IAEf,MAAM,IAAA,uBAAa,EAAC,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;AACnD,CAAC;AArFD,sBAqFC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport path from \"path\";\nimport {\n  CdktfProject,\n  CdktfProjectOptions,\n  MutationOptions,\n} from \"./cdktf-project\";\nimport * as fs from \"fs\";\nimport * as chokidar from \"chokidar\";\nimport { logger, Errors, sendTelemetry } from \"@cdktn/commons\";\nimport { CdktfStack } from \"./cdktf-stack\";\n\n// In this very first iteration we will find out which files to watch by asking the user to provide the files\n// We default to something reasonable per language and write it into the cdkt.json file\n// Mid-Term we might want to add a WatchFile / WatchDir construct that we can use (e.g. in assets) and that a user can use to specify their watch behaviour\n// See https://github.com/hashicorp/terraform-cdk/issues/1668\nfunction getOrWriteDefaultWatchConfig(projectPath = process.cwd()) {\n  const cdktfJsonPath = path.resolve(projectPath, \"cdktf.json\");\n  logger.debug(`Getting files to watch from cdktf.json at ${cdktfJsonPath}`);\n\n  let cdktfJson;\n  try {\n    cdktfJson = JSON.parse(fs.readFileSync(cdktfJsonPath, \"utf-8\"));\n  } catch (err: any) {\n    throw Errors.Internal(\n      `Could not find cdktf.json file in ${projectPath}`,\n      err,\n    );\n  }\n\n  if (cdktfJson.watchPattern) {\n    logger.debug(`Found watchPattern in cdktf.json: ${cdktfJson.watchPattern}`);\n    return cdktfJson.watchPattern;\n  }\n  const language:\n    | \"typescript\"\n    | \"python\"\n    | \"java\"\n    | \"csharp\"\n    | \"go\"\n    | undefined = cdktfJson.language;\n\n  if (!language) {\n    throw Errors.Usage(\n      `No language specified in cdktf.json, please either specify a language or watchPattern to use the watch command`,\n    );\n  }\n\n  const defaultWatchPattern = {\n    typescript: [\"./**/*.ts\"],\n    python: [\"./**/*.py\"],\n    java: [\"src/**/*.java\"],\n    csharp: [\"./**/*.cs\"],\n    go: [\"./**/*.go\"],\n  }[language];\n\n  fs.writeFileSync(\n    cdktfJsonPath,\n    JSON.stringify(\n      { ...cdktfJson, watchPattern: defaultWatchPattern },\n      null,\n      2,\n    ),\n  );\n  logger.debug(`Write default watchPattern for ${language} in cdktf.json.`);\n\n  return defaultWatchPattern;\n}\n\nconst projectStatus = (project?: CdktfProject) => {\n  if (!project?.stacksToRun.length) {\n    return {\n      inProgress: [],\n      finished: [],\n      pending: [],\n    };\n  }\n\n  const inProgress = project.stacksToRun.filter((s) => s.isRunning);\n  const finished = project.stacksToRun.filter((s) => s.isDone);\n  const pending = project.stacksToRun.filter((s) => s.isPending);\n  return { inProgress, finished, pending };\n};\n\nexport type State =\n  | {\n      type: \"waiting\";\n    }\n  | {\n      type: \"running\";\n      nextRunQueued: boolean;\n      currentRun: Promise<void>;\n      inProgress: CdktfStack[];\n      finished: CdktfStack[];\n      pending: CdktfStack[];\n    }\n  | { type: \"stopped\" };\n\nexport async function watch(\n  projectOptions: CdktfProjectOptions,\n  mutationOptions: MutationOptions,\n  abortSignal: AbortSignal,\n  onStateChange: (newState: State) => void,\n) {\n  const patterns = getOrWriteDefaultWatchConfig();\n  const watcher = chokidar.watch(patterns, {\n    ignoreInitial: true,\n  });\n  let state: State = { type: \"waiting\" };\n  const changeState = (newState: State) => {\n    state = newState;\n    onStateChange(state);\n  };\n\n  async function run() {\n    logger.debug(\"Running cdktn deploy\");\n    const project = new CdktfProject({\n      synthOrigin: \"watch\",\n      ...projectOptions,\n      onLog: (log) => {\n        if (projectOptions.onLog) {\n          projectOptions.onLog(log);\n        }\n        if (state.type === \"running\") {\n          changeState({ ...state, ...projectStatus(project) });\n        }\n      },\n    });\n    const abort = () => project.hardAbort();\n    abortSignal.addEventListener(\"abort\", abort);\n    await project.deploy(mutationOptions);\n    abortSignal.removeEventListener(\"abort\", abort);\n    logger.debug(\"cdktn deploy finished\");\n\n    if (state.type !== \"running\") {\n      throw Errors.Internal(\n        \"Watch was in a state where the state was not running in the run phase\",\n      );\n    }\n\n    if (state.nextRunQueued) {\n      logger.debug(\"Next run was queued, starting it now\");\n      changeState({\n        ...state,\n        nextRunQueued: false,\n        currentRun: run(),\n        ...projectStatus(project),\n      });\n    } else {\n      logger.debug(\"Nothing queued, waiting for changes\");\n      changeState({ type: \"waiting\" });\n    }\n  }\n\n  abortSignal.addEventListener(\"abort\", () => {\n    logger.debug(\"Abort signal received, stopping watch\");\n    watcher.close();\n    changeState({ type: \"stopped\" });\n  });\n\n  const onFileChange = () => {\n    if (state.type === \"stopped\") {\n      return;\n    }\n\n    if (state.type === \"running\") {\n      changeState({ ...state, nextRunQueued: true });\n      return;\n    }\n\n    changeState({\n      type: \"running\",\n      nextRunQueued: false,\n      currentRun: run(),\n      ...projectStatus(),\n    });\n  };\n\n  watcher.on(\"all\", onFileChange);\n  // initially run once\n  onFileChange();\n\n  await sendTelemetry(\"watch\", { event: \"start\" });\n}\n"]}

package/eslint.config.mjs

@@ -3,84 +3,16 @@
  * 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,
-});
+import rootConfig from "../../../eslint.config.mjs";
 
 export default [
   {
     ignores: [
-      "**/node_modules",
-      "**/dist",
-      "**/coverage",
-      "**/*.d.ts",
-      "**/*.js",
-      "**/*.mjs",
       // prettier v2 managed inline snapshots
       "src/test/lib/cdktf-project.test.ts",
       "src/test/lib/terraform-logs.test.ts",
       "src/test/lib/execution-logs.test.ts",
     ],
   },
-  ...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,
-      parserOptions: {
-        tsconfigRootDir: import.meta.dirname,
-      },
-    },
-
-    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,
-      "@typescript-eslint/no-require-imports": "warn",
-      "@typescript-eslint/no-unused-vars": "warn",
-      "react/no-unescaped-entities": 0,
-      "no-sequences": "error",
-      "no-unused-vars": "warn",
-
-      "no-irregular-whitespace": [
-        "error",
-        {
-          skipTemplates: true,
-        },
-      ],
-    },
-  },
-  prettierConfig,
+  ...rootConfig,
 ];

package/package.json

@@ -1,25 +1,23 @@
 {
   "name": "@cdktn/cli-core",
-  "version": "0.23.0-pre.8",
+  "version": "0.23.1",
   "description": "CDK Terrain CLI Core, meant for internal use only",
   "scripts": {
     "build": "tsc",
     "watch": "tsc -w",
     "watch-preserve-output": "tsc -w --preserveWatchOutput",
-    "lint": "eslint .",
-    "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 --maxWorkers=50%",
     "jest-watch": "jest --watch",
     "package": "./package.sh",
     "dist-clean": "rm -rf dist",
     "package:js": "./package.sh"
   },
-  "main": "src/lib/index.js",
-  "types": "src/lib/index.d.ts",
+  "main": "build/lib/index.js",
+  "types": "build/lib/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
@@ -40,101 +38,47 @@
   ],
   "license": "MPL-2.0",
   "dependencies": {
-    "@cdktf/node-pty-prebuilt-multiarch": "^0.10.2",
-    "@cdktn/commons": "0.23.0-pre.8",
-    "@cdktn/hcl-tools": "0.23.0-pre.8",
-    "@cdktn/hcl2cdk": "0.23.0-pre.8",
-    "@cdktn/hcl2json": "0.23.0-pre.8",
-    "@cdktn/provider-schema": "0.23.0-pre.8",
+    "@cdktn/commons": "0.23.1",
+    "@cdktn/hcl-tools": "0.23.1",
+    "@cdktn/hcl2cdk": "0.23.1",
+    "@cdktn/provider-schema": "0.23.1",
     "@sentry/node": "7.120.4",
-    "archiver": "7.0.1",
-    "cdktn": "0.23.0-pre.8",
+    "cdktn": "0.23.1",
     "chalk": "4.1.2",
     "chokidar": "3.6.0",
-    "cli-spinners": "2.9.2",
-    "codemaker": "1.112.0",
-    "constructs": "10.4.2",
-    "cross-fetch": "3.2.0",
+    "ci-info": "3.9.0",
+    "codemaker": "1.128.0",
+    "constructs": "10.6.0",
     "cross-spawn": "7.0.6",
-    "detect-port": "1.6.1",
-    "execa": "5.1.1",
-    "extract-zip": "2.0.1",
-    "follow-redirects": "1.15.11",
     "fs-extra": "8.1.0",
     "https-proxy-agent": "5.0.1",
     "indent-string": "4.0.0",
-    "ink": "3.2.0",
-    "ink-select-input": "4.2.2",
-    "ink-spinner": "4.0.3",
-    "ink-testing-library": "2.1.0",
-    "ink-use-stdout-dimensions": "1.0.5",
-    "jsii": "^5.8.9",
-    "jsii-pacmak": "^1.112.0",
-    "jsii-rosetta": "^5.8.8",
-    "lodash.isequal": "4.5.0",
-    "log4js": "6.9.1",
     "minimatch": "5.1.9",
     "node-fetch": "2.7.0",
-    "open": "7.4.2",
-    "parse-gitignore": "1.0.1",
     "pkg-up": "3.1.0",
     "semver": "7.7.4",
     "sscaff": "1.2.274",
-    "stream-buffers": "3.0.3",
     "strip-ansi": "6.0.1",
-    "tunnel-agent": "0.6.0",
-    "uuid": "8.3.2",
     "xml-js": "1.6.11",
     "xstate": "4.38.3",
-    "yargs": "17.7.2",
-    "yoga-layout-prebuilt": "1.10.0",
     "zod": "3.25.76"
   },
   "lint-staged": {
     "src/**/*.{ts,tsx}": "tsc-files ambient.d.ts --noEmit"
   },
   "devDependencies": {
-    "@cdktn/provider-generator": "0.23.0-pre.8",
-    "@eslint/compat": "^1.4.1",
-    "@eslint/eslintrc": "^3.3.5",
-    "@eslint/js": "^9.39.4",
-    "@npmcli/ci-detect": "1.4.0",
-    "@skorfmann/ink-confirm-input": "3.0.0",
-    "@skorfmann/terraform-cloud": "1.15.0",
-    "@types/archiver": "5.3.4",
+    "@cdktn/provider-generator": "0.23.1",
     "@types/cross-spawn": "6.0.6",
-    "@types/detect-port": "1.3.5",
-    "@types/follow-redirects": "1.14.4",
     "@types/fs-extra": "8.1.5",
-    "@types/ink": "2.0.3",
-    "@types/ink-spinner": "3.0.5",
-    "@types/jest": "29.5.14",
-    "@types/json-schema": "7.0.15",
-    "@types/lodash.isequal": "4.5.8",
-    "@types/nock": "11.1.0",
+    "@types/jest": "30.0.0",
     "@types/node": "20.19.1",
     "@types/node-fetch": "2.6.13",
-    "@types/parse-gitignore": "1.0.2",
-    "@types/react": "18.3.28",
-    "@types/scheduler": "^0.26.0",
     "@types/semver": "7.7.1",
-    "@types/stream-buffers": "3.0.8",
-    "@types/uuid": "8.3.4",
-    "esbuild": "^0.27.4",
-    "esbuild-jest": "0.5.0",
-    "eslint": "^9.39.4",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.5",
-    "eslint-plugin-react": "7.37.5",
-    "eslint-plugin-react-hooks": "^5.2.0",
-    "jest": "^29.7.0",
+    "jest": "^30.3.0",
     "nock": "13.5.6",
     "prettier": "2.8.8",
-    "react": "18.3.1",
-    "ts-jest": "29.4.6",
+    "ts-jest": "29.4.9",
     "tsc-files": "1.1.4",
-    "typescript": "5.4.5",
-    "typescript-eslint": "^8.57.0",
-    "utility-types": "3.11.0"
+    "typescript": "5.4.5"
   }
 }