@orpc/server 0.0.0-next.d16a1b6 → 0.0.0-next.d1f8ea3

package/dist/shared/{server.V6zT5iYQ.mjs → server.e3W6AG3-.mjs}

@@ -1,18 +1,48 @@
+import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
 import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
-import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, adaptRoute } from '@orpc/contract';
-import { value, intercept, toError } from '@orpc/shared';
+import { value, intercept } from '@orpc/shared';
 
-const LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function lazy(loader) {
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazy(loader, meta = {}) {
   return {
-    [LAZY_LOADER_SYMBOL]: loader
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
   };
 }
 function isLazy(item) {
-  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
 }
 function unlazy(lazied) {
-  return isLazy(lazied) ? lazied[LAZY_LOADER_SYMBOL]() : Promise.resolve({ default: lazied });
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
+    }
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
+}
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
 }
 
 class Procedure {
@@ -28,50 +58,8 @@ function isProcedure(item) {
   return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
-function flatLazy(lazied) {
-  const flattenLoader = async () => {
-    let current = await unlazy(lazied);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
-      }
-      current = await unlazy(current.default);
-    }
-    return current;
-  };
-  return lazy(flattenLoader);
-}
-function createLazyProcedureFormAnyLazy(lazied) {
-  const lazyProcedure = lazy(async () => {
-    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
-    if (!isProcedure(maybeProcedure)) {
-      throw new Error(`
-            Expected a lazy<procedure> but got lazy<unknown>.
-            This should be caught by TypeScript compilation.
-            Please report this issue if this makes you feel uncomfortable.
-        `);
-    }
-    return { default: maybeProcedure };
-  });
-  return lazyProcedure;
-}
-
-function dedupeMiddlewares(compare, middlewares) {
-  let min = 0;
-  for (let i = 0; i < middlewares.length; i++) {
-    const index = compare.indexOf(middlewares[i], min);
-    if (index === -1) {
-      return middlewares.slice(i);
-    }
-    min = index + 1;
-  }
-  return [];
-}
-function mergeMiddlewares(first, second) {
-  return [...first, ...dedupeMiddlewares(first, second)];
-}
-function addMiddleware(middlewares, addition) {
-  return [...middlewares, addition];
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
 }
 
 function createORPCErrorConstructorMap(errors) {
@@ -139,7 +127,7 @@ function createProcedureClient(lazyableProcedure, ...[options]) {
       );
     } catch (e) {
       if (!(e instanceof ORPCError)) {
-        throw toError(e);
+        throw e;
       }
       const validated = await validateORPCError(procedure["~orpc"].errorMap, e);
       throw validated;
@@ -186,188 +174,188 @@ async function executeProcedureInternal(procedure, options) {
   let currentInput = options.input;
   const next = async (...[nextOptions]) => {
     const index = currentIndex;
+    const midContext = nextOptions?.context ?? {};
     currentIndex += 1;
-    currentContext = { ...currentContext, ...nextOptions?.context };
+    currentContext = mergeCurrentContext(currentContext, midContext);
     if (index === inputValidationIndex) {
       currentInput = await validateInput(procedure, currentInput);
     }
     const mid = middlewares[index];
-    const result = mid ? await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn) : { output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput }), context: currentContext };
+    const result = mid ? {
+      context: midContext,
+      output: (await mid({ ...options, context: currentContext, next }, currentInput, middlewareOutputFn)).output
+    } : {
+      context: midContext,
+      output: await procedure["~orpc"].handler({ ...options, context: currentContext, input: currentInput })
+    };
     if (index === outputValidationIndex) {
       const validatedOutput = await validateOutput(procedure, result.output);
       return {
-        ...result,
+        context: result.context,
         output: validatedOutput
       };
     }
     return result;
   };
-  return (await next({})).output;
+  return (await next()).output;
 }
 
-const ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_ROUTER_CONTRACT");
-function setRouterContract(obj, contract) {
-  return new Proxy(obj, {
+const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
+function setHiddenRouterContract(router, contract) {
+  return new Proxy(router, {
     get(target, key) {
-      if (key === ROUTER_CONTRACT_SYMBOL) {
+      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
         return contract;
       }
       return Reflect.get(target, key);
     }
   });
 }
-function getRouterContract(obj) {
-  return obj[ROUTER_CONTRACT_SYMBOL];
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
 }
-const LAZY_ROUTER_PREFIX_SYMBOL = Symbol("ORPC_LAZY_ROUTER_PREFIX");
-function deepSetLazyRouterPrefix(router, prefix) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key !== LAZY_ROUTER_PREFIX_SYMBOL) {
-        const val = Reflect.get(target, key);
-        if (isLazy(val)) {
-          return deepSetLazyRouterPrefix(val, prefix);
-        }
-        return val;
-      }
-      return prefix;
+
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
     }
-  });
-}
-function getLazyRouterPrefix(obj) {
-  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
+    if (isProcedure(current)) {
+      return void 0;
+    }
+    if (!isLazy(current)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return lazy(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
 }
-
 function createAccessibleLazyRouter(lazied) {
-  const flattenLazy = flatLazy(lazied);
-  const recursive = new Proxy(flattenLazy, {
+  const recursive = new Proxy(lazied, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = getRouterChild(flattenLazy, key);
+      const next = getRouter(lazied, [key]);
       return createAccessibleLazyRouter(next);
     }
   });
   return recursive;
 }
-
-function adaptRouter(router, options) {
+function enhanceRouter(router, options) {
   if (isLazy(router)) {
-    const adapted2 = lazy(async () => {
-      const unlaziedRouter = (await unlazy(router)).default;
-      const adapted3 = adaptRouter(unlaziedRouter, options);
-      return { default: adapted3 };
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazy(async () => {
+      const { default: unlaziedRouter } = await unlazy(router);
+      const enhanced3 = enhanceRouter(unlaziedRouter, options);
+      return unlazy(enhanced3);
+    }, {
+      ...laziedMeta,
+      prefix: enhancedPrefix
     });
-    const accessible = createAccessibleLazyRouter(adapted2);
-    const currentPrefix = getLazyRouterPrefix(router);
-    const prefix = currentPrefix ? mergePrefix(options.prefix, currentPrefix) : options.prefix;
-    if (prefix) {
-      return deepSetLazyRouterPrefix(accessible, prefix);
-    }
+    const accessible = createAccessibleLazyRouter(enhanced2);
     return accessible;
   }
   if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares);
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, { dedupeLeading: options.dedupeLeadingMiddlewares });
     const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
-    const adapted2 = new Procedure({
+    const enhanced2 = new Procedure({
       ...router["~orpc"],
-      route: adaptRoute(router["~orpc"].route, options),
+      route: enhanceRoute(router["~orpc"].route, options),
       errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
       middlewares: newMiddlewares,
       inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
     });
-    return adapted2;
+    return enhanced2;
   }
-  const adapted = {};
+  const enhanced = {};
   for (const key in router) {
-    adapted[key] = adaptRouter(router[key], options);
-  }
-  return adapted;
-}
-function getRouterChild(router, ...path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!current) {
-      return void 0;
-    }
-    if (isProcedure(current)) {
-      return void 0;
-    }
-    if (!isLazy(current)) {
-      current = current[segment];
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    const newLazy = lazy(async () => {
-      const unwrapped = await unlazy(lazied);
-      if (!unwrapped.default) {
-        return unwrapped;
-      }
-      const next = getRouterChild(unwrapped.default, ...rest);
-      return { default: next };
-    });
-    return flatLazy(newLazy);
+    enhanced[key] = enhanceRouter(router[key], options);
   }
-  return current;
+  return enhanced;
 }
-
-function eachContractProcedure(options, callback, laziedOptions = []) {
-  const hiddenContract = getRouterContract(options.router);
-  if (hiddenContract) {
-    return eachContractProcedure(
-      {
-        router: hiddenContract,
-        path: options.path
-      },
-      callback,
-      laziedOptions
-    );
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  let currentRouter = options.router;
+  const hiddenContract = getHiddenRouterContract(options.router);
+  if (hiddenContract !== void 0) {
+    currentRouter = hiddenContract;
   }
-  if (isLazy(options.router)) {
-    laziedOptions.push({
-      lazied: options.router,
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
       path: options.path
     });
-  } else if (isContractProcedure(options.router)) {
+  } else if (isContractProcedure(currentRouter)) {
     callback({
-      contract: options.router,
+      contract: currentRouter,
       path: options.path
     });
   } else {
-    for (const key in options.router) {
-      eachContractProcedure(
+    for (const key in currentRouter) {
+      traverseContractProcedures(
         {
-          router: options.router[key],
+          router: currentRouter[key],
           path: [...options.path, key]
         },
         callback,
-        laziedOptions
+        lazyOptions
       );
     }
   }
-  return laziedOptions;
+  return lazyOptions;
 }
-async function eachAllContractProcedure(options, callback) {
+async function resolveContractProcedures(options, callback) {
   const pending = [options];
-  for (const item of pending) {
-    const lazies = eachContractProcedure(item, callback);
-    for (const lazy of lazies) {
-      const { default: router } = await unlazy(lazy.lazied);
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
       pending.push({
-        path: lazy.path,
-        router
+        router,
+        path: options3.path
       });
     }
   }
 }
-function convertPathToHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
+async function unlazyRouter(router) {
+  if (isProcedure(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+function createAssertedLazyProcedure(lazied) {
+  const lazyProcedure = lazy(async () => {
+    const { default: maybeProcedure } = await unlazy(lazied);
+    if (!isProcedure(maybeProcedure)) {
+      throw new Error(`
+            Expected a lazy<procedure> but got lazy<unknown>.
+            This should be caught by TypeScript compilation.
+            Please report this issue if this makes you feel uncomfortable.
+        `);
+    }
+    return { default: maybeProcedure };
+  }, getLazyMeta(lazied));
+  return lazyProcedure;
 }
-function createContractedProcedure(contract, procedure) {
+function createContractedProcedure(procedure, contract) {
   return new Procedure({
     ...procedure["~orpc"],
     errorMap: contract["~orpc"].errorMap,
@@ -375,5 +363,8 @@ function createContractedProcedure(contract, procedure) {
     meta: contract["~orpc"].meta
   });
 }
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
 
-export { LAZY_LOADER_SYMBOL as L, Procedure as P, convertPathToHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, eachContractProcedure as e, adaptRouter as f, getRouterChild as g, flatLazy as h, isProcedure as i, isLazy as j, createLazyProcedureFormAnyLazy as k, lazy as l, getRouterContract as m, deepSetLazyRouterPrefix as n, getLazyRouterPrefix as o, middlewareOutputFn as p, createAccessibleLazyRouter as q, eachAllContractProcedure as r, setRouterContract as s, unlazy as u };
+export { LAZY_SYMBOL as L, Procedure as P, createContractedProcedure as a, addMiddleware as b, createProcedureClient as c, isLazy as d, enhanceRouter as e, createAssertedLazyProcedure as f, getRouter as g, createORPCErrorConstructorMap as h, isProcedure as i, getLazyMeta as j, middlewareOutputFn as k, lazy as l, mergeCurrentContext as m, isStartWithMiddlewares as n, mergeMiddlewares as o, call as p, getHiddenRouterContract as q, createAccessibleLazyRouter as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u, validateORPCError as v, resolveContractProcedures as w, unlazyRouter as x };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.d16a1b6",
+  "version": "0.0.0-next.d1f8ea3",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -58,15 +58,15 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/client": "0.0.0-next.d16a1b6",
-    "@orpc/contract": "0.0.0-next.d16a1b6",
-    "@orpc/shared": "0.0.0-next.d16a1b6",
-    "@orpc/standard-server": "0.0.0-next.d16a1b6",
-    "@orpc/standard-server-node": "0.0.0-next.d16a1b6",
-    "@orpc/standard-server-fetch": "0.0.0-next.d16a1b6"
+    "@orpc/shared": "0.0.0-next.d1f8ea3",
+    "@orpc/contract": "0.0.0-next.d1f8ea3",
+    "@orpc/standard-server": "0.0.0-next.d1f8ea3",
+    "@orpc/standard-server-fetch": "0.0.0-next.d1f8ea3",
+    "@orpc/client": "0.0.0-next.d1f8ea3",
+    "@orpc/standard-server-node": "0.0.0-next.d1f8ea3"
   },
   "devDependencies": {
-    "light-my-request": "^6.5.1"
+    "supertest": "^7.0.0"
   },
   "scripts": {
     "build": "unbuild",

package/dist/shared/server.B-ewprcf.d.ts

@@ -1,77 +0,0 @@
-import { HTTPPath, Schema, Meta, SchemaOutput, 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.Cn9ybJtE.js';
-import { ORPCError } from '@orpc/client';
-
-type StandardParams = Record<string, string>;
-type StandardMatchResult = {
-    path: 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 WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
-    context: T;
-};
-type StandardHandleResult = {
-    matched: true;
-    response: StandardResponse;
-} | {
-    matched: false;
-    response: undefined;
-};
-type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
-    request: StandardLazyRequest;
-};
-interface StandardHandlerOptions<TContext extends Context> {
-    plugins?: Plugin<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, Schema, Record<never, never>, Meta>, SchemaOutput<Schema, unknown>, 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<T, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<T>>);
-    handle(request: StandardLazyRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
-}
-
-interface Plugin<TContext extends Context> {
-    init?(options: StandardHandlerOptions<TContext>): void;
-}
-declare class CompositePlugin<TContext extends Context> implements Plugin<TContext> {
-    private readonly plugins;
-    constructor(plugins?: Plugin<TContext>[]);
-    init(options: StandardHandlerOptions<TContext>): void;
-}
-
-export { CompositePlugin as C, type Plugin as P, type StandardHandleOptions as S, type WellStandardHandleOptions as W, type StandardHandlerOptions as a, type StandardMatcher as b, type StandardCodec as c, type StandardHandlerInterceptorOptions as d, type StandardParams as e, type StandardMatchResult as f, type StandardHandleResult as g, StandardHandler as h };

package/dist/shared/server.CA-o8cUY.d.mts

@@ -1,9 +0,0 @@
-import { C as Context } from './server.Cn9ybJtE.mjs';
-import { a as StandardHandlerOptions, b as StandardMatcher, c as StandardCodec } from './server.DJrh0Ceu.mjs';
-
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T> {
-    matcher?: StandardMatcher;
-    codec?: StandardCodec;
-}
-
-export type { RPCHandlerOptions as R };