@orpc/server 0.0.0-next.c59d67c → 0.0.0-next.ca29a36

package/dist/chunk-NTHCS5CK.js

@@ -0,0 +1,182 @@
+import {
+  convertPathToHttpPath,
+  createContractedProcedure,
+  createProcedureClient,
+  eachContractProcedure,
+  getRouterChild,
+  isProcedure,
+  unlazy
+} from "./chunk-MHVECKBC.js";
+import {
+  CompositePlugin
+} from "./chunk-TXHKQO7N.js";
+
+// src/adapters/standard/handler.ts
+import { ORPCError, toORPCError } from "@orpc/client";
+import { intercept, trim } from "@orpc/shared";
+var StandardHandler = class {
+  constructor(router, matcher, codec, options = {}) {
+    this.matcher = matcher;
+    this.codec = codec;
+    this.options = options;
+    this.plugin = new CompositePlugin(options.plugins);
+    this.plugin.init(this.options);
+    this.matcher.init(router);
+  }
+  plugin;
+  handle(request, ...[options]) {
+    return intercept(
+      this.options.rootInterceptors ?? [],
+      {
+        request,
+        ...options,
+        context: options?.context ?? {}
+        // context is optional only when all fields are optional so we can safely force it to have a context
+      },
+      async (interceptorOptions) => {
+        let isDecoding = false;
+        try {
+          return await intercept(
+            this.options.interceptors ?? [],
+            interceptorOptions,
+            async (interceptorOptions2) => {
+              const method = interceptorOptions2.request.method;
+              const url = interceptorOptions2.request.url;
+              const pathname = `/${trim(url.pathname.replace(interceptorOptions2.prefix ?? "", ""), "/")}`;
+              const match = await this.matcher.match(method, pathname);
+              if (!match) {
+                return { matched: false, response: void 0 };
+              }
+              const client = createProcedureClient(match.procedure, {
+                context: interceptorOptions2.context,
+                path: match.path,
+                interceptors: this.options.clientInterceptors
+              });
+              isDecoding = true;
+              const input = await this.codec.decode(request, match.params, match.procedure);
+              isDecoding = false;
+              const lastEventId = Array.isArray(request.headers["last-event-id"]) ? request.headers["last-event-id"].at(-1) : request.headers["last-event-id"];
+              const output = await client(input, { signal: request.signal, lastEventId });
+              const response = this.codec.encode(output, match.procedure);
+              return {
+                matched: true,
+                response
+              };
+            }
+          );
+        } catch (e) {
+          const error = isDecoding ? new ORPCError("BAD_REQUEST", {
+            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+            cause: e
+          }) : toORPCError(e);
+          const response = this.codec.encodeError(error);
+          return {
+            matched: true,
+            response
+          };
+        }
+      }
+    );
+  }
+};
+
+// src/adapters/standard/rpc-codec.ts
+import { RPCSerializer } from "@orpc/client/rpc";
+import { parseEmptyableJSON } from "@orpc/shared";
+var RPCCodec = class {
+  serializer;
+  constructor(options = {}) {
+    this.serializer = options.serializer ?? new RPCSerializer();
+  }
+  async decode(request, _params, _procedure) {
+    const serialized = request.method === "GET" ? parseEmptyableJSON(request.url.searchParams.getAll("data").at(-1)) : await request.body();
+    return this.serializer.deserialize(serialized);
+  }
+  encode(output, _procedure) {
+    return {
+      status: 200,
+      headers: {},
+      body: this.serializer.serialize(output)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+};
+
+// src/adapters/standard/rpc-matcher.ts
+var RPCMatcher = class {
+  tree = {};
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = eachContractProcedure({
+      router,
+      path
+    }, ({ path: path2, contract }) => {
+      const httpPath = convertPathToHttpPath(path2);
+      if (isProcedure(contract)) {
+        this.tree[httpPath] = {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        };
+      } else {
+        this.tree[httpPath] = {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        };
+      }
+    });
+    this.pendingRouters.push(...laziedOptions.map((option) => ({
+      ...option,
+      httpPathPrefix: convertPathToHttpPath(option.path)
+    })));
+  }
+  async match(_method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (pathname.startsWith(pendingRouter.httpPathPrefix)) {
+          const { default: router } = await unlazy(pendingRouter.lazied);
+          this.init(router, pendingRouter.path);
+        } else {
+          newPendingRouters.push(pendingRouter);
+        }
+      }
+      this.pendingRouters = newPendingRouters;
+    }
+    const match = this.tree[pathname];
+    if (!match) {
+      return void 0;
+    }
+    if (!match.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouterChild(match.router, ...match.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.procedure = createContractedProcedure(match.contract, maybeProcedure);
+    }
+    return {
+      path: match.path,
+      procedure: match.procedure
+    };
+  }
+};
+
+export {
+  StandardHandler,
+  RPCCodec,
+  RPCMatcher
+};
+//# sourceMappingURL=chunk-NTHCS5CK.js.map

package/dist/chunk-TXHKQO7N.js

@@ -0,0 +1,120 @@
+// src/plugins/base.ts
+var CompositePlugin = class {
+  constructor(plugins = []) {
+    this.plugins = plugins;
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+};
+
+// 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.rootInterceptors ??= [];
+    options.rootInterceptors.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.rootInterceptors.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.rootInterceptors ??= [];
+    options.rootInterceptors.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-TXHKQO7N.js.map

package/dist/fetch.js

@@ -1,106 +1,10 @@
 import {
-  createProcedureCaller,
-  isProcedure
-} from "./chunk-TDFYNRZV.js";
-
-// src/fetch/handle.ts
-import { ORPCError } from "@orpc/shared/error";
-async function handleFetchRequest(options) {
-  for (const handler of options.handlers) {
-    const response = await handler(options);
-    if (response) {
-      return response;
-    }
-  }
-  const error = new ORPCError({ code: "NOT_FOUND", message: "Not found" });
-  return new Response(JSON.stringify(error.toJSON()), {
-    status: error.status,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-}
-
-// src/fetch/handler.ts
-import { ORPC_HEADER, ORPC_HEADER_VALUE } from "@orpc/contract";
-import { trim, value } from "@orpc/shared";
-import { ORPCError as ORPCError2 } from "@orpc/shared/error";
-import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
-var serializer = new ORPCSerializer();
-var deserializer = new ORPCDeserializer();
-function createORPCHandler() {
-  return async (options) => {
-    if (options.request.headers.get(ORPC_HEADER) !== ORPC_HEADER_VALUE) {
-      return void 0;
-    }
-    const context = await value(options.context);
-    const handler = async () => {
-      const url = new URL(options.request.url);
-      const pathname = `/${trim(url.pathname.replace(options.prefix ?? "", ""), "/")}`;
-      const match = resolveORPCRouter(options.router, pathname);
-      if (!match) {
-        throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
-      }
-      const input = await deserializeRequest(options.request);
-      const caller = createProcedureCaller({
-        context,
-        procedure: match.procedure,
-        path: match.path
-      });
-      const output = await caller(input);
-      const { body, headers } = serializer.serialize(output);
-      return new Response(body, {
-        status: 200,
-        headers
-      });
-    };
-    try {
-      return await options.hooks?.(
-        context,
-        { next: handler, response: (response) => response }
-      ) ?? await handler();
-    } catch (e) {
-      const error = e instanceof ORPCError2 ? e : new ORPCError2({
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error",
-        cause: e
-      });
-      const { body, headers } = serializer.serialize(error.toJSON());
-      return new Response(body, {
-        status: error.status,
-        headers
-      });
-    }
-  };
-}
-function resolveORPCRouter(router, pathname) {
-  const path = trim(pathname, "/").split("/").map(decodeURIComponent);
-  let current = router;
-  for (const segment of path) {
-    if ((typeof current !== "object" || current === null) && typeof current !== "function") {
-      current = void 0;
-      break;
-    }
-    current = current[segment];
-  }
-  return isProcedure(current) ? {
-    procedure: current,
-    path
-  } : void 0;
-}
-async function deserializeRequest(request) {
-  try {
-    return await deserializer.deserialize(request);
-  } catch (e) {
-    throw new ORPCError2({
-      code: "BAD_REQUEST",
-      message: "Cannot parse request. Please check the request body and Content-Type header.",
-      cause: e
-    });
-  }
-}
+  RPCHandler
+} from "./chunk-MBMXGUNI.js";
+import "./chunk-NTHCS5CK.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-TXHKQO7N.js";
 export {
-  createORPCHandler,
-  handleFetchRequest
+  RPCHandler
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -0,0 +1,34 @@
+import {
+  RPCHandler
+} from "./chunk-MBMXGUNI.js";
+import "./chunk-NTHCS5CK.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-TXHKQO7N.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