@orpc/server 0.0.0-next.c0afbea → 0.0.0-next.c0ca4c7

package/dist/shared/server.T5WmDoWQ.mjs

@@ -0,0 +1,98 @@
+import { ORPCError } from '@orpc/client';
+import { StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
+import { S as StandardHandler, b as StandardRPCMatcher, a as StandardRPCCodec } from './server.Dfx1jV-K.mjs';
+import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
+import { r as resolveFriendlyStandardHandleOptions } from './server.BVwwTHyO.mjs';
+
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      if (!options2.request.body) {
+        return options2.next();
+      }
+      let currentBodySize = 0;
+      const rawReader = options2.request.body.getReader();
+      const reader = new ReadableStream({
+        start: async (controller) => {
+          try {
+            if (Number(options2.request.headers.get("content-length")) > this.maxBodySize) {
+              controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+              return;
+            }
+            while (true) {
+              const { done, value } = await rawReader.read();
+              if (done) {
+                break;
+              }
+              currentBodySize += value.length;
+              if (currentBodySize > this.maxBodySize) {
+                controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+                break;
+              }
+              controller.enqueue(value);
+            }
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      const requestInit = { body: reader, duplex: "half" };
+      return options2.next({
+        ...options2,
+        request: new Request(options2.request, requestInit)
+      });
+    });
+  }
+}
+
+class FetchHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    for (const plugin of toArray(options.plugins)) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.toFetchResponseOptions = options;
+  }
+  toFetchResponseOptions;
+  adapterInterceptors;
+  async handle(request, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        toFetchResponseOptions: this.toFetchResponseOptions
+      },
+      async ({ request: request2, toFetchResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return result;
+        }
+        return {
+          matched: true,
+          response: toFetchResponse(result.response, toFetchResponseOptions)
+        };
+      }
+    );
+  }
+}
+
+class RPCHandler extends FetchHandler {
+  constructor(router, options = {}) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const matcher = new StandardRPCMatcher();
+    const codec = new StandardRPCCodec(serializer);
+    super(new StandardHandler(router, matcher, codec, options), options);
+  }
+}
+
+export { BodyLimitPlugin as B, FetchHandler as F, RPCHandler as R };

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

@@ -1,6 +1,6 @@
 import { isContractProcedure, ValidationError, mergePrefix, mergeErrorMap, enhanceRoute } from '@orpc/contract';
 import { fallbackORPCErrorStatus, ORPCError } from '@orpc/client';
-import { value, intercept, toError } from '@orpc/shared';
+import { value, intercept } from '@orpc/shared';
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -21,7 +21,24 @@ function unlazy(lazied) {
   return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
 }
 
-function mergeMiddlewares(first, second) {
+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) {
@@ -41,6 +58,10 @@ function isProcedure(item) {
   return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
 }
 
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
+}
+
 function createORPCErrorConstructorMap(errors) {
   const proxy = new Proxy(errors, {
     get(target, code) {
@@ -106,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;
@@ -153,23 +174,30 @@ 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 HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
@@ -239,7 +267,7 @@ function enhanceRouter(router, options) {
     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 enhanced2 = new Procedure({
       ...router["~orpc"],
@@ -339,8 +367,4 @@ function call(procedure, input, ...rest) {
   return createProcedureClient(procedure, ...rest)(input);
 }
 
-function toHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
-}
-
-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, getLazyMeta as j, call as k, lazy as l, middlewareOutputFn as m, getHiddenRouterContract as n, createAccessibleLazyRouter as o, unlazyRouter as p, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, 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.c0afbea",
+  "version": "0.0.0-next.c0ca4c7",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -58,15 +58,15 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "@orpc/client": "0.0.0-next.c0afbea",
-    "@orpc/contract": "0.0.0-next.c0afbea",
-    "@orpc/shared": "0.0.0-next.c0afbea",
-    "@orpc/standard-server-node": "0.0.0-next.c0afbea",
-    "@orpc/standard-server-fetch": "0.0.0-next.c0afbea",
-    "@orpc/standard-server": "0.0.0-next.c0afbea"
+    "@orpc/contract": "0.0.0-next.c0ca4c7",
+    "@orpc/shared": "0.0.0-next.c0ca4c7",
+    "@orpc/standard-server": "0.0.0-next.c0ca4c7",
+    "@orpc/standard-server-fetch": "0.0.0-next.c0ca4c7",
+    "@orpc/standard-server-node": "0.0.0-next.c0ca4c7",
+    "@orpc/client": "0.0.0-next.c0ca4c7"
   },
   "devDependencies": {
-    "light-my-request": "^6.5.1"
+    "supertest": "^7.0.0"
   },
   "scripts": {
     "build": "unbuild",

package/dist/shared/server.Cq3B6PoL.mjs

@@ -1,28 +0,0 @@
-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.CSZRzcSW.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 };

package/dist/shared/server.Q6ZmnTgO.mjs

@@ -1,12 +0,0 @@
-class CompositePlugin {
-  constructor(plugins = []) {
-    this.plugins = plugins;
-  }
-  init(options) {
-    for (const plugin of this.plugins) {
-      plugin.init?.(options);
-    }
-  }
-}
-
-export { CompositePlugin as C };