@cdktn/cli-core 0.23.0-pre.4 → 0.23.0-pre.41

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/build/lib/terraform-provider-lock.js

@@ -0,0 +1,95 @@
+"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.TerraformProviderLock = void 0;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const dependency_manager_1 = require("./dependencies/dependency-manager");
+const commons_1 = require("@cdktn/commons");
+const TerraformLockFileName = ".terraform.lock.hcl";
+class TerraformProviderLock {
+    constructor(stackWorkingDirectory) {
+        this.stackWorkingDirectory = stackWorkingDirectory;
+        this._providerLockData = null;
+    }
+    get lockFilePath() {
+        return path_1.default.join(this.stackWorkingDirectory, TerraformLockFileName);
+    }
+    async hasProviderLockFile() {
+        try {
+            await promises_1.default.stat(this.lockFilePath);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async readProviderLockFile() {
+        try {
+            const lockFile = (await promises_1.default.readFile(this.lockFilePath)).toString();
+            return lockFile;
+        }
+        catch (e) {
+            commons_1.logger.debug("Unable to read provider lock file", e);
+        }
+        return "";
+    }
+    parseProviderLockFile(contents) {
+        const providerLockData = {
+            providers: {},
+        };
+        let currentProvider;
+        contents.split(/\r\n|\r|\n/).forEach((line) => {
+            if (currentProvider) {
+                const constraintMatch = line.match(/^\s*constraints\s+=\s+"(.*)"/);
+                if (constraintMatch) {
+                    providerLockData.providers[currentProvider].constraints =
+                        new dependency_manager_1.ProviderConstraint(currentProvider, constraintMatch[1]);
+                    return;
+                }
+                const versionMatch = line.match(/^\s*version\s+=\s+"(.*)"/);
+                if (versionMatch) {
+                    providerLockData.providers[currentProvider].version = versionMatch[1];
+                    return;
+                }
+                const endMatch = line.match(/^\s*}/);
+                if (endMatch) {
+                    currentProvider = undefined;
+                }
+                return;
+            }
+            const providerMatch = line.match(/provider "(.*)"/);
+            if (providerMatch) {
+                currentProvider = providerMatch[1];
+                providerLockData.providers[currentProvider] = {
+                    name: new dependency_manager_1.ProviderConstraint(currentProvider, ">=0").simplifiedName,
+                };
+            }
+        });
+        return providerLockData;
+    }
+    async providers(forceReread = false) {
+        if (!this._providerLockData || forceReread) {
+            const contents = await this.readProviderLockFile();
+            this._providerLockData = this.parseProviderLockFile(contents);
+        }
+        return this._providerLockData.providers;
+    }
+    async hasMatchingProvider(constraint) {
+        var _a, _b;
+        const providerLockData = await this.providers();
+        const lockedProvider = providerLockData[constraint.source];
+        if (lockedProvider) {
+            return (_a = lockedProvider.constraints) === null || _a === void 0 ? void 0 : _a.matchesVersion((_b = constraint.version) !== null && _b !== void 0 ? _b : ">0");
+        }
+        return false;
+    }
+}
+exports.TerraformProviderLock = TerraformProviderLock;
+//# 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 = require(cdktfJsonPath);
+    }
+    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":"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","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 = require(cdktfJsonPath);\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,80 +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",
       // 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,
-    },
-
-    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,
 ];