@orpc/server 0.0.0-next.f99e554 → 0.0.0-next.fe39bf3

package/dist/chunk-XI6WGCB3.js

@@ -0,0 +1,125 @@
+// 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: (origin) => origin,
+      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
+    };
+    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-XI6WGCB3.js.map

package/dist/fetch.js

@@ -1,32 +1,10 @@
 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
+} from "./chunk-KPT6FDBK.js";
+import "./chunk-LXOL226G.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-XI6WGCB3.js";
 export {
-  CompositeHandler,
-  ORPCHandler,
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  super_json_exports as SuperJSON
+  RPCHandler
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -0,0 +1,34 @@
+import {
+  RPCHandler
+} from "./chunk-KPT6FDBK.js";
+import "./chunk-LXOL226G.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-XI6WGCB3.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
+};
+//# sourceMappingURL=hono.js.map