effect-orpc 0.2.2 → 0.4.0

package/src/types/index.ts

@@ -18,11 +18,16 @@ import type {
   ProcedureBuilderWithOutput,
   ProcedureDef,
   ProcedureHandlerOptions,
+  MiddlewareNextFnOptions,
+  MiddlewareOptions,
+  MiddlewareResult,
   RouterBuilder,
 } from "@orpc/server";
-import type { Effect, ManagedRuntime } from "effect";
+import type { MaybeOptionalOptions } from "@orpc/shared";
+import type { Context as EffectContext, Effect, Layer, Option } from "effect";
 import type { YieldWrap } from "effect/Utils";
 
+import type { EffectRuntimeRunner } from "../runtime-source";
 import type {
   EffectErrorConstructorMap,
   EffectErrorMap,
@@ -44,7 +49,7 @@ type EffectBuilderDefBase<
   >;
 
 /**
- * Extended builder definition that includes the Effect ManagedRuntime.
+ * Extended builder definition that includes Effect execution state.
  */
 export interface EffectBuilderDef<
   TInputSchema extends AnySchema,
@@ -59,7 +64,7 @@ export interface EffectBuilderDef<
   TEffectErrorMap,
   TMeta
 > {
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   /**
    * Optional span configuration for Effect tracing.
    */
@@ -68,10 +73,12 @@ export interface EffectBuilderDef<
    * Effect-extended error map that supports both traditional errors and tagged errors.
    */
   effectErrorMap: TEffectErrorMap;
+  effectSteps?: readonly EffectPipelineStep[];
+  effectHandler?: EffectProcedureHandlerConfig;
 }
 
 /**
- * Extended procedure definition that includes the Effect ManagedRuntime.
+ * Extended procedure definition that includes Effect execution state.
  */
 export interface EffectProcedureDef<
   TInitialContext extends Context,
@@ -90,8 +97,10 @@ export interface EffectProcedureDef<
   EffectErrorMapToErrorMap<TEffectErrorMap>,
   TMeta
 > {
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   effectErrorMap: TEffectErrorMap;
+  effectSteps?: readonly EffectPipelineStep[];
+  effectHandler?: EffectProcedureHandlerConfig;
 }
 
 /**
@@ -139,6 +148,283 @@ export type EffectProcedureHandler<
   never
 >;
 
+export interface EffectProcedureHandlerConfig {
+  readonly effectFn: EffectProcedureHandler<any, any, any, any, any, any>;
+  readonly defaultCaptureStackTrace: () => string | undefined;
+  readonly spanConfig?: EffectSpanConfig;
+}
+
+type EffectTagService<T extends EffectContext.Tag<any, any>> =
+  T extends EffectContext.Tag<any, infer S> ? S : never;
+
+export type EffectProvider<
+  TCurrentContext extends Context,
+  TInput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+  TTag extends EffectContext.Tag<any, any>,
+> = (
+  opt: ProcedureHandlerOptions<
+    TCurrentContext,
+    TInput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >,
+) => Effect.Effect<
+  EffectTagService<TTag>,
+  EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+  TRequirementsProvided
+>;
+
+export type EffectOptionalProvider<
+  TCurrentContext extends Context,
+  TInput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+  TTag extends EffectContext.Tag<any, any>,
+> = (
+  opt: ProcedureHandlerOptions<
+    TCurrentContext,
+    TInput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >,
+) => Effect.Effect<
+  Option.Option<EffectTagService<TTag>>,
+  EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+  TRequirementsProvided
+>;
+
+interface EffectMiddlewareNext<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+> {
+  <UOutContext extends Context = Record<never, never>>(
+    ...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<UOutContext>>
+  ): Effect.Effect<
+    EffectMiddlewareResult<UOutContext, TOutput>,
+    EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+    TRequirementsProvided
+  >;
+}
+
+export type EffectMiddlewareResult<TOutContext extends Context, TOutput> = {
+  readonly output: TOutput;
+  readonly context: TOutContext;
+};
+
+export interface EffectMiddlewareOutput<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+> {
+  (
+    output: TOutput,
+  ): Effect.Effect<
+    EffectMiddlewareResult<Record<never, never>, TOutput>,
+    EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+    TRequirementsProvided
+  >;
+}
+
+/**
+ * Contextual typing bridge for `.use(...)` overloads.
+ *
+ * At runtime `next()` is either Effect-native or oRPC-native depending on
+ * whether the middleware is a generator function. At type-check time we need
+ * inline middleware to support both `return next()` and `yield* next()` without
+ * an explicit annotation. The return type is intentionally an intersection:
+ * assignable to `PromiseLike<A>` for native middleware, and yieldable as an
+ * `Effect<A, E, R>` for Effect middleware.
+ */
+type EffectAndPromiseLike<A, E, R> = Effect.Effect<A, E, R> & PromiseLike<A>;
+
+/** A `next` function that can be consumed by native oRPC or Effect middleware. */
+interface EffectOrORPCMiddlewareNext<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+> {
+  <UOutContext extends Context = Record<never, never>>(
+    ...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<UOutContext>>
+  ): EffectAndPromiseLike<
+    EffectMiddlewareResult<UOutContext, TOutput>,
+    EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+    TRequirementsProvided
+  >;
+}
+
+/** An `output` helper that can be consumed by native oRPC or Effect middleware. */
+interface EffectOrORPCMiddlewareOutput<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+> {
+  (
+    output: TOutput,
+  ): EffectAndPromiseLike<
+    EffectMiddlewareResult<Record<never, never>, TOutput>,
+    EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+    TRequirementsProvided
+  >;
+}
+
+/** Middleware options with the dual-shape `next` used for `.use(...)` inference. */
+type EffectOrORPCMiddlewareOptions<
+  TCurrentContext extends Context,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+> = Omit<
+  MiddlewareOptions<
+    TCurrentContext,
+    TOutput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >,
+  "next"
+> & {
+  readonly next: EffectOrORPCMiddlewareNext<
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided
+  >;
+};
+
+/**
+ * Public `.use(...)` middleware shape.
+ *
+ * Accepts native oRPC middleware returns (`result` / `PromiseLike<result>`) and
+ * Effect generator middleware returns. Runtime dispatch still uses
+ * `isEffectMiddleware(...)`; this type only makes the inline callback ergonomic.
+ */
+export type EffectOrORPCMiddleware<
+  TCurrentContext extends Context,
+  TOutContext extends Context,
+  TInput,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+> = (
+  opt: EffectOrORPCMiddlewareOptions<
+    TCurrentContext,
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided,
+    TMeta
+  >,
+  input: TInput,
+  output: EffectOrORPCMiddlewareOutput<
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided
+  >,
+) =>
+  | MiddlewareResult<TOutContext, TOutput>
+  | PromiseLike<MiddlewareResult<TOutContext, TOutput>>
+  | Generator<
+      YieldWrap<
+        Effect.Effect<
+          unknown,
+          | EffectErrorMapToUnion<TEffectErrorMap>
+          | ORPCError<ORPCErrorCode, unknown>,
+          TRequirementsProvided
+        >
+      >,
+      EffectMiddlewareResult<TOutContext, TOutput> | void,
+      never
+    >;
+
+export type EffectMiddlewareOptions<
+  TCurrentContext extends Context,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+> = Omit<
+  MiddlewareOptions<
+    TCurrentContext,
+    TOutput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >,
+  "next"
+> & {
+  readonly next: EffectMiddlewareNext<
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided
+  >;
+};
+
+export type EffectMiddleware<
+  TCurrentContext extends Context,
+  TOutContext extends Context,
+  TInput,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+> = (
+  opt: EffectMiddlewareOptions<
+    TCurrentContext,
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided,
+    TMeta
+  >,
+  input: TInput,
+  output: EffectMiddlewareOutput<
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided
+  >,
+) => Generator<
+  YieldWrap<
+    Effect.Effect<
+      unknown,
+      | EffectErrorMapToUnion<TEffectErrorMap>
+      | ORPCError<ORPCErrorCode, unknown>,
+      TRequirementsProvided
+    >
+  >,
+  EffectMiddlewareResult<TOutContext, TOutput> | void,
+  never
+>;
+
+type EffectProvideStep = {
+  readonly _tag: "provide";
+  readonly tag: EffectContext.Tag<any, any>;
+  readonly provider: EffectProvider<any, any, any, any, any, any>;
+};
+
+type EffectProvideOptionalStep = {
+  readonly _tag: "provideOptional";
+  readonly tag: EffectContext.Tag<any, any>;
+  readonly provider: EffectOptionalProvider<any, any, any, any, any, any>;
+};
+
+type EffectProvideLayerStep = {
+  readonly _tag: "provideLayer";
+  readonly layer: Layer.Layer<any, any, any>;
+};
+
+type EffectMiddlewareStep = {
+  readonly _tag: "middleware";
+  readonly middleware: EffectMiddleware<any, any, any, any, any, any, any>;
+};
+
+export type EffectPipelineStep =
+  | EffectProvideStep
+  | EffectProvideOptionalStep
+  | EffectProvideLayerStep
+  | EffectMiddlewareStep;
+
 export type EffectErrorMapToErrorMap<T extends EffectErrorMap> = {
   [K in keyof T as T[K] extends ErrorMapItem<AnySchema>
     ? K extends ORPCErrorCode