@solidjs/start 0.4.11 → 0.5.1

package/config/fs-router.js

@@ -24,7 +24,6 @@ export class SolidStartClientFileRouter extends BaseFileSystemRouter {
 
     if (src.endsWith(".md") || src.endsWith(".mdx")) {
       return {
-        type: "page",
         $component: {
           src: src,
           pick: ["$css"]
@@ -40,7 +39,6 @@ export class SolidStartClientFileRouter extends BaseFileSystemRouter {
     const hasRouteConfig = exports.find(e => e.n === "route");
     if (hasDefault) {
       return {
-        type: "page",
         $component: {
           src: src,
           pick: ["default", "$css"]
@@ -57,6 +55,7 @@ export class SolidStartClientFileRouter extends BaseFileSystemRouter {
     }
   }
 }
+
 const HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH"];
 function createHTTPHandlers(src, exports) {
   const handlers = {};
@@ -70,6 +69,7 @@ function createHTTPHandlers(src, exports) {
   }
   return handlers;
 }
+
 export class SolidStartServerFileRouter extends BaseFileSystemRouter {
   toPath(src) {
     const routePath = cleanPath(src, this.config)
@@ -91,10 +91,8 @@ export class SolidStartServerFileRouter extends BaseFileSystemRouter {
 
   toRoute(src) {
     let path = this.toPath(src);
-
     if (src.endsWith(".md") || src.endsWith(".mdx")) {
       return {
-        type: "page",
         $component: {
           src: src,
           pick: ["$css"]
@@ -107,25 +105,22 @@ export class SolidStartServerFileRouter extends BaseFileSystemRouter {
 
     const [_, exports] = analyzeModule(src);
     const hasRouteConfig = exports.find(e => e.n === "route");
-    if (exports.find(exp => exp.n === "default")) {
+    const hasDefault = exports.find(e => e.n === "default");
+    const hasAPIRoutes = exports.find(exp => HTTP_METHODS.includes(exp.n));
+    if (hasDefault || hasAPIRoutes) {
       return {
-        type: "page",
-        $component: {
-          src: src,
-          pick: ["default", "$css"]
-        },
+        $component: hasDefault
+          ? {
+              src: src,
+              pick: ["default", "$css"]
+            }
+          : undefined,
         $$route: hasRouteConfig
           ? {
               src: src,
               pick: ["route"]
             }
           : undefined,
-        path,
-        filePath: src
-      };
-    } else if (exports.find(exp => HTTP_METHODS.includes(exp.n))) {
-      return {
-        type: "api",
         ...createHTTPHandlers(src, exports),
         path,
         filePath: src

package/config/index.d.ts

@@ -9,8 +9,9 @@ type SolidStartInlineConfig = Omit<InlineConfig, "router"> & {
          * true: streaming mode
          * false: csr only
          * async: ssr is in async mode
+         * sync: ssr is in sync mode
          */
-        ssr?: boolean | "async",
+        ssr?: boolean | "async" | "sync",
         solid?: Options,
         extensions?: string[],
         server?: AppOptions['server'],

package/config/index.js

@@ -8,7 +8,10 @@ import { createApp, resolve } from "vinxi";
 import { normalize } from "vinxi/lib/path";
 import { config } from "vinxi/plugins/config";
 import solid from "vite-plugin-solid";
-import { SolidStartClientFileRouter, SolidStartServerFileRouter } from "./fs-router.js";
+import {
+  SolidStartClientFileRouter,
+  SolidStartServerFileRouter
+} from "./fs-router.js";
 import { serverComponents } from "./server-components.js";
 
 const DEFAULT_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
@@ -18,7 +21,7 @@ function solidStartClientFsRouter(config) {
     new SolidStartClientFileRouter(
       {
         dir: resolve.absolute(config.dir, router.root),
-        extensions: config.extensions ?? ["js", "jsx", "ts", "tsx"]
+        extensions: config.extensions ?? DEFAULT_EXTENSIONS
       },
       router,
       app
@@ -30,7 +33,7 @@ function solidStartServerFsRouter(config) {
     new SolidStartServerFileRouter(
       {
         dir: resolve.absolute(config.dir, router.root),
-        extensions: config.extensions ?? ["js", "jsx", "ts", "tsx"]
+        extensions: config.extensions ?? DEFAULT_EXTENSIONS
       },
       router,
       app
@@ -44,7 +47,12 @@ export function defineConfig(baseConfig = {}) {
     appRoot: "./src",
     ssr: true,
     islands: false,
-    solid: {}
+    solid: {},
+    server: {
+      experimental: {
+        asyncContext: true
+      }
+    }
   });
   let server = start.server;
   if (!start.ssr) {
@@ -65,16 +73,15 @@ export function defineConfig(baseConfig = {}) {
     routers: [
       {
         name: "public",
-        mode: "static",
+        type: "static",
         dir: "./public",
         base: "/"
       },
-
       {
         name: "ssr",
-        mode: "handler",
+        type: "http",
         link: {
-          client: "client"
+          client: start.islands ? undefined : "client"
         },
         handler: `${start.appRoot}/entry-server${entryExtension}`,
         middleware: start.middleware,
@@ -96,7 +103,7 @@ export function defineConfig(baseConfig = {}) {
           ...(typeof plugins === "function" ? [...(await plugins())] : plugins),
 
           serverTransform({
-            runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.jsx", import.meta.url)))
+            runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.ts", import.meta.url)))
           }),
           start.islands ? serverComponents.server() : null,
           solid({ ...start.solid, ssr: true, extensions: extensions.map(ext => `.${ext}`) }),
@@ -125,7 +132,7 @@ export function defineConfig(baseConfig = {}) {
       },
       {
         name: "client",
-        mode: "build",
+        type: "client",
         handler: `${start.appRoot}/entry-client${entryExtension}`,
         ...(start.islands
           ? {}
@@ -148,7 +155,7 @@ export function defineConfig(baseConfig = {}) {
           }),
           ...(typeof plugins === "function" ? [...(await plugins())] : plugins),
           serverFunctions.client({
-            runtime: normalize(fileURLToPath(new URL("./server-runtime.jsx", import.meta.url)))
+            runtime: normalize(fileURLToPath(new URL("./server-runtime.ts", import.meta.url)))
           }),
           start.islands ? serverComponents.client() : null,
           solid({ ...start.solid, ssr: start.ssr, extensions: extensions.map(ext => `.${ext}`) }),
@@ -182,8 +189,8 @@ export function defineConfig(baseConfig = {}) {
         base: "/_build"
       },
       serverFunctions.router({
-        handler: normalize(fileURLToPath(new URL("./server-handler.js", import.meta.url))),
-        runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.jsx", import.meta.url))),
+        handler: normalize(fileURLToPath(new URL("./server-handler.ts", import.meta.url))),
+        runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.ts", import.meta.url))),
         // routes: solidStartServerFsRouter({ dir: `${start.appRoot}/routes`, extensions }),
         plugins: async () => [
           config("user", {

package/config/{server-fns-runtime.jsx → server-fns-runtime.ts}

@@ -1,6 +1,6 @@
 import { getRequestEvent } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
-import { cloneEvent } from "../server/middleware";
+import { cloneEvent } from "../server/fetchEvent";
 
 export function createServerReference(fn, id, name) {
   if (typeof fn !== "function") throw new Error("Export from a 'use server' module must be a function");

package/config/{server-handler.js → server-handler.ts}

@@ -13,11 +13,10 @@ import {
   URLSearchParamsPlugin
 } from "seroval-plugins/web";
 import { sharedConfig } from "solid-js";
-/* @ts-ignore */
 import { provideRequestEvent } from "solid-js/web/storage";
+import { eventHandler, setHeader } from "vinxi/http";
 import invariant from "vinxi/lib/invariant";
-import { eventHandler, setHeader } from "vinxi/server";
-import { getFetchEvent } from "../server/middleware";
+import { getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent";
 
 function createChunk(data) {
   const bytes = data.length;
@@ -94,13 +93,13 @@ async function handleServerFunction(h3Event) {
     ) {
       // workaround for https://github.com/unjs/nitro/issues/1721
       // (issue only in edge runtimes)
-      parsed.push(await new Request(request, { ...request, body: event.node.req.body }).formData());
+      parsed.push(await new Request(request, { ...request, body: h3Event.node.req.body }).formData());
       // what should work when #1721 is fixed 
       // parsed.push(await request.formData);
     } else {
       // workaround for https://github.com/unjs/nitro/issues/1721
       // (issue only in edge runtimes)
-      const tmpReq = new Request(request, { ...request, body: event.node.req.body })
+      const tmpReq = new Request(request, { ...request, body: h3Event.node.req.body })
       // what should work when #1721 is fixed
       // just use request.json() here
       parsed = fromJSON(await tmpReq.json(), {
@@ -137,13 +136,9 @@ async function handleServerFunction(h3Event) {
         });
       }
       // forward headers
-      if (result.headers) {
-        for (const [key, value] of result.headers.entries()) {
-          setHeader(h3Event, key, value);
-        }
-      }
-      if (result.customBody) {
-        result = await result.customBody();
+      if (result.headers) mergeResponseHeaders(h3Event, result.headers);
+      if ((result as any).customBody) {
+        result = await (result as any).customBody();
       } else if (result.body == undefined) result = undefined;
     }
 
@@ -182,13 +177,9 @@ async function handleServerFunction(h3Event) {
         });
       }
       // forward headers
-      if (x.headers) {
-        for (const [key, value] of x.headers.entries()) {
-          setHeader(h3Event, key, value);
-        }
-      }
-      if (x.customBody) {
-        x = await x.customBody();
+      if (x.headers) mergeResponseHeaders(h3Event, x.headers);
+      if ((x as any).customBody) {
+        x = await (x as any).customBody();
       } else if (x.body == undefined) x = undefined;
     }
     return x;

package/config/{server-runtime.jsx → server-runtime.ts}

@@ -14,6 +14,9 @@ import {
 import { createIslandReference } from "../server/islands";
 
 class SerovalChunkReader {
+  reader: ReadableStreamDefaultReader<Uint8Array>;
+  buffer: string;
+  done: boolean;
   constructor(stream) {
     this.reader = stream.getReader();
     this.buffer = "";
@@ -92,6 +95,7 @@ async function deserializeStream(id, response) {
   if (!result.done) {
     reader.drain().then(
       () => {
+        // @ts-ignore
         delete $R[id];
       },
       () => {
@@ -105,7 +109,7 @@ async function deserializeStream(id, response) {
 
 let INSTANCE = 0;
 
-function createRequest(base, id, instance, body, contentType) {
+function createRequest(base: string, id: string, instance: string, body: any, contentType?: string) {
   return fetch(base, {
     method: "POST",
     headers: {
@@ -154,7 +158,7 @@ async function fetchServerFunction(base, id, method, args) {
 
   if (response.headers.get("Location")) throw response;
   if (response.headers.get("X-Revalidate")) {
-    /* ts-ignore-next-line */
+    /* @ts-ignore-next-line */
     response.customBody = () => {
       return deserializeStream(instance, response);
     };

package/{server/middleware.ts → middleware/index.ts}

@@ -1,59 +1,25 @@
 import {
-  defineMiddleware,
-  getRequestIP,
-  H3Event,
-  sendWebResponse,
-  toWebRequest
-} from "vinxi/server";
-import { FetchEvent } from "./types";
-
-const h3EventSymbol = Symbol("h3Event");
-const fetchEventSymbol = Symbol("fetchEvent");
-const eventTraps = {
-  get(target, prop) {
-    if (prop === fetchEventSymbol) return target;
-    return target[prop] ?? target[h3EventSymbol][prop];
-  }
-};
-
-export function createFetchEvent(event: H3Event): FetchEvent {
-  const request = toWebRequest(event);
-  return new Proxy(
-    {
-      request: request,
-      clientAddress: getRequestIP(event),
-      locals: {},
-      // @ts-ignore
-      [h3EventSymbol]: event
-    },
-    eventTraps
-  ) as unknown as FetchEvent;
-}
-
-export function cloneEvent<T extends FetchEvent>(fetchEvent: T): T {
-  return new Proxy({ ...fetchEvent[fetchEventSymbol] }, eventTraps);
-}
-
-export function getFetchEvent(h3Event: H3Event): FetchEvent {
-  if (!h3Event[fetchEventSymbol]) {
-    const fetchEvent = createFetchEvent(h3Event);
-    h3Event[fetchEventSymbol] = fetchEvent;
-    // @ts-ignore
-  }
-
-  return h3Event[fetchEventSymbol];
-}
+    H3Event,
+    defineMiddleware,
+    sendWebResponse
+} from "vinxi/http";
+import { getFetchEvent } from "../server/fetchEvent";
+import type { FetchEvent } from "../server/types";
 
 /** Function responsible for receiving an observable [operation]{@link Operation} and returning a [result]{@link OperationResult}. */
 
 export type MiddlewareFn = (event: FetchEvent) => Promise<unknown> | unknown;
 /** This composes an array of Exchanges into a single ExchangeIO function */
 
-type RequestMiddleware = (event: FetchEvent) => Response | Promise<Response> | void | Promise<void>;
+export type RequestMiddleware = (event: FetchEvent) => Response | Promise<Response> | void | Promise<void>;
+
+// copy-pasted from h3/dist/index.d.ts
+type EventHandlerResponse<T = any> = T | Promise<T>;
+type ResponseMiddlewareResponseParam = { body?: Awaited<EventHandlerResponse> };
 
-type ResponseMiddleware = (
+export type ResponseMiddleware = (
   event: FetchEvent,
-  response: Response
+  response: ResponseMiddlewareResponseParam
 ) => Response | Promise<Response> | void | Promise<void>;
 
 function wrapRequestMiddleware(onRequest: RequestMiddleware) {
@@ -69,7 +35,7 @@ function wrapRequestMiddleware(onRequest: RequestMiddleware) {
 }
 
 function wrapResponseMiddleware(onBeforeResponse: ResponseMiddleware) {
-  return async (h3Event: H3Event, response: Response) => {
+  return async (h3Event: H3Event, response: ResponseMiddlewareResponseParam) => {
     const fetchEvent = getFetchEvent(h3Event);
     const mwResponse = await onBeforeResponse(fetchEvent, response);
     if (!mwResponse) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "0.4.11",
+  "version": "0.5.1",
   "type": "module",
   "author": "Ryan Carniato",
   "publishConfig": {
@@ -9,7 +9,7 @@
   "files": [
     "client",
     "config",
-    "entry",
+    "middleware",
     "server",
     "shared",
     "*.d.ts"
@@ -18,8 +18,7 @@
   "exports": {
     ".": "./shared/index.tsx",
     "./config": "./config/index.js",
-    "./entry": "./entry/index.ts",
-    "./entry/spa": "./entry/spa/index.ts",
+    "./middleware": "./middleware/index.ts",
     "./server": "./server/index.tsx",
     "./server/spa": "./server/spa/index.tsx",
     "./client": "./client/index.tsx",
@@ -31,8 +30,8 @@
       ".": [
         "./shared/index.tsx"
       ],
-      "./entry": [
-        "./entry/index.ts"
+      "./middleware": [
+        "./middleware/index.ts"
       ],
       "./server": [
         "./server/index.tsx"
@@ -43,16 +42,17 @@
     }
   },
   "devDependencies": {
-    "solid-js": "^1.8.12",
-    "vinxi": "^0.1.6"
+    "solid-js": "^1.8.13",
+    "vinxi": "^0.2.1"
   },
   "dependencies": {
-    "@vinxi/plugin-directives": "^0.1.3",
-    "@vinxi/server-components": "^0.1.3",
-    "@vinxi/server-functions": "^0.1.3",
+    "@vinxi/plugin-directives": "^0.2.0",
+    "@vinxi/server-components": "^0.2.0",
+    "@vinxi/server-functions": "^0.2.1",
     "defu": "^6.1.2",
     "error-stack-parser": "^2.1.4",
     "html-to-image": "^1.11.11",
+    "radix3": "^1.1.0",
     "seroval": "^1.0.2",
     "seroval-plugins": "^1.0.2",
     "shikiji": "^0.9.12",

package/server/StartServer.tsx

@@ -35,9 +35,9 @@ export function StartServer(props: { document: Component<DocumentComponentProps>
 
   let assets = [];
   Promise.resolve().then(async () => {
-    if (context.routerMatches && context.routerMatches[0]) {
-      const matches = [...context.routerMatches[0]];
-      while (matches.length && (!matches[0].metadata || !matches[0].metadata.filesystem))
+    if (context.router && context.router.matches) {
+      const matches = [...context.router.matches];
+      while (matches.length && (!matches[0].info || !matches[0].info.filesystem))
         matches.shift();
       const matched = matches.length && matchRoute(matches, context.routes);
       if (matched) {

package/server/fetchEvent.ts

@@ -0,0 +1,114 @@
+import {
+  H3Event,
+  HTTPEventSymbol,
+  appendResponseHeader,
+  getRequestIP,
+  getResponseHeader,
+  getResponseHeaders,
+  getResponseStatus,
+  getResponseStatusText,
+  removeResponseHeader,
+  setHeader,
+  setResponseHeader,
+  setResponseStatus,
+  toWebRequest
+} from "vinxi/http";
+import type { FetchEvent, ResponseStub } from "./types";
+
+const fetchEventSymbol = Symbol("fetchEvent");
+
+export function createFetchEvent(event: H3Event): FetchEvent {
+  const request = toWebRequest(event);
+  return {
+    request: request,
+    response: createResponseStub(event),
+    clientAddress: getRequestIP(event),
+    locals: {},
+    nativeEvent: event,
+    [HTTPEventSymbol]: event
+  };
+}
+
+export function cloneEvent<T extends FetchEvent>(fetchEvent: T): T {
+  return {
+    ...fetchEvent,
+    [HTTPEventSymbol]: fetchEvent[HTTPEventSymbol]
+  };
+}
+
+export function getFetchEvent(h3Event: H3Event): FetchEvent {
+  if (!h3Event[fetchEventSymbol]) {
+    const fetchEvent = createFetchEvent(h3Event);
+    h3Event[fetchEventSymbol] = fetchEvent;
+  }
+
+  return h3Event[fetchEventSymbol];
+}
+
+export function mergeResponseHeaders(h3Event, headers) {
+  for (const [key, value] of headers.entries()) {
+    setHeader(h3Event, key, value);
+  }
+}
+
+class HeaderProxy {
+  constructor(private event: H3Event) {}
+  get(key: string) {
+    const h = getResponseHeader(this.event, key);
+    return Array.isArray(h) ? h.join(", ") : h;
+  }
+  has(key: string) {
+    return this.get(key) !== undefined;
+  }
+  set(key: string, value: string) {
+    return setResponseHeader(this.event, key, value);
+  }
+  delete(key: string) {
+    return removeResponseHeader(this.event, key);
+  }
+  append(key: string, value: string) {
+    appendResponseHeader(this.event, key, value);
+  }
+  getSetCookie() {
+    const cookies = getResponseHeader(this.event, "Set-Cookie");
+    return Array.isArray(cookies) ? cookies : [cookies];
+  }
+  forEach(fn: (value: string, key: string, object: Headers) => void) {
+    return this.entries().forEach(([key, value]) => fn(value, key, this));
+  }
+  entries() {
+    return getResponseHeaders(this.event).map(([key, value]) => [
+      key,
+      Array.isArray(value) ? value.join(", ") : value
+    ]);
+  }
+  keys() {
+    return getResponseHeaders(this.event).map(([key]) => key);
+  }
+  values() {
+    return getResponseHeaders(this.event).map(([key, value]) =>
+      Array.isArray(value) ? value.join(", ") : value
+    );
+  }
+  [Symbol.iterator]() {
+    return this.entries()[Symbol.iterator]();
+  }
+}
+
+function createResponseStub(event: H3Event): ResponseStub {
+  return {
+    get status() {
+      return getResponseStatus(event);
+    },
+    set status(v) {
+      setResponseStatus(event, v);
+    },
+    get statusText() {
+      return getResponseStatusText(event);
+    },
+    set statusText(v) {
+      setResponseStatus(event, getResponseStatus(), v);
+    },
+    headers: new HeaderProxy(event)
+  };
+}

package/{entry/index.ts → server/handler.ts}

@@ -1,21 +1,19 @@
 import { sharedConfig } from "solid-js";
-import { renderToStream } from "solid-js/web";
-/* @ts-ignore */
+import { renderToStream, renderToString } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
 import {
   EventHandlerObject,
   EventHandlerRequest,
   H3Event,
-  HTTPMethod,
   eventHandler,
   sendRedirect,
   setHeader,
   setResponseStatus
-} from "vinxi/server";
-import { getFetchEvent } from "../server/middleware";
-import { createPageEvent } from "../server/page-event";
-import { APIEvent, FetchEvent, PageEvent } from "../server/types";
+} from "vinxi/http";
 import { matchAPIRoute } from "../shared/routes";
+import { getFetchEvent } from "./fetchEvent";
+import { createPageEvent } from "./pageEvent";
+import type { APIEvent, FetchEvent, PageEvent } from "./types";
 
 export function createBaseHandler(
   fn: (context: PageEvent) => unknown,
@@ -35,21 +33,38 @@ export function createBaseHandler(
     onBeforeResponse: options.onBeforeResponse,
     handler: (e: H3Event<EventHandlerRequest> & { startEvent: FetchEvent }) => {
       const event = getFetchEvent(e);
+      const mode = import.meta.env.START_SSR;
 
       return provideRequestEvent(event, async () => {
         // api
-        const match = matchAPIRoute(new URL(event.request.url).pathname, event.request.method as HTTPMethod)
+        const match = matchAPIRoute(new URL(event.request.url).pathname, event.request.method);
         if (match) {
           const mod = await match.handler.import();
           const fn = mod[event.request.method];
           (event as APIEvent).params = match.params;
-          sharedConfig.context = { event } as any;
-          return await fn(event);
+          // @ts-ignore
+          sharedConfig.context = { event };
+          const res = await fn(event);
+          if (res !== undefined) return res;
+          if (event.request.method !== "GET") {
+            throw new Error(
+              `API handler for ${event.request.method} "${event.request.url}" did not return a response.`
+            );
+          }
         }
 
-        // render stream
-        const doAsync = import.meta.env.START_SSR === "async";
+        // render
         const context = await createPageEvent(event);
+        if (mode === "sync") {
+          const html = renderToString(() => {
+            (sharedConfig.context as any).event = context;
+            return fn(context);
+          }, options);
+          if (context.response && context.response.headers.get("Location")) {
+            return sendRedirect(event, context.response.headers.get("Location"));
+          }
+          return html;
+        }
         let cloned = { ...options };
         if (cloned.onCompleteAll) {
           const og = cloned.onCompleteAll;
@@ -67,12 +82,12 @@ export function createBaseHandler(
         } else cloned.onCompleteShell = handleShellCompleteRedirect(context, e);
         const stream = renderToStream(() => {
           (sharedConfig.context as any).event = context;
-          return fn(context)
+          return fn(context);
         }, cloned);
         if (context.response && context.response.headers.get("Location")) {
           return sendRedirect(event, context.response.headers.get("Location"));
         }
-        if (doAsync) return stream;
+        if (mode === "async") return stream;
         // fix cloudflare streaming
         const { writable, readable } = new TransformStream();
         stream.pipeTo(writable);
@@ -88,7 +103,7 @@ function handleShellCompleteRedirect(context: PageEvent, e: H3Event<EventHandler
       setResponseStatus(e, 302);
       setHeader(e, "Location", context.response.headers.get("Location"));
     }
-  }
+  };
 }
 
 function handleStreamCompleteRedirect(context: PageEvent) {
@@ -103,4 +118,4 @@ export function createHandler(
   options: Parameters<typeof createBaseHandler>[1] = {}
 ) {
   return createBaseHandler(fn, { ...options, createPageEvent });
-}
+}

package/server/index.tsx

@@ -1,4 +1,4 @@
-export * from "vinxi/server";
 export { StartServer } from "./StartServer";
-export * from "./middleware";
+export { createHandler } from "./handler";
 export * from "./types";
+

package/server/{page-event.tsx → pageEvent.ts}

@@ -1,12 +1,7 @@
 import {
-  appendResponseHeader,
-  getCookie,
-  getResponseHeader,
-  removeResponseHeader,
-  setCookie,
-  setResponseHeader,
-  setResponseStatus
-} from "vinxi/server";
+    getCookie,
+    setCookie
+} from "vinxi/http";
 import { createRoutes } from "../shared/FileRoutes";
 import { FetchEvent, PageEvent } from "./types";
 
@@ -27,7 +22,7 @@ function initFromFlash(ctx: FetchEvent) {
 export async function createPageEvent(ctx: FetchEvent) {
   const clientManifest = import.meta.env.MANIFEST["client"];
   const serverManifest = import.meta.env.MANIFEST["ssr"];
-  setResponseHeader(ctx, "Content-Type", "text/html");
+  ctx.response.headers.set("Cache-Control", "no-cache");
   // const prevPath = ctx.request.headers.get("x-solid-referrer");
   // const mutation = ctx.request.headers.get("x-solid-mutation") === "true";
   const pageEvent: PageEvent = Object.assign(ctx, {
@@ -40,31 +35,10 @@ export async function createPageEvent(ctx: FetchEvent) {
           )
         : [])
     ],
-    initialSubmission: initFromFlash(ctx),
-    routes: createRoutes(),
-    components: {
-      status: props => {
-        setResponseStatus(ctx, props.code, props.text);
-        return () => !ctx.handled && setResponseStatus(ctx, 200);
-      },
-      header: props => {
-        if (props.append) {
-          appendResponseHeader(ctx, props.name, props.value);
-        } else {
-          setResponseHeader(ctx, props.name, props.value);
-        }
-
-        return () => {
-          if (ctx.handled) return;
-          let values = getResponseHeader(ctx, props.name);
-          if (!Array.isArray(values)) values = [values as string];
-          const index = values.indexOf(props.value);
-          index !== -1 && values.splice(index, 1);
-          if (values.length) setResponseHeader(ctx, props.name, values);
-          else removeResponseHeader(ctx, props.name);
-        };
-      }
+    router: {
+      submission: initFromFlash(ctx)
     },
+    routes: createRoutes(),
     // prevUrl: prevPath || "",
     // mutation: mutation,
     // $type: FETCH_EVENT,

package/{entry/spa/index.ts → server/spa/handler.ts}

@@ -1,5 +1,5 @@
-import { createBaseHandler } from "..";
-import { FetchEvent, PageEvent } from "../../server/types";
+import { createBaseHandler } from "../handler";
+import { FetchEvent, PageEvent } from "../types";
 
 export function createHandler(
   fn: (context: PageEvent) => unknown,

package/server/spa/index.tsx

@@ -1,5 +1,4 @@
-export * from "vinxi/server";
-export * from "../middleware";
 export * from "../types";
 export { StartServer } from "./StartServer";
+export { createHandler } from "./handler";
 

package/server/types.ts

@@ -1,5 +1,5 @@
 import type { JSX } from "solid-js";
-import type { EventHandlerRequest, H3Event } from "vinxi/server";
+import { HTTPEventSymbol, type EventHandlerRequest, type H3Event } from "vinxi/http";
 
 // export const FETCH_EVENT = "$FETCH";
 
@@ -16,10 +16,21 @@ export type ContextMatches = {
   params: unknown;
 };
 
-export interface FetchEvent extends H3Event<EventHandlerRequest> {
+export interface ResponseStub {
+  status?: number;
+  statusText?: string;
+  headers: Headers;
+}
+export interface FetchEvent {
   request: Request;
+  response: ResponseStub;
   clientAddress: string;
-  locals: Record<string, unknown>;
+  locals: RequestEventLocals;
+  nativeEvent: H3Event<EventHandlerRequest>;
+  [HTTPEventSymbol]: H3Event<EventHandlerRequest>;
+}
+export interface RequestEventLocals {
+  [key: string | symbol]: any;
 }
 export interface PageEvent extends FetchEvent {
   manifest: any;
@@ -29,7 +40,6 @@ export interface PageEvent extends FetchEvent {
   // $type: typeof FETCH_EVENT;
   $islands: Set<string>;
   // mutation: boolean;
-  response?: Response;
 }
 
 export interface APIEvent extends FetchEvent {

package/shared/FileRoutes.tsx

@@ -10,8 +10,8 @@ export function createRoutes() {
     return {
       ...route,
       ...(route.$$route ? route.$$route.require().route : undefined),
-      metadata: {
-        ...(route.$$route ? route.$$route.require().route.metadata : {}),
+      info: {
+        ...(route.$$route ? route.$$route.require().route.info : {}),
         filesystem: true
       },
       component: lazyRoute(

package/shared/HttpHeader.tsx

@@ -4,7 +4,24 @@ import { getRequestEvent, isServer } from "solid-js/web";
 export function HttpHeader(props: { name: string; value: string; append?: boolean }) {
   if (isServer) {
     const event = getRequestEvent();
-    if (event) onCleanup((event as any).components.header(props));
+
+    if (props.append) event.response.headers.append(props.name, props.value);
+    else event.response.headers.set(props.name, props.value);
+
+    onCleanup(() => {
+      if (event.nativeEvent.handled) return;
+      const value = event.response.headers.get(props.name);
+      if (!value) return;
+      if (!value.includes(", ")) {
+        if (value === props.value) event.response.headers.delete(props.name);
+        return;
+      }
+      const values = value.split(", ");
+      const index = values.indexOf(props.value);
+      index !== -1 && values.splice(index, 1);
+      if (values.length) event.response.headers.set(props.name, values.join(","));
+      else event.response.headers.delete(props.name);
+    });
   }
 
   return null;

package/shared/HttpStatusCode.tsx

@@ -4,7 +4,9 @@ import { getRequestEvent, isServer } from "solid-js/web";
 export function HttpStatusCode(props: { code: number, text?: string }) {
   if (isServer) {
     const event = getRequestEvent();
-    if (event) onCleanup((event as any).components.status(props));
+    event.response.status = props.code;
+    event.response.statusText = props.text;
+    onCleanup(() => !event.nativeEvent.handled && (event.response.status = 200));
   }
   return null;
 }

package/shared/routes.ts

@@ -1,78 +1,25 @@
+import { createRouter } from "radix3";
 import fileRoutes from "vinxi/routes";
-import { HTTPMethod } from "vinxi/server";
 
 interface Route {
   path: string;
   id: string;
-  type: "api" | "page";
   children?: Route[];
+  $component?: any;
 }
 
-type MatchRoute = Route & {
-  score: number;
-  params: {
-    type: "*" | ":";
-    name: string;
-    index: number;
-  }[];
-  matchSegments: (string | null)[];
-  wildcard: boolean;
-};
-
 declare module "vinxi/routes" {
   export interface Register {
     route: {
       path: string;
-      type: "api" | "page";
       children?: Route[];
     };
   }
 }
 
-export const pageRoutes = defineRoutes((fileRoutes as unknown as Route[]).filter(o => o.type === "page"));
-const apiRoutes = defineAPIRoutes((fileRoutes as unknown as Route[]).filter(o => o.type === "api"));
-
-export function matchAPIRoute(path: string, method: HTTPMethod) {
-  const segments = path.replace(import.meta.env.SERVER_BASE_URL, "").split("/").filter(Boolean);
-
-  routeLoop: for (const route of apiRoutes) {
-    const matchSegments = route.matchSegments;
-
-    if (
-      segments.length < matchSegments.length ||
-      (!route.wildcard && segments.length > matchSegments.length)
-    ) {
-      continue;
-    }
-
-    for (let index = 0; index < matchSegments.length; index++) {
-      const match = matchSegments[index];
-      if (!match) {
-        continue;
-      }
-
-      if (segments[index] !== match) {
-        continue routeLoop;
-      }
-    }
-
-    const handler = route[`$${method}`];
-    if (handler === "skip" || handler === undefined) {
-      return;
-    }
-
-    const params: Record<string, string> = {};
-    for (const { type, name, index } of route.params) {
-      if (type === ":") {
-        params[name] = segments[index];
-      } else {
-        params[name] = segments.slice(index).join("/");
-      }
-    }
-
-    return { handler, params };
-  }
-}
+export const pageRoutes = defineRoutes(
+  (fileRoutes as unknown as Route[]).filter(o => o.$component)
+);
 
 function defineRoutes(fileRoutes: Route[]) {
   function processRoute(routes: Route[], route: Route, id: string, full: string) {
@@ -101,79 +48,35 @@ function defineRoutes(fileRoutes: Route[]) {
     }, []);
 }
 
-function defineAPIRoutes(routes: Route[]) {
-  return routes
-    .flatMap(route => {
-      const paths = expandOptionals(route.path);
-      return paths.map(path => ({ ...route, path }));
-    })
-    .map(routeToMatchRoute)
-    .sort((a, b) => b.score - a.score);
-}
-
-// This is copied from https://github.com/solidjs/solid-router/blob/main/src/utils.ts
-function expandOptionals(pattern: string): string[] {
-  let match = /(\/?\:[^\/]+)\?/.exec(pattern);
-  if (!match) return [pattern];
-
-  let prefix = pattern.slice(0, match.index);
-  let suffix = pattern.slice(match.index + match[0].length);
-  const prefixes: string[] = [prefix, (prefix += match[1])];
-
-  // This section handles adjacent optional params. We don't actually want all permuations since
-  // that will lead to equivalent apiRwhich have the same number of params. For example
-  // `/:a?/:b?/:c`? only has the unique expansion: `/`, `/:a`, `/:a/:b`, `/:a/:b/:c` and we can
-  // discard `/:b`, `/:c`, `/:b/:c` by building them up in order and not recursing. This also helps
-  // ensure predictability where earlier params have precidence.
-  while ((match = /^(\/\:[^\/]+)\?/.exec(suffix))) {
-    prefixes.push((prefix += match[1]));
-    suffix = suffix.slice(match[0].length);
+export function matchAPIRoute(path: string, method: string) {
+  const match = router.lookup(path);
+  if (match) {
+    const handler = match.route[`$${method}`];
+    if (handler === undefined) return;
+    return {
+      handler,
+      params: match.params
+    };
   }
-
-  return expandOptionals(suffix).reduce<string[]>(
-    (results, expansion) => [...results, ...prefixes.map(p => p + expansion)],
-    []
-  );
 }
 
-function routeToMatchRoute(route: Route): MatchRoute {
-  const segments = route.path.split("/").filter(Boolean);
-  const params: { type: "*" | ":"; name: string; index: number }[] = [];
-  const matchSegments: (string | null)[] = [];
-  let score = 0;
-  let wildcard = false;
+function containsHTTP(route: Route) {
+  return route["$GET"] || route["$POST"] || route["$PUT"] || route["$PATCH"] || route["$DELETE"];
+}
 
-  for (const [index, segment] of segments.entries()) {
-    if (segment[0] === ":") {
-      const name = segment.slice(1);
-      score += 3;
-      params.push({
-        type: ":",
-        name,
-        index
-      });
-      matchSegments.push(null);
-    } else if (segment[0] === "*") {
-      score -= 1;
-      params.push({
-        type: "*",
-        name: segment.slice(1),
-        index
-      });
-      wildcard = true;
-    } else {
-      score += 4;
-      if (!segment.match(/^\(.+\)$/)) {
-        matchSegments.push(segment);
-      }
+const router = createRouter({
+  routes: (fileRoutes as unknown as Route[]).reduce((memo, route) => {
+    if (!containsHTTP(route)) return memo;
+    let path = route.path.replace(/\(.*\)\/?/g, "").replace(/\*([^/]*)/g, (_, m) => `**:${m}`);
+    if (/:[^/]*\?/g.test(path)) {
+      throw new Error(`Optional parameters are not supported in API routes: ${path}`);
     }
-  }
-
-  return {
-    ...route,
-    score,
-    params,
-    matchSegments,
-    wildcard
-  };
-}
+    if (memo[path]) {
+      throw new Error(
+        `Duplicate API routes for "${path}" found at "${memo[path].route.path}" and "${route.path}"`
+      );
+    }
+    memo[path] = { route };
+    return memo;
+  }, {} as Record<string, { route: Route }>)
+});