@orpc/contract 0.30.0 → 0.31.0

package/dist/index.js

@@ -27,6 +27,15 @@ var DecoratedContractProcedure = class _DecoratedContractProcedure extends Contr
     }
     return new _DecoratedContractProcedure(procedure["~orpc"]);
   }
+  errors(errors) {
+    return new _DecoratedContractProcedure({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   route(route) {
     return new _DecoratedContractProcedure({
       ...this["~orpc"],
@@ -59,27 +68,92 @@ var DecoratedContractProcedure = class _DecoratedContractProcedure extends Contr
       }
     });
   }
+};
+
+// 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"],
       InputSchema: schema,
       inputExample: example
     });
   }
-  output(schema, example) {
-    return new _DecoratedContractProcedure({
+};
+
+// 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"],
-      OutputSchema: schema,
-      outputExample: example
+      InputSchema: schema,
+      inputExample: example
     });
   }
-  errors(errors) {
-    return new _DecoratedContractProcedure({
+  output(schema, example) {
+    return new ContractProcedureBuilderWithOutput({
       ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
+      OutputSchema: schema,
+      outputExample: example
     });
   }
 };
@@ -133,12 +207,7 @@ var ContractRouterBuilder = class _ContractRouterBuilder {
 };
 
 // src/builder.ts
-var ContractBuilder = class _ContractBuilder {
-  "~type" = "ContractBuilder";
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
+var ContractBuilder = class _ContractBuilder extends ContractProcedure {
   errors(errors) {
     return new _ContractBuilder({
       ...this["~orpc"],
@@ -148,20 +217,8 @@ var ContractBuilder = class _ContractBuilder {
       }
     });
   }
-  prefix(prefix) {
-    return new ContractRouterBuilder({
-      prefix,
-      errorMap: this["~orpc"].errorMap
-    });
-  }
-  tag(...tags) {
-    return new ContractRouterBuilder({
-      tags,
-      errorMap: this["~orpc"].errorMap
-    });
-  }
   route(route) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilder({
       route,
       InputSchema: void 0,
       OutputSchema: void 0,
@@ -169,7 +226,7 @@ var ContractBuilder = class _ContractBuilder {
     });
   }
   input(schema, example) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithInput({
       InputSchema: schema,
       inputExample: example,
       OutputSchema: void 0,
@@ -177,13 +234,25 @@ var ContractBuilder = class _ContractBuilder {
     });
   }
   output(schema, example) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithOutput({
       OutputSchema: schema,
       outputExample: example,
       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 new ContractRouterBuilder({
       errorMap: this["~orpc"].errorMap
@@ -381,14 +450,35 @@ var ValidationError = class extends Error {
   }
 };
 
+// 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({
-  errorMap: {}
+  errorMap: {},
+  InputSchema: void 0,
+  OutputSchema: void 0
 });
 export {
   COMMON_ORPC_ERROR_DEFS,
   ContractBuilder,
   ContractProcedure,
+  ContractProcedureBuilder,
+  ContractProcedureBuilderWithInput,
+  ContractProcedureBuilderWithOutput,
   ContractRouterBuilder,
   DecoratedContractProcedure,
   ORPCError,
@@ -401,6 +491,7 @@ export {
   isDefinedError,
   oc,
   safe,
+  type,
   validateORPCError
 };
 //# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,23 +1,22 @@
 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 { ContractProcedure, type RouteOptions } 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 type ContractBuilderDef<TErrorMap extends ErrorMap> = {
     errorMap: TErrorMap;
 };
-export declare class ContractBuilder<TErrorMap extends ErrorMap> {
-    '~type': "ContractBuilder";
-    '~orpc': ContractBuilderDef<TErrorMap>;
-    constructor(def: ContractBuilderDef<TErrorMap>);
+export declare class ContractBuilder<TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, 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>;
-    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/index.d.ts

@@ -8,11 +8,15 @@ 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<Record<never, never>>;
 //# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -0,0 +1,15 @@
+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';
+import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input';
+import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output';
+export declare class ContractProcedureBuilder<TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, TErrorMap> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilder<TErrorMap & U>;
+    route(route: RouteOptions): ContractProcedureBuilder<TErrorMap>;
+    prefix(prefix: HTTPPath): ContractProcedureBuilder<TErrorMap>;
+    unshiftTag(...tags: string[]): 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>;
+}
+//# sourceMappingURL=procedure-builder.d.ts.map

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

@@ -1,14 +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, 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>;
-    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 & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap & U>;
 }
 //# sourceMappingURL=procedure-decorated.d.ts.map

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.30.0",
+  "version": "0.31.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.30.0"
+    "@orpc/shared": "0.31.0"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",