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

package/dist/builder.d.ts

@@ -0,0 +1,127 @@
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MetaPlugin, ORPCErrorConstructorMap, ProcedureContractDefinition, Schema } from '@orpc/contract';
+import type { IntersectPick } from '@orpc/shared';
+import type { BuilderWithInput, BuilderWithMiddlewares, BuilderWithOutput } from './builder-variants.ts';
+import type { Context, MergedInitialContext } from './context.ts';
+import { Lazy } from './lazy.ts';
+import type { DecoratedMiddleware } from './middleware-decorated.ts';
+import type { Middleware } from './middleware.ts';
+import { DecoratedProcedure } from './procedure-decorated.ts';
+import type { OrderedMiddleware, ProcedureConfig, ProcedureHandler } from './procedure.ts';
+import type { AugmentedRouter } from './router-utils.ts';
+import type { AnyRouter } from './router.ts';
+/**
+ * The initial context type used when `.$context` is not called.
+ * Augment this interface with `declare module '@orpc/server'` to define
+ * a default initial context type globally.
+ *
+ * @see {@link https://orpc.dev/docs/context#default-initial-context | Context - Default Initial Context}
+ */
+export interface DefaultInitialContext {
+}
+export interface BuilderDefinition<TInputSchema extends AnySchema, TInjectedContext extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TInjectedContext, TErrorMap>, ProcedureConfig {
+    orderedMiddlewares: OrderedMiddleware[];
+}
+/**
+ * The procedure builder behind `os`. Chain its methods to gradually define
+ * context, middleware, errors, schemas, and finally a handler or router.
+ *
+ * @see {@link https://orpc.dev/docs/procedure | Procedure}
+ */
+export declare class Builder<TInitialContext extends Context, TErrorMap extends ErrorMap> {
+    '~orpc': BuilderDefinition<InitialInputSchema, InitialOutputSchema, TErrorMap>;
+    /**
+     * Private constructor to prevent direct instantiation.
+     * Use the static `create` method to initialize a new instance with a safe initial definition.
+     */
+    private constructor();
+    /**
+     * Creates a fresh builder with an empty definition.
+     * Prefer the exported `os` instance over calling this directly.
+     *
+     * @see {@link https://orpc.dev/docs/procedure | Procedure}
+     */
+    static 'create'<T extends Context = DefaultInitialContext>(): Builder<T & object, Record<never, never>>;
+    /**
+     * Declares the initial context type that must be provided when executing
+     * procedures built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/context#initial-context | Context - Initial Context}
+     */
+    '$context'<T extends Context = DefaultInitialContext>(): Builder<T & object, TErrorMap>;
+    /**
+     * Overrides the procedure configuration, such as disabling runtime
+     * input/output validation.
+     *
+     * @see {@link https://orpc.dev/docs/recipes/validation-customization | Validation Customization}
+     */
+    '$config'(config: ProcedureConfig): Builder<TInitialContext, TErrorMap>;
+    /**
+     * Applies metadata plugins to procedures built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/metadata | Metadata}
+     */
+    'meta'(...plugins: MetaPlugin<InitialInputSchema, InitialOutputSchema, TErrorMap>[]): Builder<TInitialContext, TErrorMap>;
+    /**
+     * Defines typesafe errors that procedures built from this builder can throw
+     * via the `errors` utility in handlers and middleware.
+     *
+     * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
+     */
+    'errors'<U extends ErrorMap>(errors: U): Builder<TInitialContext, MergedErrorMap<TErrorMap, U>>;
+    /**
+     * Applies a middleware that runs before the handler of every procedure
+     * built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'use'<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $InContext extends Context = TInitialContext, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | TInitialContext, $OutContext, InferSchemaOutput<InitialInputSchema>, InferSchemaInput<InitialOutputSchema>, $ErrorMap>): BuilderWithMiddlewares<MergedInitialContext<TInitialContext, object, $InContext>, $OutContext, MergedErrorMap<$ErrorMap, TErrorMap>>;
+    /**
+     * Creates a standalone middleware that can be composed and applied to any
+     * compatible builder or procedure with `.use`.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'middleware'<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $Input, $Output = any>(middleware: Middleware<TInitialContext, $OutContext, $Input, $Output, TErrorMap>): DecoratedMiddleware<TInitialContext, $OutContext, $Input, $Output, TErrorMap>;
+    /**
+     * Defines the input schema used to validate and type the procedure input.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+     */
+    'input'<$ extends AnySchema>(schema: $): BuilderWithInput<TInitialContext, object, $, TErrorMap>;
+    /**
+     * Defines the output schema used to validate and type the procedure output.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+     */
+    'output'<$ extends AnySchema>(schema: $): BuilderWithOutput<TInitialContext, object, $, TErrorMap>;
+    /**
+     * Defines the function that implements the procedure and completes the
+     * chain, returning a callable procedure.
+     *
+     * @see {@link https://orpc.dev/docs/procedure | Procedure}
+     */
+    'handler'<T>(handler: ProcedureHandler<TInitialContext, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, object, InitialInputSchema, Schema<T>, TErrorMap>;
+    /**
+     * Applies the builder's middleware, errors, and metadata to every procedure
+     * in the given router.
+     *
+     * @see {@link https://orpc.dev/docs/router#extending-router | Router - Extending Router}
+     */
+    'router'<T extends AnyRouter>(router: T): AugmentedRouter<T, TErrorMap>;
+    /**
+     * Like `.router`, but loads the router lazily on first access, which helps
+     * reduce startup time for large applications.
+     *
+     * @see {@link https://orpc.dev/docs/router#lazy-router | Router - Lazy Router}
+     */
+    'lazy'<T extends AnyRouter>(loader: () => Promise<{
+        default: T;
+    }>): Lazy<AugmentedRouter<T, TErrorMap>>;
+}
+/**
+ * The oRPC procedure builder. Chain methods like `.input`, `.use`, and `.handler`
+ * to define procedures, then compose them into routers.
+ *
+ * @see {@link https://orpc.dev/docs/procedure | Procedure}
+ */
+export declare const os: Builder<DefaultInitialContext & object, Record<never, never>>;

package/dist/builder.js

@@ -0,0 +1,226 @@
+import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from '@orpc/contract';
+import { toArray } from '@orpc/shared';
+import { Lazy } from './lazy.js';
+import { decorateMiddleware } from './middleware-decorated.js';
+import { DecoratedProcedure } from './procedure-decorated.js';
+import { augmentRouter } from './router-utils.js';
+/**
+ * The procedure builder behind `os`. Chain its methods to gradually define
+ * context, middleware, errors, schemas, and finally a handler or router.
+ *
+ * @see {@link https://orpc.dev/docs/procedure | Procedure}
+ */
+export class Builder {
+    '~orpc';
+    /**
+     * Private constructor to prevent direct instantiation.
+     * Use the static `create` method to initialize a new instance with a safe initial definition.
+     */
+    constructor(definition) {
+        this['~orpc'] = definition;
+    }
+    /**
+     * Creates a fresh builder with an empty definition.
+     * Prefer the exported `os` instance over calling this directly.
+     *
+     * @see {@link https://orpc.dev/docs/procedure | Procedure}
+     */
+    static 'create'() {
+        // Using `& object` avoids "has no properties in common with type" errors
+        // when combining procedures or routers with compatible but non-overlapping contexts.
+        return new Builder({
+            errorMap: {},
+            meta: {},
+            orderedMiddlewares: [],
+        });
+    }
+    /**
+     * Declares the initial context type that must be provided when executing
+     * procedures built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/context#initial-context | Context - Initial Context}
+     */
+    '$context'() {
+        // Using `& object` avoids "has no properties in common with type" errors
+        // when combining procedures or routers with compatible but non-overlapping contexts.
+        // because we can't call $context after .use method so we don't need reset middlewares here
+        return this;
+    }
+    /**
+     * Overrides the procedure configuration, such as disabling runtime
+     * input/output validation.
+     *
+     * @see {@link https://orpc.dev/docs/recipes/validation-customization | Validation Customization}
+     */
+    '$config'(config) {
+        return new Builder({
+            ...this['~orpc'],
+            ...config,
+        });
+    }
+    /**
+     * Applies metadata plugins to procedures built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/metadata | Metadata}
+     */
+    'meta'(...plugins) {
+        const [meta, metaPlugins] = resolveMetaPlugins(this['~orpc'].meta, this['~orpc'].metaPlugins, plugins);
+        return new Builder({
+            ...this['~orpc'],
+            meta,
+            metaPlugins,
+        });
+    }
+    /**
+     * Defines typesafe errors that procedures built from this builder can throw
+     * via the `errors` utility in handlers and middleware.
+     *
+     * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
+     */
+    'errors'(errors) {
+        let builder = new Builder({
+            ...this['~orpc'],
+            errorMap: mergeErrorMap(this['~orpc'].errorMap, errors),
+        });
+        const plugins = getHiddenMetaPlugins(errors);
+        if (plugins) {
+            builder = builder.meta(...plugins);
+        }
+        return builder;
+    }
+    /**
+     * Applies a middleware that runs before the handler of every procedure
+     * built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'use'(middleware) {
+        let builder = new Builder({
+            ...this['~orpc'],
+            errorMap: mergeErrorMap(middleware['~orpc']?.errorMap ?? {}, this['~orpc'].errorMap),
+            orderedMiddlewares: [
+                ...this['~orpc'].orderedMiddlewares,
+                {
+                    middleware,
+                    inputSchemasLengthAtUse: this['~orpc'].inputSchemas?.length,
+                    outputSchemasLengthAtUse: this['~orpc'].outputSchemas?.length,
+                },
+            ],
+        });
+        if (middleware['~orpc']?.metaPlugins) {
+            builder = builder.meta(...middleware['~orpc']?.metaPlugins);
+        }
+        return builder;
+    }
+    /**
+     * Creates a standalone middleware that can be composed and applied to any
+     * compatible builder or procedure with `.use`.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'middleware'(middleware) {
+        const allMiddlewares = [
+            ...this['~orpc'].orderedMiddlewares.map(({ middleware }) => middleware),
+            middleware,
+        ];
+        let current = decorateMiddleware(allMiddlewares.shift());
+        for (const mid of allMiddlewares) {
+            current = current.use(mid);
+        }
+        current['~orpc'] = {
+            ...current['~orpc'],
+            errorMap: this['~orpc'].errorMap,
+            metaPlugins: [
+                ...toArray(this['~orpc'].metaPlugins),
+                ...toArray(middleware['~orpc']?.metaPlugins),
+            ],
+        };
+        return current;
+    }
+    /**
+     * Defines the input schema used to validate and type the procedure input.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+     */
+    'input'(schema) {
+        let builder = new Builder({
+            ...this['~orpc'],
+            inputSchemas: [...toArray(this['~orpc'].inputSchemas), schema],
+        });
+        const plugins = getHiddenMetaPlugins(schema);
+        if (plugins) {
+            builder = builder.meta(...plugins);
+        }
+        return builder;
+    }
+    /**
+     * Defines the output schema used to validate and type the procedure output.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+     */
+    'output'(schema) {
+        let builder = new Builder({
+            ...this['~orpc'],
+            outputSchemas: [...toArray(this['~orpc'].outputSchemas), schema],
+        });
+        const plugins = getHiddenMetaPlugins(schema);
+        if (plugins) {
+            builder = builder.meta(...plugins);
+        }
+        return builder;
+    }
+    /**
+     * Defines the function that implements the procedure and completes the
+     * chain, returning a callable procedure.
+     *
+     * @see {@link https://orpc.dev/docs/procedure | Procedure}
+     */
+    'handler'(handler) {
+        let procedure = new DecoratedProcedure({
+            ...this['~orpc'],
+            handler,
+        });
+        const plugins = getHiddenMetaPlugins(handler);
+        if (plugins) {
+            procedure = procedure.meta(...plugins);
+        }
+        return procedure;
+    }
+    /**
+     * Applies the builder's middleware, errors, and metadata to every procedure
+     * in the given router.
+     *
+     * @see {@link https://orpc.dev/docs/router#extending-router | Router - Extending Router}
+     */
+    'router'(router) {
+        return augmentRouter(router, {
+            ...this['~orpc'],
+            middlewares: this['~orpc'].orderedMiddlewares.map(({ middleware }) => middleware),
+        });
+    }
+    /**
+     * Like `.router`, but loads the router lazily on first access, which helps
+     * reduce startup time for large applications.
+     *
+     * @see {@link https://orpc.dev/docs/router#lazy-router | Router - Lazy Router}
+     */
+    'lazy'(loader) {
+        return new Lazy({
+            loader: async () => {
+                const { default: router } = await loader();
+                return {
+                    default: this.router(router),
+                };
+            },
+            meta: this['~orpc'].meta,
+            metaPlugins: this['~orpc'].metaPlugins,
+        });
+    }
+}
+/**
+ * The oRPC procedure builder. Chain methods like `.input`, `.use`, and `.handler`
+ * to define procedures, then compose them into routers.
+ *
+ * @see {@link https://orpc.dev/docs/procedure | Procedure}
+ */
+export const os = /* @__PURE__ */ Builder.create();

package/dist/context.d.ts

@@ -0,0 +1,6 @@
+import type { DistributiveOmit } from '@orpc/shared';
+export interface Context {
+    [key: PropertyKey]: any;
+}
+export type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = TInContext extends any ? Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & DistributiveOmit<TInContext, keyof TInitial | keyof TOutContext> : never;
+export type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : DistributiveOmit<TCurrent, keyof TOutContext> & TOutContext;

package/dist/extensions/callable.d.ts

@@ -0,0 +1,11 @@
+import type { ClientContext } from '@orpc/client';
+import type { AnySchema, ErrorMap } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { Context } from '../context.ts';
+import type { ProcedureClient, ProcedureClientOptions } from '../procedure-client.ts';
+import type { Procedure } from '../procedure.ts';
+declare module '@orpc/server' {
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+    }
+}

package/dist/extensions/callable.js

@@ -0,0 +1,7 @@
+import { createProcedureClient } from '../procedure-client.js';
+import { DecoratedProcedure } from '../procedure-decorated.js';
+DecoratedProcedure.prototype.callable = function callable(...rest) {
+    const callable = createProcedureClient(this, ...rest);
+    callable['~orpc'] = this['~orpc'];
+    return callable;
+};

package/dist/helpers/base64url.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Encodes a Uint8Array to base64url format
+ * Base64url is URL-safe and doesn't use padding
+ *
+ * @example
+ * ```ts
+ * const text = "Hello World"
+ * const encoded = encodeBase64url(new TextEncoder().encode(text))
+ * const decoded = decodeBase64url(encoded)
+ * expect(new TextDecoder().decode(decoded)).toEqual(text)
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+ */
+export declare function encodeBase64url(data: Uint8Array): string;
+/**
+ * Decodes a base64url string to Uint8Array
+ * Only accepts canonical, unpadded base64url (the form produced by `encodeBase64url`),
+ * returns undefined for anything else, including padded or standard base64 input
+ *
+ * @example
+ * ```ts
+ * const text = "Hello World"
+ * const encoded = encodeBase64url(new TextEncoder().encode(text))
+ * const decoded = decodeBase64url(encoded)
+ * expect(new TextDecoder().decode(decoded)).toEqual(text)
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+ */
+export declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;

package/dist/helpers/base64url.js

@@ -0,0 +1,53 @@
+import { encodeBase64 } from '@orpc/shared';
+/**
+ * Encodes a Uint8Array to base64url format
+ * Base64url is URL-safe and doesn't use padding
+ *
+ * @example
+ * ```ts
+ * const text = "Hello World"
+ * const encoded = encodeBase64url(new TextEncoder().encode(text))
+ * const decoded = decodeBase64url(encoded)
+ * expect(new TextDecoder().decode(decoded)).toEqual(text)
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+ */
+export function encodeBase64url(data) {
+    return encodeBase64(data).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+}
+/**
+ * Decodes a base64url string to Uint8Array
+ * Only accepts canonical, unpadded base64url (the form produced by `encodeBase64url`),
+ * returns undefined for anything else, including padded or standard base64 input
+ *
+ * @example
+ * ```ts
+ * const text = "Hello World"
+ * const encoded = encodeBase64url(new TextEncoder().encode(text))
+ * const decoded = decodeBase64url(encoded)
+ * expect(new TextDecoder().decode(decoded)).toEqual(text)
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+ */
+export function decodeBase64url(base64url) {
+    try {
+        if (typeof base64url !== 'string') {
+            return undefined;
+        }
+        let base64 = base64url.replace(/-/g, '+').replace(/_/g, '/');
+        while (base64.length % 4) {
+            base64 += '=';
+        }
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return encodeBase64url(bytes) === base64url ? bytes : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/helpers/cookie.d.ts

@@ -0,0 +1,51 @@
+import type { ParseOptions, SetCookie, StringifyOptions } from 'cookie';
+export interface SetCookieOptions extends Omit<SetCookie, 'name' | 'value'>, StringifyOptions {
+    /**
+     * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
+     *
+     * @default '/'
+     */
+    path?: string;
+}
+/**
+ * Sets a cookie in the response headers.
+ *
+ * Does nothing if `headers` is `undefined`.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers()
+ *
+ * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
+ *
+ * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
+export interface GetCookieOptions extends ParseOptions {
+}
+/**
+ * Gets a cookie value from request headers
+ *
+ * Returns `undefined` if the cookie is not found or headers are `undefined`.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers({ 'Cookie': 'sessionId=abc123; theme=dark' })
+ *
+ * const sessionId = getCookie(headers, 'sessionId')
+ *
+ * expect(sessionId).toEqual('abc123')
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export declare function getCookie(headers: Headers | undefined, name: string, options?: GetCookieOptions): string | undefined;
+/**
+ * Deletes a cookie by marking it expired.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, 'maxAge'>): void;

package/dist/helpers/cookie.js

@@ -0,0 +1,69 @@
+import { parseCookie, stringifySetCookie } from 'cookie';
+/**
+ * Sets a cookie in the response headers.
+ *
+ * Does nothing if `headers` is `undefined`.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers()
+ *
+ * setCookie(headers, 'sessionId', 'abc123', { httpOnly: true, maxAge: 3600 })
+ *
+ * expect(headers.get('Set-Cookie')).toBe('sessionId=abc123; Max-Age=3600; Path=/; HttpOnly')
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export function setCookie(headers, name, value, options = {}) {
+    if (headers === undefined) {
+        return;
+    }
+    const cookieString = stringifySetCookie({
+        // Force path to '/' by default so the cookie is available across the
+        // entire app, not just under the directory of the request that set it
+        // (which is what browsers do per RFC 6265 §5.1.4 when Path is omitted).
+        path: '/',
+        ...options,
+        name, // prioritize
+        value, // prioritize
+    }, options);
+    headers.append('Set-Cookie', cookieString);
+}
+/**
+ * Gets a cookie value from request headers
+ *
+ * Returns `undefined` if the cookie is not found or headers are `undefined`.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers({ 'Cookie': 'sessionId=abc123; theme=dark' })
+ *
+ * const sessionId = getCookie(headers, 'sessionId')
+ *
+ * expect(sessionId).toEqual('abc123')
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export function getCookie(headers, name, options = {}) {
+    if (headers === undefined) {
+        return undefined;
+    }
+    const cookieHeader = headers.get('cookie');
+    if (cookieHeader === null) {
+        return undefined;
+    }
+    return parseCookie(cookieHeader, options)[name];
+}
+/**
+ * Deletes a cookie by marking it expired.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/cookie | Cookie Helpers}
+ */
+export function deleteCookie(headers, name, options = {}) {
+    return setCookie(headers, name, '', {
+        ...options,
+        maxAge: 0, // prioritize
+    });
+}

package/dist/helpers/encryption.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Encrypts a string using AES-GCM with a secret key.
+ * The output is base64url encoded to be URL-safe.
+ *
+ * @example
+ * ```ts
+ * const encrypted = await encrypt("Hello, World!", "test-secret-key")
+ * const decrypted = await decrypt(encrypted, "test-secret-key")
+ * expect(decrypted).toBe("Hello, World!")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
+ */
+export declare function encrypt(value: string, secret: string): Promise<string>;
+/**
+ * Decrypts a base64url encoded string using AES-GCM with a secret key.
+ * Returns the original string if decryption is successful, or undefined if it fails.
+ *
+ * @example
+ * ```ts
+ * const encrypted = await encrypt("Hello, World!", "test-secret-key")
+ * const decrypted = await decrypt(encrypted, "test-secret-key")
+ * expect(decrypted).toBe("Hello, World!")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/encryption | Encryption Helpers}
+ */
+export declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;