@orpc/experimental-effect 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/extensions/input-output.d.ts

@@ -4,41 +4,41 @@ import { Schema } from 'effect';
 
 declare module '@orpc/contract' {
     interface ContractBuilder<TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): ProcedureContractBuilderWithInput<Schema$1<I, A>, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): ProcedureContractBuilderWithOutput<Schema$1<I, A>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): ProcedureContractBuilderWithInput<Schema$1<S['Encoded'], S['Type']>, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): ProcedureContractBuilderWithOutput<Schema$1<S['Encoded'], S['Type']>, TErrorMap>;
     }
     interface ProcedureContractBuilderWithInput<TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): ProcedureContractBuilderWithInput<MergedSchema<Schema$1<I, A>, TInputSchema>, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): ProcedureContractBuilderWithInputOutput<TInputSchema, Schema$1<I, A>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): ProcedureContractBuilderWithInput<MergedSchema<Schema$1<S['Encoded'], S['Type']>, TInputSchema>, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): ProcedureContractBuilderWithInputOutput<TInputSchema, Schema$1<S['Encoded'], S['Type']>, TErrorMap>;
     }
     interface ProcedureContractBuilderWithOutput<TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): ProcedureContractBuilderWithInputOutput<Schema$1<I, A>, TOutputSchema, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): ProcedureContractBuilderWithOutput<MergedSchema<Schema$1<I, A>, TOutputSchema>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): ProcedureContractBuilderWithInputOutput<Schema$1<S['Encoded'], S['Type']>, TOutputSchema, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): ProcedureContractBuilderWithOutput<MergedSchema<Schema$1<S['Encoded'], S['Type']>, TOutputSchema>, TErrorMap>;
     }
     interface ProcedureContractBuilderWithInputOutput<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): ProcedureContractBuilderWithInputOutput<MergedSchema<Schema$1<I, A>, TInputSchema>, TOutputSchema, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): ProcedureContractBuilderWithInputOutput<TInputSchema, MergedSchema<Schema$1<I, A>, TOutputSchema>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): ProcedureContractBuilderWithInputOutput<MergedSchema<Schema$1<S['Encoded'], S['Type']>, TInputSchema>, TOutputSchema, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): ProcedureContractBuilderWithInputOutput<TInputSchema, MergedSchema<Schema$1<S['Encoded'], S['Type']>, TOutputSchema>, TErrorMap>;
     }
 }
 declare module '@orpc/server' {
     interface Builder<TInitialContext extends Context, TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): BuilderWithInput<TInitialContext, object, Schema$1<I, A>, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): BuilderWithOutput<TInitialContext, object, Schema$1<I, A>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithInput<TInitialContext, object, Schema$1<S['Encoded'], S['Type']>, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithOutput<TInitialContext, object, Schema$1<S['Encoded'], S['Type']>, TErrorMap>;
     }
     interface BuilderWithMiddlewares<TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): BuilderWithInput<TInitialContext, TInjectedContext, Schema$1<I, A>, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): BuilderWithOutput<TInitialContext, TInjectedContext, Schema$1<I, A>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithInput<TInitialContext, TInjectedContext, Schema$1<S['Encoded'], S['Type']>, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithOutput<TInitialContext, TInjectedContext, Schema$1<S['Encoded'], S['Type']>, TErrorMap>;
     }
     interface BuilderWithInput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): BuilderWithInput<TInitialContext, TInjectedContext, MergedSchema<Schema$1<I, A>, TInputSchema>, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, Schema$1<I, A>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithInput<TInitialContext, TInjectedContext, MergedSchema<Schema$1<S['Encoded'], S['Type']>, TInputSchema>, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, Schema$1<S['Encoded'], S['Type']>, TErrorMap>;
     }
     interface BuilderWithOutput<TInitialContext extends Context, TInjectedContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): BuilderWithInputOutput<TInitialContext, TInjectedContext, Schema$1<I, A>, TOutputSchema, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): BuilderWithOutput<TInitialContext, TInjectedContext, MergedSchema<Schema$1<I, A>, TOutputSchema>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithInputOutput<TInitialContext, TInjectedContext, Schema$1<S['Encoded'], S['Type']>, TOutputSchema, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithOutput<TInitialContext, TInjectedContext, MergedSchema<Schema$1<S['Encoded'], S['Type']>, TOutputSchema>, TErrorMap>;
     }
     interface BuilderWithInputOutput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        input<A, I>(schema: Schema.Schema<A, I>): BuilderWithInputOutput<TInitialContext, TInjectedContext, MergedSchema<Schema$1<I, A>, TInputSchema>, TOutputSchema, TErrorMap>;
-        output<A, I>(schema: Schema.Schema<A, I>): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, MergedSchema<Schema$1<I, A>, TOutputSchema>, TErrorMap>;
+        input<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithInputOutput<TInitialContext, TInjectedContext, MergedSchema<Schema$1<S['Encoded'], S['Type']>, TInputSchema>, TOutputSchema, TErrorMap>;
+        output<S extends Schema.ConstraintDecoder<any>>(schema: S): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, MergedSchema<Schema$1<S['Encoded'], S['Type']>, TOutputSchema>, TErrorMap>;
     }
 }

package/dist/extensions/input-output.mjs

@@ -1,21 +1,24 @@
 import { ContractBuilder } from '@orpc/contract';
 import { Builder } from '@orpc/server';
 import { Schema } from 'effect';
-import { t as toStandardSchema } from '../shared/experimental-effect.B68ZlIzV.mjs';
+import { t as toStandardSchema } from '../shared/experimental-effect.YQKompVf.mjs';
 
+function isEffectConstraintDecoder(schema) {
+  return Schema.isSchema(schema);
+}
 const OriginalContractBuilderInput = ContractBuilder.prototype.input;
 ContractBuilder.prototype.input = function input(schema) {
-  return OriginalContractBuilderInput.bind(this)(Schema.isSchema(schema) ? toStandardSchema(schema) : schema);
+  return OriginalContractBuilderInput.bind(this)(isEffectConstraintDecoder(schema) ? toStandardSchema(schema) : schema);
 };
 const OriginalContractBuilderOutput = ContractBuilder.prototype.output;
 ContractBuilder.prototype.output = function output(schema) {
-  return OriginalContractBuilderOutput.bind(this)(Schema.isSchema(schema) ? toStandardSchema(schema) : schema);
+  return OriginalContractBuilderOutput.bind(this)(isEffectConstraintDecoder(schema) ? toStandardSchema(schema) : schema);
 };
 const OriginalBuilderInput = Builder.prototype.input;
 Builder.prototype.input = function input2(schema) {
-  return OriginalBuilderInput.bind(this)(Schema.isSchema(schema) ? toStandardSchema(schema) : schema);
+  return OriginalBuilderInput.bind(this)(isEffectConstraintDecoder(schema) ? toStandardSchema(schema) : schema);
 };
 const OriginalBuilderOutput = Builder.prototype.output;
 Builder.prototype.output = function output2(schema) {
-  return OriginalBuilderOutput.bind(this)(Schema.isSchema(schema) ? toStandardSchema(schema) : schema);
+  return OriginalBuilderOutput.bind(this)(isEffectConstraintDecoder(schema) ? toStandardSchema(schema) : schema);
 };

package/dist/index.d.mts

@@ -1,30 +1,172 @@
-export { H as HandlerGen, I as InferYieldError, W as WithEffectContext, h as handlerGen } from './shared/experimental-effect.CuTs7Ks0.mjs';
-import { AnySchema, Schema as Schema$1 } from '@orpc/contract';
+import { AnyNestedClient, Client, ClientRest } from '@orpc/client';
+import { Effect, Schema } from 'effect';
+import { I as InferEffectServices } from './shared/experimental-effect.D0zFxpKr.mjs';
+export { H as HandlerGen, a as InferYieldError, W as WithEffectContext, h as handlerGen } from './shared/experimental-effect.D0zFxpKr.mjs';
+import { AnySchema, ErrorMap, Schema as Schema$1 } from '@orpc/contract';
 import { JsonSchemaConverter, JsonSchemaConverterDirection, JsonSchema } from '@orpc/json-schema';
-import { Cause, Effect, Schema } from 'effect';
-import '@orpc/server';
-import 'effect/Utils';
+import { AnyORPCError, ORPCError, ORPCErrorCode, Context, ORPCErrorConstructorMap, MiddlewareOptions, MiddlewareNextOptions, MiddlewareResult, MiddlewareDone, Middleware } from '@orpc/server';
+import { MaybeOptionalOptions } from '@orpc/shared';
 
+type EffectClient<T extends AnyNestedClient> = T extends Client<infer UContext, infer UInput, infer UOutput, infer UError> ? (...rest: ClientRest<UContext, UInput>) => Effect.Effect<UOutput, UError> : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? EffectClient<T[K]> : never;
+};
+/**
+ * Creates a client whose procedures return lazy effects instead of promises,
+ * so you can `yield*` calls inside Effect generators. Errors are captured in
+ * the error channel with their original types preserved, and interrupting an
+ * effect aborts the underlying call.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#client-calls | Effect Integration - Client Calls}
+ */
+declare function createEffectClient<T extends AnyNestedClient>(client: T): EffectClient<T>;
+
+/**
+ * A JSON Schema converter for Effect Schema, built on top of
+ * [Effect Schema to JSON Schema](https://effect.website/docs/schema/json-schema/).
+ * Useful with tools such as the OpenAPI Generator.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#json-schema-converter | Effect Integration - JSON Schema Converter}
+ */
 declare class EffectSchemaToJsonSchemaConverter implements JsonSchemaConverter {
+    private readonly converter;
     condition(schema: AnySchema | undefined, _direction: JsonSchemaConverterDirection): boolean;
     convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
 }
 
 /**
- * Extracts the most meaningful original error from an Effect Cause,
- * preserving the original error instance wherever possible.
+ * Recovers from `ORPCError` failures in the error channel of an effect.
+ * Other failures re-fail with their original cause. Because failure types
+ * like `Error` can also hold `ORPCError` instances at runtime, the handler
+ * can also receive such hidden errors with unknown code and data.
+ *
+ * Supports both data-first `catchORPCError(effect, handler)` and data-last
+ * `effect.pipe(catchORPCError(handler))` styles.
+ *
+ * @example
+ * ```ts
+ * declare const program: Effect.Effect<string, ORPCError<'NOT_FOUND', undefined> | TypeError>
+ *
+ * const recovered = program.pipe(
+ *   catchORPCError(error => Effect.succeed(`caught ${error.code}`)),
+ * )
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#catching-orpcerrors | Effect Integration - Catching ORPCErrors}
+ */
+declare const catchORPCError: {
+    <E, A2, E2, R2>(f: (error: E extends AnyORPCError ? E : AnyORPCError extends E ? ORPCError<ORPCErrorCode, unknown> : never) => Effect.Effect<A2, E2, R2>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E2 | Exclude<E, AnyORPCError>, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Effect.Effect<A, E, R>, f: (error: E extends AnyORPCError ? E : AnyORPCError extends E ? ORPCError<ORPCErrorCode, unknown> : never) => Effect.Effect<A2, E2, R2>): Effect.Effect<A | A2, E2 | Exclude<E, AnyORPCError>, R | R2>;
+};
+/**
+ * Recovers from `ORPCError` failures with a matching code in the error channel of an effect.
+ * Other failures re-fail with their original cause. The `code` argument is
+ * suggested and restricted to the codes present in the error channel, and is
+ * unrestricted when the channel contains failure types like `Error` that can
+ * hold hidden `ORPCError` instances, whose data is unknown.
+ *
+ * Supports both data-first `catchORPCErrorCode(effect, code, handler)` and
+ * data-last `effect.pipe(catchORPCErrorCode(code, handler))` styles.
+ *
+ * @example
+ * ```ts
+ * declare const program: Effect.Effect<
+ *   string,
+ *   ORPCError<'NOT_FOUND', { id: string }> | ORPCError<'CONFLICT', undefined>
+ * >
+ *
+ * const recovered = program.pipe(
+ *   catchORPCErrorCode('NOT_FOUND', error => Effect.succeed(error.data.id)),
+ * )
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#catching-orpcerrors | Effect Integration - Catching ORPCErrors}
+ */
+declare const catchORPCErrorCode: {
+    <const TCode extends E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never, E, A2, E2, R2>(code: TCode, f: (error: E extends AnyORPCError ? Extract<E, ORPCError<TCode, any>> : AnyORPCError extends E ? ORPCError<TCode, unknown> : never) => Effect.Effect<A2, E2, R2>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E2 | Exclude<E, ORPCError<TCode, any>>, R | R2>;
+    <A, E, R, const TCode extends E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never, A2, E2, R2>(self: Effect.Effect<A, E, R>, code: TCode, f: (error: E extends AnyORPCError ? Extract<E, ORPCError<TCode, any>> : AnyORPCError extends E ? ORPCError<TCode, unknown> : never) => Effect.Effect<A2, E2, R2>): Effect.Effect<A | A2, E2 | Exclude<E, ORPCError<TCode, any>>, R | R2>;
+};
+/**
+ * Recovers from `ORPCError` failures using a map of codes to handlers in the
+ * error channel of an effect. Other failures re-fail with their original
+ * cause. The keys are suggested and restricted to the codes present in the
+ * error channel, and are unrestricted when the channel contains failure types
+ * like `Error` that can hold hidden `ORPCError` instances, whose data is unknown.
+ *
+ * Supports both data-first `catchORPCErrorCodes(effect, cases)` and data-last
+ * `effect.pipe(catchORPCErrorCodes(cases))` styles.
+ *
+ * @example
+ * ```ts
+ * declare const program: Effect.Effect<
+ *   string,
+ *   ORPCError<'NOT_FOUND', { id: string }> | ORPCError<'CONFLICT', undefined>
+ * >
+ *
+ * const recovered = program.pipe(
+ *   catchORPCErrorCodes({
+ *     NOT_FOUND: error => Effect.succeed(error.data.id),
+ *     CONFLICT: error => Effect.succeed(error.message),
+ *   }),
+ * )
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#catching-orpcerrors | Effect Integration - Catching ORPCErrors}
+ */
+declare const catchORPCErrorCodes: {
+    <E, Cases extends {
+        [K in E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never]?: string extends K ? (error: never) => Effect.Effect<any, any, any> : K extends infer C extends ORPCErrorCode ? (error: E extends AnyORPCError ? Extract<E, ORPCError<C, any>> : AnyORPCError extends E ? ORPCError<C, unknown> : never) => Effect.Effect<any, any, any> : never;
+    } & {
+        [K in Exclude<keyof Cases, E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never>]: never;
+    }>(cases: Cases): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<infer A2, any, any> ? A2 : never;
+    }[keyof Cases], Exclude<E, ORPCError<keyof Cases & ORPCErrorCode, any>> | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<any, infer E2, any> ? E2 : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<any, any, infer R2> ? R2 : never;
+    }[keyof Cases]>;
+    <A, E, R, Cases extends {
+        [K in E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never]?: string extends K ? (error: never) => Effect.Effect<any, any, any> : K extends infer C extends ORPCErrorCode ? (error: E extends AnyORPCError ? Extract<E, ORPCError<C, any>> : AnyORPCError extends E ? ORPCError<C, unknown> : never) => Effect.Effect<any, any, any> : never;
+    } & {
+        [K in Exclude<keyof Cases, E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never>]: never;
+    }>(self: Effect.Effect<A, E, R>, cases: Cases): Effect.Effect<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<infer A2, any, any> ? A2 : never;
+    }[keyof Cases], Exclude<E, ORPCError<keyof Cases & ORPCErrorCode, any>> | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<any, infer E2, any> ? E2 : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<any, any, infer R2> ? R2 : never;
+    }[keyof Cases]>;
+};
+
+interface MiddlewareGenNext<TOutput> {
+    <U extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<U>>): Effect.Effect<Awaited<MiddlewareResult<U, TOutput>>, unknown>;
+}
+interface MiddlewareGenOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> extends Omit<MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap>, 'next'> {
+    next: MiddlewareGenNext<TOutput>;
+}
+interface MiddlewareGen<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TYield extends Effect.Effect<any, any, InferEffectServices<TInContext>>, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    (opts: MiddlewareGenOptions<TInContext, TOutput, TErrorConstructorMap>, input: TInput, done: MiddlewareDone<TOutput>): Generator<TYield, MiddlewareResult<TOutContext, TOutput>, never>;
+}
+type AnyMiddlewareGen = MiddlewareGen<any, any, any, any, any, any>;
+/**
+ * Creates an oRPC middleware from an Effect generator function.
+ * Inside the generator you can yield Effect operations and `yield* next()`
+ * to continue the chain, and `middlewareGen` handles the execution and
+ * error handling for you.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#effectful-middleware | Effect Integration - Effectful Middleware}
  */
-declare function extractErrorFromCause(cause: Cause.Cause<unknown>): unknown;
+declare function middlewareGen<TInContext extends Context, TOutContext extends Context = object, TInput = unknown, TOutput = any, // TOutput = any by default is important to make middleware can be used in any output by default
+TErrorMap extends ErrorMap = Record<never, never>, TYield extends Effect.Effect<any, any, InferEffectServices<TInContext>> = Effect.Effect<any, any, InferEffectServices<TInContext>>>(middleware: MiddlewareGen<TInContext, TOutContext, TInput, TOutput, TYield, ORPCErrorConstructorMap<TErrorMap>>): Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>;
+
 interface RunPromiseOptions {
     signal?: undefined | AbortSignal;
 }
 /**
- * Runs an Effect as a Promise while re-throwing the original error directly,
- * bypassing Effect.runPromise's FiberFailure wrapper.
+ * Runs an Effect as a Promise and throws the most meaningful errors.
  */
 declare function runPromise<T>(effect: Effect.Effect<T, unknown>, options?: RunPromiseOptions): Promise<T>;
 
-declare function toStandardSchema<A, I>(schema: Schema.Schema<A, I>): Schema$1<I, A>;
+declare function toStandardSchema<S extends Schema.ConstraintDecoder<any>>(schema: S): Schema$1<S['Encoded'], S['Type']> & S;
 
-export { EffectSchemaToJsonSchemaConverter, extractErrorFromCause, runPromise, toStandardSchema };
-export type { RunPromiseOptions };
+export { EffectSchemaToJsonSchemaConverter, InferEffectServices, catchORPCError, catchORPCErrorCode, catchORPCErrorCodes, createEffectClient, middlewareGen, runPromise, toStandardSchema };
+export type { AnyMiddlewareGen, EffectClient, MiddlewareGen, MiddlewareGenNext, MiddlewareGenOptions, RunPromiseOptions };

package/dist/index.d.ts

@@ -1,30 +1,172 @@
-export { H as HandlerGen, I as InferYieldError, W as WithEffectContext, h as handlerGen } from './shared/experimental-effect.CuTs7Ks0.js';
-import { AnySchema, Schema as Schema$1 } from '@orpc/contract';
+import { AnyNestedClient, Client, ClientRest } from '@orpc/client';
+import { Effect, Schema } from 'effect';
+import { I as InferEffectServices } from './shared/experimental-effect.D0zFxpKr.js';
+export { H as HandlerGen, a as InferYieldError, W as WithEffectContext, h as handlerGen } from './shared/experimental-effect.D0zFxpKr.js';
+import { AnySchema, ErrorMap, Schema as Schema$1 } from '@orpc/contract';
 import { JsonSchemaConverter, JsonSchemaConverterDirection, JsonSchema } from '@orpc/json-schema';
-import { Cause, Effect, Schema } from 'effect';
-import '@orpc/server';
-import 'effect/Utils';
+import { AnyORPCError, ORPCError, ORPCErrorCode, Context, ORPCErrorConstructorMap, MiddlewareOptions, MiddlewareNextOptions, MiddlewareResult, MiddlewareDone, Middleware } from '@orpc/server';
+import { MaybeOptionalOptions } from '@orpc/shared';
 
+type EffectClient<T extends AnyNestedClient> = T extends Client<infer UContext, infer UInput, infer UOutput, infer UError> ? (...rest: ClientRest<UContext, UInput>) => Effect.Effect<UOutput, UError> : {
+    [K in keyof T]: T[K] extends AnyNestedClient ? EffectClient<T[K]> : never;
+};
+/**
+ * Creates a client whose procedures return lazy effects instead of promises,
+ * so you can `yield*` calls inside Effect generators. Errors are captured in
+ * the error channel with their original types preserved, and interrupting an
+ * effect aborts the underlying call.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#client-calls | Effect Integration - Client Calls}
+ */
+declare function createEffectClient<T extends AnyNestedClient>(client: T): EffectClient<T>;
+
+/**
+ * A JSON Schema converter for Effect Schema, built on top of
+ * [Effect Schema to JSON Schema](https://effect.website/docs/schema/json-schema/).
+ * Useful with tools such as the OpenAPI Generator.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#json-schema-converter | Effect Integration - JSON Schema Converter}
+ */
 declare class EffectSchemaToJsonSchemaConverter implements JsonSchemaConverter {
+    private readonly converter;
     condition(schema: AnySchema | undefined, _direction: JsonSchemaConverterDirection): boolean;
     convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
 }
 
 /**
- * Extracts the most meaningful original error from an Effect Cause,
- * preserving the original error instance wherever possible.
+ * Recovers from `ORPCError` failures in the error channel of an effect.
+ * Other failures re-fail with their original cause. Because failure types
+ * like `Error` can also hold `ORPCError` instances at runtime, the handler
+ * can also receive such hidden errors with unknown code and data.
+ *
+ * Supports both data-first `catchORPCError(effect, handler)` and data-last
+ * `effect.pipe(catchORPCError(handler))` styles.
+ *
+ * @example
+ * ```ts
+ * declare const program: Effect.Effect<string, ORPCError<'NOT_FOUND', undefined> | TypeError>
+ *
+ * const recovered = program.pipe(
+ *   catchORPCError(error => Effect.succeed(`caught ${error.code}`)),
+ * )
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#catching-orpcerrors | Effect Integration - Catching ORPCErrors}
+ */
+declare const catchORPCError: {
+    <E, A2, E2, R2>(f: (error: E extends AnyORPCError ? E : AnyORPCError extends E ? ORPCError<ORPCErrorCode, unknown> : never) => Effect.Effect<A2, E2, R2>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E2 | Exclude<E, AnyORPCError>, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Effect.Effect<A, E, R>, f: (error: E extends AnyORPCError ? E : AnyORPCError extends E ? ORPCError<ORPCErrorCode, unknown> : never) => Effect.Effect<A2, E2, R2>): Effect.Effect<A | A2, E2 | Exclude<E, AnyORPCError>, R | R2>;
+};
+/**
+ * Recovers from `ORPCError` failures with a matching code in the error channel of an effect.
+ * Other failures re-fail with their original cause. The `code` argument is
+ * suggested and restricted to the codes present in the error channel, and is
+ * unrestricted when the channel contains failure types like `Error` that can
+ * hold hidden `ORPCError` instances, whose data is unknown.
+ *
+ * Supports both data-first `catchORPCErrorCode(effect, code, handler)` and
+ * data-last `effect.pipe(catchORPCErrorCode(code, handler))` styles.
+ *
+ * @example
+ * ```ts
+ * declare const program: Effect.Effect<
+ *   string,
+ *   ORPCError<'NOT_FOUND', { id: string }> | ORPCError<'CONFLICT', undefined>
+ * >
+ *
+ * const recovered = program.pipe(
+ *   catchORPCErrorCode('NOT_FOUND', error => Effect.succeed(error.data.id)),
+ * )
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#catching-orpcerrors | Effect Integration - Catching ORPCErrors}
+ */
+declare const catchORPCErrorCode: {
+    <const TCode extends E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never, E, A2, E2, R2>(code: TCode, f: (error: E extends AnyORPCError ? Extract<E, ORPCError<TCode, any>> : AnyORPCError extends E ? ORPCError<TCode, unknown> : never) => Effect.Effect<A2, E2, R2>): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E2 | Exclude<E, ORPCError<TCode, any>>, R | R2>;
+    <A, E, R, const TCode extends E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never, A2, E2, R2>(self: Effect.Effect<A, E, R>, code: TCode, f: (error: E extends AnyORPCError ? Extract<E, ORPCError<TCode, any>> : AnyORPCError extends E ? ORPCError<TCode, unknown> : never) => Effect.Effect<A2, E2, R2>): Effect.Effect<A | A2, E2 | Exclude<E, ORPCError<TCode, any>>, R | R2>;
+};
+/**
+ * Recovers from `ORPCError` failures using a map of codes to handlers in the
+ * error channel of an effect. Other failures re-fail with their original
+ * cause. The keys are suggested and restricted to the codes present in the
+ * error channel, and are unrestricted when the channel contains failure types
+ * like `Error` that can hold hidden `ORPCError` instances, whose data is unknown.
+ *
+ * Supports both data-first `catchORPCErrorCodes(effect, cases)` and data-last
+ * `effect.pipe(catchORPCErrorCodes(cases))` styles.
+ *
+ * @example
+ * ```ts
+ * declare const program: Effect.Effect<
+ *   string,
+ *   ORPCError<'NOT_FOUND', { id: string }> | ORPCError<'CONFLICT', undefined>
+ * >
+ *
+ * const recovered = program.pipe(
+ *   catchORPCErrorCodes({
+ *     NOT_FOUND: error => Effect.succeed(error.data.id),
+ *     CONFLICT: error => Effect.succeed(error.message),
+ *   }),
+ * )
+ * ```
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#catching-orpcerrors | Effect Integration - Catching ORPCErrors}
+ */
+declare const catchORPCErrorCodes: {
+    <E, Cases extends {
+        [K in E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never]?: string extends K ? (error: never) => Effect.Effect<any, any, any> : K extends infer C extends ORPCErrorCode ? (error: E extends AnyORPCError ? Extract<E, ORPCError<C, any>> : AnyORPCError extends E ? ORPCError<C, unknown> : never) => Effect.Effect<any, any, any> : never;
+    } & {
+        [K in Exclude<keyof Cases, E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never>]: never;
+    }>(cases: Cases): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<infer A2, any, any> ? A2 : never;
+    }[keyof Cases], Exclude<E, ORPCError<keyof Cases & ORPCErrorCode, any>> | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<any, infer E2, any> ? E2 : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<any, any, infer R2> ? R2 : never;
+    }[keyof Cases]>;
+    <A, E, R, Cases extends {
+        [K in E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never]?: string extends K ? (error: never) => Effect.Effect<any, any, any> : K extends infer C extends ORPCErrorCode ? (error: E extends AnyORPCError ? Extract<E, ORPCError<C, any>> : AnyORPCError extends E ? ORPCError<C, unknown> : never) => Effect.Effect<any, any, any> : never;
+    } & {
+        [K in Exclude<keyof Cases, E extends ORPCError<infer TCode, any> ? TCode : AnyORPCError extends E ? ORPCErrorCode : never>]: never;
+    }>(self: Effect.Effect<A, E, R>, cases: Cases): Effect.Effect<A | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<infer A2, any, any> ? A2 : never;
+    }[keyof Cases], Exclude<E, ORPCError<keyof Cases & ORPCErrorCode, any>> | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<any, infer E2, any> ? E2 : never;
+    }[keyof Cases], R | {
+        [K in keyof Cases]: Cases[K] extends (...args: any[]) => Effect.Effect<any, any, infer R2> ? R2 : never;
+    }[keyof Cases]>;
+};
+
+interface MiddlewareGenNext<TOutput> {
+    <U extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<U>>): Effect.Effect<Awaited<MiddlewareResult<U, TOutput>>, unknown>;
+}
+interface MiddlewareGenOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> extends Omit<MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap>, 'next'> {
+    next: MiddlewareGenNext<TOutput>;
+}
+interface MiddlewareGen<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TYield extends Effect.Effect<any, any, InferEffectServices<TInContext>>, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    (opts: MiddlewareGenOptions<TInContext, TOutput, TErrorConstructorMap>, input: TInput, done: MiddlewareDone<TOutput>): Generator<TYield, MiddlewareResult<TOutContext, TOutput>, never>;
+}
+type AnyMiddlewareGen = MiddlewareGen<any, any, any, any, any, any>;
+/**
+ * Creates an oRPC middleware from an Effect generator function.
+ * Inside the generator you can yield Effect operations and `yield* next()`
+ * to continue the chain, and `middlewareGen` handles the execution and
+ * error handling for you.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#effectful-middleware | Effect Integration - Effectful Middleware}
  */
-declare function extractErrorFromCause(cause: Cause.Cause<unknown>): unknown;
+declare function middlewareGen<TInContext extends Context, TOutContext extends Context = object, TInput = unknown, TOutput = any, // TOutput = any by default is important to make middleware can be used in any output by default
+TErrorMap extends ErrorMap = Record<never, never>, TYield extends Effect.Effect<any, any, InferEffectServices<TInContext>> = Effect.Effect<any, any, InferEffectServices<TInContext>>>(middleware: MiddlewareGen<TInContext, TOutContext, TInput, TOutput, TYield, ORPCErrorConstructorMap<TErrorMap>>): Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>;
+
 interface RunPromiseOptions {
     signal?: undefined | AbortSignal;
 }
 /**
- * Runs an Effect as a Promise while re-throwing the original error directly,
- * bypassing Effect.runPromise's FiberFailure wrapper.
+ * Runs an Effect as a Promise and throws the most meaningful errors.
  */
 declare function runPromise<T>(effect: Effect.Effect<T, unknown>, options?: RunPromiseOptions): Promise<T>;
 
-declare function toStandardSchema<A, I>(schema: Schema.Schema<A, I>): Schema$1<I, A>;
+declare function toStandardSchema<S extends Schema.ConstraintDecoder<any>>(schema: S): Schema$1<S['Encoded'], S['Type']> & S;
 
-export { EffectSchemaToJsonSchemaConverter, extractErrorFromCause, runPromise, toStandardSchema };
-export type { RunPromiseOptions };
+export { EffectSchemaToJsonSchemaConverter, InferEffectServices, catchORPCError, catchORPCErrorCode, catchORPCErrorCodes, createEffectClient, middlewareGen, runPromise, toStandardSchema };
+export type { AnyMiddlewareGen, EffectClient, MiddlewareGen, MiddlewareGenNext, MiddlewareGenOptions, RunPromiseOptions };

package/dist/index.mjs

@@ -1,27 +1,97 @@
-import { JSONSchema } from 'effect';
-export { e as extractErrorFromCause, h as handlerGen, r as runPromise } from './shared/experimental-effect.dulfW-wX.mjs';
-export { t as toStandardSchema } from './shared/experimental-effect.B68ZlIzV.mjs';
-import '@orpc/server';
-import '@orpc/shared';
+import { RECURSIVE_CLIENT_UNWRAP_KEYS, resolveClientRest } from '@orpc/client';
+import { isTypescriptObject, anyAbortSignal, getOwn } from '@orpc/shared';
+import { Effect, Schema, Function, Context } from 'effect';
+import { StandardJsonSchemaConverter } from '@orpc/json-schema';
+import { ORPCError } from '@orpc/server';
+import { r as runPromise } from './shared/experimental-effect._sKLzweg.mjs';
+export { h as handlerGen } from './shared/experimental-effect._sKLzweg.mjs';
+export { t as toStandardSchema } from './shared/experimental-effect.YQKompVf.mjs';
 import '@orpc/contract';
 
+function callAsEffect(client, ...rest) {
+  const [input, options] = resolveClientRest(rest);
+  return Effect.tryPromise({
+    try: (signal) => client(input, {
+      ...options,
+      signal: anyAbortSignal([options.signal, signal])
+    }),
+    catch: (error) => error
+  });
+}
+function createEffectClient(client) {
+  const cache = /* @__PURE__ */ new Map();
+  const proxy = new Proxy((...rest) => callAsEffect(client, ...rest), {
+    get(target, prop) {
+      if (typeof prop !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(prop)) {
+        return Reflect.get(target, prop);
+      }
+      let effectClient = cache.get(prop);
+      if (effectClient === void 0) {
+        const value = client[prop];
+        if (!isTypescriptObject(value)) {
+          return value;
+        }
+        effectClient = createEffectClient(value);
+        cache.set(prop, effectClient);
+      }
+      return effectClient;
+    }
+  });
+  return proxy;
+}
+
 class EffectSchemaToJsonSchemaConverter {
+  converter = new StandardJsonSchemaConverter();
   condition(schema, _direction) {
     return schema?.["~standard"].vendor === "effect";
   }
   convert(schema, direction) {
     const effectSchema = schema;
-    const jsonSchema = JSONSchema.make(effectSchema, { target: "jsonSchema2020-12" });
-    let optional = false;
-    try {
-      const result = effectSchema["~standard"].validate(void 0);
-      if (!(result instanceof Promise) && !result.issues) {
-        optional = direction === "input" ? true : result.value === void 0;
-      }
-    } catch {
-    }
-    return [jsonSchema, optional];
+    const standardJsonSchema = Schema.toStandardJSONSchemaV1(effectSchema);
+    return this.converter.convert(standardJsonSchema, direction);
   }
 }
 
-export { EffectSchemaToJsonSchemaConverter };
+const catchORPCError = Function.dual(
+  2,
+  (self, f) => self.pipe(
+    Effect.catchIf((error) => error instanceof ORPCError, f)
+  )
+);
+const catchORPCErrorCode = Function.dual(
+  3,
+  (self, code, f) => self.pipe(
+    Effect.catchIf((error) => error instanceof ORPCError && error.code === code, f)
+  )
+);
+const catchORPCErrorCodes = Function.dual(
+  2,
+  (self, cases) => self.pipe(
+    Effect.catchIf(
+      (error) => error instanceof ORPCError && typeof getOwn(cases, error.code) === "function",
+      (error) => getOwn(cases, error.code)(error)
+    )
+  )
+);
+
+function middlewareGen(middleware) {
+  const mid = (opts, input, done) => {
+    const next = (...rest) => Effect.tryPromise({
+      try: async () => opts.next(...rest),
+      catch: (error) => error
+    });
+    let ef = Effect.gen(() => middleware({ ...opts, next }, input, done));
+    if (Context.isContext(opts.context["effect/context"])) {
+      ef = ef.pipe(Effect.provide(opts.context["effect/context"]));
+    }
+    if (typeof opts.context["effect/wrap"] === "function") {
+      const intercept = opts.context["effect/wrap"];
+      ef = intercept(ef, opts);
+    }
+    return runPromise(ef, { signal: opts.signal });
+  };
+  Object.defineProperty(mid, "name", { value: middleware.name });
+  return mid;
+}
+
+export { EffectSchemaToJsonSchemaConverter, catchORPCError, catchORPCErrorCode, catchORPCErrorCodes, createEffectClient, middlewareGen, runPromise };