@orpc/server 0.0.0-next.cc4cb21 → 0.0.0-next.cc8802c

package/dist/{index.js → index.mjs}

@@ -1,33 +1,12 @@
-import {
-  LAZY_LOADER_SYMBOL,
-  Procedure,
-  adaptRouter,
-  addMiddleware,
-  convertPathToHttpPath,
-  createAccessibleLazyRouter,
-  createContractedProcedure,
-  createLazyProcedureFormAnyLazy,
-  createProcedureClient,
-  deepSetLazyRouterPrefix,
-  eachAllContractProcedure,
-  eachContractProcedure,
-  flatLazy,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  isLazy,
-  isProcedure,
-  lazy,
-  middlewareOutputFn,
-  setRouterContract,
-  unlazy
-} from "./chunk-MHVECKBC.js";
+import { mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, mergeTags, isContractProcedure, getContractRouter } from '@orpc/contract';
+export { ValidationError, eventIterator, type } from '@orpc/contract';
+import { P as Procedure, d as addMiddleware, c as createProcedureClient, e as enhanceRouter, l as lazy, s as setHiddenRouterContract, i as isProcedure, f as isLazy, h as createAssertedLazyProcedure, g as getRouter } from './shared/server.CMrS28Go.mjs';
+export { L as LAZY_SYMBOL, k as call, o as createAccessibleLazyRouter, b as createContractedProcedure, n as getHiddenRouterContract, j as getLazyMeta, m as middlewareOutputFn, r as resolveContractProcedures, a as toHttpPath, t as traverseContractProcedures, u as unlazy, p as unlazyRouter } from './shared/server.CMrS28Go.mjs';
+export { ORPCError, isDefinedError, safe } from '@orpc/client';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
-// src/builder.ts
-import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
-
-// src/config.ts
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
   initialInputValidationIndex: 0,
   initialOutputValidationIndex: 0
 };
@@ -38,9 +17,8 @@ function fallbackConfig(key, value) {
   return value;
 }
 
-// src/middleware-decorated.ts
 function decorateMiddleware(middleware) {
-  const decorated = middleware;
+  const decorated = (...args) => middleware(...args);
   decorated.mapInput = (mapInput) => {
     const mapped = decorateMiddleware(
       (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
@@ -65,30 +43,28 @@ function decorateMiddleware(middleware) {
   return decorated;
 }
 
-// src/procedure-decorated.ts
-import { mergeErrorMap, mergeMeta, mergeRoute } from "@orpc/contract";
-var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+class DecoratedProcedure extends Procedure {
   errors(errors) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
   meta(meta) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       route: mergeRoute(this["~orpc"].route, route)
     });
   }
   use(middleware, mapInput) {
     const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _DecoratedProcedure({
+    return new DecoratedProcedure({
       ...this["~orpc"],
       middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
@@ -97,9 +73,13 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
    * Make this procedure callable (works like a function while still being a procedure).
    */
   callable(...rest) {
-    return Object.assign(createProcedureClient(this, ...rest), {
-      "~type": "Procedure",
-      "~orpc": this["~orpc"]
+    return new Proxy(createProcedureClient(this, ...rest), {
+      get: (target, key) => {
+        return Reflect.has(this, key) ? Reflect.get(this, key) : Reflect.get(target, key);
+      },
+      has: (target, key) => {
+        return Reflect.has(this, key) || Reflect.has(target, key);
+      }
     });
   }
   /**
@@ -108,10 +88,9 @@ var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
   actionable(...rest) {
     return this.callable(...rest);
   }
-};
+}
 
-// src/builder.ts
-var Builder = class _Builder {
+class Builder {
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
@@ -122,7 +101,7 @@ var Builder = class _Builder {
   $config(config) {
     const inputValidationCount = this["~orpc"].inputValidationIndex - fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex);
     const outputValidationCount = this["~orpc"].outputValidationIndex - fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex);
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       config,
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", config.initialInputValidationIndex) + inputValidationCount,
@@ -133,7 +112,7 @@ var Builder = class _Builder {
    * Reset initial context
    */
   $context() {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       middlewares: [],
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex),
@@ -144,7 +123,7 @@ var Builder = class _Builder {
    * Reset initial meta
    */
   $meta(initialMeta) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       meta: initialMeta
     });
@@ -153,48 +132,54 @@ var Builder = class _Builder {
    * Reset initial route
    */
   $route(initialRoute) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       route: initialRoute
     });
   }
+  $input(initialInputSchema) {
+    return new Builder({
+      ...this["~orpc"],
+      inputSchema: initialInputSchema
+    });
+  }
   middleware(middleware) {
     return decorateMiddleware(middleware);
   }
   errors(errors) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      errorMap: mergeErrorMap2(this["~orpc"].errorMap, errors)
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
   use(middleware, mapInput) {
     const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
     });
   }
   meta(meta) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      meta: mergeMeta2(this["~orpc"].meta, meta)
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
-      route: mergeRoute2(this["~orpc"].route, route)
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
   input(schema) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       inputSchema: schema,
       inputValidationIndex: fallbackConfig("initialInputValidationIndex", this["~orpc"].config.initialInputValidationIndex) + this["~orpc"].middlewares.length
     });
   }
   output(schema) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       outputSchema: schema,
       outputValidationIndex: fallbackConfig("initialOutputValidationIndex", this["~orpc"].config.initialOutputValidationIndex) + this["~orpc"].middlewares.length
@@ -207,43 +192,38 @@ var Builder = class _Builder {
     });
   }
   prefix(prefix) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
-    return new _Builder({
+    return new Builder({
       ...this["~orpc"],
       tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
   router(router) {
-    return adaptRouter(router, this["~orpc"]);
+    return enhanceRouter(router, this["~orpc"]);
   }
   lazy(loader) {
-    return adaptRouter(flatLazy(lazy(loader)), this["~orpc"]);
+    return enhanceRouter(lazy(loader), this["~orpc"]);
   }
-};
-var os = new Builder({
+}
+const os = new Builder({
   config: {},
   route: {},
   meta: {},
   errorMap: {},
-  inputSchema: void 0,
-  outputSchema: void 0,
   inputValidationIndex: fallbackConfig("initialInputValidationIndex"),
   outputValidationIndex: fallbackConfig("initialOutputValidationIndex"),
   middlewares: []
 });
 
-// src/context.ts
 function mergeContext(context, other) {
   return { ...context, ...other };
 }
 
-// src/implementer.ts
-import { isContractProcedure } from "@orpc/contract";
 function implementerInternal(contract, config, middlewares) {
   if (isContractProcedure(contract)) {
     const impl2 = new Builder({
@@ -257,6 +237,9 @@ function implementerInternal(contract, config, middlewares) {
   }
   const impl = new Proxy(contract, {
     get: (target, key) => {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
       let method;
       if (key === "middleware") {
         method = (mid) => decorateMiddleware(mid);
@@ -270,23 +253,27 @@ function implementerInternal(contract, config, middlewares) {
         };
       } else if (key === "router") {
         method = (router) => {
-          const adapted = adaptRouter(router, {
+          const adapted = enhanceRouter(router, {
             middlewares,
-            errorMap: {}
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0
           });
-          return setRouterContract(adapted, contract);
+          return setHiddenRouterContract(adapted, contract);
         };
       } else if (key === "lazy") {
         method = (loader) => {
-          const adapted = adaptRouter(flatLazy(lazy(loader)), {
+          const adapted = enhanceRouter(lazy(loader), {
             middlewares,
-            errorMap: {}
+            errorMap: {},
+            prefix: void 0,
+            tags: void 0
           });
-          return setRouterContract(adapted, contract);
+          return setHiddenRouterContract(adapted, contract);
         };
       }
-      const next = Reflect.get(target, key);
-      if (!next || typeof next !== "function" && typeof next !== "object") {
+      const next = getContractRouter(target, [key]);
+      if (!next) {
         return method ?? next;
       }
       const nextImpl = implementerInternal(next, config, middlewares);
@@ -329,28 +316,21 @@ function implement(contract, config = {}) {
   return impl;
 }
 
-// src/procedure-utils.ts
-function call(procedure, input, ...rest) {
-  return createProcedureClient(procedure, ...rest)(input);
-}
-
-// src/router-client.ts
-function createRouterClient(router, ...rest) {
+function createRouterClient(router, ...[options]) {
   if (isProcedure(router)) {
-    const caller = createProcedureClient(router, ...rest);
+    const caller = createProcedureClient(router, options);
     return caller;
   }
-  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
+  const procedureCaller = isLazy(router) ? createProcedureClient(createAssertedLazyProcedure(router), options) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = getRouterChild(router, key);
+      const next = getRouter(router, [key]);
       if (!next) {
         return Reflect.get(target, key);
       }
-      const [options] = rest;
       return createRouterClient(next, {
         ...options,
         path: [...options?.path ?? [], key]
@@ -360,54 +340,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-// src/index.ts
-import { isDefinedError, ORPCError, safe } from "@orpc/client";
-import { eventIterator, type, ValidationError } from "@orpc/contract";
-import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
-import { getEventMeta, withEventMeta } from "@orpc/standard-server";
-export {
-  Builder,
-  DecoratedProcedure,
-  LAZY_LOADER_SYMBOL,
-  ORPCError,
-  Procedure,
-  ValidationError,
-  adaptRouter,
-  call,
-  convertPathToHttpPath,
-  createAccessibleLazyRouter,
-  createContractedProcedure,
-  createLazyProcedureFormAnyLazy,
-  createProcedureClient,
-  createRouterClient,
-  decorateMiddleware,
-  deepSetLazyRouterPrefix,
-  eachAllContractProcedure,
-  eachContractProcedure,
-  eventIterator,
-  fallbackConfig,
-  flatLazy,
-  getEventMeta,
-  getLazyRouterPrefix,
-  getRouterChild,
-  getRouterContract,
-  implement,
-  implementerInternal,
-  isDefinedError,
-  isLazy,
-  isProcedure,
-  lazy,
-  mergeContext,
-  middlewareOutputFn,
-  onError,
-  onFinish,
-  onStart,
-  onSuccess,
-  os,
-  safe,
-  setRouterContract,
-  type,
-  unlazy,
-  withEventMeta
-};
-//# sourceMappingURL=index.js.map
+export { Builder, DecoratedProcedure, Procedure, createAssertedLazyProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, fallbackConfig, getRouter, implement, implementerInternal, isLazy, isProcedure, lazy, mergeContext, os, setHiddenRouterContract };

package/dist/plugins/index.d.mts

@@ -0,0 +1,31 @@
+import { a as StandardHandlerInterceptorOptions, H as HandlerPlugin, b as StandardHandlerOptions } from '../shared/server.CM3tWr3C.mjs';
+export { C as CompositePlugin } from '../shared/server.CM3tWr3C.mjs';
+import { Value } from '@orpc/shared';
+import { C as Context } from '../shared/server.CPteJIPP.mjs';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client';
+
+interface CORSOptions<TContext extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: readonly string[];
+}
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly options;
+    constructor(options?: CORSOptions<TContext>);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface ResponseHeadersPluginContext {
+    resHeaders?: Headers;
+}
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/plugins/index.d.ts

@@ -0,0 +1,31 @@
+import { a as StandardHandlerInterceptorOptions, H as HandlerPlugin, b as StandardHandlerOptions } from '../shared/server.DmW25ynm.js';
+export { C as CompositePlugin } from '../shared/server.DmW25ynm.js';
+import { Value } from '@orpc/shared';
+import { C as Context } from '../shared/server.CPteJIPP.js';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client';
+
+interface CORSOptions<TContext extends Context> {
+    origin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    timingOrigin?: Value<string | readonly string[] | null | undefined, [origin: string, options: StandardHandlerInterceptorOptions<TContext>]>;
+    allowMethods?: readonly string[];
+    allowHeaders?: readonly string[];
+    maxAge?: number;
+    credentials?: boolean;
+    exposeHeaders?: readonly string[];
+}
+declare class CORSPlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly options;
+    constructor(options?: CORSOptions<TContext>);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+interface ResponseHeadersPluginContext {
+    resHeaders?: Headers;
+}
+declare class ResponseHeadersPlugin<TContext extends ResponseHeadersPluginContext & Context> implements HandlerPlugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { type CORSOptions, CORSPlugin, HandlerPlugin, ResponseHeadersPlugin, type ResponseHeadersPluginContext };

package/dist/{chunk-TXHKQO7N.js → plugins/index.mjs}

@@ -1,20 +1,9 @@
-// src/plugins/base.ts
-var CompositePlugin = class {
-  constructor(plugins = []) {
-    this.plugins = plugins;
-  }
-  init(options) {
-    for (const plugin of this.plugins) {
-      plugin.init?.(options);
-    }
-  }
-};
+export { C as CompositePlugin } from '../shared/server.Q6ZmnTgO.mjs';
+import { value } from '@orpc/shared';
 
-// src/plugins/cors.ts
-import { value } from "@orpc/shared";
-var CORSPlugin = class {
+class CORSPlugin {
   options;
-  constructor(options) {
+  constructor(options = {}) {
     const defaults = {
       origin: (origin) => origin,
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
@@ -84,10 +73,9 @@ var CORSPlugin = class {
       return result;
     });
   }
-};
+}
 
-// src/plugins/response-headers.ts
-var ResponseHeadersPlugin = class {
+class ResponseHeadersPlugin {
   init(options) {
     options.rootInterceptors ??= [];
     options.rootInterceptors.push(async (interceptorOptions) => {
@@ -98,23 +86,18 @@ var ResponseHeadersPlugin = class {
         return result;
       }
       const responseHeaders = result.response.headers;
-      for (const [key, value2] of headers) {
+      for (const [key, value] of headers) {
         if (Array.isArray(responseHeaders[key])) {
-          responseHeaders[key].push(value2);
+          responseHeaders[key].push(value);
         } else if (responseHeaders[key] !== void 0) {
-          responseHeaders[key] = [responseHeaders[key], value2];
+          responseHeaders[key] = [responseHeaders[key], value];
         } else {
-          responseHeaders[key] = value2;
+          responseHeaders[key] = value;
         }
       }
       return result;
     });
   }
-};
+}
 
-export {
-  CompositePlugin,
-  CORSPlugin,
-  ResponseHeadersPlugin
-};
-//# sourceMappingURL=chunk-TXHKQO7N.js.map
+export { CORSPlugin, ResponseHeadersPlugin };

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

@@ -0,0 +1,75 @@
+import { HTTPPath, AnySchema, Meta, InferSchemaOutput, ErrorFromErrorMap } from '@orpc/contract';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
+import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './server.CPteJIPP.mjs';
+import { ORPCError } from '@orpc/client';
+
+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>;
+}
+
+type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+type StandardHandlerInterceptorOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+    request: StandardLazyRequest;
+};
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: HandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, AnySchema, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardLazyRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
+}
+
+interface HandlerPlugin<TContext extends Context> {
+    init?(options: StandardHandlerOptions<TContext>): void;
+}
+declare class CompositePlugin<TContext extends Context> implements HandlerPlugin<TContext> {
+    private readonly plugins;
+    constructor(plugins?: HandlerPlugin<TContext>[]);
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+export { CompositePlugin as C, type HandlerPlugin as H, type StandardHandleOptions as S, type StandardHandlerInterceptorOptions as a, type StandardHandlerOptions as b, type StandardCodec as c, type StandardParams as d, type StandardMatcher as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };