effect-orpc 0.2.0 → 0.2.2

package/src/effect-enhance-router.ts

@@ -19,6 +19,7 @@ import {
 import type { ManagedRuntime } from "effect/ManagedRuntime";
 
 import { EffectProcedure } from "./effect-procedure";
+import { getEffectErrorMap, unwrapEffectUpstream } from "./extension/state";
 import { effectErrorMapToErrorMap, type EffectErrorMap } from "./tagged-error";
 import type { EffectErrorMapToErrorMap, EnhancedEffectRouter } from "./types";
 
@@ -51,14 +52,14 @@ export function enhanceEffectRouter<
   if (isLazy(router)) {
     const laziedMeta = getLazyMeta(router);
     const enhancedPrefix = laziedMeta?.prefix
-      ? mergePrefix(options.prefix, laziedMeta?.prefix)
+      ? mergePrefix(options.prefix, laziedMeta.prefix)
       : options.prefix;
 
     const enhanced = lazy(
       async () => {
         const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced = enhanceEffectRouter(unlaziedRouter, options);
-        return unlazy(enhanced);
+        const wrappedRouter = enhanceEffectRouter(unlaziedRouter, options);
+        return unlazy(wrappedRouter);
       },
       {
         ...laziedMeta,
@@ -66,43 +67,41 @@ export function enhanceEffectRouter<
       },
     );
 
-    const accessible = createAccessibleLazyRouter(enhanced);
-
-    return accessible as any;
+    return createAccessibleLazyRouter(enhanced) as any;
   }
 
   if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(
+    const source = unwrapEffectUpstream(router);
+    const sourceEffectErrorMap = getEffectErrorMap(router);
+    const middlewares = mergeMiddlewares(
       options.middlewares,
-      router["~orpc"].middlewares,
+      source["~orpc"].middlewares,
       { dedupeLeading: options.dedupeLeadingMiddlewares },
     );
     const newMiddlewareAdded =
-      newMiddlewares.length - router["~orpc"].middlewares.length;
-
+      middlewares.length - source["~orpc"].middlewares.length;
     const effectErrorMap = {
       ...options.errorMap,
-      ...router["~orpc"].errorMap,
+      ...sourceEffectErrorMap,
     };
     const errorMap: EffectErrorMapToErrorMap<typeof effectErrorMap> =
       effectErrorMapToErrorMap(effectErrorMap);
-    const enhanced = new EffectProcedure({
-      ...router["~orpc"],
-      route: enhanceRoute(router["~orpc"].route, options),
+
+    return new EffectProcedure({
+      ...source["~orpc"],
+      route: enhanceRoute(source["~orpc"].route, options),
       effectErrorMap,
       errorMap: errorMap as EffectErrorMapToErrorMap<typeof effectErrorMap>,
-      middlewares: newMiddlewares,
+      middlewares,
       inputValidationIndex:
-        router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+        source["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex:
-        router["~orpc"].outputValidationIndex + newMiddlewareAdded,
+        source["~orpc"].outputValidationIndex + newMiddlewareAdded,
       runtime: options.runtime,
-    });
-
-    return enhanced as any;
+    }) as any;
   }
 
-  const enhanced = {} as Record<string, any>;
+  const enhanced: Record<string, any> = {};
 
   for (const key in router) {
     enhanced[key] = enhanceEffectRouter(router[key]!, options);

package/src/effect-procedure.ts

@@ -1,22 +1,11 @@
 import type { ClientContext } from "@orpc/client";
-import type {
-  AnySchema,
-  InferSchemaInput,
-  InferSchemaOutput,
-  Meta,
-  Route,
-} from "@orpc/contract";
+import type { AnySchema, Meta, Route } from "@orpc/contract";
 import { mergeMeta, mergeRoute } from "@orpc/contract";
 import type {
   AnyMiddleware,
   Context,
   CreateProcedureClientOptions,
   MapInputMiddleware,
-  MergedCurrentContext,
-  MergedInitialContext,
-  Middleware,
-  ProcedureActionableClient,
-  ProcedureClient,
   ProcedureDef,
 } from "@orpc/server";
 import {
@@ -26,16 +15,238 @@ import {
   decorateMiddleware,
   Procedure,
 } from "@orpc/server";
-import type { IntersectPick, MaybeOptionalOptions } from "@orpc/shared";
+import type { MaybeOptionalOptions } from "@orpc/shared";
 
-import type {
-  EffectErrorConstructorMap,
-  EffectErrorMap,
-  MergedEffectErrorMap,
-} from "./tagged-error";
+import { composeSurfaceProxy } from "./extension/compose-surfaces";
+import {
+  createNodeProxy,
+  unhandled,
+  type NodeProxyContext,
+} from "./extension/create-node-proxy";
+import {
+  assertEffectState,
+  attachEffectState,
+  type EffectProxyTarget,
+} from "./extension/state";
+import type { EffectErrorMap, MergedEffectErrorMap } from "./tagged-error";
 import { effectErrorMapToErrorMap } from "./tagged-error";
 import type { EffectErrorMapToErrorMap, EffectProcedureDef } from "./types";
+import type { EffectDecoratedProcedureSurface } from "./types/effect-procedure-surface";
+
+type AnyProcedureLike = Procedure<any, any, any, any, any, any>;
+type AnyEffectProcedure = EffectProcedure<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>;
+type AnyEffectDecoratedProcedure = EffectDecoratedProcedure<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>;
+type EffectProcedureTarget<
+  T extends AnyEffectProcedure | AnyEffectDecoratedProcedure =
+    | AnyEffectProcedure
+    | AnyEffectDecoratedProcedure,
+> = T & EffectProxyTarget<AnyProcedureLike>;
+
+const procedureVirtualDescriptors = {
+  "~effect": { enumerable: true },
+  actionable: { enumerable: false },
+  callable: { enumerable: false },
+  errors: { enumerable: false },
+  meta: { enumerable: false },
+  route: { enumerable: false },
+  use: { enumerable: false },
+} as const;
+
+const baseProcedureVirtualKeys = ["~effect"] as const;
+const decoratedProcedureVirtualKeys = [
+  ...baseProcedureVirtualKeys,
+  "errors",
+  "meta",
+  "route",
+  "use",
+  "callable",
+  "actionable",
+] as const;
+
+function getOrCreateVirtualMethod<T>(
+  context: NodeProxyContext<EffectProcedureTarget, AnyProcedureLike>,
+  prop: PropertyKey,
+  factory: () => T,
+): T {
+  const cache = context.methodCache;
+  if (cache.has(prop)) {
+    return cache.get(prop) as T;
+  }
+
+  const value = factory();
+  cache.set(prop, value);
+  return value;
+}
+
+function getEffectProcedureDef(
+  context: NodeProxyContext<EffectProcedureTarget, AnyProcedureLike>,
+): EffectProcedureDef<any, any, any, any, any, any, any, any> {
+  return {
+    ...context.upstream["~orpc"],
+    effectErrorMap: context.state.effectErrorMap,
+    runtime: context.state.runtime,
+  };
+}
+
+function createEffectProcedureProxy<
+  T extends AnyEffectProcedure | AnyEffectDecoratedProcedure,
+>(
+  target: EffectProcedureTarget<T>,
+  decorated: boolean,
+): EffectProcedureTarget<T> {
+  return createNodeProxy<EffectProcedureTarget<T>, AnyProcedureLike>(target, {
+    getVirtual(context, prop, receiver) {
+      if (prop === "~effect") {
+        return getEffectProcedureDef(context);
+      }
 
+      if (!decorated) {
+        return unhandled();
+      }
+
+      const state = context.state;
+
+      switch (prop) {
+        case "errors":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return <U extends EffectErrorMap>(errors: U) => {
+              const nextEffectErrorMap: MergedEffectErrorMap<
+                typeof state.effectErrorMap,
+                U
+              > = {
+                ...state.effectErrorMap,
+                ...errors,
+              };
+              return new EffectDecoratedProcedure({
+                ...getEffectProcedureDef(context),
+                effectErrorMap: nextEffectErrorMap,
+                errorMap: effectErrorMapToErrorMap(nextEffectErrorMap),
+              });
+            };
+          });
+        case "meta":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (meta: Meta) =>
+              new EffectDecoratedProcedure({
+                ...getEffectProcedureDef(context),
+                meta: mergeMeta(getEffectProcedureDef(context).meta, meta),
+              });
+          });
+        case "route":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (route: Route) =>
+              new EffectDecoratedProcedure({
+                ...getEffectProcedureDef(context),
+                route: mergeRoute(getEffectProcedureDef(context).route, route),
+              });
+          });
+        case "use":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (
+              middleware: AnyMiddleware,
+              mapInput?: MapInputMiddleware<any, any>,
+            ) => {
+              const mapped = mapInput
+                ? decorateMiddleware(middleware).mapInput(mapInput)
+                : middleware;
+
+              return new EffectDecoratedProcedure({
+                ...getEffectProcedureDef(context),
+                middlewares: addMiddleware(
+                  getEffectProcedureDef(context).middlewares,
+                  mapped,
+                ),
+              });
+            };
+          });
+        case "callable":
+          return <TClientContext extends ClientContext>(
+            ...rest: MaybeOptionalOptions<
+              CreateProcedureClientOptions<any, any, any, any, TClientContext>
+            >
+          ) => {
+            const client = createProcedureClient(
+              receiver as AnyProcedureLike,
+              ...rest,
+            );
+            return composeSurfaceProxy(
+              receiver as EffectDecoratedProcedure<
+                any,
+                any,
+                any,
+                any,
+                any,
+                any,
+                any,
+                any
+              >,
+              client,
+            );
+          };
+        case "actionable":
+          return (
+            ...rest: MaybeOptionalOptions<
+              CreateProcedureClientOptions<
+                any,
+                any,
+                any,
+                any,
+                Record<never, never>
+              >
+            >
+          ) => {
+            const client = createProcedureClient(
+              receiver as AnyProcedureLike,
+              ...rest,
+            );
+            const action = createActionableClient(client);
+            return composeSurfaceProxy(
+              receiver as EffectDecoratedProcedure<
+                any,
+                any,
+                any,
+                any,
+                any,
+                any,
+                any,
+                any
+              >,
+              action,
+            );
+          };
+        default:
+          return unhandled();
+      }
+    },
+    virtualDescriptors: procedureVirtualDescriptors,
+    virtualKeys: decorated
+      ? decoratedProcedureVirtualKeys
+      : baseProcedureVirtualKeys,
+  });
+}
+
+/**
+ * Effect-aware base procedure that carries the upstream procedure definition
+ * together with Effect runtime and error metadata.
+ */
 export class EffectProcedure<
   TInitialContext extends Context,
   TCurrentContext extends Context,
@@ -89,9 +300,17 @@ export class EffectProcedure<
       TRequirementsProvided,
       TRuntimeError
     >,
+    procedure?: AnyProcedureLike,
   ) {
     super(def);
-    this["~effect"] = def;
+    attachEffectState(this, procedure ?? new Procedure(def), {
+      effectErrorMap: def.effectErrorMap,
+      runtime: def.runtime,
+    });
+
+    if (new.target === EffectProcedure) {
+      return createEffectProcedureProxy(this, false);
+    }
   }
 }
 
@@ -110,20 +329,8 @@ export class EffectDecoratedProcedure<
   TMeta extends Meta,
   TRequirementsProvided,
   TRuntimeError,
-> extends EffectProcedure<
-  TInitialContext,
-  TCurrentContext,
-  TInputSchema,
-  TOutputSchema,
-  TEffectErrorMap,
-  TMeta,
-  TRequirementsProvided,
-  TRuntimeError
-> {
-  /**
-   * This property holds the defined options and the effect-specific properties.
-   */
-  declare "~effect": EffectProcedureDef<
+>
+  extends EffectProcedure<
     TInitialContext,
     TCurrentContext,
     TInputSchema,
@@ -132,18 +339,9 @@ export class EffectDecoratedProcedure<
     TMeta,
     TRequirementsProvided,
     TRuntimeError
-  >;
-  declare "~orpc": ProcedureDef<
-    TInitialContext,
-    TCurrentContext,
-    TInputSchema,
-    TOutputSchema,
-    EffectErrorMapToErrorMap<TEffectErrorMap>,
-    TMeta
-  >;
-
-  constructor(
-    def: EffectProcedureDef<
+  >
+  implements
+    EffectDecoratedProcedureSurface<
       TInitialContext,
       TCurrentContext,
       TInputSchema,
@@ -152,50 +350,31 @@ export class EffectDecoratedProcedure<
       TMeta,
       TRequirementsProvided,
       TRuntimeError
-    >,
-  ) {
-    super(def);
-    this["~effect"] = def;
-  }
-
+    >
+{
   /**
    * Adds type-safe custom errors.
    * Supports both traditional oRPC error definitions and ORPCTaggedError classes.
    *
    * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
    */
-  errors<U extends EffectErrorMap>(
-    errors: U,
-  ): EffectDecoratedProcedure<
+  declare errors: EffectDecoratedProcedureSurface<
     TInitialContext,
     TCurrentContext,
     TInputSchema,
     TOutputSchema,
-    MergedEffectErrorMap<TEffectErrorMap, U>,
+    TEffectErrorMap,
     TMeta,
     TRequirementsProvided,
     TRuntimeError
-  > {
-    const newEffectErrorMap: MergedEffectErrorMap<TEffectErrorMap, U> = {
-      ...this["~effect"].effectErrorMap,
-      ...errors,
-    };
-    return new EffectDecoratedProcedure({
-      ...this["~effect"],
-      effectErrorMap: newEffectErrorMap,
-      errorMap: effectErrorMapToErrorMap(newEffectErrorMap),
-    });
-  }
-
+  >["errors"];
   /**
    * Sets or updates the metadata.
    * The provided metadata is spared-merged with any existing metadata.
    *
    * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
    */
-  meta(
-    meta: TMeta,
-  ): EffectDecoratedProcedure<
+  declare meta: EffectDecoratedProcedureSurface<
     TInitialContext,
     TCurrentContext,
     TInputSchema,
@@ -204,13 +383,7 @@ export class EffectDecoratedProcedure<
     TMeta,
     TRequirementsProvided,
     TRuntimeError
-  > {
-    return new EffectDecoratedProcedure({
-      ...this["~effect"],
-      meta: mergeMeta(this["~effect"].meta, meta),
-    });
-  }
-
+  >["meta"];
   /**
    * Sets or updates the route definition.
    * The provided route is spared-merged with any existing route.
@@ -219,9 +392,7 @@ export class EffectDecoratedProcedure<
    * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
    * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
    */
-  route(
-    route: Route,
-  ): EffectDecoratedProcedure<
+  declare route: EffectDecoratedProcedureSurface<
     TInitialContext,
     TCurrentContext,
     TInputSchema,
@@ -230,13 +401,7 @@ export class EffectDecoratedProcedure<
     TMeta,
     TRequirementsProvided,
     TRuntimeError
-  > {
-    return new EffectDecoratedProcedure({
-      ...this["~effect"],
-      route: mergeRoute(this["~effect"].route, route),
-    });
-  }
-
+  >["route"];
   /**
    * Uses a middleware to modify the context or improve the pipeline.
    *
@@ -245,92 +410,22 @@ export class EffectDecoratedProcedure<
    * @note The current context must be satisfy middleware dependent-context
    * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
    */
-  use<
-    UOutContext extends IntersectPick<TCurrentContext, UOutContext>,
-    UInContext extends Context = TCurrentContext,
-  >(
-    middleware: Middleware<
-      UInContext | TCurrentContext,
-      UOutContext,
-      InferSchemaOutput<TInputSchema>,
-      InferSchemaInput<TOutputSchema>,
-      EffectErrorConstructorMap<TEffectErrorMap>,
-      TMeta
-    >,
-  ): EffectDecoratedProcedure<
-    MergedInitialContext<TInitialContext, UInContext, TCurrentContext>,
-    MergedCurrentContext<TCurrentContext, UOutContext>,
-    TInputSchema,
-    TOutputSchema,
-    TEffectErrorMap,
-    TMeta,
-    TRequirementsProvided,
-    TRuntimeError
-  >;
-
-  /**
-   * Uses a middleware to modify the context or improve the pipeline.
-   *
-   * @info Supports both normal middleware and inline middleware implementations.
-   * @info Pass second argument to map the input.
-   * @note The current context must be satisfy middleware dependent-context
-   * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
-   */
-  use<
-    UOutContext extends IntersectPick<TCurrentContext, UOutContext>,
-    UInput,
-    UInContext extends Context = TCurrentContext,
-  >(
-    middleware: Middleware<
-      UInContext | TCurrentContext,
-      UOutContext,
-      UInput,
-      InferSchemaInput<TOutputSchema>,
-      EffectErrorConstructorMap<TEffectErrorMap>,
-      TMeta
-    >,
-    mapInput: MapInputMiddleware<InferSchemaOutput<TInputSchema>, UInput>,
-  ): EffectDecoratedProcedure<
-    MergedInitialContext<TInitialContext, UInContext, TCurrentContext>,
-    MergedCurrentContext<TCurrentContext, UOutContext>,
+  declare use: EffectDecoratedProcedureSurface<
+    TInitialContext,
+    TCurrentContext,
     TInputSchema,
     TOutputSchema,
     TEffectErrorMap,
     TMeta,
     TRequirementsProvided,
     TRuntimeError
-  >;
-
-  use(
-    middleware: AnyMiddleware,
-    mapInput?: MapInputMiddleware<any, any>,
-  ): EffectDecoratedProcedure<any, any, any, any, any, any, any, any> {
-    const mapped = mapInput
-      ? decorateMiddleware(middleware).mapInput(mapInput)
-      : middleware;
-
-    return new EffectDecoratedProcedure({
-      ...this["~effect"],
-      middlewares: addMiddleware(this["~effect"].middlewares, mapped),
-    });
-  }
-
+  >["use"];
   /**
    * Make this procedure callable (works like a function while still being a procedure).
    *
    * @see {@link https://orpc.dev/docs/client/server-side Server-side Client Docs}
    */
-  callable<TClientContext extends ClientContext>(
-    ...rest: MaybeOptionalOptions<
-      CreateProcedureClientOptions<
-        TInitialContext,
-        TOutputSchema,
-        EffectErrorMapToErrorMap<TEffectErrorMap>,
-        TMeta,
-        TClientContext
-      >
-    >
-  ): EffectDecoratedProcedure<
+  declare callable: EffectDecoratedProcedureSurface<
     TInitialContext,
     TCurrentContext,
     TInputSchema,
@@ -339,48 +434,13 @@ export class EffectDecoratedProcedure<
     TMeta,
     TRequirementsProvided,
     TRuntimeError
-  > &
-    ProcedureClient<
-      TClientContext,
-      TInputSchema,
-      TOutputSchema,
-      EffectErrorMapToErrorMap<TEffectErrorMap>
-    > {
-    const client: ProcedureClient<
-      TClientContext,
-      TInputSchema,
-      TOutputSchema,
-      EffectErrorMapToErrorMap<TEffectErrorMap>
-    > = createProcedureClient(this, ...rest);
-
-    return new Proxy(client, {
-      get: (target, key) => {
-        return Reflect.has(this, key)
-          ? Reflect.get(this, key)
-          : Reflect.get(target, key);
-      },
-      has: (target, key) => {
-        return Reflect.has(this, key) || Reflect.has(target, key);
-      },
-    }) as any;
-  }
-
+  >["callable"];
   /**
    * Make this procedure compatible with server action.
    *
    * @see {@link https://orpc.dev/docs/server-action Server Action Docs}
    */
-  actionable(
-    ...rest: MaybeOptionalOptions<
-      CreateProcedureClientOptions<
-        TInitialContext,
-        TOutputSchema,
-        EffectErrorMapToErrorMap<TEffectErrorMap>,
-        TMeta,
-        Record<never, never>
-      >
-    >
-  ): EffectDecoratedProcedure<
+  declare actionable: EffectDecoratedProcedureSurface<
     TInitialContext,
     TCurrentContext,
     TInputSchema,
@@ -389,27 +449,22 @@ export class EffectDecoratedProcedure<
     TMeta,
     TRequirementsProvided,
     TRuntimeError
-  > &
-    ProcedureActionableClient<
-      TInputSchema,
-      TOutputSchema,
-      EffectErrorMapToErrorMap<TEffectErrorMap>
-    > {
-    const action: ProcedureActionableClient<
+  >["actionable"];
+  constructor(
+    def: EffectProcedureDef<
+      TInitialContext,
+      TCurrentContext,
       TInputSchema,
       TOutputSchema,
-      EffectErrorMapToErrorMap<TEffectErrorMap>
-    > = createActionableClient(createProcedureClient(this, ...rest));
-
-    return new Proxy(action, {
-      get: (target, key) => {
-        return Reflect.has(this, key)
-          ? Reflect.get(this, key)
-          : Reflect.get(target, key);
-      },
-      has: (target, key) => {
-        return Reflect.has(this, key) || Reflect.has(target, key);
-      },
-    }) as any;
+      TEffectErrorMap,
+      TMeta,
+      TRequirementsProvided,
+      TRuntimeError
+    >,
+    procedure?: AnyProcedureLike,
+  ) {
+    super(def, procedure);
+    assertEffectState<AnyProcedureLike>(this);
+    return createEffectProcedureProxy(this, true);
   }
 }