@fishawack/lab-env 2.0.2 → 3.0.0

package/commands/create/libs/utilities.js

@@ -23,9 +23,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 +40,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);
+    });
+};

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

@@ -0,0 +1,170 @@
+const { IAMClient, CreateUserCommand, GetUserCommand, DeleteUserCommand, AttachUserPolicyCommand, ListAttachedUserPoliciesCommand, DetachUserPolicyCommand, CreateAccessKeyCommand, DeleteAccessKeyCommand, ListAccessKeysCommand } = require("@aws-sdk/client-iam");
+const { Spinner } = require('../../libs/utilities');
+const { createClient } = require('./misc.js');
+
+module.exports.createIAMUser = async (UserName, account) => {
+    const client = createClient(IAMClient, account);
+
+    let res;
+
+    try{
+        res = await Spinner.prototype.simple(`Creating IAM user ${UserName}`, () => {
+            return client.send(
+                new CreateUserCommand({ UserName })
+            );
+        });
+    } catch(e){
+        res = await Spinner.prototype.simple(`Retrieving the already existing IAM user ${UserName}`, () => {
+            return client.send(
+                new GetUserCommand({ UserName })
+            );
+        });
+    }
+
+    return res;
+};
+
+module.exports.createFWIAMUser = async (UserName, account) => {
+    await module.exports.createIAMUser(UserName, account);
+
+    await module.exports.syncFWIAMPolicies(UserName, account);
+
+    let res = await module.exports.createAccessKeySafe(UserName, account);
+
+    return res;
+};
+
+module.exports.removeIAMUser = async (UserName, account) => {
+    const client = createClient(IAMClient, account);
+
+    let res;
+
+    try{
+        await Spinner.prototype.simple(`Checking if IAM user ${UserName} exists`, () => {
+            return client.send(
+                new GetUserCommand({ UserName })
+            );
+        });
+
+        await module.exports.removeAllIAMPolicies(UserName, account);
+
+        await module.exports.removeAllAccessKeys(UserName, account);
+
+        res = await Spinner.prototype.simple(`Removing IAM user ${UserName}`, () => {
+            return client.send(
+                new DeleteUserCommand({ UserName })
+            );
+        });
+    } catch(e){
+    }
+
+    return res;
+};
+
+module.exports.attachIAMPolicy = async (UserName, account, policy) => {
+    const client = createClient(IAMClient, account);
+
+    let res = await Spinner.prototype.simple(`Attaching IAM policy ${policy}`, () => {
+        return client.send(
+            new AttachUserPolicyCommand({ UserName, PolicyArn: policy })
+        );
+    });
+
+    return res;
+};
+
+module.exports.syncFWIAMPolicies = async (UserName, account) => {
+    await module.exports.removeAllIAMPolicies(UserName, account);
+    await module.exports.attachIAMPolicy(UserName, account, 'arn:aws:iam::aws:policy/AmazonS3FullAccess');
+    await module.exports.attachIAMPolicy(UserName, account, 'arn:aws:iam::aws:policy/CloudFrontFullAccess');
+};
+
+module.exports.removeIAMPolicy = async (UserName, account, policy) => {
+    const client = createClient(IAMClient, account);
+
+    let res = await Spinner.prototype.simple(`Detaching IAM policy ${policy}`, () => {
+        return client.send(
+            new DetachUserPolicyCommand({ UserName, PolicyArn: policy })
+        );
+    });
+
+    return res;
+};
+
+module.exports.listIAMPolicies = async (UserName, account) => {
+    const client = createClient(IAMClient, account);
+
+    let res = await Spinner.prototype.simple(`Listing IAM policies`, () => {
+        return client.send(
+            new ListAttachedUserPoliciesCommand({ UserName })
+        );
+    });
+
+    return res;
+};
+
+module.exports.removeAllIAMPolicies = async (UserName, account) => {
+    let res = await module.exports.listIAMPolicies(UserName, account);
+
+    for(let i = 0; i < res.AttachedPolicies.length; i++){
+        await module.exports.removeIAMPolicy(UserName, account, res.AttachedPolicies[i].PolicyArn);
+    }
+
+    return res;
+};
+
+module.exports.createAccessKey = async (UserName, account) => {
+    const client = createClient(IAMClient, account);
+
+    let res = await Spinner.prototype.simple(`Creating access key`, () => {
+        return client.send(
+            new CreateAccessKeyCommand({ UserName })
+        );
+    });
+
+    return res;
+};
+
+module.exports.removeAccessKey = async (UserName, account, AccessKeyId) => {
+    const client = createClient(IAMClient, account);
+
+    let res = await Spinner.prototype.simple(`Removing access key ${AccessKeyId}`, () => {
+        return client.send(
+            new DeleteAccessKeyCommand({ AccessKeyId, UserName })
+        );
+    });
+
+    return res;
+};
+
+module.exports.listAccessKeys = async (UserName, account) => {
+    const client = createClient(IAMClient, account);
+
+    let res = await Spinner.prototype.simple(`Listing access keys`, () => {
+        return client.send(
+            new ListAccessKeysCommand({ UserName })
+        );
+    });
+
+    return res;
+};
+
+module.exports.removeAllAccessKeys = async (UserName, account) => {
+    let res = await module.exports.listAccessKeys(UserName, account);
+
+    for(let i = 0; i < res.AccessKeyMetadata.length; i++){
+        await module.exports.removeAccessKey(UserName, account, res.AccessKeyMetadata[i].AccessKeyId);
+    }
+
+    return res;
+};
+
+module.exports.createAccessKeySafe = async (UserName, account) => {
+    let res = await module.exports.listAccessKeys(UserName, account);
+
+    if(!res.AccessKeyMetadata.length){
+        res = await module.exports.createAccessKey(UserName, account);
+    }
+
+    return res;
+};

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

@@ -0,0 +1,25 @@
+module.exports.s3 = require("./s3.js");
+module.exports.cloudfront = require("./cloudfront.js");
+module.exports.iam = require("./iam.js");
+
+module.exports.slug = (repo, client, branch) => `fw-auto-${client}-${repo}-${branch}`;
+
+module.exports.clients = ['fishawack', 'abbvie', 'sanofigenzyme', 'gsk', 'janssen', 'astrazeneca', 'ptc', 'jazz', 'pfizer', 'heron', 'novartis', 'training'];
+
+module.exports.static = async (name, account, tags = [], credentials = []) => {
+    let s3 = await module.exports.s3.createS3Bucket(name, account, tags);
+
+    let cloudfrontFunction = await module.exports.cloudfront.createCloudFrontFunction(name, account, credentials.length ? 'aws-cloudfront-auth' : 'aws-cloudfront-simple', {credentials: credentials.map(d => `Basic ${Buffer.from(`${d.username}:${d.password}`).toString('base64')}`)});
+
+    let cloudfront = await module.exports.cloudfront.createCloudFrontDistribution(name, account, tags, cloudfrontFunction.FunctionSummary.FunctionMetadata.FunctionARN);
+
+    await module.exports.s3.setS3BucketPolicy(name, account, cloudfront.Distribution.DistributionConfig.Origins.Items[0].S3OriginConfig.OriginAccessIdentity.split('origin-access-identity/cloudfront/')[1]);
+
+    let config = {
+        "bucket": s3.Location,
+        "url": `https://${cloudfront.Distribution.DomainName}`,
+        "cloudfront": cloudfront.Distribution.Id,
+    };
+
+    return config;
+}

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

@@ -0,0 +1,9 @@
+module.exports.createClient = (client, account, region = 'us-east-1') => {
+    delete process.env.AWS_PROFILE;
+
+    if(account){
+        process.env.AWS_PROFILE = account;
+    }
+
+    return new client({ region });
+}

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

@@ -0,0 +1,109 @@
+const { S3Client, CreateBucketCommand, DeleteBucketCommand, ListBucketsCommand, PutPublicAccessBlockCommand, PutBucketTaggingCommand, PutBucketPolicyCommand, PutObjectCommand, DeleteObjectCommand } = require("@aws-sdk/client-s3");
+const { Spinner } = require('../../libs/utilities');
+const { createClient } = require('./misc.js');
+
+module.exports.createS3Bucket = async (bucket, account, tags = []) => {
+    const client = createClient(S3Client, account);
+
+    let res = await Spinner.prototype.simple(`Creating s3 bucket ${bucket}`, () => {
+        return client.send(
+            new CreateBucketCommand({ Bucket: bucket })
+        );
+    });
+
+    await Spinner.prototype.simple(`Blocking all public access to s3 bucket`, () => {
+        return client.send(
+            new PutPublicAccessBlockCommand({ Bucket: bucket, PublicAccessBlockConfiguration: { BlockPublicAcls: true, BlockPublicPolicy: true, IgnorePublicAcls: true, RestrictPublicBuckets: true } })
+        );
+    });
+
+    await Spinner.prototype.simple(`Adding tags to s3 bucket`, () => {
+        return client.send(
+            new PutBucketTaggingCommand({ Bucket: bucket, Tagging: {TagSet: [{Key: 'client', Value: account}].concat(tags)} })
+        );
+    });
+    
+    return res;
+}
+
+module.exports.listS3Buckets = async (account) => {
+    const client = createClient(S3Client, account);
+
+    let res = await Spinner.prototype.simple(`Listing s3 buckets`, () => {
+        return client.send(
+            new ListBucketsCommand({})
+        );
+    });
+
+    return res;
+}
+
+module.exports.removeS3Bucket = async (bucket, account) => {
+    const client = createClient(S3Client, account);
+
+    await Spinner.prototype.simple(`Removing s3 bucket ${bucket}`, () => {
+        return client.send(
+            new DeleteBucketCommand({ Bucket: bucket })
+        );
+    });
+}
+
+module.exports.setS3BucketPolicy = async (bucket, account, OAI) => {
+    const client = createClient(S3Client, account);
+
+    let res = await Spinner.prototype.simple(`Updating s3 bucket policy`, () => {
+        return client.send(
+            new PutBucketPolicyCommand({
+                Bucket: bucket,
+                Policy: JSON.stringify({
+                    "Version": "2008-10-17",
+                    "Id": "PolicyForCloudFrontPrivateContent",
+                    "Statement": [
+                        {
+                            "Sid": "1",
+                            "Effect": "Allow",
+                            "Principal": {
+                                "AWS": `arn:aws:iam::cloudfront:user/CloudFront Origin Access Identity ${OAI}`
+                            },
+                            "Action": "s3:GetObject",
+                            "Resource": `arn:aws:s3:::${bucket}/*`
+                        }
+                    ]
+                })
+            })
+        );
+    });
+
+    return res;
+}
+
+module.exports.addFileToS3Bucket = async (bucket, account, filepath, file) => {
+    const client = createClient(S3Client, account);
+
+    let res = await Spinner.prototype.simple(`Adding file to s3 bucket`, () => {
+        return client.send(
+            new PutObjectCommand({
+                Bucket: bucket,
+                Body: file,
+                Key: filepath
+            })
+        );
+    });
+    
+    return res;
+};
+
+module.exports.removeFileToS3Bucket = async (bucket, account, filepath) => {
+    const client = createClient(S3Client, account);
+
+    let res = await Spinner.prototype.simple(`Removing file from s3 bucket`, () => {
+        return client.send(
+            new DeleteObjectCommand({
+                Bucket: bucket,
+                Key: filepath
+            })
+        );
+    });
+    
+    return res;
+}

package/commands/create/services/guide.js

@@ -194,6 +194,19 @@ module.exports.preset = async () => {
     return inputs.preset;
 }
 
+module.exports.gitlabSkip = async () => {
+    let inputs = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Do you want to test gitlab setup? (VPN required)',
+            default: true
+        }
+    ]);
+
+    return !inputs.confirm;
+}
+
 module.exports.config = async () => {
     let inputs = await inquirer.prompt([
         {