@orpc/server 0.0.0-next.3f6c426 → 0.0.0-next.435356b

package/dist/chunk-XFBAK67J.js

@@ -0,0 +1,128 @@
+// src/plugins/base.ts
+var CompositePlugin = class {
+  constructor(plugins = []) {
+    this.plugins = plugins;
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+  beforeCreateProcedureClient(clientOptions, interceptorOptions) {
+    for (const plugin of this.plugins) {
+      plugin.beforeCreateProcedureClient?.(clientOptions, interceptorOptions);
+    }
+  }
+};
+
+// src/plugins/cors.ts
+import { value } from "@orpc/shared";
+var CORSPlugin = class {
+  options;
+  constructor(options) {
+    const defaults = {
+      origin: "*",
+      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
+    };
+    if (options?.credentials) {
+      defaults.origin = (origin) => origin;
+    }
+    this.options = {
+      ...defaults,
+      ...options
+    };
+  }
+  init(options) {
+    options.interceptorsRoot ??= [];
+    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+      if (interceptorOptions.request.method === "OPTIONS") {
+        const resHeaders = {};
+        if (this.options.maxAge !== void 0) {
+          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
+        }
+        if (this.options.allowMethods?.length) {
+          resHeaders["access-control-allow-methods"] = this.options.allowMethods.join(",");
+        }
+        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
+        if (Array.isArray(allowHeaders) && allowHeaders.length) {
+          resHeaders["access-control-allow-headers"] = allowHeaders.join(",");
+        } else if (typeof allowHeaders === "string") {
+          resHeaders["access-control-allow-headers"] = allowHeaders;
+        }
+        return {
+          matched: true,
+          response: {
+            status: 204,
+            headers: resHeaders,
+            body: void 0
+          }
+        };
+      }
+      return interceptorOptions.next();
+    });
+    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+      const result = await interceptorOptions.next();
+      if (!result.matched) {
+        return result;
+      }
+      const origin = Array.isArray(interceptorOptions.request.headers.origin) ? interceptorOptions.request.headers.origin.join(",") : interceptorOptions.request.headers.origin || "";
+      const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
+      const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
+      if (allowedOriginArr.includes("*")) {
+        result.response.headers["access-control-allow-origin"] = "*";
+      } else {
+        if (allowedOriginArr.includes(origin)) {
+          result.response.headers["access-control-allow-origin"] = origin;
+        }
+        result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
+      }
+      const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
+      const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
+      if (allowedTimingOriginArr.includes("*")) {
+        result.response.headers["timing-allow-origin"] = "*";
+      } else if (allowedTimingOriginArr.includes(origin)) {
+        result.response.headers["timing-allow-origin"] = origin;
+      }
+      if (this.options.credentials) {
+        result.response.headers["access-control-allow-credentials"] = "true";
+      }
+      if (this.options.exposeHeaders?.length) {
+        result.response.headers["access-control-expose-headers"] = this.options.exposeHeaders.join(",");
+      }
+      return result;
+    });
+  }
+};
+
+// src/plugins/response-headers.ts
+var ResponseHeadersPlugin = class {
+  init(options) {
+    options.interceptorsRoot ??= [];
+    options.interceptorsRoot.push(async (interceptorOptions) => {
+      const headers = new Headers();
+      interceptorOptions.context.resHeaders = headers;
+      const result = await interceptorOptions.next();
+      if (!result.matched) {
+        return result;
+      }
+      const responseHeaders = result.response.headers;
+      for (const [key, value2] of headers) {
+        if (Array.isArray(responseHeaders[key])) {
+          responseHeaders[key].push(value2);
+        } else if (responseHeaders[key] !== void 0) {
+          responseHeaders[key] = [responseHeaders[key], value2];
+        } else {
+          responseHeaders[key] = value2;
+        }
+      }
+      return result;
+    });
+  }
+};
+
+export {
+  CompositePlugin,
+  CORSPlugin,
+  ResponseHeadersPlugin
+};
+//# sourceMappingURL=chunk-XFBAK67J.js.map

package/dist/chunk-ZPC3OJSM.js

@@ -0,0 +1,145 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-2KWASPTM.js";
+
+// src/adapters/fetch/utils.ts
+import { once } from "@orpc/shared";
+import { contentDisposition, parse as parseContentDisposition } from "@tinyhttp/content-disposition";
+function fetchHeadersToStandardHeaders(headers) {
+  const 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;
+}
+async function fetchReToStandardBody(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();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  if (contentType.startsWith("multipart/form-data")) {
+    return await re.formData();
+  }
+  if (contentType.startsWith("application/x-www-form-urlencoded")) {
+    return new URLSearchParams(await re.text());
+  }
+  if (contentType.startsWith("text/")) {
+    return await re.text();
+  }
+  const blob = await re.blob();
+  return new File([blob], "blob", {
+    type: blob.type
+  });
+}
+function fetchRequestToStandardRequest(request) {
+  const url = new URL(request.url);
+  return {
+    raw: { request },
+    url,
+    signal: request.signal,
+    method: request.method,
+    body: once(() => {
+      return fetchReToStandardBody(request);
+    }),
+    get headers() {
+      const headers = fetchHeadersToStandardHeaders(request.headers);
+      Object.defineProperty(this, "headers", { value: headers, writable: true });
+      return headers;
+    },
+    set headers(value) {
+      Object.defineProperty(this, "headers", { value, writable: true });
+    }
+  };
+}
+function standardResponseToFetchHeaders(response) {
+  const fetchHeaders = new Headers();
+  for (const [key, value] of Object.entries(response.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 standardResponseToFetchResponse(response) {
+  const resHeaders = standardResponseToFetchHeaders(response);
+  resHeaders.delete("content-type");
+  resHeaders.delete("content-disposition");
+  if (response.body === void 0) {
+    return new Response(void 0, { headers: resHeaders, status: response.status });
+  }
+  if (response.body instanceof Blob) {
+    resHeaders.set("content-type", response.body.type);
+    resHeaders.set("content-length", response.body.size.toString());
+    resHeaders.set(
+      "content-disposition",
+      contentDisposition(response.body instanceof File ? response.body.name : "blob", { type: "inline" })
+    );
+    return new Response(response.body, { headers: resHeaders, status: response.status });
+  }
+  if (response.body instanceof FormData) {
+    return new Response(response.body, { headers: resHeaders, status: response.status });
+  }
+  if (response.body instanceof URLSearchParams) {
+    return new Response(response.body, { headers: resHeaders, status: response.status });
+  }
+  resHeaders.set("content-type", "application/json");
+  return new Response(JSON.stringify(response.body), { headers: resHeaders, status: response.status });
+}
+
+// src/adapters/fetch/rpc-handler.ts
+var RPCHandler = class {
+  standardHandler;
+  constructor(router, options) {
+    const matcher = options?.matcher ?? new RPCMatcher();
+    const codec = options?.codec ?? new RPCCodec();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...rest) {
+    const standardRequest = fetchRequestToStandardRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: standardResponseToFetchResponse(result.response)
+    };
+  }
+};
+
+export {
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardResponseToFetchResponse,
+  RPCHandler
+};
+//# sourceMappingURL=chunk-ZPC3OJSM.js.map

package/dist/fetch.js

@@ -1,32 +1,16 @@
 import {
-  ORPCHandler,
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  super_json_exports
-} from "./chunk-B2EZJB7X.js";
-import "./chunk-6A7XHEBH.js";
-
-// src/adapters/fetch/composite-handler.ts
-var CompositeHandler = class {
-  constructor(handlers) {
-    this.handlers = handlers;
-  }
-  async fetch(request, ...opt) {
-    for (const handler of this.handlers) {
-      if (handler.condition(request)) {
-        return handler.fetch(request, ...opt);
-      }
-    }
-    return new Response("None of the handlers can handle the request.", {
-      status: 404
-    });
-  }
-};
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardResponseToFetchResponse
+} from "./chunk-ZPC3OJSM.js";
+import "./chunk-2KWASPTM.js";
+import "./chunk-APTXPKZT.js";
+import "./chunk-XFBAK67J.js";
 export {
-  CompositeHandler,
-  ORPCHandler,
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  super_json_exports as SuperJSON
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardResponseToFetchResponse
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -0,0 +1,40 @@
+import {
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardResponseToFetchResponse
+} from "./chunk-ZPC3OJSM.js";
+import "./chunk-2KWASPTM.js";
+import "./chunk-APTXPKZT.js";
+import "./chunk-XFBAK67J.js";
+
+// src/adapters/hono/middleware.ts
+import { value } from "@orpc/shared";
+function createMiddleware(handler, ...[options]) {
+  return async (c, next) => {
+    const bodyProps = /* @__PURE__ */ new Set(["arrayBuffer", "blob", "formData", "json", "text"]);
+    const request = c.req.method === "GET" || c.req.method === "HEAD" ? c.req.raw : new Proxy(c.req.raw, {
+      // https://github.com/honojs/middleware/blob/main/packages/trpc-server/src/index.ts#L39
+      get(target, prop) {
+        if (bodyProps.has(prop)) {
+          return () => c.req[prop]();
+        }
+        return Reflect.get(target, prop, target);
+      }
+    });
+    const context = await value(options?.context ?? {}, c);
+    const { matched, response } = await handler.handle(request, { ...options, context });
+    if (matched) {
+      return c.newResponse(response.body, response);
+    }
+    await next();
+  };
+}
+export {
+  RPCHandler,
+  createMiddleware,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardResponseToFetchResponse
+};
+//# sourceMappingURL=hono.js.map