carlin 1.19.11 → 1.19.13

package/dist/deploy/lambda/buildLambdaSingleFile.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLambdaSingleFile = void 0;
+const tslib_1 = require("tslib");
+const esbuild = tslib_1.__importStar(require("esbuild"));
+const builtin_modules_1 = tslib_1.__importDefault(require("builtin-modules"));
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const logPrefix = 'lambda';
+const outFolder = 'dist';
+const outFile = 'index.js';
+const buildLambdaSingleFile = async ({ lambdaExternals, lambdaInput, }) => {
+    npmlog_1.default.info(logPrefix, 'Building Lambda single file...');
+    const { errors } = esbuild.buildSync({
+        banner: {
+            js: '// Powered by carlin (https://ttoss.dev)',
+        },
+        bundle: true,
+        entryPoints: [path_1.default.resolve(process.cwd(), lambdaInput)],
+        external: ['aws-sdk', ...builtin_modules_1.default, ...lambdaExternals],
+        platform: 'node',
+        outfile: path_1.default.join(process.cwd(), outFolder, outFile),
+        target: 'node12',
+        treeShaking: true,
+    });
+    if (errors.length > 0) {
+        throw errors;
+    }
+};
+exports.buildLambdaSingleFile = buildLambdaSingleFile;

package/dist/deploy/lambda/deployLambdaCode.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployLambdaCode = void 0;
+const tslib_1 = require("tslib");
+const buildLambdaSingleFile_1 = require("./buildLambdaSingleFile");
+const deployLambdaLayers_1 = require("./deployLambdaLayers");
+const uploadCodeToECR_1 = require("./uploadCodeToECR");
+const uploadCodeToS3_1 = require("./uploadCodeToS3");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const logPrefix = 'lambda';
+/**
+ * 1. Build Lambda code using esbuild. The build process will create a single
+ * file with all your code.
+ *  1. The build will ignore packages on `lambda-externals` option.
+ * 1. Zip the output file.
+ * 1. Upload the zipped code to base stack bucket.
+ * 1. Add the code bucket, key and version to the CloudFormation template as
+ * parameters.
+ */
+const deployLambdaCode = async ({ lambdaDockerfile, lambdaExternals, lambdaImage, lambdaInput, stackName, }) => {
+    if (!fs_1.default.existsSync(lambdaInput)) {
+        return undefined;
+    }
+    npmlog_1.default.info(logPrefix, 'Deploying Lambda code...');
+    await (0, buildLambdaSingleFile_1.buildLambdaSingleFile)({ lambdaExternals, lambdaInput });
+    const { bucket, key, versionId } = await (0, uploadCodeToS3_1.uploadCodeToS3)({ stackName });
+    if (!lambdaImage) {
+        await (0, deployLambdaLayers_1.deployLambdaLayers)({ lambdaExternals });
+        return { bucket, key, versionId };
+    }
+    const { imageUri } = await (0, uploadCodeToECR_1.uploadCodeToECR)({
+        bucket,
+        key,
+        versionId,
+        lambdaDockerfile,
+        lambdaExternals,
+    });
+    return { imageUri };
+};
+exports.deployLambdaCode = deployLambdaCode;

package/dist/deploy/lambda/deployLambdaLayers.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployLambdaLayers = void 0;
+const tslib_1 = require("tslib");
+const deployLambdaLayer_1 = require("../lambdaLayer/deployLambdaLayer");
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const logPrefix = 'lambda';
+const deployLambdaLayers = async ({ lambdaExternals = [], }) => {
+    if (lambdaExternals.length === 0) {
+        return;
+    }
+    npmlog_1.default.info(logPrefix, `--lambda-externals [${lambdaExternals.join(', ')}] was found. Creating other layers...`);
+    const { dependencies = {} } = (() => {
+        try {
+            return require(path_1.default.resolve(process.cwd(), 'package.json')) || {};
+        }
+        catch (err) {
+            npmlog_1.default.error(logPrefix, 'Cannot read package.json. Error message: %j', err.message);
+            return {};
+        }
+    })();
+    const packages = lambdaExternals.map((lambdaExternal) => {
+        try {
+            const semver = dependencies[lambdaExternal].replace(/(~|\^)/g, '');
+            return `${lambdaExternal}@${semver}`;
+        }
+        catch {
+            throw new Error(`Cannot find ${lambdaExternal} on package.json dependencies.`);
+        }
+    });
+    await (0, deployLambdaLayer_1.deployLambdaLayer)({ packages, deployIfExists: false });
+};
+exports.deployLambdaLayers = deployLambdaLayers;

package/dist/deploy/lambda/uploadCodeToECR.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCodeToECR = void 0;
+const config_1 = require("../../config");
+const aws_sdk_1 = require("aws-sdk");
+const getBaseStackResource_1 = require("../baseStack/getBaseStackResource");
+const utils_1 = require("../../utils");
+const codeBuild = new aws_sdk_1.CodeBuild({ region: config_1.AWS_DEFAULT_REGION });
+const uploadCodeToECR = async ({ bucket, key, lambdaExternals, lambdaDockerfile, }) => {
+    const TEMP = 1;
+    if (TEMP) {
+        throw new Error('uploadCodeToECR not finished yet.');
+    }
+    const lambdaBuilder = await (0, getBaseStackResource_1.getBaseStackResource)('BASE_STACK_LAMBDA_IMAGE_BUILDER_LOGICAL_NAME');
+    const defaultDockerfile = [
+        'FROM public.ecr.aws/lambda/nodejs:14',
+        // eslint-disable-next-line no-template-curly-in-string
+        'COPY . ${LAMBDA_TASK_ROOT}',
+        'RUN npm install',
+    ].join('\n');
+    const { build } = await codeBuild
+        .startBuild({
+        environmentVariablesOverride: [
+            {
+                name: 'DOCKERFILE',
+                value: lambdaDockerfile || defaultDockerfile,
+            },
+            {
+                name: 'LAMBDA_EXTERNALS',
+                value: lambdaExternals.join(' '),
+            },
+            {
+                name: 'IMAGE_TAG',
+                value: (0, utils_1.getPackageVersion)(),
+            },
+            {
+                name: 'REPOSITORY_ECR_REPOSITORY',
+                value: 'testtesteste',
+            },
+        ],
+        projectName: lambdaBuilder,
+        sourceLocationOverride: `${bucket}/${key}`,
+        sourceTypeOverride: 'S3',
+    })
+        .promise();
+    if (!(build === null || build === void 0 ? void 0 : build.id)) {
+        throw new Error('Cannot start build.');
+    }
+    await (0, utils_1.waitCodeBuildFinish)({ buildId: build.id, name: 'lambda-builder' });
+    const imageUri = '178804353523.dkr.ecr.us-east-1.amazonaws.com/testtesteste:0.0.1';
+    return { imageUri };
+};
+exports.uploadCodeToECR = uploadCodeToECR;

package/dist/deploy/lambda/uploadCodeToS3.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCodeToS3 = void 0;
+const tslib_1 = require("tslib");
+const getBaseStackResource_1 = require("../baseStack/getBaseStackResource");
+const s3_1 = require("../s3");
+const adm_zip_1 = tslib_1.__importDefault(require("adm-zip"));
+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 = 'lambda';
+const outFolder = 'dist';
+const outFile = 'index.js';
+const uploadCodeToS3 = async ({ stackName }) => {
+    npmlog_1.default.info(logPrefix, `Uploading code to S3...`);
+    const zip = new adm_zip_1.default();
+    const code = fs_1.default.readFileSync(path_1.default.join(process.cwd(), outFolder, outFile));
+    zip.addFile('index.js', code);
+    if (!fs_1.default.existsSync('dist')) {
+        fs_1.default.mkdirSync('dist');
+    }
+    zip.writeZip('dist/lambda.zip');
+    const bucketName = await (0, getBaseStackResource_1.getBaseStackResource)('BASE_STACK_BUCKET_LOGICAL_NAME');
+    return (0, s3_1.uploadFileToS3)({
+        bucket: bucketName,
+        contentType: 'application/zip',
+        key: `lambdas/${stackName}/lambda.zip`,
+        file: zip.toBuffer(),
+    });
+};
+exports.uploadCodeToS3 = uploadCodeToS3;

package/dist/deploy/lambdaLayer/command.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployLambdaLayerCommand = exports.options = void 0;
+const tslib_1 = require("tslib");
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const config_1 = require("../../config");
+const utils_1 = require("../../utils");
+const deployLambdaLayer_1 = require("./deployLambdaLayer");
+const logPrefix = 'deploy-lambda-layer';
+/**
+ * https://stackoverflow.com/a/64880672/8786986
+ */
+const packageNameRegex = /@[~^]?([\dvx*]+(?:[-.](?:[\dx*]+|alpha|beta))*)/;
+exports.options = {
+    packages: {
+        array: true,
+        describe: `NPM packages' names to be deployed as Lambda Layers. It must follow the format: ${packageNameRegex.toString()}.`,
+        required: true,
+        type: 'string',
+    },
+};
+exports.deployLambdaLayerCommand = {
+    command: 'lambda-layer',
+    describe: 'Deploy Lambda Layer.',
+    builder: (yargs) => yargs
+        .options((0, utils_1.addGroupToOptions)(exports.options, 'Deploy Lambda Layer Options'))
+        .check(({ packages }) => {
+        const invalidPackages = packages
+            .map((packageName) => {
+            return packageNameRegex.test(packageName) ? undefined : packageName;
+        })
+            .filter((packageName) => !!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, ...rest }) => {
+        if (destroy) {
+            npmlog_1.default.info(logPrefix, `${config_1.NAME} doesn't destroy lambda layers.`);
+        }
+        else {
+            (0, deployLambdaLayer_1.deployLambdaLayer)(rest);
+        }
+    },
+};

package/dist/deploy/lambdaLayer/deployLambdaLayer.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployLambdaLayer = exports.getPackageLambdaLayerStackName = exports.getLambdaLayerTemplate = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("../../utils");
+const aws_sdk_1 = require("aws-sdk");
+const config_1 = require("../../config");
+const cloudFormation_core_1 = require("../cloudFormation.core");
+const getBaseStackResource_1 = require("../baseStack/getBaseStackResource");
+const utils_2 = require("../utils");
+const change_case_1 = require("change-case");
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const logPrefix = 'lambda-layer';
+const createLambdaLayerZipFile = async ({ codeBuildProjectName, packageName, }) => {
+    var _a, _b;
+    npmlog_1.default.info(logPrefix, `Creating zip file for package ${packageName}...`);
+    const codeBuild = new aws_sdk_1.CodeBuild();
+    const { build } = await codeBuild
+        .startBuild({
+        environmentVariablesOverride: [
+            {
+                name: 'PACKAGE_NAME',
+                value: packageName,
+            },
+        ],
+        projectName: codeBuildProjectName,
+    })
+        .promise();
+    if (!(build === null || build === void 0 ? void 0 : build.id)) {
+        throw new Error('Cannot start build.');
+    }
+    const result = await (0, utils_1.waitCodeBuildFinish)({
+        buildId: build.id,
+        name: packageName,
+    });
+    if ((_a = result.artifacts) === null || _a === void 0 ? void 0 : _a.location) {
+        const location = result.artifacts.location.split('/');
+        const bucket = (_b = location.shift()) === null || _b === void 0 ? void 0 : _b.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}`);
+};
+/**
+ * The CloudFormation template created to deploy a Lambda Layer.
+ *
+ * - The Layer name is the same as the Stack name.
+ */
+const getLambdaLayerTemplate = ({ bucket, key, packageName, }) => {
+    const description = packageName
+        /**
+         * Description has limit of 256.
+         * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-layerversion.html#cfn-lambda-layerversion-description
+         */
+        .substring(0, 256);
+    return {
+        AWSTemplateFormatVersion: '2010-09-09',
+        Resources: {
+            LambdaLayer: {
+                Type: 'AWS::Lambda::LayerVersion',
+                Properties: {
+                    CompatibleRuntimes: ['nodejs12.x', 'nodejs14.x'],
+                    Content: {
+                        S3Bucket: bucket,
+                        S3Key: key,
+                    },
+                    Description: description,
+                    LayerName: { Ref: 'AWS::StackName' },
+                },
+            },
+        },
+        Outputs: {
+            LambdaLayerVersion: {
+                Description: description,
+                Value: { Ref: 'LambdaLayer' },
+                Export: {
+                    Name: { Ref: 'AWS::StackName' },
+                },
+            },
+        },
+    };
+};
+exports.getLambdaLayerTemplate = getLambdaLayerTemplate;
+/**
+ * The stack name is given by `CarlinLambdaLayer` prefix and the package name with
+ * `@` and `/` removed and `.` replace by the word `dot`.
+ */
+const getPackageLambdaLayerStackName = (packageName) => {
+    return (0, change_case_1.pascalCase)(`${config_1.NAME} LambdaLayer ${packageName.replace(/\./g, 'dot')}`).replace(/_/g, '');
+};
+exports.getPackageLambdaLayerStackName = getPackageLambdaLayerStackName;
+const getPackagesThatAreNotDeployed = async ({ packages, }) => {
+    return (await Promise.all(packages.map(async (packageName) => {
+        const stackName = (0, exports.getPackageLambdaLayerStackName)(packageName);
+        return (await (0, cloudFormation_core_1.doesStackExist)({ stackName })) ? '' : packageName;
+    }))).filter((packageName) => !!packageName);
+};
+const deployLambdaLayer = async ({ packages, deployIfExists = true, }) => {
+    try {
+        const packagesToBeDeployed = deployIfExists
+            ? packages
+            : await getPackagesThatAreNotDeployed({ packages });
+        if (packagesToBeDeployed.length === 0) {
+            return;
+        }
+        const codeBuildProjectName = await (0, getBaseStackResource_1.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 = (0, exports.getLambdaLayerTemplate)({
+                    packageName,
+                    bucket,
+                    key,
+                });
+                await (0, cloudFormation_core_1.deploy)({
+                    template: lambdaLayerTemplate,
+                    terminationProtection: true,
+                    params: { StackName: (0, exports.getPackageLambdaLayerStackName)(packageName) },
+                });
+            }
+            catch (error) {
+                (0, utils_2.handleDeployError)({ error, logPrefix });
+            }
+        };
+        await Promise.all(packagesToBeDeployed.map((packageName) => deployLambdaLayerSinglePackage(packageName)));
+    }
+    catch (error) {
+        (0, utils_2.handleDeployError)({ error, logPrefix });
+    }
+};
+exports.deployLambdaLayer = deployLambdaLayer;

package/dist/deploy/readDockerfile.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDockerfile = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+/**
+ * This method was created because fs.readFileSync cannot be mocked.
+ */
+const readDockerfile = (dockerfilePath) => {
+    try {
+        return fs.readFileSync(path.join(process.cwd(), dockerfilePath), 'utf8');
+    }
+    catch {
+        return '';
+    }
+};
+exports.readDockerfile = readDockerfile;

package/dist/deploy/s3.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteS3Directory = exports.emptyS3Directory = exports.uploadDirectoryToS3 = exports.getAllFilesInsideADirectory = exports.uploadFileToS3 = exports.getBucketKeyUrl = exports.s3 = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-await-in-loop */
+const aws_sdk_1 = require("aws-sdk");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const glob_1 = tslib_1.__importDefault(require("glob"));
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const mime_types_1 = tslib_1.__importDefault(require("mime-types"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const logPrefix = 's3';
+exports.s3 = new aws_sdk_1.S3({ apiVersion: '2006-03-01' });
+const getBucketKeyUrl = ({ bucket, key, }) => {
+    return `https://s3.amazonaws.com/${bucket}/${key}`;
+};
+exports.getBucketKeyUrl = getBucketKeyUrl;
+const 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_1.default.sep).join('/'),
+    };
+    if (file) {
+        params.ContentType = contentType;
+        params.Body = file;
+    }
+    else if (filePath) {
+        const readFile = await fs_1.default.promises.readFile(filePath);
+        params = {
+            ...params,
+            ContentType: contentType || mime_types_1.default.contentType(path_1.default.extname(filePath)) || undefined,
+        };
+        params.Body = Buffer.from(readFile);
+    }
+    const { Bucket, Key, VersionId } = (await exports.s3.upload(params).promise());
+    return {
+        bucket: Bucket,
+        key: Key,
+        versionId: VersionId,
+        url: (0, exports.getBucketKeyUrl)({ bucket: Bucket, key: Key }),
+    };
+};
+exports.uploadFileToS3 = uploadFileToS3;
+/**
+ * Get all files inside $directory.
+ */
+const getAllFilesInsideADirectory = async ({ directory, }) => {
+    const allFilesAndDirectories = await new Promise((resolve, reject) => {
+        (0, glob_1.default)(`${directory}/**/*`, (err, matches) => {
+            return err ? reject(err) : resolve(matches);
+        });
+    });
+    const allFiles = allFilesAndDirectories
+        /**
+         * Remove directories.
+         */
+        .filter((item) => fs_1.default.lstatSync(item).isFile());
+    return allFiles;
+};
+exports.getAllFilesInsideADirectory = getAllFilesInsideADirectory;
+const uploadDirectoryToS3 = async ({ bucket, bucketKey = '', directory, }) => {
+    npmlog_1.default.info(logPrefix, `Uploading directory ${directory}/ to ${bucket}/${bucketKey}...`);
+    const allFiles = await (0, exports.getAllFilesInsideADirectory)({ directory });
+    /**
+     * If the folder has no files (the folder name may be wrong), thrown an
+     * error. Discovered at #16 https://github.com/ttoss/carlin/issues/16.
+     */
+    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);
+    /**
+     * Divide all files and create "numberOfGroups" groups of files whose max
+     * length is 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()) {
+        npmlog_1.default.info(logPrefix, `Uploading group ${index + 1}/${aoaOfFiles.length}...`);
+        await Promise.all(groupOfFiles.map((file) => (0, exports.uploadFileToS3)({
+            bucket,
+            key: path_1.default.join(bucketKey, path_1.default.relative(directory, file)),
+            filePath: file,
+        })));
+    }
+};
+exports.uploadDirectoryToS3 = uploadDirectoryToS3;
+const emptyS3Directory = async ({ bucket, directory = '', }) => {
+    npmlog_1.default.info(logPrefix, `${bucket}/${directory} will be empty`);
+    try {
+        const { Contents, IsTruncated } = await exports.s3
+            .listObjectsV2({
+            Bucket: bucket,
+            Prefix: directory,
+        })
+            .promise();
+        if (Contents && Contents.length > 0) {
+            /**
+             * Get object versions
+             */
+            const objectsPromises = Contents.filter(({ Key }) => !!Key).map(async ({ Key }) => {
+                const { Versions = [] } = await exports.s3
+                    .listObjectVersions({
+                    Bucket: bucket,
+                    Prefix: Key,
+                })
+                    .promise();
+                return {
+                    Key: Key,
+                    Versions: Versions.map(({ VersionId }) => VersionId || undefined),
+                };
+            });
+            const objects = await Promise.all(objectsPromises);
+            const objectsWithVersionsIds = objects.reduce((acc, { Key, Versions }) => {
+                const objectWithVersionsIds = Versions.map((VersionId) => ({
+                    Key,
+                    VersionId,
+                }));
+                return [...acc, ...objectWithVersionsIds];
+            }, []);
+            await exports.s3
+                .deleteObjects({
+                Bucket: bucket,
+                Delete: { Objects: objectsWithVersionsIds },
+            })
+                .promise();
+        }
+        /**
+         * Truncated is files that exists but weren't listed from S3 API.
+         */
+        if (IsTruncated) {
+            await (0, exports.emptyS3Directory)({ bucket, directory });
+        }
+        npmlog_1.default.info(logPrefix, `${bucket}/${directory} is empty.`);
+    }
+    catch (err) {
+        npmlog_1.default.error(logPrefix, `Cannot empty ${bucket}/${directory}.`);
+        throw err;
+    }
+};
+exports.emptyS3Directory = emptyS3Directory;
+const deleteS3Directory = async ({ bucket, directory = '', }) => {
+    try {
+        npmlog_1.default.info(logPrefix, `${bucket}/${directory} is being deleted...`);
+        await (0, exports.emptyS3Directory)({ bucket, directory });
+        await exports.s3.deleteObject({ Bucket: bucket, Key: directory }).promise();
+        npmlog_1.default.info(logPrefix, `${bucket}/${directory} was deleted.`);
+    }
+    catch (error) {
+        npmlog_1.default.error(logPrefix, `Cannot delete ${bucket}/${directory}.`);
+        throw error;
+    }
+};
+exports.deleteS3Directory = deleteS3Directory;

package/dist/deploy/stackName.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStackName = exports.limitStackName = exports.STACK_NAME_MAX_LENGTH = exports.setPreDefinedStackName = void 0;
+const change_case_1 = require("change-case");
+const utils_1 = require("../utils");
+/**
+ * Used by CLI set stack name when it is defined.
+ */
+const setPreDefinedStackName = (stackName) => {
+    (0, utils_1.setEnvVar)('STACK_NAME', stackName);
+};
+exports.setPreDefinedStackName = setPreDefinedStackName;
+/**
+ * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html
+ */
+exports.STACK_NAME_MAX_LENGTH = 128;
+const limitStackName = (stackName) => `${stackName}`.substring(0, exports.STACK_NAME_MAX_LENGTH);
+exports.limitStackName = limitStackName;
+/**
+ * If stack name isn't previously defined, the name will be created accordingly
+ * with the following rules:
+ *
+ * 1. The name has to parts.
+ *
+ * 1. The first part is defined by the package.json name, if it is defined.
+ * Else, it'll be a random name starting with the string "Stack-", e.g. **Stack-96830**.
+ *
+ * 1. The second part will be defined by, whichever is defined first:
+ *  1. environment,
+ *  1. [branch name](https://carlin.ttoss.dev/docs/CLI#branchbranch_name) in param-case,
+ *  1. `undefined`.
+ *
+ * Example:
+ *
+ * | Case | Package Name | Environment | Branch Name | `--stack-name` | Stack Name |
+ * | ---- | ------------ | ----------- | ----------  | -------------- | ---------- |
+ * | #1 | @package/name | Production | main | MyStackName | **MyStackName** |
+ * | #2 | @package/name | Production | main | | **PackageName-Production** |
+ * | #3 | @package/name | | main | | **PackageName-main** |
+ * | #4 | @package/name | | | | **PackageName** |
+ * | #5 | | Production | main | | **Stack-96820-Production** |
+ * | #6 | | | main | | **Stack-96820-main** |
+ * | #7 | | | | | **Stack-96820** |
+ *
+ * CAUTION!!!
+ *
+ * This method is a BREAKING CHANGE for **carlin**, I hope we never have to
+ * change this algorithm, ever. Stack name is how we track the stacks on AWS.
+ * Suppose we change this algorithm. If we perform an update or destroy
+ * operation, **carlin** will create another stack or do nothing because the
+ * old stack won't be found due to stack name changing.
+ *
+ */
+const getStackName = async () => {
+    if ((0, utils_1.getEnvVar)('STACK_NAME')) {
+        return (0, utils_1.getEnvVar)('STACK_NAME');
+    }
+    const [currentBranch, environment, packageName] = await Promise.all([
+        (0, utils_1.getCurrentBranch)(),
+        (0, utils_1.getEnvironment)(),
+        (0, utils_1.getPackageName)(),
+    ]);
+    const firstName = packageName
+        ? (0, change_case_1.pascalCase)(packageName)
+        : `Stack-${Math.round(Math.random() * 100000)}`;
+    const secondName = (() => {
+        if (environment) {
+            return environment;
+        }
+        if (currentBranch) {
+            return (0, change_case_1.paramCase)(currentBranch);
+        }
+        return undefined;
+    })();
+    const name = [firstName, secondName].filter((word) => !!word).join('-');
+    return (0, exports.limitStackName)(name);
+};
+exports.getStackName = getStackName;