aws-architect 6.6.26 → 6.6.31

package/index.js

@@ -4,7 +4,7 @@ let exec = require('child_process').exec;
 let fs = require('fs-extra');
 let path = require('path');
 let os = require('os');
-let uuid = require('uuid');
+const shortUuid = require('short-uuid');
 
 let Server = require('./lib/server');
 let ApiGatewayManager = require('./lib/ApiGatewayManager');
@@ -47,7 +47,7 @@ AwsArchitect.prototype.publishZipArchive = async function(options = {}) {
   if (!options.zipFileName || !this.deploymentBucket || !options.sourceDirectory) {
     throw Error('The zipFileName, sourceDirectory, api options deploymentBucket must be specified.');
   }
-  let tmpDir = path.join(os.tmpdir(), `zipDirectory-${uuid.v4()}`);
+  let tmpDir = path.join(os.tmpdir(), `zipDirectory-${shortUuid.generate()}`);
   await new Promise((resolve, reject) => { fs.stat(options.sourceDirectory, (error, stats) => error || !stats.isDirectory ? reject(error || 'NotDirectoryError') : resolve()); });
   await fs.copy(options.sourceDirectory, tmpDir);
   let zipArchivePath = path.join(tmpDir, options.zipFileName);
@@ -67,7 +67,7 @@ AwsArchitect.prototype.publishZipArchive = async function(options = {}) {
 
 AwsArchitect.prototype.publishLambdaArtifactPromise = AwsArchitect.prototype.PublishLambdaArtifactPromise = async function(options = {}) {
   let lambdaZip = options && options.zipFileName || 'lambda.zip';
-  let tmpDir = path.join(os.tmpdir(), `lambda-${uuid.v4()}`);
+  let tmpDir = path.join(os.tmpdir(), `lambda-${shortUuid.generate()}`);
 
   await new Promise((resolve, reject) => {
     fs.stat(this.SourceDirectory, (error, stats) => {

package/lib/BucketManager.js

@@ -41,6 +41,9 @@ class BucketManager {
       let cacheControl = matchingCacheMap && matchingCacheMap.value || cacheControlRegexMap[relativePathUnixFormat] || cacheControlRegexMap.default || 600;
       const fileUrl = this.unixify(path.join(version, relativePath));
       const fileData = await fs.readFile(file);
+
+      await this.ensureBucketExists(this.Bucket);
+
       const putObjectParams = {
         Bucket: this.Bucket,
         Key: fileUrl,
@@ -112,18 +115,21 @@ class BucketManager {
     await this.S3Manager.putObject(params).promise();
   }
 
-  DeployLambdaPromise(bucket, localPath, remotePath) {
-    return this.S3Manager.upload({
-      Bucket: bucket || this.Bucket,
-      Key: this.unixify(remotePath),
-      Body: fs.createReadStream(localPath),
-      ContentType: contentTypeMappingConst[path.extname(remotePath)] || lookup(remotePath) || contentTypeMappingConst.default || 'text/plain',
-      CacheControl: 'public, max-age=10'
-    }).promise()
-    .then(() => { console.log(`====> ${remotePath}`); })
-    .catch(failure => {
+  async DeployLambdaPromise(bucket, localPath, remotePath) {
+    await this.ensureBucketExists(bucket || this.Bucket);
+
+    try {
+      await this.S3Manager.upload({
+        Bucket: bucket || this.Bucket,
+        Key: this.unixify(remotePath),
+        Body: fs.createReadStream(localPath),
+        ContentType: contentTypeMappingConst[path.extname(remotePath)] || lookup(remotePath) || contentTypeMappingConst.default || 'text/plain',
+        CacheControl: 'public, max-age=10'
+      }).promise();
+      console.log(`====> ${remotePath}`);
+    } catch (failure) {
       throw { File: localPath, Detail: failure };
-    });
+    }
   }
 
   CopyBucket(source, target) {
@@ -153,6 +159,21 @@ class BucketManager {
     });
   }
 
+  async ensureBucketExists(bucket) {
+    try {
+      await this.S3Manager.headBucket({ Bucket: bucket }).promise();
+    } catch (error) {
+      if (error.code !== 'NotFound') {
+        throw error;
+      }
+
+      await this.S3Manager.createBucket({ Bucket: bucket, ObjectOwnership: 'BucketOwnerEnforced', CreateBucketConfiguration: { LocationConstraint: this.S3Manager.config.region } }).promise();
+      await this.S3Manager.putPublicAccessBlock({
+        Bucket: bucket, PublicAccessBlockConfiguration: { BlockPublicAcls: true, BlockPublicPolicy: true, IgnorePublicAcls: true, RestrictPublicBuckets: true }
+      }).promise();
+    }
+  }
+
   // ensures a path will be in unix format (that is, forward slash), also on Windows systems.
   unixify(fullPath) {
     return fullPath.replace(/\\/g, '/');

package/lib/CloudFormationDeployer.js

@@ -54,35 +54,46 @@ class CloudFormationDeployer {
     }
   }
 
-  stackExists(stackName) {
-    return this.cloudFormationClient.describeStacks({ StackName: stackName }).promise()
-    .then(async data => {
-      if (!data.Stacks[0]) {
-        return false;
-      }
-      let stackStatus = data.Stacks[0].StackStatus;
-      let stackExistsDict = {
-        CREATE_COMPLETE: true,
-        UPDATE_COMPLETE: true,
-        UPDATE_ROLLBACK_COMPLETE: true
-      };
+  async stackExists(stackName) {
+    let data;
+    try {
+      data = await this.cloudFormationClient.describeStacks({ StackName: stackName }).promise();
+    } catch (error) {
+      return false;
+    }
+    if (!data.Stacks[0]) {
+      return false;
+    }
+    let stackStatus = data.Stacks[0].StackStatus;
+    let stackExistsDict = {
+      CREATE_COMPLETE: true,
+      UPDATE_COMPLETE: true,
+      UPDATE_ROLLBACK_COMPLETE: true
+    };
 
-      if (stackExistsDict[stackStatus]) {
-        return true;
-      }
-      if (stackStatus === 'REVIEW_IN_PROGRESS') {
-        return false;
-      }
-      if (stackStatus === 'ROLLBACK_COMPLETE') {
-        console.log('Current status of stack is ROLLBACK_COMPLETE, deleting before generating a new stack.');
-        await this.cloudFormationClient.deleteStack({ StackName: stackName }).promise();
-        return false;
+    if (stackExistsDict[stackStatus]) {
+      return true;
+    }
+    if (stackStatus === 'REVIEW_IN_PROGRESS') {
+      return false;
+    }
+    if (stackStatus === 'ROLLBACK_COMPLETE') {
+      console.log('Current status of stack is ROLLBACK_COMPLETE, deleting before generating a new stack.');
+      await this.cloudFormationClient.deleteStack({ StackName: stackName }).promise();
+      for (let checkIteration = 0; checkIteration < 120; checkIteration++) {
+        try {
+          await this.cloudFormationClient.describeStacks({ StackName: stackName }).promise();
+          await new Promise(resolve => setTimeout(resolve, 5000));
+        } catch (error) {
+          break;
+        }
       }
-      throw { error: 'Current status of stack prevents creation or update.', status: stackStatus };
-    }, () => false);
+      return false;
+    }
+    throw { error: 'Current status of stack prevents creation or update.', status: stackStatus };
   }
 
-  async waitForCompletion(stackName, allow_update_rollback) {
+  async waitForCompletion(stackName, allowUpdateRollback) {
     let timeout = new Date();
     let timeoutLength = 60 * 60 * 1000;
     timeout.setTime(timeout.getTime() + timeoutLength);
@@ -110,7 +121,7 @@ class CloudFormationDeployer {
           throw { error: 'Current status of the stack has failed', status: stackStatus };
         }
 
-        if (!allow_update_rollback && stackStatus === 'UPDATE_ROLLBACK_COMPLETE') {
+        if (!allowUpdateRollback && stackStatus === 'UPDATE_ROLLBACK_COMPLETE') {
           throw { title: 'Current stack status is failure', status: stackStatus };
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-architect",
-  "version": "6.6.26",
+  "version": "6.6.31",
   "description": "AWS Architect is a node based tool to configure and deploy AWS-based microservices.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -31,8 +31,8 @@
     "lodash.isequal": "^4.5.0",
     "mime-types": "^2.1.27",
     "morgan": "^1.9.1",
-    "tmp": "^0.0.33",
-    "uuid": "^2.0.2"
+    "short-uuid": "^4.2.0",
+    "tmp": "^0.0.33"
   },
   "peerDependencies": {
     "aws-sdk": ">=2.877.0"