nervur 0.20.2 → 0.20.4

package/src/node/index.ts

@@ -13,10 +13,11 @@
 //
 // One run holds a folder: a terrain refuses a folder another run serves.
 import { createHash } from 'node:crypto';
-import { chmod, rm } from 'node:fs/promises';
+import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import { connect, createServer, type Server } from 'node:net';
 import { homedir, tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import type { JsonObject } from '../being/index.ts';
 import { Loader, type Loaded, type Module } from '../contract/index.ts';
@@ -43,36 +44,99 @@ export const socketOf = (dir: string): string => {
   return join(tmpdir(), `nervur-${createHash('sha256').update(resolve(dir)).digest('hex').slice(0, 32)}.sock`);
 };
 
-// Code from a file: a module that exports `module`, `version` and
-// `classes`, found again by its absolute path. A file that cannot be
-// imported, or exports no module, is none.
+// A specifier that names a file rather than a package.
+export const isFile = (from: string): boolean => /^(\.{1,2}[\\/]|[\\/]|[A-Za-z]:[\\/])/.test(from) || /\.(m?[jt]s|c[jt]s)$/.test(from);
+
+// Code from a file or an installed package: a module that exports
+// `module`, `version` and `classes`, found again by where it was found, a
+// file by its absolute path and a package by its name, resolved from each
+// folder of `bases` in order. What cannot be imported, or exports no
+// module, is none.
 export class ImportLoader extends Loader {
+  readonly #bases: readonly string[];
+  constructor(bases: readonly string[] = [process.cwd()]) {
+    super();
+    this.#bases = bases;
+  }
+
   async load(from: string): Promise<Loaded | null> {
-    const path = resolve(from);
+    const found = isFile(from) ? resolve(from) : this.#package(from);
+    if (found === null) return null;
     let exported: { module?: unknown; version?: unknown; classes?: unknown };
     try {
-      exported = (await import(pathToFileURL(path).href)) as typeof exported;
+      exported = (await import(pathToFileURL(found).href)) as typeof exported;
     } catch {
       return null;
     }
     const { module, version, classes } = exported;
     if (typeof module !== 'string' || typeof version !== 'string' || !Array.isArray(classes)) return null;
-    return { module, version, classes, from: path };
+    return { module, version, classes, from: isFile(from) ? found : from };
+  }
+
+  #package(name: string): string | null {
+    for (const base of this.#bases) {
+      try {
+        return createRequire(join(resolve(base), 'noop.js')).resolve(name);
+      } catch {
+        // Not installed from here; the next base may hold it.
+      }
+    }
+    return null;
   }
 }
 
-// The modules a harbor is handed, by name, and then files.
+// A module by its id, the name it declares, so the catalogue's cells name
+// code the same way on every ground. `add` may name a module by its id, a
+// file, or an installed package, and the ground works out which. The
+// modules a harbor is handed are found by their id first. Where else an id
+// is found, a file's path or a package's name, is this ground's own
+// knowledge, kept beside the harbor in `<dir>/modules.json` and never in
+// the sealed package, since another ground finds the same id in its own
+// bundle. Packages resolve from where the command runs, then from the
+// harbor's folder.
 export class NodeLoader extends ImportLoader {
   readonly #held: HeldLoader;
-  constructor(modules: readonly Module[] = []) {
-    super();
+  readonly #map: string | undefined;
+  constructor(modules: readonly Module[] = [], dir?: string) {
+    super(dir === undefined ? [process.cwd()] : [process.cwd(), dir]);
     this.#held = new HeldLoader(modules);
+    this.#map = dir === undefined ? undefined : join(dir, MODULES);
   }
+
   override async load(from: string): Promise<Loaded | null> {
-    return (await this.#held.load(from)) ?? super.load(from);
+    const held = await this.#held.load(from);
+    if (held) return held;
+    const known = await this.#known();
+    const where = known[from];
+    if (where !== undefined) {
+      const loaded = await super.load(where);
+      return loaded?.module === from ? { ...loaded, from } : null;
+    }
+    const loaded = await super.load(from);
+    if (!loaded) return null;
+    if (this.#map && known[loaded.module] !== loaded.from) await this.#keep({ ...known, [loaded.module]: loaded.from });
+    return { ...loaded, from: loaded.module };
+  }
+
+  async #known(): Promise<Record<string, string>> {
+    if (!this.#map) return {};
+    try {
+      return JSON.parse(await readFile(this.#map, 'utf8')) as Record<string, string>;
+    } catch {
+      return {};
+    }
+  }
+
+  async #keep(files: Record<string, string>): Promise<void> {
+    await mkdir(dirname(this.#map!), { recursive: true, mode: 0o700 });
+    await writeFile(`${this.#map!}.new`, `${JSON.stringify(files, null, 2)}\n`, { mode: 0o600 });
+    await rename(`${this.#map!}.new`, this.#map!);
   }
 }
 
+// Where a Node harbor's module ids find their files.
+export const MODULES = 'modules.json';
+
 // One root request over a served harbor's socket, or undefined where none
 // is served.
 export const askServed = (dir: string, request: RootRequest): Promise<JsonObject | undefined> =>
@@ -107,7 +171,7 @@ export class NodeTerrain extends PointerTerrain {
     const entropy = new CryptoEntropy();
     super({
       entropy,
-      loader: new NodeLoader(parts.modules),
+      loader: new NodeLoader(parts.modules, parts.dir),
       custody: new FolderCustody(parts.dir, entropy),
       memory: new FolderMemory(parts.dir),
       faculties: [tcpFaculty, webGround, webPush],