@orpc/server 0.0.0-next.d137cdf → 0.0.0-next.d7b5662

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

@@ -0,0 +1,25 @@
+import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Hooks, Value } from '@orpc/shared';
+import type { Lazy } from './lazy';
+import type { Procedure } from './procedure';
+import type { ProcedureClient } from './procedure-client';
+import type { Meta } from './types';
+import { type ANY_ROUTER, type Router } from './router';
+export type RouterClient<TRouter extends ANY_ROUTER | ContractRouter, TClientContext> = TRouter extends Lazy<infer U extends ANY_ROUTER | ContractRouter> ? RouterClient<U, TClientContext> : TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema> | Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? ProcedureClient<SchemaInput<UInputSchema>, SchemaOutput<UOutputSchema, UFuncOutput>, TClientContext> : {
+    [K in keyof TRouter]: TRouter[K] extends ANY_ROUTER | ContractRouter ? RouterClient<TRouter[K], TClientContext> : never;
+};
+export type CreateRouterClientOptions<TRouter extends ANY_ROUTER> = {
+    router: TRouter | Lazy<undefined>;
+    /**
+     * This is helpful for logging and analytics.
+     *
+     * @internal
+     */
+    path?: string[];
+} & (TRouter extends Router<infer UContext, any> ? undefined extends UContext ? {
+    context?: Value<UContext>;
+} : {
+    context: Value<UContext>;
+} : never) & Hooks<unknown, unknown, TRouter extends Router<infer UContext, any> ? UContext : never, Meta>;
+export declare function createRouterClient<TRouter extends ANY_ROUTER>(options: CreateRouterClientOptions<TRouter>): RouterClient<TRouter, unknown>;
+//# sourceMappingURL=router-client.d.ts.map

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

@@ -1,24 +1,21 @@
-import type { DecoratedLazy } from './lazy';
+import type { ContractRouter } from '@orpc/contract';
+import type { FlattenLazy } from './lazy';
 import type { Middleware } from './middleware';
-import type { HandledRouter, RouterWithContract } from './router';
-import type { Context } from './types';
-import { type ContractProcedure, type ContractRouter } from '@orpc/contract';
-import { ProcedureImplementer } from './procedure-implementer';
-export declare const ROUTER_CONTRACT_SYMBOL: unique symbol;
-export declare class RouterImplementer<TContext extends Context, TContract extends ContractRouter> {
-    zz$ri: {
-        contract: TContract;
-    };
-    constructor(zz$ri: {
-        contract: TContract;
-    });
-    router(router: RouterWithContract<TContext, TContract>): HandledRouter<RouterWithContract<TContext, TContract>>;
-    lazy(loader: () => Promise<{
-        default: RouterWithContract<TContext, TContract>;
-    }>): DecoratedLazy<RouterWithContract<TContext, TContract>>;
+import type { Router } from './router';
+import type { AdaptedRouter } from './router-builder';
+import type { Context, MergeContext } from './types';
+export interface RouterImplementerDef<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter> {
+    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any>[];
+    contract: TContract;
+}
+export declare class RouterImplementer<TContext extends Context, TExtraContext extends Context, TContract extends ContractRouter> {
+    '~type': "RouterImplementer";
+    '~orpc': RouterImplementerDef<TContext, TExtraContext, TContract>;
+    constructor(def: RouterImplementerDef<TContext, TExtraContext, TContract>);
+    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown>): RouterImplementer<TContext, MergeContext<TExtraContext, U>, TContract>;
+    router<U extends Router<MergeContext<TContext, TExtraContext>, TContract>>(router: U): AdaptedRouter<TContext, U>;
+    lazy<U extends Router<MergeContext<TContext, TExtraContext>, TContract>>(loader: () => Promise<{
+        default: U;
+    }>): AdaptedRouter<TContext, FlattenLazy<U>>;
 }
-export type ChainedRouterImplementer<TContext extends Context, TContract extends ContractRouter, TExtraContext extends Context> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? ChainedRouterImplementer<TContext, TContract[K], TExtraContext> : never;
-} & RouterImplementer<TContext, TContract>;
-export declare function chainRouterImplementer<TContext extends Context, TContract extends ContractRouter, TExtraContext extends Context>(contract: TContract, middlewares?: Middleware<any, any, any, any>[]): ChainedRouterImplementer<TContext, TContract, TExtraContext>;
 //# sourceMappingURL=router-implementer.d.ts.map

package/dist/src/router.d.ts

@@ -1,21 +1,16 @@
 import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { ANY_LAZY, DecoratedLazy, Lazy } from './lazy';
+import type { ANY_LAZY, Lazy, Lazyable } from './lazy';
+import type { ANY_PROCEDURE, Procedure } from './procedure';
 import type { Context } from './types';
-import { type DecoratedProcedure, type Procedure } from './procedure';
-export interface Router<TContext extends Context> {
-    [k: string]: Procedure<TContext, any, any, any, any> | Lazy<Procedure<TContext, any, any, any, any>> | Router<TContext> | Lazy<Router<TContext>>;
-}
-export type HandledRouter<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<infer UContext, infer UExtraContext, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? DecoratedProcedure<UContext, UExtraContext, UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends ANY_LAZY ? DecoratedLazy<TRouter[K]> : TRouter[K] extends Router<any> ? HandledRouter<TRouter[K]> : never;
+export type Router<TContext extends Context, TContract extends ContractRouter> = Lazyable<TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> : {
+    [K in keyof TContract]: TContract[K] extends ContractRouter ? Router<TContext, TContract[K]> : never;
+}>;
+export type ANY_ROUTER = Router<any, any>;
+export type InferRouterInputs<T extends ANY_ROUTER> = T extends Lazy<infer U extends ANY_ROUTER> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends ANY_ROUTER ? InferRouterInputs<T[K]> : never;
 };
-export type RouterWithContract<TContext extends Context, TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? Procedure<TContext, any, UInputSchema, UOutputSchema, any> | Lazy<Procedure<TContext, any, UInputSchema, UOutputSchema, any>> : TContract[K] extends ContractRouter ? RouterWithContract<TContext, TContract[K]> | Lazy<RouterWithContract<TContext, TContract[K]>> : never;
-};
-export declare function toContractRouter(router: ContractRouter | Router<any>): ContractRouter;
-export type InferRouterInputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, infer UInputSchema, any, any> | Lazy<Procedure<any, any, infer UInputSchema, any, any>> ? SchemaInput<UInputSchema> : T[K] extends Router<any> ? InferRouterInputs<T[K]> : never;
-};
-export type InferRouterOutputs<T extends Router<any>> = {
-    [K in keyof T]: T[K] extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput>> ? SchemaOutput<UOutputSchema, UFuncOutput> : T[K] extends Router<any> ? InferRouterOutputs<T[K]> : never;
+export type InferRouterOutputs<T extends ANY_ROUTER> = T extends Lazy<infer U extends ANY_ROUTER> ? InferRouterOutputs<U> : T extends Procedure<any, any, any, infer UOutputSchema, infer UFuncOutput> ? SchemaOutput<UOutputSchema, UFuncOutput> : {
+    [K in keyof T]: T[K] extends ANY_ROUTER ? InferRouterOutputs<T[K]> : never;
 };
+export declare function getRouterChild<T extends ANY_ROUTER | Lazy<undefined>>(router: T, ...path: string[]): T extends ANY_LAZY ? Lazy<ANY_PROCEDURE | Record<string, ANY_ROUTER> | undefined> : ANY_ROUTER | Lazy<undefined> | undefined;
 //# sourceMappingURL=router.d.ts.map

package/dist/src/types.d.ts

@@ -1,8 +1,12 @@
-import type { WELL_DEFINED_PROCEDURE } from './procedure';
-export type Context = Record<string, unknown> | undefined;
+import type { ANY_PROCEDURE } from './procedure';
+export type Context = Record<string, any> | undefined;
+export type WELL_CONTEXT = Record<string, unknown> | undefined;
 export type MergeContext<TA extends Context, TB extends Context> = TA extends undefined ? TB : TB extends undefined ? TA : TA & TB;
-export interface Meta {
+export interface WithSignal {
+    signal?: AbortSignal;
+}
+export interface Meta extends WithSignal {
     path: string[];
-    procedure: WELL_DEFINED_PROCEDURE;
+    procedure: ANY_PROCEDURE;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.d137cdf",
+  "version": "0.0.0-next.d7b5662",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -33,17 +33,12 @@
     "!**/*.tsbuildinfo",
     "dist"
   ],
-  "peerDependencies": {
-    "zod": ">=3.23.0",
-    "@orpc/zod": "0.0.0-next.d137cdf"
-  },
   "dependencies": {
-    "@orpc/contract": "0.0.0-next.d137cdf",
-    "@orpc/transformer": "0.0.0-next.d137cdf",
-    "@orpc/shared": "0.0.0-next.d137cdf"
+    "@orpc/contract": "0.0.0-next.d7b5662",
+    "@orpc/shared": "0.0.0-next.d7b5662"
   },
   "devDependencies": {
-    "@orpc/openapi": "0.0.0-next.d137cdf"
+    "zod": "^3.24.1"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",

package/dist/chunk-MZXEMHFS.js

@@ -1,272 +0,0 @@
-// src/utils.ts
-function mergeContext(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return {
-    ...a,
-    ...b
-  };
-}
-
-// src/middleware.ts
-var decoratedMiddlewareSymbol = Symbol("\u{1F512}decoratedMiddleware");
-function decorateMiddleware(middleware) {
-  if (Reflect.get(middleware, decoratedMiddlewareSymbol)) {
-    return middleware;
-  }
-  const concat = (concatMiddleware, mapInput2) => {
-    const concatMiddleware_ = mapInput2 ? decorateMiddleware(concatMiddleware).mapInput(mapInput2) : concatMiddleware;
-    return decorateMiddleware(async (input, context, meta, ...rest) => {
-      const input_ = input;
-      const context_ = context;
-      const meta_ = meta;
-      const next = async (options) => {
-        return concatMiddleware_(input_, mergeContext(context_, options.context), meta_, ...rest);
-      };
-      const m1 = await middleware(input_, context_, {
-        ...meta_,
-        next
-      }, ...rest);
-      return m1;
-    });
-  };
-  const mapInput = (map) => {
-    return decorateMiddleware(
-      (input, ...rest) => middleware(map(input), ...rest)
-    );
-  };
-  return Object.assign(middleware, {
-    [decoratedMiddlewareSymbol]: true,
-    concat,
-    mapInput
-  });
-}
-
-// src/procedure-caller.ts
-import { executeWithHooks, trim, value } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-
-// src/procedure.ts
-import {
-  DecoratedContractProcedure,
-  isContractProcedure
-} from "@orpc/contract";
-var Procedure = class {
-  constructor(zz$p) {
-    this.zz$p = zz$p;
-  }
-};
-var DECORATED_PROCEDURE_SYMBOL = Symbol("DECORATED_PROCEDURE");
-function decorateProcedure(procedure) {
-  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
-    return procedure;
-  }
-  return Object.assign(createProcedureCaller({
-    procedure,
-    context: void 0
-  }), {
-    [DECORATED_PROCEDURE_SYMBOL]: true,
-    zz$p: procedure.zz$p,
-    prefix(prefix) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).prefix(prefix)
-        }
-      });
-    },
-    route(opts) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).route(opts)
-        }
-      });
-    },
-    use(middleware, mapInput) {
-      const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          middlewares: [middleware_, ...procedure.zz$p.middlewares ?? []]
-        }
-      });
-    }
-  });
-}
-function isProcedure(item) {
-  if (item instanceof Procedure)
-    return true;
-  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$p" in item && typeof item.zz$p === "object" && item.zz$p !== null && "contract" in item.zz$p && isContractProcedure(item.zz$p.contract) && "func" in item.zz$p && typeof item.zz$p.func === "function";
-}
-
-// src/procedure-caller.ts
-function createProcedureCaller(options) {
-  const caller = async (input) => {
-    const path = options.path ?? [];
-    const procedure = await loadProcedure(options.procedure);
-    const context = await value(options.context);
-    const execute = async () => {
-      const validInput = (() => {
-        const schema = procedure.zz$p.contract.zz$cp.InputSchema;
-        if (!schema) {
-          return input;
-        }
-        try {
-          return schema.parse(input);
-        } catch (e) {
-          throw new ORPCError({
-            message: "Validation input failed",
-            code: "BAD_REQUEST",
-            cause: e
-          });
-        }
-      })();
-      const middlewares = procedure.zz$p.middlewares ?? [];
-      let currentMidIndex = 0;
-      let currentContext = context;
-      const next = async (nextOptions) => {
-        const mid = middlewares[currentMidIndex];
-        currentMidIndex += 1;
-        currentContext = mergeContext(currentContext, nextOptions.context);
-        if (mid) {
-          return await mid(validInput, currentContext, {
-            path,
-            procedure,
-            next,
-            output: (output3) => ({ output: output3, context: void 0 })
-          });
-        } else {
-          return {
-            output: await await procedure.zz$p.func(validInput, currentContext, {
-              path,
-              procedure
-            }),
-            context: currentContext
-          };
-        }
-      };
-      const output2 = (await next({})).output;
-      const validOutput = await (async () => {
-        const schema = procedure.zz$p.contract.zz$cp.OutputSchema;
-        if (!schema) {
-          return output2;
-        }
-        const result = await schema.safeParseAsync(output2);
-        if (result.error) {
-          throw new ORPCError({
-            message: "Validation output failed",
-            code: "INTERNAL_SERVER_ERROR",
-            cause: result.error
-          });
-        }
-        return result.data;
-      })();
-      return validOutput;
-    };
-    const output = await executeWithHooks({
-      hooks: options,
-      input,
-      context,
-      meta: {
-        path,
-        procedure
-      },
-      execute
-    });
-    return output;
-  };
-  return caller;
-}
-async function loadProcedure(procedure) {
-  let loadedProcedure;
-  if (isLazy(procedure)) {
-    loadedProcedure = (await loadLazy(procedure)).default;
-  } else {
-    loadedProcedure = procedure;
-  }
-  if (!isProcedure(loadedProcedure)) {
-    throw new ORPCError({
-      code: "NOT_FOUND",
-      message: "Not found",
-      cause: new Error(trim(`
-          This error should be caught by the typescript compiler.
-          But if you still see this error, it means that you trying to call a lazy router (expected to be a lazy procedure).
-        `))
-    });
-  }
-  return loadedProcedure;
-}
-
-// src/lazy.ts
-var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function createLazy(loader) {
-  return {
-    [LAZY_LOADER_SYMBOL]: loader
-  };
-}
-function loadLazy(lazy) {
-  return lazy[LAZY_LOADER_SYMBOL]();
-}
-function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
-}
-function createFlattenLazy(lazy) {
-  const flattenLoader = async () => {
-    let current = await loadLazy(lazy);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
-      }
-      current = await loadLazy(current.default);
-    }
-    return current;
-  };
-  const flattenLazy = {
-    [LAZY_LOADER_SYMBOL]: flattenLoader
-  };
-  return flattenLazy;
-}
-function decorateLazy(lazy) {
-  const flattenLazy = createFlattenLazy(lazy);
-  const procedureCaller = createProcedureCaller({
-    procedure: flattenLazy,
-    context: void 0
-  });
-  Object.assign(procedureCaller, flattenLazy);
-  const recursive = new Proxy(procedureCaller, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      return decorateLazy(createLazy(async () => {
-        const current = await loadLazy(flattenLazy);
-        return { default: current.default[key] };
-      }));
-    }
-  });
-  return recursive;
-}
-
-export {
-  mergeContext,
-  decorateMiddleware,
-  LAZY_LOADER_SYMBOL,
-  createLazy,
-  loadLazy,
-  isLazy,
-  createFlattenLazy,
-  decorateLazy,
-  createProcedureCaller,
-  loadProcedure,
-  Procedure,
-  decorateProcedure,
-  isProcedure
-};
-//# sourceMappingURL=chunk-MZXEMHFS.js.map

package/dist/src/fetch/handle.d.ts

@@ -1,7 +0,0 @@
-import type { Router } from '../router';
-import type { FetchHandler, FetchHandlerOptions } from './types';
-export type HandleFetchRequestOptions<TRouter extends Router<any>> = FetchHandlerOptions<TRouter> & {
-    handlers: readonly [FetchHandler, ...FetchHandler[]];
-};
-export declare function handleFetchRequest<TRouter extends Router<any>>(options: HandleFetchRequestOptions<TRouter>): Promise<Response>;
-//# sourceMappingURL=handle.d.ts.map

package/dist/src/fetch/handler.d.ts

@@ -1,3 +0,0 @@
-import type { FetchHandler } from './types';
-export declare function createORPCHandler(): FetchHandler;
-//# sourceMappingURL=handler.d.ts.map

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

@@ -1,25 +0,0 @@
-import type { SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Hooks, PartialOnUndefinedDeep, Value } from '@orpc/shared';
-import type { Lazy } from './lazy';
-import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Procedure } from './procedure';
-export type CreateProcedureCallerOptions<T extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = T extends Procedure<infer UContext, any, any, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<infer UContext, any, any, infer UOutputSchema, infer UFuncOutput>> ? {
-    procedure: T;
-    /**
-     * This is helpful for logging and analytics.
-     *
-     * @internal
-     */
-    path?: string[];
-} & PartialOnUndefinedDeep<{
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<UContext>;
-}> & Hooks<unknown, SchemaOutput<UOutputSchema, UFuncOutput>, UContext, {
-    path: string[];
-    procedure: ANY_PROCEDURE;
-}> : never;
-export type ProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? (...input: [input: SchemaInput<UInputSchema>] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
-export declare function createProcedureCaller<TProcedure extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
-export declare function loadProcedure(procedure: ANY_PROCEDURE | ANY_LAZY_PROCEDURE): Promise<ANY_PROCEDURE>;
-//# sourceMappingURL=procedure-caller.d.ts.map

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

@@ -1,25 +0,0 @@
-import type { Hooks, Value } from '@orpc/shared';
-import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE } from './procedure';
-import type { Router } from './router';
-import { type ProcedureCaller } from './procedure-caller';
-export interface CreateRouterCallerOptions<TRouter extends Router<any>> extends Hooks<unknown, unknown, TRouter extends Router<infer UContext> ? UContext : never, {
-    path: string[];
-    procedure: ANY_PROCEDURE;
-}> {
-    router: TRouter;
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<TRouter extends Router<infer UContext> ? UContext : never>;
-    /**
-     * This is helpful for logging and analytics.
-     *
-     * @internal
-     */
-    basePath?: string[];
-}
-export type RouterCaller<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends ANY_PROCEDURE | ANY_LAZY_PROCEDURE ? ProcedureCaller<TRouter[K]> : TRouter[K] extends Router<any> ? RouterCaller<TRouter[K]> : never;
-};
-export declare function createRouterCaller<TRouter extends Router<any>>(options: CreateRouterCallerOptions<TRouter>): RouterCaller<TRouter>;
-//# sourceMappingURL=router-caller.d.ts.map