@solidjs/start 0.7.1 → 0.7.3

package/config/server-runtime.ts

@@ -1,229 +0,0 @@
-import { deserialize, toJSONAsync } from "seroval";
-import {
-  CustomEventPlugin,
-  DOMExceptionPlugin,
-  EventPlugin,
-  FormDataPlugin,
-  HeadersPlugin,
-  ReadableStreamPlugin,
-  RequestPlugin,
-  ResponsePlugin,
-  URLPlugin,
-  URLSearchParamsPlugin
-} from "seroval-plugins/web";
-import { type Component } from "solid-js";
-import { createIslandReference } from "../server/islands";
-
-class SerovalChunkReader {
-  reader: ReadableStreamDefaultReader<Uint8Array>;
-  buffer: string;
-  done: boolean;
-  constructor(stream: ReadableStream<Uint8Array>) {
-    this.reader = stream.getReader();
-    this.buffer = "";
-    this.done = false;
-  }
-
-  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;
-    }
-  }
-
-  async next(): Promise<any> {
-    // Check if the buffer is empty
-    if (this.buffer === "") {
-      // if we are already done...
-      if (this.done) {
-        return {
-          done: true,
-          value: undefined
-        };
-      }
-      // Otherwise, read a new chunk
-      await this.readChunk();
-      return await this.next();
-    }
-    // Read the "byte header"
-    // The byte header tells us how big the expected data is
-    // so we know how much data we should wait before we
-    // deserialize the data
-    const bytes = Number.parseInt(this.buffer.substring(1, 11), 16); // ;0x00000000;
-    // Check if the buffer has enough bytes to be parsed
-    while (bytes > this.buffer.length - 12) {
-      // If it's not enough, and the reader is done
-      // then the chunk is invalid.
-      if (this.done) {
-        throw new Error("Malformed server function stream.");
-      }
-      // Otherwise, we read more chunks
-      await this.readChunk();
-    }
-    // Extract the exact chunk as defined by the byte header
-    const partial = this.buffer.substring(12, 12 + bytes);
-    // The rest goes to the buffer
-    this.buffer = this.buffer.substring(12 + bytes);
-    // Deserialize the chunk
-    return {
-      done: false,
-      value: deserialize(partial)
-    };
-  }
-
-  async drain() {
-    while (true) {
-      const result = await this.next();
-      if (result.done) {
-        break;
-      }
-    }
-  }
-}
-
-async function deserializeStream(id: string, response: Response) {
-  if (!response.body) {
-    throw new Error("missing body");
-  }
-  const reader = new SerovalChunkReader(response.body);
-
-  const result = await reader.next();
-
-  if (!result.done) {
-    reader.drain().then(
-      () => {
-        // @ts-ignore
-        delete $R[id];
-      },
-      () => {
-        // no-op
-      }
-    );
-  }
-
-  return result.value;
-}
-
-let INSTANCE = 0;
-
-function createRequest(base: string, id: string, instance: string, options: RequestInit) {
-  return fetch(base, {
-    method: "POST",
-    ...options,
-    headers: {
-      ...options.headers,
-      "X-Server-Id": id,
-      "X-Server-Instance": instance
-    }
-  });
-}
-
-async function fetchServerFunction(
-  base: string,
-  id: string,
-  options: Omit<RequestInit, "body">,
-  args: any[]
-) {
-  const instance = `server-fn:${INSTANCE++}`;
-  const response = await (args.length === 0
-    ? createRequest(base, id, instance, options)
-    : args.length === 1 && args[0] instanceof FormData
-    ? createRequest(base, id, instance, { ...options, body: args[0] })
-    : createRequest(base, id, instance, {
-        ...options,
-        body: JSON.stringify(
-          await Promise.resolve(
-            toJSONAsync(args, {
-              plugins: [
-                CustomEventPlugin,
-                DOMExceptionPlugin,
-                EventPlugin,
-                FormDataPlugin,
-                HeadersPlugin,
-                ReadableStreamPlugin,
-                RequestPlugin,
-                ResponsePlugin,
-                URLSearchParamsPlugin,
-                URLPlugin
-              ]
-            })
-          )
-        ),
-        headers: { ...options.headers, "Content-Type": "application/json" }
-      }));
-
-  if (
-    response.headers.get("Location") ||
-    response.headers.get("X-Revalidate") ||
-    response.headers.get("X-Single-Flight")
-  ) {
-    if (response.body) {
-      /* @ts-ignore-next-line */
-      response.customBody = () => {
-        return deserializeStream(instance, response);
-      };
-    }
-    return response;
-  }
-
-  const contentType = response.headers.get("Content-Type");
-  let result;
-  if (contentType && contentType.startsWith("text/plain")) {
-    result = await response.text();
-  } else if (contentType && contentType.startsWith("application/json")) {
-    result = await response.json();
-  } else {
-    result = await deserializeStream(instance, response);
-  }
-  if (response.headers.has("X-Error")) {
-    throw result;
-  }
-  return result;
-}
-
-export function createServerReference(fn: Function, id: string, name: string) {
-  const baseURL = import.meta.env.SERVER_BASE_URL;
-  return new Proxy(fn, {
-    get(target, prop, receiver) {
-      if (prop === "url") {
-        return `${baseURL}/_server?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`;
-      }
-      if (prop === "GET") {
-        return receiver.withOptions({ method: "GET" });
-      }
-      if (prop === "withOptions") {
-        const url = `${baseURL}/_server/?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`
-        return (options: RequestInit) => {
-          const fn = (...args: any[]) => {
-            const encodeArgs = options.method && options.method.toUpperCase() === "GET";
-            return fetchServerFunction(
-              encodeArgs
-                ? url + (args.length ? `&args=${JSON.stringify(args)}` : "")
-                : `${baseURL}/_server`,
-              `${id}#${name}`,
-              options,
-              encodeArgs ? [] : args
-            );
-          };
-          fn.url = url;
-          return fn;
-        };
-      }
-    },
-    apply(target, thisArg, args) {
-      return fetchServerFunction(`${baseURL}/_server`, `${id}#${name}`, {}, args);
-    }
-  });
-}
-
-export function createClientReference(Component: Component<any>, id: string, name: string) {
-  if (typeof Component === "function") {
-    return createIslandReference(Component, id, name);
-  }
-
-  return Component;
-}

package/middleware/index.ts

@@ -1,70 +0,0 @@
-import {
-  HTTPEvent,
-  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 */
-
-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> };
-
-export type ResponseMiddleware = (
-  event: FetchEvent,
-  response: ResponseMiddlewareResponseParam
-) => Response | Promise<Response> | void | Promise<void>;
-
-function wrapRequestMiddleware(onRequest: RequestMiddleware) {
-  return async (h3Event: HTTPEvent) => {
-    const fetchEvent = getFetchEvent(h3Event);
-    const response = await onRequest(fetchEvent);
-    if (!response) {
-      return;
-    } else {
-      sendWebResponse(h3Event, response);
-    }
-  };
-}
-
-function wrapResponseMiddleware(onBeforeResponse: ResponseMiddleware) {
-  return async (h3Event: HTTPEvent, response: ResponseMiddlewareResponseParam) => {
-    const fetchEvent = getFetchEvent(h3Event);
-    const mwResponse = await onBeforeResponse(fetchEvent, response);
-    if (!mwResponse) {
-      return;
-    } else {
-      sendWebResponse(h3Event, mwResponse);
-    }
-  };
-}
-
-export function createMiddleware({
-  onRequest,
-  onBeforeResponse
-}: {
-  onRequest?: RequestMiddleware | RequestMiddleware[] | undefined;
-  onBeforeResponse?: ResponseMiddleware | ResponseMiddleware[] | undefined;
-}) {
-  return defineMiddleware({
-    onRequest:
-      typeof onRequest === "function"
-        ? wrapRequestMiddleware(onRequest)
-        : Array.isArray(onRequest)
-        ? onRequest.map(wrapRequestMiddleware)
-        : undefined,
-    onBeforeResponse:
-      typeof onBeforeResponse === "function"
-        ? wrapResponseMiddleware(onBeforeResponse)
-        : Array.isArray(onBeforeResponse)
-        ? onBeforeResponse.map(wrapResponseMiddleware)
-        : undefined
-  });
-}

package/router/FileRoutes.ts

@@ -1,35 +0,0 @@
-/* @refresh skip */
-import { getRequestEvent, isServer } from "solid-js/web";
-import lazyRoute from "./lazyRoute";
-
-import type { Route } from "vinxi/fs-router";
-import type { PageEvent } from "../server/types";
-import { pageRoutes as routeConfigs } from "./routes";
-
-export function createRoutes() {
-  function createRoute(route: Route) {
-    return {
-      ...route,
-      ...(route.$$route ? route.$$route.require().route : undefined),
-      info: {
-        ...(route.$$route ? route.$$route.require().route.info : {}),
-        filesystem: true
-      },
-      component: lazyRoute(
-        route.$component,
-        import.meta.env.START_ISLANDS
-          ? import.meta.env.MANIFEST["ssr"]
-          : import.meta.env.MANIFEST["client"],
-        import.meta.env.MANIFEST["ssr"]
-      ),
-      children: route.children ? route.children.map(createRoute) : undefined
-    };
-  }
-  const routes = routeConfigs.map(createRoute);
-  return routes;
-}
-
-let routes: any[];
-export const FileRoutes = isServer
-  ? () => (getRequestEvent() as PageEvent).routes
-  : () => routes || (routes = createRoutes());

package/router/lazyRoute.ts

@@ -1,55 +0,0 @@
-/// <reference types="vinxi/types/client" />
-import { createComponent, lazy, onCleanup, type Component, type JSX } from "solid-js";
-import { appendStyles, cleanupStyles, preloadStyles, updateStyles } from "vinxi/css";
-
-import { renderAsset } from "../server/renderAsset";
-import { Asset } from "../server/types";
-
-export default function lazyRoute<T>(component: any, clientManifest: any, serverManifest: any, exported = "default") {
-  return lazy(async () => {
-    if (import.meta.env.DEV) {
-      let manifest = import.meta.env.SSR ? serverManifest : clientManifest;
-
-      const mod = await manifest.inputs[component.src].import();
-      if (!mod[exported]) console.error(`Module ${component.src} does not export ${exported}`);
-      const Component = mod[exported];
-      let assets = await clientManifest.inputs?.[component.src].assets();
-      const styles = assets.filter((asset: Asset) => asset.tag === "style");
-
-      if (typeof window !== "undefined" && import.meta.hot) {
-        import.meta.hot.on("css-update", data => {
-          updateStyles(styles, data);
-        });
-      }
-
-      const Comp: Component<T> = props => {
-        if (typeof window !== "undefined") {
-          appendStyles(styles);
-        }
-
-        onCleanup(() => {
-          if (typeof window !== "undefined") {
-            // remove style tags added by vite when a CSS file is imported
-            cleanupStyles(styles);
-          }
-        });
-        return [...assets.map((asset: Asset) => renderAsset(asset)), createComponent(Component, props)];
-      };
-      return { default: Comp };
-    } else {
-      const mod = await component.import();
-      const Component = mod[exported];
-      let assets = await clientManifest.inputs?.[component.src].assets();
-      const styles = assets.filter(
-        (asset: Asset) => asset.tag === "style" || (asset.attrs as JSX.LinkHTMLAttributes<HTMLLinkElement>).rel === "stylesheet"
-      );
-      if (typeof window !== "undefined") {
-        preloadStyles(styles);
-      }
-      const Comp: Component<T> = props => {
-        return [...styles.map((asset: Asset) => renderAsset(asset)), createComponent(Component, props)];
-      };
-      return { default: Comp };
-    }
-  });
-}

package/router/routes.ts

@@ -1,87 +0,0 @@
-import { createRouter } from "radix3";
-import fileRoutes from "vinxi/routes";
-
-interface Route {
-  path: string;
-  id: string;
-  children?: Route[];
-  $component?: any;
-  $GET?: any;
-  $POST?: any;
-  $PUT?: any;
-  $PATCH?: any;
-  $DELETE?: any;
-}
-
-declare module "vinxi/routes" {
-  export interface Register {
-    route: {
-      path: string;
-      children?: Route[];
-    };
-  }
-}
-
-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) {
-    const parentRoute = Object.values(routes).find(o => {
-      return id.startsWith(o.id + "/");
-    });
-
-    if (!parentRoute) {
-      routes.push({ ...route, id, path: id.replace(/\/\([^)/]+\)/g, "").replace(/\./g, "/") });
-      return routes;
-    }
-    processRoute(
-      parentRoute.children || (parentRoute.children = []),
-      route,
-      id.slice(parentRoute.id.length),
-      full
-    );
-
-    return routes;
-  }
-
-  return fileRoutes
-    .sort((a, b) => a.path.length - b.path.length)
-    .reduce((prevRoutes: Route[], route) => {
-      return processRoute(prevRoutes, route, route.path, route.path);
-    }, []);
-}
-
-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
-    };
-  }
-}
-
-function containsHTTP(route: Route) {
-  return route["$GET"] || route["$POST"] || route["$PUT"] || route["$PATCH"] || route["$DELETE"];
-}
-
-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}`);
-    }
-    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 }>)
-});

package/server/StartServer.tsx

@@ -1,126 +0,0 @@
-// @refresh skip
-// @ts-ignore
-import App from "#start/app";
-import type { Component, JSX } from "solid-js";
-import {
-  Hydration,
-  HydrationScript,
-  NoHydration,
-  getRequestEvent,
-  ssr,
-  useAssets
-} from "solid-js/web";
-import { ErrorBoundary } from "../shared/ErrorBoundary";
-import { renderAsset } from "./renderAsset";
-import type { Asset, DocumentComponentProps, PageEvent } from "./types";
-
-const docType = ssr("<!DOCTYPE html>");
-
-function matchRoute(matches: any[], routes: any[], matched = []): any[] | undefined {
-  for (let i = 0; i < routes.length; i++) {
-    const segment = routes[i];
-    if (segment.path !== matches[0].path) continue;
-    let next: any = [...matched, segment];
-    if (segment.children) {
-      const nextMatches = matches.slice(1);
-      if (nextMatches.length === 0) continue;
-      next = matchRoute(nextMatches, segment.children, next);
-      if (!next) continue;
-    }
-    return next;
-  }
-}
-
-export function StartServer(props: { document: Component<DocumentComponentProps> }) {
-  const context = getRequestEvent() as PageEvent;
-  // @ts-ignore
-  const nonce = context.nonce;
-
-  let assets: Asset[] = [];
-  Promise.resolve().then(async () => {
-    // @ts-ignore
-    if (context.router && context.router.matches) {
-      // @ts-ignore
-      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) {
-        for (let i = 0; i < matched.length; i++) {
-          const segment = matched[i];
-          const part = import.meta.env.MANIFEST[import.meta.env.START_ISLANDS ? "ssr" : "client"]!
-            .inputs[segment["$component"].src]!;
-          const asset = (await part.assets()) as any;
-          assets.push.apply(assets, asset);
-        }
-      } else console.warn("No route matched for preloading js assets");
-    }
-    // dedupe assets
-    assets = [...new Map(assets.map(item => [item.attrs.key, item])).values()].filter(asset =>
-      import.meta.env.START_ISLANDS
-        ? false
-        : (asset.attrs as JSX.LinkHTMLAttributes<HTMLLinkElement>).rel === "modulepreload" &&
-          !context.assets.find((a: Asset) => a.attrs.key === asset.attrs.key)
-    );
-  });
-
-  useAssets(() => (assets.length ? assets.map(m => renderAsset(m)) : undefined));
-
-  return (
-    <NoHydration>
-      {docType as unknown as any}
-      <props.document
-        assets={
-          <>
-            <HydrationScript />
-            {context.assets.map((m: any) => renderAsset(m))}
-          </>
-        }
-        scripts={
-          nonce ? (
-            <>
-              <script
-                nonce={nonce}
-                innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}
-              />
-              <script
-                type="module"
-                nonce={nonce}
-                async
-                src={
-                  import.meta.env.MANIFEST["client"]!.inputs[
-                    import.meta.env.MANIFEST["client"]!.handler
-                  ]!.output.path
-                }
-              />
-            </>
-          ) : (
-            <>
-              <script innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`} />
-              <script
-                type="module"
-                async
-                src={
-                  import.meta.env.MANIFEST["client"]!.inputs[
-                    import.meta.env.MANIFEST["client"]!.handler
-                  ]!.output.path
-                }
-              />
-            </>
-          )
-        }
-      >
-        {!import.meta.env.START_ISLANDS ? (
-          <Hydration>
-            <ErrorBoundary>
-              <App />
-            </ErrorBoundary>
-          </Hydration>
-        ) : (
-          <ErrorBoundary>
-            <App />
-          </ErrorBoundary>
-        )}
-      </props.document>
-    </NoHydration>
-  );
-}