@orpc/server 2.0.0-beta.49 → 2.0.0-beta.50

package/dist/lazy.js

@@ -1,31 +1,20 @@
-import { getConstructor, isNonPrimitive } from '@orpc/shared';
-export class Lazy {
-    '~orpc';
-    constructor(def) {
-        this['~orpc'] = def;
-    }
-    /**
-     * Checks if the given instance satisfies the {@link Lazy} class/interface.
-     */
-    static [Symbol.hasInstance](instance) {
-        if (this !== Lazy) {
-            // fallback to default instanceof check if this is extended class
-            return Function.prototype[Symbol.hasInstance].call(this, instance);
-        }
-        const constructor = getConstructor(instance);
-        if (constructor === Lazy) {
-            return true;
-        }
-        return (isNonPrimitive(instance) &&
-            isNonPrimitive(instance['~orpc']) &&
-            isNonPrimitive(instance['~orpc'].meta) &&
-            (instance['~orpc'].metaPlugins === undefined ||
-                Array.isArray(instance['~orpc'].metaPlugins)) &&
-            typeof instance['~orpc'].loader === 'function');
-    }
-}
-export function unlazy(maybeLazy) {
-    return maybeLazy instanceof Lazy
-        ? maybeLazy['~orpc'].loader()
-        : Promise.resolve({ default: maybeLazy });
+import { getConstructor, isNonPrimitive } from "@orpc/shared";
+// src/lazy.ts
+var Lazy = class Lazy {
+	"~orpc";
+	"constructor"(def) {
+		this["~orpc"] = def;
+	}
+	/**
+	* Checks if the given instance satisfies the {@link Lazy} class/interface.
+	*/
+	static [Symbol.hasInstance](instance) {
+		if (this !== Lazy) return Function.prototype[Symbol.hasInstance].call(this, instance);
+		if (getConstructor(instance) === Lazy) return true;
+		return isNonPrimitive(instance) && isNonPrimitive(instance["~orpc"]) && isNonPrimitive(instance["~orpc"].meta) && (instance["~orpc"].metaPlugins === void 0 || Array.isArray(instance["~orpc"].metaPlugins)) && typeof instance["~orpc"].loader === "function";
+	}
+};
+function unlazy(maybeLazy) {
+	return maybeLazy instanceof Lazy ? maybeLazy["~orpc"].loader() : Promise.resolve({ default: maybeLazy });
 }
+export { Lazy, unlazy };

package/dist/middleware-decorated.d.ts

@@ -1,10 +1,9 @@
-import type { ErrorMap, MergedErrorMap } from '@orpc/contract';
-import type { IntersectPick } from '@orpc/shared';
-import type { Context, MergedContext, MergedInitialContext } from './context.ts';
-import type { Middleware } from './middleware.ts';
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { Middleware } from "./middleware.js";
+import { ErrorMap, MergedErrorMap } from "@orpc/contract";
+import { IntersectPick } from "@orpc/shared";
 export interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap> {
-    adaptInput<T>(adapt: (input: T) => TInput): DecoratedMiddleware<TInContext, TOutContext, T, TOutput, TErrorMap>;
-    errors<T extends ErrorMap>(errors: T): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, MergedErrorMap<TErrorMap, T>>;
-    use<$OutContext extends IntersectPick<MergedContext<TInContext, TOutContext>, $OutContext>, $Input extends TInput, $InContext extends Context = MergedContext<TInContext, TOutContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInContext, TOutContext>, $OutContext, $Input, TOutput, $ErrorMap>): DecoratedMiddleware<MergedInitialContext<TInContext, TOutContext, $InContext>, MergedContext<TOutContext, $OutContext>, $Input, TOutput, MergedErrorMap<$ErrorMap, TErrorMap>>;
-}
-export declare function decorateMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap>(middleware: Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>;
+  adaptInput<T>(adapt: (input: T) => TInput): DecoratedMiddleware<TInContext, TOutContext, T, TOutput, TErrorMap>;
+  errors<T extends ErrorMap>(errors: T): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, MergedErrorMap<TErrorMap, T>>;
+  use<$OutContext extends IntersectPick<MergedContext<TInContext, TOutContext>, $OutContext>, $Input extends TInput, $InContext extends Context = MergedContext<TInContext, TOutContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInContext, TOutContext>, $OutContext, $Input, TOutput, $ErrorMap>): DecoratedMiddleware<MergedInitialContext<TInContext, TOutContext, $InContext>, MergedContext<TOutContext, $OutContext>, $Input, TOutput, MergedErrorMap<$ErrorMap, TErrorMap>>;
+}

package/dist/middleware-decorated.js

@@ -1,71 +1,67 @@
-import { mergeErrorMap } from '@orpc/contract';
-import { toArray } from '@orpc/shared';
-export function decorateMiddleware(middleware) {
-    const decorated = ((...args) => middleware(...args));
-    decorated['~orpc'] = middleware['~orpc'];
-    Object.defineProperty(decorated, 'name', {
-        value: middleware.name,
-    });
-    decorated.adaptInput = (adapt) => {
-        const mapped = decorateMiddleware((opts, input, ...args) => {
-            return middleware(opts, adapt(input), ...args);
-        });
-        mapped['~orpc'] = decorated['~orpc'];
-        Object.defineProperty(mapped, 'name', {
-            value: decorated.name,
-        });
-        return mapped;
-    };
-    decorated.errors = (errors) => {
-        const newMiddleware = decorateMiddleware(decorated);
-        newMiddleware['~orpc'] = {
-            ...decorated['~orpc'],
-            errorMap: mergeErrorMap(decorated['~orpc']?.errorMap, errors),
-        };
-        return newMiddleware;
-    };
-    decorated.use = (usedMiddleware) => {
-        const merged = decorateMiddleware((opts, ...args) => {
-            return middleware({
-                ...opts,
-                async next(nextOpts1) {
-                    const signal = nextOpts1?.signal ?? opts.signal;
-                    const result = await usedMiddleware({
-                        ...opts,
-                        context: { ...opts.context, ...nextOpts1?.context },
-                        signal,
-                        next(nextOpts2, ...args) {
-                            return opts.next({
-                                context: {
-                                    ...nextOpts1?.context,
-                                    ...nextOpts2?.context,
-                                },
-                                signal: nextOpts2?.signal ?? signal,
-                            }, ...args);
-                        },
-                    }, ...args);
-                    return {
-                        ...result,
-                        context: {
-                            ...nextOpts1?.context,
-                            ...result.context,
-                        },
-                    };
-                },
-            }, ...args);
-        });
-        merged['~orpc'] = {
-            ...decorated['~orpc'],
-            errorMap: mergeErrorMap(usedMiddleware['~orpc']?.errorMap, decorated['~orpc']?.errorMap),
-            metaPlugins: [
-                ...toArray(decorated['~orpc']?.metaPlugins),
-                ...toArray(usedMiddleware['~orpc']?.metaPlugins),
-            ],
-        };
-        Object.defineProperty(merged, 'name', {
-            value: `${decorated.name} + ${usedMiddleware.name}`,
-        });
-        return merged;
-    };
-    return decorated;
+import { mergeErrorMap } from "@orpc/contract";
+import { toArray } from "@orpc/shared";
+// src/middleware-decorated.ts
+function decorateMiddleware(middleware) {
+	const decorated = ((...args) => middleware(...args));
+	decorated["~orpc"] = middleware["~orpc"];
+	Object.defineProperty(decorated, "name", { value: middleware.name });
+	decorated.adaptInput = (adapt) => {
+		const mapped = decorateMiddleware((opts, input, ...args) => {
+			return middleware(opts, adapt(input), ...args);
+		});
+		mapped["~orpc"] = decorated["~orpc"];
+		Object.defineProperty(mapped, "name", { value: decorated.name });
+		return mapped;
+	};
+	decorated.errors = (errors) => {
+		const newMiddleware = decorateMiddleware(decorated);
+		newMiddleware["~orpc"] = {
+			...decorated["~orpc"],
+			errorMap: mergeErrorMap(decorated["~orpc"]?.errorMap, errors)
+		};
+		return newMiddleware;
+	};
+	decorated.use = (usedMiddleware) => {
+		const merged = decorateMiddleware((opts, ...args) => {
+			return middleware({
+				...opts,
+				async next(nextOpts1) {
+					const signal = nextOpts1?.signal ?? opts.signal;
+					const result = await usedMiddleware({
+						...opts,
+						context: {
+							...opts.context,
+							...nextOpts1?.context
+						},
+						signal,
+						next(nextOpts2, ...args) {
+							return opts.next({
+								context: {
+									...nextOpts1?.context,
+									...nextOpts2?.context
+								},
+								signal: nextOpts2?.signal ?? signal
+							}, ...args);
+						}
+					}, ...args);
+					return {
+						...result,
+						context: {
+							...nextOpts1?.context,
+							...result.context
+						}
+					};
+				}
+			}, ...args);
+		});
+		merged["~orpc"] = {
+			...decorated["~orpc"],
+			errorMap: mergeErrorMap(usedMiddleware["~orpc"]?.errorMap, decorated["~orpc"]?.errorMap),
+			metaPlugins: [...toArray(decorated["~orpc"]?.metaPlugins), ...toArray(usedMiddleware["~orpc"]?.metaPlugins)]
+		};
+		Object.defineProperty(merged, "name", { value: `${decorated.name} + ${usedMiddleware.name}` });
+		return merged;
+	};
+	return decorated;
 }
+export { decorateMiddleware };

package/dist/middleware.d.ts

@@ -1,54 +1,54 @@
-import type { AnyMetaPlugin, ErrorMap, ORPCErrorConstructorMap } from '@orpc/contract';
-import type { MaybeOptionalOptions, Promisable } from '@orpc/shared';
-import type { Context } from './context.ts';
-import type { AnyProcedure } from './procedure.ts';
+import { Context } from "./context.js";
+import { AnyProcedure } from "./procedure.js";
+import { AnyMetaPlugin, ErrorMap, ORPCErrorConstructorMap } from "@orpc/contract";
+import { MaybeOptionalOptions, Promisable } from "@orpc/shared";
 export type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
-    output: TOutput;
-    context: TOutContext;
+  output: TOutput;
+  context: TOutContext;
 }>;
 export type MiddlewareNextOptions<TOutContext extends Context> = (object extends TOutContext ? {
-    context?: TOutContext | undefined;
+  context?: TOutContext | undefined;
 } : {
-    context: TOutContext;
+  context: TOutContext;
 }) & {
-    /** Overrides the signal for the rest of the chain. */
-    signal?: AbortSignal | undefined;
+  /** Overrides the signal for the rest of the chain. */
+  signal?: AbortSignal | undefined;
 };
 export interface MiddlewareNext<TOutput> {
-    <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
+  <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
 }
 export type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
-    context?: TOutContext | undefined;
+  context?: TOutContext | undefined;
 } : {
-    context: TOutContext;
+  context: TOutContext;
 }) & {
-    output: TOutput;
+  output: TOutput;
 };
 export interface MiddlewareDone<TOutput> {
-    /**
-     * Create a successful result and terminate the middleware chain early.
-     */
-    <TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
+  /**
+   * Create a successful result and terminate the middleware chain early.
+   */
+  <TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
 }
 export interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
-    context: TInContext;
-    path: string[];
-    procedure: AnyProcedure;
-    signal?: AbortSignal | undefined;
-    lastEventId: string | undefined;
-    /**
-     * Invoke to continue the middleware chain.
-     */
-    next: MiddlewareNext<TOutput>;
-    errors: TErrorConstructorMap;
+  context: TInContext;
+  path: string[];
+  procedure: AnyProcedure;
+  signal?: AbortSignal | undefined;
+  lastEventId: string | undefined;
+  /**
+   * Invoke to continue the middleware chain.
+   */
+  next: MiddlewareNext<TOutput>;
+  errors: TErrorConstructorMap;
 }
 export interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
-    errorMap?: TErrorMap | undefined;
-    metaPlugins?: AnyMetaPlugin[] | undefined;
+  errorMap?: TErrorMap | undefined;
+  metaPlugins?: AnyMetaPlugin[] | undefined;
 }
 export interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> {
-    /** this property should be optional to support inline middleware */
-    '~orpc'?: MiddlewareDefinition<TErrorMap> | undefined;
-    (opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+  /** this property should be optional to support inline middleware */
+  "~orpc"?: MiddlewareDefinition<TErrorMap> | undefined;
+  (opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
 }
-export type AnyMiddleware = Middleware<any, any, any, any, any>;
+export type AnyMiddleware = Middleware<any, any, any, any, any>;

package/dist/plugins/batch.d.ts

@@ -1,7 +1,9 @@
-import type { Promisable, Value } from '@orpc/shared';
-import type { StandardHeaders, StandardLazyRequest, StandardResponse } from '@standard-server/core';
-import type { StandardHandlerOptions, StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions } from '../adapters/standard/index.ts';
-import type { Context } from '../context.ts';
+import "../adapters/standard/index.js";
+import { StandardHandlerPlugin } from "../adapters/standard/plugin.js";
+import { StandardHandlerOptions, StandardHandlerRoutingInterceptorOptions } from "../adapters/standard/handler.js";
+import { Context } from "../context.js";
+import { Promisable, Value } from "@orpc/shared";
+import { StandardHeaders, StandardLazyRequest, StandardResponse } from "@standard-server/core";
 /**
  * Content type for batch responses that use the length-prefixed binary framing,
  * which they do in `streaming` mode, or when any sub-response contains binary or is a stream.
@@ -11,64 +13,62 @@ import type { Context } from '../context.ts';
  */
 export declare const BATCH_CONTENT_TYPE = "application/vnd.orpc.batch";
 export interface BatchHandlerPluginOptions<T extends Context> {
+  /**
+   * The max size of the batch allowed. Larger batches are rejected with a `413`,
+   * so keep the client Batch Link Plugin's `maxSize` at or below it.
+   *
+   * @default DEFAULT_BATCH_MAX_SIZE (10)
+   * @see {@link https://orpc.dev/docs/plugins/batch#max-size | Batch Plugin - Max Size}
+   */
+  maxSize?: Value<Promisable<number>, [options: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
+  /**
+   * Map each subrequest in the batch before it is processed.
+   *
+   * @default merges the batch request headers into the subrequest, giving them priority over
+   * the subrequest headers, and removes the `orpc-batch` header to prevent nested batching
+   */
+  mapSubrequest?: ((subrequest: StandardLazyRequest, batchOptions: StandardHandlerRoutingInterceptorOptions<T>) => StandardLazyRequest) | undefined;
+  /**
+   * Map each sub-response in the batch before it is sent.
+   *
+   * @default removes the headers the batch response already has with the same value, which the client
+   * merges back, and `set-cookie`, which the browser ignores there and JavaScript could read
+   */
+  mapSubresponse?: ((subresponse: StandardResponse, partialBatchResponse: Pick<StandardResponse, "status" | "headers">, batchOptions: StandardHandlerRoutingInterceptorOptions<T>) => StandardResponse) | undefined;
+  /**
+   * Success batch response status code.
+   *
+   * @default 207
+   */
+  successStatus?: Value<Promisable<number>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
+  /**
+   * Success batch response headers.
+   *
+   * In `buffered` mode, the batch response also gets the cookies its sub-responses set, and the headers they all share.
+   * In `streaming` mode, it gets only the cookies of the first sub-response to be ready.
+   * Headers set here win, and setting one to `undefined` keeps it off, except `set-cookie` and `vary`, which merge.
+   *
+   * @default {}
+   */
+  headers?: Value<Promisable<StandardHeaders>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
+  /**
+   * Keep-alive frames for batch responses that stream.
+   *
+   * A zero-length length-prefixed frame is sent periodically while the stream is idle
+   * (no message sent for `interval` ms). Clients ignore these frames.
+   *
+   * `false` disables it, an object customizes it.
+   *
+   * @default true
+   */
+  keepAlive?: boolean | {
     /**
-     * The max size of the batch allowed. Larger batches are rejected with a `413`,
-     * so keep the client Batch Link Plugin's `maxSize` at or below it.
+     * Interval (in milliseconds) between keep-alive frames after the last message.
      *
-     * @default DEFAULT_BATCH_MAX_SIZE (10)
-     * @see {@link https://orpc.dev/docs/plugins/batch#max-size | Batch Plugin - Max Size}
+     * @default 15000
      */
-    maxSize?: Value<Promisable<number>, [options: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
-    /**
-     * Map each subrequest in the batch before it is processed.
-     *
-     * @default merges the batch request headers into the subrequest, giving them priority over
-     * the subrequest headers, and removes the `orpc-batch` header to prevent nested batching
-     */
-    mapSubrequest?: ((subrequest: StandardLazyRequest, batchOptions: StandardHandlerRoutingInterceptorOptions<T>) => StandardLazyRequest) | undefined;
-    /**
-     * Map each sub-response in the batch before it is sent.
-     *
-     * @default removes the headers the batch response already has with the same value, which the client
-     * merges back, and `set-cookie`, which the browser ignores there and JavaScript could read
-     */
-    mapSubresponse?: ((subresponse: StandardResponse, partialBatchResponse: Pick<StandardResponse, 'status' | 'headers'>, batchOptions: StandardHandlerRoutingInterceptorOptions<T>) => StandardResponse) | undefined;
-    /**
-     * Success batch response status code.
-     *
-     * @default 207
-     */
-    successStatus?: Value<Promisable<number>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]> | undefined;
-    /**
-     * Success batch response headers.
-     *
-     * In `buffered` mode, the batch response also gets the cookies its sub-responses set, and the headers they all share.
-     * In `streaming` mode, it gets only the cookies of the first sub-response to be ready.
-     * Headers set here win, and setting one to `undefined` keeps it off, except `set-cookie` and `vary`, which merge.
-     *
-     * @default {}
-     */
-    headers?: Value<Promisable<StandardHeaders>, [
-        batchOptions: StandardHandlerRoutingInterceptorOptions<T>
-    ]> | undefined;
-    /**
-     * Keep-alive frames for batch responses that stream.
-     *
-     * A zero-length length-prefixed frame is sent periodically while the stream is idle
-     * (no message sent for `interval` ms). Clients ignore these frames.
-     *
-     * `false` disables it, an object customizes it.
-     *
-     * @default true
-     */
-    keepAlive?: boolean | {
-        /**
-         * Interval (in milliseconds) between keep-alive frames after the last message.
-         *
-         * @default 15000
-         */
-        interval?: number | undefined;
-    } | undefined;
+    interval?: number | undefined;
+  } | undefined;
 }
 /**
  * Handles batch requests sent by the client Batch Link Plugin, splitting each
@@ -84,19 +84,19 @@ export interface BatchHandlerPluginOptions<T extends Context> {
  * @see {@link https://orpc.dev/docs/plugins/batch | Batch Plugin}
  */
 export declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    name: string;
-    /**
-     * Run batch interceptors inside the tracing interceptors
-     * so each subrequest gets its own span instead of sharing one batch-level span.
-     */
-    after: string[];
-    private readonly maxSize;
-    private readonly mapSubrequest;
-    private readonly mapSubresponse;
-    private readonly successStatus;
-    private readonly headers;
-    private readonly keepAliveEnabled;
-    private readonly keepAliveInterval;
-    constructor(options?: BatchHandlerPluginOptions<T>);
-    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
+  name: string;
+  /**
+   * Run batch interceptors inside the tracing interceptors
+   * so each subrequest gets its own span instead of sharing one batch-level span.
+   */
+  after: string[];
+  private readonly maxSize;
+  private readonly mapSubrequest;
+  private readonly mapSubresponse;
+  private readonly successStatus;
+  private readonly headers;
+  private readonly keepAliveEnabled;
+  private readonly keepAliveInterval;
+  constructor(options?: BatchHandlerPluginOptions<T>);
+  init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}