@pwrdrvr/microapps-publish 0.4.0-alpha.9 → 1.0.2

package/src/config/Config.ts

@@ -1,81 +0,0 @@
-import { url, ipaddress } from 'convict-format-with-validator';
-import * as yaml from 'js-yaml';
-import * as convict from 'ts-convict';
-import { TSConvict } from 'ts-convict';
-import { FilesExist } from '../lib/FilesExist';
-import { ApplicationConfig, IApplicationConfig } from './Application';
-import { DeployerConfig, IDeployerConfig } from './Deployer';
-
-/**
- * Represents a Config
- */
-export interface IConfig {
-  deployer: IDeployerConfig;
-  app: IApplicationConfig;
-}
-
-@convict.Config({
-  // optional default file to load, no errors if it doesn't exist
-  file: 'config.yml', // relative to NODE_PATH or cwd()
-
-  // optional parameter. Defaults to 'strict', can also be 'warn'
-  validationMethod: 'strict',
-
-  // optionally add parsers like yaml or toml
-  parser: {
-    extension: ['yml', 'yaml'],
-    parse: yaml.load,
-  },
-
-  //optional extra formats to use in validation
-  formats: {
-    url,
-    ipaddress,
-  },
-})
-export class Config implements IConfig {
-  public static configFiles(): string[] {
-    const possibleFiles = [
-      './microapps.yaml',
-      './microapps.yml',
-      `./microapps-${Config.envLevel}.yaml`,
-      `./microapps-${Config.envLevel}.yml`,
-    ];
-    return FilesExist.getExistingFilesSync(possibleFiles);
-  }
-
-  private static _instance: IConfig;
-  public static get instance(): IConfig {
-    if (Config._instance === undefined) {
-      const configLoader = new TSConvict<Config>(Config);
-      Config._instance = configLoader.load(Config.configFiles());
-    }
-    return Config._instance;
-  }
-
-  public static get envLevel(): 'dev' | 'qa' | 'prod' | 'local' {
-    const nodeEnv = process.env.NODE_ENV || 'dev';
-    if (nodeEnv.startsWith('prod')) {
-      return 'prod';
-    } else if (nodeEnv === 'qa') {
-      return 'qa';
-    } else if (nodeEnv === 'local') {
-      return 'local';
-    }
-    return 'dev';
-  }
-
-  // ts-convict will use the Typescript type if no format given
-  // @convict.Property({
-  //   doc: 'The name of the thing',
-  //   default: 'Convict',
-  //   env: 'MY_CONFIG_NAME',
-  // })
-  // public name!: string;
-
-  @convict.Property(ApplicationConfig)
-  public app!: IApplicationConfig;
-
-  @convict.Property(DeployerConfig)
-  public deployer!: IDeployerConfig;
-}

package/src/config/Deployer.ts

@@ -1,17 +0,0 @@
-import { Property } from 'ts-convict';
-
-/**
- * Represents a Deployer Config
- */
-export interface IDeployerConfig {
-  lambdaName: string;
-}
-
-export class DeployerConfig implements IDeployerConfig {
-  @Property({
-    doc: 'Name of Deployer Lambda function',
-    default: 'microapps-deployer',
-    env: 'DEPLOYER_LAMBDA_NAME',
-  })
-  public lambdaName!: string;
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { run } from '@oclif/command';

package/src/lib/DeployClient.ts

@@ -1,334 +0,0 @@
-import * as lambda from '@aws-sdk/client-lambda';
-import type {
-  ICreateApplicationRequest,
-  IDeployerResponse,
-  IDeployVersionPreflightRequest,
-  IDeployVersionPreflightResponse,
-  IDeployVersionRequest,
-  IDeleteVersionRequest,
-  ILambdaAliasRequest,
-  ILambdaAliasResponse,
-} from '@pwrdrvr/microapps-deployer-lib';
-import { IConfig } from '../config/Config';
-
-/**
- * Represents a Deploy Version Preflight Result
- */
-export interface IDeployVersionPreflightResult {
-  exists: boolean;
-  response: IDeployVersionPreflightResponse;
-}
-
-export type DeployVersionArgs = Parameters<typeof DeployClient.DeployVersionLite>[0];
-
-export default class DeployClient {
-  static readonly _client = new lambda.LambdaClient({
-    maxAttempts: 8,
-  });
-  static readonly _decoder = new TextDecoder('utf-8');
-
-  /**
-   * Create an application
-   * @param opts
-   */
-  public static async CreateApp(opts: { config: IConfig }): Promise<void> {
-    const { config } = opts;
-    const request: ICreateApplicationRequest = {
-      type: 'createApp',
-      appName: config.app.name,
-      displayName: config.app.name,
-    };
-    const response = await this._client.send(
-      new lambda.InvokeCommand({
-        FunctionName: config.deployer.lambdaName,
-        Payload: Buffer.from(JSON.stringify(request)),
-      }),
-    );
-
-    if (response.$metadata.httpStatusCode === 200 && response.Payload !== undefined) {
-      const dResponse = JSON.parse(
-        Buffer.from(response.Payload).toString('utf-8'),
-      ) as IDeployerResponse;
-      if (!(dResponse.statusCode === 201 || dResponse.statusCode === 200)) {
-        throw new Error(`App create failed: ${JSON.stringify(dResponse)}`);
-      }
-    } else {
-      throw new Error(`App Create - Lambda Invoke Failed: ${JSON.stringify(response)}`);
-    }
-  }
-
-  /**
-   * Delete version
-   * @param config
-   * @param output
-   * @returns
-   */
-  public static async DeleteVersion(opts: {
-    config: IConfig;
-    output: (message: string) => void;
-  }): Promise<IDeployerResponse> {
-    const { config, output } = opts;
-
-    const request: IDeleteVersionRequest = {
-      type: 'deleteVersion',
-      appName: config.app.name,
-      semVer: config.app.semVer,
-    };
-    const response = await this._client.send(
-      new lambda.InvokeCommand({
-        FunctionName: config.deployer.lambdaName,
-        Payload: Buffer.from(JSON.stringify(request)),
-      }),
-    );
-
-    if (response.$metadata.httpStatusCode === 200 && response.Payload !== undefined) {
-      const dResponse = JSON.parse(
-        Buffer.from(response.Payload).toString('utf-8'),
-      ) as IDeployerResponse;
-      if (dResponse.statusCode === 404) {
-        output(`App/Version does not exist: ${config.app.name}/${config.app.semVer}`);
-        return dResponse;
-      } else {
-        output(`App/Version deleted: ${config.app.name}/${config.app.semVer}`);
-        return dResponse;
-      }
-    } else {
-      throw new Error(`Lambda call to DeleteVersion failed: ${JSON.stringify(response)}`);
-    }
-  }
-
-  /**
-   * Check if version exists.
-   * Optionally get S3 creds for static asset upload.
-   * @param config
-   * @param output
-   * @returns
-   */
-  public static async DeployVersionPreflight(opts: {
-    config: IConfig;
-    needS3Creds?: boolean;
-    overwrite: boolean;
-    output: (message: string) => void;
-  }): Promise<IDeployVersionPreflightResult> {
-    const { config, needS3Creds = true, overwrite, output } = opts;
-
-    const request: IDeployVersionPreflightRequest = {
-      type: 'deployVersionPreflight',
-      appName: config.app.name,
-      semVer: config.app.semVer,
-      overwrite,
-      needS3Creds,
-    };
-    const response = await this._client.send(
-      new lambda.InvokeCommand({
-        FunctionName: config.deployer.lambdaName,
-        Payload: Buffer.from(JSON.stringify(request)),
-      }),
-    );
-
-    if (response.$metadata.httpStatusCode === 200 && response.Payload !== undefined) {
-      const dResponse = JSON.parse(
-        Buffer.from(response.Payload).toString('utf-8'),
-      ) as IDeployVersionPreflightResponse;
-      if (dResponse.statusCode === 404) {
-        output(`App/Version does not exist: ${config.app.name}/${config.app.semVer}`);
-        return { exists: false, response: dResponse };
-      } else if (dResponse.statusCode > 299) {
-        // @ts-expect-error remove awsCredentials from response
-        delete dResponse.awsCredentials;
-        output(`DeployVersionPreflight failed: ${JSON.stringify(dResponse)}`);
-        throw new Error('DeployVersionPreflight failed');
-      } else {
-        output(`App/Version exists: ${config.app.name}/${config.app.semVer}`);
-        return { exists: true, response: dResponse };
-      }
-    } else {
-      // @ts-expect-error remove awsCredentials from response
-      delete dResponse.awsCredentials;
-      throw new Error(`Lambda call to DeployVersionPreflight failed: ${JSON.stringify(response)}`);
-    }
-  }
-
-  /**
-   * Create or update Lambda alias for specified Lambda version
-   * @param config
-   * @param output
-   * @returns
-   */
-  public static async LambdaAlias(opts: {
-    appName: string;
-    semVer: string;
-    lambdaVersionArn: string;
-    overwrite: boolean;
-    deployerLambdaName: string;
-    output: (message: string) => void;
-  }): Promise<{ response: ILambdaAliasResponse }> {
-    const { appName, deployerLambdaName, lambdaVersionArn, overwrite, output, semVer } = opts;
-
-    const request: ILambdaAliasRequest = {
-      type: 'lambdaAlias',
-      appName,
-      semVer,
-      lambdaARN: lambdaVersionArn,
-      overwrite,
-    };
-    output(`Creating alias for version ARN: ${lambdaVersionArn}`);
-    const response = await this._client.send(
-      new lambda.InvokeCommand({
-        FunctionName: deployerLambdaName,
-        Payload: Buffer.from(JSON.stringify(request)),
-      }),
-    );
-
-    if (response.$metadata.httpStatusCode === 200 && response.Payload !== undefined) {
-      const dResponse = JSON.parse(
-        Buffer.from(response.Payload).toString('utf-8'),
-      ) as ILambdaAliasResponse;
-      if (dResponse.statusCode > 299) {
-        output(`LambdaAlias failed: ${JSON.stringify(dResponse)}`);
-        throw new Error('LambdaAlias failed');
-      } else if (!dResponse.functionUrl) {
-        output(`LambdaAlias failed to return functionUrl: ${JSON.stringify(dResponse)}`);
-        throw new Error('LambdaAlias failed to return functionUrl');
-      } else if (dResponse.statusCode === 201) {
-        output(`Alias created: ${dResponse.lambdaAliasARN}`);
-        return { response: dResponse };
-      } else {
-        output(`Alias ${dResponse.actionTaken}: ${dResponse.lambdaAliasARN}`);
-        return { response: dResponse };
-      }
-    } else {
-      throw new Error(`Lambda call to LambdaAlias failed: ${JSON.stringify(response)}`);
-    }
-  }
-
-  /**
-   * Copy S3 static assets from staging to live bucket.
-   * Create API Gateway Integration for app (if needed).
-   * Give API Gateway permission to call the Lambda.
-   * Create API Gateway routes for this specific version.
-   * @param config
-   * @param task
-   */
-  public static async DeployVersion(opts: {
-    appName: string;
-    semVer: string;
-    defaultFile?: string;
-    lambdaAliasArn?: string;
-    deployerLambdaName: string;
-    appType: 'lambda' | 'static' | 'lambda-url' | 'url';
-    startupType?: 'iframe' | 'direct';
-    url?: string;
-    overwrite: boolean;
-    output: (message: string) => void;
-  }): Promise<void> {
-    const {
-      appName,
-      semVer,
-      defaultFile,
-      lambdaAliasArn,
-      deployerLambdaName,
-      appType,
-      startupType = 'iframe',
-      url,
-      overwrite,
-      output,
-    } = opts;
-    const request: IDeployVersionRequest = {
-      type: 'deployVersion',
-      appType,
-      startupType,
-      appName,
-      semVer,
-      defaultFile: defaultFile,
-      url,
-      overwrite,
-      ...(['lambda', 'lambda-url'].includes(appType) ? { lambdaARN: lambdaAliasArn } : {}),
-    };
-    const response = await this._client.send(
-      new lambda.InvokeCommand({
-        FunctionName: deployerLambdaName,
-        Payload: Buffer.from(JSON.stringify(request)),
-      }),
-    );
-
-    if (response.$metadata.httpStatusCode === 200 && response.Payload !== undefined) {
-      const dResponse = JSON.parse(
-        Buffer.from(response.Payload).toString('utf-8'),
-      ) as IDeployerResponse;
-      if (dResponse.statusCode === 201) {
-        output(`Deploy succeeded: ${appName}/${semVer}`);
-      } else {
-        output(`Deploy failed with: ${dResponse.statusCode}`);
-        throw new Error(`Lambda call to DeployVersion failed with: ${dResponse.statusCode}`);
-      }
-    } else {
-      throw new Error(`Lambda call to DeployVersion failed: ${JSON.stringify(response)}`);
-    }
-  }
-
-  /**
-   * Copy S3 static assets from staging to live bucket.
-   * Create DB records.
-   * Proxied to parent account if needed.
-   *
-   * @param config
-   * @param task
-   */
-  public static async DeployVersionLite(opts: {
-    appName: string;
-    semVer: string;
-    defaultFile?: string;
-    lambdaAliasArn?: string;
-    deployerLambdaName: string;
-    appType: 'lambda' | 'static' | 'lambda-url' | 'url';
-    startupType?: 'iframe' | 'direct';
-    url?: string;
-    overwrite: boolean;
-    output: (message: string) => void;
-  }): Promise<void> {
-    const {
-      appName,
-      semVer,
-      defaultFile,
-      lambdaAliasArn,
-      deployerLambdaName,
-      appType,
-      startupType = 'iframe',
-      url,
-      overwrite,
-      output,
-    } = opts;
-    const request: IDeployVersionRequest = {
-      type: 'deployVersionLite',
-      appType,
-      startupType,
-      appName,
-      semVer,
-      defaultFile: defaultFile,
-      url,
-      overwrite,
-      ...(['lambda', 'lambda-url'].includes(appType) ? { lambdaARN: lambdaAliasArn } : {}),
-    };
-    const response = await this._client.send(
-      new lambda.InvokeCommand({
-        FunctionName: deployerLambdaName,
-        Payload: Buffer.from(JSON.stringify(request)),
-      }),
-    );
-
-    if (response.$metadata.httpStatusCode === 200 && response.Payload !== undefined) {
-      const dResponse = JSON.parse(
-        Buffer.from(response.Payload).toString('utf-8'),
-      ) as IDeployerResponse;
-      if (dResponse.statusCode === 201) {
-        output(`Deploy succeeded: ${appName}/${semVer}`);
-      } else {
-        output(`Deploy failed with: ${dResponse.statusCode}`);
-        throw new Error(`Lambda call to DeployVersionLite failed with: ${dResponse.statusCode}`);
-      }
-    } else {
-      throw new Error(`Lambda call to DeployVersionLite failed: ${JSON.stringify(response)}`);
-    }
-  }
-}

package/src/lib/FilesExist.ts

@@ -1,25 +0,0 @@
-import { pathExists, pathExistsSync } from 'fs-extra';
-
-export class FilesExist {
-  public static async getExistingFiles(filesToCheck: string[]): Promise<string[]> {
-    const existingFiles: string[] = [];
-    for (const file of filesToCheck) {
-      if (await pathExists(file)) {
-        existingFiles.push(file);
-      }
-    }
-
-    return existingFiles;
-  }
-
-  public static getExistingFilesSync(filesToCheck: string[]): string[] {
-    const existingFiles: string[] = [];
-    for (const file of filesToCheck) {
-      if (pathExistsSync(file)) {
-        existingFiles.push(file);
-      }
-    }
-
-    return existingFiles;
-  }
-}

package/src/lib/S3TransferUtility.spec.ts

@@ -1,15 +0,0 @@
-import { S3TransferUtility } from './S3TransferUtility';
-import path from 'path';
-
-describe('S3TransferUtility', () => {
-  it('collects the files', () => {
-    const testFilesRoot = path.join(__dirname, '../../tests/files');
-    const files = S3TransferUtility.GetFiles(path.join(__dirname, '../../tests/files'));
-
-    expect(files).toBeDefined();
-    expect(files).toHaveLength(6);
-
-    const relativeFiles = files.map((file) => path.relative(testFilesRoot, file));
-    expect(relativeFiles).toMatchSnapshot();
-  });
-});

package/src/lib/S3TransferUtility.ts

@@ -1,113 +0,0 @@
-//
-// From: https://stackoverflow.com/a/65862128/878903
-//
-
-import { createReadStream, readdirSync } from 'fs';
-import * as path from 'path';
-import * as s3 from '@aws-sdk/client-s3';
-import { Upload } from '@aws-sdk/lib-storage';
-import type { IDeployVersionPreflightResponse } from '@pwrdrvr/microapps-deployer-lib';
-import { contentType } from 'mime-types';
-import pMap from 'p-map';
-
-export class S3TransferUtility {
-  /**
-   * @deprecated 2021-11-27
-   *
-   * @param s3Path
-   * @param destPrefixPath
-   * @param bucketName
-   * @param preflightResponse
-   */
-  public static async UploadDir(
-    s3Path: string,
-    destPrefixPath: string,
-    bucketName: string,
-    preflightResponse: IDeployVersionPreflightResponse,
-  ): Promise<void> {
-    // Use temp credentials for S3
-    const s3Client = new s3.S3Client({
-      maxAttempts: 16,
-      credentials: {
-        accessKeyId: preflightResponse.awsCredentials.accessKeyId,
-        secretAccessKey: preflightResponse.awsCredentials.secretAccessKey,
-        sessionToken: preflightResponse.awsCredentials.sessionToken,
-      },
-    });
-
-    // console.log('Uploading files to S3');
-    const files = S3TransferUtility.GetFiles(s3Path);
-    // const pathWithoutAppAndVer = path.join(s3Path, destPrefixPath);
-    // for (const filePath of files) {
-    //   const relFilePath = path.relative(pathWithoutAppAndVer, filePath);
-    //   console.log(`  ${relFilePath}`);
-    // }
-
-    // Use p-map to limit upload parallelism
-    await pMap(
-      files,
-      async (filePath) => {
-        // Use 4 multi-part parallel uploads for items > 5 MB
-        const upload = new Upload({
-          client: s3Client,
-          leavePartsOnError: false,
-          params: {
-            Bucket: bucketName,
-            Key: path.relative(s3Path, filePath),
-            Body: createReadStream(filePath),
-            ContentType: contentType(path.basename(filePath)) || 'application/octet-stream',
-            CacheControl: 'max-age=86400; public',
-          },
-        });
-        await upload.done();
-      },
-      {
-        concurrency: 10,
-      },
-      // await s3.send(
-      //   new S3.PutObjectCommand({
-      //     Key: path.relative(s3Path, filePath),
-      //     Bucket: bucketName,
-      //     Body: createReadStream(filePath),
-      //     ContentType: contentType(path.basename(filePath)) || 'application/octet-stream',
-      //     CacheControl: 'max-age=86400; public',
-      //   }),
-    );
-  }
-  // Recursive getFiles from
-  // https://stackoverflow.com/a/45130990/831465
-
-  /**
-   * Resursively enumerate the files to be uploaded
-   * @param dir
-   * @returns
-   */
-  public static GetFiles(dir: string): string[] {
-    const dirents = readdirSync(dir, { withFileTypes: true });
-    const files: string[] = [];
-    const toScan = dirents.map((dirent) => ({
-      path: path.resolve(dir, dirent.name),
-      isDirectory: dirent.isDirectory(),
-    }));
-
-    // Iteratively collect all the files in the directories
-    // Do not use function call recursion
-    while (toScan.length > 0) {
-      const dirOrFile = toScan.pop();
-
-      if (dirOrFile.isDirectory) {
-        const direntsChild = readdirSync(dirOrFile.path, { withFileTypes: true });
-        const toScanChild = direntsChild.map((dirent) => ({
-          path: path.resolve(dirOrFile.path, dirent.name),
-          isDirectory: dirent.isDirectory(),
-        }));
-        Array.prototype.push.apply(toScan, toScanChild);
-      } else {
-        files.push(dirOrFile.path);
-      }
-    }
-
-    // Reverse the array so that the files are in the same order as the original
-    return files.reverse();
-  }
-}

package/src/lib/S3Uploader.ts

@@ -1,94 +0,0 @@
-import * as path from 'path';
-import type { IDeployVersionPreflightResponse } from '@pwrdrvr/microapps-deployer-lib';
-import * as fs from 'fs-extra';
-import { IConfig } from '../config/Config';
-import { S3TransferUtility } from './S3TransferUtility';
-
-export class S3Uploader {
-  /**
-   * Copy files to local upload directory
-   * @param config
-   * @param s3UploadPath
-   * @param preflightResponse
-   */
-  public static async CopyToUploadDir(config: IConfig, s3UploadPath: string): Promise<void> {
-    const { destinationPrefix } = S3Uploader.ParseUploadPath(s3UploadPath);
-
-    // Make a local root dir for the upload
-    const tempUploadPath = path.join(S3Uploader._tempDir, destinationPrefix);
-    await S3Uploader.removeTempDirIfExists();
-    await fs.mkdir(tempUploadPath, { recursive: true });
-
-    // Copy the files in the source dir to the root dir
-    // Note: It would be faster to move the files, then move them back
-    await fs.copy(config.app.staticAssetsPath, tempUploadPath);
-  }
-
-  public static ParseUploadPath(s3UploadPath: string): {
-    bucketName: string;
-    destinationPrefix: string;
-  } {
-    // Parse the S3 Source URI
-    const uri = new URL(s3UploadPath);
-    const bucketName = uri.host;
-    const destinationPrefix = uri.pathname.length >= 1 ? uri.pathname.slice(1) : '';
-
-    return { bucketName, destinationPrefix };
-  }
-
-  /**
-   * Upload files to S3
-   * @deprecated 2021-11-27
-   * @param config
-   * @param s3UploadPath
-   * @param preflightResponse
-   */
-  public static async Upload(
-    config: IConfig,
-    s3UploadPath: string,
-    preflightResponse: IDeployVersionPreflightResponse,
-  ): Promise<void> {
-    try {
-      const { destinationPrefix, bucketName } = S3Uploader.ParseUploadPath(s3UploadPath);
-
-      // Make a local root dir for the upload
-      const tempUploadPath = path.join(S3Uploader._tempDir, destinationPrefix);
-      await S3Uploader.removeTempDirIfExists();
-      await fs.mkdir(tempUploadPath, { recursive: true });
-
-      // Copy the files in the source dir to the root dir
-      // Note: It would be faster to move the files, then move them back
-      // FIXME: Use p-map for controlled parallelism
-      await fs.copy(config.app.staticAssetsPath, tempUploadPath);
-
-      // Do the upload
-      await S3TransferUtility.UploadDir(
-        this._tempDir,
-        destinationPrefix,
-        bucketName,
-        preflightResponse,
-      );
-    } finally {
-      // Delete the directory, now that it's uploaded or if we failed
-      await S3Uploader.removeTempDirIfExists();
-    }
-  }
-
-  public static async removeTempDirIfExists(): Promise<void> {
-    try {
-      const stats = await fs.stat(S3Uploader._tempDir);
-      if (stats.isDirectory()) {
-        await fs.rm(S3Uploader._tempDir, { recursive: true });
-      }
-    } catch {
-      // Don't care
-      // fs.stat will throw if file/dir does not exist
-      // Since we want the directory deleted this is ok
-    }
-  }
-
-  private static readonly _tempDir = './deploytool-temp';
-  public static get TempDir(): string {
-    return S3Uploader._tempDir;
-  }
-}