@orpc/contract 0.0.0-next.ee0aeaf → 0.0.0-next.f17a1a0

package/README.md

@@ -0,0 +1,101 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/contract">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fcontract?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/contract`
+
+Build your API contract. Read the [documentation](https://orpc.unnoq.com/docs/contract-first/define-contract) for more information.
+
+```ts
+export const PlanetSchema = z.object({
+  id: z.number().int().min(1),
+  name: z.string(),
+  description: z.string().optional(),
+})
+
+export const listPlanetContract = oc
+  .input(
+    z.object({
+      limit: z.number().int().min(1).max(100).optional(),
+      cursor: z.number().int().min(0).default(0),
+    }),
+  )
+  .output(z.array(PlanetSchema))
+
+export const findPlanetContract = oc
+  .input(PlanetSchema.pick({ id: true }))
+  .output(PlanetSchema)
+
+export const createPlanetContract = oc
+  .input(PlanetSchema.omit({ id: true }))
+  .output(PlanetSchema)
+
+export const contract = {
+  planet: {
+    list: listPlanetContract,
+    find: findPlanetContract,
+    create: createPlanetContract,
+  },
+}
+```
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.js

@@ -1,151 +1,270 @@
+// src/error.ts
+var ValidationError = class extends Error {
+  issues;
+  constructor(options) {
+    super(options.message, options);
+    this.issues = options.issues;
+  }
+};
+function mergeErrorMap(errorMap1, errorMap2) {
+  return { ...errorMap1, ...errorMap2 };
+}
+
+// src/meta.ts
+function mergeMeta(meta1, meta2) {
+  return { ...meta1, ...meta2 };
+}
+
 // src/procedure.ts
 var ContractProcedure = class {
-  "~type" = "ContractProcedure";
   "~orpc";
   constructor(def) {
+    if (def.route?.successStatus && (def.route.successStatus < 200 || def.route?.successStatus > 299)) {
+      throw new Error("[ContractProcedure] The successStatus must be between 200 and 299");
+    }
+    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;
   }
 };
 function isContractProcedure(item) {
-  return item instanceof ContractProcedure;
+  if (item instanceof ContractProcedure) {
+    return true;
+  }
+  return (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "inputSchema" in item["~orpc"] && "outputSchema" in item["~orpc"] && "errorMap" in item["~orpc"] && "route" in item["~orpc"] && "meta" in item["~orpc"];
 }
 
-// src/procedure-decorated.ts
-var DecoratedContractProcedure = class _DecoratedContractProcedure extends ContractProcedure {
-  static decorate(procedure) {
-    if (procedure instanceof _DecoratedContractProcedure) {
-      return procedure;
-    }
-    return new _DecoratedContractProcedure(procedure["~orpc"]);
+// src/route.ts
+function mergeRoute(a, b) {
+  return { ...a, ...b };
+}
+function prefixRoute(route, prefix) {
+  if (!route.path) {
+    return route;
   }
-  route(route) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      route
+  return {
+    ...route,
+    path: `${prefix}${route.path}`
+  };
+}
+function unshiftTagRoute(route, tags) {
+  return {
+    ...route,
+    tags: [...tags, ...route.tags ?? []]
+  };
+}
+function mergePrefix(a, b) {
+  return a ? `${a}${b}` : b;
+}
+function mergeTags(a, b) {
+  return a ? [...a, ...b] : b;
+}
+function adaptRoute(route, options) {
+  let router = route;
+  if (options.prefix) {
+    router = prefixRoute(router, options.prefix);
+  }
+  if (options.tags) {
+    router = unshiftTagRoute(router, options.tags);
+  }
+  return router;
+}
+
+// src/router.ts
+function adaptContractRouter(contract, options) {
+  if (isContractProcedure(contract)) {
+    const adapted2 = new ContractProcedure({
+      ...contract["~orpc"],
+      errorMap: mergeErrorMap(options.errorMap, contract["~orpc"].errorMap),
+      route: adaptRoute(contract["~orpc"].route, options)
     });
+    return adapted2;
   }
-  prefix(prefix) {
-    return new _DecoratedContractProcedure({
+  const adapted = {};
+  for (const key in contract) {
+    adapted[key] = adaptContractRouter(contract[key], options);
+  }
+  return adapted;
+}
+
+// src/builder.ts
+var ContractBuilder = class _ContractBuilder extends ContractProcedure {
+  constructor(def) {
+    super(def);
+    this["~orpc"].prefix = def.prefix;
+    this["~orpc"].tags = def.tags;
+  }
+  /**
+   * Reset initial meta
+   */
+  $meta(initialMeta) {
+    return new _ContractBuilder({
       ...this["~orpc"],
-      ...this["~orpc"].route?.path ? {
-        route: {
-          ...this["~orpc"].route,
-          path: `${prefix}${this["~orpc"].route.path}`
-        }
-      } : void 0
+      meta: initialMeta
     });
   }
-  pushTag(...tags) {
-    return new _DecoratedContractProcedure({
+  /**
+   * Reset initial route
+   */
+  $route(initialRoute) {
+    return new _ContractBuilder({
       ...this["~orpc"],
-      route: {
-        ...this["~orpc"].route,
-        tags: [...this["~orpc"].route?.tags ?? [], ...tags]
-      }
+      route: initialRoute
     });
   }
-  input(schema, example) {
-    return new _DecoratedContractProcedure({
+  errors(errors) {
+    return new _ContractBuilder({
       ...this["~orpc"],
-      InputSchema: schema,
-      inputExample: example
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
-  output(schema, example) {
-    return new _DecoratedContractProcedure({
+  meta(meta) {
+    return new _ContractBuilder({
       ...this["~orpc"],
-      OutputSchema: schema,
-      outputExample: example
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
-};
-
-// src/router-builder.ts
-var ContractRouterBuilder = class _ContractRouterBuilder {
-  "~type" = "ContractProcedure";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  prefix(prefix) {
-    return new _ContractRouterBuilder({
+  route(route) {
+    return new _ContractBuilder({
       ...this["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
-  tag(...tags) {
-    return new _ContractRouterBuilder({
+  input(schema) {
+    return new _ContractBuilder({
       ...this["~orpc"],
-      tags: [...this["~orpc"].tags ?? [], ...tags]
+      inputSchema: schema
     });
   }
-  router(router) {
-    const adapted = {};
-    for (const key in router) {
-      const item = router[key];
-      if (isContractProcedure(item)) {
-        let decorated = DecoratedContractProcedure.decorate(item);
-        if (this["~orpc"].tags) {
-          decorated = decorated.pushTag(...this["~orpc"].tags);
-        }
-        if (this["~orpc"].prefix) {
-          decorated = decorated.prefix(this["~orpc"].prefix);
-        }
-        adapted[key] = decorated;
-      } else {
-        adapted[key] = this.router(item);
-      }
-    }
-    return adapted;
+  output(schema) {
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      outputSchema: schema
+    });
   }
-};
-
-// src/builder.ts
-var ContractBuilder = class {
   prefix(prefix) {
-    return new ContractRouterBuilder({
-      prefix
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
-    return new ContractRouterBuilder({
-      tags
-    });
-  }
-  route(route) {
-    return new DecoratedContractProcedure({
-      route,
-      InputSchema: void 0,
-      OutputSchema: void 0
-    });
-  }
-  input(schema, example) {
-    return new DecoratedContractProcedure({
-      InputSchema: schema,
-      inputExample: example,
-      OutputSchema: void 0
-    });
-  }
-  output(schema, example) {
-    return new DecoratedContractProcedure({
-      OutputSchema: schema,
-      outputExample: example,
-      InputSchema: void 0
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
   router(router) {
-    return router;
+    return adaptContractRouter(router, this["~orpc"]);
   }
 };
+var oc = new ContractBuilder({
+  errorMap: {},
+  inputSchema: void 0,
+  outputSchema: void 0,
+  route: {},
+  meta: {}
+});
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  defaultMethod: "POST",
+  defaultSuccessStatus: 200,
+  defaultSuccessDescription: "OK",
+  defaultInputStructure: "compact",
+  defaultOutputStructure: "compact"
+};
+function fallbackContractConfig(key, value) {
+  if (value === void 0) {
+    return DEFAULT_CONFIG[key];
+  }
+  return value;
+}
+
+// src/event-iterator.ts
+import { mapEventIterator, ORPCError } from "@orpc/client";
+import { isAsyncIteratorObject } from "@orpc/server-standard";
+var EVENT_ITERATOR_SCHEMA_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_SCHEMA");
+function eventIterator(yields, returns) {
+  return {
+    "~standard": {
+      [EVENT_ITERATOR_SCHEMA_SYMBOL]: { yields, returns },
+      vendor: "orpc",
+      version: 1,
+      validate(iterator) {
+        if (!isAsyncIteratorObject(iterator)) {
+          return { issues: [{ message: "Expect event source iterator", path: [] }] };
+        }
+        const mapped = mapEventIterator(iterator, {
+          async value(value, done) {
+            const schema = done ? returns : yields;
+            if (!schema) {
+              return value;
+            }
+            const result = await schema["~standard"].validate(value);
+            if (result.issues) {
+              throw new ORPCError("EVENT_ITERATOR_VALIDATION_FAILED", {
+                message: "Event source iterator validation failed",
+                cause: new ValidationError({
+                  issues: result.issues,
+                  message: "Event source iterator validation failed"
+                })
+              });
+            }
+            return result.value;
+          },
+          error: async (error) => error
+        });
+        return { value: mapped };
+      }
+    }
+  };
+}
+function getEventIteratorSchemaDetails(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  return schema["~standard"][EVENT_ITERATOR_SCHEMA_SYMBOL];
+}
+
+// src/schema.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();
+import { ORPCError as ORPCError2 } from "@orpc/client";
 export {
   ContractBuilder,
   ContractProcedure,
-  ContractRouterBuilder,
-  DecoratedContractProcedure,
+  ORPCError2 as ORPCError,
+  ValidationError,
+  adaptContractRouter,
+  adaptRoute,
+  eventIterator,
+  fallbackContractConfig,
+  getEventIteratorSchemaDetails,
   isContractProcedure,
-  oc
+  mergeErrorMap,
+  mergeMeta,
+  mergePrefix,
+  mergeRoute,
+  mergeTags,
+  oc,
+  prefixRoute,
+  type,
+  unshiftTagRoute
 };
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,38 @@
+import type { ErrorMap, MergedErrorMap } from './error';
+import type { Meta } from './meta';
+import type { ContractProcedure } from './procedure';
+import type { HTTPPath, Route } from './route';
+import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
+import type { Schema } from './schema';
+export interface ContractProcedureBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends Schema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
+}
+export interface ContractProcedureBuilderWithInput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends Schema>(schema: U): ContractProcedureBuilderWithInputOutput<TInputSchema, U, TErrorMap, TMeta>;
+}
+export interface ContractProcedureBuilderWithOutput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInputOutput<U, TOutputSchema, TErrorMap, TMeta>;
+}
+export interface ContractProcedureBuilderWithInputOutput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+}
+export interface ContractRouterBuilder<TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': AdaptContractRouterOptions<TErrorMap>;
+    'errors'<U extends ErrorMap>(errors: U): ContractRouterBuilder<MergedErrorMap<TErrorMap, U>, TMeta>;
+    'prefix'(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
+    'tag'(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
+    'router'<T extends ContractRouter<TMeta>>(router: T): AdaptedContractRouter<T, TErrorMap>;
+}
+//# sourceMappingURL=builder-variants.d.ts.map

package/dist/src/builder.d.ts

@@ -1,14 +1,32 @@
-import type { RouteOptions } from './procedure';
-import type { ContractRouter } from './router';
-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>;
-    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, undefined>;
-    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<undefined, U>;
-    router<T extends ContractRouter>(router: T): T;
+import type { ContractProcedureBuilder, ContractProcedureBuilderWithInput, ContractProcedureBuilderWithOutput, ContractRouterBuilder } from './builder-variants';
+import type { ContractProcedureDef } from './procedure';
+import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
+import type { Schema } from './schema';
+import { type ErrorMap, type MergedErrorMap } from './error';
+import { type Meta } from './meta';
+import { ContractProcedure } from './procedure';
+import { type HTTPPath, type Route } from './route';
+export interface ContractBuilderDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>, AdaptContractRouterOptions<TErrorMap> {
 }
+export declare class ContractBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    '~orpc': ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+    /**
+     * Reset initial meta
+     */
+    $meta<U extends Meta>(initialMeta: U): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, U>;
+    /**
+     * Reset initial route
+     */
+    $route(initialRoute: Route): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    errors<U extends ErrorMap>(errors: U): ContractBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends Schema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
+    router<T extends ContractRouter<TMeta>>(router: T): AdaptedContractRouter<T, TErrorMap>;
+}
+export declare const oc: ContractBuilder<undefined, undefined, {}, {}>;
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/config.d.ts

@@ -0,0 +1,10 @@
+import type { HTTPMethod, InputStructure } from './route';
+export interface ContractConfig {
+    defaultMethod: HTTPMethod;
+    defaultSuccessStatus: number;
+    defaultSuccessDescription: string;
+    defaultInputStructure: InputStructure;
+    defaultOutputStructure: InputStructure;
+}
+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.d.ts

@@ -0,0 +1,27 @@
+import type { ORPCError, ORPCErrorCode } from '@orpc/client';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Schema, SchemaOutput } from './schema';
+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);
+}
+export type ErrorMapItem<TDataSchema extends Schema> = {
+    status?: number;
+    message?: string;
+    description?: string;
+    data?: TDataSchema;
+};
+export type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<Schema>;
+};
+export type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
+export declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
+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 type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
+//# sourceMappingURL=error.d.ts.map

package/dist/src/event-iterator.d.ts

@@ -0,0 +1,8 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Schema } from './schema';
+export declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: StandardSchemaV1<TYieldIn, TYieldOut>, returns?: StandardSchemaV1<TReturnIn, TReturnOut>): StandardSchemaV1<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorObject<TYieldOut, TReturnOut, void>>;
+export declare function getEventIteratorSchemaDetails(schema: Schema): undefined | {
+    yields: Schema;
+    returns: Schema;
+};
+//# sourceMappingURL=event-iterator.d.ts.map

package/dist/src/index.d.ts

@@ -1,10 +1,15 @@
 /** unnoq */
-import { ContractBuilder } from './builder';
 export * from './builder';
+export * from './builder-variants';
+export * from './config';
+export * from './error';
+export * from './event-iterator';
+export * from './meta';
 export * from './procedure';
-export * from './procedure-decorated';
+export * from './procedure-client';
+export * from './route';
 export * from './router';
-export * from './router-builder';
-export * from './types';
-export declare const oc: ContractBuilder;
+export * from './router-client';
+export * from './schema';
+export { ORPCError } from '@orpc/client';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/meta.d.ts

@@ -0,0 +1,3 @@
+export type Meta = Record<string, any>;
+export declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
+//# sourceMappingURL=meta.d.ts.map

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

@@ -0,0 +1,5 @@
+import type { Client, ClientContext } from '@orpc/client';
+import type { ErrorFromErrorMap, ErrorMap } from './error';
+import type { Schema, SchemaInput, SchemaOutput } from './schema';
+export type ContractProcedureClient<TClientContext extends ClientContext, 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.d.ts

@@ -1,25 +1,18 @@
-import type { HTTPMethod, HTTPPath, Schema, SchemaOutput } from './types';
-export interface RouteOptions {
-    method?: HTTPMethod;
-    path?: HTTPPath;
-    summary?: string;
-    description?: string;
-    deprecated?: boolean;
-    tags?: string[];
+import type { ErrorMap } from './error';
+import type { Meta } from './meta';
+import type { Route } from './route';
+import type { Schema } from './schema';
+export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    inputSchema: TInputSchema;
+    outputSchema: TOutputSchema;
+    errorMap: TErrorMap;
 }
-export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema> {
-    route?: RouteOptions;
-    InputSchema: TInputSchema;
-    inputExample?: SchemaOutput<TInputSchema>;
-    OutputSchema: TOutputSchema;
-    outputExample?: SchemaOutput<TOutputSchema>;
+export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
 }
-export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema> {
-    '~type': "ContractProcedure";
-    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema>;
-    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema>);
-}
-export type ANY_CONTRACT_PROCEDURE = ContractProcedure<any, any>;
-export type WELL_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema>;
-export declare function isContractProcedure(item: unknown): item is ANY_CONTRACT_PROCEDURE;
+export type AnyContractProcedure = ContractProcedure<any, any, any, any>;
+export declare function isContractProcedure(item: unknown): item is AnyContractProcedure;
 //# sourceMappingURL=procedure.d.ts.map

package/dist/src/route.d.ts

@@ -0,0 +1,79 @@
+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;
+}
+export declare function mergeRoute(a: Route, b: Route): Route;
+export declare function prefixRoute(route: Route, prefix: HTTPPath): Route;
+export declare function unshiftTagRoute(route: Route, tags: readonly string[]): Route;
+export declare function mergePrefix(a: HTTPPath | undefined, b: HTTPPath): HTTPPath;
+export declare function mergeTags(a: readonly string[] | undefined, b: readonly string[]): readonly string[];
+export interface AdaptRouteOptions {
+    prefix?: HTTPPath;
+    tags?: readonly string[];
+}
+export declare function adaptRoute(route: Route, options: AdaptRouteOptions): Route;
+//# sourceMappingURL=route.d.ts.map

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

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

package/dist/src/router.d.ts

@@ -1,12 +1,29 @@
-import type { ANY_CONTRACT_PROCEDURE, ContractProcedure } from './procedure';
-import type { SchemaInput, SchemaOutput } from './types';
-export interface ContractRouter {
-    [k: string]: ANY_CONTRACT_PROCEDURE | ContractRouter;
+import type { Meta } from './meta';
+import type { SchemaInput, SchemaOutput } from './schema';
+import { type ErrorMap, type MergedErrorMap } from './error';
+import { ContractProcedure } from './procedure';
+import { type HTTPPath } from './route';
+export type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {
+    [k: string]: ContractRouter<TMeta>;
+};
+export type AnyContractRouter = ContractRouter<any>;
+export type AdaptedContractRouter<TContract extends AnyContractRouter, TErrorMap extends ErrorMap> = {
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors, infer UMeta> ? ContractProcedure<UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrors>, UMeta> : TContract[K] extends AnyContractRouter ? AdaptedContractRouter<TContract[K], TErrorMap> : never;
+};
+export interface AdaptContractRouterOptions<TErrorMap extends ErrorMap> {
+    errorMap: TErrorMap;
+    prefix?: HTTPPath;
+    tags?: readonly string[];
 }
-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 declare function adaptContractRouter<TRouter extends ContractRouter<any>, TErrorMap extends ErrorMap>(contract: TRouter, options: AdaptContractRouterOptions<TErrorMap>): AdaptedContractRouter<TRouter, TErrorMap>;
+export type InferContractRouterInputs<T extends AnyContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? 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 AnyContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? SchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterOutputs<T[K]> : never;
 };
+export type ContractRouterToErrorMap<T extends AnyContractRouter> = T extends ContractProcedure<any, any, infer UErrorMap, any> ? UErrorMap : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? ContractRouterToErrorMap<T[K]> : never;
+}[keyof T];
+export type ContractRouterToMeta<T extends AnyContractRouter> = T extends ContractRouter<infer UMeta> ? UMeta : never;
 //# sourceMappingURL=router.d.ts.map

package/dist/src/{types.d.ts → schema.d.ts}

@@ -1,7 +1,8 @@
+import type { IsEqual, Promisable } from '@orpc/shared';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-export type HTTPPath = `/${string}`;
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 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;
-//# sourceMappingURL=types.d.ts.map
+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.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.ee0aeaf",
+  "version": "0.0.0-next.f17a1a0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,13 +29,15 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0-beta.4",
-    "@orpc/shared": "0.0.0-next.ee0aeaf"
+    "@orpc/server-standard": "^0.4.0",
+    "@standard-schema/spec": "^1.0.0",
+    "@orpc/client": "0.0.0-next.f17a1a0",
+    "@orpc/shared": "0.0.0-next.f17a1a0"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",
     "valibot": "1.0.0-beta.9",
-    "zod": "3.24.1"
+    "zod": "^3.24.1"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",

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

@@ -1,12 +0,0 @@
-import type { RouteOptions } from './procedure';
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } 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>;
-    pushTag(...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>;
-}
-//# sourceMappingURL=procedure-decorated.d.ts.map

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

@@ -1,20 +0,0 @@
-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> ? DecoratedContractProcedure<UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? AdaptedContractRouter<TContract[K]> : never;
-};
-export interface ContractRouterBuilderDef {
-    prefix?: HTTPPath;
-    tags?: string[];
-}
-export declare class ContractRouterBuilder {
-    '~type': "ContractProcedure";
-    '~orpc': ContractRouterBuilderDef;
-    constructor(def: ContractRouterBuilderDef);
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tag(...tags: string[]): ContractRouterBuilder;
-    router<T extends ContractRouter>(router: T): AdaptedContractRouter<T>;
-}
-//# sourceMappingURL=router-builder.d.ts.map