@adobe/helix-deploy 6.2.26 → 6.2.29

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [6.2.29](https://github.com/adobe/helix-deploy/compare/v6.2.28...v6.2.29) (2022-04-27)
+
+
+### Bug Fixes
+
+* add tags to newly created polyfunc bucket ([#405](https://github.com/adobe/helix-deploy/issues/405)) ([db4286e](https://github.com/adobe/helix-deploy/commit/db4286ea579d91ee2ad8963b87f7fa6562f8947c))
+
+## [6.2.28](https://github.com/adobe/helix-deploy/compare/v6.2.27...v6.2.28) (2022-04-25)
+
+
+### Bug Fixes
+
+* **deps:** update external fixes ([#403](https://github.com/adobe/helix-deploy/issues/403)) ([f628019](https://github.com/adobe/helix-deploy/commit/f6280196f599823b563d9f6f1145806284334bcf))
+
+## [6.2.27](https://github.com/adobe/helix-deploy/compare/v6.2.26...v6.2.27) (2022-04-25)
+
+
+### Bug Fixes
+
+* update links should link route to alias, not specific version ([#402](https://github.com/adobe/helix-deploy/issues/402)) ([45d7ea3](https://github.com/adobe/helix-deploy/commit/45d7ea31350f7027330a97dd3773404963f85149))
+
 ## [6.2.26](https://github.com/adobe/helix-deploy/compare/v6.2.25...v6.2.26) (2022-04-22)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/helix-deploy",
-  "version": "6.2.26",
+  "version": "6.2.29",
   "description": "Library and Commandline Tools to build and deploy OpenWhisk Actions",
   "license": "Apache-2.0",
   "homepage": "https://github.com/adobe/helix-deploy#readme",
@@ -39,15 +39,15 @@
   "dependencies": {
     "@adobe/fastly-native-promises": "2.0.7",
     "@adobe/helix-fetch": "3.0.9",
-    "@aws-sdk/client-apigatewayv2": "3.72.0",
-    "@aws-sdk/client-lambda": "3.72.0",
-    "@aws-sdk/client-s3": "3.72.0",
-    "@aws-sdk/client-secrets-manager": "3.72.0",
-    "@aws-sdk/client-ssm": "3.72.0",
+    "@aws-sdk/client-apigatewayv2": "3.76.0",
+    "@aws-sdk/client-lambda": "3.76.0",
+    "@aws-sdk/client-s3": "3.76.0",
+    "@aws-sdk/client-secrets-manager": "3.76.0",
+    "@aws-sdk/client-ssm": "3.76.0",
     "@fastly/js-compute": "0.2.4",
-    "@google-cloud/functions": "1.2.0",
+    "@google-cloud/functions": "1.3.0",
     "@google-cloud/secret-manager": "3.12.0",
-    "@google-cloud/storage": "5.19.2",
+    "@google-cloud/storage": "5.19.3",
     "@rollup/plugin-alias": "3.1.9",
     "@rollup/plugin-commonjs": "21.1.0",
     "@rollup/plugin-json": "4.1.0",
@@ -77,15 +77,15 @@
     "@adobe/helix-universal-logger": "2.0.7",
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/git": "10.0.1",
-    "c8": "7.11.0",
+    "c8": "7.11.2",
     "chai": "4.3.6",
     "chai-http": "4.3.0",
     "codecov": "3.8.3",
-    "eslint": "8.13.0",
+    "eslint": "8.14.0",
     "eslint-plugin-header": "3.1.1",
     "eslint-plugin-import": "2.26.0",
     "husky": "7.0.4",
-    "lint-staged": "12.3.8",
+    "lint-staged": "12.4.0",
     "mocha": "9.2.2",
     "mocha-junit-reporter": "2.0.2",
     "mocha-multi-reporters": "1.5.1",

package/src/deploy/AWSConfig.js

@@ -27,6 +27,7 @@ export default class AWSConfig {
       createAuthorizer: '',
       attachAuthorizer: '',
       identitySources: ['$request.header.Authorization'],
+      deployTemplate: 'helix-deploy-template',
     });
   }
 
@@ -42,7 +43,8 @@ export default class AWSConfig {
       .withAWSCleanUpBuckets(argv.awsCleanupBuckets)
       .withAWSCleanUpIntegrations(argv.awsCleanupIntegrations)
       .withAWSCreateRoutes(argv.awsCreateRoutes)
-      .withAWSParamsManager(argv.awsParameterManager);
+      .withAWSParamsManager(argv.awsParameterManager)
+      .withAWSDeployTemplate(argv.awsDeployTemplate);
   }
 
   withAWSRegion(value) {
@@ -100,11 +102,16 @@ export default class AWSConfig {
     return this;
   }
 
+  withAWSDeployTemplate(value) {
+    this.deployTemplate = value;
+    return this;
+  }
+
   static yarg(yargs) {
     return yargs
       .group(['aws-region', 'aws-api', 'aws-role', 'aws-cleanup-buckets', 'aws-cleanup-integrations',
         'aws-create-routes', 'aws-create-authorizer', 'aws-attach-authorizer', 'aws-lambda-format',
-        'aws-parameter-manager'], 'AWS Deployment Options')
+        'aws-parameter-manager', 'aws-deploy-template'], 'AWS Deployment Options')
       .option('aws-region', {
         description: 'the AWS region to deploy lambda functions to',
         type: 'string',
@@ -162,6 +169,11 @@ export default class AWSConfig {
         description: 'Cleans up unused integrations',
         type: 'boolean',
         default: false,
+      })
+      .option('aws-deploy-template', {
+        description: 'Name of the deploy S3 bucket template to use',
+        type: 'string',
+        default: 'helix-deploy-template',
       });
   }
 }

package/src/deploy/AWSDeployer.js

@@ -13,8 +13,9 @@
 import chalk from 'chalk-template';
 import {
   CreateBucketCommand, DeleteBucketCommand, DeleteObjectCommand, DeleteObjectsCommand,
-  ListBucketsCommand,
+  GetBucketTaggingCommand, ListBucketsCommand,
   ListObjectsV2Command, PutObjectCommand,
+  PutPublicAccessBlockCommand, PutBucketTaggingCommand,
   S3Client,
 } from '@aws-sdk/client-s3';
 
@@ -151,6 +152,44 @@ export default class AWSDeployer extends BaseDeployer {
       Bucket: this._bucket,
     }));
     this.log.info(chalk`{green ok:} bucket ${data.Location} created`);
+
+    const { deployTemplate } = this._cfg;
+    if (!deployTemplate) {
+      return;
+    }
+
+    let tags;
+    try {
+      // Obtain tags from template bucket
+      const result = await this._s3.send(new GetBucketTaggingCommand({
+        Bucket: deployTemplate,
+      }));
+      tags = result.TagSet;
+    } catch (e) {
+      this.log.warn(`Unable to obtain default tags from template bucket: ${this.bucket}`, e);
+      return;
+    }
+
+    // Block public access
+    await this._s3.send(new PutPublicAccessBlockCommand({
+      Bucket: this._bucket,
+      PublicAccessBlockConfiguration: {
+        BlockPublicAcls: true,
+        IgnorePublicAcls: true,
+        BlockPublicPolicy: true,
+        RestrictPublicBuckets: true,
+      },
+    }));
+    this.log.info(chalk`{green ok:} bucket ${data.Location} hidden from public`);
+
+    // Put required tags
+    await this._s3.send(new PutBucketTaggingCommand({
+      Bucket: this._bucket,
+      Tagging: {
+        TagSet: tags,
+      },
+    }));
+    this.log.info(chalk`{green ok:} added tags to bucket ${data.Location}`);
   }
 
   async uploadZIP() {
@@ -228,7 +267,8 @@ export default class AWSDeployer extends BaseDeployer {
       if (e.name === 'ResourceNotFoundException') {
         this.log.info(chalk`{green ok}: does not exist yet.`);
         this.log.info(chalk`--: creating new Lambda function {yellow ${functionName}}`);
-        await this._lambda.send(new CreateFunctionCommand(functionConfig));
+        const res = await this._lambda.send(new CreateFunctionCommand(functionConfig));
+        baseARN = res.FunctionArn;
       } else {
         this.log.error(chalk`Unable to verify existence of Lambda function {yellow ${functionName}}`);
         throw e;
@@ -627,21 +667,23 @@ export default class AWSDeployer extends BaseDeployer {
         Name: name,
       }));
       this.log.info(chalk`--: updating alias {blue ${name}}...`);
-      await this._lambda.send(new UpdateAliasCommand({
+      const res = await this._lambda.send(new UpdateAliasCommand({
         FunctionName: functionName,
         Name: name,
         FunctionVersion: functionVersion,
       }));
       this.log.info(chalk`{green ok:} updated alias {blue ${name}} to version {yellow ${functionVersion}}.`);
+      return res.AliasArn;
     } catch (e) {
       if (e.name === 'ResourceNotFoundException') {
         this.log.info(chalk`--: creating alias {blue ${name}}...`);
-        await this._lambda.send(new CreateAliasCommand({
+        const res = await this._lambda.send(new CreateAliasCommand({
           FunctionName: functionName,
           Name: name,
           FunctionVersion: functionVersion,
         }));
         this.log.info(chalk`{green ok:} created alias {blue ${name}} for version {yellow ${functionVersion}}.`);
+        return res.AliasArn;
       } else {
         this.log.error(`Unable to verify existence of Lambda alias ${name}`);
         throw e;
@@ -654,9 +696,7 @@ export default class AWSDeployer extends BaseDeployer {
     const { ApiId } = await this.initApiId();
     const functionVersion = cfg.version.replace(/\./g, '_');
 
-    // get function alias
     let res;
-    let aliasArn;
     let incrementalVersion;
     try {
       this.log.info(chalk`--: fetching alias ...`);
@@ -664,71 +704,97 @@ export default class AWSDeployer extends BaseDeployer {
         FunctionName: functionName,
         Name: functionVersion,
       }));
-      aliasArn = res.AliasArn;
       incrementalVersion = res.FunctionVersion;
-      this.log.info(chalk`{green ok}: ${aliasArn}`);
+      // eslint-disable-next-line prefer-destructuring
+      this._accountId = res.AliasArn.split(':')[4];
+      this.log.info(chalk`{green ok}: ${functionName}@${functionVersion} => ${incrementalVersion}`);
     } catch (e) {
       this.log.error(chalk`{red error}: Unable to create link to function ${functionName}`);
       throw e;
     }
 
-    // find integration
-    let integration = await this.findIntegration(ApiId, aliasArn);
-    let cleanup = false;
-    if (integration) {
-      this.log.info(`--: using existing integration "${integration.IntegrationId}" for "${aliasArn}"`);
-    } else {
-      integration = await this._api.send(new CreateIntegrationCommand({
-        ApiId,
-        IntegrationMethod: 'POST',
-        IntegrationType: 'AWS_PROXY',
-        IntegrationUri: aliasArn,
-        PayloadFormatVersion: '2.0',
-        TimeoutInMillis: Math.min(cfg.timeout, 30000),
-      }));
-      this.log.info(chalk`{green ok:} created new integration "${integration.IntegrationId}" for "${aliasArn}"`);
-      cleanup = true;
-    }
-    const { IntegrationId } = integration;
-
     // get all the routes
     this.log.info(chalk`--: fetching routes ...`);
     const routes = await this.fetchRoutes(ApiId);
-    const routeParams = {
-      ApiId,
-      Target: `integrations/${IntegrationId}`,
-      AuthorizerId: undefined,
-      AuthorizationType: 'NONE',
-    };
-    if (this._cfg.attachAuthorizer) {
-      this.log.info(chalk`--: fetching authorizers...`);
-      const authorizers = await this.fetchAuthorizers(ApiId);
-      const authorizer = authorizers.find((info) => info.Name === this._cfg.attachAuthorizer);
-      if (!authorizer) {
-        throw Error(`Specified authorizer ${this._cfg.attachAuthorizer} does not exist in api ${ApiId}.`);
-      }
-      routeParams.AuthorizerId = authorizer.AuthorizerId;
-      routeParams.AuthorizationType = 'CUSTOM';
-      this.log.info(chalk`{green ok:} configuring routes with authorizer {blue ${this._cfg.attachAuthorizer}} {yellow ${authorizer.AuthorizerId}}`);
-    }
 
     // create routes for each symlink
     const sfx = this.getLinkVersions();
 
     for (const suffix of sfx) {
-      // check if route already exists
+      // create or update alias
+      const aliasArn = await this.createOrUpdateAlias(suffix.replace('.', '_'), functionName, incrementalVersion);
+
+      // find or create integration
+      let integration = await this.findIntegration(ApiId, aliasArn);
+      if (integration) {
+        this.log.info(`--: using existing integration "${integration.IntegrationId}" for "${aliasArn}"`);
+      } else {
+        integration = await this._api.send(new CreateIntegrationCommand({
+          ApiId,
+          IntegrationMethod: 'POST',
+          IntegrationType: 'AWS_PROXY',
+          IntegrationUri: aliasArn,
+          PayloadFormatVersion: '2.0',
+          TimeoutInMillis: Math.min(cfg.timeout, 30000),
+        }));
+        this.log.info(chalk`{green ok:} created new integration "${integration.IntegrationId}" for "${aliasArn}"`);
+      }
+      const { IntegrationId } = integration;
+
+      const routeParams = {
+        ApiId,
+        Target: `integrations/${IntegrationId}`,
+        AuthorizerId: undefined,
+        AuthorizationType: 'NONE',
+      };
+      if (this._cfg.attachAuthorizer) {
+        this.log.info(chalk`--: fetching authorizers...`);
+        const authorizers = await this.fetchAuthorizers(ApiId);
+        const authorizer = authorizers.find((info) => info.Name === this._cfg.attachAuthorizer);
+        if (!authorizer) {
+          throw Error(`Specified authorizer ${this._cfg.attachAuthorizer} does not exist in api ${ApiId}.`);
+        }
+        routeParams.AuthorizerId = authorizer.AuthorizerId;
+        routeParams.AuthorizationType = 'CUSTOM';
+        this.log.info(chalk`{green ok:} configuring routes with authorizer {blue ${this._cfg.attachAuthorizer}} {yellow ${authorizer.AuthorizerId}}`);
+      }
+
+      // create or update routes
       await this.createOrUpdateRoute(routes, routeParams, `ANY /${cfg.packageName}/${cfg.baseName}/${suffix}`);
       await this.createOrUpdateRoute(routes, routeParams, `ANY /${cfg.packageName}/${cfg.baseName}/${suffix}/{path+}`);
 
-      // create or update alias
-      await this.createOrUpdateAlias(suffix.replace('.', '_'), functionName, incrementalVersion);
-    }
+      await this.updateAuthorizers(ApiId, functionName, aliasArn);
 
-    if (cleanup) {
-      await this.cleanUpIntegrations(functionName);
+      // add permissions to invoke function (with and without path)
+      let sourceArn = `arn:aws:execute-api:${this._cfg.region}:${this._accountId}:${ApiId}/*/*/${cfg.packageName}/${cfg.baseName}/${suffix}`;
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await this._lambda.send(new AddPermissionCommand({
+          FunctionName: aliasArn,
+          Action: 'lambda:InvokeFunction',
+          SourceArn: sourceArn,
+          Principal: 'apigateway.amazonaws.com',
+          StatementId: crypto.createHash('md5').update(aliasArn + sourceArn).digest('hex'),
+        }));
+        this.log.info(chalk`{green ok:} added invoke permissions for ${sourceArn}`);
+      } catch (e) {
+        // ignore, most likely the permission already exists
+      }
+      sourceArn = `arn:aws:execute-api:${this._cfg.region}:${this._accountId}:${ApiId}/*/*/${cfg.packageName}/${cfg.baseName}/${suffix}/{path+}`;
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await this._lambda.send(new AddPermissionCommand({
+          FunctionName: aliasArn,
+          Action: 'lambda:InvokeFunction',
+          SourceArn: sourceArn,
+          Principal: 'apigateway.amazonaws.com',
+          StatementId: crypto.createHash('md5').update(aliasArn + sourceArn).digest('hex'),
+        }));
+        this.log.info(chalk`{green ok:} added invoke permissions for ${sourceArn}`);
+      } catch (e) {
+        // ignore, most likely the permission already exists
+      }
     }
-
-    await this.updateAuthorizers(ApiId, functionName, aliasArn);
   }
 
   async updateAuthorizers(ApiId, functionName, aliasArn) {