@temporary-name/standard-server-fetch 1.9.3-alpha.0d2fa3247b6b23bbc2e3097a95f631b86740e4d8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stainless
+
+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/README.md

@@ -0,0 +1,3 @@
+## `@temporary-name/standard-server-fetch`
+
+[Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) server adapter for oRPC.

package/dist/index.d.mts

@@ -0,0 +1,64 @@
+import { StandardBody, StandardHeaders, StandardLazyRequest, StandardRequest, StandardResponse, StandardLazyResponse } from '@temporary-name/standard-server';
+import { SetSpanErrorOptions, AsyncIteratorClass } from '@temporary-name/shared';
+
+interface ToEventIteratorOptions extends SetSpanErrorOptions {
+}
+declare function toEventIterator(stream: ReadableStream | null, options?: ToEventIteratorOptions): AsyncIteratorClass<unknown>;
+interface ToEventStreamOptions {
+    /**
+     * If true, a ping comment is sent periodically to keep the connection alive.
+     *
+     * @default true
+     */
+    eventIteratorKeepAliveEnabled?: boolean;
+    /**
+     * Interval (in milliseconds) between ping comments sent after the last event.
+     *
+     * @default 5000
+     */
+    eventIteratorKeepAliveInterval?: number;
+    /**
+     * The content of the ping comment. Must not include newline characters.
+     *
+     * @default ''
+     */
+    eventIteratorKeepAliveComment?: string;
+}
+declare function toEventStream(iterator: AsyncIterator<unknown | void, unknown | void, void>, options?: ToEventStreamOptions): ReadableStream<Uint8Array>;
+
+interface ToStandardBodyOptions extends ToEventIteratorOptions {
+}
+declare function toStandardBody(re: Request | Response, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToFetchBodyOptions extends ToEventStreamOptions {
+}
+/**
+ * @param body
+ * @param headers - The headers can be changed by the function and effects on the original headers.
+ */
+declare function toFetchBody(body: StandardBody, headers: Headers, options?: ToFetchBodyOptions): string | Blob | FormData | URLSearchParams | undefined | ReadableStream<Uint8Array>;
+
+/**
+ * @param headers
+ * @param standardHeaders - The base headers can be changed by the function and effects on the original headers.
+ */
+declare function toStandardHeaders(headers: Headers, standardHeaders?: StandardHeaders): StandardHeaders;
+/**
+ * @param headers
+ * @param fetchHeaders - The base headers can be changed by the function and effects on the original headers.
+ */
+declare function toFetchHeaders(headers: StandardHeaders, fetchHeaders?: Headers): Headers;
+
+declare function toStandardLazyRequest(request: Request): StandardLazyRequest;
+interface ToFetchRequestOptions extends ToFetchBodyOptions {
+}
+declare function toFetchRequest(request: StandardRequest, options?: ToFetchRequestOptions): Request;
+
+interface ToFetchResponseOptions extends ToFetchBodyOptions {
+}
+declare function toFetchResponse(response: StandardResponse, options?: ToFetchResponseOptions): Response;
+interface ToStandardLazyResponseOptions extends ToStandardBodyOptions {
+}
+declare function toStandardLazyResponse(response: Response, options?: ToStandardLazyResponseOptions): StandardLazyResponse;
+
+export { toEventIterator, toEventStream, toFetchBody, toFetchHeaders, toFetchRequest, toFetchResponse, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardLazyResponse };
+export type { ToEventIteratorOptions, ToEventStreamOptions, ToFetchBodyOptions, ToFetchRequestOptions, ToFetchResponseOptions, ToStandardBodyOptions, ToStandardLazyResponseOptions };

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import { StandardBody, StandardHeaders, StandardLazyRequest, StandardRequest, StandardResponse, StandardLazyResponse } from '@temporary-name/standard-server';
+import { SetSpanErrorOptions, AsyncIteratorClass } from '@temporary-name/shared';
+
+interface ToEventIteratorOptions extends SetSpanErrorOptions {
+}
+declare function toEventIterator(stream: ReadableStream | null, options?: ToEventIteratorOptions): AsyncIteratorClass<unknown>;
+interface ToEventStreamOptions {
+    /**
+     * If true, a ping comment is sent periodically to keep the connection alive.
+     *
+     * @default true
+     */
+    eventIteratorKeepAliveEnabled?: boolean;
+    /**
+     * Interval (in milliseconds) between ping comments sent after the last event.
+     *
+     * @default 5000
+     */
+    eventIteratorKeepAliveInterval?: number;
+    /**
+     * The content of the ping comment. Must not include newline characters.
+     *
+     * @default ''
+     */
+    eventIteratorKeepAliveComment?: string;
+}
+declare function toEventStream(iterator: AsyncIterator<unknown | void, unknown | void, void>, options?: ToEventStreamOptions): ReadableStream<Uint8Array>;
+
+interface ToStandardBodyOptions extends ToEventIteratorOptions {
+}
+declare function toStandardBody(re: Request | Response, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToFetchBodyOptions extends ToEventStreamOptions {
+}
+/**
+ * @param body
+ * @param headers - The headers can be changed by the function and effects on the original headers.
+ */
+declare function toFetchBody(body: StandardBody, headers: Headers, options?: ToFetchBodyOptions): string | Blob | FormData | URLSearchParams | undefined | ReadableStream<Uint8Array>;
+
+/**
+ * @param headers
+ * @param standardHeaders - The base headers can be changed by the function and effects on the original headers.
+ */
+declare function toStandardHeaders(headers: Headers, standardHeaders?: StandardHeaders): StandardHeaders;
+/**
+ * @param headers
+ * @param fetchHeaders - The base headers can be changed by the function and effects on the original headers.
+ */
+declare function toFetchHeaders(headers: StandardHeaders, fetchHeaders?: Headers): Headers;
+
+declare function toStandardLazyRequest(request: Request): StandardLazyRequest;
+interface ToFetchRequestOptions extends ToFetchBodyOptions {
+}
+declare function toFetchRequest(request: StandardRequest, options?: ToFetchRequestOptions): Request;
+
+interface ToFetchResponseOptions extends ToFetchBodyOptions {
+}
+declare function toFetchResponse(response: StandardResponse, options?: ToFetchResponseOptions): Response;
+interface ToStandardLazyResponseOptions extends ToStandardBodyOptions {
+}
+declare function toStandardLazyResponse(response: Response, options?: ToStandardLazyResponseOptions): StandardLazyResponse;
+
+export { toEventIterator, toEventStream, toFetchBody, toFetchHeaders, toFetchRequest, toFetchResponse, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardLazyResponse };
+export type { ToEventIteratorOptions, ToEventStreamOptions, ToFetchBodyOptions, ToFetchRequestOptions, ToFetchResponseOptions, ToStandardBodyOptions, ToStandardLazyResponseOptions };

package/dist/index.mjs

@@ -0,0 +1,296 @@
+import { AsyncIteratorClass, startSpan, runInSpanContext, AbortError, parseEmptyableJSON, isTypescriptObject, setSpanError, stringifyJSON, runWithSpan, isAsyncIteratorObject, once } from '@temporary-name/shared';
+import { EventDecoderStream, withEventMeta, ErrorEvent, encodeEventMessage, getEventMeta, getFilenameFromContentDisposition, generateContentDisposition } from '@temporary-name/standard-server';
+
+function toEventIterator(stream, options = {}) {
+  const eventStream = stream?.pipeThrough(new TextDecoderStream()).pipeThrough(new EventDecoderStream());
+  const reader = eventStream?.getReader();
+  let span;
+  let isCancelled = false;
+  return new AsyncIteratorClass(
+    async () => {
+      span ??= startSpan("consume_event_iterator_stream");
+      try {
+        while (true) {
+          if (reader === void 0) {
+            return { done: true, value: void 0 };
+          }
+          const { done, value } = await runInSpanContext(span, () => 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 = withEventMeta(message, value);
+              }
+              span?.addEvent("message");
+              return { done: false, value: message };
+            }
+            case "error": {
+              let error = new ErrorEvent({
+                data: parseEmptyableJSON(value.data)
+              });
+              error = withEventMeta(error, value);
+              span?.addEvent("error");
+              throw error;
+            }
+            case "done": {
+              let done2 = parseEmptyableJSON(value.data);
+              if (isTypescriptObject(done2)) {
+                done2 = withEventMeta(done2, value);
+              }
+              span?.addEvent("done");
+              return { done: true, value: done2 };
+            }
+            default: {
+              span?.addEvent("maybe_keepalive");
+            }
+          }
+        }
+      } catch (e) {
+        if (!(e instanceof ErrorEvent)) {
+          setSpanError(span, e, options);
+        }
+        throw e;
+      }
+    },
+    async (reason) => {
+      try {
+        if (reason !== "next") {
+          isCancelled = true;
+          span?.addEvent("cancelled");
+        }
+        await runInSpanContext(span, () => reader?.cancel());
+      } catch (e) {
+        setSpanError(span, e, options);
+        throw e;
+      } finally {
+        span?.end();
+      }
+    }
+  );
+}
+function toEventStream(iterator, options = {}) {
+  const keepAliveEnabled = options.eventIteratorKeepAliveEnabled ?? true;
+  const keepAliveInterval = options.eventIteratorKeepAliveInterval ?? 5e3;
+  const keepAliveComment = options.eventIteratorKeepAliveComment ?? "";
+  let cancelled = false;
+  let timeout;
+  let span;
+  const stream = new ReadableStream({
+    start() {
+      span = startSpan("stream_event_iterator");
+    },
+    async pull(controller) {
+      try {
+        if (keepAliveEnabled) {
+          timeout = setInterval(() => {
+            controller.enqueue(
+              encodeEventMessage({
+                comments: [keepAliveComment]
+              })
+            );
+            span?.addEvent("keepalive");
+          }, keepAliveInterval);
+        }
+        const value = await runInSpanContext(span, () => iterator.next());
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        const meta = getEventMeta(value.value);
+        if (!value.done || value.value !== void 0 || meta !== void 0) {
+          const event = value.done ? "done" : "message";
+          controller.enqueue(
+            encodeEventMessage({
+              ...meta,
+              event,
+              data: stringifyJSON(value.value)
+            })
+          );
+          span?.addEvent(event);
+        }
+        if (value.done) {
+          controller.close();
+          span?.end();
+        }
+      } catch (err) {
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        if (err instanceof ErrorEvent) {
+          controller.enqueue(
+            encodeEventMessage({
+              ...getEventMeta(err),
+              event: "error",
+              data: stringifyJSON(err.data)
+            })
+          );
+          span?.addEvent("error");
+          controller.close();
+        } else {
+          setSpanError(span, err);
+          controller.error(err);
+        }
+        span?.end();
+      }
+    },
+    async cancel() {
+      try {
+        cancelled = true;
+        clearInterval(timeout);
+        span?.addEvent("cancelled");
+        await runInSpanContext(span, () => iterator.return?.());
+      } catch (e) {
+        setSpanError(span, e);
+        throw e;
+      } finally {
+        span?.end();
+      }
+    }
+  }).pipeThrough(new TextEncoderStream());
+  return stream;
+}
+
+function toStandardBody(re, options = {}) {
+  return runWithSpan({ name: "parse_standard_body", signal: options.signal }, async () => {
+    const contentDisposition = re.headers.get("content-disposition");
+    if (typeof contentDisposition === "string") {
+      const fileName = getFilenameFromContentDisposition(contentDisposition) ?? "blob";
+      const blob2 = await re.blob();
+      return new File([blob2], fileName, {
+        type: blob2.type
+      });
+    }
+    const contentType = re.headers.get("content-type");
+    if (!contentType || contentType.startsWith("application/json")) {
+      const text = await re.text();
+      return parseEmptyableJSON(text);
+    }
+    if (contentType.startsWith("multipart/form-data")) {
+      return await re.formData();
+    }
+    if (contentType.startsWith("application/x-www-form-urlencoded")) {
+      const text = await re.text();
+      return new URLSearchParams(text);
+    }
+    if (contentType.startsWith("text/event-stream")) {
+      return toEventIterator(re.body, options);
+    }
+    if (contentType.startsWith("text/plain")) {
+      return await re.text();
+    }
+    const blob = await re.blob();
+    return new File([blob], "blob", {
+      type: blob.type
+    });
+  });
+}
+function toFetchBody(body, headers, options = {}) {
+  const currentContentDisposition = headers.get("content-disposition");
+  headers.delete("content-type");
+  headers.delete("content-disposition");
+  if (body === void 0) {
+    return void 0;
+  }
+  if (body instanceof Blob) {
+    headers.set("content-type", body.type);
+    headers.set("content-length", body.size.toString());
+    headers.set(
+      "content-disposition",
+      currentContentDisposition ?? generateContentDisposition(body instanceof File ? body.name : "blob")
+    );
+    return body;
+  }
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (body instanceof URLSearchParams) {
+    return body;
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers.set("content-type", "text/event-stream");
+    return toEventStream(body, options);
+  }
+  headers.set("content-type", "application/json");
+  return stringifyJSON(body);
+}
+
+function toStandardHeaders(headers, 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(headers, fetchHeaders = new Headers()) {
+  for (const [key, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        fetchHeaders.append(key, v);
+      }
+    } else if (value !== void 0) {
+      fetchHeaders.append(key, value);
+    }
+  }
+  return fetchHeaders;
+}
+
+function toStandardLazyRequest(request) {
+  return {
+    url: new URL(request.url),
+    signal: request.signal,
+    method: request.method,
+    body: once(() => toStandardBody(request, { signal: request.signal })),
+    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 });
+    }
+  };
+}
+function toFetchRequest(request, options = {}) {
+  const headers = toFetchHeaders(request.headers);
+  const body = toFetchBody(request.body, headers, options);
+  return new Request(request.url, {
+    signal: request.signal,
+    method: request.method,
+    headers,
+    body
+  });
+}
+
+function toFetchResponse(response, options = {}) {
+  const headers = toFetchHeaders(response.headers);
+  const body = toFetchBody(response.body, headers, options);
+  return new Response(body, { headers, status: response.status });
+}
+function toStandardLazyResponse(response, options = {}) {
+  return {
+    body: once(() => toStandardBody(response, options)),
+    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, toFetchRequest, toFetchResponse, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardLazyResponse };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@temporary-name/standard-server-fetch",
+  "type": "module",
+  "version": "1.9.3-alpha.0d2fa3247b6b23bbc2e3097a95f631b86740e4d8",
+  "license": "MIT",
+  "homepage": "https://www.stainless.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unnoq/krusty.git",
+    "directory": "packages/standard-server-fetch"
+  },
+  "keywords": [
+    "krusty"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@temporary-name/shared": "1.9.3-alpha.0d2fa3247b6b23bbc2e3097a95f631b86740e4d8",
+    "@temporary-name/standard-server": "1.9.3-alpha.0d2fa3247b6b23bbc2e3097a95f631b86740e4d8"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^1.19.5"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b"
+  }
+}