carlin 0.19.0

package/dist/deploy/cicd/pipelines.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTagCommands = exports.getMainCommands = exports.getClosedPrCommands = exports.getPrCommands = exports.pipelines = void 0;
+exports.pipelines = ['pr', 'closed-pr', 'main', 'tag'];
+const executeCommandFile = (pipeline) => `chmod +x ./cicd/commands/${pipeline} && ./cicd/commands/${pipeline}`;
+const getPrCommands = ({ branch }) => [
+    'git status',
+    'git fetch',
+    /**
+     * Update to the most recent main branch to Lerna performs the diff properly.
+     */
+    'git pull origin main',
+    `git checkout ${branch}`,
+    `git pull origin ${branch}`,
+    'git rev-parse HEAD',
+    'git status',
+    'yarn',
+    executeCommandFile('pr'),
+];
+exports.getPrCommands = getPrCommands;
+const getClosedPrCommands = ({ branch }) => [
+    'git status',
+    'git fetch',
+    /**
+     * Get the most recent main because the PR was approved.
+     */
+    'git pull origin main',
+    'git rev-parse HEAD',
+    `export CARLIN_BRANCH=${branch}`,
+    executeCommandFile('closed-pr'),
+];
+exports.getClosedPrCommands = getClosedPrCommands;
+const getMainCommands = () => [
+    `export CARLIN_ENVIRONMENT=Staging`,
+    'git status',
+    'git fetch',
+    'git pull origin main',
+    'git rev-parse HEAD',
+    'yarn',
+    executeCommandFile('main'),
+];
+exports.getMainCommands = getMainCommands;
+const getTagCommands = ({ tag }) => [
+    `export CARLIN_ENVIRONMENT=Production`,
+    'git status',
+    'git fetch --tags',
+    `git checkout tags/${tag} -b ${tag}-branch`,
+    'git rev-parse HEAD',
+    'yarn',
+    executeCommandFile('tag'),
+];
+exports.getTagCommands = getTagCommands;

package/dist/deploy/cloudFormation.core.js

@@ -0,0 +1,286 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const aws_sdk_1 = __importDefault(require("aws-sdk"));
+const npmlog_1 = __importDefault(require("npmlog"));
+const utils_1 = require("../utils");
+const addDefaults_cloudFormation_1 = require("./addDefaults.cloudFormation");
+const s3_1 = require("./s3");
+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, }) => {
+    console.info({ stackName, template });
+    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: 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 exports.cloudFormation().send(new client_cloudformation_1.DescribeStacksCommand({ StackName: stackName }));
+    return Stacks;
+};
+exports.describeStacks = describeStacks;
+const describeStackResource = async (input) => {
+    return 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 exports.describeStacks({ stackName });
+        npmlog_1.default.info(logPrefix, `Stack ${stackName} already exists.`);
+        return true;
+    }
+    catch (err) {
+        if (err.Code === 'ValidationError') {
+            npmlog_1.default.info(logPrefix, `Stack ${stackName} does not exist.`);
+            return false;
+        }
+        throw err;
+    }
+};
+exports.doesStackExist = doesStackExist;
+const describeStackEvents = async ({ stackName, }) => {
+    npmlog_1.default.error(logPrefix, 'Stack events:');
+    const { StackEvents } = await 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 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 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 printStackOutputsAfterDeploy = async ({ stackName, }) => {
+    const { EnableTerminationProtection, StackName, Outputs, } = await exports.describeStack({ stackName });
+    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 exports.cloudFormation().send(new client_cloudformation_1.DeleteStackCommand({ StackName: stackName }));
+    try {
+        await exports.cloudFormationV2()
+            .waitFor('stackDeleteComplete', { StackName: stackName })
+            .promise();
+    }
+    catch (err) {
+        npmlog_1.default.error(logPrefix, `An error occurred when deleting stack ${stackName}.`);
+        await 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 exports.cloudFormation().send(new client_cloudformation_1.CreateStackCommand(params));
+    try {
+        await exports.cloudFormationV2()
+            .waitFor('stackCreateComplete', { StackName: stackName })
+            .promise();
+    }
+    catch (err) {
+        npmlog_1.default.error(logPrefix, `An error occurred when creating stack ${stackName}.`);
+        await exports.describeStackEvents({ stackName });
+        await 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 exports.cloudFormation().send(new client_cloudformation_1.UpdateStackCommand(params));
+        await exports.cloudFormationV2()
+            .waitFor('stackUpdateComplete', { StackName: stackName })
+            .promise();
+    }
+    catch (err) {
+        if (err.message === 'No updates are to be performed.') {
+            npmlog_1.default.info(logPrefix, err.message);
+            return;
+        }
+        npmlog_1.default.error(logPrefix, 'An error occurred when updating stack.');
+        await exports.describeStackEvents({ stackName });
+        throw err;
+    }
+    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 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 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 exports.doesStackExist({ stackName })) {
+        await exports.updateStack({ params });
+    }
+    else {
+        await exports.createStack({ params });
+    }
+    if (terminationProtection || !!utils_1.getEnvironment()) {
+        await exports.enableTerminationProtection({ stackName });
+    }
+    await exports.printStackOutputsAfterDeploy({ stackName });
+    return exports.describeStack({ stackName });
+};
+exports.deploy = deploy;
+const canDestroyStack = async ({ stackName }) => {
+    const { EnableTerminationProtection } = await 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 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) => 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 = utils_1.getEnvironment();
+    if (environment) {
+        npmlog_1.default.info(logPrefix, `Cannot destroy stack when environment (${environment}) is defined.`);
+        return;
+    }
+    if (!(await exports.doesStackExist({ stackName }))) {
+        npmlog_1.default.info(logPrefix, `Stack ${stackName} doesn't exist.`);
+        return;
+    }
+    if (!(await exports.canDestroyStack({ stackName }))) {
+        const message = `Stack ${stackName} cannot be destroyed while TerminationProtection is enabled.`;
+        throw new Error(message);
+    }
+    await emptyStackBuckets({ stackName });
+    await exports.deleteStack({ stackName });
+};
+exports.destroy = destroy;

package/dist/deploy/cloudFormation.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroyCloudFormation = exports.deployCloudFormation = exports.defaultTemplatePaths = void 0;
+const fs_1 = __importDefault(require("fs"));
+const npmlog_1 = __importDefault(require("npmlog"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../utils");
+const cloudFormation_core_1 = require("./cloudFormation.core");
+const lambda_1 = require("./lambda");
+const s3_1 = require("./s3");
+const stackName_1 = require("./stackName");
+const utils_2 = require("./utils");
+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) => `./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 utils_1.readCloudFormationYamlTemplate({ templatePath });
+    }
+    return utils_1.readObjectFile({ path: fullPath });
+};
+const deployCloudFormation = async ({ lambdaDockerfile, lambdaInput, lambdaImage, lambdaExternals = [], parameters, template, templatePath, }) => {
+    try {
+        const { stackName } = await utils_2.handleDeployInitialization({ logPrefix });
+        const cloudFormationTemplate = (() => {
+            if (template) {
+                return { ...template };
+            }
+            return findAndReadCloudFormationTemplate({ templatePath });
+        })();
+        await cloudFormation_core_1.cloudFormationV2()
+            .validateTemplate({
+            TemplateBody: JSON.stringify(cloudFormationTemplate, null, 2),
+        })
+            .promise();
+        const params = {
+            StackName: stackName,
+            Parameters: parameters || [],
+        };
+        /**
+         * 1. If Lambda code exists, build and upload the code to base stack bucket.
+         *
+         *     1. If `lambdaImage` is `false`, retrieve the `bucket`, `key`, and
+         *     `version` of the uploaded code and pass to CloudFormation template
+         *     as [parameters](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html).
+         *
+         *     1. If `lambdaImage` is `true`, a Lambda image will be created and the
+         *     image URI will be passed to CloudFormation as parameter.
+         */
+        const deployCloudFormationDeployLambdaCode = async () => {
+            const response = await lambda_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' },
+                        LambdaS3Version: { 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}
+                     */
+                    {
+                        ParameterKey: 'LambdaS3ObjectVersion',
+                        ParameterValue: versionId,
+                    }, 
+                    /**
+                     * Used by CloudFormation AWS::Serverless::Function
+                     * @see {@link https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html}
+                     */
+                    {
+                        ParameterKey: 'LambdaS3Version',
+                        ParameterValue: versionId,
+                    });
+                }
+            }
+        };
+        await deployCloudFormationDeployLambdaCode();
+        const output = await cloudFormation_core_1.deploy({
+            params,
+            template: cloudFormationTemplate,
+        });
+        return output;
+    }
+    catch (error) {
+        return utils_2.handleDeployError({ error, logPrefix });
+    }
+};
+exports.deployCloudFormation = deployCloudFormation;
+const emptyStackBuckets = async ({ stackName }) => {
+    const buckets = [];
+    await (async function getBuckets({ nextToken }) {
+        const { NextToken, StackResourceSummaries, } = await 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) => 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 = utils_1.getEnvironment();
+    if (environment) {
+        npmlog_1.default.info(logPrefix, `Cannot destroy stack when environment (${environment}) is defined.`);
+        return;
+    }
+    if (!(await cloudFormation_core_1.doesStackExist({ stackName }))) {
+        npmlog_1.default.info(logPrefix, `Stack ${stackName} doesn't exist.`);
+        return;
+    }
+    if (!(await cloudFormation_core_1.canDestroyStack({ stackName }))) {
+        const message = `Stack ${stackName} cannot be destroyed while TerminationProtection is enabled.`;
+        throw new Error(message);
+    }
+    await emptyStackBuckets({ stackName });
+    await cloudFormation_core_1.deleteStack({ stackName });
+};
+const destroyCloudFormation = async ({ stackName: defaultStackName, } = {}) => {
+    try {
+        npmlog_1.default.info(logPrefix, 'CAUTION! Starting CloudFormation destroy...');
+        const stackName = defaultStackName || (await stackName_1.getStackName());
+        npmlog_1.default.info(logPrefix, `stackName: ${stackName}`);
+        await destroy({ stackName });
+    }
+    catch (error) {
+        utils_2.handleDeployError({ error, logPrefix });
+    }
+};
+exports.destroyCloudFormation = destroyCloudFormation;