@_linked/server 2.18.0 → 2.20.0

package/lib/esm/shapes/LinkedServer.js

@@ -37,6 +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 { isFatalError } from '../utils/fatalError.js';
 import { discoverLinkedDependencies, isBundledBySsr, NODE_IMPORT_CONDITIONS, readInstalledPackage, resolveBackendEntry, ssrNoExternalOf, } from '../utils/linkedDependencies.js';
 /**
  * `instanceof ShapeProvider`, tolerating a second copy of server-utils.
@@ -63,16 +64,38 @@ function isShapeProvider(provider) {
  * for hooks that run for every provider (boot lifecycle hooks and per-request
  * hooks), where one provider's bug must not take down boot or every request
  * without saying which provider it was.
+ *
+ * The exception is a fatal error (see utils/fatalError): with `atBoot` it is
+ * logged and re-thrown, so the server refuses to start. Without it — the
+ * server is already serving — it is logged as fatal and contained like any
+ * other error: one provider must not take a running server down.
  */
-async function runProviderHook(pkg, hook, call) {
+async function runProviderHook(pkg, hook, call, atBoot = false) {
     var _a;
     try {
         await call();
     }
     catch (err) {
+        if (isFatalError(err)) {
+            logFatalError(pkg, hook, err, atBoot);
+            if (atBoot)
+                throw err;
+            return;
+        }
         console.error(paint('red', `[linked] ${pkg} ${hook} failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`), (err === null || err === void 0 ? void 0 : err.stack) ? `\n${err.stack}` : '');
     }
 }
+/** Log a fatal error once, at the point it was thrown (see runProviderHook). */
+function logFatalError(pkg, hook, err, atBoot) {
+    var _a, _b;
+    if (loggedFatalErrors.has(err))
+        return;
+    loggedFatalErrors.add(err);
+    console.error(paint('red', atBoot
+        ? `[linked] ${pkg} ${hook}: fatal error, refusing to start: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`
+        : `[linked] ${pkg} ${hook}: fatal error after start, server keeps running: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`), (err === null || err === void 0 ? void 0 : err.stack) ? `\n${err.stack}` : '');
+}
+const loggedFatalErrors = new WeakSet();
 import process from 'process';
 import * as React from 'react';
 import { renderToPipeableStream, renderToStaticMarkup } from 'react-dom/server';
@@ -81,7 +104,7 @@ import sharp from 'sharp';
 import { findStoredKey, resolveResizeSource, } from '../utils/resizeSource.js';
 import { Transform } from 'stream';
 import { CookieJar } from 'tough-cookie';
-import { lincdServer } from '../ontologies/lincd-server.js';
+import { server } from '../ontologies/server.js';
 import { linkedShape } from '../package.js';
 import { resolveStaticAccessURL, staticAssetURL, } from '../utils/releaseManifest.js';
 import { resolveBootstrapEntry, resolveViteMainEntry, resolveViteServingMode, } from '../utils/bootstrapEntry.js';
@@ -178,6 +201,12 @@ let LinkedServer = class LinkedServer extends Shape {
         this.warnedDuplicateInstalls = new Set();
         //from resizedFileName to full resized path (CDN or similar)
         this.resizePathsMap = new Map();
+        /**
+         * True while start() / initOnly() runs. A fatal provider error (see
+         * utils/fatalError) thrown while booting stops the boot; after it, the same
+         * error is logged and contained.
+         */
+        this.booting = false;
         if (config && typeof config !== 'string' && !('id' in config)) {
             // The absence of `id` is the runtime discriminator for a LinkedConfig;
             // the widened `{id?: string}` member of the union keeps TS from narrowing
@@ -232,6 +261,9 @@ let LinkedServer = class LinkedServer extends Shape {
         this.package = JSON.parse(fsNative.readFileSync(path.resolve(process.cwd(), 'package.json'), 'utf-8'));
     }
     async initOnly() {
+        return this.bootOrRefuse(() => this.initOnlyBoot());
+    }
+    async initOnlyBoot() {
         await this.initOntologies();
         await this.initStores();
         this.initPackage();
@@ -290,7 +322,50 @@ let LinkedServer = class LinkedServer extends Shape {
     //     return nodeURI.includes(store.namedNode.uri)
     //   })
     // }
+    /**
+     * Boot the server and listen. Rejects — and makes the process exit non-zero —
+     * when a provider throws a fatal error while booting (see utils/fatalError).
+     */
     async start() {
+        return this.bootOrRefuse(() => this.startBoot());
+    }
+    /**
+     * Run a boot with `booting` set. A fatal provider error rejects it and hands
+     * the error to exitAfterFatalStartupError; any other boot error rejects as it
+     * always did.
+     */
+    async bootOrRefuse(boot) {
+        this.booting = true;
+        try {
+            return await boot();
+        }
+        catch (err) {
+            if (isFatalError(err))
+                this.exitAfterFatalStartupError(err);
+            throw err;
+        }
+        finally {
+            this.booting = false;
+        }
+    }
+    /**
+     * Make sure a server that refused to start does not stay up as a process.
+     *
+     * start() rejects either way, so the caller can report the error. But a
+     * rejected start() does not end the process on its own: the CLI's `linked
+     * start` turns an unhandled rejection into a log line, and the Vite dev
+     * server, a store connection or a provider's timer keeps the event loop
+     * alive. So the exit code is set now — a process with nothing left running
+     * exits 1 — and, as a backstop, the process is exited after a moment, on an
+     * unref'd timer that never itself keeps the process alive.
+     *
+     * Override to embed the server somewhere that must not exit (tests).
+     */
+    exitAfterFatalStartupError(_err) {
+        process.exitCode = 1;
+        setTimeout(() => process.exit(1), 1000).unref();
+    }
+    async startBoot() {
         var _a, _b, _c, _d;
         this.initPackage();
         // Static assets should come from the static store URL (versioned path),
@@ -563,7 +638,7 @@ let LinkedServer = class LinkedServer extends Shape {
             if (!genericProvider || typeof genericProvider[method] !== 'function') {
                 continue;
             }
-            await runProviderHook(pkg, method, () => genericProvider[method](...args));
+            await runProviderHook(pkg, method, () => genericProvider[method](...args), this.booting);
         }
     }
     /**
@@ -627,6 +702,9 @@ let LinkedServer = class LinkedServer extends Shape {
             });
         }
         catch (err) {
+            // Already logged where it was thrown; it must reach start().
+            if (isFatalError(err))
+                throw err;
             console.warn(err);
         }
     }
@@ -1053,6 +1131,12 @@ let LinkedServer = class LinkedServer extends Shape {
             // console.log(`✅ Successfully loaded: ${pkg}`);
         }
         catch (e) {
+            if (isFatalError(e)) {
+                logFatalError(pkg, 'module load', e, this.booting);
+                if (this.booting)
+                    throw e;
+                return;
+            }
             let providerNotFound = e.code === 'MODULE_NOT_FOUND' &&
                 e.message.indexOf(`Cannot find package '${pkg}'`) !== -1;
             if (providerNotFound) {
@@ -1168,7 +1252,7 @@ let LinkedServer = class LinkedServer extends Shape {
             await runProviderHook(pkg, `backend ${entry}`, async () => {
                 backendProviderExports = await load();
                 loaded = true;
-            });
+            }, this.booting);
             if (loaded) {
                 for (const key of Object.keys(backendProviderExports)) {
                     const providerClass = backendProviderExports[key];
@@ -1177,7 +1261,7 @@ let LinkedServer = class LinkedServer extends Shape {
                     //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);
-                    });
+                    }, this.booting);
                     if (!provider)
                         continue;
                     if (isShapeProvider(provider)) {
@@ -1888,7 +1972,7 @@ let LinkedServer = class LinkedServer extends Shape {
 /**
  * indicates that instances of this shape need to have this rdf.type
  */
-LinkedServer.targetClass = lincdServer.LincdServer;
+LinkedServer.targetClass = server.LincdServer;
 LinkedServer = __decorate([
     linkedShape({ name: 'LinkedServer' }),
     __metadata("design:paramtypes", [Object])