@solidjs/start 2.0.0-alpha.1 → 2.0.0-alpha.3

package/src/directives/remove-unused-variables.ts

@@ -0,0 +1,55 @@
+import type * as babel from "@babel/core";
+import * as t from "@babel/types";
+import { isPathValid } from "./paths.ts";
+
+export function removeUnusedVariables(program: babel.NodePath<t.Program>) {
+  // TODO(Alexis):
+  // This implementation is simple but slow
+  // We repeat removing unused variables from each pass
+  // until no potential unused variables are left.
+  // There might be a simpler implementation.
+  let dirty = true;
+
+  while (dirty) {
+    dirty = false;
+    program.traverse({
+      BindingIdentifier(path) {
+        const binding = path.scope.getBinding(path.node.name);
+
+        if (binding) {
+          switch (binding.kind) {
+            case "const":
+            case "let":
+            case "var":
+            case "hoisted":
+            case "module":
+              if (binding.references === 0 && !binding.path.removed) {
+                if (isPathValid(binding.path.parentPath, t.isImportDeclaration)) {
+                  const parent = binding.path.parentPath;
+                  if (parent.node.specifiers.length === 1) {
+                    parent.remove();
+                  } else {
+                    binding.path.remove();
+                  }
+                } else {
+                  binding.path.remove();
+                }
+                dirty = true;
+              }
+              break;
+            case "local":
+            case "param":
+            case "unknown":
+              break;
+          }
+        }
+      },
+      VariableDeclaration(path) {
+        if (path.node.declarations.length === 0) {
+          path.remove();
+        }
+      },
+    });
+    program.scope.crawl();
+  }
+}

package/src/directives/types.ts

@@ -0,0 +1,12 @@
+export interface NamedImportDefinition {
+  kind: "named";
+  name: string;
+  source: string;
+}
+
+export interface DefaultImportDefinition {
+  kind: "default";
+  source: string;
+}
+
+export type ImportDefinition = DefaultImportDefinition | NamedImportDefinition;

package/src/directives/xxhash32.ts

@@ -0,0 +1,214 @@
+// @ts-nocheck
+/**
+ * Copyright (c) 2019 Jason Dent
+ * https://github.com/Jason3S/xxhash
+ */
+const PRIME32_1 = 2654435761;
+const PRIME32_2 = 2246822519;
+const PRIME32_3 = 3266489917;
+const PRIME32_4 = 668265263;
+const PRIME32_5 = 374761393;
+
+function toUtf8(text: string): Uint8Array {
+  const bytes: number[] = [];
+  for (let i = 0, n = text.length; i < n; ++i) {
+    const c = text.charCodeAt(i);
+    if (c < 0x80) {
+      bytes.push(c);
+    } else if (c < 0x800) {
+      bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+    } else if (c < 0xd800 || c >= 0xe000) {
+      bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+    } else {
+      const cp =
+        0x10000 + (((c & 0x3ff) << 10) | (text.charCodeAt(++i) & 0x3ff));
+      bytes.push(
+        0xf0 | ((cp >> 18) & 0x7),
+        0x80 | ((cp >> 12) & 0x3f),
+        0x80 | ((cp >> 6) & 0x3f),
+        0x80 | (cp & 0x3f),
+      );
+    }
+  }
+  return new Uint8Array(bytes);
+}
+/**
+ *
+ * @param buffer - byte array or string
+ * @param seed - optional seed (32-bit unsigned);
+ */
+export default function xxHash32(
+  buffer: Uint8Array | string,
+  seed = 0,
+): number {
+  buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
+  const b = buffer;
+
+  /*
+    Step 1. Initialize internal accumulators
+    Each accumulator gets an initial value based on optional seed input.
+    Since the seed is optional, it can be 0.
+    ```
+      u32 acc1 = seed + PRIME32_1 + PRIME32_2;
+      u32 acc2 = seed + PRIME32_2;
+      u32 acc3 = seed + 0;
+      u32 acc4 = seed - PRIME32_1;
+    ```
+    Special case : input is less than 16 bytes
+    When input is too small (< 16 bytes), the algorithm will not process any stripe.
+    Consequently, it will not make use of parallel accumulators.
+    In which case, a simplified initialization is performed, using a single accumulator :
+    u32 acc  = seed + PRIME32_5;
+    The algorithm then proceeds directly to step 4.
+  */
+
+  let acc = (seed + PRIME32_5) & 0xffffffff;
+  let offset = 0;
+
+  if (b.length >= 16) {
+    const accN = [
+      (seed + PRIME32_1 + PRIME32_2) & 0xffffffff,
+      (seed + PRIME32_2) & 0xffffffff,
+      (seed + 0) & 0xffffffff,
+      (seed - PRIME32_1) & 0xffffffff,
+    ];
+
+    /*
+      Step 2. Process stripes
+      A stripe is a contiguous segment of 16 bytes. It is evenly divided into 4 lanes,
+      of 4 bytes each. The first lane is used to update accumulator 1, the second lane
+      is used to update accumulator 2, and so on. Each lane read its associated 32-bit
+      value using little-endian convention. For each {lane, accumulator}, the update
+      process is called a round, and applies the following formula :
+      ```
+      accN = accN + (laneN * PRIME32_2);
+      accN = accN <<< 13;
+      accN = accN * PRIME32_1;
+      ```
+      This shuffles the bits so that any bit from input lane impacts several bits in
+      output accumulator. All operations are performed modulo 2^32.
+      Input is consumed one full stripe at a time. Step 2 is looped as many times as
+      necessary to consume the whole input, except the last remaining bytes which cannot
+      form a stripe (< 16 bytes). When that happens, move to step 3.
+    */
+
+    const b = buffer;
+    const limit = b.length - 16;
+    let lane = 0;
+    for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
+      const i = offset;
+      const laneN0 = b[i + 0] + (b[i + 1] << 8);
+      const laneN1 = b[i + 2] + (b[i + 3] << 8);
+      const laneNP = laneN0 * PRIME32_2 + ((laneN1 * PRIME32_2) << 16);
+      let acc = (accN[lane] + laneNP) & 0xffffffff;
+      acc = (acc << 13) | (acc >>> 19);
+      const acc0 = acc & 0xffff;
+      const acc1 = acc >>> 16;
+      accN[lane] = (acc0 * PRIME32_1 + ((acc1 * PRIME32_1) << 16)) & 0xffffffff;
+      lane = (lane + 1) & 0x3;
+    }
+
+    /*
+      Step 3. Accumulator convergence
+      All 4 lane accumulators from previous steps are merged to produce a
+      single remaining accumulator
+      of same width (32-bit). The associated formula is as follows :
+      ```
+      acc = (acc1 <<< 1) + (acc2 <<< 7) + (acc3 <<< 12) + (acc4 <<< 18);
+      ```
+    */
+    acc =
+      (((accN[0] << 1) | (accN[0] >>> 31)) +
+        ((accN[1] << 7) | (accN[1] >>> 25)) +
+        ((accN[2] << 12) | (accN[2] >>> 20)) +
+        ((accN[3] << 18) | (accN[3] >>> 14))) &
+      0xffffffff;
+  }
+
+  /*
+    Step 4. Add input length
+    The input total length is presumed known at this stage.
+    This step is just about adding the length to
+    accumulator, so that it participates to final mixing.
+    ```
+    acc = acc + (u32)inputLength;
+    ```
+  */
+  acc = (acc + buffer.length) & 0xffffffff;
+
+  /*
+    Step 5. Consume remaining input
+    There may be up to 15 bytes remaining to consume from the input.
+    The final stage will digest them according
+    to following pseudo-code :
+    ```
+    while (remainingLength >= 4) {
+        lane = read_32bit_little_endian(input_ptr);
+        acc = acc + lane * PRIME32_3;
+        acc = (acc <<< 17) * PRIME32_4;
+        input_ptr += 4; remainingLength -= 4;
+    }
+    ```
+    This process ensures that all input bytes are present in the final mix.
+  */
+
+  const limit = buffer.length - 4;
+  for (; offset <= limit; offset += 4) {
+    const i = offset;
+    const laneN0 = b[i + 0] + (b[i + 1] << 8);
+    const laneN1 = b[i + 2] + (b[i + 3] << 8);
+    const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
+    acc = (acc + laneP) & 0xffffffff;
+    acc = (acc << 17) | (acc >>> 15);
+    acc =
+      ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) &
+      0xffffffff;
+  }
+
+  /*
+        ```
+        while (remainingLength >= 1) {
+            lane = read_byte(input_ptr);
+            acc = acc + lane * PRIME32_5;
+            acc = (acc <<< 11) * PRIME32_1;
+            input_ptr += 1; remainingLength -= 1;
+        }
+        ```
+    */
+
+  for (; offset < b.length; ++offset) {
+    const lane = b[offset];
+    acc += lane * PRIME32_5;
+    acc = (acc << 11) | (acc >>> 21);
+    acc =
+      ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) &
+      0xffffffff;
+  }
+
+  /*
+        Step 6. Final mix (avalanche)
+        The final mix ensures that all input bits have a chance to impact any bit in
+        the output digest, resulting in an unbiased distribution. This is also called
+        avalanche effect.
+        ```
+        acc = acc xor (acc >> 15);
+        acc = acc * PRIME32_2;
+        acc = acc xor (acc >> 13);
+        acc = acc * PRIME32_3;
+        acc = acc xor (acc >> 16);
+        ```
+    */
+
+  acc ^= acc >>> 15;
+  acc =
+    (((acc & 0xffff) * PRIME32_2) & 0xffffffff) +
+    (((acc >>> 16) * PRIME32_2) << 16);
+  acc ^= acc >>> 13;
+  acc =
+    (((acc & 0xffff) * PRIME32_3) & 0xffffffff) +
+    (((acc >>> 16) * PRIME32_3) << 16);
+  acc ^= acc >>> 16;
+
+  // turn any negatives back into a positive number;
+  return acc < 0 ? acc + 4294967296 : acc;
+}

package/src/env.d.ts

@@ -1,6 +1,6 @@
 // This file contains global type definitions that are internal to SolidStart and are not exported
 
-declare module "solidstart:server-fn-manifest" {
+declare module "solid-start:server-fn-manifest" {
   type ServerFn = (...args: Array<any>) => Promise<any>;
   export function getServerFnById(id: string): Promise<ServerFn>;
 }

package/src/fns/client.ts

@@ -0,0 +1,141 @@
+import { type Component } from "solid-js";
+import {
+  // serializeToJSONStream,
+  serializeToJSONString,
+} from "./serialization.ts";
+import {
+  BODY_FORMAT_KEY,
+  BodyFormat,
+  extractBody,
+  getHeadersAndBody,
+} from "./shared.ts";
+
+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 initializeResponse(
+  base: string,
+  id: string,
+  instance: string,
+  options: RequestInit,
+  args: any[],
+) {
+  // No args, skip serialization
+  if (args.length === 0) {
+    return createRequest(base, id, instance, options);
+  }
+  // For single arguments, we can directly encode as body
+  if (args.length === 1) {
+    const body = args[0];
+    const result = getHeadersAndBody(body);
+    if (result) {
+      return createRequest(base, id, instance, {
+        ...options,
+        body: result.body,
+        headers: {
+          ...options.headers,
+          ...result.headers,
+        },
+      });
+    }
+  }
+  // Fallback to seroval
+  return createRequest(base, id, instance, {
+    ...options,
+    // TODO(Alexis): move to serializeToJSONStream
+    body: await serializeToJSONString(args),
+    // duplex: 'half',
+    // body: serializeToJSONStream(args),
+    headers: {
+      ...options.headers,
+      "Content-Type": "text/plain",
+      [BODY_FORMAT_KEY]: BodyFormat.Seroval,
+    },
+  });
+}
+
+async function fetchServerFunction(
+  base: string,
+  id: string,
+  options: Omit<RequestInit, "body">,
+  args: any[],
+) {
+  const instance = `server-fn:${INSTANCE++}`;
+
+  const response = await initializeResponse(base, id, instance, options, args);
+
+  if (
+    response.headers.has("Location") ||
+    response.headers.has("X-Revalidate") ||
+    response.headers.has("X-Single-Flight")
+  ) {
+    if (response.body) {
+      /* @ts-ignore-next-line */
+      response.customBody = async () => {
+        return await extractBody(instance, true, response.clone());
+      };
+    }
+    return response;
+  }
+
+  const result = await extractBody(instance, true, response.clone());
+  if (response.headers.has("X-Error")) {
+    throw result;
+  }
+  return result;
+}
+
+export function cloneServerReference(id: string) {
+  let baseURL = import.meta.env.BASE_URL ?? "/";
+  if (!baseURL.endsWith("/")) baseURL += "/";
+
+  const fn = (...args: any[]) => fetchServerFunction(`${baseURL}_server`, id, {}, args);
+
+  return new Proxy(fn, {
+    get(target, prop, receiver) {
+      if (prop === "url") {
+        return `${baseURL}_server?id=${encodeURIComponent(id)}`;
+      }
+      if (prop === "GET") {
+        return receiver.withOptions({ method: "GET" });
+      }
+      if (prop === "withOptions") {
+        const url = `${baseURL}_server?id=${encodeURIComponent(id)}`;
+        return (options: RequestInit) => {
+          const fn = async (...args: any[]) => {
+            const encodeArgs = options.method && options.method.toUpperCase() === "GET";
+            return fetchServerFunction(
+              encodeArgs
+                ? url +
+                    (args.length
+                      ? `&args=${encodeURIComponent(await serializeToJSONString(args))}`
+                      : "")
+                : `${baseURL}_server`,
+              id,
+              options,
+              encodeArgs ? [] : args,
+            );
+          };
+          fn.url = url;
+          return fn;
+        };
+      }
+      return (target as any)[prop];
+    },
+  });
+}
+
+export function createClientReference(Component: Component<any>, id: string) {
+  return Component;
+}

package/src/fns/handler.spec.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import type { FetchEvent } from "./types.ts";
+
+vi.mock("h3", () => ({
+  parseCookies: vi.fn(() => ({})),
+  parseSetCookie: vi.fn(),
+}));
+
+vi.mock("solid-js/web", () => ({
+  renderToString: vi.fn(),
+  provideRequestEvent: vi.fn((_event, fn) => fn()),
+}));
+
+vi.mock("solid-start:server-fn-manifest", () => ({
+  getServerFnById: vi.fn(),
+}));
+
+vi.mock("./handler.ts", () => ({
+  createPageEvent: vi.fn(),
+}));
+
+vi.mock("./fetchEvent.ts", () => ({
+  getFetchEvent: vi.fn(),
+  mergeResponseHeaders: vi.fn(),
+}));
+
+function createMockFetchEvent(headers: Record<string, string> = {}): FetchEvent {
+  return {
+    request: new Request("http://localhost/test", { headers }),
+    response: {
+      headers: {
+        getSetCookie: () => [],
+      },
+    },
+    nativeEvent: {},
+    locals: {},
+  } as FetchEvent;
+}
+
+describe("createSingleFlightHeaders", () => {
+  let createSingleFlightHeaders: (sourceEvent: FetchEvent) => Headers;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const module = await import("./server-functions-handler.ts");
+    createSingleFlightHeaders = module.createSingleFlightHeaders;
+  });
+
+  it("should create a new Headers object instead of returning the original", () => {
+    const sourceEvent = createMockFetchEvent({
+      "content-type": "application/json",
+    });
+
+    const result = createSingleFlightHeaders(sourceEvent);
+
+    expect(result).not.toBe(sourceEvent.request.headers);
+  });
+
+  it("should not mutate the original request headers", () => {
+    const originalHeaders = new Headers({
+      "content-type": "application/json",
+      "cookie": "session=abc123",
+      "cf-ray": "abc123",
+      "cf-cache-status": "HIT",
+    });
+    const sourceEvent: FetchEvent = {
+      request: new Request("http://localhost/test", { headers: originalHeaders }),
+      response: {
+        headers: {
+          getSetCookie: () => [],
+        },
+      },
+      nativeEvent: {},
+      locals: {},
+    } as FetchEvent;
+
+    const originalCookieHeader = sourceEvent.request.headers.get("cookie");
+    const originalCfRay = sourceEvent.request.headers.get("cf-ray");
+
+    createSingleFlightHeaders(sourceEvent);
+
+    expect(sourceEvent.request.headers.get("cookie")).toBe(originalCookieHeader);
+    expect(sourceEvent.request.headers.get("cf-ray")).toBe(originalCfRay);
+  });
+});