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

package/dist/helpers/encryption.js

@@ -0,0 +1,80 @@
+import { decodeBase64url, encodeBase64url } from './base64url.js';
+const PBKDF2_CONFIG = {
+    name: 'PBKDF2',
+    /**
+     * Below the OWASP Password Storage Cheat Sheet recommendation of 600,000 iterations
+     * for PBKDF2-HMAC-SHA256. The output does not record the iteration count, so changing
+     * it would make existing ciphertexts undecryptable; raising it needs a versioned format.
+     */
+    iterations: 60_000,
+    hash: 'SHA-256',
+};
+const AES_GCM_CONFIG = {
+    name: 'AES-GCM',
+    length: 256,
+};
+const CRYPTO_CONSTANTS = {
+    SALT_LENGTH: 16,
+    IV_LENGTH: 12,
+};
+/**
+ * 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 async function encrypt(value, secret) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(value);
+    const salt = crypto.getRandomValues(new Uint8Array(CRYPTO_CONSTANTS.SALT_LENGTH));
+    const keyMaterial = await crypto.subtle.importKey('raw', encoder.encode(secret), PBKDF2_CONFIG.name, false, ['deriveKey']);
+    const key = await crypto.subtle.deriveKey({ ...PBKDF2_CONFIG, salt }, keyMaterial, AES_GCM_CONFIG, false, ['encrypt']);
+    const iv = crypto.getRandomValues(new Uint8Array(CRYPTO_CONSTANTS.IV_LENGTH));
+    const encrypted = await crypto.subtle.encrypt({ name: AES_GCM_CONFIG.name, iv }, key, data);
+    const result = new Uint8Array(salt.length + iv.length + encrypted.byteLength);
+    result.set(salt, 0);
+    result.set(iv, salt.length);
+    result.set(new Uint8Array(encrypted), salt.length + iv.length);
+    return encodeBase64url(result);
+}
+/**
+ * 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 async function decrypt(encrypted, secret) {
+    try {
+        const data = decodeBase64url(encrypted);
+        if (data === undefined) {
+            return undefined;
+        }
+        const encoder = new TextEncoder();
+        const decoder = new TextDecoder();
+        const salt = data.slice(0, CRYPTO_CONSTANTS.SALT_LENGTH);
+        const iv = data.slice(CRYPTO_CONSTANTS.SALT_LENGTH, CRYPTO_CONSTANTS.SALT_LENGTH + CRYPTO_CONSTANTS.IV_LENGTH);
+        const encryptedData = data.slice(CRYPTO_CONSTANTS.SALT_LENGTH + CRYPTO_CONSTANTS.IV_LENGTH);
+        const keyMaterial = await crypto.subtle.importKey('raw', encoder.encode(secret), PBKDF2_CONFIG.name, false, ['deriveKey']);
+        const key = await crypto.subtle.deriveKey({ ...PBKDF2_CONFIG, salt }, keyMaterial, AES_GCM_CONFIG, false, ['decrypt']);
+        const decrypted = await crypto.subtle.decrypt({ name: AES_GCM_CONFIG.name, iv }, key, encryptedData);
+        return decoder.decode(decrypted);
+    }
+    catch {
+        // Return undefined if decryption fails (invalid key, corrupted data, etc.)
+        return undefined;
+    }
+}

package/dist/helpers/index.d.ts

@@ -1,167 +1,4 @@
-import { ParseOptions, SetCookie, StringifyOptions } from 'cookie';
-
-/**
- * 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}
- */
-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}
- */
-declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
-
-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}
- */
-declare function setCookie(headers: Headers | undefined, name: string, value: string, options?: SetCookieOptions): void;
-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}
- */
-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}
- */
-declare function deleteCookie(headers: Headers | undefined, name: string, options?: Omit<SetCookieOptions, 'maxAge'>): void;
-
-/**
- * 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}
- */
-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}
- */
-declare function decrypt(encrypted: string | undefined | null, secret: string): Promise<string | undefined>;
-
-/**
- * Signs a string value using HMAC-SHA256 with a secret key.
- *
- * This function creates a cryptographic signature that can be used to verify
- * the integrity and authenticity of the data. The signature is appended to
- * the original value, separated by a dot, using base64url encoding (no padding).
- *
- * @example
- * ```ts
- * const signedValue = await sign("user123", "my-secret-key")
- * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
- */
-declare function sign(value: string, secret: string): Promise<string>;
-/**
- * Verifies and extracts the original value from a signed string.
- *
- * This function validates the signature of a previously signed value using the same
- * secret key. If the signature is valid, it returns the original value. If the
- * signature is invalid or the format is incorrect, it returns undefined.
- *
- * @example
- * ```ts
- * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
- * const originalValue = await unsign(signedValue, "my-secret-key")
- * expect(originalValue).toEqual("user123")
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
- */
-declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
-/**
- * Extracts the value part from a signed string without verification.
- *
- * This function simply extracts the original value from a signed string
- * without performing any signature verification. It's useful when you need
- * to access the value quickly without the overhead of cryptographic verification.
- *
- * @example
- * ```ts
- * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
- * const value = getSignedValue(signedValue)
- * expect(value).toEqual("user123")
- * ```
- *
- * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
- */
-declare function getSignedValue(signedValue: string | undefined | null): string | undefined;
-
-export { decodeBase64url, decrypt, deleteCookie, encodeBase64url, encrypt, getCookie, getSignedValue, setCookie, sign, unsign };
-export type { GetCookieOptions, SetCookieOptions };
+export * from './base64url.ts';
+export * from './cookie.ts';
+export * from './encryption.ts';
+export * from './signing.ts';

package/dist/helpers/index.js

@@ -0,0 +1,4 @@
+export * from './base64url.js';
+export * from './cookie.js';
+export * from './encryption.js';
+export * from './signing.js';

package/dist/helpers/signing.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Signs a string value using HMAC-SHA256 with a secret key.
+ *
+ * This function creates a cryptographic signature that can be used to verify
+ * the integrity and authenticity of the data. The signature is appended to
+ * the original value, separated by a dot, using base64url encoding (no padding).
+ *
+ * @example
+ * ```ts
+ * const signedValue = await sign("user123", "my-secret-key")
+ * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export declare function sign(value: string, secret: string): Promise<string>;
+/**
+ * Verifies and extracts the original value from a signed string.
+ *
+ * This function validates the signature of a previously signed value using the same
+ * secret key. If the signature is valid, it returns the original value. If the
+ * signature is invalid or the format is incorrect, it returns undefined.
+ *
+ * @example
+ * ```ts
+ * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+ * const originalValue = await unsign(signedValue, "my-secret-key")
+ * expect(originalValue).toEqual("user123")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export declare function unsign(signedValue: string | undefined | null, secret: string): Promise<string | undefined>;
+/**
+ * Extracts the value part from a signed string without verification.
+ *
+ * This function simply extracts the original value from a signed string
+ * without performing any signature verification. It's useful when you need
+ * to access the value quickly without the overhead of cryptographic verification.
+ *
+ * @example
+ * ```ts
+ * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+ * const value = getSignedValue(signedValue)
+ * expect(value).toEqual("user123")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export declare function getSignedValue(signedValue: string | undefined | null): string | undefined;

package/dist/helpers/signing.js

@@ -0,0 +1,88 @@
+import { decodeBase64url, encodeBase64url } from './base64url.js';
+const ALGORITHM = { name: 'HMAC', hash: 'SHA-256' };
+/**
+ * Signs a string value using HMAC-SHA256 with a secret key.
+ *
+ * This function creates a cryptographic signature that can be used to verify
+ * the integrity and authenticity of the data. The signature is appended to
+ * the original value, separated by a dot, using base64url encoding (no padding).
+ *
+ * @example
+ * ```ts
+ * const signedValue = await sign("user123", "my-secret-key")
+ * expect(signedValue).toEqual("user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export async function sign(value, secret) {
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey('raw', encoder.encode(secret), ALGORITHM, false, [
+        'sign',
+    ]);
+    const signature = await crypto.subtle.sign(ALGORITHM, key, encoder.encode(value));
+    return `${value}.${encodeBase64url(new Uint8Array(signature))}`;
+}
+/**
+ * Verifies and extracts the original value from a signed string.
+ *
+ * This function validates the signature of a previously signed value using the same
+ * secret key. If the signature is valid, it returns the original value. If the
+ * signature is invalid or the format is incorrect, it returns undefined.
+ *
+ * @example
+ * ```ts
+ * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+ * const originalValue = await unsign(signedValue, "my-secret-key")
+ * expect(originalValue).toEqual("user123")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export async function unsign(signedValue, secret) {
+    if (typeof signedValue !== 'string') {
+        return undefined;
+    }
+    const lastDotIndex = signedValue.lastIndexOf('.');
+    if (lastDotIndex === -1) {
+        return undefined;
+    }
+    const value = signedValue.slice(0, lastDotIndex);
+    const signatureBase64url = signedValue.slice(lastDotIndex + 1);
+    const signature = decodeBase64url(signatureBase64url);
+    if (signature === undefined) {
+        return undefined;
+    }
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey('raw', encoder.encode(secret), ALGORITHM, false, [
+        'verify',
+    ]);
+    const isValid = await crypto.subtle.verify(ALGORITHM, key, signature, encoder.encode(value));
+    return isValid ? value : undefined;
+}
+/**
+ * Extracts the value part from a signed string without verification.
+ *
+ * This function simply extracts the original value from a signed string
+ * without performing any signature verification. It's useful when you need
+ * to access the value quickly without the overhead of cryptographic verification.
+ *
+ * @example
+ * ```ts
+ * const signedValue = "user123.oneQsU0r5dvwQFHFEjjV1uOI_IR3gZfkYHij3TRauVA"
+ * const value = getSignedValue(signedValue)
+ * expect(value).toEqual("user123")
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/helpers/signing | Signing Helpers}
+ */
+export function getSignedValue(signedValue) {
+    if (typeof signedValue !== 'string') {
+        return undefined;
+    }
+    const lastDotIndex = signedValue.lastIndexOf('.');
+    if (lastDotIndex === -1) {
+        return undefined;
+    }
+    return signedValue.slice(0, lastDotIndex);
+}

package/dist/implementer-procedure.d.ts

@@ -0,0 +1,16 @@
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { IntersectPick } from '@orpc/shared';
+import type { BuilderDefinition } from './builder.ts';
+import type { Context, MergedContext, MergedInitialContext } from './context.ts';
+import type { Middleware } from './middleware.ts';
+import type { ProcedureHandler } from './procedure.ts';
+import { Procedure } from './procedure.ts';
+export declare class ProcedureImplementer<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>;
+    constructor(definition: BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>);
+    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): ProcedureImplementer<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
+    'handler'(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>): ImplementedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+}
+export declare class ImplementedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> {
+    use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): ImplementedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
+}

package/dist/implementer-procedure.js

@@ -0,0 +1,44 @@
+import { Procedure } from './procedure.js';
+export class ProcedureImplementer {
+    '~orpc';
+    constructor(definition) {
+        this['~orpc'] = definition;
+    }
+    'use'(middleware) {
+        return new ProcedureImplementer({
+            ...this['~orpc'],
+            orderedMiddlewares: [
+                ...this['~orpc'].orderedMiddlewares,
+                {
+                    middleware,
+                    inputSchemasLengthAtUse: this['~orpc'].inputSchemas?.length,
+                    outputSchemasLengthAtUse: this['~orpc'].outputSchemas?.length,
+                },
+            ],
+        });
+    }
+    'handler'(handler) {
+        return new ImplementedProcedure({
+            ...this['~orpc'],
+            handler,
+        });
+    }
+}
+export class ImplementedProcedure extends Procedure {
+    use(middleware) {
+        // Since middleware executes before the handler, we use `IntersectPick` to ensure
+        // that the middleware's output context ($OutContext) is compatible with the
+        // context requirements of the handler, which may have already been defined.
+        return new ImplementedProcedure({
+            ...this['~orpc'],
+            orderedMiddlewares: [
+                ...this['~orpc'].orderedMiddlewares,
+                {
+                    middleware,
+                    inputSchemasLengthAtUse: this['~orpc'].inputSchemas?.length,
+                    outputSchemasLengthAtUse: this['~orpc'].outputSchemas?.length,
+                },
+            ],
+        });
+    }
+}

package/dist/implementer-router.d.ts

@@ -0,0 +1,40 @@
+import type { ErrorMap, InferRouterContractErrorMap, RouterContract } from '@orpc/contract';
+import { ProcedureContract } from '@orpc/contract';
+import type { IntersectPick, Public } from '@orpc/shared';
+import type { Context, MergedContext, MergedInitialContext } from './context.ts';
+import { ProcedureImplementer } from './implementer-procedure.ts';
+import { Lazy } from './lazy.ts';
+import type { DecoratedMiddleware } from './middleware-decorated.ts';
+import type { AnyMiddleware, Middleware } from './middleware.ts';
+import type { ProcedureConfig } from './procedure.ts';
+import type { AugmentedRouterWithMiddlewares } from './router-utils.ts';
+import type { ContractedRouter } from './router.ts';
+export declare class SharedRouterImplementer<TContract extends RouterContract, TInitialContext extends Context> {
+    private readonly contract;
+    private readonly config;
+    private readonly middlewares;
+    private constructor();
+    static create<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract, config: ProcedureConfig): SharedRouterImplementer<TContract, TInitialContext>;
+    static create<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context>(contract: TContract, config: ProcedureConfig, middlewares: AnyMiddleware[]): SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext>;
+    use<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $InContext extends Context = TInitialContext, $ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>>(middleware: Middleware<$InContext | TInitialContext, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, object, $InContext>, $OutContext>;
+    middleware<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $Input, $InContext extends Context = TInitialContext, $Output = any>(middleware: Middleware<$InContext | TInitialContext, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, object, $InContext>, $OutContext, $Input, $Output, object>;
+    router<T extends ContractedRouter<TContract, any>>(router: T): T;
+    lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
+        default: T;
+    }>): Lazy<T>;
+}
+export interface SharedRouterImplementerWithMiddlewares<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context> {
+    use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>>;
+    middleware<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $Input, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $Output = any>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, $Input, $Output, object>;
+    router<T extends ContractedRouter<TContract, MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>;
+    lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
+        default: T;
+    }>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>>;
+}
+export type RouterImplementer<TContract extends RouterContract, TInitialContext extends Context> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, object, $InputSchema, $OutputSchema, $ErrorMap> : Public<SharedRouterImplementer<TContract, TInitialContext>> & {
+    [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementer<TContract[K], TInitialContext> : never;
+};
+export type RouterImplementerWithMiddlewares<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, TInjectedContext, $InputSchema, $OutputSchema, $ErrorMap> : SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext> & {
+    [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementerWithMiddlewares<TContract[K], TInitialContext, TInjectedContext> : never;
+};
+export declare function createRouterImplementer<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract, config: ProcedureConfig): RouterImplementer<TContract, TInitialContext>;

package/dist/implementer-router.js

@@ -0,0 +1,117 @@
+import { ProcedureContract } from '@orpc/contract';
+import { bindMethods, omit, setOwn } from '@orpc/shared';
+import { ProcedureImplementer } from './implementer-procedure.js';
+import { Lazy } from './lazy.js';
+import { decorateMiddleware } from './middleware-decorated.js';
+import { Procedure } from './procedure.js';
+import { withHiddenRouterContract } from './router-hidden.js';
+import { augmentImplementedRouter } from './router-utils.js';
+export class SharedRouterImplementer {
+    contract;
+    config;
+    middlewares;
+    constructor(contract, config, middlewares) {
+        this.contract = contract;
+        this.config = config;
+        this.middlewares = middlewares;
+    }
+    static create(contract, config, middlewares = []) {
+        return new SharedRouterImplementer(contract, config, middlewares);
+    }
+    use(middleware) {
+        return createRouterImplementerInternal(this.contract, this.config, [
+            ...this.middlewares,
+            middleware,
+        ]);
+    }
+    middleware(middleware) {
+        const allMiddlewares = [...this.middlewares, middleware];
+        let current = decorateMiddleware(allMiddlewares.shift());
+        for (const mid of allMiddlewares) {
+            current = current.use(mid);
+        }
+        return current;
+    }
+    router(router) {
+        if (this.middlewares.length) {
+            router = augmentImplementedRouter(router, {
+                ...this.config,
+                middlewares: this.middlewares,
+            });
+        }
+        return withHiddenRouterContract(router, this.contract);
+    }
+    lazy(loader) {
+        return new Lazy({
+            loader: async () => {
+                const { default: router } = await loader();
+                return { default: this.router(router) };
+            },
+            meta: {},
+        });
+    }
+}
+export function createRouterImplementer(contract, config) {
+    return createRouterImplementerInternal(toPlainRouterContract(contract), config, []);
+}
+/**
+ * A normal router can be used as a contract (e.g. for mocking), but its procedures carry a handler,
+ * middlewares and config. Kept as is, unimplemented procedures would pass as procedures, their config
+ * would override the config passed to `implement`, and handlers serving the hidden contract would run
+ * the contract's procedures instead of the actual implementation.
+ *
+ * Rebuilds the contract with every procedure turned into a plain {@link ProcedureContract}
+ * (without `handler`, `orderedMiddlewares` and procedure config), copying only the routers that contain one,
+ * so contract-first contracts are returned as is.
+ */
+function toPlainRouterContract(contract) {
+    if (contract instanceof ProcedureContract) {
+        if (!(contract instanceof Procedure)) {
+            return contract;
+        }
+        // handler & orderedMiddlewares are what make a definition a procedure (see Procedure[Symbol.hasInstance])
+        return new ProcedureContract(omit(contract['~orpc'], [
+            'handler',
+            'orderedMiddlewares',
+            'disableInputValidation',
+            'disableOutputValidation',
+        ]));
+    }
+    let copied;
+    for (const [key, child] of Object.entries(contract)) {
+        const plainChild = toPlainRouterContract(child);
+        if (plainChild !== child) {
+            copied ??= { ...contract };
+            copied[key] = plainChild;
+        }
+    }
+    return (copied ?? contract);
+}
+function createRouterImplementerInternal(contract, config, middlewares) {
+    if (contract instanceof ProcedureContract) {
+        return new ProcedureImplementer({
+            ...config,
+            ...contract['~orpc'],
+            orderedMiddlewares: middlewares.map((middleware) => ({ middleware })),
+        });
+    }
+    const implementer = {};
+    for (const [key, child] of Object.entries(contract)) {
+        setOwn(implementer, key, createRouterImplementerInternal(child, config, middlewares));
+    }
+    const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
+    for (const [key, method] of Object.entries(shared)) {
+        if (Object.hasOwn(implementer, key)) {
+            const child = implementer[key];
+            implementer[key] = new Proxy(method, {
+                get(_, p) {
+                    return Reflect.get(child, p);
+                },
+            });
+        }
+        else {
+            implementer[key] = method;
+        }
+    }
+    return implementer;
+}

package/dist/implementer.d.ts

@@ -0,0 +1,16 @@
+import type { RouterContract } from '@orpc/contract';
+import type { DefaultInitialContext } from './builder.ts';
+import type { Context } from './context.ts';
+import type { RouterImplementer } from './implementer-router.ts';
+import type { ProcedureConfig } from './procedure.ts';
+export type Implementer<TContract extends RouterContract, TInitialContext extends Context> = {
+    $context<T extends Context = DefaultInitialContext>(): Implementer<TContract, T & object>;
+    $config(config: ProcedureConfig): Implementer<TContract, TInitialContext>;
+} & RouterImplementer<TContract, TInitialContext>;
+/**
+ * Turns a contract into an implementer, used to implement the contract's
+ * procedures, routers, and middleware with full type safety.
+ *
+ * @see {@link https://orpc.dev/docs/contract/implementation#implementer | Contract Implementation - Implementer}
+ */
+export declare function implement<TContract extends RouterContract, TInitialContext extends Context = DefaultInitialContext>(contract: TContract, config?: ProcedureConfig): Implementer<TContract, TInitialContext & object>;