@orpc/contract 0.0.0-next.e9dc36e → 0.0.0-next.ed15210

package/dist/src/config.d.ts

@@ -0,0 +1,11 @@
+import type { HTTPMethod, InputStructure, Route } from './route';
+export interface ContractConfig {
+    defaultMethod: HTTPMethod;
+    defaultSuccessStatus: number;
+    defaultSuccessDescription: string;
+    defaultInputStructure: InputStructure;
+    defaultOutputStructure: InputStructure;
+    defaultInitialRoute: Route;
+}
+export declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
+//# sourceMappingURL=config.d.ts.map

package/dist/src/error-map.d.ts

@@ -0,0 +1,58 @@
+import type { CommonORPCErrorCode } from './error-orpc';
+import type { Schema } from './types';
+export type ErrorMapItem<TDataSchema extends Schema> = {
+    /**
+     *
+     * @default 500
+     */
+    status?: number;
+    message?: string;
+    description?: string;
+    data?: TDataSchema;
+};
+export interface ErrorMap {
+    [k: string]: ErrorMapItem<Schema>;
+}
+/**
+ * const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions
+ *
+ * Purpose:
+ * - Helps `U` suggest `CommonORPCErrorCode` to the user when typing.
+ *
+ * Why not replace `ErrorMap` with `ErrorMapSuggestions`?
+ * - `ErrorMapSuggestions` has a drawback: it allows `undefined` values for items.
+ * - `ErrorMapGuard<TErrorMap>` uses `Partial`, which can introduce `undefined` values.
+ *
+ * This could lead to unintended behavior where `undefined` values override `TErrorMap`,
+ * potentially resulting in a `never` type after merging.
+ *
+ * Recommendation:
+ * - Use `ErrorMapSuggestions` to assist users in typing correctly but do not replace `ErrorMap`.
+ * - Ensure `ErrorMapGuard<TErrorMap>` is adjusted to prevent `undefined` values.
+ */
+export type ErrorMapSuggestions = {
+    [key in CommonORPCErrorCode | (string & {})]?: ErrorMapItem<Schema>;
+};
+/**
+ * `U` extends `ErrorMap` & `ErrorMapGuard<TErrorMap>`
+ *
+ * `ErrorMapGuard` is a utility type that ensures `U` cannot redefine the structure of `TErrorMap`.
+ * It achieves this by setting each key in `TErrorMap` to `never`, effectively preventing any redefinition.
+ *
+ * Why not just use `Partial<TErrorMap>`?
+ * - Allowing users to redefine existing error map items would require using `StrictErrorMap`.
+ * - However, I prefer not to use `StrictErrorMap` frequently, due to perceived performance concerns,
+ *   though this has not been benchmarked and is based on personal preference.
+ *
+ */
+export type ErrorMapGuard<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]?: never;
+};
+/**
+ * Since `undefined` has a specific meaning (it use default value),
+ * we ensure all additional properties in each item of the ErrorMap are explicitly set to `undefined`.
+ */
+export type StrictErrorMap<T extends ErrorMap> = {
+    [K in keyof T]: T[K] & Partial<Record<Exclude<keyof ErrorMapItem<any>, keyof T[K]>, undefined>>;
+};
+//# sourceMappingURL=error-map.d.ts.map

package/dist/src/error-orpc.d.ts

@@ -0,0 +1,109 @@
+import type { ErrorMap, ErrorMapItem } from './error-map';
+import type { SchemaOutput } from './types';
+export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema> ? ORPCError<K, SchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+export declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+export type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+export type ORPCErrorOptions<TCode extends string, TData> = ErrorOptions & {
+    defined?: boolean;
+    code: TCode;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+export declare function fallbackORPCErrorStatus(code: CommonORPCErrorCode | (string & {}), status: number | undefined): number;
+export declare function fallbackORPCErrorMessage(code: CommonORPCErrorCode | (string & {}), message: string | undefined): string;
+export declare class ORPCError<TCode extends CommonORPCErrorCode | (string & {}), TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(options: ORPCErrorOptions<TCode, TData>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<string, unknown>;
+}
+export type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+export declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+//# sourceMappingURL=error-orpc.d.ts.map

package/dist/src/error.d.ts

@@ -0,0 +1,13 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ErrorMap } from './error-map';
+import type { ORPCErrorFromErrorMap } from './error-orpc';
+export type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
+export interface ValidationErrorOptions extends ErrorOptions {
+    message: string;
+    issues: readonly StandardSchemaV1.Issue[];
+}
+export declare class ValidationError extends Error {
+    readonly issues: readonly StandardSchemaV1.Issue[];
+    constructor(options: ValidationErrorOptions);
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/src/index.d.ts

@@ -1,10 +1,23 @@
 /** unnoq */
 import { ContractBuilder } from './builder';
 export * from './builder';
-export * from './constants';
+export * from './client';
+export * from './client-utils';
+export * from './config';
+export * from './error';
+export * from './error-map';
+export * from './error-orpc';
 export * from './procedure';
+export * from './procedure-builder';
+export * from './procedure-builder-with-input';
+export * from './procedure-builder-with-output';
+export * from './procedure-client';
+export * from './procedure-decorated';
+export * from './route';
 export * from './router';
+export * from './router-builder';
+export * from './router-client';
+export * from './schema-utils';
 export * from './types';
-export * from './utils';
-export declare const oc: ContractBuilder;
+export declare const oc: ContractBuilder<{}, {}>;
 //# sourceMappingURL=index.d.ts.map

package/dist/src/procedure-builder-with-input.d.ts

@@ -0,0 +1,19 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { HTTPPath, MergeRoute, PrefixRoute, Route, UnshiftTagRoute } from './route';
+import type { Schema, SchemaOutput } from './types';
+import { ContractProcedure } from './procedure';
+import { DecoratedContractProcedure } from './procedure-decorated';
+/**
+ * `ContractProcedureBuilderWithInput` is a branch of `ContractProcedureBuilder` which it has input schema.
+ *
+ * Why?
+ * - prevents override input schema after .input
+ */
+export declare class ContractProcedureBuilderWithInput<TInputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> extends ContractProcedure<TInputSchema, undefined, TErrorMap, TRoute> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, StrictErrorMap<U> & TErrorMap, TRoute>;
+    route<const U extends Route>(route: U): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap, MergeRoute<TRoute, U>>;
+    prefix<U extends HTTPPath>(prefix: U): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap, PrefixRoute<TRoute, U>>;
+    unshiftTag<U extends string[]>(...tags: U): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap, UnshiftTagRoute<TRoute, U>>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<TInputSchema, U, TErrorMap, TRoute>;
+}
+//# sourceMappingURL=procedure-builder-with-input.d.ts.map

package/dist/src/procedure-builder-with-output.d.ts

@@ -0,0 +1,19 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { HTTPPath, MergeRoute, PrefixRoute, Route, UnshiftTagRoute } from './route';
+import type { Schema, SchemaInput } from './types';
+import { ContractProcedure } from './procedure';
+import { DecoratedContractProcedure } from './procedure-decorated';
+/**
+ * `ContractProcedureBuilderWithOutput` is a branch of `ContractProcedureBuilder` which it has output schema.
+ *
+ * Why?
+ * - prevents override output schema after .output
+ */
+export declare class ContractProcedureBuilderWithOutput<TOutputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> extends ContractProcedure<undefined, TOutputSchema, TErrorMap, TRoute> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilderWithOutput<TOutputSchema, StrictErrorMap<U> & TErrorMap, TRoute>;
+    route<const U extends Route>(route: U): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap, MergeRoute<TRoute, U>>;
+    prefix<U extends HTTPPath>(prefix: U): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap, PrefixRoute<TRoute, U>>;
+    unshiftTag<U extends string[]>(...tags: U): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap, UnshiftTagRoute<TRoute, U>>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, TOutputSchema, TErrorMap, TRoute>;
+}
+//# sourceMappingURL=procedure-builder-with-output.d.ts.map

package/dist/src/procedure-builder.d.ts

@@ -0,0 +1,15 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { HTTPPath, MergeRoute, PrefixRoute, Route, UnshiftTagRoute } from './route';
+import type { Schema, SchemaInput, SchemaOutput } from './types';
+import { ContractProcedure } from './procedure';
+import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input';
+import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output';
+export declare class ContractProcedureBuilder<TErrorMap extends ErrorMap, TRoute extends Route> extends ContractProcedure<undefined, undefined, TErrorMap, TRoute> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilder<StrictErrorMap<U> & TErrorMap, TRoute>;
+    route<const U extends Route>(route: U): ContractProcedureBuilder<TErrorMap, MergeRoute<TRoute, U>>;
+    prefix<U extends HTTPPath>(prefix: U): ContractProcedureBuilder<TErrorMap, PrefixRoute<TRoute, U>>;
+    unshiftTag<U extends string[]>(...tags: U): ContractProcedureBuilder<TErrorMap, UnshiftTagRoute<TRoute, U>>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap, TRoute>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap, TRoute>;
+}
+//# sourceMappingURL=procedure-builder.d.ts.map

package/dist/src/procedure-client.d.ts

@@ -0,0 +1,6 @@
+import type { Client } from './client';
+import type { ErrorFromErrorMap } from './error';
+import type { ErrorMap } from './error-map';
+import type { Schema, SchemaInput, SchemaOutput } from './types';
+export type ContractProcedureClient<TClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+//# sourceMappingURL=procedure-client.d.ts.map

package/dist/src/procedure-decorated.d.ts

@@ -0,0 +1,12 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { Schema } from './types';
+import { ContractProcedure } from './procedure';
+import { type HTTPPath, type MergeRoute, type PrefixRoute, type Route, type UnshiftTagRoute } from './route';
+export declare class DecoratedContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TRoute> {
+    static decorate<UInputSchema extends Schema, UOutputSchema extends Schema, UErrorMap extends ErrorMap, URoute extends Route>(procedure: ContractProcedure<UInputSchema, UOutputSchema, UErrorMap, URoute>): DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrorMap, URoute>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, StrictErrorMap<U> & TErrorMap, TRoute>;
+    route<const U extends Route>(route: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap, MergeRoute<TRoute, U>>;
+    prefix<U extends HTTPPath>(prefix: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap, PrefixRoute<TRoute, U>>;
+    unshiftTag<U extends string[]>(...tags: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap, UnshiftTagRoute<TRoute, U>>;
+}
+//# sourceMappingURL=procedure-decorated.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,46 +1,20 @@
-import type { HTTPMethod, HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
-export interface RouteOptions {
-    method?: HTTPMethod;
-    path?: HTTPPath;
-    summary?: string;
-    description?: string;
-    deprecated?: boolean;
-    tags?: string[];
+import type { ErrorMap } from './error-map';
+import type { Route } from './route';
+import type { Schema, SchemaOutput } from './types';
+export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> {
+    route: TRoute;
+    InputSchema: TInputSchema;
+    inputExample?: SchemaOutput<TInputSchema>;
+    OutputSchema: TOutputSchema;
+    outputExample?: SchemaOutput<TOutputSchema>;
+    errorMap: TErrorMap;
 }
-export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema> {
-    zz$cp: {
-        path?: HTTPPath;
-        method?: HTTPMethod;
-        summary?: string;
-        description?: string;
-        deprecated?: boolean;
-        tags?: string[];
-        InputSchema: TInputSchema;
-        inputExample?: SchemaOutput<TInputSchema>;
-        OutputSchema: TOutputSchema;
-        outputExample?: SchemaOutput<TOutputSchema>;
-    };
-    constructor(zz$cp: {
-        path?: HTTPPath;
-        method?: HTTPMethod;
-        summary?: string;
-        description?: string;
-        deprecated?: boolean;
-        tags?: string[];
-        InputSchema: TInputSchema;
-        inputExample?: SchemaOutput<TInputSchema>;
-        OutputSchema: TOutputSchema;
-        outputExample?: SchemaOutput<TOutputSchema>;
-    });
+export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> {
+    '~type': "ContractProcedure";
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TRoute>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TRoute>);
 }
-export declare class DecoratedContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema> extends ContractProcedure<TInputSchema, TOutputSchema> {
-    static decorate<TInputSchema extends Schema, TOutputSchema extends Schema>(cp: ContractProcedure<TInputSchema, TOutputSchema>): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    route(opts: RouteOptions): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    prefix(prefix: HTTPPath): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    addTags(...tags: string[]): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    input<USchema extends Schema>(schema: USchema, example?: SchemaInput<USchema>): DecoratedContractProcedure<USchema, TOutputSchema>;
-    output<USchema extends Schema>(schema: USchema, example?: SchemaOutput<USchema>): DecoratedContractProcedure<TInputSchema, USchema>;
-}
-export type WELL_DEFINED_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema>;
-export declare function isContractProcedure(item: unknown): item is WELL_DEFINED_CONTRACT_PROCEDURE;
+export type ANY_CONTRACT_PROCEDURE = ContractProcedure<any, any, any, any>;
+export type WELL_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema, ErrorMap, Route>;
+export declare function isContractProcedure(item: unknown): item is ANY_CONTRACT_PROCEDURE;
 //# sourceMappingURL=procedure.d.ts.map

package/dist/src/route.d.ts

@@ -0,0 +1,88 @@
+export type HTTPPath = `/${string}`;
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export type InputStructure = 'compact' | 'detailed';
+export type OutputStructure = 'compact' | 'detailed';
+export interface Route {
+    method?: HTTPMethod;
+    path?: HTTPPath;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    tags?: readonly string[];
+    /**
+     * The status code of the response when the procedure is successful.
+     *
+     * @default 200
+     */
+    successStatus?: number;
+    /**
+     * The description of the response when the procedure is successful.
+     *
+     * @default 'OK'
+     */
+    successDescription?: string;
+    /**
+     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
+     *
+     * @option 'compact'
+     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
+     *
+     * @option 'detailed'
+     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
+     *
+     * Example:
+     * ```ts
+     * const input = {
+     *   params: { id: 1 },
+     *   query: { search: 'hello' },
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: { name: 'John' },
+     * }
+     * ```
+     *
+     * @default 'compact'
+     */
+    inputStructure?: InputStructure;
+    /**
+     * Determines how the response should be structured based on the output.
+     *
+     * @option 'compact'
+     * Includes only the body data, encoded directly in the response.
+     *
+     * @option 'detailed'
+     * Separates the output into `headers` and `body` fields.
+     * - `headers`: Custom headers to merge with the response headers.
+     * - `body`: The response data.
+     *
+     * Example:
+     * ```ts
+     * const output = {
+     *   headers: { 'x-custom-header': 'value' },
+     *   body: { message: 'Hello, world!' },
+     * };
+     * ```
+     *
+     * @default 'compact'
+     */
+    outputStructure?: OutputStructure;
+}
+/**
+ * Since `undefined` has a specific meaning (it use default value),
+ * we ensure all additional properties in each item of the ErrorMap are explicitly set to `undefined`.
+ */
+export type StrictRoute<T extends Route> = T & Partial<Record<Exclude<keyof Route, keyof T>, undefined>>;
+export type MergeRoute<A extends Route, B extends Route> = Omit<A, keyof B> & B;
+export declare function mergeRoute<A extends Route, B extends Route>(a: A, b: B): MergeRoute<A, B>;
+export type PrefixRoute<TRoute extends Route, TPrefix extends HTTPPath> = TRoute['path'] extends HTTPPath ? Omit<TRoute, 'path'> & {
+    path: TPrefix extends HTTPPath ? `${TPrefix}${TRoute['path']}` : TRoute['path'];
+} : TRoute;
+export declare function prefixRoute<TRoute extends Route, TPrefix extends HTTPPath>(route: TRoute, prefix: TPrefix): PrefixRoute<TRoute, TPrefix>;
+export type UnshiftTagRoute<TRoute extends Route, TTags extends readonly string[]> = Omit<TRoute, 'tags'> & {
+    tags: TRoute['tags'] extends string[] ? [...TTags, ...TRoute['tags']] : TTags;
+};
+export declare function unshiftTagRoute<TRoute extends Route, TTags extends readonly string[]>(route: TRoute, tags: TTags): UnshiftTagRoute<TRoute, TTags>;
+export type MergePrefix<A extends HTTPPath | undefined, B extends HTTPPath> = A extends HTTPPath ? `${A}${B}` : B;
+export declare function mergePrefix<A extends HTTPPath | undefined, B extends HTTPPath>(a: A, b: B): MergePrefix<A, B>;
+export type MergeTags<A extends readonly string[] | undefined, B extends readonly string[]> = A extends readonly string[] ? [...A, ...B] : B;
+export declare function mergeTags<A extends readonly string[] | undefined, B extends readonly string[]>(a: A, b: B): MergeTags<A, B>;
+//# sourceMappingURL=route.d.ts.map

package/dist/src/router-builder.d.ts

@@ -1,16 +1,24 @@
-import type { ContractRouter, HandledContractRouter } from './router';
-import type { HTTPPath } from './types';
-export declare class ContractRouterBuilder {
-    zz$crb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-    };
-    constructor(zz$crb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-    });
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tags(...tags: string[]): ContractRouterBuilder;
-    router<T extends ContractRouter>(router: T): HandledContractRouter<T>;
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { ContractProcedure } from './procedure';
+import type { ContractRouter } from './router';
+import { DecoratedContractProcedure } from './procedure-decorated';
+import { type HTTPPath, type MergePrefix, type MergeTags, type PrefixRoute, type Route, type UnshiftTagRoute } from './route';
+export type AdaptRoute<TRoute extends Route, TPrefix extends HTTPPath | undefined, TTags extends readonly string[] | undefined> = TPrefix extends HTTPPath ? PrefixRoute<TTags extends readonly string[] ? UnshiftTagRoute<TRoute, TTags> : TRoute, TPrefix> : TTags extends readonly string[] ? UnshiftTagRoute<TRoute, TTags> : TRoute;
+export type AdaptedContractRouter<TContract extends ContractRouter<any>, TErrorMapExtra extends ErrorMap, TPrefix extends HTTPPath | undefined, TTags extends readonly string[] | undefined> = {
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors, infer URoute> ? DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrors & TErrorMapExtra, AdaptRoute<URoute, TPrefix, TTags>> : TContract[K] extends ContractRouter<any> ? AdaptedContractRouter<TContract[K], TErrorMapExtra, TPrefix, TTags> : never;
+};
+export interface ContractRouterBuilderDef<TErrorMap extends ErrorMap, TPrefix extends HTTPPath | undefined, TTags extends readonly string[] | undefined> {
+    errorMap: TErrorMap;
+    prefix: TPrefix;
+    tags: TTags;
+}
+export declare class ContractRouterBuilder<TErrorMap extends ErrorMap, TPrefix extends HTTPPath | undefined, TTags extends readonly string[] | undefined> {
+    '~type': "ContractProcedure";
+    '~orpc': ContractRouterBuilderDef<TErrorMap, TPrefix, TTags>;
+    constructor(def: ContractRouterBuilderDef<TErrorMap, TPrefix, TTags>);
+    prefix<U extends HTTPPath>(prefix: U): ContractRouterBuilder<TErrorMap, MergePrefix<TPrefix, U>, TTags>;
+    tag<U extends string[]>(...tags: U): ContractRouterBuilder<TErrorMap, TPrefix, MergeTags<TTags, U>>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractRouterBuilder<StrictErrorMap<U> & TErrorMap, TPrefix, TTags>;
+    router<T extends ContractRouter<ErrorMap & Partial<TErrorMap>>>(router: T): AdaptedContractRouter<T, TErrorMap, TPrefix, TTags>;
 }
 //# sourceMappingURL=router-builder.d.ts.map

package/dist/src/router-client.d.ts

@@ -0,0 +1,7 @@
+import type { ContractProcedure } from './procedure';
+import type { ContractProcedureClient } from './procedure-client';
+import type { ContractRouter } from './router';
+export type ContractRouterClient<TRouter extends ContractRouter<any>, TClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends ContractRouter<any> ? ContractRouterClient<TRouter[K], TClientContext> : never;
+};
+//# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -1,16 +1,13 @@
+import type { ErrorMap } from './error-map';
+import type { ContractProcedure } from './procedure';
 import type { SchemaInput, SchemaOutput } from './types';
-import { type ContractProcedure, type DecoratedContractProcedure, type WELL_DEFINED_CONTRACT_PROCEDURE } from './procedure';
-export interface ContractRouter {
-    [k: string]: ContractProcedure<any, any> | ContractRouter;
-}
-export type HandledContractRouter<TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? DecoratedContractProcedure<UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? HandledContractRouter<TContract[K]> : never;
+export type ContractRouter<T extends ErrorMap> = ContractProcedure<any, any, T, any> | {
+    [k: string]: ContractRouter<T>;
 };
-export declare function eachContractRouterLeaf(router: ContractRouter, callback: (item: WELL_DEFINED_CONTRACT_PROCEDURE, path: string[]) => void, prefix?: string[]): void;
-export type InferContractRouterInputs<T extends ContractRouter> = {
-    [K in keyof T]: T[K] extends ContractProcedure<infer UInputSchema, any> ? SchemaInput<UInputSchema> : T[K] extends ContractRouter ? InferContractRouterInputs<T[K]> : never;
+export type InferContractRouterInputs<T extends ContractRouter<any>> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends ContractRouter<any> ? InferContractRouterInputs<T[K]> : never;
 };
-export type InferContractRouterOutputs<T extends ContractRouter> = {
-    [K in keyof T]: T[K] extends ContractProcedure<any, infer UOutputSchema> ? SchemaOutput<UOutputSchema> : T[K] extends ContractRouter ? InferContractRouterOutputs<T[K]> : never;
+export type InferContractRouterOutputs<T extends ContractRouter<any>> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? SchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends ContractRouter<any> ? InferContractRouterOutputs<T[K]> : never;
 };
 //# sourceMappingURL=router.d.ts.map

package/dist/src/schema-utils.d.ts

@@ -0,0 +1,5 @@
+import type { IsEqual, Promisable } from '@orpc/shared';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
+export declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): StandardSchemaV1<TInput, TOutput>;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/src/types.d.ts

@@ -1,8 +1,7 @@
-import type { input, output, ZodType } from 'zod';
-export type HTTPPath = `/${string}`;
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-export type HTTPStatus = number;
-export type Schema = ZodType<any, any, any> | undefined;
-export type SchemaInput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends ZodType<any, any, any> ? input<TSchema> : TFallback;
-export type SchemaOutput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends ZodType<any, any, any> ? output<TSchema> : TFallback;
+import type { FindGlobalInstanceType } from '@orpc/shared';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export type Schema = StandardSchemaV1 | undefined;
+export type SchemaInput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : TFallback;
+export type SchemaOutput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
+export type AbortSignal = FindGlobalInstanceType<'AbortSignal'>;
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,17 +1,12 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.e9dc36e",
-  "author": {
-    "name": "unnoq",
-    "email": "contact@unnoq.com",
-    "url": "https://unnoq.com"
-  },
+  "version": "0.0.0-next.ed15210",
   "license": "MIT",
-  "homepage": "https://github.com/unnoq/orpc",
+  "homepage": "https://orpc.unnoq.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/unnoq/orpc.git",
+    "url": "git+https://github.com/unnoq/orpc.git",
     "directory": "packages/contract"
   },
   "keywords": [
@@ -29,14 +24,18 @@
     }
   },
   "files": [
-    "dist",
-    "src"
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
+    "dist"
   ],
-  "peerDependencies": {
-    "zod": ">=3.23.0"
-  },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.e9dc36e"
+    "@standard-schema/spec": "1.0.0-beta.4",
+    "@orpc/shared": "0.0.0-next.ed15210"
+  },
+  "devDependencies": {
+    "arktype": "2.0.0-rc.26",
+    "valibot": "1.0.0-beta.9",
+    "zod": "3.24.1"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/procedure.ts","../src/router-builder.ts","../src/builder.ts","../src/constants.ts","../src/router.ts","../src/utils.ts","../src/index.ts"],"sourcesContent":["import type {\n  HTTPMethod,\n  HTTPPath,\n  Schema,\n  SchemaInput,\n  SchemaOutput,\n} from './types'\n\nexport interface RouteOptions {\n  method?: HTTPMethod\n  path?: HTTPPath\n  summary?: string\n  description?: string\n  deprecated?: boolean\n  tags?: string[]\n}\n\nexport class ContractProcedure<\n  TInputSchema extends Schema,\n  TOutputSchema extends Schema,\n> {\n  constructor(\n    public zz$cp: {\n      path?: HTTPPath\n      method?: HTTPMethod\n      summary?: string\n      description?: string\n      deprecated?: boolean\n      tags?: string[]\n      InputSchema: TInputSchema\n      inputExample?: SchemaOutput<TInputSchema>\n      OutputSchema: TOutputSchema\n      outputExample?: SchemaOutput<TOutputSchema>\n    },\n  ) {}\n}\n\nexport class DecoratedContractProcedure<\n  TInputSchema extends Schema,\n  TOutputSchema extends Schema,\n> extends ContractProcedure<TInputSchema, TOutputSchema> {\n  static decorate<TInputSchema extends Schema, TOutputSchema extends Schema>(\n    cp: ContractProcedure<TInputSchema, TOutputSchema>,\n  ): DecoratedContractProcedure<TInputSchema, TOutputSchema> {\n    if (cp instanceof DecoratedContractProcedure)\n      return cp\n    return new DecoratedContractProcedure(cp.zz$cp)\n  }\n\n  route(\n    opts: RouteOptions,\n  ): DecoratedContractProcedure<TInputSchema, TOutputSchema> {\n    return new DecoratedContractProcedure({\n      ...this.zz$cp,\n      ...opts,\n      method: opts.method,\n      path: opts.path,\n    })\n  }\n\n  prefix(\n    prefix: HTTPPath,\n  ): DecoratedContractProcedure<TInputSchema, TOutputSchema> {\n    if (!this.zz$cp.path)\n      return this\n\n    return new DecoratedContractProcedure({\n      ...this.zz$cp,\n      path: `${prefix}${this.zz$cp.path}`,\n    })\n  }\n\n  addTags(\n    ...tags: string[]\n  ): DecoratedContractProcedure<TInputSchema, TOutputSchema> {\n    if (!tags.length)\n      return this\n\n    return new DecoratedContractProcedure({\n      ...this.zz$cp,\n      tags: [...(this.zz$cp.tags ?? []), ...tags],\n    })\n  }\n\n  input<USchema extends Schema>(\n    schema: USchema,\n    example?: SchemaInput<USchema>,\n  ): DecoratedContractProcedure<USchema, TOutputSchema> {\n    return new DecoratedContractProcedure({\n      ...this.zz$cp,\n      InputSchema: schema,\n      inputExample: example,\n    })\n  }\n\n  output<USchema extends Schema>(\n    schema: USchema,\n    example?: SchemaOutput<USchema>,\n  ): DecoratedContractProcedure<TInputSchema, USchema> {\n    return new DecoratedContractProcedure({\n      ...this.zz$cp,\n      OutputSchema: schema,\n      outputExample: example,\n    })\n  }\n}\n\nexport type WELL_DEFINED_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema>\n\nexport function isContractProcedure(\n  item: unknown,\n): item is WELL_DEFINED_CONTRACT_PROCEDURE {\n  if (item instanceof ContractProcedure)\n    return true\n\n  return (\n    (typeof item === 'object' || typeof item === 'function')\n    && item !== null\n    && 'zz$cp' in item\n    && typeof item.zz$cp === 'object'\n    && item.zz$cp !== null\n    && 'InputSchema' in item.zz$cp\n    && 'OutputSchema' in item.zz$cp\n  )\n}\n","import type { ContractRouter, HandledContractRouter } from './router'\nimport type { HTTPPath } from './types'\nimport { DecoratedContractProcedure, isContractProcedure } from './procedure'\n\nexport class ContractRouterBuilder {\n  constructor(public zz$crb: { prefix?: HTTPPath, tags?: string[] }) {}\n\n  prefix(prefix: HTTPPath): ContractRouterBuilder {\n    return new ContractRouterBuilder({\n      ...this.zz$crb,\n      prefix: `${this.zz$crb.prefix ?? ''}${prefix}`,\n    })\n  }\n\n  tags(...tags: string[]): ContractRouterBuilder {\n    if (!tags.length)\n      return this\n\n    return new ContractRouterBuilder({\n      ...this.zz$crb,\n      tags: [...(this.zz$crb.tags ?? []), ...tags],\n    })\n  }\n\n  router<T extends ContractRouter>(router: T): HandledContractRouter<T> {\n    const handled: ContractRouter = {}\n\n    for (const key in router) {\n      const item = router[key]\n      if (isContractProcedure(item)) {\n        const decorated = DecoratedContractProcedure.decorate(item).addTags(\n          ...(this.zz$crb.tags ?? []),\n        )\n\n        handled[key] = this.zz$crb.prefix\n          ? decorated.prefix(this.zz$crb.prefix)\n          : decorated\n      }\n      else {\n        handled[key] = this.router(item as ContractRouter)\n      }\n    }\n\n    return handled as HandledContractRouter<T>\n  }\n}\n","import type { ContractRouter } from './router'\nimport type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types'\nimport { DecoratedContractProcedure, type RouteOptions } from './procedure'\nimport { ContractRouterBuilder } from './router-builder'\n\nexport class ContractBuilder {\n  prefix(prefix: HTTPPath): ContractRouterBuilder {\n    return new ContractRouterBuilder({\n      prefix,\n    })\n  }\n\n  tags(...tags: string[]): ContractRouterBuilder {\n    return new ContractRouterBuilder({\n      tags,\n    })\n  }\n\n  route(opts: RouteOptions): DecoratedContractProcedure<undefined, undefined> {\n    return new DecoratedContractProcedure({\n      InputSchema: undefined,\n      OutputSchema: undefined,\n      ...opts,\n    })\n  }\n\n  input<USchema extends Schema>(\n    schema: USchema,\n    example?: SchemaInput<USchema>,\n  ): DecoratedContractProcedure<USchema, undefined> {\n    return new DecoratedContractProcedure({\n      InputSchema: schema,\n      inputExample: example,\n      OutputSchema: undefined,\n    })\n  }\n\n  output<USchema extends Schema>(\n    schema: USchema,\n    example?: SchemaOutput<USchema>,\n  ): DecoratedContractProcedure<undefined, USchema> {\n    return new DecoratedContractProcedure({\n      InputSchema: undefined,\n      OutputSchema: schema,\n      outputExample: example,\n    })\n  }\n\n  router<T extends ContractRouter>(router: T): T {\n    return router\n  }\n}\n","export const ORPC_HEADER = 'x-orpc-transformer'\nexport const ORPC_HEADER_VALUE = 't'\n","import type { SchemaInput, SchemaOutput } from './types'\nimport {\n  type ContractProcedure,\n  type DecoratedContractProcedure,\n  isContractProcedure,\n  type WELL_DEFINED_CONTRACT_PROCEDURE,\n} from './procedure'\n\nexport interface ContractRouter {\n  [k: string]: ContractProcedure<any, any> | ContractRouter\n}\n\nexport type HandledContractRouter<TContract extends ContractRouter> = {\n  [K in keyof TContract]: TContract[K] extends ContractProcedure<\n    infer UInputSchema,\n    infer UOutputSchema\n  >\n    ? DecoratedContractProcedure<UInputSchema, UOutputSchema>\n    : TContract[K] extends ContractRouter\n      ? HandledContractRouter<TContract[K]>\n      : never\n}\n\nexport function eachContractRouterLeaf(\n  router: ContractRouter,\n  callback: (item: WELL_DEFINED_CONTRACT_PROCEDURE, path: string[]) => void,\n  prefix: string[] = [],\n) {\n  for (const key in router) {\n    const item = router[key]\n\n    if (isContractProcedure(item)) {\n      callback(item, [...prefix, key])\n    }\n    else {\n      eachContractRouterLeaf(item as ContractRouter, callback, [...prefix, key])\n    }\n  }\n}\n\nexport type InferContractRouterInputs<T extends ContractRouter> = {\n  [K in keyof T]: T[K] extends ContractProcedure<infer UInputSchema, any>\n    ? SchemaInput<UInputSchema>\n    : T[K] extends ContractRouter\n      ? InferContractRouterInputs<T[K]>\n      : never\n}\n\nexport type InferContractRouterOutputs<T extends ContractRouter> = {\n  [K in keyof T]: T[K] extends ContractProcedure<any, infer UOutputSchema>\n    ? SchemaOutput<UOutputSchema>\n    : T[K] extends ContractRouter\n      ? InferContractRouterOutputs<T[K]>\n      : never\n}\n","import type { HTTPPath } from './types'\n\nexport function standardizeHTTPPath(path: HTTPPath): HTTPPath {\n  return `/${path.replace(/\\/{2,}/g, '/').replace(/^\\/|\\/$/g, '')}`\n}\n\nexport function prefixHTTPPath(prefix: HTTPPath, path: HTTPPath): HTTPPath {\n  const prefix_ = standardizeHTTPPath(prefix)\n  const path_ = standardizeHTTPPath(path)\n\n  if (prefix_ === '/')\n    return path_\n  if (path_ === '/')\n    return prefix_\n\n  return `${prefix_}${path_}`\n}\n","/** unnoq */\n\nimport { ContractBuilder } from './builder'\n\nexport * from './builder'\nexport * from './constants'\nexport * from './procedure'\nexport * from './router'\nexport * from './types'\nexport * from './utils'\n\nexport const oc = new ContractBuilder()\n"],"mappings":"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","names":[]}