aws-architect 6.7.66 → 6.7.69

package/README.md

@@ -112,6 +112,14 @@ publishAndDeployStagePromise(options) {
   // options.deploymentKeyName
 }
 
+// Deploy just a new version of a lambda function
+deployLambdaFunctionVersion(options) {
+  // options.stage
+  // options.functionName
+  // options.deploymentBucketName
+  // options.deploymentKeyName
+}
+
 // Removes a deployed stage, to be used on pull-request created stages (API gateway has a limit fo 5 stages)
 removeStagePromise(stage) {...}
 

package/index.d.ts

@@ -64,19 +64,41 @@ interface WebsiteDeploymentOptions {
 
 declare class AwsArchitect {
   constructor(packageMetadata: PackageMetadata, apiOptions: ApiOptions, contentOptions: ContentOptions);
+
   publishZipArchive(options: PublishZipOptions): Promise<object>;
-  publishLambdaArtifactPromise(options: PublishLambdaOptions): Promise<object>;
+
+  /* CloudFormation */
+  // CloudFormation related handlers:
   validateTemplate(stackTemplate: object): Promise<object>;
   deployTemplate(stackTemplate: object, stackConfiguration: StackConfiguration, parameters: object): Promise<object>;
   deployStackSetTemplate(stackTemplate: object, stackSetConfiguration: StackSetConfiguration, parameters: object): Promise<object>;
   configureStackSetForAwsOrganization(stackTemplate: object, stackSetConfiguration: OrganizationalStackSetConfiguration, parameters: object): Promise<object>;
+  /* ****** */
+
+  /* API Gateway */
+  // Support for API Gateway stages
   deployStagePromise(stage: string, lambdaVersion: string): Promise<object>;
   removeStagePromise(stage: string, functionName: string): Promise<object>;
-  cleanupPreviousFunctionVersions(functionName: string, forceRemovalOfAliases: string): Promise<object>;
   publishAndDeployStagePromise(options: StageDeploymentOptions): Promise<object>;
+  /* ****** */
+
+  /* Lambda Functions */
+  // Package a lambda and push it to S3 for deployment
+  publishLambdaArtifactPromise(options: PublishLambdaOptions): Promise<object>;
+  // Clean up Lambda functions versions that aren't being used
+  cleanupPreviousFunctionVersions(functionName: string, forceRemovalOfAliases: string): Promise<object>;
+  // Deploy a new version of a lambda function alias
+  deployLambdaFunctionVersion(options: StageDeploymentOptions): Promise<object>;
+  // Run your lambda microservice locally
+  run(port: number, logger: Function): Promise<object>;
+  /* ****** */
+
+  /* S3 Websites using CloudFront */
+  // Deploy a new version of a website to S3
   publishWebsite(version: string, options: WebsiteDeploymentOptions): Promise<object>;
+  // Delete a version of the website from S3
   deleteWebsiteVersion(version: string): Promise<object>;
-  run(port: number, logger: Function): Promise<object>;
+  /* ****** */
 }
 
 export = AwsArchitect;

package/index.js

@@ -195,6 +195,31 @@ AwsArchitect.prototype.removeStagePromise = AwsArchitect.prototype.RemoveStagePr
   return { title: 'Successfully deleted stage', stage: stageName, details: result };
 };
 
+AwsArchitect.prototype.deployLambdaFunctionVersion = async function(options = {}) {
+  let stage = options.stage;
+  let stageName = getStageName(stage);
+  let functionName = options.functionName;
+  let bucket = options.deploymentBucketName || this.deploymentBucket;
+  let deploymentKey = options.deploymentKeyName;
+  if (!stage) { throw new Error('Deployment stage is not defined.'); }
+
+  try {
+    const lambda = await this.LambdaManager.PublishNewVersion(functionName, bucket, deploymentKey);
+    const lambdaArn = lambda.FunctionArn;
+    const lambdaVersion = lambda.Version;
+    await this.LambdaManager.SetAlias(functionName, stageName, lambdaVersion);
+
+    return {
+      LambdaResult: {
+        LambdaFunctionArn: lambdaArn,
+        LambdaVersion: lambdaVersion
+      }
+    };
+  } catch (failure) {
+    throw { Error: 'Failed to create and deploy updates.', Details: failure };
+  }
+};
+
 AwsArchitect.prototype.publishAndDeployStagePromise = AwsArchitect.prototype.PublishAndDeployStagePromise = async function(options = {}) {
   let stage = options.stage;
   let stageName = getStageName(stage);

package/lib/CloudFormationDeployer.js

@@ -115,14 +115,29 @@ class CloudFormationDeployer {
           }
           maxErrors += 1;
         });
-      }).then(stackStatus => {
+      }).then(async stackStatus => {
         console.log(`Current status of stack ${stackName} is ${stackStatus}.`);
         if (stackStatus === 'REVIEW_IN_PROGRESS') {
           throw { error: 'Current status of the stack has failed', status: stackStatus };
         }
 
         if (!allowUpdateRollback && stackStatus === 'UPDATE_ROLLBACK_COMPLETE') {
-          throw { title: 'Current stack status is failure', status: stackStatus };
+          const eventsResponse = await this.cloudFormationClient.describeStackEvents({ StackName: stackName }).promise();
+          const failureStackEventStatuses = {
+            CREATE_FAILED: true,
+            UPDATE_FAILED: true,
+            DELETE_FAILED: true,
+            IMPORT_FAILED: true,
+            IMPORT_ROLLBACK_FAILED: true,
+            UPDATE_ROLLBACK_FAILED: true,
+            ROLLBACK_FAILED: true
+          };
+          const mappedResults = eventsResponse.StackEvents.filter(event => failureStackEventStatuses[event.ResourceStatus]).map(result => ({
+            cloudFormationResourceName: result.LogicalResourceId, awsResourceId: result.PhysicalResourceId, error: result.ResourceStatusReason
+          }));
+          console.error('Stack status indicates failure because of the following events: ', mappedResults);
+
+          throw { title: 'Deployment to the stack failed.', status: stackStatus, code: stackStatus };
         }
 
         if (stackStatus.match(/PROGRESS$/i)) {
@@ -267,6 +282,9 @@ class CloudFormationDeployer {
 
       return stackData.Stacks[0];
     } catch (error) {
+      if (error.code === 'UPDATE_ROLLBACK_COMPLETE') {
+        throw error;
+      }
       if (error.code === 'ValidationError' || error.code === 'MultipleValidationErrors' || error.code === 'InvalidParameterType') {
         throw error;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-architect",
-  "version": "6.7.66",
+  "version": "6.7.69",
   "description": "AWS Architect is a node based tool to configure and deploy AWS-based microservices.",
   "main": "index.js",
   "types": "index.d.ts",