carlin 1.36.10 → 1.36.12

package/dist/index.js

@@ -0,0 +1,4497 @@
+import 'dotenv/config';
+import AWS from 'aws-sdk';
+import log5 from 'npmlog';
+import yaml4 from 'js-yaml';
+import 'uglify-js';
+import 'prettier';
+import git from 'simple-git';
+import findUpSync from 'findup-sync';
+import * as fs3 from 'fs';
+import fs3__default from 'fs';
+import { pascalCase, constantCase, kebabCase, camelCase } from 'change-case';
+import { stdout } from 'process';
+import childProcess from 'child_process';
+import * as path from 'path';
+import path__default from 'path';
+import { ValidateTemplateCommand, CloudFormationClient, DeleteStackCommand, CreateStackCommand, UpdateStackCommand, UpdateTerminationProtectionCommand, DescribeStacksCommand, DescribeStackEventsCommand, DescribeStackResourceCommand } from '@aws-sdk/client-cloudformation';
+import { glob } from 'glob';
+import mime from 'mime-types';
+import deepmerge from 'deepmerge';
+import { hideBin } from 'yargs/helpers';
+import yargs from 'yargs';
+import * as esbuild from 'esbuild';
+import { builtinModules } from 'node:module';
+import { typescriptConfig } from '@ttoss/config';
+import * as fs4 from 'node:fs';
+import fs4__default from 'node:fs';
+import * as path3 from 'node:path';
+import path3__default from 'node:path';
+import AdmZip from 'adm-zip';
+import importSync from 'import-sync';
+import semver from 'semver';
+import deepEqual from 'deep-equal';
+
+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');
+});
+
+// src/config.ts
+var NAME = "carlin";
+var AWS_DEFAULT_REGION = "us-east-1";
+var CLOUDFRONT_REGION = "us-east-1";
+var NODE_VERSION = "20";
+var NODE_RUNTIME = `nodejs${NODE_VERSION}.x`;
+
+// src/utils/addGroupToOptions.ts
+var addGroupToOptions = (options9, group) => {
+  Object.values(options9).forEach((option) => {
+    option.group = group;
+  });
+  return options9;
+};
+var logPrefix = "codebuild";
+var WAIT_TIME = 10 * 1e3;
+var waitCodeBuildFinish = async ({
+  buildId,
+  name
+}) => {
+  const codeBuild2 = new AWS.CodeBuild();
+  let result;
+  const checkIfBuildIsFinished = async () => {
+    const { builds } = await codeBuild2.batchGetBuilds({ ids: [buildId] }).promise();
+    return new Promise((resolve6, reject) => {
+      setTimeout(() => {
+        const executedBuild = builds?.find(({ id }) => {
+          return id === buildId;
+        });
+        log5.info(
+          logPrefix,
+          `Build status of ${name || buildId}: ${executedBuild?.buildStatus}`
+        );
+        if (executedBuild && executedBuild.currentPhase === "COMPLETED") {
+          if (executedBuild.buildStatus === "SUCCEEDED") {
+            resolve6(executedBuild);
+          } else if (["FAILED", "FAILURE"].includes(executedBuild.buildStatus || "")) {
+            reject(new Error(`Cannot execute build ${buildId}.`));
+          }
+        }
+        resolve6(void 0);
+      }, WAIT_TIME);
+    });
+  };
+  while (!result) {
+    result = await checkIfBuildIsFinished();
+  }
+  return result;
+};
+var startCodeBuildBuild = async ({
+  projectName
+}) => {
+  const codeBuild2 = new AWS.CodeBuild();
+  const { build } = await codeBuild2.startBuild({ projectName }).promise();
+  if (!build) {
+    throw new Error(`Cannot start ${projectName} build`);
+  }
+  return build;
+};
+
+// src/utils/environmentVariables.ts
+var cache = /* @__PURE__ */ new Map();
+var getEnvVar = (key) => {
+  return cache.has(key) && cache.get(key) ? cache.get(key) : void 0;
+};
+var setEnvVar = (key, value) => {
+  if (!value) {
+    return cache.delete(key);
+  }
+  return cache.set(key, value);
+};
+log5.heading = "exec";
+var getAwsAccountId = async () => {
+  const sts = new AWS.STS();
+  const { Account } = await sts.getCallerIdentity().promise();
+  return Account;
+};
+var BRANCH_UNDEFINED = "";
+var getCurrentBranch = async () => {
+  try {
+    if (getEnvVar("BRANCH")) {
+      return getEnvVar("BRANCH");
+    }
+    const { current } = await git().branch();
+    return current || BRANCH_UNDEFINED;
+  } catch (err) {
+    return BRANCH_UNDEFINED;
+  }
+};
+
+// src/utils/getEnvironment.ts
+var getEnvironment = () => {
+  return getEnvVar("ENVIRONMENT");
+};
+
+// src/utils/getIamPath.ts
+var getIamPath = () => `/${NAME}/`;
+var readPackageJson = () => {
+  const packageJsonDir = findUpSync("package.json");
+  if (!packageJsonDir) {
+    return {};
+  }
+  return JSON.parse(fs3__default.readFileSync(packageJsonDir).toString());
+};
+var getPackageJsonProperty = ({ property }) => {
+  try {
+    return readPackageJson()[property];
+  } catch {
+    return "";
+  }
+};
+var getPackageName = () => {
+  return getPackageJsonProperty({ property: "name" });
+};
+var getPackageVersion = () => {
+  return getPackageJsonProperty({ property: "version" });
+};
+var getProjectName = () => {
+  if (getEnvVar("PROJECT")) {
+    return getEnvVar("PROJECT");
+  }
+  const name = getPackageName();
+  if (!name) {
+    return "";
+  }
+  try {
+    return pascalCase(name.split(/[@/]/)[1]);
+  } catch (err) {
+    return pascalCase(name);
+  }
+};
+log5.heading = "exec";
+var spawn = (cmd) => {
+  return new Promise((resolve6, reject) => {
+    const [cmdName, ...cmdArgs] = cmd.split(" ");
+    const child = childProcess.spawn(cmdName, cmdArgs);
+    child.stdout.on("data", (data) => {
+      stdout.write(data);
+    });
+    child.stderr.on("data", (data) => {
+      stdout.write(data);
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve6({});
+      } else {
+        reject(code);
+      }
+    });
+  });
+};
+var pascalCaseName = pascalCase(NAME);
+var BASE_STACK_NAME = `${pascalCaseName}BaseStack`;
+var BASE_STACK_BUCKET_TEMPLATES_FOLDER = "cloudformation-templates";
+var BASE_STACK_BUCKET_LOGICAL_NAME = `${pascalCaseName}Bucket`;
+var BASE_STACK_BUCKET_NAME_EXPORTED_NAME = `${pascalCaseName}BucketNameExportedName`;
+var BASE_STACK_LAMBDA_IMAGE_BUILDER_LOGICAL_NAME = `${pascalCaseName}LambdaImageBuilder`;
+var BASE_STACK_LAMBDA_IMAGE_BUILDER_EXPORTED_NAME = `${pascalCaseName}LambdaImageBuilderExportedName`;
+var BASE_STACK_LAMBDA_LAYER_BUILDER_LOGICAL_NAME = `${pascalCaseName}LambdaLayerBuilder`;
+var BASE_STACK_VPC_ID_EXPORTED_NAME = `${pascalCaseName}VPCIDExportedName`;
+var BASE_STACK_VPC_DEFAULT_SECURITY_GROUP_EXPORTED_NAME = `${pascalCaseName}DefaultSecurityGroupExportedName`;
+var BASE_STACK_VPC_PUBLIC_SUBNET_0_EXPORTED_NAME = `${pascalCaseName}VPCPublicSubnet0ExportedName`;
+var BASE_STACK_VPC_PUBLIC_SUBNET_1_EXPORTED_NAME = `${pascalCaseName}VPCPublicSubnet1ExportedName`;
+var BASE_STACK_VPC_PUBLIC_SUBNET_2_EXPORTED_NAME = `${pascalCaseName}VPCPublicSubnet2ExportedName`;
+
+// src/deploy/config.ts
+var LATEST_DEPLOY_OUTPUTS_FILENAME = "latest-deploy.json";
+
+// src/deploy/addDefaults.cloudformation.ts
+var addDefaultsParametersAndTagsToParams = async (params) => {
+  const branchName = await getCurrentBranch();
+  const environment = await getEnvironment();
+  const packageName = await getPackageName();
+  const packageVersion = await getPackageVersion();
+  const projectName = await getProjectName();
+  const tagValuePattern = /[^a-zA-Z0-9_.:/=+\-@]/g;
+  return {
+    ...params,
+    Parameters: [
+      ...params.Parameters || [],
+      ...environment ? [{ ParameterKey: "Environment", ParameterValue: environment }] : [],
+      { ParameterKey: "Project", ParameterValue: projectName }
+    ],
+    Tags: [
+      ...params.Tags || [],
+      { Key: "Branch", Value: branchName },
+      ...environment ? [{ Key: "Environment", Value: environment }] : [],
+      { Key: "Package", Value: packageName },
+      { Key: "Project", Value: projectName },
+      { Key: "Version", Value: packageVersion }
+    ].filter(({ Value }) => {
+      return !!Value;
+    }).map(({ Key, Value }) => {
+      return {
+        Key,
+        Value: Value.replace(tagValuePattern, "")
+      };
+    })
+  };
+};
+var addDefaultParametersToTemplate = async (template) => {
+  const [environment, projectName] = await Promise.all([
+    getEnvironment(),
+    getProjectName()
+  ]);
+  const newParameters = {
+    Project: { Default: projectName, Type: "String" }
+  };
+  if (environment) {
+    newParameters.Environment = { Default: environment, Type: "String" };
+  }
+  template.Parameters = { ...newParameters, ...template.Parameters };
+};
+var addLogGroupToResources = (template) => {
+  const { Resources } = template;
+  const resourcesEntries = Object.entries(Resources);
+  resourcesEntries.forEach(([key, resource]) => {
+    if (["AWS::Lambda::Function", "AWS::Serverless::Function"].includes(
+      resource.Type
+    )) {
+      const logGroup = resourcesEntries.find(([, resource2]) => {
+        const logGroupNameStr = JSON.stringify(
+          resource2.Properties?.LogGroupName?.["Fn::Join"] || ""
+        );
+        return logGroupNameStr.includes(key);
+      });
+      if (!logGroup) {
+        Resources[`${key}LogsLogGroup`] = {
+          Type: "AWS::Logs::LogGroup",
+          DeletionPolicy: "Delete",
+          Properties: {
+            LogGroupName: { "Fn::Join": ["/", ["/aws/lambda", { Ref: key }]] }
+          }
+        };
+      }
+    }
+  });
+};
+var addEnvironmentsToLambdaResources = async (template) => {
+  const environment = getEnvironment();
+  const { Resources } = template;
+  const resourcesEntries = Object.entries(Resources);
+  resourcesEntries.forEach(([, resource]) => {
+    if (resource.Type === "AWS::Lambda::Function") {
+      const { Properties } = resource;
+      if ((Properties.Description || "").includes("Lambda@Edge")) {
+        return;
+      }
+      if (!environment) {
+        return;
+      }
+      if (!Properties.Environment) {
+        Properties.Environment = {};
+      }
+      if (!Properties.Environment.Variables) {
+        Properties.Environment.Variables = {};
+      }
+      Properties.Environment.Variables.ENVIRONMENT = environment;
+    }
+  });
+};
+var CRITICAL_RESOURCES_TYPES = [
+  "AWS::Cognito::UserPool",
+  "AWS::DynamoDB::Table"
+];
+var addRetainToCriticalResources = async (template) => {
+  const environment = getEnvironment();
+  Object.entries(template.Resources).forEach(([, resource]) => {
+    if (CRITICAL_RESOURCES_TYPES.includes(resource.Type)) {
+      if (!resource.DeletionPolicy && environment) {
+        resource.DeletionPolicy = "Retain";
+      }
+    }
+  });
+};
+var addAppSyncApiOutputs = async (template) => {
+  Object.entries(template.Resources).forEach(([key, resource]) => {
+    if (resource.Type === "AWS::AppSync::GraphQLApi") {
+      template.Outputs = {
+        [key]: {
+          Description: `Automatically added by ${NAME}`,
+          Value: { "Fn::GetAtt": [key, "GraphQLUrl"] },
+          Export: {
+            Name: {
+              "Fn::Join": [":", [{ Ref: "AWS::StackName" }, "GraphQLApiUrl"]]
+            }
+          }
+        },
+        ...template.Outputs
+      };
+    }
+  });
+};
+var addDefaults = async ({
+  params,
+  template
+}) => {
+  const newTemplate = JSON.parse(JSON.stringify(template));
+  await addDefaultParametersToTemplate(newTemplate);
+  await addLogGroupToResources(newTemplate);
+  await addEnvironmentsToLambdaResources(newTemplate);
+  await addAppSyncApiOutputs(newTemplate);
+  await addRetainToCriticalResources(newTemplate);
+  const response = {
+    params: await addDefaultsParametersAndTagsToParams(params),
+    template: newTemplate
+  };
+  return response;
+};
+var logPrefix2 = "s3";
+var s3 = new AWS.S3({ apiVersion: "2006-03-01" });
+var getBucketKeyUrl = ({
+  bucket,
+  key
+}) => {
+  return `https://s3.amazonaws.com/${bucket}/${key}`;
+};
+var uploadFileToS3 = async ({
+  bucket,
+  contentType,
+  file,
+  filePath,
+  key
+}) => {
+  if (!file && !filePath) {
+    throw new Error("file or filePath must be defined");
+  }
+  let params = {
+    Bucket: bucket,
+    Key: key.split(path__default.sep).join("/")
+  };
+  if (file) {
+    params.ContentType = contentType;
+    params.Body = file;
+  } else if (filePath) {
+    const readFile = await fs3__default.promises.readFile(filePath);
+    params = {
+      ...params,
+      ContentType: contentType || mime.contentType(path__default.extname(filePath)) || void 0
+    };
+    params.Body = Buffer.from(readFile);
+  }
+  const { Bucket, Key, VersionId } = await s3.upload(params).promise();
+  return {
+    bucket: Bucket,
+    key: Key,
+    versionId: VersionId,
+    url: getBucketKeyUrl({ bucket: Bucket, key: Key })
+  };
+};
+var getAllFilesInsideADirectory = async ({
+  directory
+}) => {
+  const allFilesAndDirectories = await glob(`${directory}/**/*`);
+  const allFiles = allFilesAndDirectories.filter((item) => {
+    return fs3__default.lstatSync(item).isFile();
+  });
+  return allFiles;
+};
+var copyRoot404To404Index = async ({ bucket }) => {
+  try {
+    const root404Exists = await s3.headObject({
+      Bucket: bucket,
+      Key: "404.html"
+    }).promise().catch(() => {
+      return false;
+    });
+    if (root404Exists) {
+      await s3.copyObject({
+        Bucket: bucket,
+        CopySource: `${bucket}/404.html`,
+        Key: "404/index.html"
+      }).promise();
+    }
+  } catch (err) {
+    log5.error(logPrefix2, `Cannot copy 404.html to 404/index.html`);
+    throw err;
+  }
+};
+var uploadDirectoryToS3 = async ({
+  bucket,
+  bucketKey = "",
+  directory
+}) => {
+  log5.info(
+    logPrefix2,
+    `Uploading directory ${directory}/ to ${bucket}/${bucketKey}...`
+  );
+  const allFiles = await getAllFilesInsideADirectory({ directory });
+  if (allFiles.length === 0) {
+    throw new Error(`Directory ${directory}/ has no files.`);
+  }
+  const GROUP_MAX_LENGTH = 63;
+  const numberOfGroups = Math.ceil(allFiles.length / GROUP_MAX_LENGTH);
+  const aoaOfFiles = allFiles.reduce((acc, file, index) => {
+    const groupIndex = index % numberOfGroups;
+    if (!acc[groupIndex]) {
+      acc[groupIndex] = [];
+    }
+    acc[index % numberOfGroups].push(file);
+    return acc;
+  }, []);
+  for (const [index, groupOfFiles] of aoaOfFiles.entries()) {
+    log5.info(logPrefix2, `Uploading group ${index + 1}/${aoaOfFiles.length}...`);
+    await Promise.all(
+      groupOfFiles.map((file) => {
+        return uploadFileToS3({
+          bucket,
+          key: path__default.join(bucketKey, path__default.relative(directory, file)),
+          filePath: file
+        });
+      })
+    );
+  }
+};
+var emptyS3Directory = async ({
+  bucket,
+  directory = ""
+}) => {
+  log5.info(logPrefix2, `${bucket}/${directory} will be empty`);
+  try {
+    const { Contents, IsTruncated } = await s3.listObjectsV2({
+      Bucket: bucket,
+      Prefix: directory
+    }).promise();
+    if (Contents && Contents.length > 0) {
+      const objectsPromises = Contents.filter(({ Key }) => {
+        return !!Key;
+      }).map(async ({ Key }) => {
+        const { Versions = [] } = await s3.listObjectVersions({
+          Bucket: bucket,
+          Prefix: Key
+        }).promise();
+        return {
+          Key,
+          Versions: Versions.map(({ VersionId }) => {
+            return VersionId || void 0;
+          })
+        };
+      });
+      const objects = await Promise.all(objectsPromises);
+      const objectsWithVersionsIds = objects.reduce((acc, { Key, Versions }) => {
+        const objectWithVersionsIds = Versions.map((VersionId) => {
+          return {
+            Key,
+            VersionId
+          };
+        });
+        return [...acc, ...objectWithVersionsIds];
+      }, []);
+      await s3.deleteObjects({
+        Bucket: bucket,
+        Delete: { Objects: objectsWithVersionsIds }
+      }).promise();
+    }
+    if (IsTruncated) {
+      await emptyS3Directory({ bucket, directory });
+    }
+    log5.info(logPrefix2, `${bucket}/${directory} is empty.`);
+  } catch (err) {
+    log5.error(logPrefix2, `Cannot empty ${bucket}/${directory}.`);
+    throw err;
+  }
+};
+var deleteS3Directory = async ({
+  bucket,
+  directory = ""
+}) => {
+  try {
+    log5.info(logPrefix2, `${bucket}/${directory} is being deleted...`);
+    await emptyS3Directory({ bucket, directory });
+    await s3.deleteObject({ Bucket: bucket, Key: directory }).promise();
+    log5.info(logPrefix2, `${bucket}/${directory} was deleted.`);
+  } catch (error) {
+    log5.error(logPrefix2, `Cannot delete ${bucket}/${directory}.`);
+    throw error;
+  }
+};
+
+// src/deploy/baseStack/getBaseStackResource.ts
+var getBaseStackOutput = async (outputKey) => {
+  const output = await getStackOutput({
+    stackName: BASE_STACK_NAME,
+    outputKey
+  });
+  return output.OutputValue;
+};
+var resourcesKeys = {
+  BASE_STACK_BUCKET_LOGICAL_NAME,
+  BASE_STACK_LAMBDA_IMAGE_BUILDER_LOGICAL_NAME,
+  BASE_STACK_LAMBDA_LAYER_BUILDER_LOGICAL_NAME
+};
+var resources = {};
+var getBaseStackResource = async (resource) => {
+  if (!resources[resource]) {
+    resources[resource] = await getBaseStackOutput(resourcesKeys[resource]);
+  }
+  return resources[resource];
+};
+var logPrefix3 = "cloudformation";
+log5.addLevel("event", 1e4, { fg: "yellow" });
+log5.addLevel("output", 1e4, { fg: "blue" });
+var TEMPLATE_BODY_MAX_SIZE = 51200;
+var isTemplateBodyGreaterThanMaxSize = (template) => {
+  return Buffer.byteLength(JSON.stringify(template), "utf8") >= TEMPLATE_BODY_MAX_SIZE;
+};
+var uploadTemplateToBaseStackBucket = async ({
+  stackName,
+  template
+}) => {
+  const bucketName = await getBaseStackResource(
+    "BASE_STACK_BUCKET_LOGICAL_NAME"
+  );
+  const { url } = await uploadFileToS3({
+    bucket: bucketName,
+    contentType: "application/json",
+    key: `${BASE_STACK_BUCKET_TEMPLATES_FOLDER}/${stackName}.json`,
+    file: Buffer.from(JSON.stringify(template, null, 2))
+  });
+  return { url };
+};
+var cloudFormationClients = {};
+var cloudformation = () => {
+  const cloudFormationClientConfig = {
+    apiVersion: "2010-05-15",
+    region: getEnvVar("REGION")
+  };
+  const key = JSON.stringify(cloudFormationClientConfig);
+  if (!cloudFormationClients[key]) {
+    cloudFormationClients[key] = new CloudFormationClient({
+      apiVersion: "2010-05-15",
+      region: getEnvVar("REGION")
+    });
+  }
+  return cloudFormationClients[key];
+};
+var cloudFormationV2 = () => {
+  return new AWS.CloudFormation({ apiVersion: "2010-05-15" });
+};
+var describeStacks = async ({
+  stackName
+} = {}) => {
+  const { Stacks } = await cloudformation().send(
+    new DescribeStacksCommand({ StackName: stackName })
+  );
+  return Stacks;
+};
+var describeStackResource = async (input) => {
+  return cloudformation().send(new DescribeStackResourceCommand(input));
+};
+var doesStackExist = async ({ stackName }) => {
+  log5.info(logPrefix3, `Checking if stack ${stackName} already exists...`);
+  try {
+    await describeStacks({ stackName });
+    log5.info(logPrefix3, `Stack ${stackName} already exists.`);
+    return true;
+  } catch (error) {
+    if (error.Code === "ValidationError") {
+      log5.info(logPrefix3, `Stack ${stackName} does not exist.`);
+      return false;
+    }
+    throw error;
+  }
+};
+var describeStackEvents = async ({
+  stackName
+}) => {
+  log5.error(logPrefix3, "Stack events:");
+  const { StackEvents } = await cloudformation().send(
+    new DescribeStackEventsCommand({ StackName: stackName })
+  );
+  const events = (StackEvents || []).filter(({ Timestamp }) => {
+    return Date.now() - Number(Timestamp) < 10 * 60 * 1e3;
+  }).filter(({ ResourceStatusReason }) => {
+    return ResourceStatusReason;
+  }).reverse();
+  events.forEach(({ LogicalResourceId, ResourceStatusReason }) => {
+    return log5.event(LogicalResourceId, ResourceStatusReason);
+  });
+  return events;
+};
+var describeStack = async ({ stackName }) => {
+  const stacks = await describeStacks({ stackName });
+  if (!stacks) {
+    throw new Error(`Stack ${stackName} not found and cannot be described.`);
+  }
+  return stacks[0];
+};
+var getStackOutput = async ({
+  stackName,
+  outputKey
+}) => {
+  const { Outputs = [] } = await describeStack({ stackName });
+  const output = Outputs?.find(({ OutputKey }) => {
+    return OutputKey === outputKey;
+  });
+  if (!output) {
+    throw new Error(`Output ${outputKey} doesn't exist on ${stackName} stack`);
+  }
+  return output;
+};
+var saveEnvironmentOutput = async ({
+  outputs,
+  stackName
+}) => {
+  const envFile = {
+    stackName,
+    environment: getEnvironment(),
+    projectName: getProjectName(),
+    packageName: getPackageName()
+  };
+  envFile.outputs = outputs.reduce((acc, output) => {
+    if (!output.OutputKey || !output) {
+      return acc;
+    }
+    return {
+      ...acc,
+      [output.OutputKey]: output
+    };
+  }, {});
+  const dotCarlinFolderPath = path.join(process.cwd(), ".carlin");
+  if (!fs3.existsSync(dotCarlinFolderPath)) {
+    await fs3.promises.mkdir(dotCarlinFolderPath);
+  }
+  const filePath = path.join(dotCarlinFolderPath, `${stackName}.json`);
+  await fs3.promises.writeFile(filePath, JSON.stringify(envFile, null, 2));
+  const latestFilePath = path.join(
+    dotCarlinFolderPath,
+    LATEST_DEPLOY_OUTPUTS_FILENAME
+  );
+  await fs3.promises.writeFile(latestFilePath, JSON.stringify(envFile, null, 2));
+};
+var printStackOutputsAfterDeploy = async ({
+  stackName
+}) => {
+  const {
+    EnableTerminationProtection,
+    StackName,
+    Outputs = []
+  } = await describeStack({ stackName });
+  await saveEnvironmentOutput({ stackName, outputs: Outputs });
+  log5.output("Describe Stack");
+  log5.output("StackName", StackName);
+  log5.output("EnableTerminationProtection", EnableTerminationProtection);
+  Outputs.forEach(({ OutputKey, OutputValue, Description, ExportName }) => {
+    log5.output(
+      `${OutputKey}`,
+      [
+        "",
+        `OutputKey: ${OutputKey}`,
+        `OutputValue: ${OutputValue}`,
+        `Description: ${Description}`,
+        `ExportName: ${ExportName}`,
+        ""
+      ].join("\n")
+    );
+  });
+};
+var deleteStack = async ({ stackName }) => {
+  log5.info(logPrefix3, `Deleting stack ${stackName}...`);
+  await cloudformation().send(new DeleteStackCommand({ StackName: stackName }));
+  try {
+    await cloudFormationV2().waitFor("stackDeleteComplete", { StackName: stackName }).promise();
+  } catch (err) {
+    log5.error(logPrefix3, `An error occurred when deleting stack ${stackName}.`);
+    await describeStackEvents({ stackName });
+    throw err;
+  }
+  log5.info(logPrefix3, `Stack ${stackName} deleted.`);
+};
+var createStack = async ({
+  params
+}) => {
+  const { StackName: stackName = "" } = params;
+  log5.info(logPrefix3, `Creating stack ${stackName}...`);
+  await cloudformation().send(new CreateStackCommand(params));
+  try {
+    await cloudFormationV2().waitFor("stackCreateComplete", { StackName: stackName }).promise();
+  } catch (err) {
+    log5.error(logPrefix3, `An error occurred when creating stack ${stackName}.`);
+    await describeStackEvents({ stackName });
+    await deleteStack({ stackName });
+    throw err;
+  }
+  log5.info(logPrefix3, `Stack ${stackName} was created.`);
+};
+var updateStack = async ({
+  params
+}) => {
+  const { StackName: stackName = "" } = params;
+  log5.info(logPrefix3, `Updating stack ${stackName}...`);
+  try {
+    await cloudformation().send(new UpdateStackCommand(params));
+    await cloudFormationV2().waitFor("stackUpdateComplete", { StackName: stackName }).promise();
+  } catch (error) {
+    if (error.message === "No updates are to be performed.") {
+      log5.info(logPrefix3, error.message);
+      return;
+    }
+    log5.error(logPrefix3, "An error occurred when updating stack.");
+    await describeStackEvents({ stackName });
+    throw error;
+  }
+  log5.info(logPrefix3, `Stack ${stackName} was updated.`);
+};
+var enableTerminationProtection = async ({
+  stackName
+}) => {
+  log5.info(logPrefix3, `Enabling termination protection...`);
+  try {
+    await cloudformation().send(
+      new UpdateTerminationProtectionCommand({
+        EnableTerminationProtection: true,
+        StackName: stackName
+      })
+    );
+  } catch (err) {
+    log5.error(
+      logPrefix3,
+      "An error occurred when enabling termination protection"
+    );
+    throw err;
+  }
+};
+var deploy = async ({
+  terminationProtection = false,
+  ...paramsAndTemplate
+}) => {
+  const { params, template } = await addDefaults(paramsAndTemplate);
+  const stackName = params.StackName;
+  if (!stackName) {
+    throw new Error("StackName is required");
+  }
+  delete params.TemplateBody;
+  delete params.TemplateURL;
+  if (isTemplateBodyGreaterThanMaxSize(template)) {
+    const { url } = await uploadTemplateToBaseStackBucket({
+      stackName,
+      template
+    });
+    params.TemplateURL = url;
+  } else {
+    params.TemplateBody = JSON.stringify(template);
+  }
+  params.Capabilities = [
+    "CAPABILITY_AUTO_EXPAND",
+    "CAPABILITY_IAM",
+    "CAPABILITY_NAMED_IAM"
+  ];
+  if (await doesStackExist({ stackName })) {
+    await updateStack({ params });
+  } else {
+    await createStack({ params });
+  }
+  if (terminationProtection || !!getEnvironment()) {
+    await enableTerminationProtection({ stackName });
+  }
+  await printStackOutputsAfterDeploy({ stackName });
+  return describeStack({ stackName });
+};
+var canDestroyStack = async ({ stackName }) => {
+  const { EnableTerminationProtection } = await describeStack({ stackName });
+  if (EnableTerminationProtection) {
+    return false;
+  }
+  return true;
+};
+var validateTemplate = async ({
+  stackName,
+  template
+}) => {
+  const validateTemplateCommandInput = {};
+  if (isTemplateBodyGreaterThanMaxSize(template)) {
+    const { url } = await uploadTemplateToBaseStackBucket({
+      stackName,
+      template
+    });
+    validateTemplateCommandInput.TemplateURL = url;
+  } else {
+    validateTemplateCommandInput.TemplateBody = JSON.stringify(template);
+  }
+  await cloudformation().send(
+    new ValidateTemplateCommand(validateTemplateCommandInput)
+  );
+};
+
+// src/deploy/baseStack/getBucketTemplate.ts
+var getBucketTemplate = () => {
+  return {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Resources: {
+      [BASE_STACK_BUCKET_LOGICAL_NAME]: {
+        Type: "AWS::S3::Bucket",
+        DeletionPolicy: "Retain",
+        Properties: {
+          LifecycleConfiguration: {
+            Rules: [
+              {
+                ExpirationInDays: 1,
+                Prefix: BASE_STACK_BUCKET_TEMPLATES_FOLDER,
+                Status: "Enabled"
+              },
+              {
+                NoncurrentVersionExpirationInDays: 3,
+                Status: "Enabled"
+              }
+            ]
+          },
+          /**
+           * This is necessary because if we update Lambda code without change
+           * CloudFormation template, the Lambda will not be updated.
+           */
+          VersioningConfiguration: {
+            Status: "Enabled"
+          }
+        }
+      }
+    },
+    Outputs: {
+      [BASE_STACK_BUCKET_LOGICAL_NAME]: {
+        Value: { Ref: BASE_STACK_BUCKET_LOGICAL_NAME },
+        Export: {
+          Name: BASE_STACK_BUCKET_NAME_EXPORTED_NAME
+        }
+      }
+    }
+  };
+};
+var getLambdaImageBuilderTemplate = () => {
+  const CODE_BUILD_PROJECT_LOGS_LOGICAL_ID2 = "CodeBuildProjectLogsLogGroup";
+  const CODE_BUILD_PROJECT_SERVICE_ROLE_LOGICAL_ID2 = "ImageCodeBuildProjectIAMRole";
+  return {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Resources: {
+      [CODE_BUILD_PROJECT_LOGS_LOGICAL_ID2]: {
+        Type: "AWS::Logs::LogGroup",
+        DeletionPolicy: "Delete",
+        Properties: {}
+      },
+      [CODE_BUILD_PROJECT_SERVICE_ROLE_LOGICAL_ID2]: {
+        Type: "AWS::IAM::Role",
+        Properties: {
+          AssumeRolePolicyDocument: {
+            Version: "2012-10-17",
+            Statement: [
+              {
+                Effect: "Allow",
+                Principal: {
+                  Service: "codebuild.amazonaws.com"
+                },
+                Action: "sts:AssumeRole"
+              }
+            ]
+          },
+          Path: getIamPath(),
+          Policies: [
+            {
+              PolicyName: `${CODE_BUILD_PROJECT_SERVICE_ROLE_LOGICAL_ID2}Policy`,
+              PolicyDocument: {
+                Version: "2012-10-17",
+                Statement: [
+                  {
+                    Effect: "Allow",
+                    Action: ["logs:CreateLogStream", "logs:PutLogEvents"],
+                    Resource: "*"
+                  },
+                  {
+                    Effect: "Allow",
+                    Action: ["ecr:GetAuthorizationToken"],
+                    Resource: "*"
+                  },
+                  {
+                    Effect: "Allow",
+                    Action: [
+                      "ecr:BatchCheckLayerAvailability",
+                      "ecr:CompleteLayerUpload",
+                      "ecr:InitiateLayerUpload",
+                      "ecr:PutImage",
+                      "ecr:UploadLayerPart"
+                    ],
+                    Resource: "*"
+                  },
+                  {
+                    Effect: "Allow",
+                    Action: "s3:GetObject",
+                    Resource: [
+                      {
+                        "Fn::Sub": [
+                          // eslint-disable-next-line no-template-curly-in-string
+                          "arn:aws:s3:::${BucketName}/*",
+                          {
+                            BucketName: {
+                              Ref: BASE_STACK_BUCKET_LOGICAL_NAME
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      },
+      [BASE_STACK_LAMBDA_IMAGE_BUILDER_LOGICAL_NAME]: {
+        Type: "AWS::CodeBuild::Project",
+        Properties: {
+          Artifacts: {
+            Type: "NO_ARTIFACTS"
+          },
+          Cache: {
+            Location: "LOCAL",
+            Modes: ["LOCAL_DOCKER_LAYER_CACHE"],
+            Type: "LOCAL"
+          },
+          Description: "Create Lambda image.",
+          Environment: {
+            ComputeType: "BUILD_GENERAL1_SMALL",
+            EnvironmentVariables: [
+              {
+                Name: "AWS_ACCOUNT_ID",
+                Value: { Ref: "AWS::AccountId" }
+              },
+              {
+                Name: "AWS_REGION",
+                Value: { Ref: "AWS::Region" }
+              },
+              {
+                Name: "IMAGE_TAG",
+                Value: "latest"
+              },
+              {
+                Name: "LAMBDA_EXTERNALS",
+                Value: ""
+              }
+            ],
+            Image: "aws/codebuild/standard:3.0",
+            ImagePullCredentialsType: "CODEBUILD",
+            PrivilegedMode: true,
+            Type: "LINUX_CONTAINER"
+          },
+          LogsConfig: {
+            CloudWatchLogs: {
+              Status: "ENABLED",
+              GroupName: { Ref: CODE_BUILD_PROJECT_LOGS_LOGICAL_ID2 }
+            }
+          },
+          ServiceRole: {
+            "Fn::GetAtt": [CODE_BUILD_PROJECT_SERVICE_ROLE_LOGICAL_ID2, "Arn"]
+          },
+          Source: {
+            BuildSpec: yaml4.dump({
+              version: "0.2",
+              phases: {
+                install: {
+                  commands: [
+                    "echo install started on `date`",
+                    "npm init -y",
+                    /**
+                     * https://stackoverflow.com/a/51433146/8786986
+                     */
+                    "npm install --save --package-lock-only --no-package-lock $LAMBDA_EXTERNALS",
+                    "ls"
+                  ]
+                },
+                pre_build: {
+                  commands: [
+                    "echo pre_build started on `date`",
+                    "$(aws ecr get-login --no-include-email --region $AWS_REGION)"
+                  ]
+                },
+                build: {
+                  commands: [
+                    "echo build started on `date`",
+                    "echo Building the repository image...",
+                    'echo "$DOCKERFILE" > Dockerfile',
+                    "docker build -t $REPOSITORY_ECR_REPOSITORY:$IMAGE_TAG -f Dockerfile .",
+                    "docker tag $REPOSITORY_ECR_REPOSITORY:$IMAGE_TAG $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$REPOSITORY_ECR_REPOSITORY:$IMAGE_TAG"
+                  ]
+                },
+                post_build: {
+                  commands: [
+                    "echo post_build completed on `date`",
+                    "echo Pushing the repository image...",
+                    "docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$REPOSITORY_ECR_REPOSITORY:$IMAGE_TAG"
+                  ]
+                }
+              }
+            }),
+            Type: "NO_SOURCE"
+          },
+          TimeoutInMinutes: 60
+        }
+      }
+    },
+    Outputs: {
+      [BASE_STACK_LAMBDA_IMAGE_BUILDER_LOGICAL_NAME]: {
+        Value: { Ref: BASE_STACK_LAMBDA_IMAGE_BUILDER_LOGICAL_NAME },
+        Export: {
+          Name: BASE_STACK_LAMBDA_IMAGE_BUILDER_EXPORTED_NAME
+        }
+      }
+    }
+  };
+};
+
+// src/deploy/baseStack/getLambdaLayerBuilderTemplate.ts
+var CODE_BUILD_PROJECT_LOGS_GROUP_LOGICAL_ID = `${BASE_STACK_LAMBDA_LAYER_BUILDER_LOGICAL_NAME}LogsLogGroup`;
+var CODE_BUILD_PROJECT_IAM_ROLE_LOGICAL_ID = `${BASE_STACK_LAMBDA_LAYER_BUILDER_LOGICAL_NAME}Role`;
+var getBuildSpec = () => {
+  return `
+version: 0.2
+phases:
+  install:
+    runtime-versions:
+      nodejs: ${NODE_VERSION}
+    commands:
+      - npm i --no-bin-links --no-optional --no-package-lock --no-save --no-shrinkwrap $PACKAGE_NAME
+      - mkdir nodejs
+      - mv node_modules nodejs/node_modules
+artifacts:
+  files:
+    - nodejs/**/*
+  name: $PACKAGE_NAME.zip
+`.trim();
+};
+var getLambdaLayerBuilderTemplate = () => {
+  return {
+    Resources: {
+      [CODE_BUILD_PROJECT_IAM_ROLE_LOGICAL_ID]: {
+        Type: "AWS::IAM::Role",
+        Properties: {
+          AssumeRolePolicyDocument: {
+            Version: "2012-10-17",
+            Statement: [
+              {
+                Effect: "Allow",
+                Principal: {
+                  Service: ["codebuild.amazonaws.com"]
+                },
+                Action: ["sts:AssumeRole"]
+              }
+            ]
+          },
+          Path: getIamPath(),
+          Policies: [
+            {
+              PolicyName: `${CODE_BUILD_PROJECT_IAM_ROLE_LOGICAL_ID}Policy`,
+              PolicyDocument: {
+                Version: "2012-10-17",
+                Statement: [
+                  {
+                    Effect: "Allow",
+                    Action: ["logs:CreateLogStream", "logs:PutLogEvents"],
+                    Resource: "*"
+                  },
+                  {
+                    Effect: "Allow",
+                    Action: ["s3:*"],
+                    Resource: [
+                      {
+                        "Fn::Sub": [
+                          // eslint-disable-next-line no-template-curly-in-string
+                          "arn:aws:s3:::${BucketName}",
+                          {
+                            BucketName: {
+                              Ref: BASE_STACK_BUCKET_LOGICAL_NAME
+                            }
+                          }
+                        ]
+                      },
+                      {
+                        "Fn::Sub": [
+                          // eslint-disable-next-line no-template-curly-in-string
+                          "arn:aws:s3:::${BucketName}/*",
+                          {
+                            BucketName: {
+                              Ref: BASE_STACK_BUCKET_LOGICAL_NAME
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      },
+      [CODE_BUILD_PROJECT_LOGS_GROUP_LOGICAL_ID]: {
+        Type: "AWS::Logs::LogGroup",
+        DeletionPolicy: "Delete",
+        Properties: {}
+      },
+      [BASE_STACK_LAMBDA_LAYER_BUILDER_LOGICAL_NAME]: {
+        Type: "AWS::CodeBuild::Project",
+        Properties: {
+          Artifacts: {
+            Location: { Ref: BASE_STACK_BUCKET_LOGICAL_NAME },
+            NamespaceType: "NONE",
+            OverrideArtifactName: true,
+            Packaging: "ZIP",
+            Path: "lambda-layers/packages",
+            Type: "S3"
+          },
+          Environment: {
+            ComputeType: "BUILD_GENERAL1_SMALL",
+            /**
+             * Image should match the runtime of the buildspec.
+             * https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html
+             */
+            Image: "aws/codebuild/standard:7.0",
+            Type: "LINUX_CONTAINER"
+          },
+          LogsConfig: {
+            CloudWatchLogs: {
+              GroupName: {
+                Ref: `${CODE_BUILD_PROJECT_LOGS_GROUP_LOGICAL_ID}`
+              },
+              Status: "ENABLED"
+            }
+          },
+          ServiceRole: {
+            "Fn::GetAtt": `${CODE_BUILD_PROJECT_IAM_ROLE_LOGICAL_ID}.Arn`
+          },
+          Source: {
+            BuildSpec: getBuildSpec(),
+            Type: "NO_SOURCE"
+          }
+        }
+      }
+    },
+    Outputs: {
+      [BASE_STACK_LAMBDA_LAYER_BUILDER_LOGICAL_NAME]: {
+        Value: { Ref: BASE_STACK_LAMBDA_LAYER_BUILDER_LOGICAL_NAME }
+      }
+    }
+  };
+};
+var getVpcTemplate = () => {
+  const vpcName = `${pascalCase(NAME)}VPC`;
+  const EC2_INTERNET_GATEWAY_LOGICAL_ID = "EC2InternetGateway";
+  const EC2_ROUTE_TABLE_LOGICAL_ID = "EC2RouteTable";
+  const EC2_VPC_LOGICAL_ID = "EC2VCP";
+  const template = {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Mappings: {
+      CidrMappings: {
+        VPC: {
+          CIDR: "10.0.0.0/16"
+        }
+      }
+    },
+    Resources: {
+      [EC2_VPC_LOGICAL_ID]: {
+        Type: "AWS::EC2::VPC",
+        Properties: {
+          CidrBlock: {
+            "Fn::FindInMap": ["CidrMappings", "VPC", "CIDR"]
+          },
+          EnableDnsHostnames: true,
+          EnableDnsSupport: true,
+          Tags: [
+            {
+              Key: "Name",
+              Value: vpcName
+            }
+          ]
+        }
+      },
+      [EC2_INTERNET_GATEWAY_LOGICAL_ID]: {
+        Type: "AWS::EC2::InternetGateway",
+        Properties: {}
+      },
+      EC2VPCGatewayAttachment: {
+        Type: "AWS::EC2::VPCGatewayAttachment",
+        Properties: {
+          InternetGatewayId: {
+            Ref: EC2_INTERNET_GATEWAY_LOGICAL_ID
+          },
+          VpcId: {
+            Ref: EC2_VPC_LOGICAL_ID
+          }
+        }
+      },
+      [EC2_ROUTE_TABLE_LOGICAL_ID]: {
+        Type: "AWS::EC2::RouteTable",
+        Properties: {
+          Tags: [
+            {
+              Key: "Name",
+              Value: {
+                "Fn::Join": [" ", [vpcName, "-", EC2_ROUTE_TABLE_LOGICAL_ID]]
+              }
+            }
+          ],
+          VpcId: {
+            Ref: EC2_VPC_LOGICAL_ID
+          }
+        }
+      },
+      EC2Route: {
+        Type: "AWS::EC2::Route",
+        Properties: {
+          DestinationCidrBlock: "0.0.0.0/0",
+          GatewayId: {
+            Ref: EC2_INTERNET_GATEWAY_LOGICAL_ID
+          },
+          RouteTableId: {
+            Ref: EC2_ROUTE_TABLE_LOGICAL_ID
+          }
+        }
+      }
+    },
+    Outputs: {
+      VPCId: {
+        Value: {
+          Ref: EC2_VPC_LOGICAL_ID
+        },
+        Export: {
+          Name: BASE_STACK_VPC_ID_EXPORTED_NAME
+        }
+      },
+      VPCDefaultSecurityGroup: {
+        Value: {
+          "Fn::GetAtt": [EC2_VPC_LOGICAL_ID, "DefaultSecurityGroup"]
+        },
+        Export: {
+          Name: BASE_STACK_VPC_DEFAULT_SECURITY_GROUP_EXPORTED_NAME
+        }
+      }
+    }
+  };
+  [
+    BASE_STACK_VPC_PUBLIC_SUBNET_0_EXPORTED_NAME,
+    BASE_STACK_VPC_PUBLIC_SUBNET_1_EXPORTED_NAME,
+    BASE_STACK_VPC_PUBLIC_SUBNET_2_EXPORTED_NAME
+  ].forEach((publicSubnetExportedName, index) => {
+    const publicSubnetLogicalId = `PublicSubnet${index}EC2Subnet`;
+    const publicSubnetCidrMappings = `PublicSubnet${index}`;
+    template.Mappings.CidrMappings[publicSubnetCidrMappings] = {
+      CIDR: `10.0.${index}.0/24`
+    };
+    template.Resources[publicSubnetLogicalId] = {
+      Type: "AWS::EC2::Subnet",
+      Properties: {
+        AvailabilityZone: {
+          "Fn::Select": [
+            index,
+            {
+              "Fn::GetAZs": {
+                Ref: "AWS::Region"
+              }
+            }
+          ]
+        },
+        CidrBlock: {
+          "Fn::FindInMap": ["CidrMappings", publicSubnetCidrMappings, "CIDR"]
+        },
+        MapPublicIpOnLaunch: true,
+        Tags: [
+          {
+            Key: "Name",
+            Value: {
+              "Fn::Join": [
+                " ",
+                [EC2_VPC_LOGICAL_ID, "-", publicSubnetLogicalId]
+              ]
+            }
+          }
+        ],
+        VpcId: {
+          Ref: EC2_VPC_LOGICAL_ID
+        }
+      }
+    };
+    template.Resources[`PublicSubnet${index}EC2SubnetRouteTableAssociation`] = {
+      Type: "AWS::EC2::SubnetRouteTableAssociation",
+      Properties: {
+        RouteTableId: {
+          Ref: EC2_ROUTE_TABLE_LOGICAL_ID
+        },
+        SubnetId: {
+          Ref: publicSubnetLogicalId
+        }
+      }
+    };
+    if (!template.Outputs) {
+      template.Outputs = {};
+    }
+    template.Outputs[publicSubnetLogicalId] = {
+      Value: {
+        Ref: publicSubnetLogicalId
+      },
+      Export: {
+        Name: publicSubnetExportedName
+      }
+    };
+  });
+  return template;
+};
+var setPreDefinedStackName = (stackName) => {
+  setEnvVar("STACK_NAME", stackName);
+};
+var STACK_NAME_MAX_LENGTH = 100;
+var limitStackName = (stackName) => {
+  return `${stackName}`.substring(0, STACK_NAME_MAX_LENGTH);
+};
+var getStackName = async () => {
+  if (getEnvVar("STACK_NAME")) {
+    return getEnvVar("STACK_NAME");
+  }
+  const [currentBranch, environment, packageName] = await Promise.all([
+    getCurrentBranch(),
+    getEnvironment(),
+    getPackageName()
+  ]);
+  const firstName = packageName ? pascalCase(packageName) : `Stack-${Math.round(Math.random() * 1e5)}`;
+  const secondName = (() => {
+    if (environment) {
+      return environment;
+    }
+    if (currentBranch) {
+      return kebabCase(currentBranch);
+    }
+    return void 0;
+  })();
+  const name = [firstName, secondName].filter((word) => {
+    return !!word;
+  }).join("-");
+  return limitStackName(name);
+};
+var deployErrorLogs = ({
+  error,
+  logPrefix: logPrefix22
+}) => {
+  log5.error(logPrefix22, `An error occurred. Cannot deploy ${logPrefix22}.`);
+  log5.error(logPrefix22, "Error message: %j", error?.message);
+};
+var handleDeployError = ({
+  error,
+  logPrefix: logPrefix22
+}) => {
+  deployErrorLogs({ error, logPrefix: logPrefix22 });
+  process.exit(1);
+};
+var handleDeployInitialization = async ({
+  logPrefix: logPrefix22,
+  stackName: preDefinedStackName
+}) => {
+  log5.info(logPrefix22, `Starting deploy ${logPrefix22}...`);
+  if (preDefinedStackName) {
+    setPreDefinedStackName(preDefinedStackName);
+  }
+  const stackName = await getStackName();
+  log5.info(logPrefix22, `stackName: ${stackName}`);
+  return { stackName };
+};
+var logPrefix4 = "base-stack";
+var baseStackTemplate = deepmerge.all([
+  getBucketTemplate(),
+  getLambdaImageBuilderTemplate(),
+  getLambdaLayerBuilderTemplate(),
+  getVpcTemplate()
+]);
+var deployBaseStack = async () => {
+  try {
+    const { stackName } = await handleDeployInitialization({
+      logPrefix: logPrefix4,
+      stackName: BASE_STACK_NAME
+    });
+    await deploy({
+      template: baseStackTemplate,
+      params: { StackName: stackName },
+      terminationProtection: true
+    });
+  } catch (error) {
+    handleDeployError({ error, logPrefix: logPrefix4 });
+  }
+};
+
+// src/deploy/baseStack/command.ts
+var deployBaseStackCommand = {
+  command: "base-stack",
+  describe: "Create base resources.",
+  handler: deployBaseStack
+};
+
+// src/deploy/cicd/config.ts
+var ECS_TASK_DEFAULT_CPU = "2048";
+var ECS_TASK_DEFAULT_MEMORY = "4096";
+var PIPELINE_ECS_TASK_EXECUTION_STAGE_NAME = `PipelineRunECSTasksStage`;
+var PIPELINE_ECS_TASK_EXECUTION_MANUAL_APPROVAL_ACTION_NAME = `PipelineRunECSTasksApproval`;
+
+// src/deploy/cicd/pipelines.ts
+var pipelines = ["pr", "main", "tag"];
+var options = {
+  cpu: {
+    type: "string"
+  },
+  memory: {
+    type: "string"
+  },
+  pipelines: {
+    choices: pipelines,
+    coerce: (values) => {
+      return values.map((value) => {
+        return camelCase(value);
+      });
+    },
+    default: [],
+    description: "Pipelines that will be implemented with the CICD stack.",
+    type: "array"
+  },
+  "update-repository": {
+    alias: ["ur"],
+    description: "Determine if the repository image will be updated.",
+    default: true,
+    type: "boolean"
+  },
+  "ssh-key": {
+    demandOption: true,
+    type: "string"
+  },
+  "ssh-url": {
+    demandOption: true,
+    type: "string"
+  },
+  "slack-webhook-url": {
+    type: "string"
+  },
+  /**
+   * This option has the format:
+   *
+   * ```ts
+   * Array<{
+   *  name: string,
+   *  value: string,
+   * }>
+   * ```
+   */
+  "task-environment": {
+    alias: ["te"],
+    default: [],
+    describe: "A list of environment variables that will be passed to the ECS container task.",
+    type: "array"
+  }
+};
+var getCicdConfig = () => {
+  const { parsed } = yargs(hideBin(process.argv)).config();
+  if (!parsed) {
+    return false;
+  }
+  const { argv } = parsed;
+  const config = Object.keys(options).reduce((acc, key) => {
+    const value = argv[key];
+    if (value) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+  return config;
+};
+
+// src/deploy/cicd/getTriggerPipelineObjectKey.ts
+var getTriggerPipelinesObjectKey = ({
+  prefix,
+  pipeline
+}) => {
+  return `${prefix}/${pipeline}.zip`;
+};
+var API_LOGICAL_ID = "ApiV1ServerlessApi";
+var CODE_BUILD_PROJECT_LOGS_LOGICAL_ID = "RepositoryImageCodeBuildProjectLogsLogGroup";
+var CODE_BUILD_PROJECT_SERVICE_ROLE_LOGICAL_ID = "RepositoryImageCodeBuildProjectIAMRole";
+var ECR_REPOSITORY_LOGICAL_ID = "RepositoryECRRepository";
+var FUNCTION_IAM_ROLE_LOGICAL_ID = "ApiV1ServerlessFunctionIAMRole";
+var ECS_TASK_REPORT_HANDLER_LAMBDA_FUNCTION_LOGICAL_ID = "EcsTaskReportHandler";
+var PROCESS_ENV_REPOSITORY_IMAGE_CODE_BUILD_PROJECT_NAME = "REPOSITORY_IMAGE_CODE_BUILD_PROJECT_NAME";
+var REPOSITORY_ECS_TASK_CONTAINER_NAME = "RepositoryECSTaskContainerName";
+var REPOSITORY_ECS_TASK_DEFINITION_LOGICAL_ID = "RepositoryECSTaskDefinition";
+var REPOSITORY_IMAGE_CODE_BUILD_PROJECT_LOGICAL_ID = "RepositoryImageCodeBuildProject";
+var REPOSITORY_TASKS_ECS_CLUSTER_LOGICAL_ID = "RepositoryTasksECSCluster";
+var REPOSITORY_TASKS_ECS_CLUSTER_LOGS_LOG_GROUP_LOGICAL_ID = "RepositoryTasksECSClusterLogsLogGroup";
+var REPOSITORY_TASKS_ECS_TASK_DEFINITION_EXECUTION_ROLE_LOGICAL_ID = "RepositoryTasksECSTaskDefinitionExecutionRoleIAMRole";
+var REPOSITORY_TASKS_ECS_TASK_DEFINITION_TASK_ROLE_LOGICAL_ID = "RepositoryTasksECSTaskDefinitionTaskRoleIAMRole";
+var PIPELINES_ARTIFACT_STORE_S3_BUCKET_LOGICAL_ID = "PipelinesArtifactStoreS3Bucket";
+var PIPELINES_ROLE_LOGICAL_ID = "PipelinesMainIAMRole";
+var PIPELINES_MAIN_LOGICAL_ID = "PipelinesMainCodePipeline";
+var PIPELINES_TAG_LOGICAL_ID = "PipelinesTagCodePipeline";
+var PIPELINES_HANDLER_LAMBDA_FUNCTION_LOGICAL_ID = "PipelinesHandlerLambdaFunction";
+var IMAGE_UPDATER_SCHEDULE_SERVERLESS_FUNCTION_LOGICAL_ID = "ImageUpdaterScheduleServerlessFunction";
+var getRepositoryImageBuilder = () => {
+  const nodeRuntimeNumber = NODE_RUNTIME.replace("nodejs", "").replace(
+    ".x",
+    ""
+  );
+  return {
+    Type: "AWS::CodeBuild::Project",
+    Properties: {
+      Artifacts: {
+        Type: "NO_ARTIFACTS"
+      },
+      Cache: {
+        Location: "LOCAL",
+        Modes: ["LOCAL_DOCKER_LAYER_CACHE"],
+        Type: "LOCAL"
+      },
+      Description: "Create repository image.",
+      Environment: {
+        ComputeType: "BUILD_GENERAL1_SMALL",
+        EnvironmentVariables: [
+          {
+            Name: "AWS_ACCOUNT_ID",
+            Value: { Ref: "AWS::AccountId" }
+          },
+          {
+            Name: "AWS_REGION",
+            Value: { Ref: "AWS::Region" }
+          },
+          {
+            Name: "DOCKERFILE",
+            Value: {
+              "Fn::Sub": [
+                "FROM public.ecr.aws/ubuntu/ubuntu:20.04_stable",
+                // https://stackoverflow.com/a/59693182/8786986
+                "ENV DEBIAN_FRONTEND noninteractive",
+                // Make sure apt is up to date
+                "RUN apt-get update --fix-missing",
+                "RUN apt-get install -y curl",
+                "RUN apt-get install -y git",
+                "RUN apt-get install -y jq",
+                // Install Node.js
+                `RUN curl -fsSL https://deb.nodesource.com/setup_${nodeRuntimeNumber}.x | bash -`,
+                "RUN apt-get install -y nodejs",
+                // Clean cache
+                "RUN apt-get clean",
+                // Install Yarn
+                "RUN npm install -g yarn",
+                // Install carlin CLI
+                "RUN yarn global add carlin",
+                // Configure git
+                "RUN git config --global user.name carlin",
+                "RUN git config --global user.email carlin@ttoss.dev",
+                "RUN mkdir /root/.ssh/",
+                "COPY ./id_rsa /root/.ssh/id_rsa",
+                "RUN chmod 600 /root/.ssh/id_rsa",
+                // Make sure your domain is accepted
+                "RUN touch /root/.ssh/known_hosts",
+                "RUN ssh-keyscan github.com >> /root/.ssh/known_hosts",
+                // Copy repository
+                "COPY . /home",
+                // Go to repository directory
+                "WORKDIR /home/repository",
+                // Set Yarn cache
+                "RUN mkdir -p /home/yarn-cache",
+                "RUN yarn config set cache-folder /home/yarn-cache",
+                "RUN yarn install",
+                // Used in case of yarn.lock is modified.
+                "RUN git checkout -- yarn.lock"
+              ].join("\n")
+            }
+          },
+          {
+            Name: "IMAGE_TAG",
+            Value: "latest"
+          },
+          {
+            Name: "REPOSITORY_ECR_REPOSITORY",
+            Value: { Ref: ECR_REPOSITORY_LOGICAL_ID }
+          },
+          {
+            Name: "SSH_KEY",
+            Value: { Ref: "SSHKey" }
+          },
+          {
+            Name: "SSH_URL",
+            Value: { Ref: "SSHUrl" }
+          }
+        ],
+        Image: "aws/codebuild/standard:3.0",
+        ImagePullCredentialsType: "CODEBUILD",
+        /**
+         * Enables running the Docker daemon inside a Docker container. Set to
+         * true only if the build project is used to build Docker images.
+         * Otherwise, a build that attempts to interact with the Docker daemon
+         * fails. The default setting is false."
+         * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-environment.html#cfn-codebuild-project-environment-privilegedmode
+         */
+        PrivilegedMode: true,
+        Type: "LINUX_CONTAINER"
+      },
+      LogsConfig: {
+        CloudWatchLogs: {
+          Status: "ENABLED",
+          GroupName: { Ref: CODE_BUILD_PROJECT_LOGS_LOGICAL_ID }
+        }
+      },
+      ServiceRole: {
+        "Fn::GetAtt": [CODE_BUILD_PROJECT_SERVICE_ROLE_LOGICAL_ID, "Arn"]
+      },
+      Source: {
+        BuildSpec: yaml4.dump({
+          version: "0.2",
+          phases: {
+            install: {
+              commands: [
+                "echo install started on `date`",
+                `echo "$SSH_KEY" > ~/.ssh/id_rsa`,
+                "chmod 600 ~/.ssh/id_rsa",
+                "rm -rf repository",
+                "git clone $SSH_URL repository",
+                "cd repository",
+                "ls"
+              ]
+            },
+            pre_build: {
+              commands: ["echo pre_build started on `date`"]
+            },
+            build: {
+              commands: [
+                "echo build started on `date`",
+                "$(aws ecr get-login --no-include-email --region $AWS_REGION)",
+                "echo Building the repository image...",
+                "cd ../",
+                "cp ~/.ssh/id_rsa .",
+                'echo "$DOCKERFILE" > Dockerfile',
+                "cat Dockerfile",
+                "docker build -t $REPOSITORY_ECR_REPOSITORY:$IMAGE_TAG -f Dockerfile .",
+                "docker tag $REPOSITORY_ECR_REPOSITORY:$IMAGE_TAG $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$REPOSITORY_ECR_REPOSITORY:$IMAGE_TAG",
+                "echo Pushing the repository image...",
+                "docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$REPOSITORY_ECR_REPOSITORY:$IMAGE_TAG"
+              ]
+            },
+            post_build: {
+              commands: ["echo post_build completed on `date`"]
+            }
+          }
+        }),
+        Type: "NO_SOURCE"
+      },
+      TimeoutInMinutes: 15
+    }
+  };
+};
+var triggerPipelinesObjectKeyPrefix = [
+  "cicd",
+  "pipelines",
+  "triggers",
+  getProjectName()
+].join("/");
+var getCicdTemplate = ({
+  pipelines: pipelines2 = [],
+  cpu = ECS_TASK_DEFAULT_CPU,
+  memory = ECS_TASK_DEFAULT_MEMORY,
+  s3: s32,
+  slackWebhookUrl,
+  taskEnvironment = []
+}) => {
+  const resources2 = {};
+  const executeEcsTaskVariables = {
+    ECS_CLUSTER_ARN: {
+      "Fn::GetAtt": [REPOSITORY_TASKS_ECS_CLUSTER_LOGICAL_ID, "Arn"]
+    },
+    ECS_CONTAINER_NAME: REPOSITORY_ECS_TASK_CONTAINER_NAME,
+    ECS_TASK_DEFINITION: {
+      Ref: REPOSITORY_ECS_TASK_DEFINITION_LOGICAL_ID
+    },
+    VPC_SECURITY_GROUP: {
+      "Fn::ImportValue": BASE_STACK_VPC_DEFAULT_SECURITY_GROUP_EXPORTED_NAME
+    },
+    VPC_PUBLIC_SUBNET_0: {
+      "Fn::ImportValue": BASE_STACK_VPC_PUBLIC_SUBNET_0_EXPORTED_NAME
+    },
+    VPC_PUBLIC_SUBNET_1: {
+      "Fn::ImportValue": BASE_STACK_VPC_PUBLIC_SUBNET_1_EXPORTED_NAME
+    },
+    VPC_PUBLIC_SUBNET_2: {
+      "Fn::ImportValue": BASE_STACK_VPC_PUBLIC_SUBNET_2_EXPORTED_NAME
+    },
+    ECS_TASK_REPORT_HANDLER_NAME: {
+      Ref: ECS_TASK_REPORT_HANDLER_LAMBDA_FUNCTION_LOGICAL_ID
+    }
+  };
+  const getEcrRepositoryResource = () => {
+    return {
+      Type: "AWS::ECR::Repository",
+      Properties: {
+        LifecyclePolicy: {
+          LifecyclePolicyText: JSON.stringify(
+            {
+              rules: [
+                {
+                  rulePriority: 1,
+                  description: "Only keep the latest image",
+                  selection: {
+                    tagStatus: "any",
+                    countType: "imageCountMoreThan",
+                    countNumber: 1
+                  },
+                  action: {
+                    type: "expire"
+                  }
+                }
+              ]
+            },
+            null,
+            2
+          )
+        }
+      }
+    };
+  };
+  resources2[ECR_REPOSITORY_LOGICAL_ID] = getEcrRepositoryResource();
+  const commonFunctionProperties = {
+    CodeUri: {
+      Bucket: s32.bucket,
+      Key: s32.key,
+      Version: s32.versionId
+    },
+    Role: {
+      "Fn::GetAtt": [FUNCTION_IAM_ROLE_LOGICAL_ID, "Arn"]
+    },
+    Runtime: NODE_RUNTIME,
+    Timeout: 60
+  };
+  (() => {
+    resources2[CODE_BUILD_PROJECT_LOGS_LOGICAL_ID] = {
+      Type: "AWS::Logs::LogGroup",
+      DeletionPolicy: "Delete",
+      Properties: {}
+    };
+    resources2[CODE_BUILD_PROJECT_SERVICE_ROLE_LOGICAL_ID] = {
+      Type: "AWS::IAM::Role",
+      Properties: {
+        AssumeRolePolicyDocument: {
+          Version: "2012-10-17",
+          Statement: [
+            {
+              Effect: "Allow",
+              Principal: {
+                Service: "codebuild.amazonaws.com"
+              },
+              Action: "sts:AssumeRole"
+            }
+          ]
+        },
+        Path: getIamPath(),
+        Policies: [
+          {
+            PolicyName: `${CODE_BUILD_PROJECT_SERVICE_ROLE_LOGICAL_ID}Policy`,
+            PolicyDocument: {
+              Version: "2012-10-17",
+              Statement: [
+                {
+                  Effect: "Allow",
+                  Action: ["logs:CreateLogStream", "logs:PutLogEvents"],
+                  Resource: "*"
+                },
+                {
+                  Effect: "Allow",
+                  Action: ["ecr:GetAuthorizationToken"],
+                  Resource: "*"
+                },
+                {
+                  Effect: "Allow",
+                  Action: [
+                    "ecr:BatchCheckLayerAvailability",
+                    "ecr:CompleteLayerUpload",
+                    "ecr:InitiateLayerUpload",
+                    "ecr:PutImage",
+                    "ecr:UploadLayerPart"
+                  ],
+                  Resource: {
+                    "Fn::GetAtt": [ECR_REPOSITORY_LOGICAL_ID, "Arn"]
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    };
+    resources2[REPOSITORY_IMAGE_CODE_BUILD_PROJECT_LOGICAL_ID] = getRepositoryImageBuilder();
+    const cicdConfig = {
+      ...getCicdConfig(),
+      "ssh-key": "/root/.ssh/id_rsa",
+      environment: getEnvironment()
+    };
+    resources2[IMAGE_UPDATER_SCHEDULE_SERVERLESS_FUNCTION_LOGICAL_ID] = {
+      Type: "AWS::Serverless::Function",
+      Properties: {
+        ...commonFunctionProperties,
+        Events: {
+          Schedule: {
+            Type: "Schedule",
+            Properties: {
+              Schedule: "rate(7 days)"
+            }
+          }
+        },
+        Environment: {
+          Variables: {
+            [PROCESS_ENV_REPOSITORY_IMAGE_CODE_BUILD_PROJECT_NAME]: {
+              Ref: REPOSITORY_IMAGE_CODE_BUILD_PROJECT_LOGICAL_ID
+            },
+            CICD_CONFIG: JSON.stringify(cicdConfig),
+            ...executeEcsTaskVariables
+          }
+        },
+        Handler: "index.imageUpdaterScheduleHandler"
+      }
+    };
+  })();
+  const createApiResources = () => {
+    resources2[API_LOGICAL_ID] = {
+      Type: "AWS::Serverless::Api",
+      Properties: {
+        Auth: {
+          ApiKeyRequired: false
+        },
+        StageName: "v1"
+      }
+    };
+    resources2[FUNCTION_IAM_ROLE_LOGICAL_ID] = {
+      Type: "AWS::IAM::Role",
+      Properties: {
+        AssumeRolePolicyDocument: {
+          Version: "2012-10-17",
+          Statement: [
+            {
+              Effect: "Allow",
+              Principal: {
+                Service: "lambda.amazonaws.com"
+              },
+              Action: ["sts:AssumeRole"]
+            }
+          ]
+        },
+        ManagedPolicyArns: [
+          "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
+        ],
+        Path: getIamPath(),
+        Policies: [
+          {
+            PolicyName: `${FUNCTION_IAM_ROLE_LOGICAL_ID}Policy`,
+            PolicyDocument: {
+              Version: "2012-10-17",
+              Statement: [
+                {
+                  Effect: "Allow",
+                  Action: ["codebuild:StartBuild"],
+                  Resource: {
+                    "Fn::GetAtt": [
+                      REPOSITORY_IMAGE_CODE_BUILD_PROJECT_LOGICAL_ID,
+                      "Arn"
+                    ]
+                  }
+                },
+                {
+                  Effect: "Allow",
+                  Action: ["iam:PassRole"],
+                  Resource: [
+                    {
+                      "Fn::GetAtt": [
+                        REPOSITORY_TASKS_ECS_TASK_DEFINITION_EXECUTION_ROLE_LOGICAL_ID,
+                        "Arn"
+                      ]
+                    },
+                    {
+                      "Fn::GetAtt": [
+                        REPOSITORY_TASKS_ECS_TASK_DEFINITION_TASK_ROLE_LOGICAL_ID,
+                        "Arn"
+                      ]
+                    }
+                  ]
+                },
+                {
+                  Effect: "Allow",
+                  Action: ["ecs:DescribeTasks"],
+                  Resource: "*"
+                },
+                {
+                  Effect: "Allow",
+                  Action: ["ecs:RunTask"],
+                  Resource: [
+                    {
+                      Ref: REPOSITORY_ECS_TASK_DEFINITION_LOGICAL_ID
+                    }
+                  ]
+                },
+                {
+                  Action: [
+                    "codepipeline:PutApprovalResult",
+                    "codepipeline:GetJobDetails",
+                    "codepipeline:GetPipelineState",
+                    "codepipeline:PutJobSuccessResult",
+                    "codepipeline:PutJobFailureResult"
+                  ],
+                  Effect: "Allow",
+                  Resource: "*"
+                },
+                {
+                  Action: "s3:*",
+                  Effect: "Allow",
+                  Resource: {
+                    "Fn::Sub": [
+                      `arn:aws:s3:::\${BucketName}/${triggerPipelinesObjectKeyPrefix}*`,
+                      {
+                        BucketName: {
+                          "Fn::ImportValue": BASE_STACK_BUCKET_NAME_EXPORTED_NAME
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    };
+    resources2[ECS_TASK_REPORT_HANDLER_LAMBDA_FUNCTION_LOGICAL_ID] = {
+      Type: "AWS::Serverless::Function",
+      Properties: {
+        ...commonFunctionProperties,
+        Environment: {
+          Variables: {
+            ECS_TASK_LOGS_LOG_GROUP: {
+              Ref: REPOSITORY_TASKS_ECS_CLUSTER_LOGS_LOG_GROUP_LOGICAL_ID
+            },
+            ECS_TASK_CONTAINER_NAME: REPOSITORY_ECS_TASK_CONTAINER_NAME,
+            SLACK_WEBHOOK_URL: slackWebhookUrl
+          }
+        },
+        Handler: "index.ecsTaskReportHandler"
+      }
+    };
+    resources2.CicdApiV1ServerlessFunction = {
+      Type: "AWS::Serverless::Function",
+      Properties: {
+        ...commonFunctionProperties,
+        Events: {
+          ApiEvent: {
+            Type: "Api",
+            Properties: {
+              Method: "POST",
+              Path: "/cicd",
+              RestApiId: { Ref: API_LOGICAL_ID }
+            }
+          }
+        },
+        Environment: {
+          Variables: {
+            [PROCESS_ENV_REPOSITORY_IMAGE_CODE_BUILD_PROJECT_NAME]: {
+              Ref: REPOSITORY_IMAGE_CODE_BUILD_PROJECT_LOGICAL_ID
+            },
+            ...executeEcsTaskVariables
+          }
+        },
+        Handler: "index.cicdApiV1Handler"
+      }
+    };
+    resources2.GitHubWebhooksApiV1ServerlessFunction = {
+      Type: "AWS::Serverless::Function",
+      Properties: {
+        ...commonFunctionProperties,
+        Events: {
+          ApiEvent: {
+            Type: "Api",
+            Properties: {
+              Method: "POST",
+              Path: "/github/webhooks",
+              RestApiId: { Ref: API_LOGICAL_ID }
+            }
+          }
+        },
+        Environment: {
+          Variables: {
+            BASE_STACK_BUCKET_NAME: {
+              "Fn::ImportValue": BASE_STACK_BUCKET_NAME_EXPORTED_NAME
+            },
+            TRIGGER_PIPELINES_OBJECT_KEY_PREFIX: triggerPipelinesObjectKeyPrefix,
+            PIPELINES_JSON: JSON.stringify(pipelines2),
+            ...executeEcsTaskVariables
+          }
+        },
+        Handler: "index.githubWebhooksApiV1Handler"
+      }
+    };
+  };
+  createApiResources();
+  (() => {
+    resources2[REPOSITORY_TASKS_ECS_CLUSTER_LOGICAL_ID] = {
+      Type: "AWS::ECS::Cluster",
+      Properties: {}
+    };
+    resources2[REPOSITORY_TASKS_ECS_CLUSTER_LOGS_LOG_GROUP_LOGICAL_ID] = {
+      Type: "AWS::Logs::LogGroup",
+      DeletionPolicy: "Delete",
+      Properties: {}
+    };
+    resources2[REPOSITORY_TASKS_ECS_TASK_DEFINITION_EXECUTION_ROLE_LOGICAL_ID] = {
+      Type: "AWS::IAM::Role",
+      Properties: {
+        AssumeRolePolicyDocument: {
+          Version: "2012-10-17",
+          Statement: [
+            {
+              Effect: "Allow",
+              Principal: {
+                Service: "ecs-tasks.amazonaws.com"
+              },
+              Action: "sts:AssumeRole"
+            }
+          ]
+        },
+        ManagedPolicyArns: [
+          "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
+        ],
+        Path: getIamPath()
+      }
+    };
+    resources2[REPOSITORY_TASKS_ECS_TASK_DEFINITION_TASK_ROLE_LOGICAL_ID] = {
+      Type: "AWS::IAM::Role",
+      Properties: {
+        AssumeRolePolicyDocument: {
+          Version: "2012-10-17",
+          Statement: [
+            {
+              Effect: "Allow",
+              Principal: {
+                Service: "ecs-tasks.amazonaws.com"
+              },
+              Action: "sts:AssumeRole"
+            }
+          ]
+        },
+        ManagedPolicyArns: [
+          "arn:aws:iam::aws:policy/job-function/ViewOnlyAccess"
+        ],
+        Path: getIamPath(),
+        /**
+         * TODO: improve the policies rules.
+         */
+        Policies: [
+          {
+            PolicyName: `${REPOSITORY_TASKS_ECS_TASK_DEFINITION_TASK_ROLE_LOGICAL_ID}Policy`,
+            PolicyDocument: {
+              Version: "2012-10-17",
+              Statement: [
+                {
+                  Effect: "Allow",
+                  Action: ["*"],
+                  Resource: "*"
+                }
+              ]
+            }
+          }
+        ]
+      }
+    };
+    resources2[REPOSITORY_ECS_TASK_DEFINITION_LOGICAL_ID] = {
+      Type: "AWS::ECS::TaskDefinition",
+      Properties: {
+        ContainerDefinitions: [
+          {
+            Environment: [
+              {
+                /**
+                 * https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-metadata.html#enable-metadata
+                 */
+                Name: "ECS_ENABLE_CONTAINER_METADATA",
+                Value: "true"
+              },
+              {
+                Name: "CI",
+                Value: "true"
+              },
+              ...taskEnvironment.map((te) => {
+                return {
+                  Name: te.name,
+                  Value: te.value
+                };
+              })
+            ],
+            Image: {
+              "Fn::Sub": [
+                // eslint-disable-next-line no-template-curly-in-string
+                "${AWS::AccountId}.dkr.ecr.${AWS::Region}.amazonaws.com/${RepositoryECR}:latest",
+                {
+                  RepositoryECR: { Ref: ECR_REPOSITORY_LOGICAL_ID }
+                }
+              ]
+            },
+            LogConfiguration: {
+              LogDriver: "awslogs",
+              Options: {
+                "awslogs-group": {
+                  Ref: REPOSITORY_TASKS_ECS_CLUSTER_LOGS_LOG_GROUP_LOGICAL_ID
+                },
+                "awslogs-region": { Ref: "AWS::Region" },
+                "awslogs-stream-prefix": "ecs"
+              }
+            },
+            Name: REPOSITORY_ECS_TASK_CONTAINER_NAME
+          }
+        ],
+        Cpu: cpu,
+        ExecutionRoleArn: {
+          "Fn::GetAtt": [
+            REPOSITORY_TASKS_ECS_TASK_DEFINITION_EXECUTION_ROLE_LOGICAL_ID,
+            "Arn"
+          ]
+        },
+        Memory: memory,
+        NetworkMode: "awsvpc",
+        RequiresCompatibilities: ["FARGATE"],
+        TaskRoleArn: {
+          "Fn::GetAtt": [
+            REPOSITORY_TASKS_ECS_TASK_DEFINITION_TASK_ROLE_LOGICAL_ID,
+            "Arn"
+          ]
+        }
+      }
+    };
+  })();
+  if (pipelines2.includes("main") || pipelines2.includes("tag")) {
+    resources2[PIPELINES_ARTIFACT_STORE_S3_BUCKET_LOGICAL_ID] = {
+      Type: "AWS::S3::Bucket",
+      Properties: {
+        LifecycleConfiguration: {
+          Rules: [
+            {
+              /**
+               * We won't use the artifacts forever.
+               */
+              ExpirationInDays: 7,
+              Status: "Enabled"
+            }
+          ]
+        }
+      }
+    };
+    resources2[PIPELINES_HANDLER_LAMBDA_FUNCTION_LOGICAL_ID] = {
+      Type: "AWS::Lambda::Function",
+      Properties: {
+        Code: {
+          S3Bucket: s32.bucket,
+          S3Key: s32.key,
+          S3ObjectVersion: s32.versionId
+        },
+        Environment: {
+          Variables: {
+            ...executeEcsTaskVariables
+          }
+        },
+        Handler: "index.pipelinesHandler",
+        MemorySize: 128,
+        Role: {
+          "Fn::GetAtt": [FUNCTION_IAM_ROLE_LOGICAL_ID, "Arn"]
+        },
+        Runtime: NODE_RUNTIME,
+        Timeout: 60
+      }
+    };
+    resources2[PIPELINES_ROLE_LOGICAL_ID] = {
+      Type: "AWS::IAM::Role",
+      Properties: {
+        AssumeRolePolicyDocument: {
+          Version: "2012-10-17",
+          Statement: [
+            {
+              Effect: "Allow",
+              Principal: {
+                Service: "codepipeline.amazonaws.com"
+              },
+              Action: "sts:AssumeRole"
+            }
+          ]
+        },
+        ManagedPolicyArns: [],
+        Path: getIamPath(),
+        Policies: [
+          {
+            PolicyName: `${PIPELINES_ROLE_LOGICAL_ID}Policy`,
+            PolicyDocument: {
+              Version: "2012-10-17",
+              Statement: [
+                {
+                  Effect: "Allow",
+                  Action: "lambda:InvokeFunction",
+                  Resource: [
+                    {
+                      "Fn::GetAtt": [
+                        PIPELINES_HANDLER_LAMBDA_FUNCTION_LOGICAL_ID,
+                        "Arn"
+                      ]
+                    }
+                  ]
+                },
+                {
+                  Effect: "Allow",
+                  Action: "s3:*",
+                  Resource: [
+                    {
+                      "Fn::GetAtt": [
+                        PIPELINES_ARTIFACT_STORE_S3_BUCKET_LOGICAL_ID,
+                        "Arn"
+                      ]
+                    },
+                    {
+                      "Fn::Sub": `arn:aws:s3:::\${${PIPELINES_ARTIFACT_STORE_S3_BUCKET_LOGICAL_ID}}/*`
+                    }
+                  ]
+                },
+                {
+                  Effect: "Allow",
+                  Action: "s3:*",
+                  Resource: {
+                    "Fn::Sub": [
+                      `arn:aws:s3:::\${BucketName}/${triggerPipelinesObjectKeyPrefix}*`,
+                      {
+                        BucketName: {
+                          "Fn::ImportValue": BASE_STACK_BUCKET_NAME_EXPORTED_NAME
+                        }
+                      }
+                    ]
+                  }
+                },
+                {
+                  Effect: "Allow",
+                  Action: ["s3:Get*", "s3:List*"],
+                  Resource: {
+                    "Fn::Sub": [
+                      `arn:aws:s3:::\${BucketName}`,
+                      {
+                        BucketName: {
+                          "Fn::ImportValue": BASE_STACK_BUCKET_NAME_EXPORTED_NAME
+                        }
+                      }
+                    ]
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    };
+    const getCodePipelinePipeline = (pipeline) => {
+      const pipelinePascalCase = pascalCase(pipeline);
+      const pipelineS3SourceOutputName = `Pipeline${pipelinePascalCase}S3SourceOutput`;
+      return {
+        Type: "AWS::CodePipeline::Pipeline",
+        Properties: {
+          ArtifactStore: {
+            Location: { Ref: PIPELINES_ARTIFACT_STORE_S3_BUCKET_LOGICAL_ID },
+            Type: "S3"
+          },
+          RestartExecutionOnUpdate: false,
+          RoleArn: {
+            "Fn::GetAtt": [PIPELINES_ROLE_LOGICAL_ID, "Arn"]
+          },
+          Stages: [
+            {
+              Actions: [
+                {
+                  ActionTypeId: {
+                    Category: "Source",
+                    Owner: "AWS",
+                    Provider: "S3",
+                    Version: 1
+                  },
+                  Configuration: {
+                    S3Bucket: {
+                      "Fn::ImportValue": BASE_STACK_BUCKET_NAME_EXPORTED_NAME
+                    },
+                    S3ObjectKey: getTriggerPipelinesObjectKey({
+                      prefix: triggerPipelinesObjectKeyPrefix,
+                      pipeline
+                    })
+                  },
+                  Name: `Pipeline${pipelinePascalCase}S3SourceAction`,
+                  OutputArtifacts: [
+                    {
+                      Name: pipelineS3SourceOutputName
+                    }
+                  ]
+                }
+              ],
+              Name: `Pipeline${pipelinePascalCase}S3SourceStage`
+            },
+            {
+              Actions: [
+                {
+                  ActionTypeId: {
+                    Category: "Invoke",
+                    Owner: "AWS",
+                    Provider: "Lambda",
+                    Version: 1
+                  },
+                  Configuration: {
+                    FunctionName: {
+                      Ref: PIPELINES_HANDLER_LAMBDA_FUNCTION_LOGICAL_ID
+                    },
+                    UserParameters: /* @__PURE__ */ (() => {
+                      return pipeline;
+                    })()
+                  },
+                  InputArtifacts: [
+                    {
+                      Name: pipelineS3SourceOutputName
+                    }
+                  ],
+                  Name: `Pipeline${pipelinePascalCase}RunECSTasksAction`
+                },
+                {
+                  ActionTypeId: {
+                    Category: "Approval",
+                    Owner: "AWS",
+                    Provider: "Manual",
+                    Version: 1
+                  },
+                  Name: PIPELINE_ECS_TASK_EXECUTION_MANUAL_APPROVAL_ACTION_NAME
+                }
+              ],
+              Name: PIPELINE_ECS_TASK_EXECUTION_STAGE_NAME
+            }
+          ]
+        }
+      };
+    };
+    if (pipelines2.includes("main")) {
+      resources2[PIPELINES_MAIN_LOGICAL_ID] = getCodePipelinePipeline("main");
+    }
+    if (pipelines2.includes("tag")) {
+      resources2[PIPELINES_TAG_LOGICAL_ID] = getCodePipelinePipeline("tag");
+    }
+  }
+  return {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Transform: "AWS::Serverless-2016-10-31",
+    Resources: resources2,
+    Parameters: {
+      SSHKey: {
+        NoEcho: true,
+        Type: "String"
+      },
+      SSHUrl: {
+        Type: "String"
+      }
+    },
+    Outputs: {
+      [REPOSITORY_IMAGE_CODE_BUILD_PROJECT_LOGICAL_ID]: {
+        Value: { Ref: REPOSITORY_IMAGE_CODE_BUILD_PROJECT_LOGICAL_ID }
+      },
+      ApiV1Endpoint: {
+        Description: "CICD API v1 stage endpoint.",
+        Value: {
+          "Fn::Sub": `https://\${${API_LOGICAL_ID}}.execute-api.\${AWS::Region}.amazonaws.com/v1/`
+        }
+      }
+    }
+  };
+};
+var logPrefix5 = "lambda";
+var buildLambdaCode = async ({
+  lambdaEntryPoints,
+  lambdaEntryPointsBaseDir = ".",
+  lambdaExternal = [],
+  lambdaFormat = "esm",
+  lambdaOutdir
+}) => {
+  log5.info(logPrefix5, "Building Lambda single file...");
+  if (fs4__default.existsSync(lambdaOutdir)) {
+    fs4__default.rmSync(lambdaOutdir, { recursive: true });
+  }
+  const entryPoints = lambdaEntryPoints.map((entryPoint) => {
+    return path3__default.resolve(process.cwd(), lambdaEntryPointsBaseDir, entryPoint);
+  });
+  const { errors } = esbuild.buildSync({
+    banner: {
+      js: "// Powered by carlin (https://ttoss.dev/docs/carlin/)"
+    },
+    bundle: true,
+    entryPoints,
+    external: [
+      /**
+       * Only AWS SDK v3 on Node.js 18.x or higher.
+       * https://aws.amazon.com/blogs/compute/node-js-18-x-runtime-now-available-in-aws-lambda/
+       */
+      "@aws-sdk/*",
+      ...builtinModules,
+      ...lambdaExternal
+    ],
+    /**
+     * Some packages as `graphql` are not compatible with ESM yet.
+     * https://github.com/graphql/graphql-js/issues/3603
+     */
+    format: lambdaFormat,
+    /**
+     * https://esbuild.github.io/api/#minify
+     */
+    minifySyntax: true,
+    platform: "node",
+    splitting: lambdaFormat === "esm",
+    outbase: path3__default.join(process.cwd(), lambdaEntryPointsBaseDir),
+    outdir: path3__default.join(process.cwd(), lambdaOutdir),
+    outExtension: { ".js": lambdaFormat === "esm" ? ".mjs" : ".cjs" },
+    target: typescriptConfig.target,
+    treeShaking: true
+  });
+  if (errors.length > 0) {
+    throw errors;
+  }
+};
+var lambdaLayerStackNamePrefix = `LambdaLayer`;
+var getPackageLambdaLayerStackName = (packageName) => {
+  const [scopedName, version] = packageName.split("@").filter((part) => {
+    return !!part;
+  });
+  return [
+    lambdaLayerStackNamePrefix,
+    pascalCase(scopedName),
+    version.replace(/[^0-9.]/g, "").replace(/\./g, "-")
+  ].join("-");
+};
+var logPrefix6 = "lambda-layer";
+var createLambdaLayerZipFile = async ({
+  codeBuildProjectName,
+  packageName
+}) => {
+  log5.info(logPrefix6, `Creating zip file for package ${packageName}...`);
+  const codeBuild2 = new AWS.CodeBuild();
+  const { build } = await codeBuild2.startBuild({
+    environmentVariablesOverride: [
+      {
+        name: "PACKAGE_NAME",
+        value: packageName
+      }
+    ],
+    projectName: codeBuildProjectName
+  }).promise();
+  if (!build?.id) {
+    throw new Error("Cannot start build.");
+  }
+  const result = await waitCodeBuildFinish({
+    buildId: build.id,
+    name: packageName
+  });
+  if (result.artifacts?.location) {
+    const location = result.artifacts.location.split("/");
+    const bucket = location.shift()?.replace("arn:aws:s3:::", "");
+    if (!bucket) {
+      throw new Error("Cannot retrieve bucket name.");
+    }
+    const key = location.join("/");
+    return { bucket, key };
+  }
+  throw new Error(`Cannot get artifact location for package ${packageName}`);
+};
+var getLambdaLayerTemplate = ({
+  bucket,
+  key,
+  packageName
+}) => {
+  const description = packageName.substring(0, 256);
+  return {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Resources: {
+      LambdaLayer: {
+        Type: "AWS::Lambda::LayerVersion",
+        Properties: {
+          CompatibleRuntimes: [NODE_RUNTIME],
+          Content: {
+            S3Bucket: bucket,
+            S3Key: key
+          },
+          Description: description,
+          LayerName: { Ref: "AWS::StackName" }
+        }
+      }
+    },
+    Outputs: {
+      LambdaLayerVersion: {
+        Description: description,
+        Value: { Ref: "LambdaLayer" },
+        Export: {
+          Name: { Ref: "AWS::StackName" }
+        }
+      }
+    }
+  };
+};
+var getPackagesThatAreNotDeployed = async ({
+  packages
+}) => {
+  return (await Promise.all(
+    packages.map(async (packageName) => {
+      const stackName = getPackageLambdaLayerStackName(packageName);
+      return await doesStackExist({ stackName }) ? "" : packageName;
+    })
+  )).filter((packageName) => {
+    return !!packageName;
+  });
+};
+var deployLambdaLayer = async ({
+  packages,
+  deployIfExists = true
+}) => {
+  try {
+    const packagesToBeDeployed = deployIfExists ? packages : await getPackagesThatAreNotDeployed({ packages });
+    if (packagesToBeDeployed.length === 0) {
+      return;
+    }
+    const codeBuildProjectName = await getBaseStackResource(
+      "BASE_STACK_LAMBDA_LAYER_BUILDER_LOGICAL_NAME"
+    );
+    if (!codeBuildProjectName) {
+      throw new Error(
+        "Cannot deploy lambda-layer because AWS CodeBuild project doesn't exist."
+      );
+    }
+    const deployLambdaLayerSinglePackage = async (packageName) => {
+      try {
+        const { bucket, key } = await createLambdaLayerZipFile({
+          codeBuildProjectName,
+          packageName
+        });
+        const lambdaLayerTemplate = getLambdaLayerTemplate({
+          packageName,
+          bucket,
+          key
+        });
+        await deploy({
+          template: lambdaLayerTemplate,
+          terminationProtection: true,
+          params: { StackName: getPackageLambdaLayerStackName(packageName) }
+        });
+      } catch (error) {
+        handleDeployError({ error, logPrefix: logPrefix6 });
+      }
+    };
+    await Promise.all(
+      packagesToBeDeployed.map((packageName) => {
+        return deployLambdaLayerSinglePackage(packageName);
+      })
+    );
+  } catch (error) {
+    handleDeployError({ error, logPrefix: logPrefix6 });
+  }
+};
+var logPrefix7 = "lambda";
+var deployLambdaLayers = async ({
+  lambdaExternal = []
+}) => {
+  if (lambdaExternal.length === 0) {
+    return;
+  }
+  log5.info(
+    logPrefix7,
+    `--lambda-externals [${lambdaExternal.join(
+      ", "
+    )}] was found. Creating other layers...`
+  );
+  const { dependencies = {} } = (() => {
+    try {
+      return JSON.parse(
+        fs3.readFileSync(path.resolve(process.cwd(), "package.json"), "utf8")
+      );
+    } catch (err) {
+      log5.error(
+        logPrefix7,
+        "Cannot read package.json. Error message: %j",
+        err.message
+      );
+      return {};
+    }
+  })();
+  const packages = lambdaExternal.map((external) => {
+    try {
+      const semver2 = dependencies[external].replace(/(~|\^)/g, "");
+      return `${external}@${semver2}`;
+    } catch {
+      throw new Error(`Cannot find ${external} on package.json dependencies.`);
+    }
+  });
+  await deployLambdaLayer({ packages, deployIfExists: false });
+};
+new AWS.CodeBuild({ region: AWS_DEFAULT_REGION });
+var uploadCodeToECR = async ({
+  bucket,
+  key,
+  lambdaExternal,
+  lambdaDockerfile
+}) => {
+  {
+    throw new Error("uploadCodeToECR not finished yet.");
+  }
+};
+var logPrefix8 = "lambda";
+var zipFileName = "lambda.zip";
+var uploadCodeToS3 = async ({
+  stackName,
+  lambdaOutdir
+}) => {
+  log5.info(logPrefix8, `Uploading code to S3...`);
+  const zip = new AdmZip();
+  const zipFile = `${lambdaOutdir}/${zipFileName}`;
+  if (fs4__default.existsSync(zipFile)) {
+    await fs4__default.promises.rm(zipFile);
+  }
+  zip.addLocalFolder(lambdaOutdir);
+  zip.writeZip(`${lambdaOutdir}/${zipFileName}`);
+  const bucketName = await getBaseStackResource(
+    "BASE_STACK_BUCKET_LOGICAL_NAME"
+  );
+  return uploadFileToS3({
+    bucket: bucketName,
+    contentType: "application/zip",
+    key: `lambdas/${stackName}/${zipFileName}`,
+    file: zip.toBuffer()
+  });
+};
+var logPrefix9 = "lambda";
+var deployLambdaCode = async ({
+  lambdaDockerfile,
+  lambdaExternal = [],
+  lambdaImage,
+  lambdaEntryPoints,
+  lambdaEntryPointsBaseDir = "src",
+  lambdaFormat,
+  lambdaOutdir = "dist",
+  stackName
+}) => {
+  if (!lambdaEntryPoints.length) {
+    return {};
+  }
+  log5.info(logPrefix9, "Deploying Lambda code...");
+  for (const entryPoint of lambdaEntryPoints) {
+    const entryPointPath = path3__default.resolve(lambdaEntryPointsBaseDir, entryPoint);
+    if (!fs4__default.existsSync(entryPointPath)) {
+      throw new Error(`Entry point ${entryPointPath} does not exist.`);
+    }
+  }
+  await buildLambdaCode({
+    lambdaExternal,
+    lambdaEntryPoints,
+    lambdaEntryPointsBaseDir,
+    lambdaFormat,
+    lambdaOutdir
+  });
+  const { bucket, key, versionId } = await uploadCodeToS3({
+    stackName,
+    lambdaOutdir
+  });
+  if (!lambdaImage) {
+    await deployLambdaLayers({ lambdaExternal });
+    return { bucket, key, versionId };
+  }
+  const { imageUri } = await uploadCodeToECR({
+    bucket,
+    key,
+    versionId,
+    lambdaDockerfile,
+    lambdaExternal
+  });
+  return { imageUri };
+};
+var getCicdStackName = () => {
+  const project = getProjectName();
+  return pascalCase([NAME, "Cicd", project].join(" "));
+};
+var logPrefix10 = "cicd";
+var getLambdaInput = (extension) => {
+  return path.resolve(__dirname, `lambdas/index.${extension}`);
+};
+var deployCicdLambdas = async ({ stackName }) => {
+  const lambdaInput = (() => {
+    if (fs3.existsSync(getLambdaInput("js"))) {
+      return getLambdaInput("js");
+    }
+    if (fs3.existsSync(getLambdaInput("ts"))) {
+      return getLambdaInput("ts");
+    }
+    throw new Error("Cannot read CICD lambdas file.");
+  })();
+  const s32 = await deployLambdaCode({
+    lambdaEntryPoints: [lambdaInput],
+    lambdaExternal: [],
+    /**
+     * Needs stackName to define the S3 key.
+     */
+    stackName
+  });
+  if (!s32 || !s32.bucket) {
+    throw new Error(
+      "Cannot retrieve bucket in which Lambda code was deployed."
+    );
+  }
+  return s32;
+};
+var waitRepositoryImageUpdate = async ({
+  stackName
+}) => {
+  log5.info(logPrefix10, "Starting repository image update...");
+  const { OutputValue: projectName } = await getStackOutput({
+    stackName,
+    outputKey: REPOSITORY_IMAGE_CODE_BUILD_PROJECT_LOGICAL_ID
+  });
+  if (!projectName) {
+    throw new Error(`Cannot retrieve repository image CodeBuild project name.`);
+  }
+  const build = await startCodeBuildBuild({ projectName });
+  if (build.id) {
+    await waitCodeBuildFinish({ buildId: build.id, name: stackName });
+  }
+};
+var deployCicd = async ({
+  cpu,
+  memory,
+  pipelines: pipelines2,
+  updateRepository,
+  slackWebhookUrl,
+  sshKey,
+  sshUrl,
+  taskEnvironment
+}) => {
+  try {
+    const { stackName } = await handleDeployInitialization({
+      logPrefix: logPrefix10,
+      stackName: getCicdStackName()
+    });
+    await deploy({
+      template: getCicdTemplate({
+        cpu,
+        memory,
+        pipelines: pipelines2,
+        s3: await deployCicdLambdas({ stackName }),
+        slackWebhookUrl,
+        taskEnvironment
+      }),
+      params: {
+        StackName: stackName,
+        Parameters: [
+          { ParameterKey: "SSHUrl", ParameterValue: sshUrl },
+          { ParameterKey: "SSHKey", ParameterValue: sshKey }
+        ]
+      },
+      terminationProtection: true
+    });
+    if (updateRepository) {
+      await waitRepositoryImageUpdate({ stackName });
+    }
+  } catch (error) {
+    handleDeployError({ error, logPrefix: logPrefix10 });
+  }
+};
+var readSSHKey = (dir) => {
+  return fs3.readFileSync(dir, "utf-8");
+};
+var logPrefix11 = "deploy-cicd";
+var deployCicdCommand = {
+  command: "cicd",
+  describe: "Deploy CICD.",
+  builder: (yargs3) => {
+    return yargs3.options(addGroupToOptions(options, "Deploy CICD Options"));
+  },
+  handler: ({ destroy: destroy2, ...rest }) => {
+    if (destroy2) {
+      log5.info(logPrefix11, `${NAME} doesn't destroy CICD stack.`);
+    } else {
+      deployCicd({
+        ...rest,
+        sshKey: readSSHKey(rest["ssh-key"])
+      });
+    }
+  }
+};
+var cloudFormationTypes = [
+  {
+    tag: "!Equals",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Equals": data };
+      }
+    }
+  },
+  {
+    tag: "!FindInMap",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::FindInMap": data };
+      }
+    }
+  },
+  {
+    tag: "!GetAtt",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::GetAtt": data.split(".") };
+      }
+    }
+  },
+  {
+    tag: "!GetAtt",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::GetAtt": data };
+      }
+    }
+  },
+  {
+    tag: "!If",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::If": data };
+      }
+    }
+  },
+  {
+    tag: "!ImportValue",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::ImportValue": data };
+      }
+    }
+  },
+  {
+    tag: "!Join",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Join": data };
+      }
+    }
+  },
+  {
+    tag: "!Not",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Not": data };
+      }
+    }
+  },
+  {
+    tag: "!Ref",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { Ref: data };
+      }
+    }
+  },
+  {
+    tag: "!Sub",
+    options: {
+      kind: "scalar",
+      construct: (data) => {
+        return { "Fn::Sub": data };
+      }
+    }
+  },
+  {
+    tag: "!Sub",
+    options: {
+      kind: "sequence",
+      construct: (data) => {
+        return { "Fn::Sub": data };
+      }
+    }
+  }
+];
+var getYamlTypes = (tagAndTypeArr) => {
+  return tagAndTypeArr.map(({ tag, options: options9 }) => {
+    return new yaml4.Type(tag, options9);
+  });
+};
+var getSchema = (tagAndTypeArr = []) => {
+  return yaml4.DEFAULT_SCHEMA.extend(
+    getYamlTypes([...tagAndTypeArr, ...cloudFormationTypes])
+  );
+};
+var loadCloudFormationTemplate = (template, tagAndTypeArr = []) => {
+  return yaml4.load(template, { schema: getSchema(tagAndTypeArr) });
+};
+
+// ../cloudformation/src/readCloudFormationYamlTemplate.ts
+var getTypes = () => {
+  return [
+    {
+      tag: `!SubString`,
+      options: {
+        kind: "scalar",
+        construct: (filePath) => {
+          return fs3.readFileSync(path.resolve(process.cwd(), filePath)).toString();
+        }
+      }
+    }
+  ];
+};
+var readCloudFormationYamlTemplate = ({
+  templatePath
+}) => {
+  const template = fs3.readFileSync(templatePath).toString();
+  const parsed = loadCloudFormationTemplate(template, getTypes());
+  if (!parsed || typeof parsed === "string") {
+    throw new Error("Cannot parse CloudFormation template.");
+  }
+  return parsed;
+};
+var loadConfig = (entryPoint) => {
+  const lastEntryPointName = entryPoint.split("/").pop();
+  const filename = lastEntryPointName?.split(".")[0];
+  const outfile = path3__default.resolve(process.cwd(), "out", filename + ".js");
+  const result = esbuild.buildSync({
+    bundle: true,
+    entryPoints: [entryPoint],
+    /**
+     * ttoss packages cannot be market as external because it'd break the CI.
+     * On CI, ttoss packages point to the TS main file, not the compiled
+     * ones. See more details here https://github.com/ttoss/ttoss/issues/541.
+     */
+    external: [],
+    format: "cjs",
+    outfile,
+    platform: "node",
+    target: "ES2021",
+    treeShaking: true
+  });
+  if (result.errors.length > 0) {
+    console.error("Error building config file: ", filename);
+    throw result.errors;
+  }
+  try {
+    const config = importSync(outfile);
+    return config.default || config.config;
+  } catch (error) {
+    console.error("Failed importing build config file: ", filename);
+    throw error;
+  }
+};
+var readConfigFileSync = ({
+  configFilePath,
+  options: options9
+}) => {
+  const extension = configFilePath.split(".").pop();
+  if (extension === "yaml" || extension === "yml") {
+    const file = fs3__default.readFileSync(configFilePath, "utf8");
+    return yaml4.load(file);
+  }
+  if (extension === "json") {
+    const file = fs3__default.readFileSync(configFilePath, "utf8");
+    return JSON.parse(file);
+  }
+  if (extension === "js") {
+    return __require(configFilePath);
+  }
+  if (extension === "ts") {
+    let result = loadConfig(configFilePath);
+    if (typeof result === "function") {
+      result = result(options9);
+    }
+    return result;
+  }
+  throw new Error("Unsupported config file extension: " + extension);
+};
+var readConfigFile = async ({
+  configFilePath,
+  options: options9
+}) => {
+  const extension = configFilePath.split(".").pop();
+  if (extension === "ts") {
+    let result = loadConfig(configFilePath);
+    if (typeof result === "function") {
+      result = result(options9);
+    }
+    result = await Promise.resolve(result);
+    return result;
+  }
+  return readConfigFileSync({ configFilePath, options: options9 });
+};
+
+// ../cloudformation/src/findAndReadCloudFormationTemplate.ts
+var defaultTemplatePaths2 = ["ts", "js", "yaml", "yml", "json"].map(
+  (extension) => {
+    return `./src/cloudformation.${extension}`;
+  }
+);
+var findAndReadCloudFormationTemplate = async ({
+  templatePath: defaultTemplatePath,
+  options: options9 = {}
+}) => {
+  const templatePath = defaultTemplatePath || defaultTemplatePaths2.reduce((acc, cur) => {
+    if (acc) {
+      return acc;
+    }
+    return fs4.existsSync(path3.resolve(process.cwd(), cur)) ? cur : acc;
+  }, "");
+  if (!templatePath) {
+    throw new Error("Cannot find a CloudFormation template.");
+  }
+  const extension = templatePath?.split(".").pop();
+  if (["yaml", "yml"].includes(extension)) {
+    return readCloudFormationYamlTemplate({ templatePath });
+  }
+  const configFilePath = path3.resolve(process.cwd(), templatePath);
+  return readConfigFile({ configFilePath, options: options9 });
+};
+
+// src/deploy/lambda/getLambdaEntryPointsFromTemplate.ts
+var getLambdaEntryPointsFromTemplate = (template) => {
+  const lambdaResources = Object.keys(template.Resources).filter((key) => {
+    return ["AWS::Lambda::Function", "AWS::Serverless::Function"].includes(
+      template.Resources[key].Type
+    );
+  });
+  const handlers = lambdaResources.map((key) => {
+    return template.Resources[key].Properties.Handler;
+  });
+  const handlersPaths = handlers.map((handler) => {
+    return handler.split(".")[0] + ".ts";
+  });
+  return handlersPaths;
+};
+var logPrefix12 = "cloudformation";
+log5.addLevel("event", 1e4, { fg: "yellow" });
+log5.addLevel("output", 1e4, { fg: "blue" });
+var getCloudformationTemplateOptions = ({
+  cliOptions,
+  stackName
+}) => {
+  const options9 = {
+    ...cliOptions,
+    stackName,
+    environment: getEnvironment(),
+    packageName: getPackageName(),
+    projectName: getProjectName()
+  };
+  return options9;
+};
+var deployCloudFormation = async (cliOptions) => {
+  try {
+    const {
+      lambdaDockerfile,
+      lambdaEntryPoints,
+      lambdaEntryPointsBaseDir,
+      lambdaImage,
+      lambdaExternal,
+      lambdaFormat,
+      lambdaOutdir,
+      parameters,
+      template,
+      templatePath
+    } = cliOptions;
+    const { stackName } = await handleDeployInitialization({ logPrefix: logPrefix12 });
+    const cloudFormationTemplate = await (async () => {
+      if (template) {
+        return { ...template };
+      }
+      return findAndReadCloudFormationTemplate({
+        templatePath,
+        options: getCloudformationTemplateOptions({ stackName, cliOptions })
+      });
+    })();
+    parameters?.forEach((parameter) => {
+      if (cloudFormationTemplate.Parameters?.[parameter.key]) {
+        return;
+      }
+      if (!cloudFormationTemplate.Parameters) {
+        cloudFormationTemplate.Parameters = {};
+      }
+      const type = (() => {
+        if (typeof parameter.value === "string") {
+          return "String";
+        }
+        if (typeof parameter.value === "number") {
+          return "Number";
+        }
+        throw new Error(
+          `Parameter assertion failed. Parameter ${parameter.key} value ${parameter.value} is not mapped.`
+        );
+      })();
+      cloudFormationTemplate.Parameters[parameter.key] = {
+        Type: type
+      };
+    });
+    await validateTemplate({ stackName, template: cloudFormationTemplate });
+    const params = {
+      StackName: stackName,
+      Parameters: parameters?.map((parameter) => {
+        return {
+          ParameterKey: parameter.key,
+          ParameterValue: parameter.value,
+          UsePreviousValue: parameter.usePreviousValue,
+          ResolvedValue: parameter.resolvedValue
+        };
+      }) || []
+    };
+    const deployCloudFormationDeployLambdaCode = async () => {
+      const finalLambdaEntryPoints = (() => {
+        if (lambdaEntryPoints && lambdaEntryPoints.length > 0) {
+          return lambdaEntryPoints;
+        }
+        return getLambdaEntryPointsFromTemplate(cloudFormationTemplate);
+      })();
+      const response = await deployLambdaCode({
+        lambdaDockerfile,
+        lambdaExternal,
+        lambdaEntryPoints: finalLambdaEntryPoints,
+        lambdaEntryPointsBaseDir,
+        lambdaFormat,
+        lambdaImage,
+        lambdaOutdir,
+        stackName
+      });
+      if (response) {
+        const { bucket, key, versionId, imageUri } = response;
+        if (imageUri) {
+          cloudFormationTemplate.Parameters = {
+            LambdaImageUri: { Type: "String" },
+            ...cloudFormationTemplate.Parameters
+          };
+          params.Parameters.push({
+            ParameterKey: "LambdaImageUri",
+            ParameterValue: imageUri
+          });
+        } else if (bucket && key && versionId) {
+          cloudFormationTemplate.Parameters = {
+            LambdaS3Bucket: { Type: "String" },
+            LambdaS3Key: { Type: "String" },
+            LambdaS3ObjectVersion: { Type: "String" },
+            ...cloudFormationTemplate.Parameters
+          };
+          params.Parameters.push(
+            {
+              ParameterKey: "LambdaS3Bucket",
+              ParameterValue: bucket
+            },
+            {
+              ParameterKey: "LambdaS3Key",
+              ParameterValue: key
+            },
+            /**
+             * Used by CloudFormation AWS::Lambda::Function
+             * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-code.html}
+             * and by CloudFormation AWS::Serverless::Function
+             * @see {@link https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html}
+             */
+            {
+              ParameterKey: "LambdaS3ObjectVersion",
+              ParameterValue: versionId
+            }
+          );
+          Object.keys(cloudFormationTemplate.Resources).forEach((key2) => {
+            const resource = cloudFormationTemplate.Resources[key2];
+            if (resource.Type === "AWS::Lambda::Function") {
+              if (!resource.Properties.Code) {
+                resource.Properties.Code = {
+                  S3Bucket: { Ref: "LambdaS3Bucket" },
+                  S3Key: { Ref: "LambdaS3Key" },
+                  S3ObjectVersion: { Ref: "LambdaS3ObjectVersion" }
+                };
+              }
+            }
+            if (resource.Type === "AWS::Serverless::Function") {
+              if (!resource.Properties.CodeUri) {
+                resource.Properties.CodeUri = {
+                  Bucket: { Ref: "LambdaS3Bucket" },
+                  Key: { Ref: "LambdaS3Key" },
+                  Version: { Ref: "LambdaS3ObjectVersion" }
+                };
+              }
+            }
+          });
+        }
+      }
+    };
+    await deployCloudFormationDeployLambdaCode();
+    const output = await deploy({
+      params,
+      template: cloudFormationTemplate
+    });
+    return output;
+  } catch (error) {
+    return handleDeployError({ error, logPrefix: logPrefix12 });
+  }
+};
+var emptyStackBuckets = async ({ stackName }) => {
+  const buckets = [];
+  await (async ({ nextToken }) => {
+    const {
+      // NextToken,
+      StackResourceSummaries
+    } = await cloudFormationV2().listStackResources({ StackName: stackName, NextToken: nextToken }).promise();
+    (StackResourceSummaries || []).forEach(
+      ({ ResourceType, PhysicalResourceId }) => {
+        if (ResourceType === "AWS::S3::Bucket" && PhysicalResourceId) {
+          buckets.push(PhysicalResourceId);
+        }
+      }
+    );
+  })({});
+  return Promise.all(
+    buckets.map((bucket) => {
+      return emptyS3Directory({ bucket });
+    })
+  );
+};
+var destroy = async ({ stackName }) => {
+  const environment = getEnvironment();
+  if (environment) {
+    log5.info(
+      logPrefix12,
+      `Cannot destroy stack when environment (${environment}) is defined.`
+    );
+    return;
+  }
+  if (!await doesStackExist({ stackName })) {
+    log5.info(logPrefix12, `Stack ${stackName} doesn't exist.`);
+    return;
+  }
+  if (!await canDestroyStack({ stackName })) {
+    const message = `Stack ${stackName} cannot be destroyed while TerminationProtection is enabled.`;
+    throw new Error(message);
+  }
+  await emptyStackBuckets({ stackName });
+  await deleteStack({ stackName });
+};
+var destroyCloudFormation = async ({
+  stackName: defaultStackName
+} = {}) => {
+  try {
+    log5.info(logPrefix12, "CAUTION! Starting CloudFormation destroy...");
+    const stackName = defaultStackName || await getStackName();
+    log5.info(logPrefix12, `stackName: ${stackName}`);
+    await destroy({ stackName });
+  } catch (error) {
+    handleDeployError({ error, logPrefix: logPrefix12 });
+  }
+};
+var logPrefix13 = "deploy-lambda-layer";
+var packageNameRegex = /@[~^]?([\dvx*]+(?:[-.](?:[\dx*]+|alpha|beta))*)/;
+var options2 = {
+  packages: {
+    array: true,
+    describe: `NPM packages' names to be deployed as Lambda Layers. It must follow the format: ${packageNameRegex.toString()}.`,
+    required: true,
+    type: "string"
+  }
+};
+var deployLambdaLayerCommand = {
+  command: "lambda-layer",
+  describe: "Deploy Lambda Layer.",
+  builder: (yargs3) => {
+    return yargs3.options(addGroupToOptions(options2, "Deploy Lambda Layer Options")).check(({ packages }) => {
+      const invalidPackages = packages.map((packageName) => {
+        return packageNameRegex.test(packageName) ? void 0 : packageName;
+      }).filter((packageName) => {
+        return !!packageName;
+      });
+      if (invalidPackages.length > 0) {
+        throw new Error(
+          `Some package names are invalid: ${invalidPackages.join(
+            ", "
+          )}. The package must follow the pattern: ${packageNameRegex.toString()}.`
+        );
+      } else {
+        return true;
+      }
+    });
+  },
+  handler: ({ destroy: destroy2, ...rest }) => {
+    if (destroy2) {
+      log5.info(logPrefix13, `${NAME} doesn't destroy lambda layers.`);
+    } else {
+      deployLambdaLayer(rest);
+    }
+  }
+};
+
+// src/deploy/staticApp/findDefaultBuildFolder.ts
+var defaultBuildFolders = [
+  /**
+   * Create React App default build folder
+   */
+  "build",
+  /**
+   * Next.js default output folder
+   */
+  "out",
+  /**
+   * Storybook default output folder
+   */
+  "storybook-static",
+  /**
+   * Vite.js default build folder
+   */
+  "dist"
+];
+var findDefaultBuildFolder = async () => {
+  const validFolders = await Promise.all(
+    defaultBuildFolders.map(async (directory) => {
+      const allFiles = await getAllFilesInsideADirectory({
+        directory
+      });
+      return { directory, isValid: allFiles.length !== 0 };
+    })
+  );
+  const validFolder = validFolders.reduce((acc, cur) => {
+    if (cur.isValid) {
+      return cur.directory;
+    }
+    return acc;
+  }, "");
+  return validFolder;
+};
+
+// src/deploy/staticApp/getStaticAppBucket.ts
+var STATIC_APP_BUCKET_LOGICAL_ID = "StaticBucket";
+var getStaticAppBucket = async ({
+  stackName
+}) => {
+  const params = {
+    LogicalResourceId: STATIC_APP_BUCKET_LOGICAL_ID,
+    StackName: stackName
+  };
+  try {
+    const { StackResourceDetail } = await describeStackResource(params);
+    return StackResourceDetail?.PhysicalResourceId;
+  } catch (error) {
+    return void 0;
+  }
+};
+
+// src/deploy/staticApp/staticApp.template.ts
+var PACKAGE_VERSION = getPackageVersion();
+var STATIC_APP_BUCKET_LOGICAL_ID2 = "StaticBucket";
+var CLOUDFRONT_DISTRIBUTION_LOGICAL_ID = "CloudFrontDistribution";
+var CLOUDFRONT_ORIGIN_ACCESS_CONTROL_LOGICAL_ID = "OriginAccessControl";
+var ROUTE_53_RECORD_SET_GROUP_LOGICAL_ID = "Route53RecordSetGroup";
+var ERROR_DOCUMENT = "404/index.html";
+var CACHE_POLICY_ID = "4135ea2d-6df8-44a3-9df3-4b5a84be39ad";
+var ORIGIN_REQUEST_POLICY_ID = "88a5eaf4-2fd4-4709-b370-b4c650ea3fcf";
+var ORIGIN_RESPONSE_POLICY_ID = "eaab4381-ed33-4a86-88ca-d9558dc6cd63";
+var getBucketStaticWebsiteTemplate = ({
+  spa
+}) => {
+  return {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Resources: {
+      [STATIC_APP_BUCKET_LOGICAL_ID2]: {
+        Type: "AWS::S3::Bucket",
+        Properties: {
+          CorsConfiguration: {
+            CorsRules: [
+              {
+                AllowedHeaders: ["*"],
+                AllowedMethods: ["GET"],
+                AllowedOrigins: ["*"],
+                Id: "OpenCors",
+                MaxAge: 600
+              }
+            ]
+          },
+          PublicAccessBlockConfiguration: {
+            BlockPublicPolicy: false
+          },
+          WebsiteConfiguration: {
+            IndexDocument: `index.html`,
+            ErrorDocument: spa ? "index.html" : ERROR_DOCUMENT
+          }
+        }
+      },
+      [`${STATIC_APP_BUCKET_LOGICAL_ID2}S3BucketPolicy`]: {
+        Type: "AWS::S3::BucketPolicy",
+        Properties: {
+          Bucket: { Ref: STATIC_APP_BUCKET_LOGICAL_ID2 },
+          PolicyDocument: {
+            Statement: [
+              {
+                Action: ["s3:GetObject"],
+                Effect: "Allow",
+                Principal: "*",
+                Resource: {
+                  "Fn::Join": [
+                    "",
+                    [
+                      "arn:aws:s3:::",
+                      { Ref: STATIC_APP_BUCKET_LOGICAL_ID2 },
+                      "/*"
+                    ]
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
+    Outputs: {
+      BucketWebsiteURL: {
+        Description: "Bucket static app website URL",
+        Value: {
+          "Fn::GetAtt": [STATIC_APP_BUCKET_LOGICAL_ID2, "WebsiteURL"]
+        }
+      }
+    }
+  };
+};
+var getCloudFrontTemplate = ({
+  acm,
+  aliases = [],
+  spa,
+  hostedZoneName
+}) => {
+  const template = {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Resources: {
+      [STATIC_APP_BUCKET_LOGICAL_ID2]: {
+        Type: "AWS::S3::Bucket",
+        Properties: {
+          PublicAccessBlockConfiguration: {
+            BlockPublicPolicy: false
+          }
+        }
+      },
+      [`${STATIC_APP_BUCKET_LOGICAL_ID2}S3BucketPolicy`]: {
+        Type: "AWS::S3::BucketPolicy",
+        Properties: {
+          Bucket: { Ref: STATIC_APP_BUCKET_LOGICAL_ID2 },
+          PolicyDocument: {
+            Statement: [
+              /**
+               * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-s3.html
+               */
+              {
+                Sid: "AllowCloudFrontServicePrincipalReadOnly",
+                Effect: "Allow",
+                Principal: {
+                  Service: "cloudfront.amazonaws.com"
+                },
+                Action: "s3:GetObject",
+                Resource: {
+                  "Fn::Join": [
+                    "",
+                    [
+                      "arn:aws:s3:::",
+                      { Ref: STATIC_APP_BUCKET_LOGICAL_ID2 },
+                      "/*"
+                    ]
+                  ]
+                },
+                Condition: {
+                  StringEquals: {
+                    "AWS:SourceArn": (
+                      // 'arn:aws:cloudfront::<AWS account ID>:distribution/<CloudFront distribution ID>',
+                      {
+                        "Fn::Join": [
+                          "",
+                          [
+                            "arn:aws:cloudfront::",
+                            { Ref: "AWS::AccountId" },
+                            ":distribution/",
+                            { Ref: CLOUDFRONT_DISTRIBUTION_LOGICAL_ID }
+                          ]
+                        ]
+                      }
+                    )
+                  }
+                }
+              }
+            ]
+          }
+        }
+      }
+    }
+  };
+  const cloudFrontResources = {
+    [CLOUDFRONT_DISTRIBUTION_LOGICAL_ID]: {
+      Type: "AWS::CloudFront::Distribution",
+      Properties: {
+        DistributionConfig: {
+          Comment: {
+            "Fn::Sub": [
+              "CloudFront Distribution for ${Project} project.",
+              { Project: { Ref: "Project" } }
+            ]
+          },
+          CustomErrorResponses: [403, 404].map((errorCode) => {
+            if (spa) {
+              return {
+                ErrorCachingMinTTL: 60 * 60 * 24,
+                ErrorCode: errorCode,
+                ResponseCode: 200,
+                ResponsePagePath: "/index.html"
+              };
+            }
+            return {
+              ErrorCachingMinTTL: 0,
+              ErrorCode: errorCode,
+              ResponseCode: 404,
+              ResponsePagePath: "/" + ERROR_DOCUMENT
+            };
+          }),
+          DefaultCacheBehavior: {
+            AllowedMethods: ["GET", "HEAD", "OPTIONS"],
+            Compress: true,
+            CachedMethods: ["GET", "HEAD", "OPTIONS"],
+            /**
+             * Caching OPTIONS. Related to OriginRequestPolicyId property.
+             * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/header-caching.html#header-caching-web-cors
+             */
+            OriginRequestPolicyId: ORIGIN_REQUEST_POLICY_ID,
+            /**
+             * CachePolicyId property:
+             * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cloudfront-distribution-defaultcachebehavior.html#cfn-cloudfront-distribution-defaultcachebehavior-cachepolicyid
+             */
+            CachePolicyId: CACHE_POLICY_ID,
+            ResponseHeadersPolicyId: ORIGIN_RESPONSE_POLICY_ID,
+            TargetOriginId: { Ref: STATIC_APP_BUCKET_LOGICAL_ID2 },
+            ViewerProtocolPolicy: "redirect-to-https"
+          },
+          DefaultRootObject: "index.html",
+          Enabled: true,
+          HttpVersion: "http2",
+          Origins: [
+            {
+              DomainName: {
+                "Fn::GetAtt": [STATIC_APP_BUCKET_LOGICAL_ID2, "DomainName"]
+              },
+              Id: { Ref: STATIC_APP_BUCKET_LOGICAL_ID2 },
+              OriginAccessControlId: {
+                "Fn::GetAtt": [
+                  CLOUDFRONT_ORIGIN_ACCESS_CONTROL_LOGICAL_ID,
+                  "Id"
+                ]
+              },
+              /**
+               * Note: As of September 2022, an empty OriginAccessIdentity must be specified in S3OriginConfig.
+               */
+              S3OriginConfig: {
+                OriginAccessIdentity: ""
+              }
+            }
+          ]
+        }
+      }
+    },
+    [CLOUDFRONT_ORIGIN_ACCESS_CONTROL_LOGICAL_ID]: {
+      Type: "AWS::CloudFront::OriginAccessControl",
+      Properties: {
+        OriginAccessControlConfig: {
+          Description: {
+            "Fn::Sub": [
+              "Default Origin Access Control for ${Project} project.",
+              { Project: { Ref: "Project" } }
+            ]
+          },
+          Name: {
+            Ref: "AWS::StackName"
+          },
+          OriginAccessControlOriginType: "s3",
+          SigningBehavior: "always",
+          SigningProtocol: "sigv4"
+        }
+      }
+    }
+  };
+  if (acm) {
+    const acmRegex = /^arn:aws:acm:[-a-z0-9]+:\d{12}:certificate\/[-a-z0-9]+$/;
+    const acmCertificateArn = acmRegex.test(acm) ? acm : {
+      "Fn::ImportValue": acm
+    };
+    cloudFrontResources.CloudFrontDistribution.Properties.DistributionConfig = {
+      ...cloudFrontResources.CloudFrontDistribution.Properties.DistributionConfig,
+      Aliases: aliases || { Ref: "AWS::NoValue" },
+      ViewerCertificate: {
+        AcmCertificateArn: acmCertificateArn,
+        /**
+         * AWS CloudFront recommendation.
+         */
+        MinimumProtocolVersion: "TLSv1.2_2021",
+        SslSupportMethod: "sni-only"
+      }
+    };
+  }
+  if (hostedZoneName && aliases) {
+    const recordSets = aliases.map((alias) => {
+      if (alias === hostedZoneName) {
+        return {
+          AliasTarget: {
+            DNSName: {
+              "Fn::GetAtt": `${CLOUDFRONT_DISTRIBUTION_LOGICAL_ID}.DomainName`
+            },
+            /**
+             * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-aliastarget.html#cfn-route53-aliastarget-hostedzoneid
+             */
+            HostedZoneId: "Z2FDTNDATAQYW2"
+          },
+          Name: alias,
+          Type: "A"
+        };
+      }
+      return {
+        Name: alias,
+        ResourceRecords: [
+          {
+            "Fn::GetAtt": `${CLOUDFRONT_DISTRIBUTION_LOGICAL_ID}.DomainName`
+          }
+        ],
+        TTL: 60,
+        Type: "CNAME"
+      };
+    });
+    const route53RecordSetGroupResources = {
+      [ROUTE_53_RECORD_SET_GROUP_LOGICAL_ID]: {
+        Type: "AWS::Route53::RecordSetGroup",
+        DependsOn: [CLOUDFRONT_DISTRIBUTION_LOGICAL_ID],
+        Properties: {
+          // https://forums.aws.amazon.com/thread.jspa?threadID=103919
+          HostedZoneName: `${hostedZoneName}${hostedZoneName.endsWith(".") ? "" : "."}`,
+          RecordSets: recordSets
+        }
+      }
+    };
+    template.Resources = {
+      ...template.Resources,
+      ...route53RecordSetGroupResources
+    };
+  }
+  template.Resources = { ...template.Resources, ...cloudFrontResources };
+  const aliasesOutput = (aliases || []).reduce(
+    (acc, alias, index) => {
+      return {
+        ...acc,
+        [`Alias${index}URL`]: {
+          Value: `https://${alias}`
+        }
+      };
+    },
+    {}
+  );
+  template.Outputs = {
+    ...template.Outputs,
+    ...aliasesOutput,
+    CloudFrontURL: {
+      Value: {
+        "Fn::Join": [
+          "",
+          [
+            "https://",
+            {
+              "Fn::GetAtt": `${CLOUDFRONT_DISTRIBUTION_LOGICAL_ID}.DomainName`
+            }
+          ]
+        ]
+      }
+    },
+    CloudFrontDistributionId: {
+      Value: {
+        Ref: CLOUDFRONT_DISTRIBUTION_LOGICAL_ID
+      }
+    },
+    CurrentVersion: {
+      Value: PACKAGE_VERSION
+    }
+  };
+  return template;
+};
+var getStaticAppTemplate = ({
+  acm,
+  aliases,
+  cloudfront,
+  spa,
+  hostedZoneName,
+  region
+}) => {
+  if (cloudfront) {
+    return getCloudFrontTemplate({
+      acm,
+      aliases,
+      cloudfront,
+      spa,
+      hostedZoneName,
+      region
+    });
+  }
+  return getBucketStaticWebsiteTemplate({ spa });
+};
+var CLOUDFRONT_DISTRIBUTION_ID = "CloudFrontDistributionId";
+var logPrefix14 = "static-app";
+var invalidateCloudFront = async ({
+  outputs
+}) => {
+  log5.info(logPrefix14, "Invalidating CloudFront...");
+  if (!outputs) {
+    log5.info(logPrefix14, "Invalidation: outputs do not exist.");
+    return;
+  }
+  const cloudFrontDistributionIDOutput = outputs.find((output) => {
+    return output.OutputKey === CLOUDFRONT_DISTRIBUTION_ID;
+  });
+  if (cloudFrontDistributionIDOutput?.OutputValue) {
+    const distributionId = cloudFrontDistributionIDOutput.OutputValue;
+    const params = {
+      DistributionId: distributionId,
+      InvalidationBatch: {
+        CallerReference: (/* @__PURE__ */ new Date()).toISOString(),
+        Paths: {
+          Items: ["/*"],
+          Quantity: 1
+        }
+      }
+    };
+    const cloudFront = new AWS.CloudFront();
+    try {
+      await cloudFront.createInvalidation(params).promise();
+      log5.info(
+        logPrefix14,
+        `CloudFront Distribution ID ${distributionId} invalidated with success.`
+      );
+    } catch (err) {
+      log5.error(
+        logPrefix14,
+        `Error while trying to invalidate CloudFront distribution ${distributionId}.`
+      );
+      log5.error(logPrefix14, err);
+    }
+  } else {
+    log5.info(
+      logPrefix14,
+      `Cannot invalidate because distribution does not exist.`
+    );
+  }
+};
+var logPrefix15 = "static-app";
+var removeOldVersions = async ({ bucket }) => {
+  try {
+    log5.info(logPrefix15, "Removing old versions...");
+    const { CommonPrefixes = [] } = await s3.listObjectsV2({ Bucket: bucket, Delimiter: "/" }).promise();
+    const versions = CommonPrefixes?.map(({ Prefix }) => {
+      return Prefix?.replace("/", "");
+    }).filter((version) => {
+      return semver.valid(version);
+    }).sort((a, b) => {
+      return semver.gt(a, b) ? -1 : 1;
+    });
+    versions.shift();
+    versions.shift();
+    versions.shift();
+    await Promise.all(
+      versions.map((version) => {
+        return deleteS3Directory({ bucket, directory: `${version}` });
+      })
+    );
+  } catch (error) {
+    log5.info(
+      logPrefix15,
+      `Cannot remove older versions from "${bucket}" bucket.`
+    );
+  }
+};
+
+// src/deploy/staticApp/uploadBuiltAppToS3.ts
+var uploadBuiltAppToS3 = async ({
+  buildFolder: directory,
+  bucket
+}) => {
+  if (directory) {
+    const files = await getAllFilesInsideADirectory({ directory });
+    if (files.length > 0) {
+      await emptyS3Directory({ bucket });
+    }
+    await uploadDirectoryToS3({ bucket, directory });
+    return;
+  }
+  const defaultDirectory = await findDefaultBuildFolder();
+  if (defaultDirectory) {
+    await emptyS3Directory({ bucket });
+    await uploadDirectoryToS3({ bucket, directory: defaultDirectory });
+    await copyRoot404To404Index({ bucket });
+    return;
+  }
+  throw new Error(
+    `build-folder option wasn't provided and files weren't found in ${defaultBuildFolders.join(
+      ", "
+    )} directories.`
+  );
+};
+
+// src/deploy/staticApp/deployStaticApp.ts
+var logPrefix16 = "static-app";
+var deployStaticApp = async ({
+  acm,
+  aliases,
+  buildFolder,
+  cloudfront,
+  spa,
+  hostedZoneName,
+  region,
+  skipUpload
+}) => {
+  try {
+    const { stackName } = await handleDeployInitialization({ logPrefix: logPrefix16 });
+    const params = { StackName: stackName };
+    const template = getStaticAppTemplate({
+      acm,
+      aliases,
+      cloudfront,
+      spa,
+      hostedZoneName,
+      region
+    });
+    const bucket = await getStaticAppBucket({ stackName });
+    if (bucket) {
+      if (!skipUpload) {
+        await uploadBuiltAppToS3({ buildFolder, bucket, cloudfront });
+      }
+      const { Outputs } = await deploy({ params, template });
+      await invalidateCloudFront({ outputs: Outputs });
+      if (!skipUpload) {
+        await removeOldVersions({ bucket });
+      }
+    } else {
+      await deploy({ params, template });
+      const newBucket = await getStaticAppBucket({ stackName });
+      if (!newBucket) {
+        throw new Error(`Cannot find bucket at ${stackName}.`);
+      }
+      await uploadBuiltAppToS3({ buildFolder, bucket: newBucket, cloudfront });
+    }
+  } catch (error) {
+    handleDeployError({ error, logPrefix: logPrefix16 });
+  }
+};
+var options3 = {
+  acm: {
+    describe: "The ARN of the certificate or the name of the exported variable whose value is the ARN of the certificate that will be associated to CloudFront.",
+    type: "string"
+  },
+  aliases: {
+    describe: "The aliases that will be associated with the CloudFront. See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/CNAMEs.html",
+    implies: ["acm"],
+    type: "array"
+  },
+  "build-folder": {
+    describe: `The folder that will be uploaded. If not provided, it'll search for the folders "${defaultBuildFolders.join(
+      ", "
+    )}."`,
+    type: "string"
+  },
+  cloudfront: {
+    default: false,
+    describe: "A CloudFront resource is created along with S3 if this option is `true`.",
+    require: false,
+    type: "boolean"
+  },
+  "hosted-zone-name": {
+    required: false,
+    describe: `Is the name of a Route 53 hosted zone. If this value is provided, ${NAME} creates the subdomains defined on \`--aliases\` option. E.g. if you have a hosted zone named "sub.domain.com", the value provided may be "sub.domain.com".`,
+    type: "string"
+  },
+  /**
+   * CloudFront triggers can be only in US East (N. Virginia) Region.
+   * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-requirements-limits.html#lambda-requirements-cloudfront-triggers
+   */
+  region: {
+    coerce: () => {
+      return CLOUDFRONT_REGION;
+    },
+    default: CLOUDFRONT_REGION,
+    hidden: true,
+    type: "string"
+  },
+  "skip-upload": {
+    default: false,
+    describe: "Skip files upload to S3. Useful when wanting update only CloudFormation.",
+    type: "boolean"
+  },
+  spa: {
+    default: false,
+    describe: "This option enables CloudFront to serve a single page application (SPA).",
+    require: false,
+    type: "boolean"
+  }
+};
+var deployStaticAppCommand = {
+  command: "static-app",
+  describe: "Deploy static app.",
+  builder: (yargs3) => {
+    return yargs3.options(addGroupToOptions(options3, "Deploy Static App Options")).middleware(() => {
+      AWS.config.region = CLOUDFRONT_REGION;
+    });
+  },
+  handler: ({ destroy: destroy2, ...rest }) => {
+    if (destroy2) {
+      destroyCloudFormation();
+    } else {
+      deployStaticApp(rest);
+    }
+  }
+};
+var logPrefix17 = "deploy vercel";
+var makeCommand = (cmds) => {
+  return cmds.filter((cmd) => {
+    return cmd !== void 0 && cmd !== null && cmd !== "";
+  }).join(" ");
+};
+var deployVercel = async ({ token }) => {
+  try {
+    log5.info(logPrefix17, "Deploying on Vercel...");
+    const environment = getEnvironment();
+    const finalToken = token || process.env.VERCEL_TOKEN;
+    if (!finalToken) {
+      throw new Error("Missing Vercel token");
+    }
+    const cmdToken = finalToken ? `--token=${finalToken}` : "";
+    const cmdProdFlag = environment === "Production" ? "--prod" : "";
+    const cmdEnvironment = `--environment=${environment === "Production" ? "production" : "preview"}`;
+    const pullCmd = makeCommand([
+      "vercel",
+      "pull",
+      "--yes",
+      cmdEnvironment,
+      cmdToken
+    ]);
+    await spawn(pullCmd);
+    const buildCdm = makeCommand(["vercel", "build", cmdProdFlag, cmdToken]);
+    await spawn(buildCdm);
+    const deployCmd = makeCommand([
+      "vercel",
+      "deploy",
+      "--prebuilt",
+      cmdProdFlag,
+      cmdToken
+    ]);
+    await spawn(deployCmd);
+  } catch (error) {
+    handleDeployError({ error, logPrefix: logPrefix17 });
+  }
+};
+var logPrefix18 = "deploy vercel";
+var options4 = {
+  token: {
+    describe: "Vercel authorization token.",
+    type: "string"
+  }
+};
+var deployVercelCommand = {
+  command: "vercel",
+  describe: "Deploy on Vercel.",
+  builder: (yargs3) => {
+    return yargs3.options(
+      addGroupToOptions(options4, "Deploy on Vercel Options")
+    );
+  },
+  handler: ({ destroy: destroy2, ...rest }) => {
+    if (destroy2) {
+      log5.info(logPrefix18, "Destroy Vercel deployment not implemented yet.");
+    } else {
+      deployVercel(rest);
+    }
+  }
+};
+var readDockerfile = (dockerfilePath) => {
+  try {
+    return fs3.readFileSync(path.join(process.cwd(), dockerfilePath), "utf8");
+  } catch {
+    return "";
+  }
+};
+var logPrefix19 = "deploy";
+var checkAwsAccountId = async (awsAccountId) => {
+  try {
+    const currentAwsAccountId = await getAwsAccountId();
+    if (String(awsAccountId) !== String(currentAwsAccountId)) {
+      throw new Error(
+        `AWS account id does not match. Current is "${currentAwsAccountId}" but the defined in configuration files is "${awsAccountId}".`
+      );
+    }
+  } catch (error) {
+    if (error.code === "CredentialsError") {
+      return;
+    }
+    log5.error(logPrefix19, error.message);
+    process.exit();
+  }
+};
+var describeDeployCommand = {
+  command: "describe",
+  describe: "Print the outputs of the deployment.",
+  handler: async ({ stackName }) => {
+    try {
+      const newStackName = stackName || await getStackName();
+      await printStackOutputsAfterDeploy({ stackName: newStackName });
+    } catch (error) {
+      log5.info(logPrefix19, "Cannot describe stack. Message: %s", error.message);
+    }
+  }
+};
+var options5 = {
+  "aws-account-id": {
+    describe: "AWS account id associated with the deployment.",
+    type: "string"
+  },
+  destroy: {
+    default: false,
+    describe: 'Destroy the deployment. You cannot destroy a deploy when "environment" is defined.',
+    type: "boolean"
+  },
+  "lambda-dockerfile": {
+    coerce: (arg) => {
+      return readDockerfile(arg);
+    },
+    default: "Dockerfile",
+    describe: "Instructions to create the Lambda image.",
+    type: "string"
+  },
+  "lambda-image": {
+    default: false,
+    describe: "A Lambda image will be created instead using S3.",
+    type: "boolean"
+  },
+  "lambda-external": {
+    default: [],
+    describe: "External modules that will not be bundled in the Lambda code.",
+    type: "array"
+  },
+  "lambda-entry-points-base-dir": {
+    default: "src",
+    describe: "Base directory for Lambda entry points.",
+    type: "string"
+  },
+  "lambda-entry-points": {
+    default: [],
+    describe: "This is an array of files that each serve as an input to the bundling algorithm for Lambda functions.",
+    type: "string"
+  },
+  "lambda-format": {
+    choices: ["esm", "cjs"],
+    default: "esm",
+    describe: "Lambda code format.",
+    type: "string"
+  },
+  "lambda-outdir": {
+    default: "dist",
+    describe: "Output directory for built Lambda code.",
+    type: "string"
+  },
+  /**
+   * This option has the format to match [CloudFormation parameter](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html).
+   *
+   * ```ts
+   * {
+   *  key: string,
+   *  value: string,
+   *  usePreviousValue: boolean,
+   *  resolvedValue: string
+   * }[]
+   * ```
+   *
+   * For example:
+   *
+   * ```ts
+   * [
+   *  {
+   *    key: 'key1',
+   *    value: 'value1',
+   *  },
+   *  {
+   *    key: 'key2',
+   *    value: 'value2',
+   *  }
+   * ]
+   * ```
+   *
+   * If you want to simplify the usage, you can pass a object with key and value only:
+   *
+   * ```ts
+   * {
+   *  key1: 'value1',
+   *  key2: 'value2'
+   * }
+   * ```
+   */
+  parameters: {
+    alias: "p",
+    coerce: (arg) => {
+      if (Array.isArray(arg)) {
+        return arg;
+      }
+      if (typeof arg === "object") {
+        return Object.entries(arg).map(([key, value]) => {
+          return {
+            key,
+            value
+          };
+        });
+      }
+      return [];
+    },
+    default: [],
+    describe: "A list of parameters that will be passed to CloudFormation Parameters when deploying."
+  },
+  "skip-deploy": {
+    alias: "skip",
+    default: false,
+    describe: "Skip the deploy command.",
+    type: "boolean"
+  },
+  "stack-name": {
+    describe: "Set the stack name.",
+    type: "string"
+  },
+  "template-path": {
+    alias: "t",
+    describe: "Path to the CloudFormation template.",
+    type: "string"
+  }
+};
+var examples = [
+  [
+    "carlin deploy -t src/cloudformation.template1.yml",
+    "Change the CloudFormation template path."
+  ],
+  ["carlin deploy -e Production", "Set environment."],
+  [
+    "carlin deploy --lambda-externals momentjs",
+    "Lambda exists. Don't bundle momentjs."
+  ],
+  [
+    "carlin deploy --destroy --stack-name StackToBeDeleted",
+    "Destroy a specific stack."
+  ]
+];
+var deployCommand = {
+  command: "deploy [deploy]",
+  describe: "Deploy cloud resources.",
+  builder: (yargsBuilder) => {
+    yargsBuilder.example(examples).options(addGroupToOptions(options5, "Deploy Options")).middleware(({ stackName }) => {
+      if (stackName) {
+        setPreDefinedStackName(stackName);
+      }
+    }).middleware((argv) => {
+      if (argv.lambdaDockerfile) {
+        Object.assign(argv, {
+          lambdaImage: true
+        });
+      }
+    }).middleware(
+      async ({
+        environments,
+        environment,
+        awsAccountId: defaultAwsAccountId
+      }) => {
+        const envAwsAccountId = (() => {
+          return environments && environment && environments[environment] ? environments[environment].awsAccountId : void 0;
+        })();
+        if (envAwsAccountId) {
+          await checkAwsAccountId(envAwsAccountId);
+        }
+        if (defaultAwsAccountId) {
+          await checkAwsAccountId(defaultAwsAccountId);
+        }
+      }
+    ).middleware(({ skipDeploy }) => {
+      if (skipDeploy) {
+        log5.warn(
+          logPrefix19,
+          "Skip deploy flag is true, then the deploy command wasn't executed."
+        );
+        process.exit(0);
+      }
+    }).middleware(({ lambdaExternals, lambdaInput }) => {
+      if (lambdaInput) {
+        throw new Error(
+          'Option "lambdaInput" was removed. Please use "lambdaEntryPoints" instead.'
+        );
+      }
+      if (lambdaExternals) {
+        throw new Error(
+          'Option "lambdaExternals" was removed. Please use "lambdaExternal" instead.'
+        );
+      }
+    });
+    const commands = [
+      deployLambdaLayerCommand,
+      describeDeployCommand,
+      deployBaseStackCommand,
+      deployStaticAppCommand,
+      deployCicdCommand,
+      deployVercelCommand
+    ];
+    yargsBuilder.positional("deploy", {
+      choices: commands.map(({ command }) => {
+        return command;
+      }),
+      describe: "Deploy command.",
+      type: "string"
+    });
+    commands.forEach((command) => {
+      return yargsBuilder.command(command);
+    });
+    return yargsBuilder;
+  },
+  handler: ({ destroy: destroy2, ...rest }) => {
+    if (destroy2) {
+      destroyCloudFormation();
+    } else {
+      deployCloudFormation(rest);
+    }
+  }
+};
+var logPrefix20 = "cicd-ecs-task-report";
+var sendEcsTaskReport = async ({ status }) => {
+  if (!process.env.ECS_TASK_REPORT_HANDLER_NAME) {
+    log5.info(logPrefix20, "ECS_TASK_REPORT_HANDLER_NAME not defined.");
+    return;
+  }
+  const lambda = new AWS.Lambda();
+  const payload = { status };
+  if (process.env.ECS_TASK_ARN) {
+    payload.ecsTaskArn = process.env.ECS_TASK_ARN;
+  }
+  if (process.env.PIPELINE_NAME) {
+    payload.pipelineName = process.env.PIPELINE_NAME;
+  }
+  await lambda.invokeAsync({
+    FunctionName: process.env.ECS_TASK_REPORT_HANDLER_NAME,
+    InvokeArgs: JSON.stringify(payload)
+  }).promise();
+  log5.info(logPrefix20, "Report sent.");
+};
+var options6 = {
+  status: {
+    choices: ["Approved", "Rejected", "MainTagFound"],
+    demandOption: true,
+    type: "string"
+  }
+};
+var ecsTaskReportCommand = {
+  command: "cicd-ecs-task-report",
+  describe: false,
+  builder: (yargs3) => {
+    return yargs3.options(options6);
+  },
+  handler: async (args) => {
+    return sendEcsTaskReport(args);
+  }
+};
+var logPrefix21 = "generate-env";
+var readEnvFile = async ({
+  envFileName,
+  envsPath
+}) => {
+  try {
+    const content = await fs3.promises.readFile(
+      path.resolve(process.cwd(), envsPath, envFileName),
+      "utf8"
+    );
+    return content;
+  } catch {
+    return void 0;
+  }
+};
+var writeEnvFile = async ({
+  envFileName,
+  content
+}) => {
+  return fs3.promises.writeFile(
+    path.resolve(process.cwd(), envFileName),
+    content
+  );
+};
+var generateEnv = async ({
+  defaultEnvironment,
+  path: envsPath
+}) => {
+  const environment = getEnvironment() || defaultEnvironment;
+  const envFileName = `.env.${environment}`;
+  const envFile = await readEnvFile({ envFileName, envsPath });
+  if (!envFile) {
+    log5.info(
+      logPrefix21,
+      "Env file %s doesn't exist. Skip generating env file.",
+      envFileName
+    );
+    return;
+  }
+  await writeEnvFile({ content: envFile, envFileName: ".env" });
+  log5.info(
+    logPrefix21,
+    "Generate env file %s from %s successfully.",
+    ".env",
+    envFileName
+  );
+};
+
+// src/generateEnv/generateEnvCommand.ts
+var DEFAULT_ENVIRONMENT = "Staging";
+var options7 = {
+  "default-environment": {
+    alias: "d",
+    type: "string",
+    describe: "Default environment.",
+    default: DEFAULT_ENVIRONMENT
+  },
+  path: {
+    alias: "p",
+    type: "string",
+    describe: "Path to the directory where envs files are located.",
+    default: "./"
+  }
+};
+var generateEnvCommand = {
+  command: ["generate-env", "ge", "env"],
+  describe: "Generate environment files.",
+  builder: (yargs3) => {
+    return yargs3.options(options7);
+  },
+  handler: (args) => {
+    return generateEnv(args);
+  }
+};
+var coerceSetEnvVar = (env) => {
+  return (value) => {
+    setEnvVar(env, value);
+    return value;
+  };
+};
+var options8 = {
+  branch: {
+    coerce: coerceSetEnvVar("BRANCH"),
+    require: false,
+    type: "string"
+  },
+  config: {
+    alias: "c",
+    describe: "Path to config file. You can create a config file and set all options there. Valid extensions: .js, .json, .ts, .yml, or .yaml.",
+    require: false,
+    type: "string"
+  },
+  environment: {
+    alias: ["e", "env"],
+    coerce: coerceSetEnvVar("ENVIRONMENT"),
+    type: "string"
+  },
+  environments: {},
+  project: {
+    coerce: coerceSetEnvVar("PROJECT"),
+    require: false,
+    type: "string"
+  },
+  region: {
+    alias: "r",
+    default: AWS_DEFAULT_REGION,
+    describe: "AWS region.",
+    type: "string"
+  }
+};
+var getPkgConfig = () => {
+  return NAME;
+};
+var getEnv = () => {
+  return constantCase(NAME);
+};
+var cli = () => {
+  let finalConfig;
+  const getConfig = () => {
+    const names = ["ts", "js", "yml", "yaml", "json"].map((ext) => {
+      return `${NAME}.${ext}`;
+    });
+    const paths = [];
+    let currentPath = process.cwd();
+    let findUpPath;
+    do {
+      findUpPath = findUpSync(names, { cwd: currentPath });
+      if (findUpPath) {
+        currentPath = path__default.resolve(findUpPath, "../..");
+        paths.push(findUpPath);
+      }
+    } while (findUpPath);
+    const configs = paths.map((p) => {
+      return readConfigFileSync({ configFilePath: p }) || {};
+    });
+    finalConfig = deepmerge.all(configs.reverse());
+    return finalConfig;
+  };
+  const handleEnvironments = (argv, { parsed }) => {
+    const { environment, environments } = argv;
+    if (environment && environments && environments[environment]) {
+      Object.entries(environments[environment]).forEach(([key, value]) => {
+        const isKeyFromCli = (() => {
+          const kebabCaseKey = kebabCase(key);
+          if (parsed?.defaulted?.[kebabCaseKey]) {
+            return false;
+          }
+          if (deepEqual(argv[key], finalConfig[key])) {
+            return false;
+          }
+          return true;
+        })();
+        if (!isKeyFromCli) {
+          argv[key] = value;
+        }
+      });
+    }
+  };
+  return yargs(hideBin(process.argv)).strictCommands().scriptName(NAME).env(getEnv()).options(addGroupToOptions(options8, "Common Options")).middleware((argv) => {
+    const finalEnvironment = argv.environment || process.env.ENVIRONMENT;
+    if (finalEnvironment) {
+      setEnvVar("ENVIRONMENT", finalEnvironment);
+      const envKeys = ["environment", ...options8.environment.alias];
+      const envEntries = envKeys.map((key) => {
+        return [key, finalEnvironment];
+      });
+      Object.assign(argv, Object.fromEntries(envEntries));
+    }
+  }).middleware(handleEnvironments).middleware(({ environment }) => {
+    if (!["string", "undefined"].includes(typeof environment)) {
+      throw new Error(
+        `environment type is invalid. The value: ${JSON.stringify(
+          environment
+        )}`
+      );
+    }
+  }).middleware(({ region }) => {
+    AWS.config.region = region;
+    setEnvVar("REGION", region);
+  }).pkgConf(getPkgConfig()).config(getConfig()).config("config", (configFilePath) => {
+    return readConfigFileSync({ configFilePath });
+  }).command({
+    command: "print-args",
+    describe: false,
+    handler: (argv) => {
+      return console.log(JSON.stringify(argv, null, 2));
+    }
+  }).command(deployCommand).command(ecsTaskReportCommand).command(generateEnvCommand).epilogue(
+    "For more information, read our docs at https://ttoss.dev/docs/carlin/"
+  ).help();
+};
+
+// src/index.ts
+cli().parse();