@cdktn/cli-core 0.21.0

package/src/lib/terraform-json.d.ts.map

@@ -0,0 +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"}

package/src/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/src/lib/terraform-provider-lock.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { ProviderConstraint } from "./dependencies/dependency-manager";
+type TerraformProviderLockFileEntry = {
+    name: string;
+    version?: string;
+    constraints?: ProviderConstraint;
+};
+export declare class TerraformProviderLock {
+    private stackWorkingDirectory;
+    private _providerLockData;
+    constructor(stackWorkingDirectory: string);
+    private get lockFilePath();
+    hasProviderLockFile(): Promise<boolean>;
+    private readProviderLockFile;
+    private parseProviderLockFile;
+    providers(forceReread?: boolean): Promise<{
+        [name: string]: TerraformProviderLockFileEntry;
+    }>;
+    hasMatchingProvider(constraint: ProviderConstraint): Promise<boolean | undefined>;
+}
+export {};
+//# sourceMappingURL=terraform-provider-lock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"terraform-provider-lock.d.ts","sourceRoot":"","sources":["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/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/lib/watch.d.ts

@@ -0,0 +1,16 @@
+import { CdktfProjectOptions, MutationOptions } from "./cdktf-project";
+import { CdktfStack } from "./cdktf-stack";
+export type State = {
+    type: "waiting";
+} | {
+    type: "running";
+    nextRunQueued: boolean;
+    currentRun: Promise<void>;
+    inProgress: CdktfStack[];
+    finished: CdktfStack[];
+    pending: CdktfStack[];
+} | {
+    type: "stopped";
+};
+export declare function watch(projectOptions: CdktfProjectOptions, mutationOptions: MutationOptions, abortSignal: AbortSignal, onStateChange: (newState: State) => void): Promise<void>;
+//# sourceMappingURL=watch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["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/src/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":["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/templates/csharp/.hooks.sscaff.js

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+const { execSync } = require('child_process');
+const { readFileSync, writeFileSync } = require('fs');
+const os = require('os');
+const path = require('path');
+
+exports.pre = (variables) => {
+  try {
+    if (os.platform() === 'win32') {
+      execSync('where dotnet')
+    }
+    else {
+      execSync('which dotnet')
+    }
+  } catch {
+    console.error(`Unable to find "dotnet" installation. Install from https://dotnet.microsoft.com/download`);
+    process.exit(1);
+  }
+};
+
+exports.post = options => {
+  const { nuget_cdktf, cdktf_version } = options;
+  if (!nuget_cdktf) {
+    throw new Error(`missing context "nuget_cdktf"`);
+  }
+
+  // Terraform Cloud configuration settings if the organization name and workspace is set.
+  if (options.OrganizationName != '') {
+    console.log(`\nGenerating Terraform Cloud configuration for '${options.OrganizationName}' organization and '${options.WorkspaceName}' workspace.....`)
+    terraformCloudConfig(options.$base, options.OrganizationName, options.WorkspaceName, options.TerraformRemoteHostname)
+  }
+
+  // dist package
+  if (nuget_cdktf.endsWith('.nupkg')) {
+    srcFolder = path.dirname(nuget_cdktf);
+
+    writeFileSync('./NuGet.Config', `<?xml version="1.0" encoding="utf-8"?>
+    <configuration>
+      <packageSources>
+        <add key="Locally Distributed Packages" value="${srcFolder}" />
+        <add key="NuGet official package source" value="https://api.nuget.org/v3/index.json" />
+      </packageSources>
+    </configuration>`, 'utf-8');
+  }
+  execSync(`dotnet add package Microsoft.NET.Test.Sdk --version 17.2.0`, { stdio: 'inherit' });
+  execSync(`dotnet add package xunit --version 2.4.1`, { stdio: 'inherit' });
+  execSync(`dotnet add package xunit.runner.visualstudio --version 2.4.5`, { stdio: 'inherit' });
+  execSync(`dotnet restore`, { stdio: 'inherit' });
+  console.log(readFileSync('./help', 'utf-8'));
+};
+
+function terraformCloudConfig(baseName, organizationName, workspaceName, terraformRemoteHostname) {
+  template = readFileSync('./Program.cs', 'utf-8');
+
+  result = template.replace(`new MainStack(app, "${baseName}");`, `MainStack stack = new MainStack(app, "${baseName}");
+            new CloudBackend(stack, new CloudBackendConfig { Hostname = "${terraformRemoteHostname}", Organization = "${organizationName}", Workspaces = new NamedCloudWorkspace("${workspaceName}") });`);
+
+  writeFileSync('./Program.cs', result, 'utf-8');
+}

package/templates/csharp/MainStack.cs

@@ -0,0 +1,15 @@
+using System;
+using Constructs;
+using Io.Cdktn;
+
+
+namespace MyCompany.MyApp
+{
+    class MainStack : TerraformStack
+    {
+        public MainStack(Construct scope, string id) : base(scope, id)
+        {
+            // define resources here
+        }
+    }
+}

package/templates/csharp/MyTerraformStack.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <GenerateProgramFile>false</GenerateProgramFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Io.Cdktn" Version="{{ cdktf_version }}" />
+  </ItemGroup>
+
+</Project>

package/templates/csharp/Program.cs

@@ -0,0 +1,17 @@
+using System;
+using Constructs;
+using Io.Cdktn;
+
+namespace MyCompany.MyApp
+{
+    class Program
+    {
+        public static void Main(string[] args)
+        {
+            App app = new App();
+            new MainStack(app, "{{ $base }}");
+            app.Synth();
+            Console.WriteLine("App synth complete");
+        }
+    }
+}

package/templates/csharp/TestProgram.cs

@@ -0,0 +1,42 @@
+using Xunit;
+using Io.Cdktn;
+using System;
+using System.Collections.Generic;
+
+namespace MyCompany.MyApp{
+    // The tests below are example tests, you can find more information at
+    // https://cdk.tf/testing
+    public class TestProgram{
+        
+        [Fact]
+        public void myAppTest(){
+            Assert.True(true);
+        }
+
+        //[Fact]
+        //public void CheckValidity(){
+        //    TerraformStack stack = new TerraformStack(Testing.App(), "stack");
+        //    MyApplicationsAbstraction appAbstraction = new MyApplicationsAbstraction(stack, "construct");
+        //    Assert.True(Testing.ToBeValidTerraform(Testing.FullSynth(stack)) );
+        //}
+
+        //[Fact]
+        //public void shouldContainContainer(){
+        //    TerraformStack stack = new TerraformStack(Testing.App(), "stack");
+        //    MyApplicationsAbstraction appAbstraction = new MyApplicationsAbstraction(stack, "construct");
+        //    string synthesized = Testing.Synth(stack);
+        //    Assert.True(Testing.ToHaveResource(synthesized, Container.TfResourceType) );
+        //}
+
+        //[Fact]
+        //public void shouldUseUbuntuImage(){
+        //    TerraformStack stack = new TerraformStack(Testing.App(), "stack");
+        //    MyApplicationsAbstraction appAbstraction = new MyApplicationsAbstraction(stack, "construct");
+        //    string synthesized = Testing.Synth(stack);
+        //    Assert.True(Testing.ToHaveResourceWithProperties(synthesized, Image.TfResourceType, new Dictionary<String, Object>() {
+        //       {"name", "ubuntu:latest"}
+        //    }) );
+        //}
+    }
+
+}

package/templates/csharp/cdktf.json

@@ -0,0 +1,11 @@
+{
+  "language": "csharp",
+  "app": "dotnet run -p MyTerraformStack.csproj",
+  "projectId": "{{projectId}}",
+  "sendCrashReports": "{{sendCrashReports}}",
+  "terraformProviders": [],
+  "terraformModules": [],
+  "context": {
+{{futureFlags}}
+  }
+}

package/templates/csharp/help

@@ -0,0 +1,42 @@
+========================================================================================================
+
+  Your cdktn csharp project is ready!
+
+  cat help                Prints this message
+
+  Compile:
+    dotnet build          Builds your dotnet packages
+
+  Synthesize:
+    cdktn synth [stack]   Synthesize Terraform resources to cdktf.out/
+
+  Diff:
+    cdktn diff [stack]    Perform a diff (terraform plan) for the given stack
+
+  Deploy:
+    cdktn deploy [stack]  Deploy the given stack
+
+  Destroy:
+    cdktn destroy [stack] Destroy the given stack
+
+  Learn more about using modules and providers https://cdk.tf/modules-and-providers
+
+Use Providers:
+
+  Use the add command to add both prebuilt providers (if available) or locally generated providers:
+  
+  cdktn provider add "aws@~>3.0" null kreuzwerker/docker
+
+  You can find all prebuilt providers on nuget: https://www.nuget.org/packages?q=HashiCorp.Cdktf.Providers
+  You can also install these providers directly through dotnet:
+
+  dotnet add package HashiCorp.Cdktf.Providers.Aws
+  dotnet add package HashiCorp.Cdktf.Providers.Google
+  dotnet add package HashiCorp.Cdktf.Providers.Azurerm
+  dotnet add package HashiCorp.Cdktf.Providers.Docker
+  dotnet add package HashiCorp.Cdktf.Providers.Github
+  dotnet add package HashiCorp.Cdktf.Providers.Null
+
+  You can also build any module or provider locally. Learn more: https://cdk.tf/modules-and-providers
+
+========================================================================================================