@effect-app/infra 2.94.0 → 3.0.1

package/test/dist/fixtures.d.ts

@@ -1,6 +1,5 @@
-import { Context, Effect, S, Scope } from "effect-app";
+import { Context, Effect, Layer, S, Scope } from "effect-app";
 import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client";
-import { Middleware } from "../src/api/routing.js";
 declare const UserProfile_base: S.EnhancedClass<UserProfile, {
     id: typeof S.String;
     roles: S.Array$<typeof S.String> & {
@@ -23,12 +22,12 @@ declare const Some_base: (abstract new (service: {
     a: number;
 }>) & {
     toLayer: {
-        (): import("effect/Layer").Layer<Some, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<Some, keyof Context.TagClassShape<any, any>>, E_1, R_1>): import("effect/Layer").Layer<Some, E_1, R_1>;
+        (): Layer.Layer<Some, never, never>;
+        <E_1, R_1>(eff: Effect.Effect<Omit<Some, keyof Context.TagClassShape<any, any>>, E_1, R_1>): Layer.Layer<Some, E_1, R_1>;
     };
     toLayerScoped: {
-        (): import("effect/Layer").Layer<Some, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<Some, keyof Context.TagClassShape<any, any>>, E_1, R_2>): import("effect/Layer").Layer<Some, E_1, Exclude<R_2, Scope.Scope>>;
+        (): Layer.Layer<Some, never, never>;
+        <E_1, R_2>(eff: Effect.Effect<Omit<Some, keyof Context.TagClassShape<any, any>>, E_1, R_2>): Layer.Layer<Some, E_1, Exclude<R_2, Scope.Scope>>;
     };
     of: (service: Context.TagClassShape<any, any>) => Some;
     make: Effect.Effect<Some, never, never>;
@@ -37,7 +36,7 @@ declare const Some_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         a: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, Some | R_3> : Effect.Effect<X, never, Some>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, Some | R_4> : Effect.Effect<X, never, Some>;
 };
 export declare class Some extends Some_base {
 }
@@ -49,12 +48,12 @@ declare const SomeElse_base: (abstract new (service: {
     b: number;
 }>) & {
     toLayer: {
-        (): import("effect/Layer").Layer<SomeElse, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<SomeElse, keyof Context.TagClassShape<any, any>>, E_1, R_1>): import("effect/Layer").Layer<SomeElse, E_1, R_1>;
+        (): Layer.Layer<SomeElse, never, never>;
+        <E_1, R_1>(eff: Effect.Effect<Omit<SomeElse, keyof Context.TagClassShape<any, any>>, E_1, R_1>): Layer.Layer<SomeElse, E_1, R_1>;
     };
     toLayerScoped: {
-        (): import("effect/Layer").Layer<SomeElse, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<SomeElse, keyof Context.TagClassShape<any, any>>, E_1, R_2>): import("effect/Layer").Layer<SomeElse, E_1, Exclude<R_2, Scope.Scope>>;
+        (): Layer.Layer<SomeElse, never, never>;
+        <E_1, R_2>(eff: Effect.Effect<Omit<SomeElse, keyof Context.TagClassShape<any, any>>, E_1, R_2>): Layer.Layer<SomeElse, E_1, Exclude<R_2, Scope.Scope>>;
     };
     of: (service: Context.TagClassShape<any, any>) => SomeElse;
     make: Effect.Effect<SomeElse, never, never>;
@@ -63,7 +62,7 @@ declare const SomeElse_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         b: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | SomeElse> : Effect.Effect<X, never, SomeElse>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, R_4 | SomeElse> : Effect.Effect<X, never, SomeElse>;
 };
 export declare class SomeElse extends SomeElse_base {
 }
@@ -75,12 +74,12 @@ declare const SomeService_base: (abstract new (service: {
     a: number;
 }>) & {
     toLayer: {
-        (): import("effect/Layer").Layer<SomeService, never, never>;
-        <E_1, R_1>(eff: Effect.Effect<Omit<SomeService, keyof Context.TagClassShape<any, any>>, E_1, R_1>): import("effect/Layer").Layer<SomeService, E_1, R_1>;
+        (): Layer.Layer<SomeService, never, never>;
+        <E_1, R_1>(eff: Effect.Effect<Omit<SomeService, keyof Context.TagClassShape<any, any>>, E_1, R_1>): Layer.Layer<SomeService, E_1, R_1>;
     };
     toLayerScoped: {
-        (): import("effect/Layer").Layer<SomeService, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Omit<SomeService, keyof Context.TagClassShape<any, any>>, E_1, R_2>): import("effect/Layer").Layer<SomeService, E_1, Exclude<R_2, Scope.Scope>>;
+        (): Layer.Layer<SomeService, never, never>;
+        <E_1, R_2>(eff: Effect.Effect<Omit<SomeService, keyof Context.TagClassShape<any, any>>, E_1, R_2>): Layer.Layer<SomeService, E_1, Exclude<R_2, Scope.Scope>>;
     };
     of: (service: Context.TagClassShape<any, any>) => SomeService;
     make: Effect.Effect<SomeService, never, never>;
@@ -89,10 +88,30 @@ declare const SomeService_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         a: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | SomeService> : Effect.Effect<X, never, SomeService>;
+    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, R_4 | SomeService> : Effect.Effect<X, never, SomeService>;
 };
 export declare class SomeService extends SomeService_base {
 }
+declare const SomeMiddleware_base: import("effect-app/rpc").TagClass<SomeMiddleware, "SomeMiddleware", {
+    readonly provides: typeof Some;
+}>;
+export declare class SomeMiddleware extends SomeMiddleware_base {
+}
+export declare const SomeMiddlewareLive: Layer.Layer<SomeMiddleware, never, never>;
+declare const SomeMiddlewareWrap_base: import("effect-app/rpc").TagClass<SomeMiddlewareWrap, "SomeMiddlewareWrap", {
+    readonly provides: typeof Some;
+    readonly wrap: true;
+}>;
+export declare class SomeMiddlewareWrap extends SomeMiddlewareWrap_base {
+}
+export declare const SomeMiddlewareWrapLive: Layer.Layer<SomeMiddlewareWrap, never, never>;
+declare const SomeElseMiddleware_base: import("effect-app/rpc").TagClass<SomeElseMiddleware, "SomeElseMiddleware", {
+    readonly provides: typeof SomeElse;
+    readonly wrap: true;
+}>;
+export declare class SomeElseMiddleware extends SomeElseMiddleware_base {
+}
+export declare const SomeElseMiddlewareLive: Layer.Layer<SomeElseMiddleware, never, never>;
 export declare const RequestContextMap: {
     readonly allowAnonymous: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
     readonly requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>;
@@ -101,31 +120,28 @@ export declare const RequestContextMap: {
 type _RequestContextMap = typeof RequestContextMap;
 export interface RequestContextMap extends _RequestContextMap {
 }
-declare const AllowAnonymous_base: Middleware.TagClass<AllowAnonymous, "AllowAnonymous", {
-    readonly dynamic: Middleware.RpcDynamic<"allowAnonymous", RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>>;
+declare const AllowAnonymous_base: import("effect-app/rpc").TagClass<AllowAnonymous, "AllowAnonymous", {
+    readonly dynamic: import("effect-app/rpc").RpcDynamic<"allowAnonymous", RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>>;
     readonly requires: typeof SomeElse;
-}> & {
-    Default: import("effect/Layer").Layer<AllowAnonymous, never, never>;
-};
+}>;
 export declare class AllowAnonymous extends AllowAnonymous_base {
 }
-declare const RequireRoles_base: Middleware.TagClass<RequireRoles, "RequireRoles", {
-    readonly dynamic: Middleware.RpcDynamic<"requireRoles", RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>>;
+export declare const AllowAnonymousLive: Layer.Layer<AllowAnonymous, never, never>;
+declare const RequireRoles_base: import("effect-app/rpc").TagClass<RequireRoles, "RequireRoles", {
+    readonly dynamic: import("effect-app/rpc").RpcDynamic<"requireRoles", RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>>;
     readonly wrap: true;
     readonly dependsOn: readonly [typeof AllowAnonymous];
-}> & {
-    Default: import("effect/Layer").Layer<RequireRoles, never, SomeService>;
-};
+}>;
 export declare class RequireRoles extends RequireRoles_base {
 }
-declare const Test_base: Middleware.TagClass<Test, "Test", {
+export declare const RequireRolesLive: Layer.Layer<RequireRoles, never, SomeService>;
+declare const Test_base: import("effect-app/rpc").TagClass<Test, "Test", {
     readonly wrap: true;
-    readonly dynamic: Middleware.RpcDynamic<"test", RPCContextMap.RPCContextMap<never, typeof S.Never>>;
-}> & {
-    Default: import("effect/Layer").Layer<Test, never, never>;
-};
+    readonly dynamic: import("effect-app/rpc").RpcDynamic<"test", RPCContextMap.RPCContextMap<never, typeof S.Never>>;
+}>;
 export declare class Test extends Test_base {
 }
+export declare const TestLive: Layer.Layer<Test, never, never>;
 declare const CustomError1_base: S.TaggedErrorClass<NotLoggedInError, "CustomError1", {
     readonly _tag: S.tag<"CustomError1">;
 }>;

package/test/dist/fixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAU,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEtF,OAAO,EAAyB,UAAU,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;;;AAEzE,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;AASpG,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,KAAK,kBAAkB,GAAG,OAAO,iBAAiB,CAAA;AAClD,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAAG;;;;;;;AAEhE,qBAAa,cAAe,SAAQ,mBA4BlC;CACD;;;;;;;;AAID,qBAAa,YAAa,SAAQ,iBA6BhC;CACD;;;;;;;AAGD,qBAAa,IAAK,SAAQ,SASxB;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;;;;;;;;;;;;;AAItF,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;;;;AAEpG,qBAAa,cAAe,SAAQ,mBAElC;CAAG;AAEL,eAAO,MAAM,kBAAkB,2CAS9B,CAAA;;;;;AAGD,qBAAa,kBAAmB,SAAQ,uBAGtC;CACD;AAED,eAAO,MAAM,sBAAsB,+CAMlC,CAAA;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAGtC;CAAG;AAEL,eAAO,MAAM,sBAAsB,+CAUlC,CAAA;AASD,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,KAAK,kBAAkB,GAAG,OAAO,iBAAiB,CAAA;AAClD,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAAG;;;;;AAEhE,qBAAa,cAAe,SAAQ,mBAGlC;CAAG;AAEL,eAAO,MAAM,kBAAkB,2CA0B9B,CAAA;;;;;;AAID,qBAAa,YAAa,SAAQ,iBAOhC;CAAG;AAEL,eAAO,MAAM,gBAAgB,+CAuB5B,CAAA;;;;;AAGD,qBAAa,IAAK,SAAQ,SAGxB;CAAG;AAEL,eAAO,MAAM,QAAQ,iCAOpB,CAAA;;;;AAED,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG"}

package/test/dist/fixtures.js

@@ -1,7 +1,7 @@
-import { Context, Effect, Option, S, Scope } from "effect-app";
+import { Context, Effect, Layer, Option, S, Scope } from "effect-app";
 import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client";
+import { contextMap, getConfig, Tag } from "effect-app/rpc";
 import { TaggedError } from "effect-app/Schema";
-import { contextMap, getConfig, Middleware } from "../src/api/routing.js";
 export class UserProfile extends Context.assignTag("UserProfile")(S.Class("UserProfile")({
     id: S.String,
     roles: S.Array(S.String)
@@ -14,6 +14,38 @@ export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b:
 const MakeSomeService = Effect.succeed({ a: 1 });
 export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)() {
 }
+export class SomeMiddleware extends Tag()("SomeMiddleware", {
+    provides: Some
+}) {
+}
+export const SomeMiddlewareLive = Layer.effect(SomeMiddleware, Effect.gen(function* () {
+    // yield* Effect.context<"test-dep">()
+    return () => Effect.gen(function* () {
+        return new Some({ a: 1 });
+    });
+}));
+// functionally equivalent to the one above
+export class SomeMiddlewareWrap extends Tag()("SomeMiddlewareWrap", {
+    provides: Some,
+    wrap: true
+}) {
+}
+export const SomeMiddlewareWrapLive = Layer.effect(SomeMiddlewareWrap, Effect.gen(function* () {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) => next.pipe(Effect.provideService(Some, new Some({ a: 1 })));
+}));
+export class SomeElseMiddleware extends Tag()("SomeElseMiddleware", {
+    provides: SomeElse,
+    wrap: true
+}) {
+}
+export const SomeElseMiddlewareLive = Layer.effect(SomeElseMiddleware, Effect.gen(function* () {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) => Effect.gen(function* () {
+        // yield* Effect.context<"test-dep2">()
+        return yield* next.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })));
+    });
+}));
 const requestConfig = getConfig();
 // TODO: null as never sucks
 // why [UserProfile] is needed? AllowAnonymous triggers an error if just UserProfile without []
@@ -25,71 +57,68 @@ export const RequestContextMap = {
     requireRoles: RPCContextMap.makeCustom(null, UnauthorizedError, Array()),
     test: RPCContextMap.make(null, S.Never)
 };
-export class AllowAnonymous extends Middleware.Tag()("AllowAnonymous", {
+export class AllowAnonymous extends Tag()("AllowAnonymous", {
     dynamic: contextMap(RequestContextMap, "allowAnonymous"),
     requires: SomeElse
-})({
-    effect: Effect.gen(function* () {
-        return Effect.fnUntraced(function* ({ headers, rpc }) {
-            yield* SomeElse;
-            yield* Scope.Scope; // provided by HttpLayerRouter.Provided
-            const isLoggedIn = !!headers["x-user"];
-            if (!isLoggedIn) {
-                if (!requestConfig(rpc).allowAnonymous) {
-                    return yield* new NotLoggedInError({ message: "Not logged in" });
-                }
-                return Option.none();
-            }
-            return Option.some(Context.make(UserProfile, new UserProfile({
-                id: "whatever",
-                roles: ["user", ...headers["x-is-manager"] === "true" ? ["manager"] : []]
-            })));
-        });
-    })
 }) {
 }
+export const AllowAnonymousLive = Layer.effect(AllowAnonymous, Effect.gen(function* () {
+    return Effect.fnUntraced(function* ({ headers, rpc }) {
+        yield* SomeElse;
+        yield* Scope.Scope; // provided by HttpLayerRouter.Provided
+        const isLoggedIn = !!headers["x-user"];
+        if (!isLoggedIn) {
+            if (!requestConfig(rpc).allowAnonymous) {
+                return yield* new NotLoggedInError({ message: "Not logged in" });
+            }
+            return Option.none();
+        }
+        return Option.some(Context.make(UserProfile, new UserProfile({
+            id: "whatever",
+            roles: ["user", ...headers["x-is-manager"] === "true" ? ["manager"] : []]
+        })));
+    });
+}));
 // TODO: don't expect service when it's wrap
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class RequireRoles extends Middleware.Tag()("RequireRoles", {
+export class RequireRoles extends Tag()("RequireRoles", {
     dynamic: contextMap(RequestContextMap, "requireRoles"),
     wrap: true,
     // wrap: true,
     // had to move this in here, because once you put it manually as a readonly static property on the class,
     // there's a weird issue where the fluent api stops behaving properly after adding this middleware via `addDynamicMiddleware`
     dependsOn: [AllowAnonymous]
-})({
-    effect: Effect.gen(function* () {
-        yield* SomeService;
-        return Effect.fnUntraced(function* ({ next, rpc }) {
-            // we don't know if the service will be provided or not, so we use option..
-            const userProfile = yield* Effect.serviceOption(UserProfile);
-            const { requireRoles } = requestConfig(rpc);
-            console.dir({
-                userProfile,
-                requireRoles
-            }, { depth: 5 });
-            if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
-                return yield* new UnauthorizedError({ message: "don't have the right roles" });
-            }
-            return yield* next;
-        });
-    })
 }) {
 }
+export const RequireRolesLive = Layer.effect(RequireRoles, Effect.gen(function* () {
+    yield* SomeService;
+    return Effect.fnUntraced(function* ({ next, rpc }) {
+        // we don't know if the service will be provided or not, so we use option..
+        const userProfile = yield* Effect.serviceOption(UserProfile);
+        const { requireRoles } = requestConfig(rpc);
+        console.dir({
+            userProfile,
+            requireRoles
+        }, { depth: 5 });
+        if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
+            return yield* new UnauthorizedError({ message: "don't have the right roles" });
+        }
+        return yield* next;
+    });
+}));
 // TODO: don't expect service when it's wrap
-export class Test extends Middleware.Tag()("Test", {
+export class Test extends Tag()("Test", {
     wrap: true,
     dynamic: contextMap(RequestContextMap, "test")
-})({
-    effect: Effect.gen(function* () {
-        return Effect.fn(function* ({ next }) {
-            return yield* next;
-        });
-    })
 }) {
 }
+export const TestLive = Layer.effect(Test, Effect.gen(function* () {
+    return Effect.fn(function* ({ next }) {
+        return yield* next;
+    });
+}));
 export class CustomError1 extends TaggedError()("CustomError1", {}) {
 }
 export class CustomError2 extends TaggedError()("CustomError1", {}) {
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/test/dist/requires.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,KAAK,EAAK,MAAM,YAAY,CAAA;AAG9D,OAAO,EAAkB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAmD,IAAI,EAAE,QAAQ,EAAqB,MAAM,eAAe,CAAA;;;;;;AAElH,qBAAa,cAAe,SAAQ,mBAUlC;CACD;;;;;;;AAGD,qBAAa,kBAAmB,SAAQ,uBAQtC;CACD;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAYtC;CACD;;;;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAa1C;CACD"}
+{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,KAAK,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAGvE,OAAO,EAAE,cAAc,EAAyC,YAAY,EAAoB,IAAI,EAAE,kBAAkB,EAA8D,kBAAkB,EAAe,IAAI,EAAY,MAAM,eAAe,CAAA;;;;;;;AAE5P,qBAAa,sBAAuB,SAAQ,2BAa1C;CACD;AAkBD,eAAO,MAAM,eAAe;;;;;;;;;;SAKK,CAAA"}

package/test/dist/rpc-multi-middleware.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-multi-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-multi-middleware.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAkD,MAAM,aAAa,CAAA;AAEvF,OAAO,EAA2B,KAAK,EAAE,MAAM,QAAQ,CAAA;AAOvD,OAAO,EAAoN,WAAW,EAAE,MAAM,eAAe,CAAA;AA8C7P,eAAO,MAAM,OAAO,uFAWO,CAAA;AAiB3B,eAAO,MAAM,YAAY,yKAItB,CAAA;AAEH,eAAO,MAAM,YAAY,+FAgByB,CAAA"}

package/test/fixtures.ts

@@ -1,7 +1,7 @@
-import { Context, Effect, Option, S, Scope } from "effect-app"
+import { Context, Effect, Layer, Option, S, Scope } from "effect-app"
 import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client"
+import { contextMap, getConfig, Tag } from "effect-app/rpc"
 import { TaggedError } from "effect-app/Schema"
-import { contextMap, getConfig, Middleware } from "../src/api/routing.js"
 
 export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
   S.Class<UserProfile>("UserProfile")({
@@ -16,6 +16,53 @@ export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b:
 const MakeSomeService = Effect.succeed({ a: 1 })
 export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
 
+export class SomeMiddleware extends Tag<SomeMiddleware>()("SomeMiddleware", {
+  provides: Some
+}) {}
+
+export const SomeMiddlewareLive = Layer.effect(
+  SomeMiddleware,
+  Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return () =>
+      Effect.gen(function*() {
+        return new Some({ a: 1 })
+      })
+  })
+)
+
+// functionally equivalent to the one above
+export class SomeMiddlewareWrap extends Tag<SomeMiddlewareWrap>()("SomeMiddlewareWrap", {
+  provides: Some,
+  wrap: true
+}) {
+}
+
+export const SomeMiddlewareWrapLive = Layer.effect(
+  SomeMiddlewareWrap,
+  Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) => next.pipe(Effect.provideService(Some, new Some({ a: 1 })))
+  })
+)
+
+export class SomeElseMiddleware extends Tag<SomeElseMiddleware>()("SomeElseMiddleware", {
+  provides: SomeElse,
+  wrap: true
+}) {}
+
+export const SomeElseMiddlewareLive = Layer.effect(
+  SomeElseMiddleware,
+  Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) =>
+      Effect.gen(function*() {
+        // yield* Effect.context<"test-dep2">()
+        return yield* next.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })))
+      })
+  })
+)
+
 const requestConfig = getConfig<RequestContextMap>()
 
 // TODO: null as never sucks
@@ -32,11 +79,14 @@ export const RequestContextMap = {
 type _RequestContextMap = typeof RequestContextMap
 export interface RequestContextMap extends _RequestContextMap {}
 
-export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnonymous", {
+export class AllowAnonymous extends Tag<AllowAnonymous>()("AllowAnonymous", {
   dynamic: contextMap(RequestContextMap, "allowAnonymous"),
   requires: SomeElse
-})({
-  effect: Effect.gen(function*() {
+}) {}
+
+export const AllowAnonymousLive = Layer.effect(
+  AllowAnonymous,
+  Effect.gen(function*() {
     return Effect.fnUntraced(
       function*({ headers, rpc }) {
         yield* SomeElse
@@ -60,20 +110,22 @@ export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnony
       }
     )
   })
-}) {
-}
+)
 
 // TODO: don't expect service when it's wrap
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles", {
+export class RequireRoles extends Tag<RequireRoles>()("RequireRoles", {
   dynamic: contextMap(RequestContextMap, "requireRoles"),
   wrap: true,
   // wrap: true,
   // had to move this in here, because once you put it manually as a readonly static property on the class,
   // there's a weird issue where the fluent api stops behaving properly after adding this middleware via `addDynamicMiddleware`
   dependsOn: [AllowAnonymous]
-})({
-  effect: Effect.gen(function*() {
+}) {}
+
+export const RequireRolesLive = Layer.effect(
+  RequireRoles,
+  Effect.gen(function*() {
     yield* SomeService
     return Effect.fnUntraced(
       function*({ next, rpc }) {
@@ -94,20 +146,22 @@ export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles",
       }
     )
   })
-}) {
-}
+)
 
 // TODO: don't expect service when it's wrap
-export class Test extends Middleware.Tag<Test>()("Test", {
+export class Test extends Tag<Test>()("Test", {
   wrap: true,
   dynamic: contextMap(RequestContextMap, "test")
-})({
-  effect: Effect.gen(function*() {
+}) {}
+
+export const TestLive = Layer.effect(
+  Test,
+  Effect.gen(function*() {
     return Effect.fn(function*({ next }) {
       return yield* next
     })
   })
-}) {}
+)
 
 export class CustomError1 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
 export class CustomError2 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}

package/test/requires.test.ts

@@ -4,50 +4,10 @@ import { describe, expect, expectTypeOf, it } from "@effect/vitest"
 import { Context, Effect, Either, Layer, S } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { HttpHeaders } from "effect-app/http"
-import { makeMiddleware, Middleware } from "../src/api/routing.js"
-import { AllowAnonymous, RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
+import { makeMiddleware, TagService } from "effect-app/rpc"
+import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeMiddlewareWrap, SomeService, Test, TestLive } from "./fixtures.js"
 
-export class SomeMiddleware extends Middleware.Tag<SomeMiddleware>()("SomeMiddleware", {
-  provides: Some
-})({
-  effect: Effect.gen(function*() {
-    // yield* Effect.context<"test-dep">()
-    return () =>
-      Effect.gen(function*() {
-        return new Some({ a: 1 })
-      })
-  })
-}) {
-}
-
-// functionally equivalent to the one above
-export class SomeMiddlewareWrap extends Middleware.Tag<SomeMiddlewareWrap>()("SomeMiddlewareWrap", {
-  provides: Some,
-  wrap: true
-})({
-  effect: Effect.gen(function*() {
-    // yield* Effect.context<"test-dep">()
-    return ({ next }) => next.pipe(Effect.provideService(Some, new Some({ a: 1 })))
-  })
-}) {
-}
-
-export class SomeElseMiddleware extends Middleware.Tag<SomeElseMiddleware>()("SomeElseMiddleware", {
-  provides: SomeElse,
-  wrap: true
-})({
-  effect: Effect.gen(function*() {
-    // yield* Effect.context<"test-dep">()
-    return ({ next }) =>
-      Effect.gen(function*() {
-        // yield* Effect.context<"test-dep2">()
-        return yield* next.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })))
-      })
-  })
-}) {
-}
-
-export class RequiresSomeMiddleware extends Middleware.Tag<RequiresSomeMiddleware>()("RequiresSomeMiddleware", {
+export class RequiresSomeMiddleware extends TagService<RequiresSomeMiddleware>()("RequiresSomeMiddleware", {
   requires: [Some],
   wrap: true
 })({
@@ -79,7 +39,7 @@ const _middlewareSideways = makeMiddleware(RequestContextMap)
 const _middlewareSidewaysFully = makeMiddleware(RequestContextMap)
   .middleware(RequiresSomeMiddleware, SomeMiddleware, RequireRoles, AllowAnonymous, Test, SomeElseMiddleware)
 
-const _middleware3Bis = makeMiddleware(RequestContextMap)
+export const _middleware3Bis = makeMiddleware(RequestContextMap)
   .middleware(RequiresSomeMiddleware)
   .middleware(SomeMiddlewareWrap)
   .middleware(RequireRoles)
@@ -88,11 +48,7 @@ const _middleware3Bis = makeMiddleware(RequestContextMap)
 
 expectTypeOf(_middlewareSideways).toEqualTypeOf<typeof middleware3>()
 expectTypeOf(_middlewareSidewaysFully).toEqualTypeOf<typeof _middlewareSideways>()
-// expectTypeOf(_middleware3Bis).toEqualTypeOf<typeof middleware3>() // is not the same because SomeMiddlewareWrap is not SomeMiddleware
-
-type Default = typeof middleware3["Default"]
-type LayerContext = Layer.Layer.Context<Default>
-expectTypeOf({} as LayerContext).toEqualTypeOf<SomeService>()
+expectTypeOf(_middleware3Bis).not.toEqualTypeOf<typeof middleware3>() // is not the same because SomeMiddlewareWrap is not SomeMiddleware
 
 class TestRequest extends S.TaggedRequest<Test>("Test")("Test", {
   payload: {},
@@ -112,7 +68,16 @@ const testSuite = (_mw: typeof middleware3) =>
           rpc: { ...Rpc.fromTaggedRequest(TestRequest), annotations: Context.make(_mw.requestContext, {}) },
           next: Effect.void as unknown as Effect<SuccessValue, never, any>
         }
-        const layer = _mw.Default.pipe(Layer.provide(SomeService.toLayer()))
+        const layer = _mw.layer.pipe(
+          Layer.provide([
+            RequiresSomeMiddleware.Default,
+            SomeMiddlewareLive,
+            RequireRolesLive.pipe(Layer.provide(SomeService.toLayer())),
+            AllowAnonymousLive,
+            TestLive,
+            SomeElseMiddlewareLive
+          ])
+        )
         yield* Effect
           .gen(function*() {
             const mw = yield* _mw
@@ -194,6 +159,6 @@ const testSuite = (_mw: typeof middleware3) =>
   })
 
 testSuite(middleware3)
-testSuite(_middleware3Bis)
+// testSuite(_middleware3Bis)
 testSuite(_middlewareSideways)
 testSuite(_middlewareSidewaysFully)