@orpc/contract - npm Package Compare versions

Comparing version 0.0.0-next.4a31e17 to 0.0.0-next.4e27480

dist/index.js

@@ -9,2 +9,5 @@ // src/procedure.ts
     }
+    if (Object.values(def.errorMap ?? {}).some((val) => val && val.status && (val.status < 400 || val.status > 599))) {
+      throw new Error("[ContractProcedure] The error status code must be in the 400-599 range.");
+    }
     this["~orpc"] = def;
@@ -17,3 +20,3 @@ }
   }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "ContractProcedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "InputSchema" in item["~orpc"] && "OutputSchema" in item["~orpc"];
+  return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "ContractProcedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "InputSchema" in item["~orpc"] && "OutputSchema" in item["~orpc"] && "errorMap" in item["~orpc"];
 }
@@ -29,2 +32,11 @@
   }
+  errors(errors) {
+    return new _DecoratedContractProcedure({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   route(route) {
@@ -62,4 +74,51 @@ return new _DecoratedContractProcedure({
   }
+};
+
+// src/procedure-builder-with-input.ts
+var ContractProcedureBuilderWithInput = class _ContractProcedureBuilderWithInput extends ContractProcedure {
+  errors(errors) {
+    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
+    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  }
+  route(route) {
+    const decorated = DecoratedContractProcedure.decorate(this).route(route);
+    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  }
+  prefix(prefix) {
+    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
+    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  }
+  unshiftTag(...tags) {
+    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
+    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  }
+  output(schema, example) {
+    return new DecoratedContractProcedure({
+      ...this["~orpc"],
+      OutputSchema: schema,
+      outputExample: example
+    });
+  }
+};
+
+// src/procedure-builder-with-output.ts
+var ContractProcedureBuilderWithOutput = class _ContractProcedureBuilderWithOutput extends ContractProcedure {
+  errors(errors) {
+    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
+    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
+  }
+  route(route) {
+    const decorated = DecoratedContractProcedure.decorate(this).route(route);
+    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
+  }
+  prefix(prefix) {
+    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
+    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
+  }
+  unshiftTag(...tags) {
+    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
+    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
+  }
   input(schema, example) {
-    return new _DecoratedContractProcedure({
+    return new DecoratedContractProcedure({
       ...this["~orpc"],
@@ -70,4 +129,31 @@ InputSchema: schema,
   }
+};
+
+// src/procedure-builder.ts
+var ContractProcedureBuilder = class _ContractProcedureBuilder extends ContractProcedure {
+  errors(errors) {
+    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
+    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  }
+  route(route) {
+    const decorated = DecoratedContractProcedure.decorate(this).route(route);
+    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  }
+  prefix(prefix) {
+    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
+    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  }
+  unshiftTag(...tags) {
+    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
+    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  }
+  input(schema, example) {
+    return new ContractProcedureBuilderWithInput({
+      ...this["~orpc"],
+      InputSchema: schema,
+      inputExample: example
+    });
+  }
   output(schema, example) {
-    return new _DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithOutput({
       ...this["~orpc"],
@@ -99,2 +185,11 @@ OutputSchema: schema,
   }
+  errors(errors) {
+    return new _ContractRouterBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   router(router) {
@@ -109,2 +204,3 @@ if (isContractProcedure(router)) {
       }
+      decorated = decorated.errors(this["~orpc"].errorMap);
       return decorated;
@@ -121,39 +217,227 @@ }
 // src/builder.ts
-var ContractBuilder = class {
-  prefix(prefix) {
-    return new ContractRouterBuilder({
-      prefix
+var ContractBuilder = class _ContractBuilder extends ContractProcedure {
+  constructor(def) {
+    super(def);
+  }
+  config(config) {
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      config: {
+        ...this["~orpc"].config,
+        ...config
+      }
     });
   }
-  tag(...tags) {
-    return new ContractRouterBuilder({
-      tags
+  errors(errors) {
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
     });
   }
   route(route) {
-    return new DecoratedContractProcedure({
-      route,
+    return new ContractProcedureBuilder({
+      route: {
+        ...this["~orpc"].config.initialRoute,
+        ...route
+      },
       InputSchema: void 0,
-      OutputSchema: void 0
+      OutputSchema: void 0,
+      errorMap: this["~orpc"].errorMap
     });
   }
   input(schema, example) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithInput({
+      route: this["~orpc"].config.initialRoute,
       InputSchema: schema,
       inputExample: example,
-      OutputSchema: void 0
+      OutputSchema: void 0,
+      errorMap: this["~orpc"].errorMap
     });
   }
   output(schema, example) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithOutput({
+      route: this["~orpc"].config.initialRoute,
       OutputSchema: schema,
       outputExample: example,
-      InputSchema: void 0
+      InputSchema: void 0,
+      errorMap: this["~orpc"].errorMap
     });
   }
+  prefix(prefix) {
+    return new ContractRouterBuilder({
+      prefix,
+      errorMap: this["~orpc"].errorMap
+    });
+  }
+  tag(...tags) {
+    return new ContractRouterBuilder({
+      tags,
+      errorMap: this["~orpc"].errorMap
+    });
+  }
   router(router) {
-    return router;
+    return new ContractRouterBuilder({
+      errorMap: this["~orpc"].errorMap
+    }).router(router);
   }
 };
 
+// src/error-orpc.ts
+import { isPlainObject } from "@orpc/shared";
+var COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+var ORPCError = class extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(options) {
+    if (options.status && (options.status < 400 || options.status >= 600)) {
+      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
+    }
+    const message = fallbackORPCErrorMessage(options.code, options.message);
+    super(message, options);
+    this.code = options.code;
+    this.status = fallbackORPCErrorStatus(options.code, options.status);
+    this.defined = options.defined ?? false;
+    this.data = options.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+  static isValidJSON(json) {
+    return isPlainObject(json) && "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
+  }
+};
+function isDefinedError(error) {
+  return error instanceof ORPCError && error.defined;
+}
+async function validateORPCError(map, error) {
+  const { code, status, message, data, cause, defined } = error;
+  const config = map?.[error.code];
+  if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
+    return defined ? new ORPCError({ defined: false, code, status, message, data, cause }) : error;
+  }
+  if (!config.data) {
+    return defined ? error : new ORPCError({ defined: true, code, status, message, data, cause });
+  }
+  const validated = await config.data["~standard"].validate(error.data);
+  if (validated.issues) {
+    return defined ? new ORPCError({ defined: false, code, status, message, data, cause }) : error;
+  }
+  return new ORPCError({
+    defined: true,
+    code,
+    status,
+    message,
+    data: validated.value,
+    cause
+  });
+}
+
+// src/client-utils.ts
+async function safe(promise) {
+  try {
+    const output = await promise;
+    return [output, void 0, false];
+  } catch (e) {
+    const error = e;
+    if (isDefinedError(error)) {
+      return [void 0, error, true];
+    }
+    return [void 0, error, false];
+  }
+}
+
 // src/config.ts
@@ -167,16 +451,5 @@ var DEFAULT_CONFIG = {
 };
-var GLOBAL_CONFIG_REF = { value: DEFAULT_CONFIG };
-function configGlobal(config) {
-  if (config.defaultSuccessStatus !== void 0 && (config.defaultSuccessStatus < 200 || config.defaultSuccessStatus > 299)) {
-    throw new Error("[configGlobal] The defaultSuccessStatus must be between 200 and 299");
-  }
-  GLOBAL_CONFIG_REF.value = config;
-}
-function fallbackToGlobalConfig(key, value) {
+function fallbackContractConfig(key, value) {
   if (value === void 0) {
-    const fallback = GLOBAL_CONFIG_REF.value[key];
-    if (fallback === void 0) {
-      return DEFAULT_CONFIG[key];
-    }
-    return fallback;
+    return DEFAULT_CONFIG[key];
   }
@@ -186,14 +459,55 @@ return value;
 
+// src/error.ts
+var ValidationError = class extends Error {
+  issues;
+  constructor(options) {
+    super(options.message, options);
+    this.issues = options.issues;
+  }
+};
+
+// src/schema-utils.ts
+function type(...[map]) {
+  return {
+    "~standard": {
+      vendor: "custom",
+      version: 1,
+      async validate(value) {
+        if (map) {
+          return { value: await map(value) };
+        }
+        return { value };
+      }
+    }
+  };
+}
+
 // src/index.ts
-var oc = new ContractBuilder();
+var oc = new ContractBuilder({
+  errorMap: {},
+  InputSchema: void 0,
+  OutputSchema: void 0,
+  config: {}
+});
 export {
+  COMMON_ORPC_ERROR_DEFS,
   ContractBuilder,
   ContractProcedure,
+  ContractProcedureBuilder,
+  ContractProcedureBuilderWithInput,
+  ContractProcedureBuilderWithOutput,
   ContractRouterBuilder,
   DecoratedContractProcedure,
-  configGlobal,
-  fallbackToGlobalConfig,
+  ORPCError,
+  ValidationError,
+  fallbackContractConfig,
+  fallbackORPCErrorMessage,
+  fallbackORPCErrorStatus,
   isContractProcedure,
-  oc
+  isDefinedError,
+  oc,
+  safe,
+  type,
+  validateORPCError
 };
 //# sourceMappingURL=index.js.map

dist/src/builder.d.ts

@@ -1,14 +0,29 @@
-import type { RouteOptions } from './procedure';
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { ContractProcedureDef, 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 { ContractProcedure } from './procedure';
+import { ContractProcedureBuilder } from './procedure-builder';
+import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input';
+import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output';
 import { ContractRouterBuilder } from './router-builder';
-export declare class ContractBuilder {
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tag(...tags: string[]): ContractRouterBuilder;
-    route(route: RouteOptions): DecoratedContractProcedure<undefined, undefined>;
-    input<U extends Schema = undefined>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, undefined>;
-    output<U extends Schema = undefined>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<undefined, U>;
-    router<T extends ContractRouter>(router: T): T;
+export interface ContractBuilderConfig {
+    initialRoute?: RouteOptions;
 }
+export interface ContractBuilderDef<TErrorMap extends ErrorMap> extends ContractProcedureDef<undefined, undefined, TErrorMap> {
+    config: ContractBuilderConfig;
+}
+export declare class ContractBuilder<TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, TErrorMap> {
+    '~orpc': ContractBuilderDef<TErrorMap>;
+    constructor(def: ContractBuilderDef<TErrorMap>);
+    config(config: ContractBuilderConfig): ContractBuilder<TErrorMap>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractBuilder<U & TErrorMap>;
+    route(route: RouteOptions): ContractProcedureBuilder<TErrorMap>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap>;
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap>;
+    router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap>;
+}
 //# sourceMappingURL=builder.d.ts.map

dist/src/config.d.ts

 import type { HTTPMethod, InputStructure } from './types';
-export interface ORPCConfig {
-    /**
-     * @default 'POST'
-     */
-    defaultMethod?: HTTPMethod;
-    /**
-     *
-     * @default 200
-     */
-    defaultSuccessStatus?: number;
-    /**
-     *
-     * @default 'OK'
-     */
-    defaultSuccessDescription?: string;
-    /**
-     *
-     * @default 'compact'
-     */
-    defaultInputStructure?: InputStructure;
-    /**
-     *
-     * @default 'compact'
-     */
-    defaultOutputStructure?: InputStructure;
+export interface ContractConfig {
+    defaultMethod: HTTPMethod;
+    defaultSuccessStatus: number;
+    defaultSuccessDescription: string;
+    defaultInputStructure: InputStructure;
+    defaultOutputStructure: InputStructure;
 }
-/**
- * Set the global configuration, this configuration can effect entire project
- */
-export declare function configGlobal(config: ORPCConfig): void;
-/**
- * Fallback the value to the global config if it is undefined
- */
-export declare function fallbackToGlobalConfig<T extends keyof ORPCConfig>(key: T, value: ORPCConfig[T]): Exclude<ORPCConfig[T], undefined>;
+export declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
 //# sourceMappingURL=config.d.ts.map

dist/src/index.d.ts

 /** unnoq */
 import { ContractBuilder } from './builder';
 export * from './builder';
+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 './router';
 export * from './router-builder';
+export * from './router-client';
+export * from './schema-utils';
 export * from './types';
-export declare const oc: ContractBuilder;
+export declare const oc: ContractBuilder<Record<never, never>>;
 //# sourceMappingURL=index.d.ts.map

dist/src/procedure-decorated.d.ts

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

dist/src/procedure.d.ts

@@ -0,1 +1,2 @@
+import type { ErrorMap } from './error-map';
 import type { HTTPMethod, HTTPPath, InputStructure, OutputStructure, Schema, SchemaOutput } from './types';
@@ -66,3 +67,3 @@ export interface RouteOptions {
 }
-export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema> {
+export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
     route?: RouteOptions;
@@ -73,11 +74,12 @@ InputSchema: TInputSchema;
     outputExample?: SchemaOutput<TOutputSchema>;
+    errorMap: TErrorMap;
 }
-export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema> {
+export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
     '~type': "ContractProcedure";
-    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema>;
-    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema>);
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap>);
 }
-export type ANY_CONTRACT_PROCEDURE = ContractProcedure<any, any>;
-export type WELL_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema>;
+export type ANY_CONTRACT_PROCEDURE = ContractProcedure<any, any, any>;
+export type WELL_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema, ErrorMap>;
 export declare function isContractProcedure(item: unknown): item is ANY_CONTRACT_PROCEDURE;
 //# sourceMappingURL=procedure.d.ts.map

dist/src/router-builder.d.ts

@@ -0,1 +1,2 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
 import type { ContractProcedure } from './procedure';
@@ -5,17 +6,19 @@ import type { ContractRouter } from './router';
 import { DecoratedContractProcedure } from './procedure-decorated';
-export type AdaptedContractRouter<TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? DecoratedContractProcedure<UInputSchema, UOutputSchema> : 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

dist/src/router.d.ts

@@ -1,12 +0,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> ? 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> ? 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

dist/src/types.d.ts

@@ -0,1 +1,2 @@
+import type { FindGlobalInstanceType } from '@orpc/shared';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
@@ -9,2 +10,3 @@ export type HTTPPath = `/${string}`;
 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.json

 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.4a31e17",
+  "version": "0.0.0-next.4e27480",
   "license": "MIT",
@@ -33,3 +33,3 @@ "homepage": "https://orpc.unnoq.com",
     "@standard-schema/spec": "1.0.0-beta.4",
-    "@orpc/shared": "0.0.0-next.4a31e17"
+    "@orpc/shared": "0.0.0-next.4e27480"
   },
@@ -36,0 +36,0 @@ "devDependencies": {

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

39793

increased by156.76%

Number of package files

22

increased by100%

Lines of code

951

increased by157.03%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

Number of versions

228

decreased by-4.2%

Published versions last year

228

decreased by-4.2%

Dependency changes

• + Added@orpc/shared@0.0.0-next.4e27480(transitive)

• + Addedtype-fest@4.35.0(transitive)

• - Removed@orpc/shared@0.0.0-next.4a31e17(transitive)

• - Removedtype-fest@4.36.0(transitive)

• Updated@orpc/shared@0.0.0-next.4e27480