@orpc/contract 0.29.0 → 0.30.0

package/dist/index.js

@@ -73,10 +73,13 @@ var DecoratedContractProcedure = class _DecoratedContractProcedure extends Contr
       outputExample: example
     });
   }
-  errors(errorMap) {
+  errors(errors) {
     return new _DecoratedContractProcedure({
       ...this["~orpc"],
-      errorMap
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
     });
   }
 };
@@ -100,6 +103,15 @@ var ContractRouterBuilder = class _ContractRouterBuilder {
       tags: [...this["~orpc"].tags ?? [], ...tags]
     });
   }
+  errors(errors) {
+    return new _ContractRouterBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   router(router) {
     if (isContractProcedure(router)) {
       let decorated = DecoratedContractProcedure.decorate(router);
@@ -109,6 +121,7 @@ var ContractRouterBuilder = class _ContractRouterBuilder {
       if (this["~orpc"].prefix) {
         decorated = decorated.prefix(this["~orpc"].prefix);
       }
+      decorated = decorated.errors(this["~orpc"].errorMap);
       return decorated;
     }
     const adapted = {};
@@ -120,15 +133,31 @@ var ContractRouterBuilder = class _ContractRouterBuilder {
 };
 
 // src/builder.ts
-var ContractBuilder = class {
+var ContractBuilder = class _ContractBuilder {
+  "~type" = "ContractBuilder";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  errors(errors) {
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   prefix(prefix) {
     return new ContractRouterBuilder({
-      prefix
+      prefix,
+      errorMap: this["~orpc"].errorMap
     });
   }
   tag(...tags) {
     return new ContractRouterBuilder({
-      tags
+      tags,
+      errorMap: this["~orpc"].errorMap
     });
   }
   route(route) {
@@ -136,7 +165,7 @@ var ContractBuilder = class {
       route,
       InputSchema: void 0,
       OutputSchema: void 0,
-      errorMap: void 0
+      errorMap: this["~orpc"].errorMap
     });
   }
   input(schema, example) {
@@ -144,7 +173,7 @@ var ContractBuilder = class {
       InputSchema: schema,
       inputExample: example,
       OutputSchema: void 0,
-      errorMap: void 0
+      errorMap: this["~orpc"].errorMap
     });
   }
   output(schema, example) {
@@ -152,18 +181,13 @@ var ContractBuilder = class {
       OutputSchema: schema,
       outputExample: example,
       InputSchema: void 0,
-      errorMap: void 0
-    });
-  }
-  errors(errorMap) {
-    return new DecoratedContractProcedure({
-      InputSchema: void 0,
-      OutputSchema: void 0,
-      errorMap
+      errorMap: this["~orpc"].errorMap
     });
   }
   router(router) {
-    return router;
+    return new ContractRouterBuilder({
+      errorMap: this["~orpc"].errorMap
+    }).router(router);
   }
 };
 
@@ -358,7 +382,9 @@ var ValidationError = class extends Error {
 };
 
 // src/index.ts
-var oc = new ContractBuilder();
+var oc = new ContractBuilder({
+  errorMap: {}
+});
 export {
   COMMON_ORPC_ERROR_DEFS,
   ContractBuilder,

package/dist/src/builder.d.ts

@@ -1,16 +1,23 @@
-import type { ErrorMap } from './error-map';
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
 import type { RouteOptions } from './procedure';
 import type { ContractRouter } from './router';
+import type { AdaptedContractRouter } from './router-builder';
 import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
 import { DecoratedContractProcedure } from './procedure-decorated';
 import { ContractRouterBuilder } from './router-builder';
-export declare class ContractBuilder {
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tag(...tags: string[]): ContractRouterBuilder;
-    route(route: RouteOptions): DecoratedContractProcedure<undefined, undefined, undefined>;
-    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, undefined, undefined>;
-    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<undefined, U, undefined>;
-    errors<const U extends ErrorMap>(errorMap: U): DecoratedContractProcedure<undefined, undefined, U>;
-    router<T extends ContractRouter>(router: T): T;
+export type ContractBuilderDef<TErrorMap extends ErrorMap> = {
+    errorMap: TErrorMap;
+};
+export declare class ContractBuilder<TErrorMap extends ErrorMap> {
+    '~type': "ContractBuilder";
+    '~orpc': ContractBuilderDef<TErrorMap>;
+    constructor(def: ContractBuilderDef<TErrorMap>);
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractBuilder<U & TErrorMap>;
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap>;
+    route(route: RouteOptions): DecoratedContractProcedure<undefined, undefined, TErrorMap>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, undefined, TErrorMap>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<undefined, U, TErrorMap>;
+    router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap>;
 }
 //# sourceMappingURL=builder.d.ts.map

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

@@ -3,14 +3,56 @@ import type { Schema } from './types';
 export type ErrorMapItem<TDataSchema extends Schema> = {
     /**
      *
-     * @default 200
+     * @default 500
      */
     status?: number;
     message?: string;
     description?: string;
     data?: TDataSchema;
 };
-export type ErrorMap = undefined | {
+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/index.d.ts

@@ -14,5 +14,5 @@ export * from './router';
 export * from './router-builder';
 export * from './router-client';
 export * from './types';
-export declare const oc: ContractBuilder;
+export declare const oc: ContractBuilder<Record<never, never>>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { ErrorMap } from './error-map';
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions } from './error-map';
 import type { RouteOptions } from './procedure';
 import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
 import { ContractProcedure } from './procedure';
@@ -9,6 +9,6 @@ export declare class DecoratedContractProcedure<TInputSchema extends Schema, TOu
     unshiftTag(...tags: string[]): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
     input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, TOutputSchema, TErrorMap>;
     output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<TInputSchema, U, TErrorMap>;
-    errors<const U extends ErrorMap>(errorMap: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, U>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap & U>;
 }
 //# sourceMappingURL=procedure-decorated.d.ts.map

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

@@ -1,20 +1,23 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
 import type { ContractProcedure } from './procedure';
 import type { ContractRouter } from './router';
 import type { HTTPPath } from './types';
 import { DecoratedContractProcedure } from './procedure-decorated';
-export type AdaptedContractRouter<TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors> ? DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrors> : TContract[K] extends ContractRouter ? AdaptedContractRouter<TContract[K]> : never;
+export type AdaptedContractRouter<TContract extends ContractRouter<any>, TErrorMapExtra extends ErrorMap> = {
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors> ? DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrors & TErrorMapExtra> : TContract[K] extends ContractRouter<any> ? AdaptedContractRouter<TContract[K], TErrorMapExtra> : never;
 };
-export interface ContractRouterBuilderDef {
+export interface ContractRouterBuilderDef<TErrorMap extends ErrorMap> {
     prefix?: HTTPPath;
     tags?: string[];
+    errorMap: TErrorMap;
 }
-export declare class ContractRouterBuilder {
+export declare class ContractRouterBuilder<TErrorMap extends ErrorMap> {
     '~type': "ContractProcedure";
-    '~orpc': ContractRouterBuilderDef;
-    constructor(def: ContractRouterBuilderDef);
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tag(...tags: string[]): ContractRouterBuilder;
-    router<T extends ContractRouter>(router: T): AdaptedContractRouter<T>;
+    '~orpc': ContractRouterBuilderDef<TErrorMap>;
+    constructor(def: ContractRouterBuilderDef<TErrorMap>);
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractRouterBuilder<U & TErrorMap>;
+    router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap>;
 }
 //# sourceMappingURL=router-builder.d.ts.map

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

@@ -1,7 +1,7 @@
 import type { ContractProcedure } from './procedure';
 import type { ContractProcedureClient } from './procedure-client';
 import type { ContractRouter } from './router';
-export type ContractRouterClient<TRouter extends ContractRouter, TClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
-    [K in keyof TRouter]: TRouter[K] extends ContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
+export type ContractRouterClient<TRouter extends ContractRouter<any>, TClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> ? 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,12 +1,13 @@
-import type { ANY_CONTRACT_PROCEDURE, ContractProcedure } from './procedure';
+import type { ErrorMap } from './error-map';
+import type { ContractProcedure } from './procedure';
 import type { SchemaInput, SchemaOutput } from './types';
-export type ContractRouter = ANY_CONTRACT_PROCEDURE | {
-    [k: string]: ContractRouter;
+export type ContractRouter<T extends ErrorMap> = ContractProcedure<any, any, T> | {
+    [k: string]: ContractRouter<T>;
 };
-export type InferContractRouterInputs<T extends ContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any> ? SchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends ContractRouter ? InferContractRouterInputs<T[K]> : never;
+export type InferContractRouterInputs<T extends ContractRouter<any>> = T extends ContractProcedure<infer UInputSchema, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends ContractRouter<any> ? InferContractRouterInputs<T[K]> : never;
 };
-export type InferContractRouterOutputs<T extends ContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any> ? SchemaOutput<UOutputSchema> : {
-    [K in keyof T]: T[K] extends ContractRouter ? InferContractRouterOutputs<T[K]> : never;
+export type InferContractRouterOutputs<T extends ContractRouter<any>> = T extends ContractProcedure<any, infer UOutputSchema, any> ? SchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends ContractRouter<any> ? InferContractRouterOutputs<T[K]> : never;
 };
 //# sourceMappingURL=router.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -30,7 +30,7 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "1.0.0-beta.4",
-    "@orpc/shared": "0.29.0"
+    "@orpc/shared": "0.30.0"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",