carlin 1.19.11 → 1.19.13

package/dist/deploy/staticApp/command.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployStaticAppCommand = exports.options = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable no-param-reassign */
+const config_1 = require("../../config");
+const utils_1 = require("../../utils");
+const findDefaultBuildFolder_1 = require("./findDefaultBuildFolder");
+const deployStaticApp_1 = require("./deployStaticApp");
+const cloudFormation_1 = require("../cloudFormation");
+const aws_sdk_1 = tslib_1.__importDefault(require("aws-sdk"));
+exports.options = {
+    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 "${findDefaultBuildFolder_1.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, ${config_1.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: () => config_1.CLOUDFRONT_REGION,
+        default: config_1.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',
+    },
+};
+exports.deployStaticAppCommand = {
+    command: 'static-app',
+    describe: 'Deploy static app.',
+    builder: (yargs) => yargs
+        .options((0, utils_1.addGroupToOptions)(exports.options, 'Deploy Static App Options'))
+        /**
+         * 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
+         */
+        .middleware(() => {
+        aws_sdk_1.default.config.region = config_1.CLOUDFRONT_REGION;
+    }),
+    handler: ({ destroy, ...rest }) => {
+        if (destroy) {
+            (0, cloudFormation_1.destroyCloudFormation)();
+        }
+        else {
+            (0, deployStaticApp_1.deployStaticApp)(rest);
+        }
+    },
+};

package/dist/deploy/staticApp/deployStaticApp.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployStaticApp = void 0;
+const cloudFormation_core_1 = require("../cloudFormation.core");
+const getStaticAppBucket_1 = require("./getStaticAppBucket");
+const staticApp_template_1 = require("./staticApp.template");
+const utils_1 = require("../utils");
+const invalidateCloudFront_1 = require("./invalidateCloudFront");
+const removeOldVersions_1 = require("./removeOldVersions");
+const uploadBuiltAppToS3_1 = require("./uploadBuiltAppToS3");
+const logPrefix = 'static-app';
+/**
+ * 1. Create the stack name that will be passed to CloudFormation.
+ * 1. Create a CloudFormation template based on the type of the deployment, and
+ *    the options, for instance, only S3, SPA, with hosted zone...
+ * 1. Create AWS resources using the templated created.
+ * 1. Upload static files to the host bucket S3.
+ * 1. Remove old deployment versions. Keep only the 3 most recent ones.
+ */
+const deployStaticApp = async ({ acm, aliases, buildFolder, cloudfront, spa, hostedZoneName, region, skipUpload, }) => {
+    try {
+        const { stackName } = await (0, utils_1.handleDeployInitialization)({ logPrefix });
+        const params = { StackName: stackName };
+        const template = (0, staticApp_template_1.getStaticAppTemplate)({
+            acm,
+            aliases,
+            cloudfront,
+            spa,
+            hostedZoneName,
+            region,
+        });
+        const bucket = await (0, getStaticAppBucket_1.getStaticAppBucket)({ stackName });
+        /**
+         * Stack already exists. Upload files first after changing the files routes
+         * because of the version changing.
+         */
+        if (bucket) {
+            if (!skipUpload) {
+                await (0, uploadBuiltAppToS3_1.uploadBuiltAppToS3)({ buildFolder, bucket, cloudfront });
+            }
+            const { Outputs } = await (0, cloudFormation_core_1.deploy)({ params, template });
+            await (0, invalidateCloudFront_1.invalidateCloudFront)({ outputs: Outputs });
+            if (!skipUpload) {
+                await (0, removeOldVersions_1.removeOldVersions)({ bucket });
+            }
+        }
+        else {
+            /**
+             * Stack doesn't exist. Deploy CloudFormation first, get the bucket name,
+             * and upload files to S3.
+             */
+            await (0, cloudFormation_core_1.deploy)({ params, template });
+            const newBucket = await (0, getStaticAppBucket_1.getStaticAppBucket)({ stackName });
+            if (!newBucket) {
+                throw new Error(`Cannot find bucket at ${stackName}.`);
+            }
+            await (0, uploadBuiltAppToS3_1.uploadBuiltAppToS3)({ buildFolder, bucket: newBucket, cloudfront });
+        }
+    }
+    catch (error) {
+        (0, utils_1.handleDeployError)({ error, logPrefix });
+    }
+};
+exports.deployStaticApp = deployStaticApp;

package/dist/deploy/staticApp/findDefaultBuildFolder.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDefaultBuildFolder = exports.defaultBuildFolders = void 0;
+const s3_1 = require("../s3");
+/**
+ * Fixes #20 https://github.com/ttoss/carlin/issues/20
+ */
+exports.defaultBuildFolders = ['build', 'out', 'storybook-static'];
+const findDefaultBuildFolder = async () => {
+    /**
+     * Valid folders have at least one file inside.
+     */
+    const validFolders = await Promise.all(exports.defaultBuildFolders.map(async (directory) => {
+        const allFiles = await (0, s3_1.getAllFilesInsideADirectory)({
+            directory,
+        });
+        return { directory, isValid: allFiles.length !== 0 };
+    }));
+    const validFolder = validFolders.reduce((acc, cur) => {
+        if (cur.isValid) {
+            return cur.directory;
+        }
+        return acc;
+    }, '');
+    return validFolder;
+};
+exports.findDefaultBuildFolder = findDefaultBuildFolder;

package/dist/deploy/staticApp/getOriginShieldRegion.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOriginShieldRegion = void 0;
+/**
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/origin-shield.html#choose-origin-shield-region
+ * @param region
+ */
+const getOriginShieldRegion = (region) => {
+    switch (region) {
+        case 'us-west-1':
+            return 'us-west-2';
+        case 'af-south-1':
+            return 'eu-west-1';
+        case 'ap-east-1':
+            return 'ap-southeast-1';
+        case 'ca-central-1':
+            return 'us-east-1';
+        case 'eu-south-1':
+            return 'eu-central-1';
+        case 'eu-west-3':
+            return 'eu-west-2';
+        case 'eu-north-1':
+            return 'eu-west-2';
+        case 'me-south-1':
+            return 'ap-south-1';
+        default:
+            return region;
+    }
+};
+exports.getOriginShieldRegion = getOriginShieldRegion;

package/dist/deploy/staticApp/getStaticAppBucket.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStaticAppBucket = void 0;
+const cloudFormation_core_1 = require("../cloudFormation.core");
+const STATIC_APP_BUCKET_LOGICAL_ID = 'StaticBucket';
+const getStaticAppBucket = async ({ stackName, }) => {
+    const params = {
+        LogicalResourceId: STATIC_APP_BUCKET_LOGICAL_ID,
+        StackName: stackName,
+    };
+    try {
+        const { StackResourceDetail } = await (0, cloudFormation_core_1.describeStackResource)(params);
+        return StackResourceDetail === null || StackResourceDetail === void 0 ? void 0 : StackResourceDetail.PhysicalResourceId;
+    }
+    catch (error) {
+        return undefined;
+    }
+};
+exports.getStaticAppBucket = getStaticAppBucket;

package/dist/deploy/staticApp/invalidateCloudFront.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidateCloudFront = void 0;
+const tslib_1 = require("tslib");
+const aws_sdk_1 = require("aws-sdk");
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const CLOUDFRONT_DISTRIBUTION_ID = 'CloudFrontDistributionId';
+const logPrefix = 'static-app';
+const invalidateCloudFront = async ({ outputs, }) => {
+    npmlog_1.default.info(logPrefix, 'Invalidating CloudFront...');
+    if (!outputs) {
+        npmlog_1.default.info(logPrefix, 'Invalidation: outputs do not exist.');
+        return;
+    }
+    const cloudFrontDistributionIDOutput = outputs.find((output) => output.OutputKey === CLOUDFRONT_DISTRIBUTION_ID);
+    if (cloudFrontDistributionIDOutput === null || cloudFrontDistributionIDOutput === void 0 ? void 0 : cloudFrontDistributionIDOutput.OutputValue) {
+        const distributionId = cloudFrontDistributionIDOutput.OutputValue;
+        const params = {
+            DistributionId: distributionId,
+            InvalidationBatch: {
+                CallerReference: new Date().toISOString(),
+                Paths: {
+                    Items: ['/*'],
+                    Quantity: 1,
+                },
+            },
+        };
+        const cloudFront = new aws_sdk_1.CloudFront();
+        try {
+            await cloudFront.createInvalidation(params).promise();
+            npmlog_1.default.info(logPrefix, `CloudFront Distribution ID ${distributionId} invalidated with success.`);
+        }
+        catch (err) {
+            npmlog_1.default.error(logPrefix, `Error while trying to invalidate CloudFront distribution ${distributionId}.`);
+            npmlog_1.default.error(logPrefix, err);
+        }
+    }
+    else {
+        npmlog_1.default.info(logPrefix, `Cannot invalidate because distribution does not exist.`);
+    }
+};
+exports.invalidateCloudFront = invalidateCloudFront;

package/dist/deploy/staticApp/removeOldVersions.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeOldVersions = void 0;
+const tslib_1 = require("tslib");
+const s3_1 = require("../s3");
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const logPrefix = 'static-app';
+/**
+ * When a static-app deployment is executed, the algorithm delete old versions
+ * if there are three newer versions, and keep these three. For instance, if
+ * the bucket has the versions/folders below:
+ *
+ * - `9.0.1/`
+ * - `9.0.2/`
+ * - `9.2.0/`
+ * - `9.3.0/`
+ * - `9.3.1/`
+ * - `10.0.0/` _<- created by the last deploy._
+ *
+ * The folders `9.0.1/`, `9.0.2/`, and `9.2.0/` will be delete after the
+ * deploy.
+ */
+const removeOldVersions = async ({ bucket }) => {
+    try {
+        npmlog_1.default.info(logPrefix, 'Removing old versions...');
+        const { CommonPrefixes = [] } = await s3_1.s3
+            .listObjectsV2({ Bucket: bucket, Delimiter: '/' })
+            .promise();
+        const versions = CommonPrefixes === null || CommonPrefixes === void 0 ? void 0 : CommonPrefixes.map(({ Prefix }) => Prefix === null || Prefix === void 0 ? void 0 : Prefix.replace('/', '')).filter((version) => semver_1.default.valid(version)).sort((a, b) => (semver_1.default.gt(a, b) ? -1 : 1));
+        /**
+         * Keep the 3 most recent versions.
+         */
+        versions.shift();
+        versions.shift();
+        versions.shift();
+        await Promise.all(versions.map((version) => (0, s3_1.deleteS3Directory)({ bucket, directory: `${version}` })));
+    }
+    catch (error) {
+        npmlog_1.default.info(logPrefix, `Cannot remove older versions from "${bucket}" bucket.`);
+    }
+};
+exports.removeOldVersions = removeOldVersions;

package/dist/deploy/staticApp/staticApp.template.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStaticAppTemplate = exports.ROUTE_53_RECORD_SET_GROUP_LOGICAL_ID = exports.CLOUDFRONT_DISTRIBUTION_LOGICAL_ID = void 0;
+const utils_1 = require("../../utils");
+const getOriginShieldRegion_1 = require("./getOriginShieldRegion");
+const PACKAGE_VERSION = (0, utils_1.getPackageVersion)();
+const STATIC_APP_BUCKET_LOGICAL_ID = 'StaticBucket';
+const CLOUDFRONT_DISTRIBUTION_ID = 'CloudFrontDistributionId';
+exports.CLOUDFRONT_DISTRIBUTION_LOGICAL_ID = 'CloudFrontDistribution';
+exports.ROUTE_53_RECORD_SET_GROUP_LOGICAL_ID = 'Route53RecordSetGroup';
+/**
+ * Name: Managed-CachingDisabled
+ * ID: 4135ea2d-6df8-44a3-9df3-4b5a84be39ad
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-cache-policies.html
+ */
+const CACHE_POLICY_ID = '4135ea2d-6df8-44a3-9df3-4b5a84be39ad';
+/**
+ * Name: Managed-CORS-S3Origin
+ * ID: 88a5eaf4-2fd4-4709-b370-b4c650ea3fcf
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html
+ */
+const ORIGIN_REQUEST_POLICY_ID = '88a5eaf4-2fd4-4709-b370-b4c650ea3fcf';
+/**
+ * Name: CORS-with-preflight-and-SecurityHeadersPolicy
+ * ID: eaab4381-ed33-4a86-88ca-d9558dc6cd63
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html
+ */
+const ORIGIN_RESPONSE_POLICY_ID = 'eaab4381-ed33-4a86-88ca-d9558dc6cd63';
+const getBaseTemplate = ({ spa, }) => {
+    return {
+        AWSTemplateFormatVersion: '2010-09-09',
+        Resources: {
+            [STATIC_APP_BUCKET_LOGICAL_ID]: {
+                Type: 'AWS::S3::Bucket',
+                Properties: {
+                    CorsConfiguration: {
+                        CorsRules: [
+                            {
+                                AllowedHeaders: ['*'],
+                                AllowedMethods: ['GET'],
+                                AllowedOrigins: ['*'],
+                                Id: 'OpenCors',
+                                MaxAge: 600,
+                            },
+                        ],
+                    },
+                    WebsiteConfiguration: {
+                        IndexDocument: `index.html`,
+                        ErrorDocument: spa ? 'index.html' : '404/index.html',
+                    },
+                },
+            },
+            [`${STATIC_APP_BUCKET_LOGICAL_ID}S3BucketPolicy`]: {
+                Type: 'AWS::S3::BucketPolicy',
+                Properties: {
+                    Bucket: { Ref: STATIC_APP_BUCKET_LOGICAL_ID },
+                    PolicyDocument: {
+                        Statement: [
+                            {
+                                Action: ['s3:GetObject'],
+                                Effect: 'Allow',
+                                Principal: '*',
+                                Resource: {
+                                    'Fn::Join': [
+                                        '',
+                                        [
+                                            'arn:aws:s3:::',
+                                            { Ref: STATIC_APP_BUCKET_LOGICAL_ID },
+                                            '/*',
+                                        ],
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+        Outputs: {
+            BucketWebsiteURL: {
+                Description: 'Bucket static app website URL',
+                Value: {
+                    'Fn::GetAtt': [STATIC_APP_BUCKET_LOGICAL_ID, 'WebsiteURL'],
+                },
+            },
+        },
+    };
+};
+const getCloudFrontTemplate = ({ acm, aliases = [], cloudfront, spa, hostedZoneName, region, }) => {
+    const template = { ...getBaseTemplate({ cloudfront, spa }) };
+    const cloudFrontResources = {
+        [exports.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: '/404',
+                        };
+                    }),
+                    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_ID },
+                        ViewerProtocolPolicy: 'redirect-to-https',
+                    },
+                    DefaultRootObject: spa ? 'index.html' : undefined,
+                    Enabled: true,
+                    HttpVersion: 'http2',
+                    Origins: [
+                        {
+                            CustomOriginConfig: {
+                                OriginProtocolPolicy: 'http-only',
+                            },
+                            /**
+                             * https://github.com/aws/aws-cdk/issues/1882#issuecomment-629141467
+                             */
+                            DomainName: {
+                                'Fn::Select': [
+                                    1,
+                                    {
+                                        'Fn::Split': [
+                                            '//',
+                                            {
+                                                'Fn::GetAtt': [
+                                                    STATIC_APP_BUCKET_LOGICAL_ID,
+                                                    'WebsiteURL',
+                                                ],
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                            Id: { Ref: STATIC_APP_BUCKET_LOGICAL_ID },
+                            /**
+                             * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/origin-shield.html#choose-origin-shield-region
+                             */
+                            ...(region && {
+                                OriginShield: {
+                                    Enabled: true,
+                                    OriginShieldRegion: (0, getOriginShieldRegion_1.getOriginShieldRegion)(region),
+                                },
+                            }),
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    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,
+            };
+        /**
+         * Add ACM to CloudFront template.
+         */
+        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',
+            },
+        };
+    }
+    /**
+     * Add aliases to Route 53 records.
+     */
+    if (hostedZoneName && aliases) {
+        const recordSets = aliases.map((alias) => {
+            if (alias === hostedZoneName) {
+                return {
+                    AliasTarget: {
+                        DNSName: {
+                            'Fn::GetAtt': `${exports.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': `${exports.CLOUDFRONT_DISTRIBUTION_LOGICAL_ID}.DomainName`,
+                    },
+                ],
+                TTL: 60,
+                Type: 'CNAME',
+            };
+        });
+        const route53RecordSetGroupResources = {
+            [exports.ROUTE_53_RECORD_SET_GROUP_LOGICAL_ID]: {
+                Type: 'AWS::Route53::RecordSetGroup',
+                DependsOn: [exports.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 };
+    /**
+     * Add aliases output to template.
+     */
+    const aliasesOutput = (aliases || []).reduce((acc, alias, index) => ({
+        ...acc,
+        [`Alias${index}URL`]: {
+            Value: `https://${alias}`,
+        },
+    }), {});
+    /**
+     * Add CloudFront Distribution ID and CloudFront URL to template.
+     */
+    template.Outputs = {
+        ...template.Outputs,
+        ...aliasesOutput,
+        CloudFrontURL: {
+            Value: {
+                'Fn::Join': [
+                    '',
+                    [
+                        'https://',
+                        {
+                            'Fn::GetAtt': `${exports.CLOUDFRONT_DISTRIBUTION_LOGICAL_ID}.DomainName`,
+                        },
+                    ],
+                ],
+            },
+        },
+        [CLOUDFRONT_DISTRIBUTION_ID]: {
+            Value: {
+                Ref: exports.CLOUDFRONT_DISTRIBUTION_LOGICAL_ID,
+            },
+        },
+        CurrentVersion: {
+            Value: PACKAGE_VERSION,
+        },
+    };
+    return template;
+};
+const getStaticAppTemplate = ({ acm, aliases, cloudfront, spa, hostedZoneName, region, }) => {
+    if (cloudfront) {
+        return getCloudFrontTemplate({
+            acm,
+            aliases,
+            cloudfront,
+            spa,
+            hostedZoneName,
+            region,
+        });
+    }
+    return getBaseTemplate({ cloudfront, spa });
+};
+exports.getStaticAppTemplate = getStaticAppTemplate;

package/dist/deploy/staticApp/uploadBuiltAppToS3.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadBuiltAppToS3 = void 0;
+const findDefaultBuildFolder_1 = require("./findDefaultBuildFolder");
+const s3_1 = require("../s3");
+const uploadBuiltAppToS3 = async ({ buildFolder: directory, bucket, }) => {
+    /**
+     * Only empty directory if the number of the files inside $directory.
+     * If the number of files is zero, uploadDirectoryToS3 will thrown.
+     */
+    if (directory) {
+        const files = await (0, s3_1.getAllFilesInsideADirectory)({ directory });
+        if (files.length > 0) {
+            await (0, s3_1.emptyS3Directory)({ bucket });
+        }
+        await (0, s3_1.uploadDirectoryToS3)({ bucket, directory });
+        return;
+    }
+    const defaultDirectory = await (0, findDefaultBuildFolder_1.findDefaultBuildFolder)();
+    if (defaultDirectory) {
+        await (0, s3_1.emptyS3Directory)({ bucket });
+        await (0, s3_1.uploadDirectoryToS3)({ bucket, directory: defaultDirectory });
+        return;
+    }
+    throw new Error(`build-folder option wasn't provided and files weren't found in ${findDefaultBuildFolder_1.defaultBuildFolders.join(', ')} directories.`);
+};
+exports.uploadBuiltAppToS3 = uploadBuiltAppToS3;

package/dist/deploy/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDeployInitialization = exports.handleDeployError = exports.deployErrorLogs = void 0;
+const tslib_1 = require("tslib");
+const stackName_1 = require("./stackName");
+const npmlog_1 = tslib_1.__importDefault(require("npmlog"));
+const deployErrorLogs = ({ error, logPrefix, }) => {
+    npmlog_1.default.error(logPrefix, `An error occurred. Cannot deploy ${logPrefix}.`);
+    npmlog_1.default.error(logPrefix, 'Error message: %j', error.message);
+};
+exports.deployErrorLogs = deployErrorLogs;
+const handleDeployError = ({ error, logPrefix, }) => {
+    (0, exports.deployErrorLogs)({ error, logPrefix });
+    process.exit(1);
+};
+exports.handleDeployError = handleDeployError;
+/**
+ * @param param.stackName acts as a default stack name.
+ */
+const handleDeployInitialization = async ({ logPrefix, stackName: preDefinedStackName, }) => {
+    npmlog_1.default.info(logPrefix, `Starting deploy ${logPrefix}...`);
+    if (preDefinedStackName) {
+        (0, stackName_1.setPreDefinedStackName)(preDefinedStackName);
+    }
+    const stackName = await (0, stackName_1.getStackName)();
+    npmlog_1.default.info(logPrefix, `stackName: ${stackName}`);
+    return { stackName };
+};
+exports.handleDeployInitialization = handleDeployInitialization;