@_linked/server 2.16.2 → 2.17.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @\_linked/server
 
+## 2.17.0
+
+### Minor Changes
+
+- [#126](https://github.com/linked-fw/server/pull/126) [`93ebd50`](https://github.com/linked-fw/server/commit/93ebd5002d76ad9208cac63c09ad92e5f4f74c0a) Thanks [@flyon](https://github.com/flyon)! - Load each linked package's backend from the directory it is installed in, not by its bare name.
+
+  The backend entry used to be loaded with `import('<pkg>/backend')`, which Node resolves from @_linked/server's own location. A linked package installed only nested inside another package's `node_modules` (npm does this when the root cannot share one version, e.g. `@_linked/owl/node_modules/@_linked/rdfs`) could therefore never be loaded: boot logged a red "Cannot find package" error for packages without a backend, and a nested package WITH a backend never had its providers constructed, its request hooks never ran, and `/call` to it answered 501.
+
+  Now the server keeps the path discovery found for every linked package, resolves the `./backend` entry from that package's own `exports` (new `resolveBackendEntry`: exact key, `./*` patterns, `import`/`node`/`default` conditions; legacy layout without `exports`) and imports it by file URL. Whether a package has a backend is decided before anything is imported: no entry is quiet, and a backend file that fails to load is a loud error naming the package and the file, without stopping other packages. The error-text matching that used to tell the two apart is gone.
+
+  When a linked package is installed more than once, only the copy the app itself resolves is loaded, and the server warns once with every copy's version and path and a hint to run `npm dedupe`.
+
 ## 2.16.2
 
 ### Patch Changes

package/lib/esm/shapes/LinkedServer.d.ts

@@ -39,6 +39,16 @@ export declare class LinkedServer extends Shape {
     private shapeProviders;
     private genericProviders;
     private providerIndexing;
+    /**
+     * Package name → realpath of the installed copy whose backend is loaded,
+     * as discovery found it. A package's backend is resolved from THIS
+     * directory, never by its bare name from @_linked/server's own location:
+     * Node would never look inside another package's nested node_modules, so a
+     * linked package installed only there (owl/node_modules/@_linked/rdfs)
+     * could not be loaded at all.
+     */
+    private linkedPackageDirs;
+    private warnedDuplicateInstalls;
     private resizePathsMap;
     private api;
     /**
@@ -98,9 +108,22 @@ export declare class LinkedServer extends Shape {
      * Index the backend providers of every linked package in the app's
      * dependency tree, dependencies first. Workspace members (`localPackages`)
      * are also imported whole, as before; for anything else only its `/backend`
-     * entry is loaded, and a package without one costs a failed resolve.
+     * entry is loaded — resolved from the directory discovery found the package
+     * in, and skipped without an import when the package has none.
      */
     private indexLinkedDependencyProviders;
+    /**
+     * Two installed copies of one linked package mean two copies of its module
+     * state, and only one of them can own the backend. The one the app resolves
+     * is loaded (see discoverLinkedDependencies); the other is never loaded.
+     */
+    private warnIfInstalledMoreThanOnce;
+    /**
+     * The directory a package's backend is resolved from: the copy discovery
+     * chose, or — for a package outside the linked tree, reached only by a lazy
+     * /call — the copy the app itself resolves.
+     */
+    private packageDirFor;
     /**
      * Index a package's backend providers once. Shared by boot and the lazy
      * path in callBackendMethod / callShapeMethod. `onSourceChange` bypasses it
@@ -108,8 +131,8 @@ export declare class LinkedServer extends Shape {
      */
     ensurePackageBackendProviders(pkg: string, warnIfNotFound?: boolean): Promise<void>;
     /**
-     * Node's `import()`, as a method so a test can resolve a fixture app's
-     * node_modules (a test runner resolves bare specifiers from this file).
+     * Node's `import()`. Called with the absolute file URL of a resolved backend
+     * entry (see resolveBackendEntry), never a bare name.
      */
     protected importModule(specifier: string): Promise<any>;
     /**
@@ -119,7 +142,7 @@ export declare class LinkedServer extends Shape {
     private filterPackagesByDependencyTree;
     resizeImage(req: any, res: any): Promise<void>;
     indexLincdPackage(pkg: string, warnIfNotFound?: boolean): Promise<void>;
-    indexPackageBackendProviders(pkg: string, warnIfNotFound?: boolean, backendIndexFilePath?: string): Promise<{
+    indexPackageBackendProviders(pkg: string, warnIfNotFound?: boolean): Promise<{
         backendProviderExports: any;
         shapeProviders: any[];
     }>;

package/lib/esm/shapes/LinkedServer.js

@@ -37,7 +37,7 @@ import { autoLoadOntologyData } from '@_linked/core/utils/Package';
 import { getShapeClass, getSuperShapesClasses, } from '@_linked/core/utils/ShapeClass';
 import path from 'path';
 import { pathToFileURL } from 'node:url';
-import { discoverLinkedDependencies, isBundledBySsr, ssrNoExternalOf, } from '../utils/linkedDependencies.js';
+import { discoverLinkedDependencies, isBundledBySsr, NODE_IMPORT_CONDITIONS, readInstalledPackage, resolveBackendEntry, ssrNoExternalOf, } from '../utils/linkedDependencies.js';
 /**
  * `instanceof ShapeProvider`, tolerating a second copy of server-utils.
  *
@@ -166,6 +166,16 @@ let LinkedServer = class LinkedServer extends Shape {
         // concurrent first calls (or a call racing boot) never construct a
         // package's providers twice.
         this.providerIndexing = new Map();
+        /**
+         * Package name → realpath of the installed copy whose backend is loaded,
+         * as discovery found it. A package's backend is resolved from THIS
+         * directory, never by its bare name from @_linked/server's own location:
+         * Node would never look inside another package's nested node_modules, so a
+         * linked package installed only there (owl/node_modules/@_linked/rdfs)
+         * could not be loaded at all.
+         */
+        this.linkedPackageDirs = new Map();
+        this.warnedDuplicateInstalls = new Set();
         //from resizedFileName to full resized path (CDN or similar)
         this.resizePathsMap = new Map();
         if (config && typeof config !== 'string' && !('id' in config)) {
@@ -624,16 +634,32 @@ let LinkedServer = class LinkedServer extends Shape {
      * Index the backend providers of every linked package in the app's
      * dependency tree, dependencies first. Workspace members (`localPackages`)
      * are also imported whole, as before; for anything else only its `/backend`
-     * entry is loaded, and a package without one costs a failed resolve.
+     * entry is loaded — resolved from the directory discovery found the package
+     * in, and skipped without an import when the package has none.
      */
     async indexLinkedDependencyProviders(localPackages) {
-        var _a;
+        var _a, _b;
         const started = Date.now();
         const installed = [];
         const ordered = discoverLinkedDependencies(process.cwd(), this.package);
         // A workspace member the walk cannot reach through node_modules still
         // loads, after the rest, as it always did.
         const remaining = new Set(localPackages.keys());
+        (_a = this.linkedPackageDirs) !== null && _a !== void 0 ? _a : (this.linkedPackageDirs = new Map());
+        for (const dep of ordered) {
+            this.linkedPackageDirs.set(dep.packageName, dep.path);
+            this.warnIfInstalledMoreThanOnce(dep);
+        }
+        for (const [packageName, local] of localPackages) {
+            if (!this.linkedPackageDirs.has(packageName) && (local === null || local === void 0 ? void 0 : local.path)) {
+                let dir = local.path;
+                try {
+                    dir = fsNative.realpathSync(dir);
+                }
+                catch (_c) { }
+                this.linkedPackageDirs.set(packageName, dir);
+            }
+        }
         for (const { packageName } of ordered) {
             const isLocal = remaining.delete(packageName);
             await this.ensurePackageBackendProviders(packageName);
@@ -641,7 +667,7 @@ let LinkedServer = class LinkedServer extends Shape {
                 await this.indexLincdPackage(packageName);
             }
             else if (this.genericProviders.get(packageName) ||
-                ((_a = this.shapeProviders.get(packageName)) === null || _a === void 0 ? void 0 : _a.length)) {
+                ((_b = this.shapeProviders.get(packageName)) === null || _b === void 0 ? void 0 : _b.length)) {
                 installed.push(packageName);
             }
         }
@@ -653,6 +679,44 @@ let LinkedServer = class LinkedServer extends Shape {
             console.log(paint('gray', `[linked] indexed backend providers of ${ordered.length} linked package(s) in ${Date.now() - started}ms; installed ones with providers: ${installed.join(', ')}`));
         }
     }
+    /**
+     * Two installed copies of one linked package mean two copies of its module
+     * state, and only one of them can own the backend. The one the app resolves
+     * is loaded (see discoverLinkedDependencies); the other is never loaded.
+     */
+    warnIfInstalledMoreThanOnce(dep) {
+        var _a, _b;
+        const copies = (_a = dep.copies) !== null && _a !== void 0 ? _a : [];
+        (_b = this.warnedDuplicateInstalls) !== null && _b !== void 0 ? _b : (this.warnedDuplicateInstalls = new Set());
+        if (copies.length < 2 || this.warnedDuplicateInstalls.has(dep.packageName)) {
+            return;
+        }
+        this.warnedDuplicateInstalls.add(dep.packageName);
+        const list = copies
+            .map((c) => { var _a; return `${(_a = c.version) !== null && _a !== void 0 ? _a : '?'} at ${c.path}`; })
+            .join(', ');
+        console.warn(paint('yellow', `[linked] ${dep.packageName} is installed ${copies.length} times (${list}); loaded ${dep.path}. Run npm dedupe.`));
+    }
+    /**
+     * The directory a package's backend is resolved from: the copy discovery
+     * chose, or — for a package outside the linked tree, reached only by a lazy
+     * /call — the copy the app itself resolves.
+     */
+    packageDirFor(pkg) {
+        var _a;
+        const known = (_a = this.linkedPackageDirs) === null || _a === void 0 ? void 0 : _a.get(pkg);
+        if (known)
+            return known;
+        const installed = readInstalledPackage(pkg, process.cwd());
+        if (!installed)
+            return null;
+        try {
+            return fsNative.realpathSync(installed.root);
+        }
+        catch (_b) {
+            return installed.root;
+        }
+    }
     /**
      * Index a package's backend providers once. Shared by boot and the lazy
      * path in callBackendMethod / callShapeMethod. `onSourceChange` bypasses it
@@ -675,8 +739,8 @@ let LinkedServer = class LinkedServer extends Shape {
         }
     }
     /**
-     * Node's `import()`, as a method so a test can resolve a fixture app's
-     * node_modules (a test runner resolves bare specifiers from this file).
+     * Node's `import()`. Called with the absolute file URL of a resolved backend
+     * entry (see resolveBackendEntry), never a bare name.
      */
     importModule(specifier) {
         return import(/* @vite-ignore */ specifier);
@@ -1008,19 +1072,11 @@ let LinkedServer = class LinkedServer extends Shape {
             }
         }
     }
-    async indexPackageBackendProviders(pkg, warnIfNotFound = false, backendIndexFilePath) {
-        var _a, _b;
-        if (!backendIndexFilePath) {
-            backendIndexFilePath = `${pkg}/backend`;
-        }
+    async indexPackageBackendProviders(pkg, warnIfNotFound = false) {
+        var _a, _b, _c, _d;
         let backendProviderExports;
-        let genericBackendProvider;
+        let genericBackendProvider = null;
         let shapeProviders = [];
-        // Plan-010 phase 4/5: when Vite SSR is active, route module loading
-        // through vite.ssrLoadModule. This handles the case where the user app
-        // is the consuming workspace itself (self-reference like
-        // @semantu/create-now/backend), which Node's ESM resolver can't resolve
-        // from inside an installed package like @_linked/server.
         const vite = (_a = this.config.server) === null || _a === void 0 ? void 0 : _a.vite;
         // In dev, load a package's backend with the loader that owns the package
         // (see isBundledBySsr): Vite for the app itself and for what the SSR
@@ -1032,126 +1088,114 @@ let LinkedServer = class LinkedServer extends Shape {
             typeof vite.ssrLoadModule === 'function' &&
             (pkg === ((_b = this.package) === null || _b === void 0 ? void 0 : _b.name) ||
                 isBundledBySsr(pkg, ssrNoExternalOf(vite)));
-        const loadModule = async (specifier) => {
-            var _a, _b, _c;
+        // Decide whether there IS a backend before importing anything. A package
+        // without one is the normal case (most linked packages have none) and is
+        // quiet; once a backend file is known to exist, any failure to load it is
+        // a real error. This used to be decided after the fact, by matching the
+        // loader's error text — which Node and Vite word differently, so a nested
+        // package's "Cannot find package" was reported as a broken backend.
+        let entry = null;
+        let load = null;
+        if (pkg === ((_c = this.package) === null || _c === void 0 ? void 0 : _c.name)) {
+            // The app's own backend cannot be imported by name: a self-reference
+            // resolves only from inside the package that declares it, and this code
+            // lives in node_modules/@_linked/server. Load it by path.
+            const cwd = process.cwd();
             if (viteOwnsPackage) {
-                // For the user app's own backend, resolve to ./src/backend.ts directly.
-                // Vite reads the app's package.json exports.development condition.
-                if (specifier === `${this.package.name}/backend`) {
-                    return await vite.ssrLoadModule('/src/backend.ts');
+                const source = path.join(cwd, 'src', 'backend.ts');
+                if (fsNative.existsSync(source)) {
+                    entry = source;
+                    load = () => vite.ssrLoadModule('/src/backend.ts');
                 }
-                // Plan-011: ssr.external is now an npm-only allowlist. Workspace
-                // packages MUST go through Vite's SSR loader so they share the
-                // same module instance as everything else in the SSR call graph
-                // (otherwise we get duplicate React contexts, duplicate Linked
-                // package registrations, etc).
-                //
-                // Pre-check whether the specifier actually resolves before
-                // calling ssrLoadModule — many packages have no `/backend`
-                // export, and ssrLoadModule logs a "Failed to load url" error
-                // INTERNALLY before throwing, which spams stdout even when the
-                // surrounding catch handles it. pluginContainer.resolveId is
-                // quiet: it returns null when no plugin can resolve the id.
+            }
+            else {
+                entry = (_d = [
+                    path.join(cwd, 'lib', 'backend.js'),
+                    path.join(cwd, 'src', 'backend.ts'),
+                ].find((f) => fsNative.existsSync(f))) !== null && _d !== void 0 ? _d : null;
+                if (entry) {
+                    const url = pathToFileURL(entry).href;
+                    load = () => this.importModule(url);
+                }
+            }
+        }
+        else {
+            const dir = this.packageDirFor(pkg);
+            let json = null;
+            if (dir) {
                 try {
-                    const resolved = await ((_b = (_a = vite.pluginContainer) === null || _a === void 0 ? void 0 : _a.resolveId) === null || _b === void 0 ? void 0 : _b.call(_a, specifier));
-                    if (!resolved) {
-                        // Synthesise the same error shape the catch expects so the
-                        // "no backend export, that's fine" branch fires.
-                        const err = new Error(`Failed to load url ${specifier} (resolved id: ${specifier}). Does the file exist?`);
-                        throw err;
-                    }
+                    json = JSON.parse(fsNative.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
                 }
-                catch (e) {
-                    // If the pre-check itself errored (e.g. plugin threw on a
-                    // pkg name it doesn't know), let the call below surface the
-                    // real error path.
-                    if (!((_c = e === null || e === void 0 ? void 0 : e.message) === null || _c === void 0 ? void 0 : _c.includes('Failed to load url'))) {
-                        // fall through to ssrLoadModule which will throw + log
-                    }
-                    else {
-                        throw e;
+                catch (_e) { }
+            }
+            if (dir && json) {
+                if (viteOwnsPackage) {
+                    // Vite resolves a bundled package with the `development` condition
+                    // (a workspace's `./backend` may point at src only there). It is
+                    // still loaded by its bare name, so it is the same module id the
+                    // rest of the SSR graph imports.
+                    entry = resolveBackendEntry(dir, json, [
+                        'development',
+                        ...NODE_IMPORT_CONDITIONS,
+                    ]);
+                    if (entry)
+                        load = () => vite.ssrLoadModule(`${pkg}/backend`);
+                }
+                else {
+                    // Node caches ESM by resolved real file URL, and a bare import of
+                    // `<pkg>/backend` from the app resolves to this same real path — so
+                    // loading it by URL yields the instance the app's own imports get.
+                    entry = resolveBackendEntry(dir, json, NODE_IMPORT_CONDITIONS);
+                    if (entry) {
+                        const url = pathToFileURL(entry).href;
+                        load = () => this.importModule(url);
                     }
                 }
-                return await vite.ssrLoadModule(specifier);
             }
-            // Node path: production runtime, or a package the dev SSR runner
-            // leaves external.
-            //
-            // The app's own backend cannot be imported by name here. A self-reference
-            // resolves only from inside the package that declares it, and this code
-            // lives in node_modules/@_linked/server — so Node reports
-            // `Cannot find package '<app>'` and every one of the app's Providers
-            // silently fails to register. The Vite branch above already works around
-            // this; the compiled runtime needs the same treatment, by path.
-            if (specifier === `${this.package.name}/backend`) {
-                const compiled = path.join(process.cwd(), 'lib', 'backend.js');
-                const source = path.join(process.cwd(), 'src', 'backend.ts');
-                const target = fsNative.existsSync(compiled) ? compiled : source;
-                return await import(/* @vite-ignore */ pathToFileURL(target).href);
+        }
+        if (!load) {
+            if (warnIfNotFound) {
+                console.warn(paint('magenta', `Could not find backend file of package ${pkg}. 
+        Check:\n
+          - Make sure backend.ts exists and is included in tsconfig.json\n
+          - Make sure the package name in src/package.ts matches the package name in package.json`));
             }
-            // Fall back to Node's resolver. The dynamic specifier is intentional.
-            return await this.importModule(specifier);
-        };
-        await loadModule(backendIndexFilePath)
-            .then((backendProviderExports) => {
-            //instantiate the exported provider classes and add them to the right place
-            Object.keys(backendProviderExports).forEach((key) => {
-                let providerClass = backendProviderExports[key];
-                //always send an instance of the express server
-                //TODO: do not create an instance, just save the class and instantiate it when needed
-                let provider = new providerClass(this.server, this);
-                if (isShapeProvider(provider)) {
-                    shapeProviders.push(provider);
-                    if (!Object.getOwnPropertyNames(provider).includes('shape')) {
-                        console.warn(paint('red', `${Object.getPrototypeOf(provider).constructor.name} in package ${pkg}
+        }
+        else {
+            // Loud, naming the package and the file, and contained: one package's
+            // broken backend does not stop the others from loading.
+            let loaded = false;
+            await runProviderHook(pkg, `backend ${entry}`, async () => {
+                backendProviderExports = await load();
+                loaded = true;
+            });
+            if (loaded) {
+                for (const key of Object.keys(backendProviderExports)) {
+                    const providerClass = backendProviderExports[key];
+                    let provider;
+                    //always send an instance of the express server
+                    //TODO: do not create an instance, just save the class and instantiate it when needed
+                    await runProviderHook(pkg, `${key} constructor`, () => {
+                        provider = new providerClass(this.server, this);
+                    });
+                    if (!provider)
+                        continue;
+                    if (isShapeProvider(provider)) {
+                        shapeProviders.push(provider);
+                        if (!Object.getOwnPropertyNames(provider).includes('shape')) {
+                            console.warn(paint('red', `${Object.getPrototypeOf(provider).constructor.name} in package ${pkg}
                is not properly linked to a shape. Use public shape = SomeShape.`));
+                        }
                     }
-                }
-                else {
-                    if (genericBackendProvider) {
+                    else if (genericBackendProvider) {
                         console.warn(`Package ${pkg} exports two generic backend providers. Only one will work`);
                     }
                     else {
                         genericBackendProvider = provider;
                     }
                 }
-            });
-        })
-            .catch((e) => {
-            var _a;
-            // Recognize "no /backend export" failures across two loader
-            // shapes:
-            //   Node's import()             → ERR_MODULE_NOT_FOUND + "Cannot find module 'X/backend'"
-            //   Vite's ssrLoadModule()      → "Failed to load url X/backend"
-            //   package `exports` without a ./backend entry (Node + Vite)
-            //                               → 'Missing "./backend" specifier in "X" package'
-            // In either case, missing /backend on a package that doesn't
-            // ship a backend is expected; loud-error only on REAL load
-            // failures (syntax error inside an existing backend.ts, etc).
-            const nodeMatch = e.message.match(/module \'([^\']+)'/);
-            const viteMatch = e.message.match(/Failed to load url ([^\s]+)/);
-            const matchedSpec = (_a = nodeMatch === null || nodeMatch === void 0 ? void 0 : nodeMatch[1]) !== null && _a !== void 0 ? _a : viteMatch === null || viteMatch === void 0 ? void 0 : viteMatch[1];
-            const notExported = /Missing "\.\/backend" specifier in "[^"]+" package/.test(e.message);
-            let providerNotFound = notExported ||
-                (!!matchedSpec &&
-                    matchedSpec.includes('/backend') &&
-                    ((e.code === 'ERR_MODULE_NOT_FOUND' &&
-                        e.message.indexOf(`Cannot find module`) !== -1) ||
-                        e.message.indexOf('Failed to load url') !== -1));
-            if (providerNotFound) {
-                // console.warn('Error loading ' + providerPath + ': ' + e.stack);
-                if (warnIfNotFound) {
-                    console.warn(paint('magenta', `Could not find backend file of package ${pkg}. 
-        Check:\n
-          - Make sure backend.ts exists and is included in tsconfig.json\n
-          - Make sure the package name in src/package.ts matches the package name in package.json`));
-                }
             }
-            else {
-                console.warn(paint('red', `Could not load backend file of module '${pkg}' from ${process.cwd()}:\n`), e.stack);
-            }
-            genericBackendProvider = null;
-        });
+        }
         this.genericProviders.set(pkg, genericBackendProvider);
         this.shapeProviders.set(pkg, shapeProviders);
         return { backendProviderExports, shapeProviders };