@pwrdrvr/microapps-publish 0.0.21 → 0.0.25

package/src/commands/publish-static.ts

@@ -0,0 +1,322 @@
+import 'reflect-metadata';
+import * as s3 from '@aws-sdk/client-s3';
+import * as sts from '@aws-sdk/client-sts';
+import { Command, flags as flagsParser } from '@oclif/command';
+import * as path from 'path';
+import { pathExists, createReadStream } from 'fs-extra';
+import { Listr, ListrTask } from 'listr2';
+import { Config } from '../config/Config';
+import DeployClient, { IDeployVersionPreflightResult } from '../lib/DeployClient';
+import S3Uploader from '../lib/S3Uploader';
+import S3TransferUtility from '../lib/S3TransferUtility';
+import { Upload } from '@aws-sdk/lib-storage';
+import { contentType } from 'mime-types';
+import { createVersions, IVersions } from '../lib/Versions';
+
+interface IContext {
+  preflightResult: IDeployVersionPreflightResult;
+  files: string[];
+}
+
+export class PublishCommand extends Command {
+  static description = 'Publish arbitrary framework static app - deploy static assets to S3 only.';
+
+  static examples = [
+    `$ microapps-publish publish-static -d microapps-deployer-dev -n 0.0.21 -l microapps-app-release-dev -a release
+✔ Get S3 Temp Credentials [1s]
+✔ Confirm Static Assets Folder Exists [0.0s]
+✔ Copy Static Files to Local Upload Dir [0.0s]
+✔ Enumerate Files to Upload to S3 [0.0s]
+✔ Upload Static Files to S3 [1s]
+✔ Creating MicroApp Application: release [0.0s]
+✔ Creating MicroApp Version: 0.0.21 [1s]
+`,
+  ];
+
+  static flags = {
+    version: flagsParser.version({
+      char: 'v',
+    }),
+    help: flagsParser.help(),
+    deployerLambdaName: flagsParser.string({
+      char: 'd',
+      multiple: false,
+      required: true,
+      description: 'Name of the deployer lambda function',
+    }),
+    newVersion: flagsParser.string({
+      char: 'n',
+      multiple: false,
+      required: true,
+      description: 'New semantic version to apply',
+    }),
+    appName: flagsParser.string({
+      char: 'a',
+      multiple: false,
+      required: false,
+      description: 'MicroApps app name',
+    }),
+    staticAssetsPath: flagsParser.string({
+      char: 's',
+      multiple: false,
+      required: false,
+      description:
+        'Path to files to be uploaded to S3 static bucket at app/version/ path.  Do include app/version/ in path if files are already "rooted" under that path locally.',
+    }),
+    defaultFile: flagsParser.string({
+      char: 'i',
+      multiple: false,
+      required: false,
+      description:
+        'Default file to return when the app is loaded via the router without a version (e.g. when app/ is requested).',
+    }),
+    overwrite: flagsParser.boolean({
+      char: 'o',
+      required: false,
+      default: false,
+      description:
+        'Allow overwrite - Warn but do not fail if version exists. Discouraged outside of test envs if cacheable static files have changed.',
+    }),
+    noCache: flagsParser.boolean({
+      required: false,
+      default: false,
+      description: 'Force revalidation of CloudFront and browser caching of static assets',
+    }),
+  };
+
+  private VersionAndAlias: IVersions;
+
+  async run(): Promise<void> {
+    const config = Config.instance;
+
+    // const RUNNING_TEXT = ' RUNS ';
+    // const RUNNING = chalk.reset.inverse.yellow.bold(RUNNING_TEXT) + ' ';
+    const RUNNING = ''; //chalk.reset.inverse.yellow.bold(RUNNING_TEXT) + ' ';
+
+    const { flags: parsedFlags } = this.parse(PublishCommand);
+    const appName = parsedFlags.appName ?? config.app.name;
+    const deployerLambdaName = parsedFlags.deployerLambdaName ?? config.deployer.lambdaName;
+    const semVer = parsedFlags.newVersion ?? config.app.semVer;
+    const staticAssetsPath = parsedFlags.staticAssetsPath ?? config.app.staticAssetsPath;
+    const defaultFile = parsedFlags.defaultFile ?? config.app.defaultFile;
+    const overwrite = parsedFlags.overwrite;
+    const noCache = parsedFlags.noCache;
+
+    // Override the config value
+    config.deployer.lambdaName = deployerLambdaName;
+    delete config.app.lambdaName;
+    config.app.name = appName;
+    config.app.semVer = semVer;
+    config.app.staticAssetsPath = staticAssetsPath;
+    config.app.defaultFile = defaultFile;
+
+    // Get the account ID and region from STS
+    // TODO: Move this to the right place
+    if (config.app.awsAccountID === 0 || config.app.awsRegion === '') {
+      const stsClient = new sts.STSClient({
+        maxAttempts: 8,
+      });
+      const stsResponse = await stsClient.send(new sts.GetCallerIdentityCommand({}));
+      if (config.app.awsAccountID === 0) {
+        config.app.awsAccountID = parseInt(stsResponse.Account, 10);
+      }
+      if (config.app.awsRegion === '') {
+        config.app.awsRegion = stsClient.config.region as string;
+      }
+    }
+
+    this.VersionAndAlias = createVersions(semVer);
+
+    if (config.app.staticAssetsPath === undefined) {
+      this.error('staticAssetsPath must be specified');
+    }
+    if (config.app.defaultFile === undefined || config.app.defaultFile === '') {
+      this.error('defaultFile must be specified');
+    }
+
+    //
+    // Setup Tasks
+    //
+
+    const tasks = new Listr<IContext>(
+      [
+        {
+          // TODO: Disable this task if no static assets path
+          title: 'Get S3 Temp Credentials',
+          task: async (ctx, task) => {
+            const origTitle = task.title;
+            task.title = RUNNING + origTitle;
+
+            // Confirm the Version Does Not Exist in Published State
+            task.output = `Checking if deployed app/version already exists for ${config.app.name}/${semVer}`;
+            ctx.preflightResult = await DeployClient.DeployVersionPreflight({
+              config,
+              overwrite,
+              output: (message: string) => (task.output = message),
+            });
+            if (ctx.preflightResult.exists) {
+              if (!overwrite) {
+                throw new Error(
+                  `App/Version already exists: ${config.app.name}/${config.app.semVer}`,
+                );
+              } else {
+                task.title = `Warning: App/Version already exists: ${config.app.name}/${config.app.semVer}`;
+              }
+            } else {
+              task.title = `App/Version does not exist: ${config.app.name}/${config.app.semVer}`;
+            }
+          },
+        },
+        {
+          // TODO: Disable this task if no static assets path
+          title: 'Confirm Static Assets Folder Exists',
+          task: async (ctx, task) => {
+            const origTitle = task.title;
+            task.title = RUNNING + origTitle;
+
+            // Check that Static Assets Folder exists
+            if (!(await pathExists(config.app.staticAssetsPath))) {
+              this.error(`Static asset path does not exist: ${config.app.staticAssetsPath}`);
+            }
+
+            task.title = origTitle;
+          },
+        },
+        {
+          // TODO: Disable this task if no static assets path
+          title: 'Copy Static Files to Local Upload Dir',
+          task: async (ctx, task) => {
+            const origTitle = task.title;
+            task.title = RUNNING + origTitle;
+
+            // Copy files to local dir to be uploaded
+            await S3Uploader.CopyToUploadDir(config, ctx.preflightResult.response.s3UploadUrl);
+
+            task.title = origTitle;
+          },
+        },
+        {
+          // TODO: Disable this task if no static assets path
+          title: 'Enumerate Files to Upload to S3',
+          task: async (ctx, task) => {
+            const origTitle = task.title;
+            task.title = RUNNING + origTitle;
+
+            ctx.files = (await S3TransferUtility.GetFiles(S3Uploader.TempDir)) as string[];
+
+            task.title = origTitle;
+          },
+        },
+        {
+          // TODO: Disable this task if no static assets path
+          title: 'Upload Static Files to S3',
+          task: (ctx, task) => {
+            const origTitle = task.title;
+            task.title = RUNNING + origTitle;
+
+            const { bucketName, destinationPrefix } = S3Uploader.ParseUploadPath(
+              ctx.preflightResult.response.s3UploadUrl,
+            );
+
+            // Use temp credentials for S3
+            const s3Client = new s3.S3Client({
+              maxAttempts: 16,
+              credentials: {
+                accessKeyId: ctx.preflightResult.response.awsCredentials.accessKeyId,
+                secretAccessKey: ctx.preflightResult.response.awsCredentials.secretAccessKey,
+                sessionToken: ctx.preflightResult.response.awsCredentials.sessionToken,
+              },
+            });
+
+            // Setup caching on static assets
+            // NoCache - Only used for test deploys, requires browser and CloudFront to refetch every time
+            // Overwrite - Reduces default cache time period from 24 hours to 15 minutes
+            // Default - 24 hours
+            const CacheControl = noCache
+              ? 'max-age=0, must-revalidate, public'
+              : overwrite
+              ? `max-age=${15 * 60}, public`
+              : `max-age=${24 * 60 * 60}, public`;
+
+            const pathWithoutAppAndVer = path.join(S3Uploader.TempDir, destinationPrefix);
+
+            const tasks: ListrTask<IContext>[] = ctx.files.map((filePath) => ({
+              task: async (ctx: IContext, subtask) => {
+                const relFilePath = path.relative(pathWithoutAppAndVer, filePath);
+
+                const origTitle = relFilePath;
+                subtask.title = RUNNING + origTitle;
+
+                const upload = new Upload({
+                  client: s3Client,
+                  leavePartsOnError: false,
+                  params: {
+                    Bucket: bucketName,
+                    Key: path.relative(S3Uploader.TempDir, filePath),
+                    Body: createReadStream(filePath),
+                    ContentType: contentType(path.basename(filePath)) || 'application/octet-stream',
+                    CacheControl,
+                  },
+                });
+                await upload.done();
+
+                subtask.title = origTitle;
+              },
+            }));
+
+            task.title = origTitle;
+
+            return task.newListr(tasks, {
+              concurrent: 8,
+              rendererOptions: {
+                clearOutput: false,
+                showErrorMessage: true,
+                showTimer: true,
+              },
+            });
+          },
+        },
+        {
+          title: `Creating MicroApp Application: ${config.app.name}`,
+          task: async (ctx, task) => {
+            const origTitle = task.title;
+            task.title = RUNNING + origTitle;
+
+            // Call Deployer to Create App if Not Exists
+            await DeployClient.CreateApp({ config });
+
+            task.title = origTitle;
+          },
+        },
+        {
+          title: `Creating MicroApp Version: ${config.app.semVer}`,
+          task: async (ctx, task) => {
+            const origTitle = task.title;
+            task.title = RUNNING + origTitle;
+
+            // Call Deployer to Deploy AppName/Version
+            await DeployClient.DeployVersion({
+              config,
+              appType: 'static',
+              overwrite,
+              output: (message: string) => (task.output = message),
+            });
+
+            task.title = origTitle;
+          },
+        },
+      ],
+      {
+        rendererOptions: {
+          showTimer: true,
+        },
+      },
+    );
+
+    try {
+      await tasks.run();
+    } finally {
+      await S3Uploader.removeTempDirIfExists();
+    }
+  }
+}

package/src/commands/publish.ts

@@ -4,7 +4,6 @@ import * as lambda from '@aws-sdk/client-lambda';
 import * as s3 from '@aws-sdk/client-s3';
 import * as sts from '@aws-sdk/client-sts';
 import { Command, flags as flagsParser } from '@oclif/command';
-import * as chalk from 'chalk';
 import * as path from 'path';
 import { pathExists, createReadStream } from 'fs-extra';
 import { Listr, ListrTask } from 'listr2';
@@ -74,6 +73,32 @@ export class PublishCommand extends Command {
       required: false,
       description: 'MicroApps app name',
     }),
+    staticAssetsPath: flagsParser.string({
+      char: 's',
+      multiple: false,
+      required: false,
+      description:
+        'Path to files to be uploaded to S3 static bucket at app/version/ path.  Do include app/version/ in path if files are already "rooted" under that path locally.',
+    }),
+    defaultFile: flagsParser.string({
+      char: 'i',
+      multiple: false,
+      required: false,
+      description:
+        'Default file to return when the app is loaded via the router without a version (e.g. when app/ is requested).',
+    }),
+    overwrite: flagsParser.boolean({
+      char: 'o',
+      required: false,
+      default: false,
+      description:
+        'Allow overwrite - Warn but do not fail if version exists. Discouraged outside of test envs if cacheable static files have changed.',
+    }),
+    noCache: flagsParser.boolean({
+      required: false,
+      default: false,
+      description: 'Force revalidation of CloudFront and browser caching of static assets',
+    }),
   };
 
   private VersionAndAlias: IVersions;
@@ -81,20 +106,27 @@ export class PublishCommand extends Command {
   async run(): Promise<void> {
     const config = Config.instance;
 
-    const RUNNING_TEXT = ' RUNS ';
-    const RUNNING = chalk.reset.inverse.yellow.bold(RUNNING_TEXT) + ' ';
+    // const RUNNING_TEXT = ' RUNS ';
+    // const RUNNING = chalk.reset.inverse.yellow.bold(RUNNING_TEXT) + ' ';
+    const RUNNING = ''; //chalk.reset.inverse.yellow.bold(RUNNING_TEXT) + ' ';
 
     const { flags: parsedFlags } = this.parse(PublishCommand);
     const appLambdaName = parsedFlags.appLambdaName ?? config.app.lambdaName;
     const appName = parsedFlags.appName ?? config.app.name;
     const deployerLambdaName = parsedFlags.deployerLambdaName ?? config.deployer.lambdaName;
     const semVer = parsedFlags.newVersion ?? config.app.semVer;
+    const staticAssetsPath = parsedFlags.staticAssetsPath ?? config.app.staticAssetsPath;
+    const defaultFile = parsedFlags.defaultFile ?? config.app.defaultFile;
+    const overwrite = parsedFlags.overwrite;
+    const noCache = parsedFlags.noCache;
 
     // Override the config value
     config.deployer.lambdaName = deployerLambdaName;
     config.app.lambdaName = appLambdaName;
     config.app.name = appName;
     config.app.semVer = semVer;
+    config.app.staticAssetsPath = staticAssetsPath;
+    config.app.defaultFile = defaultFile;
 
     // Get the account ID and region from STS
     // TODO: Move this to the right place
@@ -113,11 +145,8 @@ export class PublishCommand extends Command {
 
     this.VersionAndAlias = createVersions(semVer);
 
-    if (config === undefined) {
-      this.error('Failed to load the config file');
-    }
     if (config.app.staticAssetsPath === undefined) {
-      this.error('StaticAssetsPath must be specified in the config file');
+      this.error('staticAssetsPath must be specified');
     }
 
     //
@@ -137,13 +166,20 @@ export class PublishCommand extends Command {
             task.output = `Checking if deployed app/version already exists for ${config.app.name}/${semVer}`;
             ctx.preflightResult = await DeployClient.DeployVersionPreflight({
               config,
+              overwrite,
               output: (message: string) => (task.output = message),
             });
             if (ctx.preflightResult.exists) {
-              task.output = `Warning: App/Version already exists: ${config.app.name}/${config.app.semVer}`;
+              if (!overwrite) {
+                throw new Error(
+                  `App/Version already exists: ${config.app.name}/${config.app.semVer}`,
+                );
+              } else {
+                task.title = `Warning: App/Version already exists: ${config.app.name}/${config.app.semVer}`;
+              }
+            } else {
+              task.title = `App/Version does not exist: ${config.app.name}/${config.app.semVer}`;
             }
-
-            task.title = origTitle;
           },
         },
         {
@@ -220,6 +256,16 @@ export class PublishCommand extends Command {
               },
             });
 
+            // Setup caching on static assets
+            // NoCache - Only used for test deploys, requires browser and CloudFront to refetch every time
+            // Overwrite - Reduces default cache time period from 24 hours to 15 minutes
+            // Default - 24 hours
+            const CacheControl = noCache
+              ? 'max-age=0, must-revalidate, public'
+              : overwrite
+              ? `max-age=${15 * 60}, public`
+              : `max-age=${24 * 60 * 60}, public`;
+
             const pathWithoutAppAndVer = path.join(S3Uploader.TempDir, destinationPrefix);
 
             const tasks: ListrTask<IContext>[] = ctx.files.map((filePath) => ({
@@ -237,7 +283,7 @@ export class PublishCommand extends Command {
                     Key: path.relative(S3Uploader.TempDir, filePath),
                     Body: createReadStream(filePath),
                     ContentType: contentType(path.basename(filePath)) || 'application/octet-stream',
-                    CacheControl: 'max-age=86400; public',
+                    CacheControl,
                   },
                 });
                 await upload.done();
@@ -265,7 +311,7 @@ export class PublishCommand extends Command {
             task.title = RUNNING + origTitle;
 
             // Call Deployer to Create App if Not Exists
-            await DeployClient.CreateApp(config);
+            await DeployClient.CreateApp({ config });
 
             task.title = origTitle;
           },
@@ -277,7 +323,12 @@ export class PublishCommand extends Command {
             task.title = RUNNING + origTitle;
 
             // Call Deployer to Deploy AppName/Version
-            await DeployClient.DeployVersion(config, (message: string) => (task.output = message));
+            await DeployClient.DeployVersion({
+              config,
+              appType: 'lambda',
+              overwrite,
+              output: (message: string) => (task.output = message),
+            });
 
             task.title = origTitle;
           },
@@ -292,9 +343,6 @@ export class PublishCommand extends Command {
 
     try {
       await tasks.run();
-      // this.log(`Published: ${config.app.name}/${config.app.semVer}`);
-    } catch (error) {
-      this.log(`Caught exception: ${error.message}`);
     } finally {
       await S3Uploader.removeTempDirIfExists();
     }

package/src/lib/DeployClient.ts

@@ -19,7 +19,8 @@ export default class DeployClient {
   });
   static readonly _decoder = new TextDecoder('utf-8');
 
-  public static async CreateApp(config: IConfig): Promise<void> {
+  public static async CreateApp(opts: { config: IConfig }): Promise<void> {
+    const { config } = opts;
     const request = {
       type: 'createApp',
       appName: config.app.name,
@@ -54,14 +55,16 @@ export default class DeployClient {
   public static async DeployVersionPreflight(opts: {
     config: IConfig;
     needS3Creds?: boolean;
+    overwrite: boolean;
     output: (message: string) => void;
   }): Promise<IDeployVersionPreflightResult> {
-    const { config, needS3Creds = true, output } = opts;
+    const { config, needS3Creds = true, overwrite, output } = opts;
 
     const request = {
       type: 'deployVersionPreflight',
       appName: config.app.name,
       semVer: config.app.semVer,
+      overwrite,
       needS3Creds,
     } as IDeployVersionPreflightRequest;
     const response = await this._client.send(
@@ -95,16 +98,21 @@ export default class DeployClient {
    * @param config
    * @param task
    */
-  public static async DeployVersion(
-    config: IConfig,
-    output: (message: string) => void,
-  ): Promise<void> {
+  public static async DeployVersion(opts: {
+    config: IConfig;
+    appType: 'lambda' | 'static';
+    overwrite: boolean;
+    output: (message: string) => void;
+  }): Promise<void> {
+    const { config, appType, overwrite, output } = opts;
     const request = {
       type: 'deployVersion',
+      appType,
       appName: config.app.name,
       semVer: config.app.semVer,
       defaultFile: config.app.defaultFile,
-      lambdaARN: config.app.lambdaARN,
+      lambdaARN: appType === 'lambda' ? config.app.lambdaARN : undefined,
+      overwrite,
     } as IDeployVersionRequest;
     const response = await this._client.send(
       new lambda.InvokeCommand({