@orpc/contract 0.0.0-next.db1f26d → 0.0.0-next.e7b4f63

package/dist/index.js

@@ -1,96 +1,109 @@
 // src/procedure.ts
 var ContractProcedure = class {
-  constructor(zz$cp) {
-    this.zz$cp = zz$cp;
+  "~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");
+    }
+    this["~orpc"] = def;
   }
 };
+function isContractProcedure(item) {
+  if (item instanceof ContractProcedure) {
+    return true;
+  }
+  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"];
+}
+
+// src/procedure-decorated.ts
 var DecoratedContractProcedure = class _DecoratedContractProcedure extends ContractProcedure {
-  static decorate(cp) {
-    if (cp instanceof _DecoratedContractProcedure)
-      return cp;
-    return new _DecoratedContractProcedure(cp.zz$cp);
+  static decorate(procedure) {
+    if (procedure instanceof _DecoratedContractProcedure) {
+      return procedure;
+    }
+    return new _DecoratedContractProcedure(procedure["~orpc"]);
   }
-  route(opts) {
+  route(route) {
     return new _DecoratedContractProcedure({
-      ...this.zz$cp,
-      ...opts,
-      method: opts.method,
-      path: opts.path
+      ...this["~orpc"],
+      route
     });
   }
   prefix(prefix) {
-    if (!this.zz$cp.path)
-      return this;
     return new _DecoratedContractProcedure({
-      ...this.zz$cp,
-      path: `${prefix}${this.zz$cp.path}`
+      ...this["~orpc"],
+      ...this["~orpc"].route?.path ? {
+        route: {
+          ...this["~orpc"].route,
+          path: `${prefix}${this["~orpc"].route.path}`
+        }
+      } : void 0
     });
   }
-  addTags(...tags) {
-    if (!tags.length)
-      return this;
+  unshiftTag(...tags) {
     return new _DecoratedContractProcedure({
-      ...this.zz$cp,
-      tags: [...this.zz$cp.tags ?? [], ...tags]
+      ...this["~orpc"],
+      route: {
+        ...this["~orpc"].route,
+        tags: [
+          ...tags,
+          ...this["~orpc"].route?.tags?.filter((tag) => !tags.includes(tag)) ?? []
+        ]
+      }
     });
   }
   input(schema, example) {
     return new _DecoratedContractProcedure({
-      ...this.zz$cp,
+      ...this["~orpc"],
       InputSchema: schema,
       inputExample: example
     });
   }
   output(schema, example) {
     return new _DecoratedContractProcedure({
-      ...this.zz$cp,
+      ...this["~orpc"],
       OutputSchema: schema,
       outputExample: example
     });
   }
 };
-function isContractProcedure(item) {
-  if (item instanceof ContractProcedure)
-    return true;
-  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$cp" in item && typeof item.zz$cp === "object" && item.zz$cp !== null && "InputSchema" in item.zz$cp && "OutputSchema" in item.zz$cp;
-}
 
 // src/router-builder.ts
 var ContractRouterBuilder = class _ContractRouterBuilder {
-  constructor(zz$crb) {
-    this.zz$crb = zz$crb;
-    if (zz$crb.prefix && zz$crb.prefix.includes("{")) {
-      throw new Error('Prefix cannot contain "{" for dynamic routing');
-    }
+  "~type" = "ContractProcedure";
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
   }
   prefix(prefix) {
     return new _ContractRouterBuilder({
-      ...this.zz$crb,
-      prefix: `${this.zz$crb.prefix ?? ""}${prefix}`
+      ...this["~orpc"],
+      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
     });
   }
-  tags(...tags) {
-    if (!tags.length)
-      return this;
+  tag(...tags) {
     return new _ContractRouterBuilder({
-      ...this.zz$crb,
-      tags: [...this.zz$crb.tags ?? [], ...tags]
+      ...this["~orpc"],
+      tags: [...this["~orpc"].tags ?? [], ...tags]
     });
   }
   router(router) {
-    const handled = {};
-    for (const key in router) {
-      const item = router[key];
-      if (isContractProcedure(item)) {
-        const decorated = DecoratedContractProcedure.decorate(item).addTags(
-          ...this.zz$crb.tags ?? []
-        );
-        handled[key] = this.zz$crb.prefix ? decorated.prefix(this.zz$crb.prefix) : decorated;
-      } else {
-        handled[key] = this.router(item);
+    if (isContractProcedure(router)) {
+      let decorated = DecoratedContractProcedure.decorate(router);
+      if (this["~orpc"].tags) {
+        decorated = decorated.unshiftTag(...this["~orpc"].tags);
+      }
+      if (this["~orpc"].prefix) {
+        decorated = decorated.prefix(this["~orpc"].prefix);
       }
+      return decorated;
     }
-    return handled;
+    const adapted = {};
+    for (const key in router) {
+      adapted[key] = this.router(router[key]);
+    }
+    return adapted;
   }
 };
 
@@ -101,16 +114,16 @@ var ContractBuilder = class {
       prefix
     });
   }
-  tags(...tags) {
+  tag(...tags) {
     return new ContractRouterBuilder({
       tags
     });
   }
-  route(opts) {
+  route(route) {
     return new DecoratedContractProcedure({
+      route,
       InputSchema: void 0,
-      OutputSchema: void 0,
-      ...opts
+      OutputSchema: void 0
     });
   }
   input(schema, example) {
@@ -122,9 +135,9 @@ var ContractBuilder = class {
   }
   output(schema, example) {
     return new DecoratedContractProcedure({
-      InputSchema: void 0,
       OutputSchema: schema,
-      outputExample: example
+      outputExample: example,
+      InputSchema: void 0
     });
   }
   router(router) {
@@ -132,48 +145,14 @@ var ContractBuilder = class {
   }
 };
 
-// src/constants.ts
-var ORPC_HEADER = "x-orpc-transformer";
-var ORPC_HEADER_VALUE = "t";
-
-// src/router.ts
-function eachContractRouterLeaf(router, callback, prefix = []) {
-  for (const key in router) {
-    const item = router[key];
-    if (isContractProcedure(item)) {
-      callback(item, [...prefix, key]);
-    } else {
-      eachContractRouterLeaf(item, callback, [...prefix, key]);
-    }
-  }
-}
-
-// src/utils.ts
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-function prefixHTTPPath(prefix, path) {
-  const prefix_ = standardizeHTTPPath(prefix);
-  const path_ = standardizeHTTPPath(path);
-  if (prefix_ === "/")
-    return path_;
-  if (path_ === "/")
-    return prefix_;
-  return `${prefix_}${path_}`;
-}
-
 // src/index.ts
 var oc = new ContractBuilder();
 export {
   ContractBuilder,
   ContractProcedure,
+  ContractRouterBuilder,
   DecoratedContractProcedure,
-  ORPC_HEADER,
-  ORPC_HEADER_VALUE,
-  eachContractRouterLeaf,
   isContractProcedure,
-  oc,
-  prefixHTTPPath,
-  standardizeHTTPPath
+  oc
 };
 //# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,13 +1,14 @@
+import type { RouteOptions } from './procedure';
 import type { ContractRouter } from './router';
 import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
-import { DecoratedContractProcedure, type RouteOptions } from './procedure';
+import { DecoratedContractProcedure } from './procedure-decorated';
 import { ContractRouterBuilder } from './router-builder';
 export declare class ContractBuilder {
     prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tags(...tags: string[]): ContractRouterBuilder;
-    route(opts: RouteOptions): DecoratedContractProcedure<undefined, undefined>;
-    input<USchema extends Schema>(schema: USchema, example?: SchemaInput<USchema>): DecoratedContractProcedure<USchema, undefined>;
-    output<USchema extends Schema>(schema: USchema, example?: SchemaOutput<USchema>): DecoratedContractProcedure<undefined, USchema>;
+    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;
 }
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/index.d.ts

@@ -1,10 +1,10 @@
 /** unnoq */
 import { ContractBuilder } from './builder';
 export * from './builder';
-export * from './constants';
 export * from './procedure';
+export * from './procedure-decorated';
 export * from './router';
+export * from './router-builder';
 export * from './types';
-export * from './utils';
 export declare const oc: ContractBuilder;
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,12 @@
+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>;
+    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>;
+}
+//# sourceMappingURL=procedure-decorated.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,47 +1,75 @@
-import type { HTTPMethod, HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
+import type { HTTPMethod, HTTPPath, Schema, SchemaOutput } from './types';
 export interface RouteOptions {
     method?: HTTPMethod;
     path?: HTTPPath;
     summary?: string;
     description?: string;
     deprecated?: boolean;
-    tags?: string[];
+    tags?: readonly string[];
+    /**
+     * The status code of the response when the procedure is successful.
+     *
+     * @default 200
+     */
+    successStatus?: number;
+    /**
+     * 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?: 'compact' | 'detailed';
+    /**
+     * 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?: 'compact' | 'detailed';
+}
+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> {
-    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>;
-    });
+    '~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 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 declare function isContractProcedure(item: unknown): item is ANY_CONTRACT_PROCEDURE;
 //# sourceMappingURL=procedure.d.ts.map

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

@@ -1,16 +1,20 @@
-import type { ContractRouter, HandledContractRouter } from './router';
+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 {
-    zz$crb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-    };
-    constructor(zz$crb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-    });
+    '~type': "ContractProcedure";
+    '~orpc': ContractRouterBuilderDef;
+    constructor(def: ContractRouterBuilderDef);
     prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tags(...tags: string[]): ContractRouterBuilder;
-    router<T extends ContractRouter>(router: T): HandledContractRouter<T>;
+    tag(...tags: string[]): ContractRouterBuilder;
+    router<T extends ContractRouter>(router: T): AdaptedContractRouter<T>;
 }
 //# sourceMappingURL=router-builder.d.ts.map

package/dist/src/router.d.ts

@@ -1,16 +1,12 @@
+import type { ANY_CONTRACT_PROCEDURE, 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 = ANY_CONTRACT_PROCEDURE | {
+    [k: string]: ContractRouter;
 };
-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> = T extends ContractProcedure<infer UInputSchema, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends ContractRouter ? 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> = T extends ContractProcedure<any, infer UOutputSchema> ? SchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends ContractRouter ? InferContractRouterOutputs<T[K]> : never;
 };
 //# sourceMappingURL=router.d.ts.map

package/dist/src/types.d.ts

@@ -1,8 +1,7 @@
-import type { input, output, ZodType } from 'zod';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 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;
+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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.db1f26d",
+  "version": "0.0.0-next.e7b4f63",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -28,11 +28,14 @@
     "!**/*.tsbuildinfo",
     "dist"
   ],
-  "peerDependencies": {
-    "zod": ">=3.23.0"
-  },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.db1f26d"
+    "@standard-schema/spec": "1.0.0-beta.4",
+    "@orpc/shared": "0.0.0-next.e7b4f63"
+  },
+  "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/src/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const ORPC_HEADER = "x-orpc-transformer";
-export declare const ORPC_HEADER_VALUE = "t";
-//# sourceMappingURL=constants.d.ts.map

package/dist/src/utils.d.ts

@@ -1,4 +0,0 @@
-import type { HTTPPath } from './types';
-export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
-export declare function prefixHTTPPath(prefix: HTTPPath, path: HTTPPath): HTTPPath;
-//# sourceMappingURL=utils.d.ts.map