@travetto/pack 3.0.0 → 3.0.1-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/pack",
-  "version": "3.0.0",
+  "version": "3.0.1-rc.1",
   "description": "Code packing utilities",
   "keywords": [
     "travetto",
@@ -28,12 +28,12 @@
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-terser": "^0.4.0",
-    "@travetto/base": "^3.0.0",
+    "@travetto/base": "^3.0.1-rc.1",
     "rollup": "^3.17.2",
     "rollup-plugin-sourcemaps": "^0.6.3"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0"
+    "@travetto/cli": "^3.0.1-rc.1"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/support/bin/docker-operation.ts

@@ -6,6 +6,7 @@ import { cliTpl } from '@travetto/cli';
 
 import { ActiveShellCommand } from './shell';
 import { DockerPackConfig, DockerPackFactoryModule } from './types';
+import { PackOperation } from './operation';
 
 export class DockerPackOperation {
 
@@ -18,7 +19,7 @@ export class DockerPackOperation {
    */
   static async* writeDockerFile(cfg: DockerPackConfig): AsyncIterable<string[]> {
     const dockerFile = path.resolve(cfg.workspace, 'Dockerfile');
-    const title = cliTpl`${{ title: 'Generating Docker File' }} ${{ path: dockerFile }} ${{ param: cfg.dockerFactory }}`;
+
     const factory = RootIndex.getFromImport(cfg.dockerFactory);
     if (!factory) {
       throw new Error(`Unable to resolve docker factory at ${cfg.dockerFactory}`);
@@ -26,11 +27,11 @@ export class DockerPackOperation {
     const mod: DockerPackFactoryModule = await import(factory.import);
     const content = (await mod.factory(cfg)).trim();
 
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Generating Docker File' }} ${{ path: dockerFile }} ${{ param: cfg.dockerFactory }}`);
+
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield* ActiveShellCommand.createFile(dockerFile, content.split(/\n/));
     } else {
-      yield [title];
       await fs.writeFile(dockerFile, content, 'utf8');
     }
   }
@@ -39,15 +40,13 @@ export class DockerPackOperation {
    * Pull Docker Base Image
    */
   static async* pullDockerBaseImage(cfg: DockerPackConfig): AsyncIterable<string[]> {
-    const title = cliTpl`${{ title: 'Pulling Docker Base Image' }} ${{ param: cfg.dockerImage }}`;
-
     const command = ['docker', 'pull', cfg.dockerImage];
 
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Pulling Docker Base Image' }} ${{ param: cfg.dockerImage }}`);
+
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield command;
     } else {
-      yield [title];
       await ExecUtil.spawn(command[0], command.slice(1), {}).result;
     }
   }
@@ -56,16 +55,15 @@ export class DockerPackOperation {
    * Building Docker Container
    */
   static async* buildDockerContainer(cfg: DockerPackConfig): AsyncIterable<string[]> {
-    const title = cliTpl`${{ title: 'Building Docker Container' }} ${{ param: cfg.dockerTag?.join(',') }}`;
     const cmd = ['docker', 'build', ...DockerPackOperation.getDockerTags(cfg).flatMap(x => ['-t', x]), '.'];
 
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Building Docker Container' }} ${{ param: cfg.dockerTag?.join(',') }}`);
+
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield ActiveShellCommand.chdir(cfg.workspace);
       yield cmd;
       yield ActiveShellCommand.chdir(path.cwd());
     } else {
-      yield [title];
       await ExecUtil.spawn(cmd[0], cmd.slice(1), { cwd: cfg.workspace, stdio: [0, 'pipe', 2] }).result;
     }
   }
@@ -78,16 +76,15 @@ export class DockerPackOperation {
       return;
     }
     const tags = DockerPackOperation.getDockerTags(cfg);
-    const title = cliTpl`${{ title: 'Push Container to registry' }} ${{ param: cfg.dockerRegistry }}`;
     const cmd = ['docker', 'image', 'push'];
 
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Push Container to registry' }} ${{ param: cfg.dockerRegistry }}`);
+
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       for (const tag of tags) {
         yield [...cmd, tag];
       }
     } else {
-      yield [title];
       for (const tag of tags) {
         await ExecUtil.spawn(cmd[0], [...cmd.slice(1), tag], { stdio: [0, 'pipe', 2] }).result;
       }

package/support/bin/operation.ts

@@ -14,6 +14,15 @@ async function writeRawFile(file: string, contents: string, mode?: string): Prom
 
 export class PackOperation {
 
+  static async * title(cfg: CommonPackConfig, title: string): AsyncIterable<string[]> {
+    if (cfg.ejectFile) {
+      yield ActiveShellCommand.comment(title);
+      yield ActiveShellCommand.echo(title);
+    } else {
+      yield [title];
+    }
+  }
+
   /**
    * Clean out pack workspace, removing all content
    */
@@ -22,17 +31,15 @@ export class PackOperation {
       return;
     }
 
-    const title = cliTpl`${{ title: 'Cleaning Output' }} ${{ path: cfg.workspace }}`;
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Cleaning Output' }} ${{ path: cfg.workspace }}`);
 
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield ActiveShellCommand.rmRecursive(cfg.workspace);
       if (cfg.output) {
         yield ActiveShellCommand.rmRecursive(cfg.output);
       }
       yield ActiveShellCommand.mkdir(cfg.workspace);
     } else {
-      yield [title];
       await fs.rm(cfg.workspace, { recursive: true, force: true });
       if (cfg.output) {
         await fs.rm(cfg.output, { recursive: true, force: true });
@@ -49,9 +56,10 @@ export class PackOperation {
 
     const bundleCommand = ['npx', 'rollup', '-c', 'node_modules/@travetto/pack/support/bin/rollup.js'];
 
+    const entryPointFile = RootIndex.getFromImport(cfg.entryPoint)!.outputFile.split(`${RootIndex.manifest.outputFolder}/`)[1];
+
     const env = Object.fromEntries(([
-      ['BUNDLE_ENTRY', cfg.entryPoint],
-      ['BUNDLE_ENTRY_NAME', cfg.entryCommand],
+      ['BUNDLE_ENTRY', entryPointFile],
       ['BUNDLE_COMPRESS', cfg.minify],
       ['BUNDLE_SOURCEMAP', cfg.sourcemap],
       ['BUNDLE_SOURCES', cfg.includeSources],
@@ -66,10 +74,9 @@ export class PackOperation {
     const props = (['minify', 'sourcemap', 'entryPoint'] as const)
       .map(k => cliTpl`${{ subtitle: k }}=${{ param: cfg[k] }}`).join(' ');
 
-    const title = cliTpl`${{ title: 'Bundling Output' }} ${props}`;
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Bundling Output' }} ${props}`);
 
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield* Object.entries(env).filter(x => !!x[1]).map(x =>
         ActiveShellCommand.export(x[0], x[1])
       );
@@ -77,7 +84,6 @@ export class PackOperation {
       yield bundleCommand;
       yield ActiveShellCommand.chdir(path.cwd());
     } else {
-      yield [title];
       await ExecUtil.spawn(bundleCommand[0], bundleCommand.slice(1), { cwd, env, stdio: ['inherit', 'pipe', 'pipe'] }).result;
     }
   }
@@ -87,17 +93,16 @@ export class PackOperation {
    */
   static async * writePackageJson(cfg: CommonPackConfig): AsyncIterable<string[]> {
     const file = 'package.json';
-    const title = cliTpl`${{ title: 'Writing' }} ${{ path: file }}`;
     const pkg = { type: RootIndex.manifest.moduleType };
 
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Writing' }} ${{ path: file }}`);
+
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield* ActiveShellCommand.createFile(
         path.resolve(cfg.workspace, file),
         [JSON.stringify(pkg)]
       );
     } else {
-      yield [title];
       await writeRawFile(
         path.resolve(cfg.workspace, file),
         JSON.stringify(pkg, null, 2)
@@ -110,20 +115,19 @@ export class PackOperation {
    */
   static async * writeEnv(cfg: CommonPackConfig): AsyncIterable<string[]> {
     const file = '.env.js';
-    const title = cliTpl`${{ title: 'Writing' }} ${{ path: file }}`;
     const env = {
       TRV_MANIFEST: `node_modules/${cfg.module}`,
       TRV_CLI_IPC: ''
     };
 
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Writing' }} ${{ path: file }}`);
+
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield* ActiveShellCommand.createFile(
         path.resolve(cfg.workspace, file),
         PackUtil.buildEnvJS(env)
       );
     } else {
-      yield [title];
       await writeRawFile(
         path.resolve(cfg.workspace, file),
         PackUtil.buildEnvJS(env).join('\n')
@@ -144,18 +148,18 @@ export class PackOperation {
         text: [
           ShellCommands[type].scriptOpen(),
           ShellCommands[type].chdirScript(),
-          ShellCommands[type].callCommandWithAllArgs('node', cfg.entryCommand, ...cfg.entryArguments),
+          ShellCommands[type].callCommandWithAllArgs('node', cfg.entrySource, ...cfg.entryArguments),
         ].map(x => x.join(' '))
       }));
 
     if (cfg.ejectFile) {
       for (const { fileTitle, text, file } of files) {
-        yield ActiveShellCommand.comment(fileTitle);
+        yield* PackOperation.title(cfg, fileTitle);
         yield* ActiveShellCommand.createFile(path.resolve(cfg.workspace, file), text, '755');
       }
     } else {
       for (const { fileTitle, text, file } of files) {
-        yield [fileTitle];
+        yield* PackOperation.title(cfg, fileTitle);
         await writeRawFile(path.resolve(cfg.workspace, file), text.join('\n'), '755');
       }
     }
@@ -180,10 +184,9 @@ export class PackOperation {
       destFolder: path.resolve(cfg.workspace, mod.outputFolder)
     }));
 
-    const title = cliTpl`${{ title: 'Copying over resources' }}`;
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Copying over resources' }}`);
 
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield* copyFiles.flatMap(mod => [
         ActiveShellCommand.mkdir(path.dirname(mod.dest)),
         ActiveShellCommand.copy(mod.src, mod.dest)
@@ -192,8 +195,6 @@ export class PackOperation {
         yield ActiveShellCommand.copyRecursive(resources.src, path.resolve(cfg.workspace, 'resources'));
       }
     } else {
-      yield [title];
-
       for (const { src, dest, destFolder } of copyFiles) {
         await fs.mkdir(destFolder, { recursive: true });
         await fs.copyFile(src, dest);
@@ -210,24 +211,22 @@ export class PackOperation {
    * Generate the trv-app-cache.json for @travetto/app, which is needed for 'running' programs
    */
   static async * primeAppCache(cfg: CommonPackConfig): AsyncIterable<string[]> {
-    const isRun = cfg.entryCommand === 'cli' && cfg.entryArguments.filter(x => !x.startsWith('-'))[0] === 'run';
+    const isRun = /entry[.]cli/.test(cfg.entryPoint) && cfg.entryArguments.filter(x => !x.startsWith('-'))[0] === 'run';
     if (!isRun) {
       return;
     }
 
     const appCacheCmd = ['npx', 'trv', 'main', '@travetto/app/support/bin/list'];
     const sub = path.join(RootIndex.manifest.modules[RootIndex.mainModule.name].outputFolder, 'trv-app-cache.json');
-    const title = cliTpl`${{ title: 'Generating App Cache' }} ${{ path: sub }}`;
     const env = { DEBUG: '0', TRV_MODULE: cfg.module };
     const appCache = path.resolve(cfg.workspace, sub);
 
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Generating App Cache' }} ${{ path: sub }}`);
 
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield ActiveShellCommand.mkdir(path.dirname(appCache));
       yield [...Object.entries(env).map(x => `${x[0]}=${x[1]}`), ...appCacheCmd, '>', appCache];
     } else {
-      yield [title];
       const { stdout } = await ExecUtil.spawn(appCacheCmd[0], appCacheCmd.slice(1), { env }).result;
 
       await fs.mkdir(path.dirname(appCache), { recursive: true });
@@ -242,13 +241,12 @@ export class PackOperation {
     const out = path.resolve(cfg.workspace, 'node_modules', cfg.module);
     const cmd = ['npx', 'trv', 'manifest', out, 'prod'];
     const env = { TRV_MODULE: cfg.module };
-    const title = cliTpl`${{ title: 'Writing Manifest' }} ${{ path: path.join('node_modules', cfg.module) }}`;
+
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Writing Manifest' }} ${{ path: path.join('node_modules', cfg.module) }}`);
 
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield [...Object.entries(env).map(([k, v]) => `${k}=${v}`), ...cmd];
     } else {
-      yield [title];
       await ExecUtil.spawn(cmd[0], cmd.slice(1), { env, stdio: ['inherit', 'ignore', 'inherit'] }).result;
     }
   }
@@ -257,15 +255,14 @@ export class PackOperation {
    * Generate ZIP file for workspace
    */
   static async * compress(cfg: CommonPackConfig): AsyncIterable<string[]> {
-    const title = cliTpl`${{ title: 'Compressing' }} ${{ path: cfg.output }}`;
+
+    yield* PackOperation.title(cfg, cliTpl`${{ title: 'Compressing' }} ${{ path: cfg.output }}`);
 
     if (cfg.ejectFile) {
-      yield ActiveShellCommand.comment(title);
       yield ActiveShellCommand.chdir(cfg.workspace);
       yield ActiveShellCommand.zip(cfg.output);
       yield ActiveShellCommand.chdir(path.cwd());
     } else {
-      yield [title];
       const [cmd, ...args] = ActiveShellCommand.zip(cfg.output);
       await ExecUtil.spawn(cmd, args, { cwd: cfg.workspace }).result;
     }

package/support/bin/shell.ts

@@ -27,6 +27,7 @@ export const ShellCommands: Record<'win32' | 'posix', ShellCommandImpl> = {
     export: (key, value) => ['set', `${key}=${value}`],
     chdir: (dest) => ['cd', dest],
     comment: (message) => ['\nREM', stripAnsiCodes(message), '\n'],
+    echo: (message) => ['echo', `"${escape(stripAnsiCodes(message))}\n"`],
     zip: (outputFile) => ['powershell', 'Compress-Archive', '-Path', '.', '-DestinationPath', outputFile]
   },
   posix: {
@@ -46,6 +47,7 @@ export const ShellCommands: Record<'win32' | 'posix', ShellCommandImpl> = {
     export: (key, value) => ['export', `${key}=${value}`],
     chdir: (dest) => ['cd', dest],
     comment: (message) => ['\n#', stripAnsiCodes(message), '\n'],
+    echo: (message) => ['echo', `"${escape(stripAnsiCodes(message))}\n"`],
     zip: (outputFile) => ['zip', '-r', outputFile, '.']
   },
 };

package/support/bin/types.ts

@@ -10,6 +10,7 @@ export type CommonPackConfig = {
   // Bundle
   entryPoint: string;
   entryCommand: string;
+  entrySource: string;
   entryArguments: string[];
   minify: boolean;
   sourcemap: boolean;
@@ -24,7 +25,6 @@ export type CommonPackOptions = {
 
   // Bundle
   entryPoint: OptionConfig<string>;
-  entryCommand: OptionConfig<string>;
   minify: OptionConfig<boolean>;
   sourcemap: OptionConfig<boolean>;
   includeSources: OptionConfig<boolean>;
@@ -63,6 +63,7 @@ export type ShellCommandImpl = {
   export(key: string, value: string): string[];
   chdir(dest: string): string[];
   comment(message: string): string[];
+  echo(text: string): string[];
   zip(output: string): string[];
 };
 

package/support/pack.base.ts

@@ -28,18 +28,33 @@ export abstract class BasePackCommand<T extends CommonPackOptions, S extends Com
     return !!RootIndex.manifest.monoRepo && path.cwd() === RootIndex.manifest.workspacePath;
   }
 
+  get entries(): string[] {
+    return RootIndex.findSupport({ filter: x => x.includes('entry.') })
+      .map(x => x.import.replace(/[.][^.]+s$/, ''));
+  }
+
+  /**
+   * Add help output
+   */
+  async help(): Promise<string> {
+    const entryPoints = this.entries.map(x => cliTpl`${{ subtitle: '*' }} ${{ identifier: x }}`);
+
+    return ['', cliTpl`${{ title: 'Available Entry Points:' }}`, '', ...entryPoints, ''].join('\n');
+  }
+
+
   getArgs(): string | undefined {
     return this.monoRoot ? '<module> [args...]' : '[args...]';
   }
 
   getCommonOptions(): CommonPackOptions {
+    const entries = this.entries;
+    const mainEntry = this.entries.find(x => x.startsWith('@travetto/cli'))!;
     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' }),
+      entryPoint: this.choiceOption({ short: 'e', desc: 'Entry point', def: mainEntry, choices: entries }),
       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' }),
@@ -89,7 +104,8 @@ export abstract class BasePackCommand<T extends CommonPackOptions, S extends Com
 
   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.entrySource = `${path.basename(this.cmd.entryPoint)}.js`;
+    this.cmd.entryCommand = path.basename(this.cmd.entryPoint).replace(/entry[.]/, '');
     this.cmd.module = RootIndex.mainModule.name;
     return this.cmd;
   }