@antelopejs/dms-frontend 0.3.5 → 0.3.7

package/dist/fs-sync.js

@@ -151,8 +151,7 @@ function collectFiles(dir, baseDir = dir) {
     const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = (0, node_path_1.join)(dir, entry.name);
-        const { relative } = require("node:path");
-        const relPath = relative(baseDir, fullPath);
+        const relPath = (0, node_path_1.relative)(baseDir, fullPath);
         if (entry.isDirectory()) {
             files.push(...collectFiles(fullPath, baseDir));
         }
@@ -179,12 +178,11 @@ function syncDirectories(src, dest) {
     cleanEmptyDirs(dest);
 }
 function cleanEmptyDirs(dir) {
-    const { statSync } = require("node:fs");
-    if (!(0, node_fs_1.existsSync)(dir) || !statSync(dir).isDirectory())
+    if (!(0, node_fs_1.existsSync)(dir) || !(0, node_fs_1.statSync)(dir).isDirectory())
         return;
     for (const entry of (0, node_fs_1.readdirSync)(dir)) {
         const full = (0, node_path_1.join)(dir, entry);
-        if (statSync(full).isDirectory())
+        if ((0, node_fs_1.statSync)(full).isDirectory())
             cleanEmptyDirs(full);
     }
     if ((0, node_fs_1.readdirSync)(dir).length === 0) {

package/dist/manifest.d.ts

@@ -4,6 +4,9 @@ export declare class ManifestUnauthorizedError extends Error {
     readonly status: number;
     constructor(url: string, status: number);
 }
+export declare class ManifestRefusedError extends Error {
+    constructor(reason: string);
+}
 export declare function fetchManifest(backendUrl: string, clientUrl?: string, bootstrapSecret?: string): Promise<Manifest>;
 export interface ManifestCacheEntry {
     manifest: Manifest;

package/dist/manifest.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManifestUnauthorizedError = void 0;
+exports.ManifestRefusedError = exports.ManifestUnauthorizedError = void 0;
 exports.fetchManifest = fetchManifest;
 exports.readCachedManifest = readCachedManifest;
 exports.resolveManifest = resolveManifest;
@@ -22,6 +22,13 @@ class ManifestUnauthorizedError extends Error {
     }
 }
 exports.ManifestUnauthorizedError = ManifestUnauthorizedError;
+class ManifestRefusedError extends Error {
+    constructor(reason) {
+        super(reason);
+        this.name = "ManifestRefusedError";
+    }
+}
+exports.ManifestRefusedError = ManifestRefusedError;
 async function fetchManifest(backendUrl, clientUrl, bootstrapSecret) {
     const frontendUrl = new URL(`${backendUrl}/dms/frontend`);
     frontendUrl.searchParams.set("renderer", "vue");
@@ -40,11 +47,11 @@ async function fetchManifest(backendUrl, clientUrl, bootstrapSecret) {
     }
     const manifest = (await response.json());
     if (manifest.version !== workspace_1.FRONTEND_MANIFEST_VERSION) {
-        throw new Error(`Unsupported frontend manifest version: ${String(manifest.version)}`);
+        throw new ManifestRefusedError(`Unsupported frontend manifest version: ${String(manifest.version)}`);
     }
     const incompatible = manifest.modules.filter((module) => module.renderer?.name !== "vue" || module.renderer?.version !== "3");
     if (incompatible.length) {
-        throw new Error(`Frontend manifest contains incompatible renderer modules: ${incompatible.map((module) => module.name).join(", ")}`);
+        throw new ManifestRefusedError(`Frontend manifest contains incompatible renderer modules: ${incompatible.map((module) => module.name).join(", ")}`);
     }
     return { pack: manifest.archive, modules: manifest.modules };
 }
@@ -80,6 +87,8 @@ async function resolveManifest(workspaceDir, backendUrl, offline, clientUrl, boo
         catch (err) {
             if (err instanceof ManifestUnauthorizedError)
                 throw err;
+            if (err instanceof ManifestRefusedError)
+                throw err;
             const cached = readCachedManifest(workspaceDir);
             if (!cached)
                 throw err;

package/dist/ports.js

@@ -19,7 +19,7 @@ async function reserveFreePort(preferred, range = exports.PORT_FALLBACK_RANGE) {
         const server = await tryListen(port);
         if (server) {
             return {
-                port,
+                port: server.address().port,
                 release: () => new Promise((resolve) => {
                     server.close(() => resolve());
                 }),

package/dist/renderer-range.js

@@ -8,9 +8,14 @@ const semver_1 = __importDefault(require("semver"));
 const layers_1 = require("./layers");
 const OWN_RELEASE = require("../package.json");
 const noticedModules = new Set();
+function moduleLabel(layer) {
+    if (!layer.packageName)
+        return layer.path;
+    return `${layer.packageName} (${layer.path})`;
+}
 function declaredRange(layer, rendererName) {
     return {
-        module: layer.packageName ?? layer.path,
+        module: moduleLabel(layer),
         range: (0, layers_1.readLayerPackage)(layer.path)?.engines?.[rendererName],
     };
 }

package/dist/verify-source-runner.js

@@ -74,7 +74,13 @@ const layers = roots.map((root) => ({
     packageName: JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(root, "package.json"), "utf8"))
         .name,
 }));
-(0, common_1.assertLayersSupportRenderer)(layers);
+try {
+    (0, common_1.assertLayersSupportRenderer)(layers);
+}
+catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+}
 (0, common_1.materializeLayers)(workspace, layers);
 const registry = (0, common_1.createFrontendModuleRegistry)(workspace, layers);
 registry.modules.forEach((module) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-frontend",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Frontend-agnostic loader for AntelopeJS DMS, shipping the Vue 3 renderer (Vite, Inertia, SSR)",
   "keywords": [
     "antelope",

package/templates/vue/frontend-module.ts

@@ -906,9 +906,6 @@ export function useDmsRuntimeConfig(): DmsRuntimeConfig {
 export function useDmsAppConfig(): DmsAppConfig {
   return appConfig.value as DmsAppConfig;
 }
-export function configureDmsRuntime(config: DmsRuntimeConfig): void {
-  runtimeConfig.value = config;
-}
 export function defineAppConfig<T extends Record<string, unknown>>(
   config: T,
 ): T {
@@ -934,14 +931,6 @@ export function defineDmsPageMeta(meta: Record<string, unknown>): void {
 export function abortNavigation(): false {
   return false;
 }
-export function addDmsMiddleware(
-  handler: DmsMiddleware,
-  name?: string,
-  isGlobal = false,
-): void {
-  if (isGlobal) registry.middleware.push(handler);
-  else if (name) registry.namedMiddleware.set(name, handler);
-}
 export const useHead = useUnhead;
 export const useSeoMeta = useUnheadSeoMeta;
 export function useI18n(): DmsI18n {

package/templates/vue/server/client-error.mjs

@@ -0,0 +1,41 @@
+// Answers for requests Node rejects before the request handler runs. Without
+// a `clientError` listener Node answers on its own and logs nothing, so a page
+// refused for its headers left no trace in the server output.
+
+const HEADER_OVERFLOW = "HPE_HEADER_OVERFLOW";
+const HEADER_OVERFLOW_RESPONSE =
+  "HTTP/1.1 431 Request Header Fields Too Large\r\nConnection: close\r\n\r\n";
+const BAD_REQUEST_RESPONSE =
+  "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n";
+// A browser retries a refused page with the same cookies: one hint per minute
+// is enough to explain them all.
+const HEADER_OVERFLOW_HINT_INTERVAL_MS = 60_000;
+
+let lastHeaderOverflowHint = -Infinity;
+
+function warnHeaderOverflow(maxHeaderSize) {
+  const now = Date.now();
+  if (now - lastHeaderOverflowHint < HEADER_OVERFLOW_HINT_INTERVAL_MS) return;
+  lastHeaderOverflowHint = now;
+  console.warn(
+    `DMS refused a request with 431: its headers exceed the ${maxHeaderSize}-byte limit. ` +
+      "This is most often cookies accumulated on this host (browsers share " +
+      "localhost cookies across ports); clear this site's cookies and reload.",
+  );
+}
+
+/**
+ * The server's `clientError` listener: explains a 431 in the logs, and
+ * otherwise answers as Node does without a listener.
+ */
+export function handleClientError(error, socket, maxHeaderSize) {
+  let response = BAD_REQUEST_RESPONSE;
+  if (error.code === HEADER_OVERFLOW) {
+    response = HEADER_OVERFLOW_RESPONSE;
+    warnHeaderOverflow(maxHeaderSize);
+  }
+  // Once a response went out on this connection, a status line would land in
+  // the middle of it.
+  if (socket.writable && socket.bytesWritten === 0) socket.write(response);
+  socket.destroy();
+}

package/templates/vue/server/vite-errors.mjs

@@ -0,0 +1,50 @@
+const INTERNAL_ERROR_STATUS = 500;
+const ERROR_CONTENT_TYPE = "text/plain; charset=utf-8";
+const VITE_ERROR = Symbol("dms.viteError");
+
+/**
+ * In middleware mode, Vite's own error middleware logs an error, sends it to
+ * the client overlay, then passes the request on with no error: a module that
+ * fails to transform would fall through to page handling and answer 404. This
+ * plugin runs just before it, keeps the error on the request and hands it on,
+ * so Vite still logs it and shows the overlay.
+ */
+export function captureViteErrors() {
+  return {
+    name: "dms-capture-vite-errors",
+    apply: "serve",
+    configureServer(server) {
+      return () =>
+        server.middlewares.use((error, request, _response, next) => {
+          request[VITE_ERROR] = error;
+          next(error);
+        });
+    },
+  };
+}
+
+/**
+ * Hands a request to Vite's middlewares. Resolves `handled` once Vite answered
+ * it, `unhandled` when Vite passed it on, and `failed` with the error when a
+ * Vite middleware failed on it.
+ */
+export function runViteMiddlewares(devServer, request, response) {
+  return new Promise((resolve) => {
+    devServer.middlewares(request, response, (error) => {
+      const failure = error ?? request[VITE_ERROR];
+      resolve(
+        failure
+          ? { status: "failed", error: failure }
+          : { status: "unhandled" },
+      );
+    });
+    response.once("finish", () => resolve({ status: "handled" }));
+  });
+}
+
+/** Answers 500 with Vite's error message instead of rendering a page. */
+export function writeViteError(response, error) {
+  response.statusCode = INTERNAL_ERROR_STATUS;
+  response.setHeader("content-type", ERROR_CONTENT_TYPE);
+  response.end(error?.message ?? String(error));
+}

package/templates/vue/server.mjs

@@ -1,5 +1,5 @@
 import { createReadStream, existsSync, readFileSync, statSync } from "node:fs";
-import { createServer } from "node:http";
+import { createServer, maxHeaderSize } from "node:http";
 import { extname, join, resolve, sep } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -19,8 +19,14 @@ import {
   redirectAccessRefusal,
   UNEXPECTED_ERROR_BODY,
 } from "./server/backend-response.mjs";
+import { handleClientError } from "./server/client-error.mjs";
 import { productionHtmlTemplate } from "./server/client-manifest.mjs";
 import { writeContent } from "./server/content.mjs";
+import {
+  captureViteErrors,
+  runViteMiddlewares,
+  writeViteError,
+} from "./server/vite-errors.mjs";
 import { documentStyleTags } from "./server/dev-styles.mjs";
 import { handleEmailRender, watchEmailBundle } from "./server/email.mjs";
 import { HOMEPAGE } from "./server/homepage.mjs";
@@ -88,7 +94,11 @@ async function developmentServer() {
       const serverOptions = { middlewareMode: true };
       if (frontendHttpServer)
         serverOptions.hmr = { server: frontendHttpServer };
-      return createViteServer({ server: serverOptions, appType: "custom" });
+      return createViteServer({
+        server: serverOptions,
+        appType: "custom",
+        plugins: [captureViteErrors()],
+      });
     })
     .then((server) => {
       vite = server;
@@ -385,6 +395,12 @@ async function writeBackendError(error, request, response) {
   response.end(JSON.stringify(payload));
 }
 
+async function answeredByVite(devServer, request, response) {
+  const result = await runViteMiddlewares(devServer, request, response);
+  if (result.status === "failed") writeViteError(response, result.error);
+  return result.status !== "unhandled";
+}
+
 export async function handleRequest(request, response) {
   const url = new URL(request.url, "http://frontend.local");
   const pathname = url.pathname;
@@ -409,11 +425,7 @@ export async function handleRequest(request, response) {
     return;
   const devServer = await developmentServer();
   if (devServer && pathname !== "/") {
-    const handled = await new Promise((resolve) => {
-      devServer.middlewares(request, response, () => resolve(false));
-      response.once("finish", () => resolve(true));
-    });
-    if (handled) return;
+    if (await answeredByVite(devServer, request, response)) return;
   }
   if (!devServer && serveAsset(pathname, request, response)) return;
   if (handleAssetVersionMismatch(request, response)) return;
@@ -478,6 +490,9 @@ if (
   import.meta.url === new URL(`file://${process.argv[1]}`).href
 ) {
   frontendHttpServer = createServer(handleRequestSafely);
+  frontendHttpServer.on("clientError", (error, socket) =>
+    handleClientError(error, socket, maxHeaderSize),
+  );
   frontendHttpServer.listen(
     Number(process.env.PORT ?? 3001),
     process.env.HOST ?? "0.0.0.0",