@travetto/manifest 3.4.0 → 4.0.0-rc.1

package/src/package.ts

@@ -1,16 +1,19 @@
-import { createRequire } from 'module';
-import { execSync } from 'child_process';
+import { createRequire } from 'node:module';
+import { execSync } from 'node:child_process';
 
-import { ManifestContext, Package, PackageVisitor, PackageVisitReq, PackageWorkspaceEntry } from './types';
 import { path } from './path';
 import { ManifestFileUtil } from './file';
 
+import { PackagePath, type Package, type PackageVisitor, type PackageWorkspaceEntry } from './types/package';
+import type { ManifestContext } from './types/context';
+import type { NodePackageManager } from './types/common';
+
 /**
  * Utilities for querying, traversing and reading package.json files.
  */
 export class PackageUtil {
 
-  static #req = createRequire(path.resolve('node_modules'));
+  static #resolvers: Record<string, (imp: string) => string> = {};
   static #cache: Record<string, Package> = {};
   static #workspaces: Record<string, PackageWorkspaceEntry[]> = {};
 
@@ -21,21 +24,19 @@ export class PackageUtil {
   }
 
   /**
-   * Clear out cached package file reads
+   * Resolve import given a manifest context
    */
-  static clearCache(): void {
-    this.#cache = {};
-    this.#workspaces = {};
+  static resolveImport(imp: string, root?: string): string {
+    const loc = path.resolve(root ?? '.', 'node_modules');
+    return (this.#resolvers[loc] ??= createRequire(loc).resolve.bind(null))(imp);
   }
 
-  static resolveImport = (library: string): string => this.#req.resolve(library);
-
   /**
    * Resolve version path, if file: url
    */
-  static resolveVersionPath(rootPath: string, ver: string): string | undefined {
+  static resolveVersionPath(root: Package, ver: string): string | undefined {
     if (ver.startsWith('file:')) {
-      return path.resolve(rootPath, ver.replace('file:', ''));
+      return path.resolve(this.getPackagePath(root), ver.replace('file:', ''));
     } else {
       return;
     }
@@ -44,43 +45,18 @@ export class PackageUtil {
   /**
    * Find package.json folder for a given dependency
    */
-  static resolvePackagePath(name: string): string {
+  static resolvePackagePath(name: string, root?: string): string {
     try {
-      return path.dirname(this.resolveImport(`${name}/package.json`));
+      return path.dirname(this.resolveImport(`${name}/package.json`, root));
     } catch {
       try {
-        const resolved = this.resolveImport(name);
+        const resolved = this.resolveImport(name, root);
         return path.join(resolved.split(name)[0], name);
       } catch { }
     }
     throw new Error(`Unable to resolve: ${name}`);
   }
 
-  /**
-   * Build a package visit req
-   */
-  static packageReq<T>(sourcePath: string, prod: boolean, topLevel?: boolean): PackageVisitReq<T> {
-    return { pkg: this.readPackage(sourcePath), sourcePath, prod, topLevel };
-  }
-
-  /**
-   * Extract all dependencies from a package
-   */
-  static getAllDependencies<T = unknown>(modulePath: string, local: boolean): PackageVisitReq<T>[] {
-    const pkg = this.readPackage(modulePath);
-    const children: Record<string, PackageVisitReq<T>> = {};
-    for (const [deps, prod] of [
-      [pkg.dependencies, true],
-      ...(local ? [[pkg.devDependencies, false] as const] : []),
-    ] as const) {
-      for (const [name, version] of Object.entries(deps ?? {})) {
-        const depPath = this.resolveVersionPath(modulePath, version) ?? this.resolvePackagePath(name);
-        children[`${name}#${version}`] = this.packageReq<T>(depPath, prod, false);
-      }
-    }
-    return Object.values(children).sort((a, b) => a.pkg.name.localeCompare(b.pkg.name));
-  }
-
   /**
    * Read a package.json from a given folder
    */
@@ -94,90 +70,80 @@ export class PackageUtil {
 
     res.name ??= 'untitled'; // If a package.json (root-only) is missing a name, allows for npx execution
 
+    res[PackagePath] = modulePath;
     return res;
   }
 
   /**
-   * import a package.json from a given module name
+   * Get the package path
    */
-  static importPackage(moduleName: string): Package {
-    return this.readPackage(this.resolvePackagePath(moduleName));
+  static getPackagePath(pkg: Package): string {
+    return pkg[PackagePath];
   }
 
   /**
    * Visit packages with ability to track duplicates
    */
-  static async visitPackages<T>(
-    rootOrPath: PackageVisitReq<T> | string,
-    visitor: PackageVisitor<T>
-  ): Promise<Set<T>> {
-
-    const root = typeof rootOrPath === 'string' ?
-      this.packageReq<T>(rootOrPath, false, true) :
-      rootOrPath;
-
-    const seen = new Map<string, T>();
-    const queue: PackageVisitReq<T>[] = [...await visitor.init?.(root) ?? [], root];
-    const out = new Set<T>();
+  static async visitPackages<T>(visitor: PackageVisitor<T>): Promise<Iterable<T>> {
+    const seen = new Set<T>();
+    const queue = [...await visitor.init()];
 
     while (queue.length) {
-      const req = queue.pop();
+      const node = queue.shift()!; // Visit initial set first
 
-      if (!req || (visitor.valid && !visitor.valid(req))) {
+      if (!visitor.valid(node)) {
         continue;
       }
 
-      const key = req.sourcePath;
-      if (seen.has(key)) {
-        await visitor.visit?.(req, seen.get(key)!);
+      visitor.visit(node);
+
+      if (seen.has(node.value)) {
+        continue;
       } else {
-        const dep = await visitor.create(req);
-        out.add(dep);
-        await visitor.visit?.(req, dep);
-        seen.set(key, dep);
-        const children = this.getAllDependencies<T>(
-          req.sourcePath,
-          // We consider a module local if its not in the node_modules
-          !req.sourcePath.includes('node_modules') && (
-            // And its the root or we are in a monorepo
-            root.sourcePath === req.sourcePath ||
-            !!root.pkg.workspaces
-          )
-        );
-        queue.push(...children.map(x => ({ ...x, parent: dep })));
+        seen.add(node.value);
       }
+
+      const children = Object.entries(node.children)
+        .map(([n, v]) => this.readPackage(this.resolveVersionPath(node.pkg, v) ?? this.resolvePackagePath(n)))
+        .map(pkg => ({ ...visitor.create(pkg), parent: node.value }));
+
+      queue.push(...children);
     }
-    return (await visitor.complete?.(out)) ?? out;
+
+    return await visitor.complete(seen);
   }
 
   /**
    * Find workspace values from rootPath
    */
-  static async resolveWorkspaces(ctx: ManifestContext, rootPath: string): Promise<PackageWorkspaceEntry[]> {
-    if (!this.#workspaces[rootPath]) {
-      const cache = path.resolve(ctx.workspacePath, ctx.outputFolder, 'workspaces.json');
-      try {
-        return await ManifestFileUtil.readAsJson(cache);
-      } catch (err) {
+  static async resolveWorkspaces(ctx: ManifestContext): Promise<PackageWorkspaceEntry[]> {
+    const rootPath = ctx.workspace.path;
+    const cache = path.resolve(rootPath, ctx.build.outputFolder, 'workspaces.json');
+    return this.#workspaces[rootPath] ??= await ManifestFileUtil.readAsJson<PackageWorkspaceEntry[]>(cache)
+      .catch(async () => {
         let out: PackageWorkspaceEntry[];
-        switch (ctx.packageManager) {
+        switch (ctx.workspace.manager) {
+          case 'yarn':
           case 'npm': {
             const res = await this.#exec<{ location: string, name: string }[]>(rootPath, 'npm query .workspace');
-            out = res.map(d => ({ sourcePath: d.location, name: d.name }));
-            break;
-          }
-          case 'yarn': {
-            const res = await this.#exec<Record<string, { location: string }>>(rootPath, 'npm query .workspace');
-            out = Object.entries(res).map(([name, { location }]) => ({ sourcePath: location, name }));
+            out = res.map(d => ({ path: path.resolve(ctx.workspace.path, d.location), name: d.name }));
             break;
           }
         }
-
-        this.#workspaces[rootPath] = out;
-
         await ManifestFileUtil.bufferedFileWrite(cache, out);
-      }
+        return out;
+      });
+  }
+
+  /**
+   * Get an install command for a given npm module
+   */
+  static getInstallCommand(ctx: { workspace: { manager: NodePackageManager } }, pkg: string, prod = false): string {
+    let install: string;
+    switch (ctx.workspace.manager) {
+      case 'npm': install = `npm i ${prod ? '' : '--save-dev '}${pkg}`; break;
+      case 'yarn': install = `yarn add ${prod ? '' : '--dev '}${pkg}`; break;
     }
-    return this.#workspaces[rootPath];
+    return install;
   }
 }

package/src/path.ts

@@ -1,6 +1,6 @@
-import type * as pathMod from 'path';
-import { extname, dirname, basename, resolve, join } from 'path/posix';
-import { sep, resolve as nativeResolve, join as nativeJoin } from 'path';
+import type * as pathMod from 'node:path';
+import { extname, dirname, basename, resolve, join } from 'node:path/posix';
+import { sep, resolve as nativeResolve, join as nativeJoin } from 'node:path';
 
 /**
  * Converts a given file name by replace all slashes, with forward slashes

package/src/{root-index.ts → runtime.ts}

@@ -1,6 +1,9 @@
 import { path } from './path';
-import { IndexedModule, ManifestIndex } from './manifest-index';
-import { FunctionMetadata, ManifestContext } from './types';
+import { ManifestIndex } from './manifest-index';
+
+import type { FunctionMetadata } from './types/common';
+import type { IndexedModule, ManifestModule } from './types/manifest';
+import type { ManifestContext } from './types/context';
 
 const METADATA = Symbol.for('@travetto/manifest:metadata');
 type Metadated = { [METADATA]: FunctionMetadata };
@@ -8,7 +11,7 @@ type Metadated = { [METADATA]: FunctionMetadata };
 /**
  * Extended manifest index geared for application execution
  */
-class $RootIndex extends ManifestIndex {
+class $RuntimeIndex extends ManifestIndex {
 
   #metadata = new Map<string, FunctionMetadata>();
 
@@ -20,13 +23,6 @@ class $RootIndex extends ManifestIndex {
     this.init(`${this.outputRoot}/node_modules/${module}`);
   }
 
-  /**
-   * Determines if the manifest root is the root for a monorepo
-   */
-  isMonoRepoRoot(): boolean {
-    return !!this.manifest.monoRepo && !this.manifest.mainFolder;
-  }
-
   /**
    * Get internal id from file name and optionally, class name
    */
@@ -36,29 +32,11 @@ class $RootIndex extends ManifestIndex {
     return clsName ? `${id}￮${clsName}` : id;
   }
 
-  /**
-   * Get main module name
-   */
-  get mainModuleName(): string {
-    return this.manifest.mainModule;
-  }
-
   /**
    * Get main module for manifest
    */
   get mainModule(): IndexedModule {
-    return this.getModule(this.mainModuleName)!;
-  }
-
-  /**
-   * Digest manifest
-   */
-  manifestDigest(): Pick<ManifestContext, 'mainModule' | 'frameworkVersion' | 'version'> {
-    return {
-      mainModule: this.manifest.mainModule,
-      frameworkVersion: this.manifest.frameworkVersion,
-      version: this.manifest.version,
-    };
+    return this.getModule(this.manifest.main.name)!;
   }
 
   /**
@@ -107,23 +85,59 @@ class $RootIndex extends ManifestIndex {
    * Resolve module path to folder, with support for main module and monorepo support
    */
   resolveModulePath(modulePath: string): string {
-    const main = this.manifest.mainModule;
-    const workspace = this.manifest.workspacePath;
+    const main = this.manifest.main.name;
+    const workspace = this.manifest.workspace.path;
     const [base, sub] = modulePath
       .replace(/^(@@?)(#|$)/g, (_, v, r) => `${v === '@' ? main : workspace}${r}`)
       .split('#');
     return path.resolve(this.hasModule(base) ? this.getModule(base)!.sourcePath : base, sub ?? '.');
   }
-}
 
-let index: $RootIndex | undefined;
+  /**
+   * Get manifest module by name
+   */
+  getManifestModule(mod: string): ManifestModule {
+    return this.manifest.modules[mod];
+  }
 
-try {
-  index = new $RootIndex(process.env.TRV_MANIFEST!);
-} catch (err) {
-  if (/prod/i.test(process.env.NODE_ENV ?? '')) {
-    throw err;
+  /**
+   * Get manifest modules
+   */
+  getManifestModules(): ManifestModule[] {
+    return Object.values(this.manifest.modules);
   }
 }
 
-export const RootIndex: $RootIndex = index!;
+export const RuntimeIndex = new $RuntimeIndex(process.env.TRV_MANIFEST!);
+
+const build = <T extends object>(inp: T, props: (keyof ManifestContext)[]): T & ManifestContext => {
+  for (const prop of props) {
+    Object.defineProperty(inp, prop, { configurable: false, get: () => RuntimeIndex.manifest[prop] });
+  }
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return inp as T & ManifestContext;
+};
+
+export const RuntimeContext = build({
+  /**
+   * Produce a workspace relative path
+   * @param rel The relative path
+   */
+  workspaceRelative(...rel: string[]): string {
+    return path.resolve(RuntimeIndex.manifest.workspace.path, ...rel);
+  },
+  /**
+   * Produce a workspace path for tooling, with '@' being replaced by node_module/name folder
+   * @param rel The relative path
+   */
+  toolPath(...rel: string[]): string {
+    rel = rel.flatMap(x => x === '@' ? ['node_modules', RuntimeIndex.manifest.main.name] : [x]);
+    return path.resolve(RuntimeIndex.manifest.workspace.path, RuntimeIndex.manifest.build.toolFolder, ...rel);
+  },
+  /**
+   * Are we running from a mono-root?
+   */
+  get monoRoot(): boolean {
+    return !!RuntimeIndex.manifest.workspace.mono && !RuntimeIndex.manifest.main.folder;
+  }
+}, ['main', 'workspace']);

package/src/types/common.ts

@@ -0,0 +1,20 @@
+export type NodeModuleType = 'module' | 'commonjs';
+export type NodePackageManager = 'yarn' | 'npm';
+
+export type ManifestModuleFileType = 'typings' | 'ts' | 'js' | 'json' | 'package-json' | 'unknown' | 'fixture' | 'md';
+export type ManifestModuleFolderType =
+  '$root' | '$index' | '$package' |
+  'src' | 'bin' | 'support' | 'resources' | 'test' | 'doc' |
+  'test/fixtures' | 'support/fixtures' | 'support/resources' |
+  '$other' | '$transformer';
+
+export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';
+
+export type FunctionMetadata = {
+  id: string;
+  source: string;
+  hash?: number;
+  methods?: Record<string, { hash: number }>;
+  synthetic?: boolean;
+  abstract?: boolean;
+};

package/src/types/context.ts

@@ -0,0 +1,40 @@
+import type { NodeModuleType, NodePackageManager } from './common';
+
+export type ManifestContext = {
+  workspace: {
+    /** Workspace path for module */
+    path: string;
+    /** The module name for the workspace root */
+    name: string;
+    /** Is the workspace a monorepo? */
+    mono?: boolean;
+    /** The module type of the workspace */
+    type: NodeModuleType;
+    /** The package manager of the workspace */
+    manager: NodePackageManager;
+    /** The default env name */
+    defaultEnv: string;
+  };
+  build: {
+    /** Compiler folder, relative to workspace */
+    compilerFolder: string;
+    /** Compiler module folder */
+    compilerModuleFolder: string;
+    /** URL for the compiler server */
+    compilerUrl: string;
+    /** Code output folder, relative to workspace */
+    outputFolder: string;
+    /** Location of development-time tool output */
+    toolFolder: string;
+  };
+  main: {
+    /** Main module for manifest */
+    name: string;
+    /** Folder, relative to workspace for main module */
+    folder: string;
+    /** Description of the main module */
+    description?: string;
+    /** Version of the main module */
+    version: string;
+  };
+};

package/src/types/manifest.ts

@@ -0,0 +1,79 @@
+import type { ManifestModuleFileType, ManifestModuleFolderType, ManifestModuleRole } from './common';
+import type { ManifestContext } from './context';
+import { Package } from './package';
+
+export type ManifestModuleFile = [string, ManifestModuleFileType, number] | [string, ManifestModuleFileType, number, ManifestModuleRole];
+
+export type ManifestDepCore = {
+  /** Package name */
+  name: string;
+  /** Package version */
+  version: string;
+  /** Is this the main module */
+  main?: boolean;
+  /** Is this a module that is part of the workspace */
+  workspace?: boolean;
+  /** Should this module be deployed to prod? */
+  prod: boolean;
+  /** Is the module intended to be published? */
+  internal?: boolean;
+};
+
+export type ManifestModuleCore = ManifestDepCore & {
+  sourceFolder: string;
+  outputFolder: string;
+  roles: ManifestModuleRole[];
+  parents: string[];
+};
+
+export type ManifestModule = ManifestModuleCore & {
+  files: Partial<Record<ManifestModuleFolderType, ManifestModuleFile[]>>;
+};
+
+export type ManifestRoot = ManifestContext & {
+  generated: number;
+  modules: Record<string, ManifestModule>;
+};
+
+export type FindConfig = {
+  folder?: (folder: ManifestModuleFolderType) => boolean;
+  module?: (module: IndexedModule) => boolean;
+  file?: (file: IndexedFile) => boolean;
+  sourceOnly?: boolean;
+};
+
+export type IndexedFile = {
+  id: string;
+  import: string;
+  module: string;
+  sourceFile: string;
+  outputFile: string;
+  relativeFile: string;
+  role: ManifestModuleRole;
+  type: ManifestModuleFileType;
+};
+
+export type IndexedModule = ManifestModuleCore & {
+  sourcePath: string;
+  outputPath: string;
+  files: Record<ManifestModuleFolderType, IndexedFile[]>;
+  children: Set<string>;
+};
+
+/** Module dependency, used in dependency visiting */
+export type PackageModule = Omit<ManifestModule, 'files' | 'parents' | 'roles'> & {
+  state: {
+    /** Role root? */
+    roleRoot?: boolean;
+    /** Travetto package info */
+    travetto?: Package['travetto'];
+    /** Prod dependencies */
+    prodDeps: Set<string>;
+    /** Set of parent package names */
+    parentSet: Set<string>;
+    /** Set of child package names */
+    childSet: Set<string>;
+    /** Defined roles for a given module */
+    roleSet: Set<ManifestModuleRole>;
+  };
+};

package/src/types/package.ts

@@ -0,0 +1,75 @@
+import type { ManifestModuleRole, NodeModuleType } from './common';
+import type { ManifestContext } from './context';
+
+export const PackagePath = Symbol.for('@travetto/manifest:package-path');
+
+export type Package = {
+  [PackagePath]: string;
+  name: string;
+  type?: NodeModuleType;
+  version: string;
+  description?: string;
+  license?: string;
+  repository?: {
+    url: string;
+    directory?: string;
+  };
+  author?: {
+    email?: string;
+    name?: string;
+  };
+  main: string;
+  homepage?: string;
+  files?: string[];
+  bin?: Record<string, string>;
+  scripts?: Record<string, string>;
+  engines?: Record<string, string>;
+  keywords?: string[];
+
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
+  optionalDependencies?: Record<string, string>;
+  travetto?: {
+    displayName?: string;
+    roles?: ManifestModuleRole[];
+    doc?: {
+      output?: string[];
+      root?: string;
+      baseUrl?: string;
+      outputs?: string[];
+    };
+    defaultEnv?: string;
+    build?: Partial<ManifestContext['build']> & {
+      isolated?: boolean;
+      withModules?: Record<string, 'main' | true>;
+    };
+  };
+  workspaces?: string[];
+  private?: boolean;
+  publishConfig?: { access?: 'restricted' | 'public' };
+};
+
+export type PackageDepType = 'dependencies' | 'devDependencies' | 'optionalDependencies' | 'peerDependencies';
+
+export type PackageVisitReq<T> = {
+  /** Request package */
+  pkg: Package;
+  /** Children to visit */
+  children: Record<string, string>;
+  /** Value */
+  value: T;
+  /** Parent */
+  parent?: T;
+};
+
+export type PackageVisitor<T> = {
+  create(pkg: Package): PackageVisitReq<T>;
+  init(): Promise<Iterable<PackageVisitReq<T>>>;
+  valid(req: PackageVisitReq<T>): boolean;
+  visit(req: PackageVisitReq<T>): void;
+  complete(values: Iterable<T>): Promise<Iterable<T>>;
+};
+
+export type PackageWorkspaceEntry = { name: string, path: string };