@standardserver/fetch 0.0.0

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Standard Server
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,97 @@
+import { StandardBodyHint, StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse, StandardLazyResponse, StandardUrl } from '@standardserver/core';
+import { AsyncIteratorClass } from '@standardserver/shared';
+
+declare function toEventIterator(stream: ReadableStream<Uint8Array<ArrayBuffer>> | null): AsyncIteratorClass<unknown>;
+interface ToEventStreamOptions {
+    /**
+     * If true, a ping comment is sent periodically to keep the connection alive.
+     *
+     * @default true
+     */
+    keepAliveEnabled?: boolean;
+    /**
+     * Interval (in milliseconds) between ping comments sent after the last event.
+     *
+     * @default 5000
+     */
+    keepAliveInterval?: number;
+    /**
+     * The content of the ping comment. Must not include newline characters.
+     *
+     * @default ''
+     */
+    keepAliveComment?: string;
+    /**
+     * If true, an initial comment is sent immediately upon stream start to flush headers.
+     * This allows the receiving side to establish the connection without waiting for the first event.
+     *
+     * @default true
+     */
+    initialCommentEnabled?: boolean;
+    /**
+     * The content of the initial comment sent upon stream start. Must not include newline characters.
+     *
+     * @default ''
+     */
+    initialComment?: string;
+    /**
+     * If false, a 'close' event is only sent if the iterator returns a non-empty value (undefined).
+     * By default, a 'close' event is always sent when the iterator completes.
+     *
+     * @default true
+     */
+    alwaysSendCloseEvent?: boolean;
+}
+declare function toEventStream(iterator: AsyncIterator<unknown | void, unknown | void, void>, options?: ToEventStreamOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
+
+interface ToStandardBodyOptions {
+    /**
+     * Hints on how the body should be parsed.
+     */
+    hint?: StandardBodyHint | undefined;
+}
+/**
+ * Convert a fetch request or response to a standard body.
+ */
+declare function toStandardBody(re: Request | Response, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToFetchBodyOptions {
+    /**
+     * Options for the event iterator, like keep-alive settings, initial comment, etc.
+     */
+    eventIterator?: ToEventStreamOptions;
+}
+/**
+ * Convert a standard body to a fetch body.
+ */
+declare function toFetchBody(body: StandardBody, headers: StandardHeaders, options?: ToFetchBodyOptions): [
+    body: undefined | string | FormData | URLSearchParams | Blob | ReadableStream<Uint8Array<ArrayBuffer>>,
+    headers: StandardHeaders
+];
+
+/**
+ * Convert fetch headers to standard headers.
+ */
+declare function toStandardHeaders(headers: Headers): StandardHeaders;
+/**
+ * Convert standard headers to fetch headers.
+ */
+declare function toFetchHeaders(standardHeaders: StandardHeaders): Headers;
+
+/**
+ * Convert a fetch request to a standard request.
+ */
+declare function toStandardLazyRequest(request: Request): StandardLazyRequest;
+
+interface ToFetchResponseOptions {
+    /**
+     * Options for body conversion, like event iterator options, etc.
+     */
+    body?: ToFetchBodyOptions;
+}
+declare function toFetchResponse(standardResponse: StandardResponse, options?: ToFetchResponseOptions): Response;
+declare function toStandardLazyResponse(response: Response): StandardLazyResponse;
+
+declare function toStandardUrl(url: URL): StandardUrl;
+
+export { toEventIterator, toEventStream, toFetchBody, toFetchHeaders, toFetchResponse, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardLazyResponse, toStandardUrl };
+export type { ToEventStreamOptions, ToFetchBodyOptions, ToFetchResponseOptions, ToStandardBodyOptions };

package/dist/index.d.ts

@@ -0,0 +1,97 @@
+import { StandardBodyHint, StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse, StandardLazyResponse, StandardUrl } from '@standardserver/core';
+import { AsyncIteratorClass } from '@standardserver/shared';
+
+declare function toEventIterator(stream: ReadableStream<Uint8Array<ArrayBuffer>> | null): AsyncIteratorClass<unknown>;
+interface ToEventStreamOptions {
+    /**
+     * If true, a ping comment is sent periodically to keep the connection alive.
+     *
+     * @default true
+     */
+    keepAliveEnabled?: boolean;
+    /**
+     * Interval (in milliseconds) between ping comments sent after the last event.
+     *
+     * @default 5000
+     */
+    keepAliveInterval?: number;
+    /**
+     * The content of the ping comment. Must not include newline characters.
+     *
+     * @default ''
+     */
+    keepAliveComment?: string;
+    /**
+     * If true, an initial comment is sent immediately upon stream start to flush headers.
+     * This allows the receiving side to establish the connection without waiting for the first event.
+     *
+     * @default true
+     */
+    initialCommentEnabled?: boolean;
+    /**
+     * The content of the initial comment sent upon stream start. Must not include newline characters.
+     *
+     * @default ''
+     */
+    initialComment?: string;
+    /**
+     * If false, a 'close' event is only sent if the iterator returns a non-empty value (undefined).
+     * By default, a 'close' event is always sent when the iterator completes.
+     *
+     * @default true
+     */
+    alwaysSendCloseEvent?: boolean;
+}
+declare function toEventStream(iterator: AsyncIterator<unknown | void, unknown | void, void>, options?: ToEventStreamOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
+
+interface ToStandardBodyOptions {
+    /**
+     * Hints on how the body should be parsed.
+     */
+    hint?: StandardBodyHint | undefined;
+}
+/**
+ * Convert a fetch request or response to a standard body.
+ */
+declare function toStandardBody(re: Request | Response, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToFetchBodyOptions {
+    /**
+     * Options for the event iterator, like keep-alive settings, initial comment, etc.
+     */
+    eventIterator?: ToEventStreamOptions;
+}
+/**
+ * Convert a standard body to a fetch body.
+ */
+declare function toFetchBody(body: StandardBody, headers: StandardHeaders, options?: ToFetchBodyOptions): [
+    body: undefined | string | FormData | URLSearchParams | Blob | ReadableStream<Uint8Array<ArrayBuffer>>,
+    headers: StandardHeaders
+];
+
+/**
+ * Convert fetch headers to standard headers.
+ */
+declare function toStandardHeaders(headers: Headers): StandardHeaders;
+/**
+ * Convert standard headers to fetch headers.
+ */
+declare function toFetchHeaders(standardHeaders: StandardHeaders): Headers;
+
+/**
+ * Convert a fetch request to a standard request.
+ */
+declare function toStandardLazyRequest(request: Request): StandardLazyRequest;
+
+interface ToFetchResponseOptions {
+    /**
+     * Options for body conversion, like event iterator options, etc.
+     */
+    body?: ToFetchBodyOptions;
+}
+declare function toFetchResponse(standardResponse: StandardResponse, options?: ToFetchResponseOptions): Response;
+declare function toStandardLazyResponse(response: Response): StandardLazyResponse;
+
+declare function toStandardUrl(url: URL): StandardUrl;
+
+export { toEventIterator, toEventStream, toFetchBody, toFetchHeaders, toFetchResponse, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardLazyResponse, toStandardUrl };
+export type { ToEventStreamOptions, ToFetchBodyOptions, ToFetchResponseOptions, ToStandardBodyOptions };

package/dist/index.mjs

@@ -0,0 +1,273 @@
+import { getFilenameFromContentDisposition, generateContentDisposition } from '@standardserver/core';
+import { AsyncIteratorClass, parseEmptyableJSON, isTypescriptObject, stringifyJSON, AbortError, isAsyncIteratorObject } from '@standardserver/shared';
+import { EventStreamDecoderStream, withEventIteratorEventMeta, EventIteratorErrorEvent, encodeEventStreamMessage, resolveEventIteratorEvent, getEventIteratorEventMeta } from '@standardserver/core/event-stream';
+
+function toEventIterator(stream) {
+  const eventStream = stream?.pipeThrough(new TextDecoderStream()).pipeThrough(new EventStreamDecoderStream());
+  const reader = eventStream?.getReader();
+  let isCancelled = false;
+  return new AsyncIteratorClass(async () => {
+    while (true) {
+      if (reader === void 0) {
+        return { done: true, value: void 0 };
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        if (isCancelled) {
+          throw new AbortError("Stream was cancelled");
+        }
+        return { done: true, value: void 0 };
+      }
+      switch (value.event) {
+        case "message": {
+          let message = parseEmptyableJSON(value.data);
+          if (isTypescriptObject(message)) {
+            message = withEventIteratorEventMeta(message, value);
+          }
+          return { done: false, value: message };
+        }
+        case "error": {
+          let error = new EventIteratorErrorEvent(parseEmptyableJSON(value.data));
+          error = withEventIteratorEventMeta(error, value);
+          throw error;
+        }
+        case "close": {
+          let close = parseEmptyableJSON(value.data);
+          if (isTypescriptObject(close)) {
+            close = withEventIteratorEventMeta(close, value);
+          }
+          return { done: true, value: close };
+        }
+      }
+    }
+  }, async (isCompleted) => {
+    if (!isCompleted) {
+      isCancelled = true;
+    }
+    await reader?.cancel();
+  });
+}
+function toEventStream(iterator, options = {}) {
+  const keepAliveEnabled = options.keepAliveEnabled ?? true;
+  const keepAliveInterval = options.keepAliveInterval ?? 5e3;
+  const keepAliveComment = options.keepAliveComment ?? "";
+  const initialCommentEnabled = options.initialCommentEnabled ?? true;
+  const initialComment = options.initialComment ?? "";
+  const alwaysSendCloseEvent = options.alwaysSendCloseEvent ?? true;
+  let cancelled = false;
+  let timeout;
+  const stream = new ReadableStream({
+    start(controller) {
+      if (initialCommentEnabled) {
+        controller.enqueue(encodeEventStreamMessage({
+          comments: [initialComment]
+        }));
+      }
+    },
+    async pull(controller) {
+      try {
+        if (keepAliveEnabled) {
+          timeout = setInterval(() => {
+            controller.enqueue(encodeEventStreamMessage({
+              comments: [keepAliveComment]
+            }));
+          }, keepAliveInterval);
+        }
+        const result = await iterator.next();
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        const [data, meta] = resolveEventIteratorEvent(result.value);
+        if (alwaysSendCloseEvent || !result.done || data !== void 0 || meta !== void 0) {
+          const event = result.done ? "close" : "message";
+          controller.enqueue(encodeEventStreamMessage({
+            ...meta,
+            event,
+            data: stringifyJSON(data)
+          }));
+        }
+        if (result.done) {
+          controller.close();
+        }
+      } catch (err) {
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        if (err instanceof EventIteratorErrorEvent) {
+          controller.enqueue(encodeEventStreamMessage({
+            ...getEventIteratorEventMeta(err),
+            event: "error",
+            data: stringifyJSON(err.data)
+          }));
+          controller.close();
+        } else {
+          controller.error(err);
+        }
+      }
+    },
+    async cancel() {
+      cancelled = true;
+      clearInterval(timeout);
+      await iterator.return?.();
+    }
+  }).pipeThrough(new TextEncoderStream());
+  return stream;
+}
+
+async function toStandardBody(re, options) {
+  const hint = re.headers.get("standard-server") ?? options?.hint;
+  const mimeType = re.headers.get("content-type")?.split(";")[0]?.trim();
+  const contentDisposition = re.headers.get("content-disposition");
+  const contentLength = re.headers.get("content-length");
+  if (hint === "none") {
+    return void 0;
+  }
+  if (hint === void 0 && re.body === null) {
+    return void 0;
+  }
+  if (re.bodyUsed) {
+    throw new TypeError("Failed to read body: body stream already read");
+  }
+  if (hint === "json" || hint === void 0 && contentDisposition === null && mimeType === "application/json") {
+    const text = await re.text();
+    return parseEmptyableJSON(text);
+  }
+  if (hint === "form-data" || hint === void 0 && contentDisposition === null && mimeType === "multipart/form-data") {
+    return await re.formData();
+  }
+  if (hint === "url-search-params" || hint === void 0 && contentDisposition === null && mimeType === "application/x-www-form-urlencoded") {
+    const text = await re.text();
+    return new URLSearchParams(text);
+  }
+  if (hint === "event-stream" || hint === void 0 && contentDisposition === null && mimeType === "text/event-stream") {
+    return toEventIterator(re.body);
+  }
+  if (hint === "file" || hint === void 0 && (contentDisposition !== null || contentLength !== null)) {
+    const fileName = contentDisposition !== null ? getFilenameFromContentDisposition(contentDisposition) : void 0;
+    const blob = await re.blob();
+    return new File([blob], fileName ?? "blob", {
+      type: blob.type
+    });
+  }
+  return re.body ?? new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function toFetchBody(body, headers, options = {}) {
+  headers = { ...headers };
+  if (body === void 0) {
+    headers["standard-server"] = "none";
+    return [void 0, headers];
+  }
+  if (body instanceof ReadableStream) {
+    headers["standard-server"] = "octet-stream";
+    headers["content-type"] ??= "application/octet-stream";
+    return [body, headers];
+  }
+  if (body instanceof Blob) {
+    headers["standard-server"] = "file";
+    headers["content-type"] ??= body.type;
+    headers["content-disposition"] ??= generateContentDisposition(body instanceof File ? body.name : "blob");
+    if (Number.isNaN(body.size)) {
+      return [body.stream(), headers];
+    }
+    headers["content-length"] ??= body.size.toString();
+    return [body, headers];
+  }
+  if (body instanceof FormData) {
+    headers["standard-server"] = "form-data";
+    return [body, headers];
+  }
+  if (body instanceof URLSearchParams) {
+    headers["standard-server"] = "url-search-params";
+    return [body, headers];
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers["standard-server"] = "event-stream";
+    headers["content-type"] ??= "text/event-stream";
+    return [toEventStream(body, options.eventIterator), headers];
+  }
+  headers["standard-server"] = "json";
+  headers["content-type"] ??= "application/json";
+  return [stringifyJSON(body), headers];
+}
+
+function toStandardHeaders(headers) {
+  const standardHeaders = {};
+  headers.forEach((value, key) => {
+    if (Array.isArray(standardHeaders[key])) {
+      standardHeaders[key].push(value);
+    } else if (standardHeaders[key] !== void 0) {
+      standardHeaders[key] = [standardHeaders[key], value];
+    } else {
+      standardHeaders[key] = value;
+    }
+  });
+  return standardHeaders;
+}
+function toFetchHeaders(standardHeaders) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(standardHeaders)) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        headers.append(key, v);
+      }
+    } else if (value !== void 0) {
+      headers.append(key, value);
+    }
+  }
+  return headers;
+}
+
+function toStandardUrl(url) {
+  const pathname = `${url.pathname.startsWith("/") ? "" : "/"}${url.pathname}`;
+  return `${pathname}${url.search}${url.hash}`;
+}
+
+function toStandardLazyRequest(request) {
+  const url = new URL(request.url);
+  return {
+    url: toStandardUrl(url),
+    method: request.method,
+    get headers() {
+      const headers = toStandardHeaders(request.headers);
+      Object.defineProperty(this, "headers", { value: headers, writable: true });
+      return headers;
+    },
+    set headers(value) {
+      Object.defineProperty(this, "headers", { value, writable: true });
+    },
+    resolveBody: (hint) => toStandardBody(request, { hint }),
+    signal: request.signal
+  };
+}
+
+function toFetchResponse(standardResponse, options = {}) {
+  const [body, standardHeaders] = toFetchBody(standardResponse.body, standardResponse.headers, options.body);
+  const response = new Response(body, {
+    headers: toFetchHeaders(standardHeaders),
+    status: standardResponse.status
+  });
+  void response.body;
+  return response;
+}
+function toStandardLazyResponse(response) {
+  return {
+    resolveBody: (hint) => toStandardBody(response, { hint }),
+    status: response.status,
+    get headers() {
+      const headers = toStandardHeaders(response.headers);
+      Object.defineProperty(this, "headers", { value: headers, writable: true });
+      return headers;
+    },
+    set headers(value) {
+      Object.defineProperty(this, "headers", { value, writable: true });
+    }
+  };
+}
+
+export { toEventIterator, toEventStream, toFetchBody, toFetchHeaders, toFetchResponse, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardLazyResponse, toStandardUrl };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@standardserver/fetch",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "homepage": "https://standardserver.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/standardserver/standardserver.git",
+    "directory": "packages/fetch"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@standardserver/core": "0.0.0",
+    "@standardserver/shared": "0.0.0"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^1.19.7"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "type:check": "tsc -b"
+  }
+}