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

package/dist/lazy.d.ts

@@ -0,0 +1,20 @@
+import type { AnyMetaPlugin, Meta } from '@orpc/contract';
+export interface LazyDefinition<T> {
+    meta: Meta;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+    loader: () => Promise<{
+        default: T;
+    }>;
+}
+export declare class Lazy<T> {
+    '~orpc': LazyDefinition<T>;
+    constructor(def: LazyDefinition<T>);
+    /**
+     * Checks if the given instance satisfies the {@link Lazy} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+export type Lazyable<T> = T | Lazy<T>;
+export declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;

package/dist/lazy.js

@@ -0,0 +1,31 @@
+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 });
+}

package/dist/middleware-decorated.d.ts

@@ -0,0 +1,10 @@
+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';
+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>;

package/dist/middleware-decorated.js

@@ -0,0 +1,71 @@
+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;
+}

package/dist/middleware.d.ts

@@ -0,0 +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';
+export type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+export type MiddlewareNextOptions<TOutContext extends Context> = (object extends TOutContext ? {
+    context?: TOutContext | undefined;
+} : {
+    context: TOutContext;
+}) & {
+    /** 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>;
+}
+export type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
+    context?: TOutContext | undefined;
+} : {
+    context: TOutContext;
+}) & {
+    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>;
+}
+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;
+}
+export interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
+    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>>;
+}
+export type AnyMiddleware = Middleware<any, any, any, any, any>;

package/dist/middleware.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/batch.d.ts

@@ -0,0 +1,102 @@
+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';
+/**
+ * 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.
+ *
+ * Decoding is driven by the `standard-server` body hint, not this header,
+ * so it only serves to describe the payload to logs, proxies, and dev tools.
+ */
+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 | {
+        /**
+         * Interval (in milliseconds) between keep-alive frames after the last message.
+         *
+         * @default 15000
+         */
+        interval?: number | undefined;
+    } | undefined;
+}
+/**
+ * Handles batch requests sent by the client Batch Link Plugin, splitting each
+ * batch into sub-requests and sending their responses back together.
+ *
+ * @remarks
+ * The client Batch Link Plugin's `mode` picks how each batch responds: `buffered` (default) waits for every
+ * sub-response and carries their cookies and shared headers; `streaming` starts once the first is ready and
+ * carries only its cookies.
+ *
+ * **Note**: HTTP/2 and later already multiplex requests over a single connection, which often makes this plugin unnecessary.
+ *
+ * @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>;
+}