@temporary-name/server 1.9.3-alpha.4275e976ddda4d8be107c2cfde9899bdea9a337d → 1.9.3-alpha.4c6c68e5af7355d5a6dff1179055586e1093ac2d

package/dist/adapters/node/index.d.ts

@@ -1,77 +1,28 @@
-import { C as Context } from '../../shared/server.C1YnHvvf.js';
-import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
+import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, S as StandardHandler } from '../../shared/server.Btxrgkj5.js';
-import { FriendlyStandardHandleOptions } from '../standard/index.js';
-import compression from '@temporary-name/interop/compression';
-import '@temporary-name/contract';
-import '@temporary-name/standard-server';
-
-interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
-}
-declare class CompositeNodeHttpHandlerPlugin<T extends Context, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
-}
+import { C as Context, m as Router } from '../../shared/server.BfraJHay.js';
+import { b as StandardHandlerOptions, F as FriendlyStandardHandleOptions } from '../../shared/server.CHugaZ_Y.js';
+import '@temporary-name/zod';
 
 type NodeHttpHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
-    request: NodeHttpRequest;
-    response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions;
-}
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
-    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
-    plugins?: NodeHttpHandlerPlugin<T>[];
-}
-declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
-}
-
-interface BodyLimitPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions, StandardHandlerOptions<T> {
 }
 /**
- * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ * OpenAPI Handler for Node Server
  *
- * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
  */
-declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    private readonly maxBodySize;
-    constructor(options: BodyLimitPluginOptions);
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
-}
-
-interface CompressionPluginOptions extends compression.CompressionOptions {
-    /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning [Event Iterator](https://orpc.unnoq.com/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
-     */
-    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
-}
-/**
- * The Compression Plugin adds response compression to the Node.js HTTP Server.
- *
- * @see {@link https://orpc.unnoq.com/docs/plugins/compression Compression Plugin Docs}
- */
-declare class CompressionPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    private readonly compressionHandler;
-    constructor(options?: CompressionPluginOptions);
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly sendStandardResponseOptions;
+    private readonly standardHandler;
+    constructor(router: Router<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler };
-export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin };
+export { NodeHttpHandler };
+export type { NodeHttpHandleResult, NodeHttpHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,136 +1,31 @@
-import { once, ORPCError, toArray, intercept, resolveMaybeOptionalOptions } from '@temporary-name/shared';
-import compression from '@temporary-name/interop/compression';
+import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-node';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.CYa9puL2.mjs';
 import '@temporary-name/standard-server';
-import '@temporary-name/contract';
-import '../../shared/server.D6K9uoPI.mjs';
-import { C as CompositeStandardHandlerPlugin } from '../../shared/server.X0YaZxSJ.mjs';
-import 'node:async_hooks';
-import 'zod';
-import 'zod/v4/core';
-
-class BodyLimitPlugin {
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  initRuntimeAdapter(options) {
-    options.adapterInterceptors ??= [];
-    options.adapterInterceptors.push(async (options2) => {
-      const checkHeader = once(() => {
-        if (Number(options2.request.headers["content-length"]) > this.maxBodySize) {
-          throw new ORPCError("PAYLOAD_TOO_LARGE");
-        }
-      });
-      const originalEmit = options2.request.emit;
-      let currentBodySize = 0;
-      options2.request.emit = (event, ...args) => {
-        if (event === "data") {
-          checkHeader();
-          currentBodySize += args[0].length;
-          if (currentBodySize > this.maxBodySize) {
-            throw new ORPCError("PAYLOAD_TOO_LARGE");
-          }
-        }
-        return originalEmit.call(options2.request, event, ...args);
-      };
-      try {
-        return await options2.next(options2);
-      } finally {
-        options2.request.emit = originalEmit;
-      }
-    });
-  }
-}
-
-class CompressionPlugin {
-  compressionHandler;
-  constructor(options = {}) {
-    this.compressionHandler = compression({
-      ...options,
-      filter: (req, res) => {
-        const hasContentDisposition = res.hasHeader("content-disposition");
-        const contentType = res.getHeader("content-type")?.toString();
-        if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
-          return false;
-        }
-        return options.filter ? options.filter(req, res) : compression.filter(req, res);
-      }
-    });
-  }
-  initRuntimeAdapter(options) {
-    options.adapterInterceptors ??= [];
-    options.adapterInterceptors.unshift(async (options2) => {
-      let resolve;
-      let reject;
-      const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-      });
-      const originalWrite = options2.response.write;
-      const originalEnd = options2.response.end;
-      const originalOn = options2.response.on;
-      this.compressionHandler(options2.request, options2.response, async (err) => {
-        if (err) {
-          reject(err);
-        } else {
-          try {
-            resolve(await options2.next());
-          } catch (error) {
-            reject(error);
-          }
-        }
-      });
-      try {
-        return await promise;
-      } finally {
-        options2.response.write = originalWrite;
-        options2.response.end = originalEnd;
-        options2.response.on = originalOn;
-      }
-    });
-  }
-}
-
-class CompositeNodeHttpHandlerPlugin extends CompositeStandardHandlerPlugin {
-  initRuntimeAdapter(options) {
-    for (const plugin of this.plugins) {
-      plugin.initRuntimeAdapter?.(options);
-    }
-  }
-}
+import '@temporary-name/server';
+import 'rou3';
+import '../../shared/server.Cza0RB3u.mjs';
+import '@temporary-name/zod';
+import '../../shared/server.ChOv1yG3.mjs';
+import '../../shared/server.CQIFwyhc.mjs';
 
 class NodeHttpHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
-    const plugin = new CompositeNodeHttpHandlerPlugin(options.plugins);
-    plugin.initRuntimeAdapter(options);
-    this.adapterInterceptors = toArray(options.adapterInterceptors);
+  sendStandardResponseOptions;
+  standardHandler;
+  constructor(router, options = {}) {
+    this.standardHandler = new StandardHandler(router, options);
     this.sendStandardResponseOptions = options;
   }
-  sendStandardResponseOptions;
-  adapterInterceptors;
   async handle(request, response, ...rest) {
-    return intercept(
-      this.adapterInterceptors,
-      {
-        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
-        request,
-        response,
-        sendStandardResponseOptions: this.sendStandardResponseOptions
-      },
-      async ({ request: request2, response: response2, sendStandardResponseOptions, ...options }) => {
-        const standardRequest = toStandardLazyRequest(request2, response2);
-        const result = await this.standardHandler.handle(standardRequest, options);
-        if (!result.matched) {
-          return { matched: false };
-        }
-        await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
-        return { matched: true };
-      }
-    );
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const standardRequest = toStandardLazyRequest(request, response);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
+    return { matched: true };
   }
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler };
+export { NodeHttpHandler };

package/dist/adapters/standard/index.d.mts

@@ -1,16 +1,29 @@
-import { b as StandardHandleOptions } from '../../shared/server.Bo94xDTv.mjs';
-export { C as CompositeStandardHandlerPlugin, i as StandardCodec, e as StandardHandleResult, S as StandardHandler, c as StandardHandlerInterceptorOptions, d as StandardHandlerOptions, a as StandardHandlerPlugin, g as StandardMatchResult, h as StandardMatcher, f as StandardParams } from '../../shared/server.Bo94xDTv.mjs';
-import { C as Context } from '../../shared/server.C1YnHvvf.mjs';
-import '@temporary-name/contract';
-import '@temporary-name/shared';
-import '@temporary-name/standard-server';
+export { F as FriendlyStandardHandleOptions, S as StandardHandleOptions, a as StandardHandleResult, c as StandardHandler, b as StandardHandlerOptions, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.BbUmcWIW.mjs';
+import { AnyProcedure, AnyRouter } from '@temporary-name/server';
+import { StandardLazyRequest, StandardResponse, ORPCError, HTTPPath } from '@temporary-name/shared';
+import '../../shared/server.BfraJHay.mjs';
+import '@temporary-name/zod';
 
-type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+declare function decode(request: StandardLazyRequest, pathParams: Record<string, string> | undefined): Promise<{
+    path: unknown;
+    query: unknown;
+    headers: Headers;
+    body: unknown;
+}>;
+declare function encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+declare function encodeError(error: ORPCError<any, any>): StandardResponse;
 
-export { StandardHandleOptions, resolveFriendlyStandardHandleOptions };
-export type { FriendlyStandardHandleOptions };
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: Record<string, string>;
+} | undefined;
+declare class StandardOpenAPIMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { StandardOpenAPIMatcher, decode, encode, encodeError };
+export type { StandardMatchResult };

package/dist/adapters/standard/index.d.ts

@@ -1,16 +1,29 @@
-import { b as StandardHandleOptions } from '../../shared/server.Btxrgkj5.js';
-export { C as CompositeStandardHandlerPlugin, i as StandardCodec, e as StandardHandleResult, S as StandardHandler, c as StandardHandlerInterceptorOptions, d as StandardHandlerOptions, a as StandardHandlerPlugin, g as StandardMatchResult, h as StandardMatcher, f as StandardParams } from '../../shared/server.Btxrgkj5.js';
-import { C as Context } from '../../shared/server.C1YnHvvf.js';
-import '@temporary-name/contract';
-import '@temporary-name/shared';
-import '@temporary-name/standard-server';
+export { F as FriendlyStandardHandleOptions, S as StandardHandleOptions, a as StandardHandleResult, c as StandardHandler, b as StandardHandlerOptions, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.CHugaZ_Y.js';
+import { AnyProcedure, AnyRouter } from '@temporary-name/server';
+import { StandardLazyRequest, StandardResponse, ORPCError, HTTPPath } from '@temporary-name/shared';
+import '../../shared/server.BfraJHay.js';
+import '@temporary-name/zod';
 
-type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+declare function decode(request: StandardLazyRequest, pathParams: Record<string, string> | undefined): Promise<{
+    path: unknown;
+    query: unknown;
+    headers: Headers;
+    body: unknown;
+}>;
+declare function encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+declare function encodeError(error: ORPCError<any, any>): StandardResponse;
 
-export { StandardHandleOptions, resolveFriendlyStandardHandleOptions };
-export type { FriendlyStandardHandleOptions };
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure;
+    params?: Record<string, string>;
+} | undefined;
+declare class StandardOpenAPIMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { StandardOpenAPIMatcher, decode, encode, encodeError };
+export type { StandardMatchResult };

package/dist/adapters/standard/index.mjs

@@ -1,101 +1,9 @@
-import { toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, ORPCError, toORPCError } from '@temporary-name/shared';
-import { flattenHeader } from '@temporary-name/standard-server';
-import { c as createProcedureClient } from '../../shared/server.BEQrAa3A.mjs';
-import { C as CompositeStandardHandlerPlugin } from '../../shared/server.X0YaZxSJ.mjs';
-export { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-import '@temporary-name/contract';
-import '../../shared/server.D6K9uoPI.mjs';
-import 'node:async_hooks';
-import 'zod';
-import 'zod/v4/core';
-
-class StandardHandler {
-  constructor(router, matcher, codec, options) {
-    this.matcher = matcher;
-    this.codec = codec;
-    const plugins = new CompositeStandardHandlerPlugin(options.plugins);
-    plugins.init(options, router);
-    this.interceptors = toArray(options.interceptors);
-    this.clientInterceptors = toArray(options.clientInterceptors);
-    this.rootInterceptors = toArray(options.rootInterceptors);
-    this.matcher.init(router);
-  }
-  interceptors;
-  clientInterceptors;
-  rootInterceptors;
-  async handle(request, options) {
-    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
-    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
-      return { matched: false, response: void 0 };
-    }
-    return intercept(this.rootInterceptors, { ...options, request, prefix }, async (interceptorOptions) => {
-      return runWithSpan({ name: `${request.method} ${request.url.pathname}` }, async (span) => {
-        let step;
-        try {
-          return await intercept(
-            this.interceptors,
-            interceptorOptions,
-            async ({ request: request2, context, prefix: prefix2 }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
-              const match = await runWithSpan(
-                { name: "find_procedure" },
-                () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
-              );
-              if (!match) {
-                return { matched: false, response: void 0 };
-              }
-              span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
-              span?.setAttribute("rpc.system", ORPC_NAME);
-              span?.setAttribute("rpc.method", match.path.join("."));
-              step = "decode_input";
-              let input = await runWithSpan(
-                { name: "decode_input" },
-                () => this.codec.decode(request2, match.params, match.procedure)
-              );
-              step = void 0;
-              if (isAsyncIteratorObject(input)) {
-                input = asyncIteratorWithSpan(
-                  { name: "consume_event_iterator_input", signal: request2.signal },
-                  input
-                );
-              }
-              const client = createProcedureClient(match.procedure, {
-                context,
-                path: match.path,
-                interceptors: this.clientInterceptors
-              });
-              step = "call_procedure";
-              const output = await client(input, {
-                signal: request2.signal,
-                lastEventId: flattenHeader(request2.headers["last-event-id"])
-              });
-              step = void 0;
-              const response = this.codec.encode(output, match.procedure);
-              return {
-                matched: true,
-                response
-              };
-            }
-          );
-        } catch (e) {
-          if (step !== "call_procedure") {
-            setSpanError(span, e);
-          }
-          const error = step === "decode_input" && !(e instanceof ORPCError) ? 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
-          };
-        }
-      });
-    });
-  }
-}
-
-export { CompositeStandardHandlerPlugin, StandardHandler };
+export { S as StandardHandler, b as StandardOpenAPIMatcher, d as decode, c as decodeParams, e as encode, a as encodeError, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.CYa9puL2.mjs';
+import '@temporary-name/shared';
+import '../../shared/server.Cza0RB3u.mjs';
+import '@temporary-name/standard-server';
+import '@temporary-name/zod';
+import '../../shared/server.ChOv1yG3.mjs';
+import '../../shared/server.CQIFwyhc.mjs';
+import '@temporary-name/server';
+import 'rou3';

package/dist/helpers/index.mjs

@@ -1,4 +1,5 @@
-import { serialize, parse } from 'cookie';
+export { d as deleteCookie, g as getCookie, s as setCookie } from '../shared/server.C1RJffw4.mjs';
+import 'cookie';
 
 function encodeBase64url(data) {
   const chunkSize = 8192;
@@ -30,33 +31,6 @@ function decodeBase64url(base64url) {
   }
 }
 
-function setCookie(headers, name, value, options = {}) {
-  if (headers === void 0) {
-    return;
-  }
-  const cookieString = serialize(name, value, {
-    path: "/",
-    ...options
-  });
-  headers.append("Set-Cookie", cookieString);
-}
-function getCookie(headers, name, options = {}) {
-  if (headers === void 0) {
-    return void 0;
-  }
-  const cookieHeader = headers.get("cookie");
-  if (cookieHeader === null) {
-    return void 0;
-  }
-  return parse(cookieHeader, options)[name];
-}
-function deleteCookie(headers, name, options = {}) {
-  return setCookie(headers, name, "", {
-    ...options,
-    maxAge: 0
-  });
-}
-
 const PBKDF2_CONFIG = {
   name: "PBKDF2",
   iterations: 6e4,
@@ -165,4 +139,4 @@ function getSignedValue(signedValue) {
   return signedValue.slice(0, lastDotIndex);
 }
 
-export { decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };
+export { decodeBase64url, decrypt, encodeBase64url, encrypt, getSignedValue, sign, unsign };