@travetto/pack 3.0.0-rc.7 → 3.0.0-rc.9

package/support/bin/types.ts

@@ -1,19 +1,70 @@
-export type CommonConfig = {
-  name?: string;
-  file?: string;
+import { ListOptionConfig, OptionConfig } from '@travetto/cli';
+
+export type CommonPackConfig = {
   workspace: string;
-  active?: boolean;
-  postProcess?: { [key: string]: (<T extends CommonConfig>(cfg: T) => Promise<void>) }[];
-  preProcess?: { [key: string]: (<T extends CommonConfig>(cfg: T) => Promise<void>) }[];
+  output: string;
+  clean: boolean;
+  ejectFile: string;
+  module: string;
+
+  // Bundle
+  entryPoint: string;
+  entryCommand: string;
+  entryArguments: string[];
+  minify: boolean;
+  sourcemap: boolean;
+  includeSources: boolean;
+};
+
+export type CommonPackOptions = {
+  workspace: OptionConfig<string>;
+  output: OptionConfig<string>;
+  clean: OptionConfig<boolean>;
+  ejectFile: OptionConfig<string>;
+
+  // Bundle
+  entryPoint: OptionConfig<string>;
+  entryCommand: OptionConfig<string>;
+  minify: OptionConfig<boolean>;
+  sourcemap: OptionConfig<boolean>;
+  includeSources: OptionConfig<boolean>;
+};
+
+export type DockerPackConfig = {
+  dockerFactory: string;
+  dockerImage: string;
+  dockerName: string;
+  dockerTag: string[];
+  dockerPort: string[];
+  dockerPush: boolean;
+  dockerRegistry: string;
+} & CommonPackConfig;
+
+export type DockerPackOptions = {
+  dockerFactory: OptionConfig<string>;
+  dockerImage: OptionConfig<string>;
+  dockerName: OptionConfig<string>;
+  dockerTag: ListOptionConfig<string>;
+  dockerPort: ListOptionConfig<string>;
+  dockerPush: OptionConfig<boolean>;
+  dockerRegistry: OptionConfig<string>;
+} & CommonPackOptions;
+
+export type ShellCommandImpl = {
+  var(name: string): string;
+  createFile(file: string, text: string[], mode?: string): string[][];
+  scriptOpen(): string[];
+  chdirScript(): string[];
+  callCommandWithAllArgs(cmd: string, ...args: string[]): string[];
+  copy(src: string, dest: string): string[];
+  copyRecursive(src: string, dest: string): string[];
+  rmRecursive(dest: string): string[];
+  mkdir(dest: string): string[];
+  export(key: string, value: string): string[];
+  chdir(dest: string): string[];
+  comment(message: string): string[];
+  zip(output: string): string[];
 };
 
-export type PackOperation<T extends CommonConfig, K extends string> = {
-  key: K;
-  title: string;
-  defaults?: Partial<T>;
-  overrides?: Partial<T>;
-  extend?(src: Partial<T>, dest: Partial<T>): Partial<T>;
-  context(cfg: T): Promise<string> | string;
-  exec(cfg: T): AsyncGenerator<string>;
-  buildConfig(configs: Partial<T>[]): T;
-};
+export type DockerPackFactory = (cfg: DockerPackConfig) => (string | Promise<string>);
+export type DockerPackFactoryModule = { factory: DockerPackFactory };

package/support/bin/util.ts

@@ -1,162 +1,19 @@
 import fs from 'fs/promises';
 
-import glob from 'picomatch';
-
 import { path, RootIndex } from '@travetto/manifest';
-import { cliTpl } from '@travetto/cli';
 import { ExecUtil } from '@travetto/base';
-import { stripAnsiCodes } from '@travetto/terminal';
 
-import { CommonConfig, PackOperation } from './types';
+import { ActiveShellCommand } from './shell';
 
-/**
- * Shared packing utils
- */
 export class PackUtil {
-
-  static #modes: Partial<CommonConfig>[];
-
-  /**
-   * Build configuration object for an operation with a set of configs
-   */
-  static buildConfig<T extends CommonConfig>(
-    op: { defaults?: Partial<T>, overrides?: Partial<T>, extend?(src: Partial<T>, dest: Partial<T>): Partial<T> },
-    configs: Partial<T>[]
-  ): T {
-    const inputs = [
-      op.defaults! ?? {},
-      ...configs,
-      op.overrides! ?? {}
-    ].filter(x => Object.keys(x).length > 0);
-
-    const res = inputs.reduce((out: Partial<T>, config: Partial<T>): Partial<T> => {
-      const final = {
-        active: config.active ?? out.active,
-        workspace: config.workspace ?? out.workspace,
-        preProcess: [...(config.preProcess! ?? []), ...(out.preProcess ?? [])],
-        postProcess: [...(config.postProcess! ?? []), ...(out.postProcess ?? [])],
-        ...op.extend?.(config, out)
-      };
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return final as Partial<T>;
-    }, {});
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return res as T;
-  }
-
-  /**
-   * Find pack modes with associated metadata
-   */
-  static async modeList(): Promise<Partial<CommonConfig>[]> {
-    if (!this.#modes) {
-      this.#modes = await Promise.all(
-        RootIndex.findSupport({ filter: f => /\/pack[.].*[.]/.test(f) })
-          .map(async (x) => {
-            const req: Partial<CommonConfig> = (await import(x.output)).config;
-            req.file = x.import.replace(/^node_modules\//, '');
-            return req;
-          })
-      );
-    }
-    return this.#modes;
-  }
-
-
-  /**
-   * Build file include/exclude lists/checker
-   */
-  static excludeChecker(files: string[], base: string): (file: string) => boolean {
-    const all = files.map(x => {
-      const negate = x.startsWith('!') || x.startsWith('^');
-      x = negate ? x.substring(1) : x;
-      x = x.replace(/^[.][/]/g, `${base}/`);
-      const match: (f: string) => boolean = glob(x, { nocase: true, dot: true, basename: true, contains: true, cwd: base });
-      Object.defineProperty(match, 'source', { value: x });
-      return [match, negate] as const;
-    });
-
-    return (f: string): boolean => {
-      let exclude = undefined;
-      f = path.resolve(base, f);
-      for (const [match, n] of all) {
-        if ((n || exclude === undefined) && match(f)) {
-          if (n) { // Fast exit if negating
-            return false;
-          }
-          exclude = match;
-        }
-      }
-      return !!exclude;
-    };
-  }
-
-  /**
-   * Update .env.js with new env data
-   */
-  static async writeEnvJs(workspace: string, env: Record<string, string | undefined>): Promise<void> {
-    const out = path.resolve(workspace, '.env.js');
-    let src = '';
-    if (!!(await fs.stat(out).catch(() => { }))) {
-      src = await fs.readFile(out, 'utf8');
-    }
-    const lines = Object.entries(env).map(([k, v]) => v ? `process.env['${k}'] = \`${v.replace(/`/g, '\\`')}\`;` : '');
-    const content = `${src}\n${lines.join('\n')}`;
-    await fs.writeFile(out, content, { encoding: 'utf8' });
-  }
-
   /**
-   * Run operation with logging
+   * Generate env.js
    */
-  static async runOperation<T extends CommonConfig>(op: PackOperation<T, string>, cfg: T, indent = 0): Promise<void> {
-    const spacer = ' '.repeat(indent);
-    const ctx = await op.context(cfg);
-    const title = cliTpl`${{ title: op.title }} ${ctx}`;
-    const width = Math.max(stripAnsiCodes(title).length, 50); // eslint-disable-line
-
-    let i = 0;
-    function stdout(msg?: string): void {
-      if (i++ > 0) {
-        process.stdout.write(cliTpl`${spacer}${{ param: 'done' }}\n`);
-      }
-      if (msg) {
-        process.stdout.write(cliTpl`${spacer}${{ output: '᳁' }} ${{ path: msg.padEnd(width - 15) }} ... `);
-      }
-    }
-
-    async function runPhase(phase: 'preProcess' | 'postProcess'): Promise<void> {
-      for (const el of cfg[phase] ?? []) {
-        const [name, fn] = Object.entries(el)[0];
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        await stdout(name as string);
-        await fn(cfg);
-      }
-    }
-
-    let message: string | undefined;
-
-    process.stdout.write(`${spacer}${title}\n`);
-    process.stdout.write(`${spacer}${'-'.repeat(width)}\n`);
-
-    await runPhase('preProcess');
-
-    for await (const msg of op.exec(cfg)) {
-      if (msg.includes('Success')) { // We are done
-        message = msg;
-        break;
-      } else {
-        stdout(msg);
-      }
-    }
-
-    await runPhase('postProcess');
-
-    // Wrap up
-    stdout();
-
-    if (message !== undefined) {
-      process.stdout.write(`${spacer}${'-'.repeat(width)}\n`);
-      process.stdout.write(`${spacer}${message}\n`);
-    }
+  static buildEnvJS(env: Record<string, string | number | boolean | undefined>): string[] {
+    const entries = Object.entries(env)
+      .filter(([k, v]) => (v !== undefined))
+      .map(([k, v]) => [k, `${v}`]);
+    return entries.map(([k, v]) => `process.env.${k} = '${v}';`);
   }
 
   /**
@@ -166,13 +23,41 @@ export class PackUtil {
    * @param ignore Should errors be ignored
    */
   static async copyRecursive(src: string, dest: string, ignore = false): Promise<void> {
-    const [cmd, args] = process.platform === 'win32' ?
-      ['xcopy', ['/y', '/h', '/s', path.toNative(src), path.toNative(dest)]] :
-      ['cp', ['-r', '-p', src, dest]];
-
+    const [cmd, ...args] = ActiveShellCommand.copyRecursive(src, dest);
     const res = await ExecUtil.spawn(cmd, args, { catchAsResult: true }).result;
     if (res.code && !ignore) {
       throw new Error(`Failed to copy ${src} to ${dest}`);
     }
   }
+
+  /**
+   * Finalize eject output
+   */
+  static async writeEjectOutput(
+    workspace: string,
+    module: string,
+    output: string[],
+    file: string
+  ): Promise<void> {
+    const vars = {
+      DIST: workspace,
+      TRV_OUT: RootIndex.outputRoot,
+      ROOT: path.cwd(),
+      MOD: module
+    };
+
+    const content = [
+      ActiveShellCommand.scriptOpen(),
+      ...Object.entries(vars).map(([k, v]) => ActiveShellCommand.export(k, v).join(' ')),
+      Object.entries(vars).reduce((text, [k, v]) => text.replaceAll(v, ActiveShellCommand.var(k)), output.join('\n')),
+      '', ''
+    ].join('\n');
+
+    if (file === '-' || file === '/dev/stdout') {
+      console.log!(content);
+    } else {
+      await fs.mkdir(path.dirname(file), { recursive: true });
+      await fs.writeFile(file, content, 'utf8');
+    }
+  }
 }

package/support/cli.pack.ts

@@ -1,10 +1,14 @@
-import { BaseOptions, BasePackCommand } from './cli.pack-base';
-import { Pack, AllConfig } from './bin/pack';
+import { BasePackCommand } from './pack.base';
+import { CommonPackConfig, CommonPackOptions } from './bin/types';
 
-export class PackCommand extends BasePackCommand<BaseOptions, AllConfig, ''> {
-  operation = Pack;
+/**
+ * Standard pack support
+ */
+export class PackCommand extends BasePackCommand<CommonPackOptions, CommonPackConfig> {
 
-  getOptions(): BaseOptions {
-    return this.commonOptions();
+  name = 'pack';
+
+  getOptions(): CommonPackOptions {
+    return this.getCommonOptions();
   }
 }

package/support/cli.pack_docker.ts

@@ -1,29 +1,36 @@
-import { OptionConfig, ListOptionConfig } from '@travetto/cli';
+import { DockerPackConfig, DockerPackOptions } from './bin/types';
+import { DockerPackOperation } from './bin/docker-operation';
+import { BasePackCommand, PackOperationShape } from './pack.base';
 
-import { BaseOptions, BasePackCommand } from './cli.pack-base';
-import { Docker, DockerConfig } from './bin/docker';
 
-type Options = BaseOptions & {
-  image: OptionConfig<string>;
-  name: OptionConfig<string>;
-  tag: ListOptionConfig<string>;
-  port: ListOptionConfig<string>;
-  push: OptionConfig<boolean>;
-  registry: OptionConfig<string>;
-};
+/**
+ * Standard docker support for pack
+ */
+export class PackDockerCommand extends BasePackCommand<DockerPackOptions, DockerPackConfig> {
 
-export class PackDockerCommand extends BasePackCommand<Options, DockerConfig, 'docker'> {
-  operation = Docker;
+  name = 'pack:docker';
 
-  getOptions(): Options {
+  getOptions(): DockerPackOptions {
+    const opts = this.getCommonOptions();
     return {
-      ...this.commonOptions(),
-      image: this.option({ desc: 'Docker Image to extend' }),
-      name: this.option({ desc: 'Image Name' }),
-      tag: this.listOption({ desc: 'Image Tag' }),
-      port: this.listOption({ desc: 'Image Port' }),
-      push: this.boolOption({ short: 'x', desc: 'Push Tags' }),
-      registry: this.option({ desc: 'Registry' })
+      ...opts,
+      dockerFactory: this.option({ short: 'df', desc: 'Docker Factory source', def: '@travetto/pack/support/pack.dockerfile' }),
+      dockerImage: this.option({ short: 'di', desc: 'Docker Image to extend', def: 'node:18-alpine3.16' }),
+      dockerName: this.option({ short: 'dn', desc: 'Docker Image Name', def: this.monoRoot ? '<module>' : this.getSimpleModuleName() }),
+      dockerTag: this.listOption({ short: 'dt', desc: 'Docker Image Tag', def: ['latest'] }),
+      dockerPort: this.listOption({ short: 'dp', desc: 'Docker Image Port' }),
+      dockerPush: this.boolOption({ short: 'dx', desc: 'Docker Push Tags' }),
+      dockerRegistry: this.option({ short: 'dr', desc: 'Docker Registry' })
     };
   }
+
+  getOperations(): PackOperationShape<DockerPackConfig>[] {
+    return [
+      ...super.getOperations(),
+      DockerPackOperation.writeDockerFile,
+      DockerPackOperation.pullDockerBaseImage,
+      DockerPackOperation.buildDockerContainer,
+      DockerPackOperation.pushDockerContainer
+    ];
+  }
 }

package/support/cli.pack_zip.ts

@@ -1,19 +1,24 @@
-import { OptionConfig } from '@travetto/cli';
+import { CommonPackConfig, CommonPackOptions } from './bin/types';
+import { PackOperation } from './bin/operation';
+import { BasePackCommand, PackOperationShape } from './pack.base';
 
-import { BaseOptions, BasePackCommand } from './cli.pack-base';
-import { Zip, ZipConfig } from './bin/zip';
+/**
+ * Standard zip support for pack
+ */
+export class PackZipCommand extends BasePackCommand<CommonPackOptions, CommonPackConfig> {
 
-type Options = BaseOptions & {
-  output: OptionConfig<string>;
-};
+  name = 'pack:zip';
 
-export class PackZipCommand extends BasePackCommand<Options, ZipConfig, 'zip'> {
-  operation = Zip;
+  getOptions(): CommonPackOptions {
+    const opts = this.getCommonOptions();
+    opts.output.def = this.monoRoot ? '<module>.zip' : `${this.getSimpleModuleName()}.zip`;
+    return opts;
+  }
 
-  getOptions(): Options {
-    return {
-      ...this.commonOptions(),
-      output: this.option({ desc: 'Output File' })
-    };
+  getOperations(): PackOperationShape<CommonPackConfig>[] {
+    return [
+      ...super.getOperations(),
+      PackOperation.compress
+    ];
   }
 }

package/support/pack.base.ts

@@ -0,0 +1,138 @@
+import os from 'os';
+
+import { CliCommand, cliTpl } from '@travetto/cli';
+import { path, RootIndex } from '@travetto/manifest';
+import { TimeUtil } from '@travetto/base';
+import { GlobalTerminal } from '@travetto/terminal';
+
+import { CommonPackConfig, CommonPackOptions } from './bin/types';
+import { PackOperation } from './bin/operation';
+import { PackUtil } from './bin/util';
+
+export type PackOperationShape<T extends CommonPackConfig> = ((config: T) => AsyncIterable<string[]>);
+
+export abstract class BasePackCommand<T extends CommonPackOptions, S extends CommonPackConfig> extends CliCommand<{}> {
+
+  get monoRoot(): boolean {
+    return !!RootIndex.manifest.monoRepo && path.cwd() === RootIndex.manifest.workspacePath;
+  }
+
+  getArgs(): string | undefined {
+    return this.monoRoot ? '<module> [args...]' : '[args...]';
+  }
+
+  getCommonOptions(): CommonPackOptions {
+    return {
+      workspace: this.option({ short: 'w', desc: 'Workspace for building' }),
+      clean: this.boolOption({ short: 'c', desc: 'Clean workspace', def: true }),
+      output: this.option({ short: 'o', desc: 'Output Location' }),
+
+      entryPoint: this.option({ short: 'e', desc: 'Entry point', def: 'node_modules/@travetto/cli/support/cli.js' }),
+      entryCommand: this.option({ short: 'ec', desc: 'Entry command' }),
+      minify: this.boolOption({ short: 'm', desc: 'Minify output', def: true }),
+      sourcemap: this.boolOption({ short: 'sm', desc: 'Bundle source maps' }),
+      includeSources: this.boolOption({ short: 'is', desc: 'Include source with source maps' }),
+      ejectFile: this.option({ short: 'x', desc: 'Eject commands to file' }),
+    };
+  }
+
+  abstract getOptions(): T;
+
+  get cmd(): S {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return super.cmd as S;
+  }
+
+  getSimpleModuleName(): string {
+    return RootIndex.mainPackage.name.replace(/[\/]/, '_').replace(/@/, '');
+  }
+
+  getOperations(): PackOperationShape<S>[] {
+    const ops: ((config: S) => AsyncIterable<string[]>)[] = [];
+
+    if (this.cmd.clean) {
+      ops.push(PackOperation.clean);
+    }
+
+    ops.push(
+      PackOperation.writeEnv,
+      PackOperation.writePackageJson,
+      PackOperation.writeEntryScript,
+      PackOperation.copyResources,
+      PackOperation.primeAppCache,
+      PackOperation.writeManifest,
+      PackOperation.bundle,
+    );
+
+    return ops;
+  }
+
+  getModule(moduleName: string): string {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    let module = this.monoRoot ? moduleName : RootIndex.mainModule.name;
+    module = RootIndex.getModuleByFolder(module)?.name ?? module;
+
+    // Reinitialize for module
+    if (this.monoRoot) {
+      RootIndex.reinitForModule(module);
+    }
+
+    return module;
+  }
+
+  async buildConfig(): Promise<S> {
+    this.cmd.workspace ??= path.resolve(os.tmpdir(), RootIndex.mainModule.sourcePath.replace(/[\/\\: ]/g, '_'));
+    this.cmd.entryCommand ??= path.basename(this.cmd.entryPoint).replace(/[.][tj]s$/, '');
+    this.cmd.module = RootIndex.mainModule.name;
+    return this.cmd;
+  }
+
+  async action(module: string, args: string[]): Promise<void> {
+    const start = Date.now();
+    if (!module && this.monoRoot) {
+      this.showHelp(new Error('The module needs to specified when running from a monorepo root'));
+    }
+
+    module = this.getModule(module);
+
+    const cfg = await this.buildConfig();
+    cfg.entryArguments = Array.isArray(args) ? args : [];
+
+    for (const k in this.cmd) {
+      if (Object.hasOwn(this.cmd, k)) {
+        const v = this.cmd[k];
+        if (typeof v === 'string' && /<module>/.test(v)) {
+          // @ts-expect-error
+          this.cmd[k] = v.replace(/<module>/g, this.getSimpleModuleName());
+        }
+      }
+    }
+
+    // Resolve all files to absolute paths
+    if (this.cmd.output) {
+      this.cmd.output = path.resolve(this.cmd.output);
+    }
+    if (this.cmd.ejectFile) {
+      this.cmd.ejectFile = path.resolve(this.cmd.ejectFile);
+    }
+    this.cmd.workspace = path.resolve(this.cmd.workspace);
+
+    const stream = PackOperation.runOperations(cfg, this.getOperations());
+
+    // Eject to file
+    if (this.cmd.ejectFile) {
+      const output: string[] = [];
+      for await (const line of stream) {
+        output.push(line);
+      }
+      await PackUtil.writeEjectOutput(this.cmd.workspace, cfg.module, output, this.cmd.ejectFile);
+    } else {
+      await GlobalTerminal.streamLinesWithWaiting(stream, { initialDelay: 0, cycleDelay: 100, end: true });
+      let msg = cliTpl`${{ success: 'Success' }} (${{ identifier: TimeUtil.prettyDeltaSinceTime(start) }}) ${{ subtitle: 'module' }}=${{ param: this.cmd.module }}`;
+      if (this.cmd.output) {
+        msg = cliTpl`${msg} ${{ subtitle: 'output' }}=${{ path: this.cmd.output }}`;
+      }
+      await GlobalTerminal.writeLines(msg);
+    }
+  }
+}

package/support/pack.dockerfile.ts

@@ -0,0 +1,9 @@
+import { DockerPackFactory } from './bin/types';
+
+export const factory: DockerPackFactory = cfg => `
+FROM ${cfg.dockerImage}
+WORKDIR /app
+COPY . .
+${cfg.dockerPort.map(port => `EXPOSE ${port}`).join('\n')}
+ENTRYPOINT ["/app/${cfg.entryCommand}.sh"]
+`;

package/support/bin/assemble/operation.ts

@@ -1,59 +0,0 @@
-import fs from 'fs/promises';
-
-import { path } from '@travetto/manifest';
-import { cliTpl } from '@travetto/cli';
-import { Env } from '@travetto/base';
-
-import { PackUtil } from '../util';
-import { CommonConfig, PackOperation } from '../types';
-import { AssembleUtil } from './util';
-export interface AssembleConfig extends CommonConfig {
-  keepSource: boolean;
-  readonly: boolean;
-  add: Record<string, string>[];
-  exclude: string[];
-  env: Record<string, string | undefined>;
-}
-
-/**
- * Utils for packing source code and minimizing space usage
- */
-export const Assemble: PackOperation<AssembleConfig, 'assemble'> = {
-  key: 'assemble',
-  title: 'Assembling',
-  context(cfg: AssembleConfig) {
-    return `[readonly=${cfg.readonly},source=${cfg.keepSource}]`;
-  },
-  overrides: {
-    keepSource: Env.getBoolean('PACK_ASSEMBLE_KEEP_SOURCE'),
-    readonly: Env.getBoolean('PACK_ASSEMBLE_READONLY')
-  },
-  extend(src: Partial<AssembleConfig>, dest: Partial<AssembleConfig>): Partial<AssembleConfig> {
-    return {
-      keepSource: src.keepSource ?? dest.keepSource,
-      readonly: src.readonly ?? dest.readonly,
-      add: [...(src.add ?? []), ...(dest.add ?? [])],
-      exclude: [...(src.exclude ?? []), ...(dest.exclude ?? [])],
-      env: { ...(src.env ?? {}), ...(dest.env ?? {}) },
-    };
-  },
-  buildConfig(configs: Partial<AssembleConfig>[]): AssembleConfig {
-    return PackUtil.buildConfig(this, configs);
-  },
-  /**
-   * Assemble the project into a workspace directory, optimized for space and runtime
-   */
-  async * exec({ workspace, add, exclude, env, keepSource }: AssembleConfig) {
-    const ws = path.resolve(workspace!);
-    yield 'Cleaning Workspace'; {
-      await fs.rm(ws, { recursive: true, force: true }).catch(() => { });
-      await fs.mkdir(ws);
-    }
-    yield 'Create Entrypoint'; await AssembleUtil.copyEntryPoint(ws);
-    yield 'Copying Prod Dependencies'; await AssembleUtil.copyProdDependencies(ws, keepSource);
-    yield 'Excluding Files'; await AssembleUtil.excludeFiles(ws, exclude);
-    yield 'Copying Added Content'; await AssembleUtil.copyAddedContent(ws, add);
-    yield 'Removing Empty Folders'; await AssembleUtil.removeEmptyFolders(ws);
-    yield cliTpl`${{ success: 'Successfully' }} assembled project at ${{ path: workspace }}`;
-  }
-};