@orpc/experimental-effect 2.0.0-beta.3 → 2.0.0-beta.31

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,130 @@
-export { H as HandlerGen, I as InferYieldError, W as WithEffectContext, h as handlerGen } from './shared/experimental-effect.CuTs7Ks0.mjs';
+export { H as HandlerGen, I as InferYieldError, W as WithEffectContext, h as handlerGen } from './shared/experimental-effect.BupPDCRJ.mjs';
 import { AnySchema, 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 } from '@orpc/server';
+import { Effect, Schema } from 'effect';
 
+/**
+ * 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.
+ *
+ * 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: Extract<E, AnyORPCError>) => 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: Extract<E, AnyORPCError>) => 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.
+ *
+ * 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> | TypeError
+ * >
+ *
+ * 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 function extractErrorFromCause(cause: Cause.Cause<unknown>): unknown;
+declare const catchORPCErrorCode: {
+    <const TCode extends E extends ORPCError<infer TCode, any> ? TCode : never, E, A2, E2, R2>(code: TCode, f: (error: Extract<E, ORPCError<TCode, any>>) => 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 : never, A2, E2, R2>(self: Effect.Effect<A, E, R>, code: TCode, f: (error: Extract<E, ORPCError<TCode, any>>) => 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.
+ *
+ * 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> | TypeError
+ * >
+ *
+ * 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 Extract<E, AnyORPCError>['code']]?: (error: Extract<E, ORPCError<K, any>>) => Effect.Effect<any, any, any>;
+    } & (unknown extends E ? object : {
+        [K in Exclude<keyof Cases, Extract<E, AnyORPCError>['code']>]: 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 Extract<E, AnyORPCError>['code']]?: (error: Extract<E, ORPCError<K, any>>) => Effect.Effect<any, any, any>;
+    } & (unknown extends E ? object : {
+        [K in Exclude<keyof Cases, Extract<E, AnyORPCError>['code']>]: 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 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 { EffectSchemaToJsonSchemaConverter, catchORPCError, catchORPCErrorCode, catchORPCErrorCodes, runPromise, toStandardSchema };
 export type { RunPromiseOptions };

package/dist/index.d.ts

@@ -1,30 +1,130 @@
-export { H as HandlerGen, I as InferYieldError, W as WithEffectContext, h as handlerGen } from './shared/experimental-effect.CuTs7Ks0.js';
+export { H as HandlerGen, I as InferYieldError, W as WithEffectContext, h as handlerGen } from './shared/experimental-effect.BupPDCRJ.js';
 import { AnySchema, 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 } from '@orpc/server';
+import { Effect, Schema } from 'effect';
 
+/**
+ * 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.
+ *
+ * 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: Extract<E, AnyORPCError>) => 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: Extract<E, AnyORPCError>) => 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.
+ *
+ * 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> | TypeError
+ * >
+ *
+ * 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 function extractErrorFromCause(cause: Cause.Cause<unknown>): unknown;
+declare const catchORPCErrorCode: {
+    <const TCode extends E extends ORPCError<infer TCode, any> ? TCode : never, E, A2, E2, R2>(code: TCode, f: (error: Extract<E, ORPCError<TCode, any>>) => 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 : never, A2, E2, R2>(self: Effect.Effect<A, E, R>, code: TCode, f: (error: Extract<E, ORPCError<TCode, any>>) => 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.
+ *
+ * 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> | TypeError
+ * >
+ *
+ * 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 Extract<E, AnyORPCError>['code']]?: (error: Extract<E, ORPCError<K, any>>) => Effect.Effect<any, any, any>;
+    } & (unknown extends E ? object : {
+        [K in Exclude<keyof Cases, Extract<E, AnyORPCError>['code']>]: 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 Extract<E, AnyORPCError>['code']]?: (error: Extract<E, ORPCError<K, any>>) => Effect.Effect<any, any, any>;
+    } & (unknown extends E ? object : {
+        [K in Exclude<keyof Cases, Extract<E, AnyORPCError>['code']>]: 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 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 { EffectSchemaToJsonSchemaConverter, catchORPCError, catchORPCErrorCode, catchORPCErrorCodes, runPromise, toStandardSchema };
 export type { RunPromiseOptions };

package/dist/index.mjs

@@ -1,27 +1,43 @@
-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 { StandardJsonSchemaConverter } from '@orpc/json-schema';
+import { Schema, Function, Effect } from 'effect';
+import { ORPCError } from '@orpc/server';
+import { getOwn } from '@orpc/shared';
+export { h as handlerGen, r as runPromise } from './shared/experimental-effect.C9oJcd5q.mjs';
+export { t as toStandardSchema } from './shared/experimental-effect.YQKompVf.mjs';
 import '@orpc/contract';
 
 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)
+    )
+  )
+);
+
+export { EffectSchemaToJsonSchemaConverter, catchORPCError, catchORPCErrorCode, catchORPCErrorCodes };

package/dist/shared/{experimental-effect.CuTs7Ks0.d.mts → experimental-effect.BupPDCRJ.d.mts}

@@ -1,7 +1,12 @@
 import { AnyProcedure, Context as Context$1, ORPCErrorConstructorMap, ProcedureHandlerOptions, ProcedureHandler, AnyORPCError } from '@orpc/server';
-import { YieldWrap } from 'effect/Utils';
 import { Context, Effect } from 'effect';
 
+/**
+ * A context shape that provides Effect services to effectful handlers
+ * through the oRPC context in a typesafe way.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#effect-services | Effect Integration - Effect Services}
+ */
 interface WithEffectContext<Services> {
     /**
      * A pre-built Effect context providing the services available within this oRPC context.
@@ -14,13 +19,13 @@ interface WithEffectContext<Services> {
      * interface ServerContext extends WithEffectContext<Random | Logger> {}
      *
      * const context: ServerContext = {
-     *   '~effect/context': Context.empty().pipe(
+     *   'effect/context': Context.empty().pipe(
      *     Context.add(Random, { next: Effect.sync(() => Math.random()) }),
      *   ),
      * }
      * ```
      */
-    ['~effect/context']: Context.Context<Services>;
+    ['effect/context']: Context.Context<Services>;
     /**
      * An optional hook to wrap any effect before it is executed within this oRPC context.
      * Useful for adding observability, tracing, or error handling.
@@ -37,23 +42,30 @@ interface WithEffectContext<Services> {
      * )
      *
      * const context: ServerContext = {
-     *   '~effect/context': Context.empty(),
-     *   '~effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
+     *   'effect/context': Context.empty(),
+     *   'effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
      * }
      * ```
      */
-    ['~effect/wrap']?: <A, E>(effect: Effect.Effect<A, E>, opts: {
+    ['effect/wrap']?: <A, E>(effect: Effect.Effect<A, E>, opts: {
         path: string[];
         procedure: AnyProcedure;
         signal?: undefined | AbortSignal;
     }) => Effect.Effect<A, E>;
 }
 
-type InferYieldError<Eff> = [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E : never;
-interface HandlerGen<TCurrentContext extends Context$1, TInput, TYield extends YieldWrap<Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>>, TReturn, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+type InferYieldError<Eff> = [Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never;
+interface HandlerGen<TCurrentContext extends Context$1, TInput, TYield extends Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>, TReturn, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
     (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Generator<TYield, TReturn, never>;
 }
-declare function handlerGen<TCurrentContext extends Context$1, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TYield extends YieldWrap<Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>>, TReturn>(handler: HandlerGen<TCurrentContext, TInput, TYield, TReturn, TErrorConstructorMap>): ProcedureHandler<TCurrentContext, TInput, TReturn | Extract<InferYieldError<TYield>, AnyORPCError>, TErrorConstructorMap>;
+/**
+ * Creates a procedure handler from an Effect generator function.
+ * Inside the generator you can yield Effect operations, and `handlerGen`
+ * handles the execution and error handling for you.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#effectful-handlers | Effect Integration - Effectful Handlers}
+ */
+declare function handlerGen<TCurrentContext extends Context$1, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TYield extends Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>, TReturn>(handler: HandlerGen<TCurrentContext, TInput, TYield, TReturn, TErrorConstructorMap>): ProcedureHandler<TCurrentContext, TInput, TReturn | Extract<InferYieldError<TYield>, AnyORPCError>, TErrorConstructorMap>;
 
 export { handlerGen as h };
 export type { HandlerGen as H, InferYieldError as I, WithEffectContext as W };

package/dist/shared/{experimental-effect.CuTs7Ks0.d.ts → experimental-effect.BupPDCRJ.d.ts}

@@ -1,7 +1,12 @@
 import { AnyProcedure, Context as Context$1, ORPCErrorConstructorMap, ProcedureHandlerOptions, ProcedureHandler, AnyORPCError } from '@orpc/server';
-import { YieldWrap } from 'effect/Utils';
 import { Context, Effect } from 'effect';
 
+/**
+ * A context shape that provides Effect services to effectful handlers
+ * through the oRPC context in a typesafe way.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#effect-services | Effect Integration - Effect Services}
+ */
 interface WithEffectContext<Services> {
     /**
      * A pre-built Effect context providing the services available within this oRPC context.
@@ -14,13 +19,13 @@ interface WithEffectContext<Services> {
      * interface ServerContext extends WithEffectContext<Random | Logger> {}
      *
      * const context: ServerContext = {
-     *   '~effect/context': Context.empty().pipe(
+     *   'effect/context': Context.empty().pipe(
      *     Context.add(Random, { next: Effect.sync(() => Math.random()) }),
      *   ),
      * }
      * ```
      */
-    ['~effect/context']: Context.Context<Services>;
+    ['effect/context']: Context.Context<Services>;
     /**
      * An optional hook to wrap any effect before it is executed within this oRPC context.
      * Useful for adding observability, tracing, or error handling.
@@ -37,23 +42,30 @@ interface WithEffectContext<Services> {
      * )
      *
      * const context: ServerContext = {
-     *   '~effect/context': Context.empty(),
-     *   '~effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
+     *   'effect/context': Context.empty(),
+     *   'effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
      * }
      * ```
      */
-    ['~effect/wrap']?: <A, E>(effect: Effect.Effect<A, E>, opts: {
+    ['effect/wrap']?: <A, E>(effect: Effect.Effect<A, E>, opts: {
         path: string[];
         procedure: AnyProcedure;
         signal?: undefined | AbortSignal;
     }) => Effect.Effect<A, E>;
 }
 
-type InferYieldError<Eff> = [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E : never;
-interface HandlerGen<TCurrentContext extends Context$1, TInput, TYield extends YieldWrap<Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>>, TReturn, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+type InferYieldError<Eff> = [Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never;
+interface HandlerGen<TCurrentContext extends Context$1, TInput, TYield extends Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>, TReturn, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
     (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Generator<TYield, TReturn, never>;
 }
-declare function handlerGen<TCurrentContext extends Context$1, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TYield extends YieldWrap<Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>>, TReturn>(handler: HandlerGen<TCurrentContext, TInput, TYield, TReturn, TErrorConstructorMap>): ProcedureHandler<TCurrentContext, TInput, TReturn | Extract<InferYieldError<TYield>, AnyORPCError>, TErrorConstructorMap>;
+/**
+ * Creates a procedure handler from an Effect generator function.
+ * Inside the generator you can yield Effect operations, and `handlerGen`
+ * handles the execution and error handling for you.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#effectful-handlers | Effect Integration - Effectful Handlers}
+ */
+declare function handlerGen<TCurrentContext extends Context$1, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TYield extends Effect.Effect<any, any, TCurrentContext extends WithEffectContext<infer S> ? S : never>, TReturn>(handler: HandlerGen<TCurrentContext, TInput, TYield, TReturn, TErrorConstructorMap>): ProcedureHandler<TCurrentContext, TInput, TReturn | Extract<InferYieldError<TYield>, AnyORPCError>, TErrorConstructorMap>;
 
 export { handlerGen as h };
 export type { HandlerGen as H, InferYieldError as I, WithEffectContext as W };

package/dist/shared/experimental-effect.C9oJcd5q.mjs

@@ -0,0 +1,34 @@
+import { ORPCError } from '@orpc/server';
+import { Effect, Exit, Cause, Context } from 'effect';
+import { AbortError } from '@orpc/shared';
+
+async function runPromise(effect, options = {}) {
+  const exit = await Effect.runPromiseExit(effect, options);
+  if (Exit.isSuccess(exit)) {
+    return exit.value;
+  }
+  if (Cause.hasInterruptsOnly(exit.cause)) {
+    if (options.signal?.aborted) {
+      throw options.signal.reason;
+    }
+    throw new AbortError("All fibers interrupted without error");
+  }
+  throw Cause.squash(exit.cause);
+}
+
+const succeedOnORPCError = Effect.catch((error) => error instanceof ORPCError ? Effect.succeed(error) : Effect.fail(error));
+function handlerGen(handler) {
+  return (opts, input) => {
+    let ef = Effect.gen(() => handler(opts, input)).pipe(succeedOnORPCError);
+    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 });
+  };
+}
+
+export { handlerGen as h, runPromise as r };

package/dist/shared/{experimental-effect.B68ZlIzV.mjs → experimental-effect.YQKompVf.mjs}

@@ -2,7 +2,7 @@ import { getHiddenMetaPlugins, setHiddenMetaPlugins } from '@orpc/contract';
 import { Schema } from 'effect';
 
 function toStandardSchema(schema) {
-  const converted = Schema.standardSchemaV1(schema);
+  const converted = Schema.toStandardSchemaV1(schema);
   const metaPlugins = getHiddenMetaPlugins(schema);
   if (metaPlugins) {
     setHiddenMetaPlugins(converted, metaPlugins);

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@orpc/experimental-effect",
   "type": "module",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.31",
+  "description": "Effect integration for oRPC: build typesafe procedures with Effect",
   "license": "MIT",
+  "funding": [
+    "https://github.com/sponsors/dinwwwh",
+    "https://opencollective.com/middleapi"
+  ],
   "homepage": "https://orpc.dev",
   "repository": {
     "type": "git",
@@ -11,7 +16,11 @@
   },
   "keywords": [
     "orpc",
-    "effect"
+    "effect",
+    "effect-ts",
+    "rpc",
+    "typescript",
+    "typesafe"
   ],
   "sideEffects": [
     "./dist/extensions/effect.mjs",
@@ -39,16 +48,16 @@
     "dist"
   ],
   "peerDependencies": {
-    "effect": ">=3.21.2"
+    "effect": ">=4.0.0-beta.90"
   },
   "dependencies": {
-    "@orpc/json-schema": "2.0.0-beta.3",
-    "@orpc/shared": "2.0.0-beta.3",
-    "@orpc/contract": "2.0.0-beta.3",
-    "@orpc/server": "2.0.0-beta.3"
+    "@orpc/contract": "2.0.0-beta.31",
+    "@orpc/server": "2.0.0-beta.31",
+    "@orpc/json-schema": "2.0.0-beta.31",
+    "@orpc/shared": "2.0.0-beta.31"
   },
   "devDependencies": {
-    "effect": "^3.21.3"
+    "effect": "4.0.0-rc.109"
   },
   "scripts": {
     "build": "unbuild",

package/dist/shared/experimental-effect.dulfW-wX.mjs

@@ -1,40 +0,0 @@
-import { ORPCError } from '@orpc/server';
-import { Effect, Exit, Cause, FiberId, Context } from 'effect';
-import { AbortError } from '@orpc/shared';
-
-function extractErrorFromCause(cause) {
-  return Cause.match(cause, {
-    onFail: (error) => error,
-    onDie: (defect) => defect,
-    onInterrupt: (fiberId) => new AbortError(`Fiber interrupted: ${FiberId.threadName(fiberId)}`),
-    onEmpty: new Error("Effect failed with no error information"),
-    // Mirrors native try/finally: if the finalizer (right) also throws,
-    // it overwrites the original (left) — same behaviour as JS would produce
-    onSequential: (_left, right) => right,
-    onParallel: (left, _right) => left
-  });
-}
-async function runPromise(effect, options = {}) {
-  const exit = await Effect.runPromiseExit(effect, options);
-  if (Exit.isSuccess(exit)) {
-    return exit.value;
-  }
-  throw extractErrorFromCause(exit.cause);
-}
-
-const succeedOnORPCError = Effect.catchAll((error) => error instanceof ORPCError ? Effect.succeed(error) : Effect.fail(error));
-function handlerGen(handler) {
-  return (opts, input) => {
-    let ef = Effect.gen(() => handler(opts, input)).pipe(succeedOnORPCError);
-    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 });
-  };
-}
-
-export { extractErrorFromCause as e, handlerGen as h, runPromise as r };