@solidjs/web 2.0.0-beta.2 → 2.0.0-beta.20

package/server-functions/dist/server.js

@@ -0,0 +1,531 @@
+import { sharedConfig } from 'solid-js';
+import { fromCrossJSON, Feature, toCrossJSONStream } from 'seroval';
+import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
+
+const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
+function isResponseEnvelope(value) {
+  return !!(value && typeof value === "object" && value[ENVELOPE]);
+}
+
+Feature.AggregateError | Feature.BigIntTypedArray;
+const DEFAULT_WEB_PLUGINS = Object.freeze([AbortSignalPlugin,
+CustomEventPlugin, DOMExceptionPlugin, EventPlugin,
+FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin]);
+function resolveSerializerPlugins(customPlugins) {
+  return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
+}
+const JSON_CODEC_DISABLED_FEATURES = Feature.RegExp;
+const JSON_CODEC_DEPTH_LIMIT = 64;
+function resolveCodecOptions({
+  plugins,
+  disabledFeatures,
+  depthLimit
+} = {}) {
+  return {
+    plugins: resolveSerializerPlugins(plugins),
+    disabledFeatures: disabledFeatures === undefined ? JSON_CODEC_DISABLED_FEATURES : disabledFeatures,
+    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit
+  };
+}
+function serializeJSON(value, {
+  onParse,
+  onDone,
+  onError,
+  ...codecOptions
+}) {
+  return toCrossJSONStream(value, {
+    onParse,
+    onDone,
+    onError,
+    ...resolveCodecOptions(codecOptions)
+  });
+}
+function createJSONDeserializer(options) {
+  const refs = new Map();
+  const resolved = resolveCodecOptions(options);
+  return function deserializeJSONChunk(node) {
+    return fromCrossJSON(node, {
+      refs,
+      ...resolved
+    });
+  };
+}
+
+const RequestContext = Symbol.for("solid.RequestContext");
+function getRequestEvent() {
+  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || sharedConfig.context && sharedConfig.context.event || console.warn("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+}
+
+const codecConfig = {
+  codec: undefined
+};
+function configureServerFunctionsCodec(codec) {
+  codecConfig.codec = codec;
+}
+function getServerFunctionsCodec() {
+  return codecConfig.codec;
+}
+const FUNCTION_HEADER = "X-Server-Function-Id";
+const INSTANCE_HEADER = "X-Server-Function-Instance";
+const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+const FILE_FORM_KEY = "__server_function_file__";
+const BodyFormat = {
+  Serialized: "0",
+  String: "1",
+  FormData: "2",
+  URLSearchParams: "3",
+  Blob: "4",
+  File: "5",
+  ArrayBuffer: "6",
+  Uint8Array: "7"
+};
+function getHeadersAndBody(body) {
+  switch (true) {
+    case typeof body === "string":
+      return {
+        headers: {
+          "Content-Type": "text/plain",
+          [BODY_FORMAT_HEADER]: BodyFormat.String
+        },
+        body
+      };
+    case body instanceof FormData:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.FormData
+        },
+        body
+      };
+    case body instanceof URLSearchParams:
+      return {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          [BODY_FORMAT_HEADER]: BodyFormat.URLSearchParams
+        },
+        body
+      };
+    case typeof File !== "undefined" && body instanceof File:
+      {
+        const formData = new FormData();
+        formData.append(FILE_FORM_KEY, body, body.name);
+        return {
+          headers: {
+            [BODY_FORMAT_HEADER]: BodyFormat.File
+          },
+          body: formData
+        };
+      }
+    case body instanceof Blob:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Blob
+        },
+        body
+      };
+    case body instanceof ArrayBuffer:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.ArrayBuffer
+        },
+        body
+      };
+    case body instanceof Uint8Array:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Uint8Array
+        },
+        body: new Uint8Array(body)
+      };
+    default:
+      return undefined;
+  }
+}
+async function extractBody(source, codecOptions) {
+  const contentType = source.headers.get("content-type");
+  const format = source.headers.get(BODY_FORMAT_HEADER);
+  const clone = source.clone();
+  switch (true) {
+    case format === BodyFormat.Serialized:
+      return await deserializeStream(clone, codecOptions);
+    case format === BodyFormat.String:
+      return await clone.text();
+    case format === BodyFormat.File:
+      {
+        const formData = await clone.formData();
+        return formData.get(FILE_FORM_KEY);
+      }
+    case format === BodyFormat.FormData:
+    case contentType && contentType.startsWith("multipart/form-data"):
+      return await clone.formData();
+    case format === BodyFormat.URLSearchParams:
+    case contentType && contentType.startsWith("application/x-www-form-urlencoded"):
+      return new URLSearchParams(await clone.text());
+    case format === BodyFormat.Blob:
+      return await clone.blob();
+    case format === BodyFormat.ArrayBuffer:
+      return await clone.arrayBuffer();
+    case format === BodyFormat.Uint8Array:
+      return new Uint8Array(await clone.arrayBuffer());
+  }
+  return undefined;
+}
+function createChunk(data) {
+  const encodeData = new TextEncoder().encode(data);
+  const bytes = encodeData.length;
+  const baseHex = bytes.toString(16);
+  const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex;
+  const head = new TextEncoder().encode(`;0x${totalHex};`);
+  const chunk = new Uint8Array(12 + bytes);
+  chunk.set(head);
+  chunk.set(encodeData, 12);
+  return chunk;
+}
+class ChunkReader {
+  constructor(stream) {
+    this.reader = stream.getReader();
+    this.buffer = new Uint8Array(0);
+    this.done = false;
+  }
+  async readChunk() {
+    const chunk = await this.reader.read();
+    if (!chunk.done) {
+      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
+      newBuffer.set(this.buffer);
+      newBuffer.set(chunk.value, this.buffer.length);
+      this.buffer = newBuffer;
+    } else {
+      this.done = true;
+    }
+  }
+  async next() {
+    if (this.buffer.length === 0) {
+      if (this.done) {
+        return {
+          done: true,
+          value: undefined
+        };
+      }
+      await this.readChunk();
+      return await this.next();
+    }
+    const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
+    const bytes = Number.parseInt(head, 16);
+    if (Number.isNaN(bytes)) {
+      throw new Error("Malformed server function stream.");
+    }
+    while (bytes > this.buffer.length - 12) {
+      if (this.done) {
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
+    this.buffer = this.buffer.subarray(12 + bytes);
+    return {
+      done: false,
+      value: partial
+    };
+  }
+  async drain(interpret) {
+    while (true) {
+      const result = await this.next();
+      if (result.done) {
+        break;
+      }
+      interpret(result.value);
+    }
+  }
+}
+function serializeStream(value, codecOptions) {
+  return new ReadableStream({
+    start(controller) {
+      serializeJSON(value, {
+        ...codecOptions,
+        onParse(node) {
+          controller.enqueue(createChunk(JSON.stringify(node)));
+        },
+        onDone() {
+          controller.close();
+        },
+        onError(error) {
+          controller.error(error);
+        }
+      });
+    }
+  });
+}
+async function deserializeStream(source, codecOptions) {
+  if (!source.body) {
+    throw new Error("missing body");
+  }
+  const reader = new ChunkReader(source.body);
+  const result = await reader.next();
+  if (!result.done) {
+    const deserializeChunk = createJSONDeserializer(codecOptions);
+    function interpretChunk(chunk) {
+      return deserializeChunk(JSON.parse(chunk));
+    }
+    void reader.drain(interpretChunk);
+    return interpretChunk(result.value);
+  }
+  return undefined;
+}
+async function deserializeString(text, codecOptions) {
+  return await deserializeStream(new Response(text), codecOptions);
+}
+async function decodeResponse(response, codecOptions) {
+  if (!response.body) return undefined;
+  return await extractBody(response, codecOptions === undefined ? codecConfig.codec : codecOptions);
+}
+
+const config = {
+  provideEvent: undefined,
+  endpoint: "/_server"
+};
+function configureServerFunctionsServer({
+  provideEvent,
+  endpoint,
+  codec
+} = {}) {
+  if (provideEvent !== undefined) config.provideEvent = provideEvent;
+  if (endpoint !== undefined) config.endpoint = endpoint;
+  if (codec !== undefined) configureServerFunctionsCodec(codec);
+}
+function provideEvent(event, fn) {
+  if (config.provideEvent) return config.provideEvent(event, fn);
+  const ctx = globalThis[RequestContext];
+  if (ctx) return ctx.run(event, fn);
+  throw new Error("No request event provider. Configure one with configureServerFunctionsServer({ provideEvent }).");
+}
+const REGISTRATIONS = new Map();
+function registerServerFunction(id, callback) {
+  REGISTRATIONS.set(id, callback);
+  return callback;
+}
+function getServerFunction(id) {
+  const fn = REGISTRATIONS.get(id);
+  if (fn) {
+    return fn;
+  }
+  throw new Error("invalid server function: " + id);
+}
+function registerServerReference(id, fn) {
+  registerServerFunction(id, fn);
+  return {
+    id,
+    fn
+  };
+}
+function createServerReference({
+  id,
+  fn
+}) {
+  if (typeof fn !== "function") throw new Error("Export from a 'use server' module must be a function");
+  return new Proxy(fn, {
+    get(target, prop, receiver) {
+      if (prop === "url") {
+        return `${config.endpoint}?id=${encodeURIComponent(id)}`;
+      }
+      if (prop === "GET") return receiver;
+      return target[prop];
+    },
+    apply(target, thisArg, args) {
+      const ogEvt = getRequestEvent();
+      if (!ogEvt) throw new Error("Cannot call server function outside of a request");
+      const evt = {
+        ...ogEvt
+      };
+      evt.locals.serverFunctionMeta = {
+        id
+      };
+      evt.serverOnly = true;
+      return provideEvent(evt, () => {
+        return fn.apply(thisArg, args);
+      });
+    }
+  });
+}
+function getServerFunctionMeta() {
+  const event = getRequestEvent();
+  return event && event.locals.serverFunctionMeta;
+}
+function resolveFunctionId(request, url) {
+  const reference = request.headers.get(FUNCTION_HEADER);
+  if (reference) {
+    return reference.split("#")[0];
+  }
+  return url.searchParams.get("id");
+}
+async function parseArguments(request, url, instance, codec) {
+  const parsed = [];
+  if (!instance || request.method === "GET") {
+    const args = url.searchParams.get("args");
+    if (args) {
+      const result = args.startsWith(";0x") ? await deserializeString(args, codec) : JSON.parse(args);
+      for (const arg of result) {
+        parsed.push(arg);
+      }
+    }
+  }
+  if (request.method === "POST" && request.body !== null) {
+    const format = request.headers.get(BODY_FORMAT_HEADER);
+    const decoded = await extractBody(request.clone(), codec);
+    if (format === BodyFormat.Serialized) {
+      return decoded;
+    }
+    parsed.push(decoded);
+  }
+  return parsed;
+}
+function serializedResponse(value, headers, codec) {
+  headers.set(BODY_FORMAT_HEADER, BodyFormat.Serialized);
+  headers.set("Content-Type", "text/plain");
+  return new Response(serializeStream(value, codec), {
+    headers
+  });
+}
+function encodeResult(value, headers, status, codec) {
+  const direct = getHeadersAndBody(value);
+  if (direct) {
+    for (const [key, val] of Object.entries(direct.headers || {})) {
+      headers.set(key, val);
+    }
+    return new Response(direct.body, {
+      status,
+      headers
+    });
+  }
+  const response = serializedResponse(value, headers, codec);
+  return status === 200 ? response : new Response(response.body, {
+    status,
+    headers
+  });
+}
+async function handleServerFunctionRequest(request, options = {}) {
+  const codec = options.codec !== undefined ? options.codec : getServerFunctionsCodec();
+  const url = new URL(request.url);
+  const instance = request.headers.get(INSTANCE_HEADER);
+  const functionId = resolveFunctionId(request, url);
+  if (!functionId) {
+    return new Response(process.env.NODE_ENV === "development" ? "Server function not found" : null, {
+      status: 404
+    });
+  }
+  let serverFunction;
+  try {
+    serverFunction = getServerFunction(functionId);
+  } catch {
+    return new Response(process.env.NODE_ENV === "development" ? `Unknown server function: ${functionId}` : null, {
+      status: 404
+    });
+  }
+  const event = options.createEvent ? options.createEvent(request) : {
+    request,
+    locals: {}
+  };
+  const provide = options.provideEvent || provideEvent;
+  const parsed = await parseArguments(request, url, instance, codec);
+  const headers = new Headers();
+  try {
+    let result = await provide(event, async () => {
+      event.locals.serverFunctionMeta = {
+        id: functionId
+      };
+      return serverFunction(...parsed);
+    });
+    if (options.transformResult) {
+      result = await options.transformResult(event, result, {
+        instance,
+        request
+      });
+    }
+    let status = 200;
+    if (isResponseEnvelope(result)) {
+      const {
+        response,
+        value
+      } = result;
+      if (!instance && !options.handleNoJS && response && response.body) {
+        return response;
+      }
+      if (response && response.headers) {
+        response.headers.forEach((val, key) => headers.append(key, val));
+      }
+      if (response && response.status && (response.status < 300 || response.status >= 400)) {
+        status = response.status;
+      }
+      result = value;
+    } else if (result instanceof Response) {
+      if (result.headers && result.headers.has("X-Content-Raw")) return result;
+      if (instance) {
+        if (result.headers) {
+          result.headers.forEach((value, key) => headers.append(key, value));
+        }
+        if (result.status && (result.status < 300 || result.status >= 400)) {
+          status = result.status;
+        }
+        if (result.body == null) {
+          result = null;
+        }
+      }
+    }
+    if (!instance) {
+      if (options.handleNoJS) return options.handleNoJS(result, request, parsed);
+      if (result instanceof Response) return result;
+      return encodeResult(result, headers, 200, codec);
+    }
+    return encodeResult(result, headers, status, codec);
+  } catch (x) {
+    if (x instanceof Response || isResponseEnvelope(x)) {
+      if (options.transformResult) {
+        x = await options.transformResult(event, x, {
+          instance,
+          request,
+          thrown: true
+        });
+      }
+      let status = 200;
+      if (isResponseEnvelope(x)) {
+        const {
+          response,
+          value
+        } = x;
+        if (response && response.headers) {
+          response.headers.forEach((val, key) => headers.append(key, val));
+        }
+        if (response && response.status && (!instance || response.status < 300 || response.status >= 400)) {
+          status = response.status;
+        }
+        x = value;
+      } else if (x instanceof Response) {
+        if (x.headers) {
+          x.headers.forEach((value, key) => headers.append(key, value));
+        }
+        if (x.status && (!instance || x.status < 300 || x.status >= 400)) {
+          status = x.status;
+        }
+        if (x.body == null) {
+          x = null;
+        }
+      }
+      headers.set("X-Server-Function-Error", "true");
+      if (!instance) {
+        if (options.handleNoJS) return options.handleNoJS(x, request, parsed, true);
+        if (x instanceof Response) return x;
+      }
+      return encodeResult(x, headers, status, codec);
+    }
+    if (!instance) {
+      if (options.handleNoJS) return options.handleNoJS(x, request, parsed, true);
+      const message = x instanceof Error ? x.message : String(x);
+      return new Response(process.env.NODE_ENV === "development" ? message : null, {
+        status: 500
+      });
+    }
+    const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
+    headers.set("X-Server-Function-Error", error.replace(/[\r\n]+/g, ""));
+    return encodeResult(x, headers, 200, codec);
+  }
+}
+
+export { FUNCTION_HEADER, INSTANCE_HEADER, configureServerFunctionsServer, createServerReference, decodeResponse, getServerFunction, getServerFunctionMeta, handleServerFunctionRequest, registerServerFunction, registerServerReference };

package/server-functions/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@solidjs/web/server-functions",
+  "main": "./dist/server.cjs",
+  "module": "./dist/server.js",
+  "types": "../types/server-functions/server.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "browser": {
+        "import": {
+          "types": "../types/server-functions/client.d.ts",
+          "default": "./dist/client.js"
+        },
+        "require": {
+          "types": "../types-cjs/server-functions/client.d.cts",
+          "default": "./dist/client.cjs"
+        }
+      },
+      "import": {
+        "types": "../types/server-functions/server.d.ts",
+        "default": "./dist/server.js"
+      },
+      "require": {
+        "types": "../types-cjs/server-functions/server.d.cts",
+        "default": "./dist/server.cjs"
+      }
+    }
+  }
+}

package/storage/package.json

@@ -7,9 +7,14 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./types/index.d.ts",
-      "import": "./dist/storage.js",
-      "require": "./dist/storage.cjs"
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./dist/storage.js"
+      },
+      "require": {
+        "types": "./types-cjs/index.d.cts",
+        "default": "./dist/storage.cjs"
+      }
     }
   }
 }

package/storage/types/index.d.ts

@@ -1,2 +1,28 @@
 import type { RequestEvent } from "@solidjs/web";
+/**
+ * Establishes the request-event scope for a server request: everything
+ * `cb` runs (across `await`s, via AsyncLocalStorage) sees `init` from
+ * `getRequestEvent()`. Call it at the top of the server's request handling,
+ * wrapping SSR and server-function dispatch; the server-functions runtime
+ * also picks the scope up automatically as its default event provider.
+ *
+ * Lives on its own subpath because it imports `node:async_hooks` — keep it
+ * out of environments without that module.
+ *
+ * @example
+ * ```ts
+ * import { provideRequestEvent } from "@solidjs/web/storage";
+ *
+ * async function handler(request: Request) {
+ *   return provideRequestEvent({ request, locals: {} }, () =>
+ *     renderToStringAsync(() => <App />)
+ *   );
+ * }
+ * ```
+ *
+ * @param init the event for this request — frameworks pass their richer
+ * event shapes
+ * @param cb runs synchronously; its return value is passed through
+ * @throws on the client, where there is no request to scope
+ */
 export declare function provideRequestEvent<T extends RequestEvent, U>(init: T, cb: () => U): U;

package/storage/types-cjs/index.d.cts

@@ -0,0 +1,28 @@
+import type { RequestEvent } from "@solidjs/web";
+/**
+ * Establishes the request-event scope for a server request: everything
+ * `cb` runs (across `await`s, via AsyncLocalStorage) sees `init` from
+ * `getRequestEvent()`. Call it at the top of the server's request handling,
+ * wrapping SSR and server-function dispatch; the server-functions runtime
+ * also picks the scope up automatically as its default event provider.
+ *
+ * Lives on its own subpath because it imports `node:async_hooks` — keep it
+ * out of environments without that module.
+ *
+ * @example
+ * ```ts
+ * import { provideRequestEvent } from "@solidjs/web/storage";
+ *
+ * async function handler(request: Request) {
+ *   return provideRequestEvent({ request, locals: {} }, () =>
+ *     renderToStringAsync(() => <App />)
+ *   );
+ * }
+ * ```
+ *
+ * @param init the event for this request — frameworks pass their richer
+ * event shapes
+ * @param cb runs synchronously; its return value is passed through
+ * @throws on the client, where there is no request to scope
+ */
+export declare function provideRequestEvent<T extends RequestEvent, U>(init: T, cb: () => U): U;

package/storage/types-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}