@solidjs/start 0.4.7 → 0.4.9

package/config/server-runtime.jsx

@@ -13,54 +13,100 @@ import {
 } from 'seroval-plugins/web';
 import { createIslandReference } from "../server/islands";
 
-async function deserializeStream(id, response) {
-  if (!response.body) {
-    throw new Error("missing body");
+class ChunkReader {
+  constructor(stream) {
+    this.reader = stream.getReader();
+    this.buffer = '';
+    this.done = false;
   }
-  const reader = response.body.getReader();
-
-  async function pop() {
-    const result = await reader.read();
-    if (!result.done) {
-      const serialized = new TextDecoder().decode(result.value);
-      const splits = serialized.split("\n");
-      for (const split of splits) {
-        if (split !== "") {
-          deserialize(split);
-        }
-      }
-      await pop();
+
+  async readChunk() {
+    // if there's no chunk, read again
+    const chunk = await this.reader.read();
+    if (!chunk.done) {
+      // repopulate the buffer
+      this.buffer += new TextDecoder().decode(chunk.value);
+    } else {
+      this.done = true;
     }
   }
 
-  const result = await reader.read();
-  if (result.done) {
-    throw new Error("Unexpected end of body");
+  async nextValue() {
+    // Check if the buffer is empty
+    if (this.buffer === '') {
+      // if we are already one...
+      if (this.done) {
+        return {
+          done: true,
+          value: undefined,
+        };
+      }
+      // Otherwise, read a new chunk
+      await this.readChunk();
+    }
+    // Get the first valid seroval chunk
+    const [first, ...rest] = this.buffer.split('\n');
+    // Deserialize the seroval chunk
+    const result = {
+      done: false,
+      value: deserialize(first),
+    };
+    // if it succeeds, remove the first valid chunk
+    // from the buffer
+    this.buffer = rest.join('\n');
+    return result;
   }
-  const serialized = new TextDecoder().decode(result.value);
-  let pending = true;
-  let revived;
-  const splits = serialized.split("\n");
-  for (const split of splits) {
-    if (split !== "") {
-      const current = deserialize(split);
-      if (pending) {
-        revived = current;
-        pending = false;
+
+  async next() {
+    try {
+      // Attempt to read a valid seroval chunk
+      return await this.nextValue();
+    } catch (error) {
+      // If it happens that there's an error again
+      // and we are done reading the buffer
+      // then the whole stream is invalid.
+      if (this.done) {
+        throw new Error('Malformed server function stream.');
       }
+      // Since it's invalid (some syntax-related issue)
+      // we read a new chunk, and hope there's a valid
+      // seroval chunk there
+      await this.readChunk();
+      // Retry again
+      return await this.next();
     }
   }
 
-  pop().then(
-    () => {
-      delete $R[id];
-    },
-    () => {
-      // no-op
+  async drain() {
+    while (true) {
+      const result = await this.next();
+      if (result.done) {
+        break;
+      }
     }
-  );
+  }
+}
+
+async function deserializeStream(id, response) {
+  if (!response.body) {
+    throw new Error("missing body");
+  }
+  const reader = new ChunkReader(response.body);
+
+  const result = await reader.next();
+
+  if (!result.done) {
+    reader.drain().then(
+      () => {
+        delete $R[id];
+      },
+      () => {
+        // no-op
+      }
+    );
+  }
 
-  return revived;
+  return result.value;
 }
 
 let INSTANCE = 0;
@@ -108,7 +154,7 @@ async function fetchServerFunction(base, id, args) {
   let result;
   if (contentType && contentType.startsWith("text/plain")) {
     result = await response.text();
-  } else if(contentType && contentType.startsWith("application/json")) {
+  } else if (contentType && contentType.startsWith("application/json")) {
     result = await response.json();
   } else {
     result = deserializeStream(instance, response);

package/entry/index.ts

@@ -0,0 +1,106 @@
+import { sharedConfig } from "solid-js";
+import { renderToStream } from "solid-js/web";
+/* @ts-ignore */
+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";
+import { matchAPIRoute } from "../shared/routes";
+
+export function createBaseHandler(
+  fn: (context: PageEvent) => unknown,
+  options: {
+    nonce?: string;
+    renderId?: string;
+    timeoutMs?: number;
+    onCompleteAll?: (options: { write: (v: any) => void }) => void;
+    onCompleteShell?: (options: { write: (v: any) => void }) => void;
+    createPageEvent?: (event: FetchEvent) => Promise<PageEvent>;
+    onRequest?: EventHandlerObject["onRequest"];
+    onBeforeResponse?: EventHandlerObject["onBeforeResponse"];
+  } = {}
+) {
+  return eventHandler({
+    onRequest: options.onRequest,
+    onBeforeResponse: options.onBeforeResponse,
+    handler: (e: H3Event<EventHandlerRequest> & { startEvent: FetchEvent }) => {
+      const event = getFetchEvent(e);
+
+      return provideRequestEvent(event, async () => {
+        // api
+        const match = matchAPIRoute(new URL(event.request.url).pathname, event.request.method as HTTPMethod)
+        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);
+        }
+
+        // render stream
+        const doAsync = import.meta.env.START_SSR === "async";
+        const context = await createPageEvent(event);
+        let cloned = { ...options };
+        if (cloned.onCompleteAll) {
+          const og = cloned.onCompleteAll;
+          cloned.onCompleteAll = options => {
+            handleStreamCompleteRedirect(context)(options);
+            og(options);
+          };
+        } else cloned.onCompleteAll = handleStreamCompleteRedirect(context);
+        if (cloned.onCompleteShell) {
+          const og = cloned.onCompleteShell;
+          cloned.onCompleteShell = options => {
+            handleShellCompleteRedirect(context, e)();
+            og(options);
+          };
+        } else cloned.onCompleteShell = handleShellCompleteRedirect(context, e);
+        const stream = renderToStream(() => {
+          (sharedConfig.context as any).event = 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;
+        // fix cloudflare streaming
+        const { writable, readable } = new TransformStream();
+        stream.pipeTo(writable);
+        return readable;
+      });
+    }
+  });
+}
+
+function handleShellCompleteRedirect(context: PageEvent, e: H3Event<EventHandlerRequest>) {
+  return () => {
+    if (context.response && context.response.headers.get("Location")) {
+      setResponseStatus(e, 302);
+      setHeader(e, "Location", context.response.headers.get("Location"));
+    }
+  }
+}
+
+function handleStreamCompleteRedirect(context: PageEvent) {
+  return ({ write }: { write: (html: string) => void }) => {
+    const to = context.response && context.response.headers.get("Location");
+    to && write(`<script>window.location="${to}"</script>`);
+  };
+}
+
+export function createHandler(
+  fn: (context: PageEvent) => unknown,
+  options: Parameters<typeof createBaseHandler>[1] = {}
+) {
+  return createBaseHandler(fn, { ...options, createPageEvent });
+}

package/entry/spa/index.ts

@@ -0,0 +1,24 @@
+import { createBaseHandler } from "..";
+import { FetchEvent, PageEvent } from "../../server/types";
+
+export function createHandler(
+  fn: (context: PageEvent) => unknown,
+  options?: { nonce?: string; renderId?: string; timeoutMs?: number }
+) {
+  return createBaseHandler(fn, { ...options, createPageEvent });
+}
+
+export async function createPageEvent(ctx: FetchEvent) {
+  const clientManifest = import.meta.env.MANIFEST["client"];
+  const pageEvent: PageEvent = Object.assign(ctx, {
+    manifest: await clientManifest.json(),
+    assets: [...(await clientManifest.inputs[clientManifest.handler].assets())],
+    routes: [],
+    // prevUrl: "",
+    // mutation: false,
+    // $type: FETCH_EVENT,
+    $islands: new Set<string>()
+  });
+
+  return pageEvent;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "type": "module",
   "author": "Ryan Carniato",
   "publishConfig": {
@@ -9,6 +9,7 @@
   "files": [
     "client",
     "config",
+    "entry",
     "server",
     "shared",
     "*.d.ts"
@@ -42,8 +43,8 @@
     }
   },
   "devDependencies": {
-    "solid-js": "^1.8.10",
-    "vinxi": "0.1.1"
+    "solid-js": "^1.8.11",
+    "vinxi": "^0.1.2"
   },
   "dependencies": {
     "@vinxi/plugin-directives": "^0.1.0",

package/shared/routes.ts

@@ -33,7 +33,7 @@ export const pageRoutes = defineRoutes((fileRoutes as unknown as Route[]).filter
 const apiRoutes = defineAPIRoutes((fileRoutes as unknown as Route[]).filter(o => o.type === "api"));
 
 export function matchAPIRoute(path: string, method: HTTPMethod) {
-  const segments = path.split("/").filter(Boolean);
+  const segments = path.replace(import.meta.env.SERVER_BASE_URL, "").split("/").filter(Boolean);
 
   routeLoop: for (const route of apiRoutes) {
     const matchSegments = route.matchSegments;