@fishawack/lab-env 2.1.0 → 3.1.0

package/commands/create/cmds/provision.js

@@ -0,0 +1,120 @@
+const _ = require('../../../globals.js');
+const utilities = require('../libs/utilities');
+const execSync = require('child_process').execSync;
+const inquirer = require('inquirer');
+const aws = require('../services/aws/index.js');
+const generator = require('generate-password');
+
+module.exports = [
+    ['provision', 'prov'],
+    'Provisions the deployment target',
+    yargs => {
+        yargs.option('branch', {
+            alias: 'b',
+            describe: 'Branch to configure',
+            type: 'string'
+        });
+    },
+    async argv => {
+        let branch = argv.branch || _.branch;
+        
+        let answer = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'check',
+                message: `Provisioning the ${utilities.colorize(branch, 'success')} branch, is this correct?`,
+                default: 'Y'
+            }
+        ]);
+
+        if(!answer.check){
+            process.exit(1);
+        }
+
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'stack',
+                message: 'What type of project are you deploying?',
+                choices: ['static'],
+                default: 'static'
+            },
+            {
+                type: 'list',
+                name: 'client',
+                message: 'Which AWS account should this be deployed too?',
+                choices: aws.clients,
+                default: 'fishawack'
+            },
+            {
+                type: 'confirm',
+                name: 'protected',
+                message: 'Should the site be password protected?',
+                default: true
+            }
+        ]);
+
+        let credentials = [];
+
+        if(answers.protected){
+            let user = {
+                another: true
+            };
+
+            while(user.another){
+                user = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'username',
+                        message: 'Username',
+                        default: `${_.repo_safe}User${credentials.length ? `-${credentials.length}` : ''}`,
+                        validate: (input) => !!input.length
+                    },
+                    {
+                        type: 'input',
+                        name: 'password',
+                        message: 'Password (leave empty to generate)',
+                        default: generator.generate({ length: 10, numbers: true }),
+                        validate: (input) => !!input.length
+                    },
+                    {
+                        type: 'confirm',
+                        name: 'another',
+                        message: 'Add another user?',
+                        default: false
+                    }
+                ]);
+
+                credentials.push({username: user.username, password: user.password});
+            }
+        }
+
+        let config = {};
+        let infastructure;
+        
+        try{
+            infastructure = await aws.static(aws.slug(_.repo, answers.client, branch), answers.client, [{Key: 'repository', Value: _.repo}, {Key: 'environment', Value: branch}], credentials);
+        } catch(e){
+            console.log(e.message);
+            process.exit(1);
+        }
+        
+        config[branch] = {
+            deploy: {
+                "url": infastructure.url,
+                "location": infastructure.bucket.slice(1), // Remove / from start
+                "aws-s3": answers.client,
+                "aws-cloudfront": infastructure.cloudfront
+            }
+        };
+
+        if(credentials.length){
+            config[branch].deploy.users = credentials;
+        }
+
+        let stringify = JSON.stringify(config, null, 4);
+        let output = stringify.substring(1, stringify.length-1).trim();
+        execSync(`printf '${output}' | pbcopy`);
+        console.log(utilities.colorize(`\n${output}\n\n(copied to clipboard)`, 'title'));
+    }
+];

package/commands/create/libs/aws-cloudfront-auth.js

@@ -0,0 +1,77 @@
+function handler(event) {
+    // Redirect if www to non-www
+    if (event.request.headers.host.value.includes('www.')) {
+        var query = '';
+        var index = 0;
+
+        for(var key in event.request.querystring){
+            query += `${index ? '&' : '?'}${key}=${event.request.querystring[key].value}`;
+            index++;
+        }
+        
+        var response = {
+            statusCode: 301,
+            statusDescription: 'Moved Permanently',
+            headers: { "location": { "value": `https://${event.request.headers.host.value.split('www.')[1]}${event.request.uri}${query}` } }
+        };
+
+        return response;
+    }
+
+    // Redirect if no trailing slash
+    if(!event.request.uri.includes('.') && !event.request.uri.endsWith('/')){
+        var query = '';
+        var index = 0;
+
+        for(var key in event.request.querystring){
+            query += `${index ? '&' : '?'}${key}=${event.request.querystring[key].value}`;
+            index++;
+        }
+
+        return {
+            statusCode: 301,
+            statusDescription: 'Moved Permanently',
+            headers: { "location": { "value": `${event.request.uri}/${query}` } }
+        };
+    }
+    
+    var authHeaders = event.request.headers.authorization;
+
+    // The Base64-encoded Auth string that should be present.
+    // It is an encoding of `Basic base64([username]:[password])`
+    var expected = <%= credentials %>;
+
+    // If an Authorization header is supplied and it's an exact match, pass the
+    // request on through to CF/the origin without any modification.
+    if(authHeaders && expected.find(d => d === authHeaders.value)) {
+        // Rewrite url to append index.html if not present
+        var request = event.request;
+        var uri = request.uri;
+
+        // Check whether the URI is missing a file name.
+        if(uri.endsWith('/')) {
+            request.uri += 'index.html';
+        }
+        // Check whether the URI is missing a file extension.
+        else if(!uri.includes('.')) {
+            request.uri += '/index.html';
+        }
+
+        return request;
+    }
+
+    // But if we get here, we must either be missing the auth header or the
+    // credentials failed to match what we expected.
+    // Request the browser present the Basic Auth dialog.
+    var response = {
+        statusCode: 401,
+        statusDescription: 'Unauthorized',
+        headers: {
+            "www-authenticate": {
+                value: 'Basic'
+            }
+        },
+    };
+
+    return response;
+}

package/commands/create/libs/aws-cloudfront-simple.js

@@ -0,0 +1,51 @@
+function handler(event) {
+    // Redirect if www to non-www
+    if (event.request.headers.host.value.includes('www.')) {
+        var query = '';
+        var index = 0;
+
+        for(var key in event.request.querystring){
+            query += `${index ? '&' : '?'}${key}=${event.request.querystring[key].value}`;
+            index++;
+        }
+        
+        var response = {
+            statusCode: 301,
+            statusDescription: 'Moved Permanently',
+            headers: { "location": { "value": `https://${event.request.headers.host.value.split('www.')[1]}${event.request.uri}${query}` } }
+        };
+
+        return response;
+    }
+
+    // Redirect if no trailing slash
+    if(!event.request.uri.includes('.') && !event.request.uri.endsWith('/')){
+        var query = '';
+        var index = 0;
+
+        for(var key in event.request.querystring){
+            query += `${index ? '&' : '?'}${key}=${event.request.querystring[key].value}`;
+            index++;
+        }
+
+        return {
+            statusCode: 301,
+            statusDescription: 'Moved Permanently',
+            headers: { "location": { "value": `${event.request.uri}/${query}` } }
+        };
+    }
+    
+    var request = event.request;
+    var uri = request.uri;
+
+    // Check whether the URI is missing a file name.
+    if(uri.endsWith('/')) {
+        request.uri += 'index.html';
+    }
+    // Check whether the URI is missing a file extension.
+    else if(!uri.includes('.')) {
+        request.uri += '/index.html';
+    }
+
+    return request;
+}

package/commands/create/libs/utilities.js

@@ -8,6 +8,8 @@ const colorize = module.exports.colorize = (str, type) => {
     switch (type) {
         case 'success':
             return chalk.green(str);
+        case 'warning':
+            return chalk.yellow(str);
         case 'error':
             return chalk.red(str);
         case 'title':
@@ -23,9 +25,12 @@ const colorize = module.exports.colorize = (str, type) => {
     }
 };
 
+let latestSpinner = null;
+
 module.exports.Spinner = class Spinner {
-    constructor(startMessage) {
-        this.ora = ora(colorize(startMessage, 'info')).start();
+    constructor(startMessage, simple = false) {
+        this.ora = ora(simple ? startMessage : colorize(startMessage, 'info')).start();
+        latestSpinner = this;
     }
 
     update(message, status) {
@@ -37,6 +42,50 @@ module.exports.Spinner = class Spinner {
             this.ora.succeed(colorize(message, status || 'success'));
         }
     }
+
+    action(message, action, success, failure) {
+        return new Promise(async (resolve, reject) => {
+            let instance = new this.constructor(message);
+            let res;
+
+            try {
+                res = await action();
+
+                instance.update(success);
+            } catch (e){
+                instance.update(failure, 'fail');
+                reject(e);
+            }
+
+            resolve(res);
+        });
+    }
+
+    simple(message, action) {
+        return new Promise(async (resolve, reject) => {
+            let instance = new this.constructor(message, true);
+            let res;
+
+            try {
+                res = await action();
+
+                instance.ora.succeed();
+            } catch (e){
+                instance.ora.fail();
+                reject(e);
+            }
+
+            resolve(res);
+        });
+    }
+
+    ping(){
+        latestSpinner.ora.color = latestSpinner.ora.color === 'cyan' ? 'magenta' : 'cyan';
+        let message = ' - check: ';
+        let split = latestSpinner.ora.text.split(message);
+        let iteration = split[1] && +split[1].split(':')[0] || 0;
+        latestSpinner.ora.text = `${split[0]}${message}${iteration+1}`;
+    }
 };
 
 module.exports.encode = (username, password) => {

package/commands/create/services/aws/cloudfront.js

@@ -0,0 +1,295 @@
+const { CloudFrontClient, CreateDistributionWithTagsCommand, CreateCloudFrontOriginAccessIdentityCommand, DeleteDistributionCommand , DeleteCloudFrontOriginAccessIdentityCommand, GetDistributionCommand, UpdateDistributionCommand, GetCloudFrontOriginAccessIdentityCommand, CreateFunctionCommand, GetFunctionCommand, UpdateFunctionCommand, PublishFunctionCommand, DeleteFunctionCommand, DescribeFunctionCommand } = require("@aws-sdk/client-cloudfront");
+const fs = require('fs');
+const { Spinner } = require('../../libs/utilities');
+const { createClient } = require('./misc.js');
+
+module.exports.createCloudFrontDistribution = async (name, account, tags = [], FunctionARN = null, region = 'us-east-1') => {
+    const client = createClient(CloudFrontClient, account, region);
+
+    let OAI = await Spinner.prototype.simple(`Creating CloudFront OAI`, () => {
+        return client.send(
+            new CreateCloudFrontOriginAccessIdentityCommand({ 
+                CloudFrontOriginAccessIdentityConfig: {
+                    CallerReference: name,
+                    Comment: `lab-env provisioned CloudFront OAI for s3 bucket ${name}`,
+                }
+            })
+        )
+    });
+
+    let res;
+
+    try {
+        res = await Spinner.prototype.simple(`Creating CloudFront distribution with CloudFront OAI and tags`, () => {
+            return client.send(
+                new CreateDistributionWithTagsCommand({
+                    DistributionConfigWithTags: {
+                        DistributionConfig: { 
+                            Enabled: true,
+                            CallerReference: name,
+                            Comment: `lab-env provisioned CloudFront distribution for project ${name}`,
+                            CustomErrorResponses: {
+                                Items: [
+                                    {
+                                        ErrorCachingMinTTL: 0,
+                                        ErrorCode: 403,
+                                        ResponseCode: 200,
+                                        ResponsePagePath: '/index.html'
+                                    }
+                                ],
+                                Quantity: 1
+                            },
+                            DefaultCacheBehavior: { 
+                                Compress: true,
+                                TargetOriginId: `${name}.s3.${region}.amazonaws.com`,
+                                ViewerProtocolPolicy: 'redirect-to-https',
+                                CachePolicyId: '658327ea-f89d-4fab-a63d-7e88639e58f6', // Built in, Managed AWS Policy - Cache Optimized
+                                FunctionAssociations: FunctionARN && {
+                                    Items: [
+                                        {
+                                            EventType: 'viewer-request',
+                                            FunctionARN
+                                        }
+                                    ],
+                                    Quantity: 1
+                                }
+                            },
+                            Origins: {
+                                Items: [
+                                    {
+                                        DomainName: `${name}.s3.${region}.amazonaws.com`,
+                                        Id: `${name}.s3.${region}.amazonaws.com`,
+                                        S3OriginConfig: {
+                                            OriginAccessIdentity: `origin-access-identity/cloudfront/${OAI.CloudFrontOriginAccessIdentity.Id}`
+                                        }
+                                    }
+                                ],
+                                Quantity: 1
+                            }
+                        },
+                        Tags: {
+                            Items: [{Key: 'client', Value: account}].concat(tags)
+                        }
+                    }
+                })
+            )
+        });
+
+        await Spinner.prototype.simple(`Waiting for CloudFront distribution to deploy`, () => {
+            return module.exports.waitForCloudFrontDistribution(res.Distribution.Id, account);
+        });
+    } catch(e){
+        let Id = e.message.split(' ')[e.message.split(' ').length - 1];
+     
+        res = await Spinner.prototype.simple(`Retrieving the already existing CloudFront distribution`, () => {
+            return client.send(
+                new GetDistributionCommand({ Id })
+            );
+        });
+    }
+    
+    return res;
+}
+
+module.exports.removeCloudFrontDistribution = async (Id, account) => {
+    const client = createClient(CloudFrontClient, account);
+
+    let res = await Spinner.prototype.simple(`Retrieving the CloudFront distribution ${Id}`, () => {
+        return client.send(
+            new GetDistributionCommand({ Id })
+        );
+    });
+
+    let OAI = res.Distribution.DistributionConfig.Origins.Items[0].S3OriginConfig.OriginAccessIdentity.split('origin-access-identity/cloudfront/')[1];
+
+    res.Distribution.DistributionConfig.Enabled = false;
+
+    res = await Spinner.prototype.simple(`Disabling the CloudFront distribution`, () => {
+        return client.send(
+            new UpdateDistributionCommand({ DistributionConfig: res.Distribution.DistributionConfig, Id, IfMatch: res.ETag })
+        );
+    });
+
+    await Spinner.prototype.simple(`Waiting for CloudFront distribution to deploy`, () => {
+        return module.exports.waitForCloudFrontDistribution(res.Distribution.Id, account);
+    });
+
+    res = await Spinner.prototype.simple(`Deleting the CloudFront distribution`, () => {
+        return client.send(
+            new DeleteDistributionCommand({ Id, IfMatch: res.ETag })
+        );
+    });
+
+    res = await Spinner.prototype.simple(`Retrieving the CloudFront OAI`, () => {
+        return client.send(
+            new GetCloudFrontOriginAccessIdentityCommand({ Id: OAI })
+        );
+    });
+
+    res = await Spinner.prototype.simple(`Deleting the CloudFront OAI`, () => {
+        return client.send(
+            new DeleteCloudFrontOriginAccessIdentityCommand({ Id: OAI, IfMatch: res.ETag })
+        );
+    });
+}
+
+module.exports.waitForCloudFrontDistribution = async (Id, account) => {
+    const client = createClient(CloudFrontClient, account);
+
+    let status;
+
+    do{
+        await new Promise((resolve) => setTimeout(() => resolve(), 5000));
+
+        await Spinner.prototype.ping();
+
+        let check = await client.send(
+            new GetDistributionCommand({ Id })
+        );
+    
+        status = check.Distribution.Status;
+    } while(status !== 'Deployed')
+}
+
+module.exports.createCloudFrontFunction = async (name, account, fn, config) => {
+    const client = createClient(CloudFrontClient, account);
+
+    let FunctionConfig = {
+        Comment: `lab-env provisioned cloudfront function for project ${name} using code snippet ${fn}.js`,
+        Runtime: `cloudfront-js-1.0`
+    };
+
+    let res;
+
+    try{
+        res = await Spinner.prototype.simple(`Creating CloudFront function`, () => {
+            return client.send(
+                new CreateFunctionCommand({
+                    Name: name,
+                    FunctionCode: new TextEncoder().encode(" "),
+                    FunctionConfig
+                })
+            );
+        });
+    } catch (e){
+        res = await Spinner.prototype.simple(`Retrieving the already existing CloudFront function`, () => {
+            return client.send(
+                new GetFunctionCommand({
+                    Name: name
+                })
+            );
+        });
+    }
+
+    let processedFn = fs.readFileSync(`${__dirname}/../../libs/${fn}.js`).toString();
+    processedFn = processedFn.replace(/<%=.*%>/g, (el) => JSON.stringify(config[el.slice(3, el.length - 2).trim()], null, 4));
+
+    res = await Spinner.prototype.simple(`Updating CloudFront function with ${fn}.js code`, () => {
+        return client.send(
+            new UpdateFunctionCommand({
+                Name: name,
+                FunctionCode: new TextEncoder().encode(processedFn),
+                FunctionConfig,
+                IfMatch: res.ETag
+            })
+        );
+    });
+    
+    res = await Spinner.prototype.simple(`Publishing CloudFront function`, () => {
+        return client.send(
+            new PublishFunctionCommand({
+                Name: name,
+                IfMatch: res.ETag
+            })
+        );
+    });
+
+    return res;
+}
+
+module.exports.removeCloudFrontFunction = async (name, account) => {
+    const client = createClient(CloudFrontClient, account);
+
+    let res = await Spinner.prototype.simple(`Retrieving CloudFront function`, () => {
+        return client.send(
+            new GetFunctionCommand({
+                Name: name
+            })
+        );
+    });
+
+    res = await Spinner.prototype.simple(`Deleting CloudFront function`, () => {
+        return client.send(
+            new DeleteFunctionCommand({
+                Name: name,
+                IfMatch: res.ETag
+            })
+        );
+    });
+
+    return res;
+}
+
+module.exports.setCloudFrontFunctionAssociation = async (Id, account) => {
+    const client = createClient(CloudFrontClient, account);
+
+    let res = await Spinner.prototype.simple(`Retrieving CloudFront distribution`, () => {
+        return client.send(
+            new GetDistributionCommand({ Id })
+        );
+    });
+
+    let { FunctionSummary: { FunctionMetadata: { FunctionARN } } } = await Spinner.prototype.simple(`Retrieving CloudFront function`, () => {
+        return client.send(
+            new DescribeFunctionCommand({
+                Name: res.Distribution.DistributionConfig.CallerReference,
+                Stage: 'LIVE'
+            })
+        );
+    });
+
+    res.Distribution.DistributionConfig.DefaultCacheBehavior.FunctionAssociations = {
+        Items: [
+            {
+                EventType: 'viewer-request',
+                FunctionARN: FunctionARN
+            }
+        ],
+        Quantity: 1
+    };
+
+    res = await Spinner.prototype.simple(`Adding CloudFront function to CloudFront distribution`, () => {
+        return client.send(
+            new UpdateDistributionCommand({ DistributionConfig: res.Distribution.DistributionConfig, Id, IfMatch: res.ETag })
+        );
+    });
+
+    await Spinner.prototype.simple(`Waiting for CloudFront distribution to deploy`, () => {
+        return module.exports.waitForCloudFrontDistribution(res.Distribution.Id, account);
+    });
+};
+
+module.exports.removeCloudFrontFunctionAssociation = async (Id, account) => {
+    const client = createClient(CloudFrontClient, account);
+
+    let res = await Spinner.prototype.simple(`Retrieving CloudFront distribution`, () => {
+        return client.send(
+            new GetDistributionCommand({ Id })
+        );
+    });
+
+    res.Distribution.DistributionConfig.DefaultCacheBehavior.FunctionAssociations = {
+        Items: [],
+        Quantity: 0
+    };
+
+    res = await Spinner.prototype.simple(`Removing CloudFront function from CloudFront distribution`, () => {
+        return client.send(
+            new UpdateDistributionCommand({ DistributionConfig: res.Distribution.DistributionConfig, Id, IfMatch: res.ETag })
+        );
+    });
+
+    await Spinner.prototype.simple(`Waiting for CloudFront distribution to deploy`, () => {
+        return module.exports.waitForCloudFrontDistribution(res.Distribution.Id, account);
+    });
+};