@orpc/server 0.0.0-next.ea0903c → 0.0.0-next.eaf61c7

package/dist/shared/server.Et1O6Bm7.mjs

@@ -1,98 +0,0 @@
-import { ORPCError } from '@orpc/client';
-import { StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
-import { S as StandardHandler, b as StandardRPCMatcher, a as StandardRPCCodec } from './server.D9QduY95.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 };