@orpc/standard-server-fetch 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 oRPC
+
+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.js

@@ -0,0 +1,228 @@
+// src/body.ts
+import { contentDisposition, isAsyncIteratorObject, parseContentDisposition, parseEmptyableJSON as parseEmptyableJSON2 } from "@orpc/standard-server";
+
+// src/event-source.ts
+import {
+  encodeEventMessage,
+  ErrorEvent,
+  EventDecoderStream,
+  getEventMeta,
+  isEventMetaContainer,
+  parseEmptyableJSON,
+  UnknownEvent,
+  withEventMeta
+} from "@orpc/standard-server";
+function toEventIterator(stream) {
+  const eventStream = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventDecoderStream());
+  const reader = eventStream.getReader();
+  async function* gen() {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          return;
+        }
+        switch (value.event) {
+          case "message": {
+            let message = parseEmptyableJSON(value.data);
+            if (isEventMetaContainer(message)) {
+              message = withEventMeta(message, value);
+            }
+            yield message;
+            break;
+          }
+          case "error": {
+            let error = new ErrorEvent({
+              data: parseEmptyableJSON(value.data)
+            });
+            error = withEventMeta(error, value);
+            throw error;
+          }
+          case "done": {
+            let done2 = parseEmptyableJSON(value.data);
+            if (isEventMetaContainer(done2)) {
+              done2 = withEventMeta(done2, value);
+            }
+            return done2;
+          }
+          default: {
+            let error = new UnknownEvent({
+              message: `Unknown event: ${value.event}`,
+              data: parseEmptyableJSON(value.data)
+            });
+            error = withEventMeta(error, value);
+            throw error;
+          }
+        }
+      }
+    } finally {
+      await reader.cancel();
+    }
+  }
+  return gen();
+}
+function toEventStream(iterator) {
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        const value = await iterator.next();
+        controller.enqueue(encodeEventMessage({
+          ...getEventMeta(value.value),
+          event: value.done ? "done" : "message",
+          data: JSON.stringify(value.value)
+        }));
+        if (value.done) {
+          controller.close();
+        }
+      } catch (err) {
+        controller.enqueue(encodeEventMessage({
+          ...getEventMeta(err),
+          event: "error",
+          data: err instanceof ErrorEvent ? JSON.stringify(err.data) : void 0
+        }));
+        controller.close();
+      }
+    },
+    async cancel(reason) {
+      if (reason) {
+        await iterator.throw?.(reason);
+      } else {
+        await iterator.return?.();
+      }
+    }
+  }).pipeThrough(new TextEncoderStream());
+  return stream;
+}
+
+// src/body.ts
+async function toStandardBody(re) {
+  if (!re.body) {
+    return void 0;
+  }
+  const contentDisposition2 = re.headers.get("content-disposition");
+  if (contentDisposition2) {
+    const fileName = parseContentDisposition(contentDisposition2).parameters.filename;
+    if (typeof fileName === "string") {
+      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 parseEmptyableJSON2(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);
+  }
+  if (contentType.startsWith("text/")) {
+    return await re.text();
+  }
+  const blob = await re.blob();
+  return new File([blob], "blob", {
+    type: blob.type
+  });
+}
+function toFetchBody(body, headers) {
+  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",
+      contentDisposition(body instanceof File ? body.name : "blob", { type: "inline" })
+    );
+    return body;
+  }
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (body instanceof URLSearchParams) {
+    return body;
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers.set("content-type", "text/event-stream");
+    headers.set("cache-control", "no-cache");
+    headers.set("connection", "keep-alive");
+    return toEventStream(body);
+  }
+  headers.set("content-type", "application/json");
+  return JSON.stringify(body);
+}
+
+// src/headers.ts
+function toStandardHeaders(headers, standardHeaders = {}) {
+  for (const [key, value] of headers) {
+    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;
+}
+
+// src/request.ts
+import { once } from "@orpc/standard-server";
+function toStandardRequest(request) {
+  return {
+    raw: { request },
+    url: new URL(request.url),
+    signal: request.signal,
+    method: request.method,
+    body: once(() => toStandardBody(request)),
+    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 });
+    }
+  };
+}
+
+// src/response.ts
+function toFetchResponse(response) {
+  const headers = toFetchHeaders(response.headers);
+  const body = toFetchBody(response.body, headers);
+  return new Response(body, { headers, status: response.status });
+}
+export {
+  toEventIterator,
+  toEventStream,
+  toFetchBody,
+  toFetchHeaders,
+  toFetchResponse,
+  toStandardBody,
+  toStandardHeaders,
+  toStandardRequest
+};
+//# sourceMappingURL=index.js.map

package/dist/src/body.d.ts

@@ -0,0 +1,8 @@
+import type { StandardBody } from '@orpc/standard-server';
+export declare function toStandardBody(re: Request | Response): Promise<StandardBody>;
+/**
+ * @param body
+ * @param headers - The headers can be changed by the function and effects on the original headers.
+ */
+export declare function toFetchBody(body: StandardBody, headers: Headers): string | Blob | FormData | URLSearchParams | undefined | ReadableStream<Uint8Array>;
+//# sourceMappingURL=body.d.ts.map

package/dist/src/event-source.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue } from '@orpc/standard-server';
+export declare function toEventIterator(stream: ReadableStream<Uint8Array>): AsyncGenerator<JsonValue | void, JsonValue | void, void>;
+export declare function toEventStream(iterator: AsyncIterator<JsonValue | void, JsonValue | void, void>): ReadableStream<Uint8Array>;
+//# sourceMappingURL=event-source.d.ts.map

package/dist/src/headers.d.ts

@@ -0,0 +1,12 @@
+import type { StandardHeaders } from '@orpc/standard-server';
+/**
+ * @param headers
+ * @param standardHeaders - The base headers can be changed by the function and effects on the original headers.
+ */
+export 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.
+ */
+export declare function toFetchHeaders(headers: StandardHeaders, fetchHeaders?: Headers): Headers;
+//# sourceMappingURL=headers.d.ts.map

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './body';
+export * from './event-source';
+export * from './headers';
+export * from './request';
+export * from './response';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/request.d.ts

@@ -0,0 +1,3 @@
+import type { StandardRequest } from '@orpc/standard-server';
+export declare function toStandardRequest(request: Request): StandardRequest;
+//# sourceMappingURL=request.d.ts.map

package/dist/src/response.d.ts

@@ -0,0 +1,3 @@
+import type { StandardResponse } from '@orpc/standard-server';
+export declare function toFetchResponse(response: StandardResponse): Response;
+//# sourceMappingURL=response.d.ts.map

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@orpc/standard-server-fetch",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "homepage": "https://unnoq.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unnoq/orpc.git",
+    "directory": "packages/standard-server-fetch"
+  },
+  "keywords": [
+    "orpc"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./🔒/*": {
+      "types": "./dist/src/*.d.ts"
+    }
+  },
+  "files": [
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
+    "dist"
+  ],
+  "dependencies": {
+    "@orpc/standard-server": "0.0.0"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^1.13.8"
+  },
+  "scripts": {
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b"
+  }
+}