@orpc/server 0.0.0-next.d5f0415 → 0.0.0-next.d5f6b77

package/dist/shared/server.eWLxY3lq.d.mts

@@ -0,0 +1,74 @@
+import { HTTPPath, ORPCError } from '@orpc/client';
+import { Meta, InferSchemaOutput, AnySchema, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, ThrowableError } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { C as Context, R as Router, f as AnyRouter, h as AnyProcedure, F as ProcedureClientInterceptorOptions } from './server.DPWk5pjW.mjs';
+
+interface StandardHandlerPlugin<T extends Context> {
+    order?: number;
+    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: StandardHandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    private readonly rootInterceptors;
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
+}
+
+export { CompositeStandardHandlerPlugin as C, StandardHandler as i };
+export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardCodec as c, StandardParams as d, StandardMatcher as e, StandardMatchResult as f, StandardHandleOptions as g, StandardHandleResult as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.d5f0415",
+  "version": "0.0.0-next.d5f6b77",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,66 +15,76 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
     "./plugins": {
-      "types": "./dist/src/plugins/index.d.ts",
-      "import": "./dist/plugins.js",
-      "default": "./dist/plugins.js"
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
     },
     "./standard": {
-      "types": "./dist/src/adapters/standard/index.d.ts",
-      "import": "./dist/standard.js",
-      "default": "./dist/standard.js"
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     },
-    "./hono": {
-      "types": "./dist/src/adapters/hono/index.d.ts",
-      "import": "./dist/hono.js",
-      "default": "./dist/hono.js"
+    "./node": {
+      "types": "./dist/adapters/node/index.d.mts",
+      "import": "./dist/adapters/node/index.mjs",
+      "default": "./dist/adapters/node/index.mjs"
     },
-    "./next": {
-      "types": "./dist/src/adapters/next/index.d.ts",
-      "import": "./dist/next.js",
-      "default": "./dist/next.js"
+    "./websocket": {
+      "types": "./dist/adapters/websocket/index.d.mts",
+      "import": "./dist/adapters/websocket/index.mjs",
+      "default": "./dist/adapters/websocket/index.mjs"
     },
-    "./node": {
-      "types": "./dist/src/adapters/node/index.d.ts",
-      "import": "./dist/node.js",
-      "default": "./dist/node.js"
+    "./crossws": {
+      "types": "./dist/adapters/crossws/index.d.mts",
+      "import": "./dist/adapters/crossws/index.mjs",
+      "default": "./dist/adapters/crossws/index.mjs"
+    },
+    "./ws": {
+      "types": "./dist/adapters/ws/index.d.mts",
+      "import": "./dist/adapters/ws/index.mjs",
+      "default": "./dist/adapters/ws/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./bun-ws": {
+      "types": "./dist/adapters/bun-ws/index.d.mts",
+      "import": "./dist/adapters/bun-ws/index.mjs",
+      "default": "./dist/adapters/bun-ws/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
-    "hono": ">=4.6.0",
-    "next": ">=14.0.0"
+    "crossws": ">=0.3.4",
+    "ws": ">=8.18.1"
   },
   "dependencies": {
-    "@orpc/server-standard": "^0.4.0",
-    "@orpc/server-standard-fetch": "^0.4.0",
-    "@orpc/server-standard-node": "^0.4.0",
-    "@orpc/contract": "0.0.0-next.d5f0415",
-    "@orpc/client": "0.0.0-next.d5f0415",
-    "@orpc/shared": "0.0.0-next.d5f0415"
+    "@orpc/shared": "0.0.0-next.d5f6b77",
+    "@orpc/contract": "0.0.0-next.d5f6b77",
+    "@orpc/standard-server": "0.0.0-next.d5f6b77",
+    "@orpc/standard-server-fetch": "0.0.0-next.d5f6b77",
+    "@orpc/standard-server-node": "0.0.0-next.d5f6b77",
+    "@orpc/client": "0.0.0-next.d5f6b77",
+    "@orpc/standard-server-peer": "0.0.0-next.d5f6b77"
   },
   "devDependencies": {
-    "light-my-request": "^6.5.1"
+    "@types/ws": "^8.18.1",
+    "crossws": "^0.3.4",
+    "next": "^15.3.0",
+    "supertest": "^7.1.0",
+    "ws": "^8.18.1"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-47YYO5JS.js

@@ -1,32 +0,0 @@
-import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-77FU7QSO.js";
-
-// src/adapters/fetch/rpc-handler.ts
-import { toFetchResponse, toStandardRequest } from "@orpc/server-standard-fetch";
-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 = toStandardRequest(request);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return result;
-    }
-    return {
-      matched: true,
-      response: toFetchResponse(result.response)
-    };
-  }
-};
-
-export {
-  RPCHandler
-};
-//# sourceMappingURL=chunk-47YYO5JS.js.map

package/dist/chunk-77FU7QSO.js

@@ -1,181 +0,0 @@
-import {
-  convertPathToHttpPath,
-  createContractedProcedure,
-  createProcedureClient,
-  eachContractProcedure,
-  getRouterChild,
-  isProcedure,
-  unlazy
-} from "./chunk-MHVECKBC.js";
-import {
-  CompositePlugin
-} from "./chunk-WQNNSBXW.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";
-var RPCCodec = class {
-  serializer;
-  constructor(options = {}) {
-    this.serializer = options.serializer ?? new RPCSerializer();
-  }
-  async decode(request, _params, _procedure) {
-    const serialized = request.method === "GET" ? JSON.parse(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-77FU7QSO.js.map

package/dist/chunk-WQNNSBXW.js

@@ -1,120 +0,0 @@
-// 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-WQNNSBXW.js.map

package/dist/fetch.js

@@ -1,10 +0,0 @@
-import {
-  RPCHandler
-} from "./chunk-47YYO5JS.js";
-import "./chunk-77FU7QSO.js";
-import "./chunk-MHVECKBC.js";
-import "./chunk-WQNNSBXW.js";
-export {
-  RPCHandler
-};
-//# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,34 +0,0 @@
-import {
-  RPCHandler
-} from "./chunk-47YYO5JS.js";
-import "./chunk-77FU7QSO.js";
-import "./chunk-MHVECKBC.js";
-import "./chunk-WQNNSBXW.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