@orpc/server 0.0.0-next.6affcc9 → 0.0.0-next.6c13765

package/dist/{chunk-L4ESXQX7.js → chunk-47YYO5JS.js}

@@ -2,7 +2,7 @@ import {
   RPCCodec,
   RPCMatcher,
   StandardHandler
-} from "./chunk-NXEANHUK.js";
+} from "./chunk-77FU7QSO.js";
 
 // src/adapters/fetch/rpc-handler.ts
 import { toFetchResponse, toStandardRequest } from "@orpc/server-standard-fetch";
@@ -29,4 +29,4 @@ var RPCHandler = class {
 export {
   RPCHandler
 };
-//# sourceMappingURL=chunk-L4ESXQX7.js.map
+//# sourceMappingURL=chunk-47YYO5JS.js.map

package/dist/chunk-77FU7QSO.js

@@ -0,0 +1,181 @@
+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-XXBE6CYD.js → chunk-MHVECKBC.js}

@@ -62,8 +62,50 @@ function middlewareOutputFn(output) {
 }
 
 // src/procedure-client.ts
-import { createORPCErrorConstructorMap, ORPCError, validateORPCError, ValidationError } from "@orpc/contract";
+import { ORPCError as ORPCError2 } from "@orpc/client";
+import { ValidationError } from "@orpc/contract";
 import { intercept, toError, value } from "@orpc/shared";
+
+// src/error.ts
+import { fallbackORPCErrorStatus, ORPCError } from "@orpc/client";
+function createORPCErrorConstructorMap(errors) {
+  const proxy = new Proxy(errors, {
+    get(target, code) {
+      if (typeof code !== "string") {
+        return Reflect.get(target, code);
+      }
+      const item = (...[options]) => {
+        const config = errors[code];
+        return new ORPCError(code, {
+          defined: Boolean(config),
+          status: config?.status,
+          message: options?.message ?? config?.message,
+          data: options?.data,
+          cause: options?.cause
+        });
+      };
+      return item;
+    }
+  });
+  return proxy;
+}
+async function validateORPCError(map, error) {
+  const { code, status, message, data, cause, defined } = error;
+  const config = map?.[error.code];
+  if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
+    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
+  }
+  if (!config.data) {
+    return defined ? error : new ORPCError(code, { defined: true, status, message, data, cause });
+  }
+  const validated = await config.data["~standard"].validate(error.data);
+  if (validated.issues) {
+    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
+  }
+  return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
+}
+
+// src/procedure-client.ts
 function createProcedureClient(lazyableProcedure, ...[options]) {
   return async (...[input, callerOptions]) => {
     const path = options?.path ?? [];
@@ -87,7 +129,7 @@ function createProcedureClient(lazyableProcedure, ...[options]) {
         (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
       );
     } catch (e) {
-      if (!(e instanceof ORPCError)) {
+      if (!(e instanceof ORPCError2)) {
         throw toError(e);
       }
       const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
@@ -102,7 +144,7 @@ async function validateInput(procedure, input) {
   }
   const result = await schema["~standard"].validate(input);
   if (result.issues) {
-    throw new ORPCError("BAD_REQUEST", {
+    throw new ORPCError2("BAD_REQUEST", {
       message: "Input validation failed",
       data: {
         issues: result.issues
@@ -119,7 +161,7 @@ async function validateOutput(procedure, output) {
   }
   const result = await schema["~standard"].validate(output);
   if (result.issues) {
-    throw new ORPCError("INTERNAL_SERVER_ERROR", {
+    throw new ORPCError2("INTERNAL_SERVER_ERROR", {
       message: "Output validation failed",
       cause: new ValidationError({ message: "Output validation failed", issues: result.issues })
     });
@@ -376,4 +418,4 @@ export {
   convertPathToHttpPath,
   createContractedProcedure
 };
-//# sourceMappingURL=chunk-XXBE6CYD.js.map
+//# sourceMappingURL=chunk-MHVECKBC.js.map

package/dist/{chunk-XI6WGCB3.js → chunk-WQNNSBXW.js}

@@ -8,11 +8,6 @@ var CompositePlugin = class {
       plugin.init?.(options);
     }
   }
-  beforeCreateProcedureClient(clientOptions, interceptorOptions) {
-    for (const plugin of this.plugins) {
-      plugin.beforeCreateProcedureClient?.(clientOptions, interceptorOptions);
-    }
-  }
 };
 
 // src/plugins/cors.ts
@@ -30,8 +25,8 @@ var CORSPlugin = class {
     };
   }
   init(options) {
-    options.interceptorsRoot ??= [];
-    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
       if (interceptorOptions.request.method === "OPTIONS") {
         const resHeaders = {};
         if (this.options.maxAge !== void 0) {
@@ -57,7 +52,7 @@ var CORSPlugin = class {
       }
       return interceptorOptions.next();
     });
-    options.interceptorsRoot.unshift(async (interceptorOptions) => {
+    options.rootInterceptors.unshift(async (interceptorOptions) => {
       const result = await interceptorOptions.next();
       if (!result.matched) {
         return result;
@@ -94,8 +89,8 @@ var CORSPlugin = class {
 // src/plugins/response-headers.ts
 var ResponseHeadersPlugin = class {
   init(options) {
-    options.interceptorsRoot ??= [];
-    options.interceptorsRoot.push(async (interceptorOptions) => {
+    options.rootInterceptors ??= [];
+    options.rootInterceptors.push(async (interceptorOptions) => {
       const headers = new Headers();
       interceptorOptions.context.resHeaders = headers;
       const result = await interceptorOptions.next();
@@ -122,4 +117,4 @@ export {
   CORSPlugin,
   ResponseHeadersPlugin
 };
-//# sourceMappingURL=chunk-XI6WGCB3.js.map
+//# sourceMappingURL=chunk-WQNNSBXW.js.map

package/dist/fetch.js

@@ -1,9 +1,9 @@
 import {
   RPCHandler
-} from "./chunk-L4ESXQX7.js";
-import "./chunk-NXEANHUK.js";
-import "./chunk-XXBE6CYD.js";
-import "./chunk-XI6WGCB3.js";
+} from "./chunk-47YYO5JS.js";
+import "./chunk-77FU7QSO.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-WQNNSBXW.js";
 export {
   RPCHandler
 };

package/dist/hono.js

@@ -1,9 +1,9 @@
 import {
   RPCHandler
-} from "./chunk-L4ESXQX7.js";
-import "./chunk-NXEANHUK.js";
-import "./chunk-XXBE6CYD.js";
-import "./chunk-XI6WGCB3.js";
+} 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";

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   middlewareOutputFn,
   setRouterContract,
   unlazy
-} from "./chunk-XXBE6CYD.js";
+} from "./chunk-MHVECKBC.js";
 
 // src/builder.ts
 import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
@@ -361,7 +361,8 @@ function createRouterClient(router, ...rest) {
 }
 
 // src/index.ts
-import { eventIterator, isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
+import { isDefinedError, ORPCError, safe } from "@orpc/client";
+import { eventIterator, type, ValidationError } from "@orpc/contract";
 import { getEventMeta, withEventMeta } from "@orpc/server-standard";
 import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
 export {

package/dist/next.js

@@ -1,9 +1,9 @@
 import {
   RPCHandler
-} from "./chunk-L4ESXQX7.js";
-import "./chunk-NXEANHUK.js";
-import "./chunk-XXBE6CYD.js";
-import "./chunk-XI6WGCB3.js";
+} from "./chunk-47YYO5JS.js";
+import "./chunk-77FU7QSO.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-WQNNSBXW.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";

package/dist/node.js

@@ -2,9 +2,9 @@ import {
   RPCCodec,
   RPCMatcher,
   StandardHandler
-} from "./chunk-NXEANHUK.js";
-import "./chunk-XXBE6CYD.js";
-import "./chunk-XI6WGCB3.js";
+} from "./chunk-77FU7QSO.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-WQNNSBXW.js";
 
 // src/adapters/node/rpc-handler.ts
 import { sendStandardResponse, toStandardRequest } from "@orpc/server-standard-node";

package/dist/plugins.js

@@ -2,7 +2,7 @@ import {
   CORSPlugin,
   CompositePlugin,
   ResponseHeadersPlugin
-} from "./chunk-XI6WGCB3.js";
+} from "./chunk-WQNNSBXW.js";
 export {
   CORSPlugin,
   CompositePlugin,

package/dist/src/adapters/standard/handler.d.ts

@@ -1,9 +1,9 @@
-import type { ErrorMap, HTTPPath, Meta, Schema } from '@orpc/contract';
+import type { ErrorFromErrorMap, HTTPPath, Meta, Schema, SchemaOutput } from '@orpc/contract';
 import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
 import type { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from '../../context';
 import type { Plugin } from '../../plugins';
-import type { CreateProcedureClientOptions } from '../../procedure-client';
+import type { ProcedureClientInterceptorOptions } from '../../procedure-client';
 import type { Router } from '../../router';
 import type { StandardCodec, StandardMatcher } from './types';
 export type StandardHandleOptions<T extends Context> = {
@@ -26,9 +26,6 @@ export type StandardHandleResult = {
 export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
     request: StandardRequest;
 };
-export type WellCreateProcedureClientOptions<TContext extends Context> = CreateProcedureClientOptions<TContext, Schema, Schema, unknown, ErrorMap, Meta, Record<never, never>> & {
-    context: TContext;
-};
 export interface StandardHandlerOptions<TContext extends Context> {
     plugins?: Plugin<TContext>[];
     /**
@@ -36,9 +33,14 @@ export interface StandardHandlerOptions<TContext extends Context> {
      */
     interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
     /**
-     * Interceptors at the root level, helpful when you want override the response
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     *
+     * Interceptors for procedure client.
      */
-    interceptorsRoot?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Schema, Record<never, never>, Meta>, SchemaOutput<Schema, unknown>, ErrorFromErrorMap<Record<never, never>>>[];
 }
 export declare class StandardHandler<T extends Context> {
     private readonly matcher;

package/dist/src/adapters/standard/index.d.ts

@@ -2,6 +2,5 @@ export * from './handler';
 export * from './rpc-codec';
 export * from './rpc-handler';
 export * from './rpc-matcher';
-export * from './rpc-serializer';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/rpc-codec.d.ts

@@ -1,8 +1,8 @@
-import type { ORPCError } from '@orpc/contract';
+import type { ORPCError } from '@orpc/client';
 import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
 import type { AnyProcedure } from '../../procedure';
 import type { StandardCodec, StandardParams } from './types';
-import { RPCSerializer } from './rpc-serializer';
+import { RPCSerializer } from '@orpc/client/rpc';
 export interface StandardCodecOptions {
     serializer?: RPCSerializer;
 }

package/dist/src/adapters/standard/types.d.ts

@@ -1,4 +1,5 @@
-import type { HTTPPath, ORPCError } from '@orpc/contract';
+import type { ORPCError } from '@orpc/client';
+import type { HTTPPath } from '@orpc/contract';
 import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
 import type { AnyProcedure } from '../../procedure';
 import type { AnyRouter } from '../../router';

package/dist/src/builder-variants.d.ts

@@ -1,6 +1,7 @@
-import type { ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { BuilderDef } from './builder';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { FlattenLazy } from './lazy-utils';
 import type { MapInputMiddleware, Middleware } from './middleware';
 import type { ProcedureHandler } from './procedure';

package/dist/src/builder.d.ts

@@ -1,6 +1,7 @@
-import type { ContractProcedureDef, ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractProcedureDef, ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { BuilderWithMiddlewares, ProcedureBuilder, ProcedureBuilderWithInput, ProcedureBuilderWithOutput, RouterBuilder } from './builder-variants';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { FlattenLazy } from './lazy-utils';
 import type { AnyMiddleware, MapInputMiddleware, Middleware } from './middleware';
 import type { DecoratedMiddleware } from './middleware-decorated';

package/dist/src/error.d.ts

@@ -0,0 +1,12 @@
+import type { ORPCErrorCode, ORPCErrorOptions } from '@orpc/client';
+import type { ErrorMap, ErrorMapItem, SchemaInput } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import { ORPCError } from '@orpc/client';
+export type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+export type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+export type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
+};
+export declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+export declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+//# sourceMappingURL=error.d.ts.map

package/dist/src/implementer-procedure.d.ts

@@ -1,7 +1,9 @@
-import type { ClientContext, ClientRest, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientContext, ClientRest } from '@orpc/client';
+import type { ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { BuilderDef } from './builder';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
 import type { Procedure, ProcedureHandler } from './procedure';
 import type { CreateProcedureClientOptions, ProcedureClient } from './procedure-client';

package/dist/src/implementer-variants.d.ts

@@ -1,5 +1,6 @@
-import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta } from '@orpc/contract';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { ProcedureImplementer } from './implementer-procedure';
 import type { FlattenLazy } from './lazy-utils';
 import type { Middleware } from './middleware';

package/dist/src/implementer.d.ts

@@ -1,5 +1,6 @@
-import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta } from '@orpc/contract';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { ProcedureImplementer } from './implementer-procedure';
 import type { ImplementerInternalWithMiddlewares } from './implementer-variants';
 import type { AnyMiddleware, Middleware } from './middleware';

package/dist/src/index.d.ts

@@ -18,7 +18,8 @@ export * from './router';
 export * from './router-accessible-lazy';
 export * from './router-client';
 export * from './utils';
-export { eventIterator, isDefinedError, ORPCError, safe, type, ValidationError } from '@orpc/contract';
+export { isDefinedError, ORPCError, safe } from '@orpc/client';
+export { eventIterator, type, ValidationError } from '@orpc/contract';
 export { getEventMeta, withEventMeta } from '@orpc/server-standard';
 export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/middleware-decorated.d.ts

@@ -1,5 +1,6 @@
-import type { Meta, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { Meta } from '@orpc/contract';
 import type { Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
 export interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorConstructorMap, TMeta> {
     concat<UOutContext extends Context, UInput>(middleware: Middleware<TInContext & TOutContext, UOutContext, UInput & TInput, TOutput, TErrorConstructorMap, TMeta>): DecoratedMiddleware<TInContext, MergedContext<TOutContext, UOutContext>, UInput & TInput, TOutput, TErrorConstructorMap, TMeta>;

package/dist/src/middleware.d.ts

@@ -1,6 +1,7 @@
-import type { ErrorMap, Meta, ORPCErrorConstructorMap, Schema } from '@orpc/contract';
+import type { ErrorMap, Meta, Schema } from '@orpc/contract';
 import type { MaybeOptionalOptions, Promisable } from '@orpc/shared';
 import type { Context } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { Procedure } from './procedure';
 export type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
     output: TOutput;

package/dist/src/plugins/base.d.ts

@@ -1,13 +1,11 @@
-import type { StandardHandlerInterceptorOptions, StandardHandlerOptions, WellCreateProcedureClientOptions } from '../adapters/standard';
+import type { StandardHandlerOptions } from '../adapters/standard';
 import type { Context } from '../context';
 export interface Plugin<TContext extends Context> {
     init?(options: StandardHandlerOptions<TContext>): void;
-    beforeCreateProcedureClient?(clientOptions: WellCreateProcedureClientOptions<TContext>, interceptorOptions: StandardHandlerInterceptorOptions<TContext>): void;
 }
 export declare class CompositePlugin<TContext extends Context> implements Plugin<TContext> {
     private readonly plugins;
     constructor(plugins?: Plugin<TContext>[]);
     init(options: StandardHandlerOptions<TContext>): void;
-    beforeCreateProcedureClient(clientOptions: WellCreateProcedureClientOptions<TContext>, interceptorOptions: StandardHandlerInterceptorOptions<TContext>): void;
 }
 //# sourceMappingURL=base.d.ts.map

package/dist/src/procedure-client.d.ts

@@ -1,8 +1,10 @@
-import type { Client, ClientContext, ErrorFromErrorMap, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Client, ClientContext } from '@orpc/client';
 import type { Interceptor, MaybeOptionalOptions, Value } from '@orpc/shared';
 import type { Context } from './context';
 import type { Lazyable } from './lazy';
 import type { Procedure } from './procedure';
+import { type ErrorFromErrorMap, type ErrorMap, type Meta, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
+import { type ORPCErrorConstructorMap } from './error';
 export type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
 export interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
     context: TInitialContext;

package/dist/src/procedure-decorated.d.ts

@@ -1,6 +1,8 @@
-import type { ClientContext, ClientRest, ErrorMap, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientContext, ClientRest } from '@orpc/client';
+import type { ErrorMap, MergedErrorMap, Meta, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
 import type { CreateProcedureClientOptions, ProcedureClient } from './procedure-client';
 import { Procedure } from './procedure';

package/dist/src/procedure-utils.d.ts

@@ -1,4 +1,5 @@
-import type { ClientPromiseResult, ErrorFromErrorMap, ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientPromiseResult } from '@orpc/client';
+import type { ErrorFromErrorMap, ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from './context';
 import type { Lazyable } from './lazy';

package/dist/src/procedure.d.ts

@@ -1,6 +1,7 @@
-import type { ContractProcedureDef, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractProcedureDef, ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
 import type { Context } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { AnyMiddleware } from './middleware';
 export interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TCurrentContext;

package/dist/src/router-client.d.ts

@@ -1,10 +1,11 @@
-import type { ClientContext, ErrorMap, Meta } from '@orpc/contract';
+import type { ClientContext } from '@orpc/client';
+import type { ErrorMap, Meta } from '@orpc/contract';
 import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Lazy } from './lazy';
 import type { Procedure } from './procedure';
 import type { CreateProcedureClientOptions, ProcedureClient } from './procedure-client';
 import type { AnyRouter, InferRouterInitialContext } from './router';
-export type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext> = TRouter extends Lazy<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, any> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
+export type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = Record<never, never>> = TRouter extends Lazy<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, any> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
     [K in keyof TRouter]: TRouter[K] extends AnyRouter ? RouterClient<TRouter[K], TClientContext> : never;
 };
 export declare function createRouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext>(router: TRouter | Lazy<undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<TRouter>, undefined, undefined, unknown, ErrorMap, Meta, TClientContext>>): RouterClient<TRouter, TClientContext>;

package/dist/standard.js

@@ -1,17 +1,13 @@
 import {
   RPCCodec,
   RPCMatcher,
-  RPCSerializer,
-  StandardHandler,
-  serializeRPCJson
-} from "./chunk-NXEANHUK.js";
-import "./chunk-XXBE6CYD.js";
-import "./chunk-XI6WGCB3.js";
+  StandardHandler
+} from "./chunk-77FU7QSO.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-WQNNSBXW.js";
 export {
   RPCCodec,
   RPCMatcher,
-  RPCSerializer,
-  StandardHandler,
-  serializeRPCJson
+  StandardHandler
 };
 //# sourceMappingURL=standard.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.6affcc9",
+  "version": "0.0.0-next.6c13765",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -66,8 +66,9 @@
     "@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.6affcc9",
-    "@orpc/shared": "0.0.0-next.6affcc9"
+    "@orpc/client": "0.0.0-next.6c13765",
+    "@orpc/contract": "0.0.0-next.6c13765",
+    "@orpc/shared": "0.0.0-next.6c13765"
   },
   "devDependencies": {
     "light-my-request": "^6.5.1"

package/dist/chunk-NXEANHUK.js

@@ -1,351 +0,0 @@
-import {
-  convertPathToHttpPath,
-  createContractedProcedure,
-  createProcedureClient,
-  eachContractProcedure,
-  getRouterChild,
-  isProcedure,
-  unlazy
-} from "./chunk-XXBE6CYD.js";
-import {
-  CompositePlugin
-} from "./chunk-XI6WGCB3.js";
-
-// src/adapters/standard/handler.ts
-import { ORPCError, toORPCError } from "@orpc/contract";
-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.interceptorsRoot ?? [],
-      {
-        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 clientOptions = {
-                context: interceptorOptions2.context,
-                path: match.path
-              };
-              this.plugin.beforeCreateProcedureClient(clientOptions, interceptorOptions2);
-              const client = createProcedureClient(match.procedure, clientOptions);
-              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-serializer.ts
-import { mapEventIterator, ORPCError as ORPCError2, toORPCError as toORPCError2 } from "@orpc/contract";
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
-import { findDeepMatches, isObject, set } from "@orpc/shared";
-var RPCSerializer = class {
-  serialize(data) {
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => serializeRPCJson(value),
-        error: async (e) => {
-          if (e instanceof ErrorEvent) {
-            return new ErrorEvent({
-              data: serializeRPCJson(e.data),
-              cause: e
-            });
-          }
-          return new ErrorEvent({
-            data: serializeRPCJson(toORPCError2(e).toJSON()),
-            cause: e
-          });
-        }
-      });
-    }
-    const serializedJSON = serializeRPCJson(data);
-    const { maps, values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON.json);
-    if (blobs.length === 0) {
-      return serializedJSON;
-    }
-    const form = new FormData();
-    form.set("data", JSON.stringify(serializedJSON));
-    form.set("maps", JSON.stringify(maps));
-    for (const i in blobs) {
-      form.set(i, blobs[i]);
-    }
-    return form;
-  }
-  deserialize(serialized) {
-    if (isAsyncIteratorObject(serialized)) {
-      return mapEventIterator(serialized, {
-        value: async (value) => deserializeRPCJson(value),
-        error: async (e) => {
-          if (!(e instanceof ErrorEvent)) {
-            return e;
-          }
-          const deserialized = deserializeRPCJson(e.data);
-          if (ORPCError2.isValidJSON(deserialized)) {
-            return ORPCError2.fromJSON(deserialized, { cause: e });
-          }
-          return new ErrorEvent({
-            data: deserialized,
-            cause: e
-          });
-        }
-      });
-    }
-    if (!(serialized instanceof FormData)) {
-      return deserializeRPCJson(serialized);
-    }
-    const data = JSON.parse(serialized.get("data"));
-    const maps = JSON.parse(serialized.get("maps"));
-    for (const i in maps) {
-      data.json = set(data.json, maps[i], serialized.get(i));
-    }
-    return deserializeRPCJson(data);
-  }
-};
-function serializeRPCJson(value, segments = [], meta = []) {
-  if (typeof value === "bigint") {
-    meta.push(["bigint", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof Date) {
-    meta.push(["date", segments]);
-    const data = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
-    return { json: data, meta };
-  }
-  if (Number.isNaN(value)) {
-    meta.push(["nan", segments]);
-    return { json: "NaN", meta };
-  }
-  if (value instanceof RegExp) {
-    meta.push(["regexp", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof URL) {
-    meta.push(["url", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (isObject(value)) {
-    const json = {};
-    for (const k in value) {
-      json[k] = serializeRPCJson(value[k], [...segments, k], meta).json;
-    }
-    return { json, meta };
-  }
-  if (Array.isArray(value)) {
-    const json = value.map((v, i) => {
-      if (v === void 0) {
-        meta.push(["undefined", [...segments, i]]);
-        return null;
-      }
-      return serializeRPCJson(v, [...segments, i], meta).json;
-    });
-    return { json, meta };
-  }
-  if (value instanceof Set) {
-    const result = serializeRPCJson(Array.from(value), segments, meta);
-    meta.push(["set", segments]);
-    return result;
-  }
-  if (value instanceof Map) {
-    const result = serializeRPCJson(Array.from(value.entries()), segments, meta);
-    meta.push(["map", segments]);
-    return result;
-  }
-  return { json: value, meta };
-}
-function deserializeRPCJson({
-  json,
-  meta
-}) {
-  if (meta.length === 0) {
-    return json;
-  }
-  const ref = { data: json };
-  for (const [type, segments] of meta) {
-    let currentRef = ref;
-    let preSegment = "data";
-    for (let i = 0; i < segments.length; i++) {
-      currentRef = currentRef[preSegment];
-      preSegment = segments[i];
-    }
-    switch (type) {
-      case "nan":
-        currentRef[preSegment] = Number.NaN;
-        break;
-      case "bigint":
-        currentRef[preSegment] = BigInt(currentRef[preSegment]);
-        break;
-      case "date":
-        currentRef[preSegment] = new Date(currentRef[preSegment]);
-        break;
-      case "regexp": {
-        const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
-        currentRef[preSegment] = new RegExp(pattern, flags);
-        break;
-      }
-      case "url":
-        currentRef[preSegment] = new URL(currentRef[preSegment]);
-        break;
-      case "undefined":
-        currentRef[preSegment] = void 0;
-        break;
-      case "map":
-        currentRef[preSegment] = new Map(currentRef[preSegment]);
-        break;
-      case "set":
-        currentRef[preSegment] = new Set(currentRef[preSegment]);
-        break;
-      /* v8 ignore next 3 */
-      default: {
-        const _expected = type;
-      }
-    }
-  }
-  return ref.data;
-}
-
-// src/adapters/standard/rpc-codec.ts
-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,
-  RPCSerializer,
-  serializeRPCJson,
-  RPCCodec,
-  RPCMatcher
-};
-//# sourceMappingURL=chunk-NXEANHUK.js.map

package/dist/src/adapters/standard/rpc-serializer.d.ts

@@ -1,22 +0,0 @@
-import type { Segment } from '@orpc/shared';
-export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url', Segment[]][];
-export type RPCSerialized = {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-} | FormData | AsyncIteratorObject<{
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-}, {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-}, void>;
-export type RPCSerializedFormDataMaps = Segment[][];
-export declare class RPCSerializer {
-    serialize(data: unknown): RPCSerialized;
-    deserialize(serialized: RPCSerialized): unknown;
-}
-export declare function serializeRPCJson(value: unknown, segments?: Segment[], meta?: RPCSerializedJsonMeta): {
-    json: unknown;
-    meta: RPCSerializedJsonMeta;
-};
-//# sourceMappingURL=rpc-serializer.d.ts.map