@orpc/server 0.0.0-next.b42ba03 → 0.0.0-next.b45a533

package/dist/shared/server.3mOimouH.mjs

@@ -0,0 +1,158 @@
+import { ORPCError, toORPCError } from '@orpc/client';
+import { intercept, trim, parseEmptyableJSON } from '@orpc/shared';
+import { C as CompositePlugin } from './server.Q6ZmnTgO.mjs';
+import { c as createProcedureClient, t as traverseContractProcedures, a as toHttpPath, i as isProcedure, u as unlazy, g as getRouter, b as createContractedProcedure } from './server.B_5ZADvP.mjs';
+
+class StandardHandler {
+  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
+          };
+        }
+      }
+    );
+  }
+}
+
+class RPCCodec {
+  constructor(serializer) {
+    this.serializer = serializer;
+  }
+  async decode(request, _params, _procedure) {
+    const serialized = request.method === "GET" ? parseEmptyableJSON(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())
+    };
+  }
+}
+
+class RPCMatcher {
+  tree = {};
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
+      const httpPath = toHttpPath(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: toHttpPath(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.router);
+          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(getRouter(match.router, match.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.procedure = createContractedProcedure(maybeProcedure, match.contract);
+    }
+    return {
+      path: match.path,
+      procedure: match.procedure
+    };
+  }
+}
+
+export { RPCCodec as R, StandardHandler as S, RPCMatcher as a };

package/dist/{chunk-EDQKEHUX.js → shared/server.B_5ZADvP.mjs}

@@ -1,25 +1,56 @@
-// src/lazy.ts
-var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
-function lazy(loader) {
+import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
+import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
+import { value, intercept, toError } from '@orpc/shared';
+
+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];
 }
 
-// src/procedure.ts
-import { isContractProcedure } from "@orpc/contract";
-var Procedure = class {
+class Procedure {
   "~orpc";
   constructor(def) {
     this["~orpc"] = def;
   }
-};
+}
 function isProcedure(item) {
   if (item instanceof Procedure) {
     return true;
@@ -27,48 +58,53 @@ function isProcedure(item) {
   return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
-// src/lazy-utils.ts
-function flatLazy(lazied) {
-  const flattenLoader = async () => {
-    let current = await unlazy(lazied);
-    while (true) {
-      if (!isLazy(current.default)) {
-        break;
+function createORPCErrorConstructorMap(errors) {
+  const proxy = new Proxy(errors, {
+    get(target, code) {
+      if (typeof code !== "string") {
+        return Reflect.get(target, code);
       }
-      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.
-        `);
+      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 { default: maybeProcedure };
   });
-  return lazyProcedure;
+  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/middleware.ts
 function middlewareOutputFn(output) {
   return { output, context: {} };
 }
 
-// src/procedure-client.ts
-import { createORPCErrorConstructorMap, ORPCError, validateORPCError, ValidationError } from "@orpc/contract";
-import { intercept, toError, value } from "@orpc/shared";
 function createProcedureClient(lazyableProcedure, ...[options]) {
   return async (...[input, callerOptions]) => {
     const path = options?.path ?? [];
     const { default: procedure } = await unlazy(lazyableProcedure);
-    const context = await value(options?.context ?? {}, callerOptions?.context);
+    const clientContext = callerOptions?.context ?? {};
+    const context = await value(options?.context ?? {}, clientContext);
     const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
     try {
       return await intercept(
@@ -80,7 +116,8 @@ function createProcedureClient(lazyableProcedure, ...[options]) {
           errors,
           path,
           procedure,
-          signal: callerOptions?.signal
+          signal: callerOptions?.signal,
+          lastEventId: callerOptions?.lastEventId
         },
         (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
       );
@@ -152,98 +189,22 @@ async function executeProcedureInternal(procedure, options) {
   return (await next({})).output;
 }
 
-// src/hidden.ts
-var 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];
-}
-var 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 getLazyRouterPrefix(obj) {
-  return obj[LAZY_ROUTER_PREFIX_SYMBOL];
+function getHiddenRouterContract(router) {
+  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
 }
 
-// src/router.ts
-import { adaptRoute, mergeErrorMap, mergePrefix } from "@orpc/contract";
-
-// src/middleware-utils.ts
-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];
-}
-
-// src/router.ts
-function adaptRouter(router, options) {
-  if (isLazy(router)) {
-    const adapted2 = lazy(async () => {
-      const unlaziedRouter = (await unlazy(router)).default;
-      const adapted3 = adaptRouter(unlaziedRouter, options);
-      return { default: adapted3 };
-    });
-    const accessible = createAccessibleLazyRouter(adapted2);
-    const currentPrefix = getLazyRouterPrefix(router);
-    const prefix = currentPrefix ? mergePrefix(options.prefix, currentPrefix) : options.prefix;
-    if (prefix) {
-      return deepSetLazyRouterPrefix(accessible, prefix);
-    }
-    return accessible;
-  }
-  if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares);
-    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
-    const adapted2 = new Procedure({
-      ...router["~orpc"],
-      route: adaptRoute(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;
-  }
-  const adapted = {};
-  for (const key in router) {
-    adapted[key] = adaptRouter(router[key], options);
-  }
-  return adapted;
-}
-function getRouterChild(router, ...path) {
+function getRouter(router, path) {
   let current = router;
   for (let i = 0; i < path.length; i++) {
     const segment = path[i];
@@ -259,89 +220,131 @@ function getRouterChild(router, ...path) {
     }
     const lazied = current;
     const rest = path.slice(i);
-    const newLazy = lazy(async () => {
+    return lazy(async () => {
       const unwrapped = await unlazy(lazied);
-      if (!unwrapped.default) {
-        return unwrapped;
-      }
-      const next = getRouterChild(unwrapped.default, ...rest);
-      return { default: next };
-    });
-    return flatLazy(newLazy);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
   }
   return current;
 }
-
-// src/router-accessible-lazy.ts
 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;
 }
-
-// src/utils.ts
-import { isContractProcedure as isContractProcedure2 } from "@orpc/contract";
-function eachContractProcedure(options, callback, laziedOptions = []) {
-  const hiddenContract = getRouterContract(options.router);
-  if (hiddenContract) {
-    return eachContractProcedure(
-      {
-        router: hiddenContract,
-        path: options.path
-      },
-      callback,
-      laziedOptions
-    );
+function enhanceRouter(router, options) {
+  if (isLazy(router)) {
+    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(enhanced2);
+    return accessible;
   }
-  if (isLazy(options.router)) {
-    laziedOptions.push({
-      lazied: options.router,
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, { dedupeLeading: options.dedupeLeadingMiddlewares });
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      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 enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceRouter(router[key], options);
+  }
+  return enhanced;
+}
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  let currentRouter = options.router;
+  const hiddenContract = getHiddenRouterContract(options.router);
+  if (hiddenContract !== void 0) {
+    currentRouter = hiddenContract;
+  }
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
       path: options.path
     });
-  } else if (isContractProcedure2(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 lazy2 of lazies) {
-      const { default: router } = await unlazy(lazy2.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: lazy2.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 createContractedProcedure(contract, procedure) {
+
+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(procedure, contract) {
   return new Procedure({
     ...procedure["~orpc"],
     errorMap: contract["~orpc"].errorMap,
@@ -349,29 +352,12 @@ function createContractedProcedure(contract, procedure) {
     meta: contract["~orpc"].meta
   });
 }
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
+
+function toHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
 
-export {
-  LAZY_LOADER_SYMBOL,
-  lazy,
-  isLazy,
-  unlazy,
-  Procedure,
-  isProcedure,
-  flatLazy,
-  createLazyProcedureFormAnyLazy,
-  addMiddleware,
-  middlewareOutputFn,
-  createProcedureClient,
-  setRouterContract,
-  getRouterContract,
-  deepSetLazyRouterPrefix,
-  getLazyRouterPrefix,
-  createAccessibleLazyRouter,
-  adaptRouter,
-  getRouterChild,
-  eachContractProcedure,
-  eachAllContractProcedure,
-  convertPathToHttpPath,
-  createContractedProcedure
-};
-//# sourceMappingURL=chunk-EDQKEHUX.js.map
+export { LAZY_SYMBOL as L, Procedure as P, toHttpPath as a, createContractedProcedure as b, createProcedureClient as c, addMiddleware as d, enhanceRouter as e, isLazy as f, getRouter as g, createAssertedLazyProcedure as h, isProcedure as i, createORPCErrorConstructorMap as j, getLazyMeta as k, lazy as l, middlewareOutputFn 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/dist/shared/server.BgDZnmUZ.mjs

@@ -0,0 +1,28 @@
+import { RPCSerializer } from '@orpc/client/standard';
+import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
+import { S as StandardHandler, a as RPCMatcher, R as RPCCodec } from './server.3mOimouH.mjs';
+
+class RPCHandler {
+  standardHandler;
+  constructor(router, options = {}) {
+    const serializer = new RPCSerializer();
+    const matcher = new RPCMatcher();
+    const codec = new RPCCodec(serializer);
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...[
+    options = {}
+  ]) {
+    const standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, options)
+    };
+  }
+}
+
+export { RPCHandler as R };