solidstep 0.3.4 → 0.4.0

package/utils/middleware.js

@@ -0,0 +1,48 @@
+// utils/middleware.ts
+// Composable middleware for SolidStep.
+//
+// Vinxi/H3 only allow a single middleware module per router. This helper lets
+// you split request/response concerns (auth, CORS, CSRF, logging, ...) into
+// independent units and compose them into one Vinxi-compatible middleware.
+import { defineMiddleware as defineVinxiMiddleware } from 'vinxi/http';
+/**
+ * Compose an ordered array of middleware into a single Vinxi middleware object.
+ *
+ * `onRequest` hooks run in array order and stop as soon as one returns a
+ * `Response` or marks the event handled. `onBeforeResponse` hooks always all
+ * run, in array order.
+ *
+ * @example
+ * ```ts
+ * // app/middleware.ts
+ * import { defineMiddleware } from 'solidstep/utils/middleware';
+ *
+ * export default defineMiddleware([
+ *   authMiddleware,
+ *   corsMiddleware,
+ *   csrfMiddleware,
+ * ]);
+ * ```
+ */
+export const defineMiddleware = (middlewares) => defineVinxiMiddleware({
+    onRequest: async (event) => {
+        for (const middleware of middlewares) {
+            if (!middleware.onRequest)
+                continue;
+            const result = await middleware.onRequest(event);
+            if (result instanceof Response) {
+                await event.respondWith(result);
+                return;
+            }
+            if (event.handled)
+                return;
+        }
+    },
+    onBeforeResponse: async (event, response) => {
+        for (const middleware of middlewares) {
+            if (!middleware.onBeforeResponse)
+                continue;
+            await middleware.onBeforeResponse(event, response);
+        }
+    },
+});

package/utils/path-router.js

@@ -38,17 +38,17 @@ export const insertRoute = (root, path, handler) => {
             node = node.paramChild.node;
             continue;
         }
-        if (parsed.type === 'catchAll') {
-            if (!node.catchAllChild) {
-                node.catchAllChild = {
-                    name: parsed.name,
-                    optional: parsed.optional,
-                    node: createNode()
-                };
-            }
-            node = node.catchAllChild.node;
-            break; // catch-all always consumes the rest
+        // Only catchAll segments reach here — static and param both continue above
+        const catchAll = parsed;
+        if (!node.catchAllChild) {
+            node.catchAllChild = {
+                name: catchAll.name,
+                optional: catchAll.optional,
+                node: createNode()
+            };
         }
+        node = node.catchAllChild.node;
+        break; // catch-all always consumes the rest
     }
     node.handler = handler;
 };

package/utils/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../utils/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAa,MAAM,iBAAiB,CAAC;AAElE,qBAAa,YAAa,SAAQ,oBAAoB;IAClD,MAAM,CAAC,GAAG,EAAE,MAAM;IAQlB,OAAO,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4K3B;AAED,qBAAa,YAAa,SAAQ,oBAAoB;IAClD,MAAM,CAAC,GAAG,EAAE,MAAM;IAQlB,OAAO,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;CAiF3B"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../utils/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAa,MAAM,iBAAiB,CAAC;AAElE,qBAAa,YAAa,SAAQ,oBAAoB;IAClD,MAAM,CAAC,GAAG,EAAE,MAAM;IAQlB,OAAO,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4K3B;AAED,qBAAa,YAAa,SAAQ,oBAAoB;IAClD,MAAM,CAAC,GAAG,EAAE,MAAM;IAQlB,OAAO,CAAC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;CAmF3B"}

package/utils/router.js

@@ -249,7 +249,9 @@ export class ClientRouter extends BaseFileSystemRouter {
                 path: `/not-found${path}`,
                 $component: {
                     src: filePath,
-                    pick: ['default'],
+                    // Include `$css` so the client manifest has the same variant
+                    // the server looks up when rendering the not-found page.
+                    pick: ['default', '$css'],
                 },
             };
         }

package/utils/server-action.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-action.server.d.ts","sourceRoot":"","sources":["../../utils/server-action.server.ts"],"names":[],"mappings":"AAgBA,OAAO,EAIN,KAAK,SAAS,EAWd,MAAM,YAAY,CAAC;AAuHpB,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,SAAS,oBA2M1D;;AAED,wBAAkD"}
+{"version":3,"file":"server-action.server.d.ts","sourceRoot":"","sources":["../../utils/server-action.server.ts"],"names":[],"mappings":"AAoBA,OAAO,EAIH,KAAK,SAAS,EAWjB,MAAM,YAAY,CAAC;AA4IpB,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,SAAS,oBA4Q1D;;AAED,wBAAkD"}

package/utils/server-action.server.js

@@ -1,15 +1,16 @@
 /// <reference types='vinxi/types/server' />
-import { crossSerializeStream, fromJSON, getCrossReferenceHeader } from 'seroval';
-import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin } from 'seroval-plugins/web';
+import { crossSerializeStream, fromJSON, getCrossReferenceHeader, } from 'seroval';
+import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin, } from 'seroval-plugins/web';
 import { sharedConfig } from 'solid-js';
 import { provideRequestEvent } from 'solid-js/web/storage';
-import { eventHandler, setHeader, setResponseStatus, appendResponseHeader, toWebRequest, getWebRequest, getRequestIP, getResponseStatus, getResponseStatusText, getResponseHeader, getResponseHeaders, removeResponseHeader, setResponseHeader } from 'vinxi/http';
+import { eventHandler, setHeader, setResponseStatus, appendResponseHeader, toWebRequest, getWebRequest, getRequestIP, getResponseStatus, getResponseStatusText, getResponseHeader, getResponseHeaders, removeResponseHeader, setResponseHeader, } from 'vinxi/http';
 import invariant from 'vinxi/lib/invariant';
 import { getManifest } from 'vinxi/manifest';
 import { RedirectError } from './redirect';
 import { createDiffDOM } from './diff-dom';
 import { getCache, invalidateCache } from './cache';
 import fetch from './fetch.server';
+import { createRequestContext, createResponseContext, getInstrumentation, safeExecuteHook, } from '../utils/instrumentation';
 function createChunk(data) {
     const encodeData = new TextEncoder().encode(data);
     const bytes = encodeData.length;
@@ -36,19 +37,21 @@ function serializeToStream(id, value) {
                     RequestPlugin,
                     ResponsePlugin,
                     URLSearchParamsPlugin,
-                    URLPlugin
+                    URLPlugin,
                 ],
                 onSerialize(data, initial) {
-                    controller.enqueue(createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data));
+                    controller.enqueue(createChunk(initial
+                        ? `(${getCrossReferenceHeader(id)},${data})`
+                        : data));
                 },
                 onDone() {
                     controller.close();
                 },
                 onError(error) {
                     controller.error(error);
-                }
+                },
             });
-        }
+        },
     });
 }
 class HeaderProxy {
@@ -88,7 +91,7 @@ class HeaderProxy {
     }
     values() {
         return Object.values(getResponseHeaders(this.event))
-            .map(value => (Array.isArray(value) ? value.join(', ') : value))[Symbol.iterator]();
+            .map((value) => Array.isArray(value) ? value.join(', ') : value)[Symbol.iterator]();
     }
     [Symbol.iterator]() {
         return this.entries()[Symbol.iterator]();
@@ -108,14 +111,20 @@ function createResponseStub(event) {
         set statusText(v) {
             setResponseStatus(event, getResponseStatus(event), v);
         },
-        headers: new HeaderProxy(event)
+        headers: new HeaderProxy(event),
     };
 }
 export async function handleServerFunction(event) {
     const request = toWebRequest(event);
+    const url = new URL(request.url);
+    const inst = getInstrumentation();
+    const reqCtx = createRequestContext(request, {
+        routePath: url.pathname,
+        routeType: 'server-action',
+    });
+    await safeExecuteHook('onRequest', inst?.onRequest, request, reqCtx);
     const serverReference = request.headers.get('X-Server-Id');
     const instance = request.headers.get('X-Server-Instance');
-    const url = new URL(request.url);
     let functionId;
     let name;
     if (serverReference) {
@@ -150,8 +159,8 @@ export async function handleServerFunction(event) {
                         RequestPlugin,
                         ResponsePlugin,
                         URLSearchParamsPlugin,
-                        URLPlugin
-                    ]
+                        URLPlugin,
+                    ],
                 })
                 : json).forEach((arg) => parsed.push(arg));
         }
@@ -164,7 +173,9 @@ export async function handleServerFunction(event) {
         const isReadableStream = h3Request instanceof ReadableStream;
         const hasReadableStream = h3Request.body instanceof ReadableStream;
         const isH3EventBodyStreamLocked = (isReadableStream && h3Request.locked) ||
-            (hasReadableStream && h3Request.body.locked);
+            (hasReadableStream &&
+                h3Request.body
+                    .locked);
         const requestBody = isReadableStream ? h3Request : h3Request.body;
         if (contentType?.startsWith('multipart/form-data') ||
             contentType?.startsWith('application/x-www-form-urlencoded')) {
@@ -195,8 +206,8 @@ export async function handleServerFunction(event) {
                     RequestPlugin,
                     ResponsePlugin,
                     URLSearchParamsPlugin,
-                    URLPlugin
-                ]
+                    URLPlugin,
+                ],
             });
         }
     }
@@ -206,14 +217,23 @@ export async function handleServerFunction(event) {
             response: createResponseStub(event),
             clientAddress: getRequestIP(event),
             locals: {},
-            nativeEvent: event
+            nativeEvent: event,
         }, async () => {
             sharedConfig.context = { event };
             event.locals.serverFunctionMeta = {
-                id: `${functionId}#${name}`
+                id: `${functionId}#${name}`,
             };
             return serverFunction(...parsed);
         });
+        // No-JS fallback: native form submission without client-side JS
+        // When there's no X-Server-Instance header, this is a plain form POST.
+        // Execute the action and redirect back to the referring page.
+        if (!instance) {
+            const referer = request.headers.get('Referer') || '/';
+            setResponseStatus(event, 303);
+            setHeader(event, 'Location', referer);
+            return '';
+        }
         // handle responses
         if (result instanceof Response) {
             if (result.headers?.has('X-Content-Raw'))
@@ -222,7 +242,8 @@ export async function handleServerFunction(event) {
                 // forward headers
                 // if (result.headers) mergeResponseHeaders(event, result.headers);
                 // forward non-redirect statuses
-                if (result.status && (result.status < 300 || result.status >= 400))
+                if (result.status &&
+                    (result.status < 300 || result.status >= 400))
                     setResponseStatus(event, result.status);
                 if (result.customBody) {
                     result = await result.customBody();
@@ -245,14 +266,14 @@ export async function handleServerFunction(event) {
                 const reqUrl = new URL(request.url);
                 const serverUrl = reqUrl.origin;
                 const response = await fetch(serverUrl + revalidatePath, {
-                    method: 'GET'
+                    method: 'GET',
                 }, false);
                 await response.text(); // ensure the fetch is completed and cache is populated
                 const newCacheValue = getCache(revalidatePath);
                 const newHtml = newCacheValue?.rendered;
                 const dd = createDiffDOM({
                     skipSelector: 'SCRIPT, STYLE, NOSCRIPT',
-                    skipMode: 'full'
+                    skipMode: 'full',
                 });
                 const ddDiff = dd.diff(oldHtml, newHtml);
                 diff = structuredClone(ddDiff);
@@ -267,11 +288,15 @@ export async function handleServerFunction(event) {
         return serializeToStream(instance, result);
     }
     catch (x) {
+        await safeExecuteHook('onRequestError', inst?.onRequestError, x instanceof Error ? x : new Error(String(x)), request, reqCtx);
         if (x instanceof Response) {
             // forward headers
             // if ((x as any).headers) mergeResponseHeaders(event, (x as any).headers);
             // forward non-redirect statuses
-            if (x.status && (!instance || x.status < 300 || x.status >= 400))
+            if (x.status &&
+                (!instance ||
+                    x.status < 300 ||
+                    x.status >= 400))
                 setResponseStatus(event, x.status);
             if (x.customBody) {
                 // biome-ignore lint/suspicious/noCatchAssign: <explanation>
@@ -283,7 +308,11 @@ export async function handleServerFunction(event) {
             setHeader(event, 'X-Error', 'true');
         }
         else if (instance) {
-            const error = x instanceof Error ? x.message : typeof x === 'string' ? x : 'true';
+            const error = x instanceof Error
+                ? x.message
+                : typeof x === 'string'
+                    ? x
+                    : 'true';
             setHeader(event, 'X-Error', error.replace(/[\r\n]+/g, ''));
             if (!(x instanceof RedirectError)) {
                 setResponseStatus(event, 500);
@@ -295,5 +324,10 @@ export async function handleServerFunction(event) {
         }
         return x;
     }
+    finally {
+        const statusCode = getResponseStatus(event) || 200;
+        const respCtx = createResponseContext(reqCtx, statusCode);
+        await safeExecuteHook('onResponseEnd', inst?.onResponseEnd, request, respCtx);
+    }
 }
 export default eventHandler(handleServerFunction);