@codedrifters/configulator 0.0.85 → 0.0.87

package/lib/index.mjs

@@ -0,0 +1,1497 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../utils/lib/aws/aws-types.js
+var require_aws_types = __commonJS({
+  "../utils/lib/aws/aws-types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AWS_ENVIRONMENT_TYPE = exports.DEPLOYMENT_TARGET_ROLE = exports.AWS_STAGE_TYPE = void 0;
+    exports.AWS_STAGE_TYPE = {
+      /**
+       * Development environment, typically used for testing and development.
+       */
+      DEV: "dev",
+      /**
+       * Staging environment, used for pre-production testing.
+       */
+      STAGE: "stage",
+      /**
+       * Production environment, used for live deployments.
+       */
+      PROD: "prod"
+    };
+    exports.DEPLOYMENT_TARGET_ROLE = {
+      /**
+       * Account and region that represents the primary region for this service.
+       * For example, the base DynamoDB Region for global tables.
+       */
+      PRIMARY: "primary",
+      /**
+       * Account and region that represents a secondary region for this service.
+       * For example, a replica region for a global DynamoDB table.
+       */
+      SECONDARY: "secondary"
+    };
+    exports.AWS_ENVIRONMENT_TYPE = exports.DEPLOYMENT_TARGET_ROLE;
+  }
+});
+
+// ../utils/lib/git/git-utils.js
+var require_git_utils = __commonJS({
+  "../utils/lib/git/git-utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.findGitRepoName = exports.findGitBranch = void 0;
+    var node_child_process_1 = __require("child_process");
+    var findGitBranch = () => {
+      return (0, node_child_process_1.execSync)("git rev-parse --abbrev-ref HEAD").toString("utf8").replace(/[\n\r\s]+$/, "");
+    };
+    exports.findGitBranch = findGitBranch;
+    var findGitRepoName = () => {
+      if (process.env.GITHUB_REPOSITORY) {
+        return process.env.GITHUB_REPOSITORY;
+      }
+      const remote = (0, node_child_process_1.execSync)("git config --get remote.origin.url").toString("utf8").replace(/[\n\r\s]+$/, "").trim();
+      const match = remote.match(/[:\/]([^/]+\/[^/]+?)(?:\.git)?$/);
+      const repoName = match ? match[1] : "error-repo-name";
+      return repoName;
+    };
+    exports.findGitRepoName = findGitRepoName;
+  }
+});
+
+// ../utils/lib/string/string-utils.js
+var require_string_utils = __commonJS({
+  "../utils/lib/string/string-utils.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) 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 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.trimStringLength = exports.hashString = void 0;
+    var crypto = __importStar(__require("crypto"));
+    var hashString = (inString, trimLength = 999) => {
+      return crypto.createHash("sha256").update(inString).digest("hex").substring(0, trimLength);
+    };
+    exports.hashString = hashString;
+    var trimStringLength = (inputString, maxLength) => {
+      return inputString.length < maxLength ? inputString : inputString.substring(0, maxLength);
+    };
+    exports.trimStringLength = trimStringLength;
+  }
+});
+
+// ../utils/lib/index.js
+var require_lib = __commonJS({
+  "../utils/lib/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) 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 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_aws_types(), exports);
+    __exportStar(require_git_utils(), exports);
+    __exportStar(require_string_utils(), exports);
+  }
+});
+
+// src/aws/aws-deployment-config.ts
+var import_utils = __toESM(require_lib());
+import { join, relative } from "path";
+import { Component as Component3 } from "projen";
+
+// src/turbo/turbo-repo-task.ts
+import { Component } from "projen/lib";
+var TurboRepoTask = class extends Component {
+  constructor(project, options) {
+    super(project);
+    this.project = project;
+    this.name = options.name;
+    this.dependsOn = options.dependsOn ?? [];
+    this.env = options.env ?? [];
+    this.passThroughEnv = options.passThroughEnv ?? [];
+    this.outputs = options.outputs ?? [];
+    this.cache = options.cache ?? true;
+    this.inputs = [
+      ...options.inputs ?? [],
+      // rerun if projen config changes
+      ".projen/**",
+      // ignore mac files
+      "!.DS_Store",
+      "!**/.DS_Store"
+    ];
+    this.outputLogs = options.outputLogs ?? "new-only";
+    this.persistent = options.persistent ?? false;
+    this.interactive = options.interactive ?? false;
+    this.isActive = true;
+  }
+  taskConfig() {
+    return {
+      dependsOn: this.dependsOn,
+      env: this.env,
+      passThroughEnv: this.passThroughEnv,
+      outputs: this.outputs,
+      cache: this.cache,
+      inputs: this.inputs,
+      outputLogs: this.outputLogs,
+      persistent: this.persistent,
+      interactive: this.interactive
+    };
+  }
+};
+
+// src/turbo/turbo-repo.ts
+import { Component as Component2, FileBase, JsonFile } from "projen/lib";
+import { JobPermission } from "projen/lib/github/workflows-model";
+var ROOT_TURBO_TASK_NAME = "turbo:build";
+var ROOT_CI_TASK_NAME = "build:all";
+var _TurboRepo = class _TurboRepo extends Component2 {
+  constructor(project, options = {}) {
+    super(project);
+    this.project = project;
+    /**
+     * Sub-Tasks to run
+     */
+    this.tasks = [];
+    this.turboVersion = options.turboVersion ?? "catalog:";
+    this.isRootProject = project === project.root;
+    if (this.isRootProject) {
+      project.addDevDeps(`turbo@${this.turboVersion}`);
+    }
+    project.gitignore.addPatterns("/.turbo");
+    project.npmignore?.addPatterns("/.turbo/");
+    this.extends = options.extends ?? (this.isRootProject ? [] : ["//"]);
+    this.globalDependencies = options.globalDependencies ?? [];
+    this.globalEnv = options.globalEnv ?? [];
+    this.globalPassThroughEnv = options.globalPassThroughEnv ?? [];
+    this.ui = options.ui ?? "stream";
+    this.dangerouslyDisablePackageManagerCheck = options.dangerouslyDisablePackageManagerCheck ?? false;
+    this.cacheDir = options.cacheDir ?? ".turbo/cache";
+    this.daemon = options.daemon ?? true;
+    this.envMode = options.envMode ?? "strict";
+    this.remoteCacheOptions = options.remoteCacheOptions;
+    this.buildAllTaskEnvVars = options.buildAllTaskEnvVars ?? {};
+    this.buildTask = new TurboRepoTask(this.project, {
+      name: ROOT_TURBO_TASK_NAME,
+      dependsOn: this.isRootProject ? [`^${ROOT_TURBO_TASK_NAME}`] : []
+    });
+    if (this.isRootProject) {
+      this.buildAllTask = this.project.tasks.addTask(ROOT_CI_TASK_NAME, {
+        description: "Root build followed by sub-project builds. Mimics the CI build process in one step."
+      });
+      this.buildAllTask.exec("turbo telemetry disable");
+      if (this.buildAllTaskEnvVars) {
+        Object.entries(this.buildAllTaskEnvVars).forEach(([name, value]) => {
+          this.addGlobalEnvVar(name, value);
+        });
+      }
+      if (!this.remoteCacheOptions) {
+        this.buildAllTask.exec(
+          `turbo ${ROOT_TURBO_TASK_NAME} --summarize --concurrency=10`
+        );
+      } else {
+        this.buildAllTask.exec(
+          `turbo turbo:build --summarize --concurrency=10 --cache=remote:rw --api=$TURBO_ENDPOINT --token=$TURBO_TOKEN --team=${this.remoteCacheOptions.teamName}`,
+          {
+            condition: '[ ! -n "$CI" ]',
+            env: {
+              TURBO_ENDPOINT: `$(aws ssm get-parameter --name ${this.remoteCacheOptions.endpointParamName} --query Parameter.Value --output text --profile ${this.remoteCacheOptions.profileName})`,
+              TURBO_TOKEN: `$(aws ssm get-parameter --name ${this.remoteCacheOptions.tokenParamName} --query Parameter.Value --output text --profile ${this.remoteCacheOptions.profileName})`
+            }
+          }
+        );
+        this.buildAllTask.exec(
+          `turbo turbo:build --summarize --concurrency=10 --cache=remote:rw --api=$TURBO_ENDPOINT --token=$TURBO_TOKEN --team=${this.remoteCacheOptions.teamName}`,
+          {
+            condition: '[ -n "$CI" ]',
+            env: {
+              TURBO_ENDPOINT: `$(aws ssm get-parameter --name ${this.remoteCacheOptions.endpointParamName} --query Parameter.Value --output text)`,
+              TURBO_TOKEN: `$(aws ssm get-parameter --name ${this.remoteCacheOptions.tokenParamName} --query Parameter.Value --output text)`
+            }
+          }
+        );
+      }
+    }
+    if (!this.isRootProject) {
+      const generatedFiles = this.project.components.filter((c) => c instanceof FileBase).map((c) => c.path);
+      this.preCompileTask = new TurboRepoTask(project, {
+        name: options.preCompileTask?.name ?? "pre-compile",
+        inputs: ["src/**", ...generatedFiles]
+      });
+      this.compileTask = new TurboRepoTask(project, {
+        name: options.compileTask?.name ?? "compile",
+        inputs: ["src/**", ...generatedFiles]
+      });
+      this.postCompileTask = new TurboRepoTask(project, {
+        name: options.postCompileTask?.name ?? "post-compile",
+        inputs: ["src/**", ...generatedFiles]
+      });
+      this.testTask = new TurboRepoTask(project, {
+        name: options.testTask?.name ?? "test"
+      });
+      this.packageTask = new TurboRepoTask(project, {
+        name: options.packageTask?.name ?? "package",
+        inputs: [".npmignore"]
+      });
+      this.tasks.push(
+        this.preCompileTask,
+        this.compileTask,
+        this.postCompileTask,
+        this.testTask,
+        this.packageTask
+      );
+    }
+  }
+  /**
+   * Static method to discovert turbo in a project.
+   */
+  static of(project) {
+    const isDefined = (c) => c instanceof _TurboRepo;
+    return project.components.find(isDefined);
+  }
+  /**
+   * Add an env var to the global env vars for all tasks.
+   * This will also become an input for the build:all task cache at the root.
+   */
+  addGlobalEnvVar(name, value) {
+    this.buildAllTask?.env(name, value);
+    if (this.isRootProject) {
+      this.globalEnv.push(name);
+    }
+  }
+  activateBranchNameEnvVar() {
+    this.addGlobalEnvVar("BRANCH_NAME", "$(git rev-parse --abbrev-ref HEAD)");
+  }
+  preSynthesize() {
+    let nextDependsOn = this.project.deps.all.filter((d) => d.version === "workspace:*").map((d) => [d.name, ROOT_TURBO_TASK_NAME].join("#"));
+    if (!this.isRootProject) {
+      [
+        [this.project.preCompileTask, this.preCompileTask],
+        [this.project.compileTask, this.compileTask],
+        [this.project.postCompileTask, this.postCompileTask],
+        [this.project.testTask, this.testTask],
+        [this.project.packageTask, this.packageTask]
+      ].forEach(([pjTask, turboTask]) => {
+        if (pjTask && turboTask && pjTask.steps.length > 0) {
+          if (nextDependsOn.length > 0) {
+            turboTask.dependsOn.push(...nextDependsOn);
+          }
+          nextDependsOn = [turboTask.name];
+        } else {
+          turboTask.isActive = false;
+        }
+      });
+      this.buildTask.dependsOn.push(...nextDependsOn);
+    }
+    const fileName = "turbo.json";
+    this.project.addPackageIgnore(fileName);
+    new JsonFile(this.project, fileName, {
+      obj: {
+        extends: this.extends.length ? this.extends : void 0,
+        globalDependencies: this.isRootProject && this.globalDependencies.length ? this.globalDependencies : void 0,
+        globalEnv: this.isRootProject && this.globalEnv.length ? this.globalEnv : void 0,
+        globalPassThroughEnv: this.isRootProject && this.globalPassThroughEnv.length ? this.globalPassThroughEnv : void 0,
+        ui: this.isRootProject ? this.ui : void 0,
+        dangerouslyDisablePackageManagerCheck: this.isRootProject ? this.dangerouslyDisablePackageManagerCheck : void 0,
+        cacheDir: this.isRootProject ? this.cacheDir : void 0,
+        daemon: this.isRootProject ? this.daemon : void 0,
+        envMode: this.isRootProject ? this.envMode : void 0,
+        /**
+         * All tasks
+         */
+        tasks: this.tasks.filter((task) => task.isActive).reduce(
+          (acc, task) => {
+            acc[task.name] = {
+              ...task.taskConfig()
+            };
+            return acc;
+          },
+          {
+            [this.buildTask.name]: { ...this.buildTask.taskConfig() }
+          }
+        )
+      }
+    });
+    super.preSynthesize();
+  }
+};
+_TurboRepo.buildWorkflowOptions = (remoteCacheOptions) => {
+  return {
+    permissions: {
+      contents: JobPermission.WRITE,
+      idToken: JobPermission.WRITE
+    },
+    preBuildSteps: [
+      {
+        name: "AWS Creds for SSM",
+        uses: "aws-actions/configure-aws-credentials@v4",
+        with: {
+          ["role-to-assume"]: remoteCacheOptions.oidcRole,
+          ["aws-region"]: "us-east-1",
+          ["role-duration-seconds"]: "900"
+        }
+      }
+    ]
+  };
+};
+var TurboRepo = _TurboRepo;
+
+// src/aws/aws-deployment-config.ts
+var AwsDeploymentConfig = class _AwsDeploymentConfig extends Component3 {
+  constructor(project) {
+    super(project);
+    /**
+     * Array of targets for deployment.
+     */
+    this.awsDeploymentTargets = [];
+    /*****************************************************************************
+     *
+     * Synth Tasks
+     *
+     * - Configure synth task to use the branch name
+     * - Change the output location for easier workflows.
+     *
+     ****************************************************************************/
+    this.configureSynthTask = () => {
+      this.project.tasks.tryFind("synth")?.reset(`rm -rf ${this.cdkOut}`);
+      this.project.tasks.tryFind("synth")?.exec(`cdk synth --output ${this.cdkOut}`, { env: this.env });
+      this.project.tasks.tryFind("synth:silent")?.reset(`rm -rf ${this.cdkOut}`);
+      this.project.tasks.tryFind("synth:silent")?.exec(`cdk synth -q --output ${this.cdkOut}`, { env: this.env });
+    };
+    this.env = { GIT_BRANCH: "$(git branch --show-current)" };
+    this.projectPath = relative(project.root.outdir, project.outdir);
+    this.rootPath = relative(project.outdir, project.root.outdir);
+    this.rootCdkOut = join("dist", this.projectPath, "cdk.out");
+    this.cdkOut = join(this.rootPath, "dist", this.projectPath, "cdk.out");
+    ["deploy", "watch"].forEach((taskName) => {
+      const task = project.tasks.tryFind(taskName);
+      if (task) {
+        task.reset();
+        task.say(
+          "Generic task is disabled. Please use the specific task for your deployment target."
+        );
+      }
+    });
+    this.configureSynthTask();
+  }
+  static of(project) {
+    const isDefined = (c) => c instanceof _AwsDeploymentConfig;
+    return project.components.find(isDefined);
+  }
+  /*****************************************************************************
+   *
+   * Target filter helpers
+   *
+   * Return various targets for deployment scripts to use.
+   *
+   ****************************************************************************/
+  /**
+   * @returns All production deployment targets.
+   */
+  get prodTargets() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.PROD
+    );
+  }
+  get prodTargetsForCI() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.PROD && target.ciDeployment
+    );
+  }
+  get prodTargetsForLocal() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.PROD && target.localDeployment
+    );
+  }
+  /**
+   *
+   * @returns All stage deployment targets.
+   */
+  get stageTargets() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.STAGE
+    );
+  }
+  get stageTargetsForCI() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.STAGE && target.ciDeployment
+    );
+  }
+  get stageTargetsForLocal() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.STAGE && target.localDeployment
+    );
+  }
+  /**
+   *
+   * @returns All dev deployment targets.
+   */
+  get devTargets() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.DEV
+    );
+  }
+  get devTargetsForCI() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.DEV && target.ciDeployment
+    );
+  }
+  get devTargetsForLocal() {
+    return this.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === import_utils.AWS_STAGE_TYPE.DEV && target.localDeployment
+    );
+  }
+  preSynthesize() {
+    super.preSynthesize();
+    if (TurboRepo.of(this.project)) {
+      const turbo = TurboRepo.of(this.project);
+      turbo.postCompileTask?.outputs.push(join(this.cdkOut, "**"));
+    }
+  }
+};
+
+// src/jsii/jsii-faker.ts
+import * as spec from "@jsii/spec";
+import { Component as Component4, JsonFile as JsonFile2 } from "projen";
+var ProjenBaseFqn = {
+  TYPESCRIPT_PROJECT: "projen.typescript.TypeScriptProject",
+  TYPESCRIPT_PROJECT_OPTIONS: "projen.typescript.TypeScriptProjectOptions"
+};
+var JsiiFaker = class _JsiiFaker extends Component4 {
+  constructor(project) {
+    super(project);
+    this.project = project;
+    this._types = {};
+    this.toJSON = () => {
+      return {
+        types: this._types
+      };
+    };
+    this._assemblyName = this.project.package.packageName;
+    new JsonFile2(project, ".jsii", {
+      obj: () => {
+        return {
+          name: this._assemblyName,
+          types: this._types
+        };
+      }
+    });
+  }
+  // find project singleton
+  static of(project) {
+    const isDefined = (c) => c instanceof _JsiiFaker;
+    return project.components.find(isDefined);
+  }
+  addClassType(options) {
+    const fqn = [this._assemblyName, options.name].join(".");
+    const type = {
+      assembly: this._assemblyName,
+      base: options.baseFqn ?? ProjenBaseFqn.TYPESCRIPT_PROJECT,
+      fqn,
+      kind: spec.TypeKind.Class,
+      name: options.name,
+      initializer: {
+        parameters: [
+          {
+            name: "options",
+            type: {
+              fqn: options.optionsFqn ?? ProjenBaseFqn.TYPESCRIPT_PROJECT_OPTIONS
+            }
+          }
+        ]
+      }
+    };
+    this._types[fqn] = type;
+  }
+};
+
+// src/pnpm/pnpm-workspace.ts
+import { relative as relative2 } from "path";
+import { Component as Component5, YamlFile } from "projen";
+var MIMIMUM_RELEASE_AGE = {
+  ZERO_DAYS: 0,
+  ONE_HOUR: 60,
+  SIX_HOURS: 360,
+  TWELVE_HOURS: 720,
+  ONE_DAY: 1440,
+  TWO_DAYS: 2880,
+  THREE_DAYS: 4320,
+  FOUR_DAYS: 5760,
+  FIVE_DAYS: 7200,
+  SIX_DAYS: 8640,
+  ONE_WEEK: 10080
+};
+var PnpmWorkspace = class _PnpmWorkspace extends Component5 {
+  /**
+   * Get the pnpm workspace component of a project. If it does not exist,
+   * return undefined.
+   *
+   * @param project
+   * @returns
+   */
+  static of(project) {
+    const isDefined = (c) => c instanceof _PnpmWorkspace;
+    return project.root.components.find(isDefined);
+  }
+  constructor(project, options = {}) {
+    super(project);
+    project.tryFindObjectFile("package.json")?.addDeletionOverride("pnpm");
+    this.fileName = options.fileName ?? "pnpm-workspace.yaml";
+    this.minimumReleaseAge = options.minimumReleaseAge ? options.minimumReleaseAge : MIMIMUM_RELEASE_AGE.ONE_DAY;
+    this.minimumReleaseAgeExclude = options.minimumReleaseAgeExclude ? ["@codedrifters/*", ...options.minimumReleaseAgeExclude] : ["@codedrifters/*"];
+    this.onlyBuiltDependencies = options.onlyBuiltDependencies ? options.onlyBuiltDependencies : [];
+    this.ignoredBuiltDependencies = options.ignoredBuiltDependencies ? options.ignoredBuiltDependencies : [];
+    this.subprojects = options.subprojects ?? [];
+    this.defaultCatalog = options.defaultCatalog;
+    this.namedCatalogs = options.namedCatalogs;
+    project.addPackageIgnore(this.fileName);
+    new YamlFile(this.project, this.fileName, {
+      obj: () => {
+        const pnpmConfig = {};
+        const packages = new Array();
+        for (const subproject of project.subprojects) {
+          packages.push(relative2(this.project.outdir, subproject.outdir));
+        }
+        const packageSet = new Set(packages);
+        for (const subprojectPath of this.subprojects) {
+          packageSet.add(subprojectPath);
+        }
+        if (this.subprojects.length > 0) {
+          packages.length = 0;
+          packages.push(...packageSet);
+        }
+        pnpmConfig.minimumReleaseAge = this.minimumReleaseAge;
+        if (this.minimumReleaseAgeExclude.length > 0) {
+          pnpmConfig.minimumReleaseAgeExclude = this.minimumReleaseAgeExclude;
+        }
+        if (this.onlyBuiltDependencies.length > 0) {
+          pnpmConfig.onlyBuiltDependencies = this.onlyBuiltDependencies;
+        }
+        if (this.ignoredBuiltDependencies.length > 0) {
+          pnpmConfig.ignoreBuiltDependencies = this.ignoredBuiltDependencies;
+        }
+        if (this.defaultCatalog && Object.keys(this.defaultCatalog).length > 0) {
+          pnpmConfig.catalog = this.defaultCatalog;
+        }
+        if (this.namedCatalogs && Object.keys(this.namedCatalogs).length > 0) {
+          pnpmConfig.namedCatalogs = this.namedCatalogs;
+        }
+        return {
+          ...packages.length > 0 ? { packages } : {},
+          ...pnpmConfig ? { ...pnpmConfig } : {}
+        };
+      }
+    });
+  }
+};
+
+// src/projects/monorepo-project.ts
+import {
+  NodePackageManager as NodePackageManager2,
+  UpgradeDependencies,
+  UpgradeDependenciesSchedule as UpgradeDependenciesSchedule2
+} from "projen/lib/javascript";
+import {
+  TypeScriptAppProject
+} from "projen/lib/typescript";
+import { merge as merge2 } from "ts-deepmerge";
+
+// src/tasks/reset-task.ts
+import { Component as Component6 } from "projen";
+
+// src/projects/typescript-project.ts
+import { typescript } from "projen";
+import {
+  NodePackageManager,
+  Transform,
+  UpgradeDependenciesSchedule
+} from "projen/lib/javascript";
+import { ReleaseTrigger } from "projen/lib/release";
+import { merge } from "ts-deepmerge";
+
+// src/versions.ts
+var VERSION = {
+  /**
+   * CDK CLI for workflows and command line operations.
+   *
+   * CLI and lib are versioned separately, so this is the CLI version.
+   */
+  AWS_CDK_CLI_VERSION: "2.1104.0",
+  /**
+   * CDK Version to use for construct projects.
+   *
+   * CLI and lib are versioned separately, so this is the lib version.
+   */
+  AWS_CDK_LIB_VERSION: "2.237.1",
+  /**
+   * Version of the AWS Constructs library to use.
+   */
+  AWS_CONSTRUCTS_VERSION: "10.4.5",
+  /**
+   * Version of Node.js to use in CI workflows at github actions.
+   */
+  NODE_WORKFLOWS: "24",
+  /**
+   * Version of PNPM to use in workflows at github actions.
+   */
+  PNPM_VERSION: "10.28.2",
+  /**
+   * Version of Projen to use.
+   */
+  PROJEN_VERSION: "0.99.9",
+  /**
+   * What version of the turborepo library should we use?
+   */
+  TURBO_VERSION: "2.8.3"
+};
+
+// src/projects/typescript-project.ts
+var TypeScriptProject = class extends typescript.TypeScriptProject {
+  constructor(userOptions) {
+    const pnpmVersion = userOptions.parent && userOptions.parent instanceof MonorepoProject ? userOptions.parent.pnpmVersion : VERSION.PNPM_VERSION;
+    const pnpmWorkspace = userOptions.parent && userOptions.parent instanceof MonorepoProject ? PnpmWorkspace.of(userOptions.parent) : void 0;
+    const defaultOptions = {
+      /**
+       * This is a standard, so don't require it to passed in everywhere.
+       */
+      defaultReleaseBranch: "main",
+      /**
+       * Enable reset task by default.
+       */
+      resetTask: true,
+      /**
+       * Packaging options
+       */
+      packageManager: NodePackageManager.PNPM,
+      pnpmVersion,
+      licensed: userOptions.license !== void 0 || false,
+      copyrightOwner: "CodeDrifters",
+      release: false,
+      /**
+       * Don't add sample code.
+       */
+      sampleCode: false,
+      /**
+       * Make sure jest config is stored outside of package.json
+       */
+      jestOptions: {
+        configFilePath: "jest.config.json",
+        jestConfig: {
+          roots: [`<rootDir>/src`],
+          transform: {
+            ["^.+\\.[t]sx?$"]: new Transform("@swc/jest")
+          },
+          moduleFileExtensions: ["js", "ts"]
+        }
+      },
+      /**
+       * Turn on prettier formatting
+       */
+      prettier: true,
+      /**
+       * SWC for faster testing
+       */
+      devDeps: ["@swc/jest", "@swc/core"],
+      /**
+       * Don't package test files.
+       */
+      npmIgnoreOptions: {
+        ignorePatterns: ["*.spec.*", "*.test.*"]
+      },
+      /**
+       * Options for the automated dependency upgrade task / workflow
+       * Automatically exclude any packages that are managed by the root
+       * project as default catalog dependencies since we want to let the
+       * catalog manage those dependencies.
+       */
+      depsUpgrade: true,
+      depsUpgradeOptions: {
+        workflow: false,
+        exclude: Object.keys(pnpmWorkspace?.defaultCatalog || {}),
+        ...userOptions.parent && userOptions.parent instanceof MonorepoProject ? {
+          workflowOptions: {
+            schedule: UpgradeDependenciesSchedule.WEEKLY
+          },
+          cooldown: 1
+        } : {}
+      },
+      /**
+       * Only release when the package folder sourcce content changes
+       */
+      releaseTrigger: ReleaseTrigger.continuous({
+        paths: [`${userOptions.outdir}/src/**`]
+      })
+    };
+    const options = merge(defaultOptions, userOptions);
+    super(options);
+    this.deps.removeDependency("ts-jest");
+    this.package.file.addOverride(
+      "packageManager",
+      `pnpm@${options.pnpmVersion}`
+    );
+    this.eslint?.addOverride({
+      files: ["**/*.test.*", "**/*.spec.*"],
+      rules: {
+        "import/no-extraneous-dependencies": "off"
+      }
+    });
+    this.gitignore?.addPatterns(".DS_Store");
+    this.npmignore?.addPatterns("*.spec.*", "*.test.*", "__fixtures__");
+    const turboActive = userOptions.parent && TurboRepo.of(userOptions.parent) !== void 0;
+    if (turboActive) {
+      const turbo = new TurboRepo(this);
+      turbo.compileTask?.outputs.push("dist/**");
+      turbo.compileTask?.outputs.push("lib/**");
+    }
+    if (options.resetTask !== false) {
+      const defaultResetTaskOptions = {
+        pathsToRemove: [
+          "node_modules",
+          "dist",
+          "lib",
+          "coverage",
+          "test-reports",
+          ".turbo",
+          "tsconfig.tsbuildinfo",
+          this.artifactsDirectory
+        ]
+      };
+      const userResetTaskOptions = options.resetTaskOptions ?? {};
+      const resetTaskOptions = merge(
+        defaultResetTaskOptions,
+        {
+          ...userResetTaskOptions,
+          pathsToRemove: [
+            ...defaultResetTaskOptions.pathsToRemove ?? [],
+            ...userResetTaskOptions.pathsToRemove ?? []
+          ]
+        }
+      );
+      new ResetTask(this, resetTaskOptions);
+    }
+    if (options.parent && options.parent instanceof MonorepoProject) {
+      const originalResolve = this.package.resolveDepsAndWritePackageJson;
+      this.package.installDependencies = () => {
+        options.parent.requestInstallDependencies({
+          resolveDepsAndWritePackageJson: () => originalResolve.apply(this.package)
+        });
+      };
+      this.package.resolveDepsAndWritePackageJson = () => {
+      };
+    }
+  }
+};
+
+// src/tasks/reset-task.ts
+var ResetTask = class _ResetTask extends Component6 {
+  constructor(project, options = {}) {
+    super(project);
+    this.project = project;
+    this.artifactsDirectory = options.artifactsDirectory ? options.artifactsDirectory : project instanceof TypeScriptProject ? project.artifactsDirectory : "lib";
+    const pathsToRemove = options.pathsToRemove ?? [];
+    const finalPaths = pathsToRemove.length === 0 ? [this.artifactsDirectory] : pathsToRemove;
+    this.pathsToRemove = Array.from(new Set(finalPaths));
+    this.taskName = options.taskName ?? "reset";
+    const resetTask = this.project.tasks.addTask(this.taskName, {
+      description: "Delete build artifacts specified by pathsToRemove option, or artifactsDirectory if pathsToRemove is empty"
+    });
+    this.pathsToRemove.forEach((path) => {
+      resetTask.exec(`[ -e "${path}" ] && rm -rf ${path} || true`);
+    });
+    const rootHasTurbo = TurboRepo.of(this.project.root) !== void 0;
+    const isSubproject = this.project !== this.project.root;
+    const isRootProject = this.project === this.project.root;
+    if (isSubproject && rootHasTurbo) {
+      const turbo = TurboRepo.of(this.project);
+      if (turbo && !turbo.isRootProject) {
+        const turboResetTask = new TurboRepoTask(this.project, {
+          name: `turbo:${this.taskName}`,
+          cache: false
+        });
+        turbo.tasks.push(turboResetTask);
+        const turboTaskWithSameName = new TurboRepoTask(this.project, {
+          name: this.taskName,
+          cache: false
+        });
+        turbo.tasks.push(turboTaskWithSameName);
+        turboResetTask.dependsOn.push(turboTaskWithSameName.name);
+      }
+    }
+    if (isRootProject && rootHasTurbo) {
+      const turbo = TurboRepo.of(this.project);
+      if (turbo && turbo.isRootProject) {
+        const rootTurboResetTask = new TurboRepoTask(this.project, {
+          name: `turbo:${this.taskName}`,
+          dependsOn: [`^turbo:${this.taskName}`],
+          cache: false
+        });
+        turbo.tasks.push(rootTurboResetTask);
+        const turboTaskWithSameName = new TurboRepoTask(this.project, {
+          name: this.taskName,
+          cache: false
+        });
+        turbo.tasks.push(turboTaskWithSameName);
+        rootTurboResetTask.dependsOn.push(turboTaskWithSameName.name);
+        const resetAllTask = this.project.tasks.addTask(
+          `${this.taskName}:all`,
+          {
+            description: `Reset all build artifacts across the monorepo by running turbo:${this.taskName} in all subprojects.`
+          }
+        );
+        resetAllTask.exec("turbo telemetry disable");
+        resetAllTask.exec(
+          `turbo turbo:${this.taskName} --summarize --concurrency=10`
+        );
+        resetAllTask.exec(`pnpm ${this.taskName}`);
+      }
+    }
+  }
+  /**
+   * Static method to discover reset task in a project.
+   */
+  static of(project) {
+    const isDefined = (c) => c instanceof _ResetTask;
+    return project.components.find(isDefined);
+  }
+};
+
+// src/vscode/vscode.ts
+import { Component as Component7, vscode } from "projen";
+var VSCodeConfig = class extends Component7 {
+  constructor(project) {
+    super(project);
+    const vsConfig = new vscode.VsCode(project);
+    const vsSettings = new vscode.VsCodeSettings(vsConfig);
+    vsSettings.addSetting("editor.tabSize", 2);
+    vsSettings.addSetting("editor.detectIndentation", false);
+    vsSettings.addSetting("editor.bracketPairColorization.enabled", true);
+    vsSettings.addSetting("editor.guides.bracketPairs", "active");
+    vsSettings.addSetting("editor.rulers", [80, 120]);
+    vsSettings.addSetting(
+      "editor.codeActionsOnSave",
+      { "source.fixAll.eslint": "explicit" },
+      "typescript"
+    );
+  }
+};
+
+// src/projects/monorepo-project.ts
+var MonorepoProject = class extends TypeScriptAppProject {
+  constructor(userOptions) {
+    const buildWorkflowOptions = userOptions.turboOptions?.remoteCacheOptions ? TurboRepo.buildWorkflowOptions(
+      userOptions.turboOptions.remoteCacheOptions
+    ) : {};
+    const defaultOptions = {
+      /**
+       * Use typescript based config file.
+       */
+      projenrcTs: true,
+      /**
+       * Projen version should be pinned to the local specified version.
+       */
+      projenVersion: "catalog:",
+      /**
+       * Use Prettier for code formatting.
+       */
+      prettier: true,
+      /**
+       * Not licensed by default.
+       */
+      licensed: false,
+      /**
+       * GitHub options for the monorepo.
+       * Don't enable mergify by default.
+       */
+      githubOptions: {
+        mergify: false,
+        /**
+         * Configure pull request linting to validate PR titles follow Conventional Commits.
+         * By default, all conventional commit types are allowed, providing flexibility
+         * for different types of changes (features, fixes, documentation, refactoring, etc.).
+         */
+        pullRequestLintOptions: {
+          semanticTitleOptions: {
+            /**
+             * Allowed conventional commit types for PR titles.
+             * This includes all standard types from the Conventional Commits specification:
+             * - feat: New features
+             * - fix: Bug fixes
+             * - docs: Documentation changes
+             * - style: Code style changes (formatting, etc.)
+             * - refactor: Code refactoring
+             * - perf: Performance improvements
+             * - test: Test additions or changes
+             * - build: Build system changes
+             * - ci: CI configuration changes
+             * - chore: Maintenance tasks
+             * - revert: Revert commits
+             */
+            types: [
+              "feat",
+              "fix",
+              "docs",
+              "style",
+              "refactor",
+              "perf",
+              "test",
+              "build",
+              "ci",
+              "chore",
+              "revert"
+            ]
+          }
+        }
+      },
+      /**
+       * Default PNPM version to use in the monorepo.
+       */
+      pnpmVersion: VERSION.PNPM_VERSION,
+      /**
+       * We don't want sample code generated for the root project.
+       */
+      sampleCode: false,
+      /**
+       * Jest is not required in the root project.
+       */
+      jest: false,
+      /**
+       * Don't release the root project.
+       */
+      release: false,
+      /**
+       * Uppgrade dependencies automatically unless otherwise instructed.
+       */
+      depsUpgrade: true,
+      depsUpgradeOptions: {
+        workflowOptions: {
+          schedule: UpgradeDependenciesSchedule2.WEEKLY
+        },
+        cooldown: 1
+      },
+      /**
+       * Disable tsconfig.dev.json in the root since we aren't going to be
+       * developing any code here. It's just a task runner and configuration
+       * tool for sub-projects.
+       */
+      disableTsconfigDev: true,
+      /**
+       * Kill the srcdir in the root since we aren't using one.
+       */
+      tsconfig: {
+        compilerOptions: {
+          rootDir: void 0
+        },
+        exclude: ["node_modules"]
+      },
+      /**
+       * Enable turborepo by default.
+       */
+      turbo: true,
+      /**
+       * Enable reset task by default.
+       */
+      resetTask: true,
+      /**
+       * Include self as a devDep
+       */
+      devDeps: ["@codedrifters/configulator"],
+      /**
+       * PNPM options for the monorepo.
+       */
+      pnpmOptions: {
+        pnpmWorkspaceOptions: {
+          defaultCatalog: {
+            ["aws-cdk"]: VERSION.AWS_CDK_CLI_VERSION,
+            ["aws-cdk-lib"]: VERSION.AWS_CDK_LIB_VERSION,
+            ["projen"]: VERSION.PROJEN_VERSION,
+            ["constructs"]: VERSION.AWS_CONSTRUCTS_VERSION,
+            ["turbo"]: VERSION.TURBO_VERSION
+          }
+        }
+      }
+    };
+    const requiredOptions = {
+      /**
+       * This is required because it's standard practice and also to simplify
+       * some workflow design.
+       */
+      defaultReleaseBranch: "main",
+      /**
+       * Use PNPM instead of the default (Yarn). Much of the ecosystem depends
+       * on PNPM and making monorepos PNPM only simplifies many configurations.
+       */
+      packageManager: NodePackageManager2.PNPM,
+      /**
+       * Some additional pre-build steps if we're using turbo's remote cache.
+       */
+      buildWorkflowOptions: {
+        permissions: {
+          ...buildWorkflowOptions?.permissions,
+          ...userOptions.buildWorkflowOptions?.permissions
+        },
+        preBuildSteps: [
+          ...buildWorkflowOptions?.preBuildSteps ?? [],
+          ...userOptions.buildWorkflowOptions?.preBuildSteps ?? []
+        ]
+      }
+    };
+    const options = merge2(
+      defaultOptions,
+      userOptions,
+      requiredOptions
+    );
+    super({ ...options });
+    /**
+     * List of functions to call after dependencies have been installed.
+     */
+    this.postInstallDependencies = new Array();
+    this.pnpmVersion = options.pnpmVersion;
+    new VSCodeConfig(this);
+    new PnpmWorkspace(this, options.pnpmOptions?.pnpmWorkspaceOptions);
+    if (options.turbo) {
+      new TurboRepo(this, options.turboOptions);
+      this.buildWorkflow?.addPostBuildSteps({
+        name: "Build Sub Projects",
+        run: `npx projen ${ROOT_CI_TASK_NAME}`
+      });
+    }
+    if (options.resetTask !== false) {
+      const defaultResetTaskOptions = {
+        pathsToRemove: ["node_modules", ".turbo", "dist", "lib"]
+      };
+      const userResetTaskOptions = options.resetTaskOptions ?? {};
+      const resetTaskOptions = merge2(
+        defaultResetTaskOptions,
+        {
+          ...userResetTaskOptions,
+          pathsToRemove: [
+            ...defaultResetTaskOptions.pathsToRemove ?? [],
+            ...userResetTaskOptions.pathsToRemove ?? []
+          ]
+        }
+      );
+      new ResetTask(this, resetTaskOptions);
+    }
+    this.package.file.addOverride(
+      "packageManager",
+      `pnpm@${options.pnpmVersion}`
+    );
+    this.gitignore?.addPatterns(".DS_Store");
+    this.addDevDeps("constructs@catalog:");
+    if (options.upgradeConfigulatorTask !== false) {
+      this.upgradeConfigulatorTask = new UpgradeDependencies(
+        this,
+        merge2(
+          {
+            include: ["@codedrifters/configulator"],
+            taskName: `upgrade-codedrifters-configulator`,
+            workflowOptions: {
+              schedule: UpgradeDependenciesSchedule2.DAILY
+            }
+          },
+          options.upgradeConfigulatorTaskOptions ?? {}
+        )
+      );
+    }
+    this.tasks.tryFind("post-upgrade")?.exec("pnpm upgrade -r");
+    this.tasks.tryFind("post-upgrade")?.spawn(this.defaultTask);
+  }
+  /**
+   * Allows a sub project to request installation of dependency at the Monorepo root
+   * They must provide a function that is executed after dependencies have been installed
+   * If this function returns true, the install command is run for a second time after all sub project requests have run.
+   * This is used to resolve dependency versions from `*` to a concrete version constraint.
+   */
+  requestInstallDependencies(resolver) {
+    this.postInstallDependencies.push(resolver.resolveDepsAndWritePackageJson);
+  }
+  /**
+   * Hooks into the install dependencies cycle
+   */
+  postSynthesize() {
+    if (this.postInstallDependencies.length) {
+      const nodePkg = this.package;
+      nodePkg.installDependencies();
+      const completedRequests = this.postInstallDependencies.map(
+        (request) => request()
+      );
+      if (completedRequests.some(Boolean)) {
+        nodePkg.installDependencies();
+      }
+      this.postInstallDependencies = [];
+    }
+  }
+};
+
+// src/typescript/typescript-config.ts
+import { relative as relative3 } from "path";
+import { Component as Component8 } from "projen";
+import { ensureRelativePathStartsWithDot } from "projen/lib/util/path";
+var TypeScriptConfig = class extends Component8 {
+  constructor(project) {
+    super(project);
+    let tsPaths = {};
+    const workspaceDeps = project.deps.all.filter(
+      (d) => d.version === "workspace:*"
+    );
+    workspaceDeps.forEach((dep) => {
+      const subproject = project.root.subprojects.find((p) => p.package.packageName === dep.name);
+      if (!subproject) {
+        throw new Error(`Could not find subproject ${dep.name} in monorepo.`);
+      }
+      tsPaths = {
+        ...tsPaths,
+        [dep.name]: [
+          ensureRelativePathStartsWithDot(
+            relative3(project.outdir, subproject.outdir)
+          )
+        ]
+      };
+    });
+    project.tsconfig?.file.addOverride("compilerOptions.paths", tsPaths);
+    project.tsconfigDev?.file.addOverride("compilerOptions.paths", tsPaths);
+  }
+};
+
+// src/workflows/aws-deploy-workflow.ts
+var import_utils2 = __toESM(require_lib());
+import { Component as Component9 } from "projen";
+import { BuildWorkflow } from "projen/lib/build";
+import { GitHub } from "projen/lib/github";
+import { JobPermission as JobPermission2 } from "projen/lib/github/workflows-model";
+var PROD_DEPLOY_NAME = "prod-deploy";
+var AwsDeployWorkflow = class _AwsDeployWorkflow extends Component9 {
+  constructor(project, options = {}) {
+    super(project);
+    this.project = project;
+    /**
+     * AWS environment type, such as primary or secondary.
+     *
+     * @deprecated Use deployment target role terminology elsewhere. This property is maintained for backward compatibility.
+     * @default 'primary' (this is the only type supported currently)
+     */
+    this.awsEnvironmentType = import_utils2.DEPLOYMENT_TARGET_ROLE.PRIMARY;
+    this.setupNode = () => {
+      return [
+        {
+          name: "Setup Node",
+          uses: "actions/setup-node@v4",
+          with: {
+            ["node-version"]: VERSION.NODE_WORKFLOWS
+          },
+          // occasionally this step fails due to internal issues at github
+          timeoutMinutes: 1
+        }
+      ];
+    };
+    this.setupPnpm = () => {
+      return [
+        {
+          name: "Setup PNPM",
+          uses: "pnpm/action-setup@v3",
+          with: {
+            version: VERSION.PNPM_VERSION
+          }
+        }
+      ];
+    };
+    /**
+     * Builds a GitHub Actions condition string that checks if the current branch
+     * matches any of the provided branch patterns.
+     *
+     * Handles both exact matches (e.g., "main") and glob patterns (e.g., "feature/*").
+     * Also allows workflow_dispatch (manual runs) to proceed.
+     *
+     * @param branches Array of GitBranch objects with branch patterns
+     * @returns Condition string or empty string if no branches provided
+     */
+    this.buildBranchFilterCondition = (branches) => {
+      if (!branches || branches.length === 0) {
+        return "";
+      }
+      const conditions = [];
+      conditions.push("github.event_name == 'workflow_dispatch'");
+      for (const branch of branches) {
+        const branchPattern = branch.branch;
+        if (branchPattern.includes("*")) {
+          const prefix = branchPattern.replace(/\*.*$/, "");
+          conditions.push(`startsWith(github.ref, 'refs/heads/${prefix}')`);
+        } else {
+          conditions.push(`github.ref == 'refs/heads/${branchPattern}'`);
+        }
+      }
+      return conditions.join(" || ");
+    };
+    this.deploySteps = (target) => {
+      const {
+        awsStageType,
+        deploymentTargetRole,
+        account,
+        region,
+        ciDeploymentConfig,
+        awsDeploymentConfig
+      } = target;
+      const { roleArn, stackPattern } = ciDeploymentConfig ?? {};
+      const { rootCdkOut } = awsDeploymentConfig;
+      return [
+        ...this.setupPnpm(),
+        ...this.setupNode(),
+        /**
+         * Install CDK
+         */
+        {
+          name: "Install CDK",
+          run: "pnpm add aws-cdk"
+        },
+        /**
+         * Configure AWS creds.
+         */
+        {
+          name: `AWS Creds ${awsStageType}/${deploymentTargetRole}/${account}/${region}`,
+          uses: "aws-actions/configure-aws-credentials@v4",
+          with: {
+            "role-to-assume": roleArn,
+            "aws-region": region,
+            "role-duration-seconds": 900
+            // 15 minutes
+          }
+        },
+        /**
+         * Run CDK Deploy
+         */
+        {
+          name: `Deploy ${awsStageType}/${deploymentTargetRole}/${account}/${region}`,
+          run: `pnpm dlx aws-cdk deploy --no-rollback --require-approval=never --app=${rootCdkOut} "${stackPattern}"`
+        }
+      ];
+    };
+    if (!(project.root instanceof MonorepoProject)) {
+      throw new Error(
+        "AwsDeployWorkflow requires the root project to be a MonorepoProject"
+      );
+    }
+    this.rootProject = project.root;
+    const github = GitHub.of(this.rootProject);
+    if (!github) {
+      throw new Error(
+        "AwsDeployWorkflow requires a GitHub component in the root project"
+      );
+    }
+    const turbo = TurboRepo.of(this.rootProject);
+    const buildWorkflowOptions = turbo?.remoteCacheOptions ? TurboRepo.buildWorkflowOptions(turbo.remoteCacheOptions) : {};
+    this.awsStageType = options.awsStageType ?? import_utils2.AWS_STAGE_TYPE.DEV;
+    this.awsDeploymentTargets = options.awsDeploymentTargets ?? AwsDeploymentConfig.of(project)?.awsDeploymentTargets.filter(
+      (target) => target.awsStageType === this.awsStageType && target.ciDeployment
+    ) ?? [];
+    this.deployAfterTargets = options.deployAfterTargets ?? [];
+    if (options.buildWorkflow && options.buildWorkflowOptions) {
+      throw new Error(
+        "Cannot provide both buildWorkflow and buildWorkflowOptions"
+      );
+    }
+    this.externalWorkflow = !!options.buildWorkflow;
+    this.buildWorkflow = options.buildWorkflow ?? new BuildWorkflow(this.rootProject, {
+      /**
+       * Name based on project and environment.
+       */
+      name: options.buildWorkflowOptions?.name ?? [
+        "deploy",
+        project.name,
+        this.awsStageType,
+        this.awsEnvironmentType
+      ].join("-"),
+      /**
+       * Use the root projects build task.
+       */
+      buildTask: this.rootProject.buildTask,
+      /**
+       * Use push triggers based n the branch config for each environment.
+       */
+      workflowTriggers: {
+        push: {
+          branches: [
+            ...this.awsDeploymentTargets.flatMap(
+              (t) => t.branches.map((b) => b.branch)
+            )
+          ]
+        },
+        workflowDispatch: {},
+        ...options.buildWorkflowOptions?.workflowTriggers
+      },
+      /**
+       * Never allow mutations for deploys. This should have been handled
+       * during build.
+       */
+      mutableBuild: false,
+      /**
+       * Do this pre-merge of permissions and build steps
+       */
+      ...options.buildWorkflowOptions,
+      /**
+       * Some additional permissions may be required when turbo's involved.
+       */
+      permissions: {
+        ...options.buildWorkflowOptions?.permissions,
+        ...buildWorkflowOptions?.permissions
+      },
+      /**
+       * Assemble all pre-build steps
+       */
+      preBuildSteps: [
+        ...this.setupPnpm(),
+        ...this.setupNode(),
+        {
+          name: "Install dependencies",
+          run: "pnpm i --no-frozen-lockfile"
+        },
+        ...options.buildWorkflowOptions?.preBuildSteps ?? [],
+        ...buildWorkflowOptions?.preBuildSteps ?? []
+      ]
+    });
+    const buildJobName = (target) => {
+      return [
+        target.awsStageType,
+        target.deploymentTargetRole,
+        "deploy",
+        target.project.name,
+        target.account,
+        target.region
+      ].join("-");
+    };
+    this.awsDeploymentTargets.forEach((target) => {
+      const deployJobName = buildJobName(target);
+      const branchFilterCondition = this.buildBranchFilterCondition(
+        target.branches
+      );
+      const jobCondition = branchFilterCondition ? [
+        "${{ !needs.build.outputs.self_mutation_happened }}",
+        `(${branchFilterCondition})`
+      ].join(" && ") : "${{ !needs.build.outputs.self_mutation_happened }}";
+      this.buildWorkflow.addPostBuildJob(deployJobName, {
+        name: `Deploy ${this.project.name} ${target.awsStageType}/${target.deploymentTargetRole}/${target.account}/${target.region}`,
+        needs: [
+          "build",
+          ...this.deployAfterTargets.map((p) => {
+            return buildJobName(p);
+          })
+        ],
+        runsOn: ["ubuntu-latest"],
+        permissions: {
+          contents: JobPermission2.READ,
+          idToken: JobPermission2.WRITE
+        },
+        concurrency: deployJobName,
+        if: jobCondition,
+        steps: [...this.deploySteps(target)]
+      });
+    });
+  }
+  static of(project, buildWorkflow) {
+    const isDefined = (c) => c instanceof _AwsDeployWorkflow && c.buildWorkflow === buildWorkflow;
+    return project.components.find(isDefined);
+  }
+  preSynthesize() {
+    if (!this.externalWorkflow && TurboRepo.of(this.rootProject)) {
+      this.buildWorkflow.addPostBuildSteps({
+        name: "Build Sub Projects",
+        run: `npx projen ${ROOT_CI_TASK_NAME}`
+      });
+    }
+    super.preSynthesize();
+  }
+};
+export {
+  AwsDeployWorkflow,
+  AwsDeploymentConfig,
+  JsiiFaker,
+  MIMIMUM_RELEASE_AGE,
+  MonorepoProject,
+  PROD_DEPLOY_NAME,
+  PnpmWorkspace,
+  ROOT_CI_TASK_NAME,
+  ROOT_TURBO_TASK_NAME,
+  ResetTask,
+  TurboRepo,
+  TurboRepoTask,
+  TypeScriptConfig,
+  TypeScriptProject,
+  VSCodeConfig
+};
+//# sourceMappingURL=index.mjs.map