effect-orpc 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-orpc",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "keywords": [
     "effect",
     "orpc",

package/src/effect-builder.ts

@@ -12,8 +12,10 @@ import { Layer, ManagedRuntime } from "effect";
 import { enhanceEffectRouter } from "./effect-enhance-router";
 import { EffectDecoratedProcedure } from "./effect-procedure";
 import {
+  createEffectOrORPCMiddleware,
   createEffectPipelineMiddleware,
   createEffectProcedureHandler,
+  isDecoratedMiddleware,
   isEffectMiddleware,
 } from "./effect-runtime";
 import {
@@ -248,27 +250,25 @@ function createEffectBuilderProxy(
         case "middleware":
           return getOrCreateVirtualMethod(context, prop, () => {
             return (middleware: any) => {
-              if (isEffectMiddleware(middleware)) {
-                const effectMiddleware = createEffectPipelineMiddleware({
-                  effectErrorMap: state.effectErrorMap,
-                  runner: state.runner,
-                  steps: [
-                    ...(state.effectSteps ?? []),
-                    { _tag: "middleware" as const, middleware },
-                  ],
-                });
-
-                return Reflect.apply(
-                  Reflect.get(source, "middleware", source),
-                  source,
-                  [effectMiddleware],
-                );
-              }
+              const effectMiddleware = isEffectMiddleware(middleware)
+                ? createEffectPipelineMiddleware({
+                    effectErrorMap: state.effectErrorMap,
+                    runner: state.runner,
+                    steps: [
+                      ...(state.effectSteps ?? []),
+                      { _tag: "middleware" as const, middleware },
+                    ],
+                  })
+                : createEffectOrORPCMiddleware({
+                    effectErrorMap: state.effectErrorMap,
+                    middleware,
+                    runner: state.runner,
+                  });
 
               return Reflect.apply(
                 Reflect.get(source, "middleware", source),
                 source,
-                [middleware],
+                [effectMiddleware],
               );
             };
           });
@@ -302,7 +302,7 @@ function createEffectBuilderProxy(
         case "use":
           return getOrCreateVirtualMethod(context, prop, () => {
             return (middleware: any, ...rest: unknown[]) => {
-              if (isEffectMiddleware(middleware) && rest.length === 0) {
+              if (rest.length === 0 && isEffectMiddleware(middleware)) {
                 return wrapBuilderLike(
                   source,
                   appendEffectStep(state, {
@@ -316,7 +316,16 @@ function createEffectBuilderProxy(
               const nextBuilder: AnyBuilderLike = Reflect.apply(
                 Reflect.get(flushed.builder, "use", flushed.builder),
                 flushed.builder,
-                [middleware, ...rest],
+                [
+                  rest.length === 0 && !isDecoratedMiddleware(middleware)
+                    ? createEffectOrORPCMiddleware({
+                        effectErrorMap: flushed.state.effectErrorMap,
+                        middleware,
+                        runner: flushed.state.runner,
+                      })
+                    : middleware,
+                  ...rest,
+                ],
               );
               return wrapBuilderLike(nextBuilder, flushed.state);
             };
@@ -347,11 +356,16 @@ function createEffectBuilderProxy(
                   any
                 >["handler"]
               >[0],
-            ) =>
-              new EffectDecoratedProcedure({
-                ...effectDef,
+            ) => {
+              const flushed = flushEffectSteps(source, state);
+              return new EffectDecoratedProcedure({
+                ...flushed.builder["~orpc"],
+                effectErrorMap: flushed.state.effectErrorMap,
+                runner: flushed.state.runner,
+                effectSteps: flushed.state.effectSteps,
                 handler,
               });
+            };
           });
         case "router":
           return getOrCreateVirtualMethod(context, prop, () => {

package/src/effect-procedure.ts

@@ -20,9 +20,11 @@ import { Layer } from "effect";
 
 import {
   createEffectOptionalProviderMiddleware,
+  createEffectOrORPCMiddleware,
   createEffectPipelineMiddleware,
   createEffectProcedureHandler,
   createEffectProviderMiddleware,
+  isDecoratedMiddleware,
   isEffectMiddleware,
 } from "./effect-runtime";
 import { composeSurfaceProxy } from "./extension/compose-surfaces";
@@ -323,18 +325,40 @@ function createEffectProcedureProxy<
             ) => {
               const def = getEffectProcedureDef(context);
               if (!mapInput && isEffectMiddleware(middleware)) {
-                return new EffectDecoratedProcedure(
-                  appendEffectStep(def, {
-                    _tag: "middleware",
-                    middleware,
-                  }),
-                );
+                const step: EffectPipelineStep = {
+                  _tag: "middleware" as const,
+                  middleware,
+                };
+
+                if (def.effectHandler) {
+                  return new EffectDecoratedProcedure(
+                    appendEffectStep(def, step),
+                  );
+                }
+
+                return new EffectDecoratedProcedure({
+                  ...def,
+                  middlewares: addMiddleware(
+                    def.middlewares,
+                    createEffectPipelineMiddleware({
+                      effectErrorMap: state.effectErrorMap,
+                      runner: state.runner,
+                      steps: [step],
+                    }),
+                  ),
+                });
               }
 
               const flushedDef = flushEffectSteps(def);
               const mapped = mapInput
                 ? decorateMiddleware(middleware).mapInput(mapInput)
-                : middleware;
+                : isDecoratedMiddleware(middleware)
+                  ? middleware
+                  : createEffectOrORPCMiddleware({
+                      effectErrorMap: state.effectErrorMap,
+                      middleware: middleware as any,
+                      runner: state.runner,
+                    });
 
               return new EffectDecoratedProcedure({
                 ...flushedDef,