carlin 1.19.11 → 1.19.13

package/dist/deploy/cloudFormation.core.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroy = exports.canDestroyStack = exports.deploy = exports.defaultTemplatePaths = exports.enableTerminationProtection = exports.updateStack = exports.createStack = exports.deleteStack = exports.printStackOutputsAfterDeploy = exports.getStackOutput = exports.describeStack = exports.describeStackEvents = exports.doesStackExist = exports.describeStackResource = exports.describeStacks = exports.cloudFormationV2 = exports.cloudFormation = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const utils_1 = require("../utils");
+const addDefaults_cloudFormation_1 = require("./addDefaults.cloudFormation");
+const s3_1 = require("./s3");
+const stackName_1 = require("./stackName");
+const aws_sdk_1 = tslib_1.__importDefault(require("aws-sdk"));
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const logPrefix = 'cloudformation';
+npmlog_1.default.addLevel('event', 10000, { fg: 'yellow' });
+npmlog_1.default.addLevel('output', 10000, { fg: 'blue' });
+/**
+ * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html
+ */
+const TEMPLATE_BODY_MAX_SIZE = 51200;
+const isTemplateBodyGreaterThanMaxSize = (template) => Buffer.byteLength(JSON.stringify(template), 'utf8') >= TEMPLATE_BODY_MAX_SIZE;
+/**
+ * Update CloudFormation template to base stack bucket.
+ * @param input.stackName: CloudFormation stack name.
+ * @param input.template: CloudFormation template.
+ */
+const uploadTemplateToBaseStackBucket = async ({ stackName, template, }) => {
+    // eslint-disable-next-line no-console
+    console.info({ stackName, template });
+    // eslint-disable-next-line no-console
+    console.log('uploadTemplateToBaseStackBucket needs to be implemented.');
+    throw new Error();
+    // const key = getPepeBucketTemplateKey({ stackName });
+    // return uploadFileToS3({
+    //   bucket: await getPepeBucketName(),
+    //   contentType: 'application/json',
+    //   file: Buffer.from(JSON.stringify(template, null, 2)),
+    //   key,
+    // });
+};
+const cloudFormation = () => {
+    return new client_cloudformation_1.CloudFormationClient({
+        apiVersion: '2010-05-15',
+        region: (0, utils_1.getEnvVar)('REGION'),
+    });
+};
+exports.cloudFormation = cloudFormation;
+const cloudFormationV2 = () => {
+    return new aws_sdk_1.default.CloudFormation({ apiVersion: '2010-05-15' });
+};
+exports.cloudFormationV2 = cloudFormationV2;
+const describeStacks = async ({ stackName, } = {}) => {
+    const { Stacks } = await (0, exports.cloudFormation)().send(new client_cloudformation_1.DescribeStacksCommand({ StackName: stackName }));
+    return Stacks;
+};
+exports.describeStacks = describeStacks;
+const describeStackResource = async (input) => {
+    return (0, exports.cloudFormation)().send(new client_cloudformation_1.DescribeStackResourceCommand(input));
+};
+exports.describeStackResource = describeStackResource;
+const doesStackExist = async ({ stackName }) => {
+    npmlog_1.default.info(logPrefix, `Checking if stack ${stackName} already exists...`);
+    try {
+        await (0, exports.describeStacks)({ stackName });
+        npmlog_1.default.info(logPrefix, `Stack ${stackName} already exists.`);
+        return true;
+    }
+    catch (error) {
+        if (error.Code === 'ValidationError') {
+            npmlog_1.default.info(logPrefix, `Stack ${stackName} does not exist.`);
+            return false;
+        }
+        throw error;
+    }
+};
+exports.doesStackExist = doesStackExist;
+const describeStackEvents = async ({ stackName, }) => {
+    npmlog_1.default.error(logPrefix, 'Stack events:');
+    const { StackEvents } = await (0, exports.cloudFormation)().send(new client_cloudformation_1.DescribeStackEventsCommand({ StackName: stackName }));
+    const events = (StackEvents || [])
+        .filter(({ Timestamp }) => Date.now() - Number(Timestamp) < 10 * 60 * 1000)
+        .filter(({ ResourceStatusReason }) => ResourceStatusReason)
+        /**
+         * Show newer events last.
+         */
+        .reverse();
+    events.forEach(({ LogicalResourceId, ResourceStatusReason }) => npmlog_1.default.event(LogicalResourceId, ResourceStatusReason));
+    return events;
+};
+exports.describeStackEvents = describeStackEvents;
+const describeStack = async ({ stackName }) => {
+    const stacks = await (0, exports.describeStacks)({ stackName });
+    if (!stacks) {
+        throw new Error(`Stack ${stackName} not found and cannot be described.`);
+    }
+    return stacks[0];
+};
+exports.describeStack = describeStack;
+const getStackOutput = async ({ stackName, outputKey, }) => {
+    const { Outputs = [] } = await (0, exports.describeStack)({ stackName });
+    const output = Outputs === null || Outputs === void 0 ? void 0 : Outputs.find(({ OutputKey }) => OutputKey === outputKey);
+    if (!output) {
+        throw new Error(`Output ${outputKey} doesn't exist on ${stackName} stack`);
+    }
+    return output;
+};
+exports.getStackOutput = getStackOutput;
+const saveEnvironmentOutput = async ({ outputs, }) => {
+    const stackName = await (0, stackName_1.getStackName)();
+    const envFile = { stackName, outputs };
+    const dotCarlinFolderPath = path.join(process.cwd(), '.carlin');
+    if (!fs.existsSync(dotCarlinFolderPath)) {
+        await fs.promises.mkdir(dotCarlinFolderPath);
+    }
+    const filePath = path.join(dotCarlinFolderPath, `${stackName}.json`);
+    await fs.promises.writeFile(filePath, JSON.stringify(envFile, null, 2));
+};
+const printStackOutputsAfterDeploy = async ({ stackName, }) => {
+    const { EnableTerminationProtection, StackName, Outputs = [], } = await (0, exports.describeStack)({ stackName });
+    await saveEnvironmentOutput({ outputs: Outputs });
+    npmlog_1.default.output('Describe Stack');
+    npmlog_1.default.output('StackName', StackName);
+    npmlog_1.default.output('EnableTerminationProtection', EnableTerminationProtection);
+    Outputs.forEach(({ OutputKey, OutputValue, Description, ExportName }) => {
+        npmlog_1.default.output(`${OutputKey}`, [
+            '',
+            `OutputKey: ${OutputKey}`,
+            `OutputValue: ${OutputValue}`,
+            `Description: ${Description}`,
+            `ExportName: ${ExportName}`,
+            '',
+        ].join('\n'));
+    });
+};
+exports.printStackOutputsAfterDeploy = printStackOutputsAfterDeploy;
+const deleteStack = async ({ stackName }) => {
+    npmlog_1.default.info(logPrefix, `Deleting stack ${stackName}...`);
+    await (0, exports.cloudFormation)().send(new client_cloudformation_1.DeleteStackCommand({ StackName: stackName }));
+    try {
+        await (0, exports.cloudFormationV2)()
+            .waitFor('stackDeleteComplete', { StackName: stackName })
+            .promise();
+    }
+    catch (err) {
+        npmlog_1.default.error(logPrefix, `An error occurred when deleting stack ${stackName}.`);
+        await (0, exports.describeStackEvents)({ stackName });
+        throw err;
+    }
+    npmlog_1.default.info(logPrefix, `Stack ${stackName} deleted.`);
+};
+exports.deleteStack = deleteStack;
+const createStack = async ({ params, }) => {
+    const { StackName: stackName } = params;
+    npmlog_1.default.info(logPrefix, `Creating stack ${stackName}...`);
+    await (0, exports.cloudFormation)().send(new client_cloudformation_1.CreateStackCommand(params));
+    try {
+        await (0, exports.cloudFormationV2)()
+            .waitFor('stackCreateComplete', { StackName: stackName })
+            .promise();
+    }
+    catch (err) {
+        npmlog_1.default.error(logPrefix, `An error occurred when creating stack ${stackName}.`);
+        await (0, exports.describeStackEvents)({ stackName });
+        await (0, exports.deleteStack)({ stackName });
+        throw err;
+    }
+    npmlog_1.default.info(logPrefix, `Stack ${stackName} was created.`);
+};
+exports.createStack = createStack;
+const updateStack = async ({ params, }) => {
+    const { StackName: stackName } = params;
+    npmlog_1.default.info(logPrefix, `Updating stack ${stackName}...`);
+    try {
+        await (0, exports.cloudFormation)().send(new client_cloudformation_1.UpdateStackCommand(params));
+        await (0, exports.cloudFormationV2)()
+            .waitFor('stackUpdateComplete', { StackName: stackName })
+            .promise();
+    }
+    catch (error) {
+        if (error.message === 'No updates are to be performed.') {
+            npmlog_1.default.info(logPrefix, error.message);
+            return;
+        }
+        npmlog_1.default.error(logPrefix, 'An error occurred when updating stack.');
+        await (0, exports.describeStackEvents)({ stackName });
+        throw error;
+    }
+    npmlog_1.default.info(logPrefix, `Stack ${stackName} was updated.`);
+};
+exports.updateStack = updateStack;
+const enableTerminationProtection = async ({ stackName, }) => {
+    npmlog_1.default.info(logPrefix, `Enabling termination protection...`);
+    try {
+        await (0, exports.cloudFormation)().send(new client_cloudformation_1.UpdateTerminationProtectionCommand({
+            EnableTerminationProtection: true,
+            StackName: stackName,
+        }));
+    }
+    catch (err) {
+        npmlog_1.default.error(logPrefix, 'An error occurred when enabling termination protection');
+        throw err;
+    }
+};
+exports.enableTerminationProtection = enableTerminationProtection;
+exports.defaultTemplatePaths = ['ts', 'js', 'yaml', 'yml', 'json'].map((extension) => `src/cloudformation.${extension}`);
+/**
+ * 1. Add defaults to CloudFormation template and parameters.
+ * 1. Check is CloudFormation template body is greater than max size limit.
+ *  1. If is greater, upload to S3 base stack.
+ * 1. If stack exists, update the stack, else create a new stack.
+ * 1. If `terminationProtection` option is true or `environment` is defined,
+ * then stack termination protection will be enabled.
+ */
+const deploy = async ({ terminationProtection = false, ...paramsAndTemplate }) => {
+    const { params, template } = await (0, addDefaults_cloudFormation_1.addDefaults)(paramsAndTemplate);
+    const stackName = params.StackName;
+    delete params.TemplateBody;
+    delete params.TemplateURL;
+    if (isTemplateBodyGreaterThanMaxSize(template)) {
+        const { url } = await uploadTemplateToBaseStackBucket({
+            stackName,
+            template,
+        });
+        params.TemplateURL = url;
+    }
+    else {
+        params.TemplateBody = JSON.stringify(template);
+    }
+    /**
+     * CAPABILITY_AUTO_EXPAND allows serverless transform.
+     */
+    params.Capabilities = [
+        'CAPABILITY_AUTO_EXPAND',
+        'CAPABILITY_IAM',
+        'CAPABILITY_NAMED_IAM',
+    ];
+    if (await (0, exports.doesStackExist)({ stackName })) {
+        await (0, exports.updateStack)({ params });
+    }
+    else {
+        await (0, exports.createStack)({ params });
+    }
+    if (terminationProtection || !!(0, utils_1.getEnvironment)()) {
+        await (0, exports.enableTerminationProtection)({ stackName });
+    }
+    await (0, exports.printStackOutputsAfterDeploy)({ stackName });
+    return (0, exports.describeStack)({ stackName });
+};
+exports.deploy = deploy;
+const canDestroyStack = async ({ stackName }) => {
+    const { EnableTerminationProtection } = await (0, exports.describeStack)({ stackName });
+    if (EnableTerminationProtection) {
+        return false;
+    }
+    return true;
+};
+exports.canDestroyStack = canDestroyStack;
+const emptyStackBuckets = async ({ stackName }) => {
+    const buckets = [];
+    await (async function getBuckets({ nextToken }) {
+        const { NextToken, StackResourceSummaries } = await (0, exports.cloudFormation)().send(new client_cloudformation_1.ListStackResourcesCommand({
+            StackName: stackName,
+            NextToken: nextToken,
+        }));
+        if (NextToken) {
+            await getBuckets({ nextToken: NextToken });
+        }
+        (StackResourceSummaries || []).forEach(({ ResourceType, PhysicalResourceId }) => {
+            if (ResourceType === 'AWS::S3::Bucket' && PhysicalResourceId) {
+                buckets.push(PhysicalResourceId);
+            }
+        });
+    })({});
+    return Promise.all(buckets.map((bucket) => (0, s3_1.emptyS3Directory)({ bucket })));
+};
+/**
+ * 1. Check if `environment` is defined. If defined, return. It doesn't destroy
+ * stacks with defined `environment`.
+ * 1. Check if termination protection is disabled.
+ * 1. If the stack deployed buckets, empty all buckets.
+ * 1. Delete the stack.
+ */
+const destroy = async ({ stackName }) => {
+    const environment = (0, utils_1.getEnvironment)();
+    if (environment) {
+        npmlog_1.default.info(logPrefix, `Cannot destroy stack when environment (${environment}) is defined.`);
+        return;
+    }
+    if (!(await (0, exports.doesStackExist)({ stackName }))) {
+        npmlog_1.default.info(logPrefix, `Stack ${stackName} doesn't exist.`);
+        return;
+    }
+    if (!(await (0, exports.canDestroyStack)({ stackName }))) {
+        const message = `Stack ${stackName} cannot be destroyed while TerminationProtection is enabled.`;
+        throw new Error(message);
+    }
+    await emptyStackBuckets({ stackName });
+    await (0, exports.deleteStack)({ stackName });
+};
+exports.destroy = destroy;

package/dist/deploy/cloudFormation.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroyCloudFormation = exports.deployCloudFormation = exports.defaultTemplatePaths = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("../utils");
+const cloudFormation_core_1 = require("./cloudFormation.core");
+const deployLambdaCode_1 = require("./lambda/deployLambdaCode");
+const s3_1 = require("./s3");
+const stackName_1 = require("./stackName");
+const utils_2 = require("./utils");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const logPrefix = 'cloudformation';
+npmlog_1.default.addLevel('event', 10000, { fg: 'yellow' });
+npmlog_1.default.addLevel('output', 10000, { fg: 'blue' });
+exports.defaultTemplatePaths = ['ts', 'js', 'yaml', 'yml', 'json'].map((extension) => `./src/cloudformation.${extension}`);
+const findAndReadCloudFormationTemplate = ({ templatePath: defaultTemplatePath, }) => {
+    const templatePath = defaultTemplatePath ||
+        exports.defaultTemplatePaths
+            /**
+             * Iterate over extensions. If the template of the current extension is
+             * found, we save it on the accumulator and return it every time until
+             * the loop ends.
+             */
+            .reduce((acc, cur) => {
+            if (acc) {
+                return acc;
+            }
+            return fs_1.default.existsSync(path_1.default.resolve(process.cwd(), cur)) ? cur : acc;
+        }, '');
+    if (!templatePath) {
+        throw new Error('Cannot find a CloudFormation template.');
+    }
+    const extension = templatePath === null || templatePath === void 0 ? void 0 : templatePath.split('.').pop();
+    const fullPath = path_1.default.resolve(process.cwd(), templatePath);
+    /**
+     * We need to read Yaml first because CloudFormation specific tags aren't
+     * recognized when parsing a simple Yaml file. I.e., a possible error:
+     * "Error message: "unknown tag !<!Ref> at line 21, column 34:\n"
+     */
+    if (['yaml', 'yml'].includes(extension)) {
+        return (0, utils_1.readCloudFormationYamlTemplate)({ templatePath });
+    }
+    return (0, utils_1.readObjectFile)({ path: fullPath });
+};
+const deployCloudFormation = async ({ lambdaDockerfile, lambdaInput, lambdaImage, lambdaExternals = [], parameters, template, templatePath, }) => {
+    try {
+        const { stackName } = await (0, utils_2.handleDeployInitialization)({ logPrefix });
+        const cloudFormationTemplate = (() => {
+            if (template) {
+                return { ...template };
+            }
+            return findAndReadCloudFormationTemplate({ templatePath });
+        })();
+        await (0, cloudFormation_core_1.cloudFormationV2)()
+            .validateTemplate({
+            TemplateBody: JSON.stringify(cloudFormationTemplate, null, 2),
+        })
+            .promise();
+        const params = {
+            StackName: stackName,
+            Parameters: parameters || [],
+        };
+        const deployCloudFormationDeployLambdaCode = async () => {
+            const response = await (0, deployLambdaCode_1.deployLambdaCode)({
+                lambdaDockerfile,
+                lambdaExternals,
+                lambdaInput,
+                lambdaImage,
+                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) {
+                    /**
+                     * Add Parameters to CloudFormation template.
+                     */
+                    cloudFormationTemplate.Parameters = {
+                        LambdaS3Bucket: { Type: 'String' },
+                        LambdaS3Key: { Type: 'String' },
+                        LambdaS3ObjectVersion: { Type: 'String' },
+                        ...cloudFormationTemplate.Parameters,
+                    };
+                    /**
+                     * Add S3Bucket and S3Key to params.
+                     */
+                    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,
+                    });
+                }
+            }
+        };
+        await deployCloudFormationDeployLambdaCode();
+        const output = await (0, cloudFormation_core_1.deploy)({
+            params,
+            template: cloudFormationTemplate,
+        });
+        return output;
+    }
+    catch (error) {
+        return (0, utils_2.handleDeployError)({ error, logPrefix });
+    }
+};
+exports.deployCloudFormation = deployCloudFormation;
+const emptyStackBuckets = async ({ stackName }) => {
+    const buckets = [];
+    await (async function getBuckets({ nextToken }) {
+        const { NextToken, StackResourceSummaries } = await (0, cloudFormation_core_1.cloudFormationV2)()
+            .listStackResources({ StackName: stackName, NextToken: nextToken })
+            .promise();
+        if (NextToken) {
+            await getBuckets({ nextToken: NextToken });
+        }
+        (StackResourceSummaries || []).forEach(({ ResourceType, PhysicalResourceId }) => {
+            if (ResourceType === 'AWS::S3::Bucket' && PhysicalResourceId) {
+                buckets.push(PhysicalResourceId);
+            }
+        });
+    })({});
+    return Promise.all(buckets.map((bucket) => (0, s3_1.emptyS3Directory)({ bucket })));
+};
+/**
+ * 1. Check if `environment` is defined. If defined, return. It doesn't destroy
+ * stacks with defined `environment`.
+ * 1. Check if termination protection is disabled.
+ * 1. If the stack deployed buckets, empty all buckets.
+ * 1. Delete the stack.
+ */
+const destroy = async ({ stackName }) => {
+    const environment = (0, utils_1.getEnvironment)();
+    if (environment) {
+        npmlog_1.default.info(logPrefix, `Cannot destroy stack when environment (${environment}) is defined.`);
+        return;
+    }
+    if (!(await (0, cloudFormation_core_1.doesStackExist)({ stackName }))) {
+        npmlog_1.default.info(logPrefix, `Stack ${stackName} doesn't exist.`);
+        return;
+    }
+    if (!(await (0, cloudFormation_core_1.canDestroyStack)({ stackName }))) {
+        const message = `Stack ${stackName} cannot be destroyed while TerminationProtection is enabled.`;
+        throw new Error(message);
+    }
+    await emptyStackBuckets({ stackName });
+    await (0, cloudFormation_core_1.deleteStack)({ stackName });
+};
+const destroyCloudFormation = async ({ stackName: defaultStackName, } = {}) => {
+    try {
+        npmlog_1.default.info(logPrefix, 'CAUTION! Starting CloudFormation destroy...');
+        const stackName = defaultStackName || (await (0, stackName_1.getStackName)());
+        npmlog_1.default.info(logPrefix, `stackName: ${stackName}`);
+        await destroy({ stackName });
+    }
+    catch (error) {
+        (0, utils_2.handleDeployError)({ error, logPrefix });
+    }
+};
+exports.destroyCloudFormation = destroyCloudFormation;

package/dist/deploy/command.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = exports.examples = exports.options = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("../utils");
+const command_1 = require("./baseStack/command");
+const command_2 = require("./cicd/command");
+const cloudFormation_1 = require("./cloudFormation");
+const command_3 = require("./lambdaLayer/command");
+const command_4 = require("./staticApp/command");
+const stackName_1 = require("./stackName");
+const cloudFormation_core_1 = require("./cloudFormation.core");
+const readDockerfile_1 = require("./readDockerfile");
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const logPrefix = 'deploy';
+const checkAwsAccountId = async (awsAccountId) => {
+    try {
+        const currentAwsAccountId = await (0, utils_1.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) {
+        npmlog_1.default.error(logPrefix, error.message);
+        process.exit();
+    }
+};
+const describeDeployCommand = {
+    command: 'describe',
+    describe: 'Print the outputs of the deployment.',
+    handler: async ({ stackName }) => {
+        try {
+            const newStackName = stackName || (await (0, stackName_1.getStackName)());
+            await (0, cloudFormation_core_1.printStackOutputsAfterDeploy)({ stackName: newStackName });
+        }
+        catch (error) {
+            npmlog_1.default.info(logPrefix, 'Cannot describe stack. Message: %s', error.message);
+        }
+    },
+};
+exports.options = {
+    'aws-account-id': {
+        description: 'AWS account id associated with the deployment.',
+        type: 'string',
+    },
+    destroy: {
+        default: false,
+        description: 'Destroy the deployment. You cannot destroy a deploy with "environment" is defined.',
+        type: 'boolean',
+    },
+    'lambda-dockerfile': {
+        coerce: (arg) => (0, readDockerfile_1.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-externals': {
+        default: [],
+        describe: 'Lambda external packages.',
+        type: 'array',
+    },
+    'lambda-input': {
+        default: 'src/lambda.ts',
+        describe: 'Lambda input file. This file export all handlers used by the Lambda Functions.',
+        type: 'string',
+    },
+    /**
+     * This option has the format:
+     *
+     * ```ts
+     * Array<{
+     *  ParameterKey: string,
+     *  ParameterValue: string,
+     *  UsePreviousValue: true | false,
+     *  ResolvedValue: string
+     * }>
+     * ```
+     */
+    parameters: {
+        alias: 'p',
+        default: [],
+        describe: 'A list of parameters that will be passed to CloudFormation Parameters when deploying. The format is the same as parameters from cloudformation create-stack CLI command.',
+        type: 'array',
+    },
+    'skip-deploy': {
+        alias: 'skip',
+        default: false,
+        describe: 'Skip deploy.',
+        type: 'boolean',
+    },
+    'stack-name': {
+        describe: 'CloudFormation Stack name.',
+        type: 'string',
+    },
+    'template-path': {
+        alias: 't',
+        type: 'string',
+    },
+};
+exports.examples = [
+    [
+        'carlin deploy -t src/cloudformation.template1.yml',
+        'Change the CloudFormation template path.',
+    ],
+    ['carlin deploy -e Production', 'Set environment.'],
+    [
+        'carlin deploy --lambda-input src/lambda/index.ts --lambda-externals momentjs',
+        "Lambda exists. Don't bundle momentjs.",
+    ],
+    [
+        'carlin deploy --destroy --stack-name StackToBeDeleted',
+        'Destroy a specific stack.',
+    ],
+];
+exports.deployCommand = {
+    command: 'deploy [deploy]',
+    describe: 'Deploy cloud resources.',
+    builder: (yargsBuilder) => {
+        yargsBuilder
+            .example(exports.examples)
+            .options((0, utils_1.addGroupToOptions)(exports.options, 'Deploy Options'))
+            /**
+             * Set stack name.
+             */
+            .middleware(({ stackName }) => {
+            if (stackName)
+                (0, stackName_1.setPreDefinedStackName)(stackName);
+        })
+            /**
+             * Set lambdaImage if lambdaDockerfile exists.
+             */
+            .middleware((argv) => {
+            if (argv.lambdaDockerfile) {
+                // eslint-disable-next-line no-param-reassign
+                argv.lambdaImage = true;
+            }
+        })
+            /**
+             * Check AWS account id.
+             */
+            .middleware(async ({ environments, environment, awsAccountId: defaultAwsAccountId, }) => {
+            const envAwsAccountId = (() => {
+                return environments && environment && environments[environment]
+                    ? environments[environment].awsAccountId
+                    : undefined;
+            })();
+            if (defaultAwsAccountId || envAwsAccountId) {
+                await checkAwsAccountId(defaultAwsAccountId || envAwsAccountId);
+            }
+        })
+            .middleware(({ skipDeploy }) => {
+            if (skipDeploy) {
+                npmlog_1.default.warn(logPrefix, "Skip deploy flag is true, then the deploy command wasn't executed.");
+                process.exit(0);
+            }
+        });
+        const commands = [
+            command_3.deployLambdaLayerCommand,
+            describeDeployCommand,
+            command_1.deployBaseStackCommand,
+            command_4.deployStaticAppCommand,
+            command_2.deployCicdCommand,
+        ];
+        yargsBuilder.positional('deploy', {
+            choices: commands.map(({ command }) => command),
+            describe: 'Type of deployment.',
+            type: 'string',
+        });
+        commands.forEach((command) => yargsBuilder.command(command));
+        return yargsBuilder;
+    },
+    handler: ({ destroy, ...rest }) => {
+        if (destroy) {
+            (0, cloudFormation_1.destroyCloudFormation)();
+        }
+        else {
+            (0, cloudFormation_1.deployCloudFormation)(rest);
+        }
+    },
+};