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

package/support/bin/assemble/util.ts

@@ -1,139 +0,0 @@
-import fs from 'fs/promises';
-
-import { IndexedModule, Package, PackageUtil, path, RootIndex } from '@travetto/manifest';
-import { FileQueryProvider, TypedObject } from '@travetto/base';
-
-import { PackUtil } from '../util';
-
-/**
- * Utils for assembling
- */
-export class AssembleUtil {
-
-  /**
-   * Purge workspace using file rules
-   */
-  static async excludeFiles(root: string, files: string[]): Promise<void> {
-    const filter = PackUtil.excludeChecker(files, root);
-    for await (const el of FileQueryProvider.query({ paths: [root], filter, hidden: true })) {
-      try {
-        await fs.unlink(el);
-      } catch { }
-    }
-  }
-
-  /**
-   * Copy over added content
-   */
-  static async copyAddedContent(workspace: string, files: Record<string, string>[]): Promise<void> {
-    for (const a of files) {
-      let [src, dest] = Object.entries(a)[0];
-      [src, dest] = [path.resolve(src), path.resolve(workspace, dest)];
-      const stat = await fs.stat(src).catch(() => { });
-      if (stat) {
-        if (stat.isFile()) {
-          await fs.mkdir(path.dirname(dest), { recursive: true });
-          await fs.copyFile(src, dest);
-        } else {
-          await fs.mkdir(path.dirname(dest), { recursive: true });
-          await PackUtil.copyRecursive(src, dest);
-        }
-      }
-    }
-  }
-
-  static async copyModule(workspace: string, module: IndexedModule, keepSource?: boolean): Promise<void> {
-    const toCopy: Promise<void>[] = [];
-    for (const [key, files] of TypedObject.entries(module.files)) {
-      switch (key) {
-        case '$index':
-        case '$root':
-        case '$package':
-        case 'src':
-        case 'support':
-        case 'resources':
-        case 'bin': {
-          for (const file of files) {
-            const targetPartial = file.output.split(RootIndex.manifest.outputFolder)[1];
-            const target = path.join(workspace, targetPartial);
-            const src = await fs.stat(file.output).then(() => file.output, () => file.source);
-            toCopy.push((async (): Promise<void> => {
-              await fs.mkdir(path.dirname(target), { recursive: true });
-              await fs.copyFile(src, target);
-
-              if (file.type === 'ts' || file.type === 'js') {
-                if (keepSource) {
-                  await fs.copyFile(`${src}.map`, `${target}.map`).catch(() => { });
-                } else {
-                  await fs.writeFile(target, (await fs.readFile(target, 'utf8')).replace(/\/\/# sourceMap.*/g, ''));
-                }
-              }
-            })());
-          }
-          break;
-        }
-      }
-    }
-    await Promise.all(toCopy);
-  }
-
-  /**
-   * Copy over all prod dependencies
-   */
-  static async copyProdDependencies(workspace: string, keepSource?: boolean): Promise<void> {
-    const pkgs = await PackageUtil.visitPackages<{ pkg: Package, src: string }>(RootIndex.mainModule.source, {
-      valid: req =>
-        (req.rel === 'prod' || req.rel === 'opt' || req.rel === 'root') &&
-        !req.pkg.name.startsWith('@types/'),
-      create: req => ({ pkg: req.pkg, src: req.sourcePath }),
-    });
-    await fs.mkdir(path.resolve(workspace, 'node_modules'), { recursive: true });
-    for (const { pkg, src } of pkgs) {
-      if (RootIndex.hasModule(pkg.name)) {
-        await this.copyModule(workspace, RootIndex.getModule(pkg.name)!, keepSource);
-      } else {
-        const folder = path.dirname(path.resolve(workspace, 'node_modules', src.replace(/^.*?node_modules\//, '')));
-        await PackUtil.copyRecursive(src, folder);
-      }
-    }
-  }
-
-  /**
-   * Copy over entry point
-   */
-  static async copyEntryPoint(workspace: string): Promise<void> {
-    // Faux-package.json
-    await fs.writeFile(path.resolve(workspace, 'package.json'), JSON.stringify({
-      name: '@entry/main',
-      version: RootIndex.mainPackage.version,
-      dependencies: { [RootIndex.mainPackage.name]: '*', }
-    }, null, 2), 'utf8');
-
-    const manifest = structuredClone(RootIndex.manifest);
-    for (const [name, mod] of TypedObject.entries(manifest.modules)) {
-      if (!mod.profiles.includes('std')) {
-        delete manifest.modules[name];
-      }
-    }
-
-    manifest.manifestFile = 'manifest.json';
-    manifest.mainPath = RootIndex.manifest.modules[RootIndex.mainPackage.name].output;
-
-    await fs.writeFile(path.resolve(workspace, 'manifest.json'), JSON.stringify(manifest), 'utf8');
-
-    const output = path.resolve(RootIndex.manifest.workspacePath, RootIndex.manifest.outputFolder);
-    for (const file of [
-      path.resolve(output, 'trv'), // Entry points
-      path.resolve(output, 'trv.cmd')
-    ]) {
-      await fs.copyFile(file, path.resolve(workspace, path.basename(file)));
-    }
-  }
-
-  /**
-   * Delete all empty folders
-   */
-  static async removeEmptyFolders(root: string): Promise<void> {
-    // Remove
-  }
-}

package/support/bin/docker.ts

@@ -1,97 +0,0 @@
-import fs from 'fs/promises';
-
-import { path, RootIndex } from '@travetto/manifest';
-import { Env, ExecUtil } from '@travetto/base';
-import { cliTpl } from '@travetto/cli';
-
-import { CommonConfig, PackOperation } from './types';
-import { PackUtil } from './util';
-
-export interface DockerConfig extends CommonConfig {
-  image: string;
-  tag: string[];
-  name?: string;
-  app?: string;
-  port?: (string | number)[];
-  env: Record<string, string | number | boolean>;
-  builder?: (cfg: DockerConfig) => string;
-  registry?: string;
-  push?: boolean;
-}
-
-const dockerFileBuilder = ({ image, port, app = 'rest', env }: DockerConfig): string => `
-FROM ${image}
-WORKDIR /app
-COPY . .
-${Object.entries(env).map(([k, v]) => `ENV ${k} "${v}"`).join('\n')}
-${(port ?? []).map(x => `EXPOSE ${x}`).join('\n')}
-CMD ["./trv", "run", "${app}"]
-`;
-
-export const Docker: PackOperation<DockerConfig, 'docker'> = {
-  key: 'docker',
-  title: 'Docker-izing',
-  context(cfg: DockerConfig) {
-    return `[image=${cfg.image}, port=${cfg.port}]`;
-  },
-  defaults: {
-    name: RootIndex.mainPackage.name.replace('@', ''),
-    image: 'node:18-alpine3.16',
-    builder: dockerFileBuilder,
-    port: [],
-    tag: ['latest']
-  },
-  overrides: {
-    image: Env.get('PACK_DOCKER_IMAGE') || undefined,
-    name: Env.get('PACK_DOCKER_NAME') || undefined,
-    app: Env.get('PACK_DOCKER_APP') || undefined,
-    registry: Env.get('PACK_DOCKER_REGISTRY') || undefined,
-    push: Env.getBoolean('PACK_DOCKER_PUSH'),
-    port: Env.getList('PACK_DOCKER_PORT'),
-    tag: Env.getList('PACK_DOCKER_TAG')
-  },
-  extend(src: Partial<DockerConfig>, dest: Partial<DockerConfig>): Partial<DockerConfig> {
-    return {
-      image: src.image ?? dest.image,
-      app: src.app ?? dest.app,
-      name: src.name ?? dest.name,
-      builder: src.builder ?? dest.builder,
-      tag: src.tag ?? dest.tag,
-      port: src.port ?? dest.port,
-      registry: src.registry ?? dest.registry,
-      env: { ...(src.env ?? {}), ...(dest.env ?? {}) },
-      push: src.push ?? dest.push
-    };
-  },
-  buildConfig(configs: Partial<DockerConfig>[]): DockerConfig {
-    return PackUtil.buildConfig(this, configs);
-  },
-  /**
-  * Dockerize workspace with flags
-  */
-  async* exec(cfg: DockerConfig) {
-    const { builder, workspace, push, image, tag, name, registry } = cfg;
-
-    const ws = path.resolve(workspace);
-
-    yield 'Building Dockerfile';
-
-    await fs.writeFile(path.resolve(ws, 'Dockerfile'), builder!(cfg), { encoding: 'utf8' });
-
-    yield 'Pulling Base Image';
-    await ExecUtil.spawn('docker', ['pull', image]).result;
-
-    yield 'Building Docker Container';
-    const tags = tag.map(x => registry ? `${registry}/${name}:${x}` : `${name}:${x}`);
-    const args = ['build', ...tags.flatMap(x => ['-t', x]), '.'];
-
-    await ExecUtil.spawn('docker', args, { cwd: ws, stdio: [0, 'pipe', 2] }).result;
-
-    if (push) {
-      yield 'Pushing Tags';
-      await ExecUtil.spawn('docker', ['image', 'push', ...tags]).result;
-    }
-
-    yield cliTpl`${{ success: 'Successfully' }} containerized project`;
-  }
-};

package/support/bin/pack.ts

@@ -1,69 +0,0 @@
-import { cliTpl } from '@travetto/cli';
-
-import { CommonConfig, PackOperation } from './types';
-import { PackUtil } from './util';
-import { Assemble, AssembleConfig } from './assemble/operation';
-import { Docker, DockerConfig } from './docker';
-import { Zip, ZipConfig } from './zip';
-
-type DeepPartial<T> = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [P in keyof T]?: (T[P] extends (number | string | boolean | undefined | RegExp | ((...args: any[]) => any)) ?
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (T[P] | undefined) : (T[P] extends any[] ? DeepPartial<T[P][number]>[] : DeepPartial<T[P]>));
-};
-
-const ops = {
-  [Assemble.key]: Assemble,
-  [Zip.key]: Zip,
-  [Docker.key]: Docker
-} as const;
-
-export type AllConfig = CommonConfig &
-{ assemble: AssembleConfig } &
-{ zip: ZipConfig } &
-{ docker: DockerConfig };
-
-export type AllConfigPartial = DeepPartial<AllConfig>;
-
-type DefaultOpType = ['assemble', typeof Assemble];
-
-export const Pack: PackOperation<AllConfig, ''> = {
-  key: '',
-  title: 'Packing',
-  buildConfig(configs: Partial<AllConfig>[]): AllConfig {
-    const ret: Partial<AllConfig> = {
-      workspace: configs[0].workspace,
-    };
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    for (const [k, op] of (Object.entries(ops) as DefaultOpType[])) {
-      ret[k] = op.buildConfig(configs.map(config => config[k] ?? {}));
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return ret as AllConfig;
-  },
-  async context(cfg: AllConfig) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return `[ ${(Object.entries(ops) as DefaultOpType[])
-      .filter(x => cfg[x[0]].active)
-      .map(x => x[0])
-      .join(', ')} ]`;
-  },
-  async * exec(cfg: AllConfig) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const steps = (Object.entries(ops) as DefaultOpType[])
-      .filter(x => cfg[x[0]].active);
-
-    if (!steps.length) {
-      throw new Error('Pack operation has zero active steps');
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    for (const [step, op] of steps as DefaultOpType[]) {
-      process.stdout.write('\n');
-      cfg[step].workspace = cfg.workspace;
-      await PackUtil.runOperation(op, cfg[step], 2);
-    }
-    process.stdout.write('\n');
-    yield cliTpl`${{ success: 'Successfully' }} packed project`;
-  }
-};

package/support/bin/zip.ts

@@ -1,51 +0,0 @@
-import fs from 'fs/promises';
-
-import { path } from '@travetto/manifest';
-import { ExecUtil } from '@travetto/base';
-import { cliTpl } from '@travetto/cli';
-
-import { CommonConfig, PackOperation } from './types';
-import { PackUtil } from './util';
-
-export interface ZipConfig extends CommonConfig {
-  output: string;
-}
-
-export const Zip: PackOperation<ZipConfig, 'zip'> = {
-  key: 'zip',
-  title: 'Zipping',
-  context(cfg: ZipConfig) {
-    return `[output=${cfg.output}]`;
-  },
-  overrides: {
-    output: process.env.PACK_ZIP_OUTPUT || undefined
-  },
-  extend(src: Partial<ZipConfig>, dest: Partial<ZipConfig>): Partial<ZipConfig> {
-    return { output: src.output ?? dest.output };
-  },
-  buildConfig(configs: Partial<ZipConfig>[]): ZipConfig {
-    return PackUtil.buildConfig(this, configs);
-  },
-  /**
-  * Zip workspace with flags
-  */
-  async * exec({ workspace, output }: ZipConfig) {
-    const ws = path.resolve(workspace);
-    const zipFile = path.resolve(output);
-
-    yield 'Preparing Target';
-    await fs.mkdir(path.dirname(zipFile), { recursive: true });
-    if (await fs.stat(zipFile).catch(() => { })) {
-      await fs.unlink(zipFile); // Unlink
-    }
-
-    yield 'Compressing';
-    if (/win/i.test(process.platform)) {
-      await ExecUtil.spawn('powershell', ['Compress-Archive', '-Path', '.', '-DestinationPath', zipFile], { cwd: ws }).result;
-    } else {
-      await ExecUtil.spawn('zip', ['-r', zipFile, '.'], { cwd: ws }).result;
-    }
-
-    yield cliTpl`${{ success: 'Successfully' }} archived project to ${{ path: zipFile.replace(path.cwd(), '.') }}`;
-  }
-};

package/support/cli.pack-base.ts

@@ -1,97 +0,0 @@
-import os from 'os';
-
-import { path, RootIndex } from '@travetto/manifest';
-import { CliCommand, CliScmUtil, cliTpl, OptionConfig } from '@travetto/cli';
-
-import { PackUtil } from './bin/util';
-import { CommonConfig, PackOperation } from './bin/types';
-
-const packName = `pack_${RootIndex.mainPackage.name}`
-  .toLowerCase()
-  .replace(/[^a-z]+/g, '_')
-  .replace(/_+/g, '_');
-
-export type BaseOptions = {
-  workspace: OptionConfig<string>;
-};
-
-function getConfigFromOperationOrGlobal<C extends CommonConfig, K extends string>(key: K, config: Partial<C> | Record<K, Partial<C>> | undefined): Partial<C> | undefined {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !config ? config : (key && key in config ? (config as Record<K, C>)[key] : config) as C;
-}
-
-/**
- * Supports packing a project into a directory, ready for archiving
- */
-export abstract class BasePackCommand<V extends BaseOptions, C extends CommonConfig, K extends string> extends CliCommand<V> {
-
-  /**
-   * Package stage name
-   */
-  abstract get operation(): PackOperation<C, K>;
-
-  get cmdOptions(): Partial<C> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return this.cmd as Partial<C>;
-  }
-
-  get name(): string {
-    return this.operation.key ? `pack:${this.operation.key}` : 'pack';
-  }
-
-  commonOptions(): BaseOptions {
-    return { workspace: this.option({ desc: 'Working directory' }) } as const;
-  }
-
-  async resolveConfigs(cfg: Partial<CommonConfig>, def?: Partial<CommonConfig>): Promise<C> {
-    const configs = [
-      { workspace: path.resolve(os.tmpdir(), packName) },
-      def,
-      cfg,
-      this.cmdOptions,
-      { active: true }
-    ]
-      .map(x => getConfigFromOperationOrGlobal(this.operation.key, x))
-      .filter((x): x is C => x !== undefined);
-
-    return this.operation.buildConfig(configs);
-  }
-
-  getArgs(): string {
-    return '[mode]';
-  }
-
-  async help(): Promise<string> {
-    const lines = await PackUtil.modeList();
-
-    const out: string[] = [];
-    if (lines.length) {
-      out.push('', cliTpl`${{ title: 'Available Pack Modes:' }}`);
-      for (const { name, file } of lines) {
-        out.push(cliTpl`  * ${{ input: `${name}` }} [${{ path: file }}]`);
-      }
-      out.push('');
-    }
-    return out.join('\n');
-  }
-
-  async action(): Promise<void> {
-    if (!this.args[0]) {
-      return this.showHelp('Missing config mode');
-    }
-
-    const list = (await PackUtil.modeList());
-    const cfg = list.find(c => c.name === this.args[0]);
-    if (!cfg) {
-      return this.showHelp(`Unknown config mode: ${this.args[0]}`);
-    }
-
-    const def = list.find(c => c.name === 'default');
-
-    const resolved = await this.resolveConfigs(cfg, def);
-    if (await CliScmUtil.isRepoRoot(resolved.workspace)) {
-      throw new Error('Refusing to use workspace with a .git directory');
-    }
-    return PackUtil.runOperation(this.operation, resolved);
-  }
-}

package/support/cli.pack_assemble.ts

@@ -1,21 +0,0 @@
-import { OptionConfig } from '@travetto/cli';
-
-import { BaseOptions, BasePackCommand } from './cli.pack-base';
-import { Assemble, AssembleConfig } from './bin/assemble/operation';
-
-type Options = BaseOptions & {
-  keepSource: OptionConfig<boolean>;
-  readonly: OptionConfig<boolean>;
-};
-
-export class PackAssembleCommand extends BasePackCommand<Options, AssembleConfig, 'assemble'> {
-  operation = Assemble;
-
-  getOptions(): Options {
-    return {
-      ...this.commonOptions(),
-      keepSource: this.boolOption({ desc: 'Should source be preserved' }),
-      readonly: this.boolOption({ desc: 'Build a readonly deployable' })
-    };
-  }
-}

package/support/cli.pack_docker-export.ts

@@ -1,55 +0,0 @@
-import fs from 'fs/promises';
-import { existsSync } from 'fs';
-
-import { path } from '@travetto/manifest';
-import { CliCommand, OptionConfig, ListOptionConfig } from '@travetto/cli';
-
-type Options = {
-  app: OptionConfig<string>;
-  image: OptionConfig<string>;
-  port: OptionConfig<number>;
-  add: ListOptionConfig<string>;
-  output: OptionConfig<string>;
-};
-
-export class PackDockerExportCommand extends CliCommand<Options> {
-
-  name = 'pack:docker-export';
-
-  getOptions(): Options {
-    return {
-      app: this.option({ desc: 'The application target to run', def: 'rest' }),
-      image: this.option({ desc: 'Docker image to extend', def: 'node:16-alpine' }),
-      port: this.intOption({ desc: 'Expose port', def: 3000 }),
-      add: this.listOption({ desc: 'Files to include' }),
-      output: this.option({ desc: 'Docker file name', def: 'Dockerfile' })
-    };
-  }
-
-  async action(...args: unknown[]): Promise<void> {
-    const files = ['src', 'bin', 'support', 'resource', 'package.json', 'package-lock.json', ...this.cmd.add]
-      .filter(x => existsSync(path.resolve(x)));
-
-    const content = `
-FROM ${this.cmd.image} as build
-WORKDIR /build
-${files.map(x => `COPY ${x} ${x}`).join('\n')}
-ENV NODE_OPTIONS "--no-deprecation"
-RUN npm ci
-RUN npx trv pack:assemble -w /app
-
-FROM ${this.cmd.image} as scratch
-COPY --from=build /app /app
-EXPOSE ${this.cmd.port}
-WORKDIR  /app
-ENV NODE_OPTIONS "--no-deprecation"
-CMD ["./trv", "run", "${this.cmd.app}"]
-`;
-
-    if (this.cmd.output === '-' || this.cmd.output === '/dev/stdout' || !this.cmd.output) {
-      console.log(content);
-    } else {
-      await fs.writeFile(this.cmd.output, content, { encoding: 'utf8' });
-    }
-  }
-}

package/support/pack.config.ts

@@ -1,60 +0,0 @@
-import { AllConfigPartial } from './bin/pack';
-
-const mod = (f: string): string => `node_modules/${f}`;
-
-export const config: AllConfigPartial = {
-  name: 'default',
-  assemble: {
-    active: true,
-    keepSource: true,
-    readonly: true,
-    env: {
-      TRV_DYNAMIC: '0'
-    },
-    add: [
-      { [mod('@travetto/cli/bin/trv.js')]: mod('.bin/trv') },
-      { [mod('lodash/lodash.min.js')]: mod('lodash/lodash.js') },
-    ],
-    exclude: [
-      'bower.json',
-      'LICENSE',
-      'LICENCE',
-      '*.map',
-      '*.md',
-      '*.lock',
-      '*.html',
-      '*.mjs',
-      mod('**/*.ts'),
-      '*.d.ts',
-      '*.tsbuildinfo',
-      '*.java',
-      '*.markdown',
-      '.eslintrc',
-      '.npmignore',
-      '.*.yml',
-      'cache/compiler.*.log',
-      mod('faker'),
-      mod('lodash/lodash.min.js'),
-      mod('source-map-support/node_modules/source-map'),
-      mod('source-map-support/browser-source-map-support.js'),
-      mod('bson/browser_build/'),
-      mod('**/tsconfig.json'),
-      mod('**/tsconfig.*.json'),
-      mod('@travetto/*/doc.ts'),
-      mod('typescript/'),
-      mod('@types/'),
-      `^./${mod('@travetto/**/*.ts')}`,
-      `^./${mod('@travetto/compiler/tsconfig.trv.json')}`,
-      '^./resources/',
-      '^./src/',
-    ]
-  },
-  zip: {
-    active: false,
-    output: 'output.zip'
-  },
-  docker: {
-    active: false,
-    image: 'node:16-alpine'
-  }
-};