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

package/dist/shared/experimental-effect.D0zFxpKr.d.mts

@@ -0,0 +1,77 @@
+import { Context, AnyProcedure, ORPCErrorConstructorMap, ProcedureHandlerOptions, ProcedureHandler } from '@orpc/server';
+import { Context as Context$1, 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.
+     * Automatically provided to any effect that runs under this context.
+     *
+     * @example
+     * ```ts
+     * import { Context } from 'effect'
+     *
+     * interface ServerContext extends WithEffectContext<Random | Logger> {}
+     *
+     * const context: ServerContext = {
+     *   'effect/context': Context.empty().pipe(
+     *     Context.add(Random, { next: Effect.sync(() => Math.random()) }),
+     *   ),
+     * }
+     * ```
+     */
+    ['effect/context']: Context$1.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.
+     *
+     * @example
+     * ```ts
+     * import { Resource, Tracer } from '@effect/opentelemetry'
+     * import { Context, Effect, Layer } from 'effect'
+     *
+     * interface ServerContext extends WithEffectContext<never> {}
+     *
+     * const TracingLive = Tracer.layerGlobal.pipe(
+     *   Layer.provide(Resource.layerFromEnv()),
+     * )
+     *
+     * const context: ServerContext = {
+     *   'effect/context': Context.empty(),
+     *   'effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
+     * }
+     * ```
+     */
+    ['effect/wrap']?: <A, E>(effect: Effect.Effect<A, E>, opts: {
+        path: string[];
+        procedure: AnyProcedure;
+        signal?: undefined | AbortSignal;
+    }) => Effect.Effect<A, E>;
+}
+/**
+ * Infers the Effect services available in an oRPC context that extends `WithEffectContext`.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#effect-services | Effect Integration - Effect Services}
+ */
+type InferEffectServices<T extends Context> = T extends WithEffectContext<infer Services> ? Services : never;
+
+type InferYieldError<Eff> = [Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never;
+interface HandlerGen<TCurrentContext extends Context, TInput, TYield extends Effect.Effect<any, any, InferEffectServices<TCurrentContext>>, TReturn, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Generator<TYield, TReturn, never>;
+}
+/**
+ * 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, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TYield extends Effect.Effect<any, any, InferEffectServices<TCurrentContext>>, TReturn>(handler: HandlerGen<TCurrentContext, TInput, TYield, TReturn, TErrorConstructorMap>): ProcedureHandler<TCurrentContext, TInput, TReturn, TErrorConstructorMap>;
+
+export { handlerGen as h };
+export type { HandlerGen as H, InferEffectServices as I, WithEffectContext as W, InferYieldError as a };

package/dist/shared/experimental-effect.D0zFxpKr.d.ts

@@ -0,0 +1,77 @@
+import { Context, AnyProcedure, ORPCErrorConstructorMap, ProcedureHandlerOptions, ProcedureHandler } from '@orpc/server';
+import { Context as Context$1, 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.
+     * Automatically provided to any effect that runs under this context.
+     *
+     * @example
+     * ```ts
+     * import { Context } from 'effect'
+     *
+     * interface ServerContext extends WithEffectContext<Random | Logger> {}
+     *
+     * const context: ServerContext = {
+     *   'effect/context': Context.empty().pipe(
+     *     Context.add(Random, { next: Effect.sync(() => Math.random()) }),
+     *   ),
+     * }
+     * ```
+     */
+    ['effect/context']: Context$1.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.
+     *
+     * @example
+     * ```ts
+     * import { Resource, Tracer } from '@effect/opentelemetry'
+     * import { Context, Effect, Layer } from 'effect'
+     *
+     * interface ServerContext extends WithEffectContext<never> {}
+     *
+     * const TracingLive = Tracer.layerGlobal.pipe(
+     *   Layer.provide(Resource.layerFromEnv()),
+     * )
+     *
+     * const context: ServerContext = {
+     *   'effect/context': Context.empty(),
+     *   'effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
+     * }
+     * ```
+     */
+    ['effect/wrap']?: <A, E>(effect: Effect.Effect<A, E>, opts: {
+        path: string[];
+        procedure: AnyProcedure;
+        signal?: undefined | AbortSignal;
+    }) => Effect.Effect<A, E>;
+}
+/**
+ * Infers the Effect services available in an oRPC context that extends `WithEffectContext`.
+ *
+ * @see {@link https://orpc.dev/docs/integrations/effect#effect-services | Effect Integration - Effect Services}
+ */
+type InferEffectServices<T extends Context> = T extends WithEffectContext<infer Services> ? Services : never;
+
+type InferYieldError<Eff> = [Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never;
+interface HandlerGen<TCurrentContext extends Context, TInput, TYield extends Effect.Effect<any, any, InferEffectServices<TCurrentContext>>, TReturn, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Generator<TYield, TReturn, never>;
+}
+/**
+ * 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, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TYield extends Effect.Effect<any, any, InferEffectServices<TCurrentContext>>, TReturn>(handler: HandlerGen<TCurrentContext, TInput, TYield, TReturn, TErrorConstructorMap>): ProcedureHandler<TCurrentContext, TInput, TReturn, TErrorConstructorMap>;
+
+export { handlerGen as h };
+export type { HandlerGen as H, InferEffectServices as I, WithEffectContext as W, InferYieldError as a };

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/dist/shared/experimental-effect._sKLzweg.mjs

@@ -0,0 +1,32 @@
+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);
+}
+
+function handlerGen(handler) {
+  return (opts, input) => {
+    let ef = Effect.gen(() => handler(opts, input));
+    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/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@orpc/experimental-effect",
   "type": "module",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.41",
+  "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,19 +48,19 @@
     "dist"
   ],
   "peerDependencies": {
-    "effect": ">=3.21.2"
+    "effect": ">=4.0.0"
   },
   "dependencies": {
-    "@orpc/contract": "2.0.0-beta.4",
-    "@orpc/json-schema": "2.0.0-beta.4",
-    "@orpc/server": "2.0.0-beta.4",
-    "@orpc/shared": "2.0.0-beta.4"
+    "@orpc/client": "2.0.0-beta.41",
+    "@orpc/contract": "2.0.0-beta.41",
+    "@orpc/json-schema": "2.0.0-beta.41",
+    "@orpc/server": "2.0.0-beta.41",
+    "@orpc/shared": "2.0.0-beta.41"
   },
   "devDependencies": {
-    "effect": "^3.21.3"
+    "effect": "^4.0.0"
   },
   "scripts": {
-    "build": "unbuild",
     "type:check": "tsc -b"
   }
 }

package/dist/shared/experimental-effect.CuTs7Ks0.d.mts

@@ -1,59 +0,0 @@
-import { AnyProcedure, Context as Context$1, ORPCErrorConstructorMap, ProcedureHandlerOptions, ProcedureHandler, AnyORPCError } from '@orpc/server';
-import { YieldWrap } from 'effect/Utils';
-import { Context, Effect } from 'effect';
-
-interface WithEffectContext<Services> {
-    /**
-     * A pre-built Effect context providing the services available within this oRPC context.
-     * Automatically provided to any effect that runs under this context.
-     *
-     * @example
-     * ```ts
-     * import { Context } from 'effect'
-     *
-     * interface ServerContext extends WithEffectContext<Random | Logger> {}
-     *
-     * const context: ServerContext = {
-     *   '~effect/context': Context.empty().pipe(
-     *     Context.add(Random, { next: Effect.sync(() => Math.random()) }),
-     *   ),
-     * }
-     * ```
-     */
-    ['~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.
-     *
-     * @example
-     * ```ts
-     * import { Resource, Tracer } from '@effect/opentelemetry'
-     * import { Context, Effect, Layer } from 'effect'
-     *
-     * interface ServerContext extends WithEffectContext<never> {}
-     *
-     * const TracingLive = Tracer.layerGlobal.pipe(
-     *   Layer.provide(Resource.layerFromEnv()),
-     * )
-     *
-     * const context: ServerContext = {
-     *   '~effect/context': Context.empty(),
-     *   '~effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
-     * }
-     * ```
-     */
-    ['~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>> {
-    (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>;
-
-export { handlerGen as h };
-export type { HandlerGen as H, InferYieldError as I, WithEffectContext as W };

package/dist/shared/experimental-effect.CuTs7Ks0.d.ts

@@ -1,59 +0,0 @@
-import { AnyProcedure, Context as Context$1, ORPCErrorConstructorMap, ProcedureHandlerOptions, ProcedureHandler, AnyORPCError } from '@orpc/server';
-import { YieldWrap } from 'effect/Utils';
-import { Context, Effect } from 'effect';
-
-interface WithEffectContext<Services> {
-    /**
-     * A pre-built Effect context providing the services available within this oRPC context.
-     * Automatically provided to any effect that runs under this context.
-     *
-     * @example
-     * ```ts
-     * import { Context } from 'effect'
-     *
-     * interface ServerContext extends WithEffectContext<Random | Logger> {}
-     *
-     * const context: ServerContext = {
-     *   '~effect/context': Context.empty().pipe(
-     *     Context.add(Random, { next: Effect.sync(() => Math.random()) }),
-     *   ),
-     * }
-     * ```
-     */
-    ['~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.
-     *
-     * @example
-     * ```ts
-     * import { Resource, Tracer } from '@effect/opentelemetry'
-     * import { Context, Effect, Layer } from 'effect'
-     *
-     * interface ServerContext extends WithEffectContext<never> {}
-     *
-     * const TracingLive = Tracer.layerGlobal.pipe(
-     *   Layer.provide(Resource.layerFromEnv()),
-     * )
-     *
-     * const context: ServerContext = {
-     *   '~effect/context': Context.empty(),
-     *   '~effect/wrap': (effect) => effect.pipe(Effect.provide(TracingLive)),
-     * }
-     * ```
-     */
-    ['~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>> {
-    (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>;
-
-export { handlerGen as h };
-export type { HandlerGen as H, InferYieldError as I, WithEffectContext as W };

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 };