@effect-app/infra 2.87.2 → 2.88.0

package/test/dist/fixtures.d.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, S, Scope } from "effect-app";
-import { NotLoggedInError, type RPCContextMap, UnauthorizedError } from "effect-app/client";
+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;
@@ -37,7 +37,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, R_3 | Some> : Effect.Effect<X, never, Some>;
+    }) => 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>;
 };
 export declare class Some extends Some_base {
 }
@@ -67,16 +67,42 @@ declare const SomeElse_base: (abstract new (service: {
 };
 export declare class SomeElse extends SomeElse_base {
 }
-export type RequestContextMap = {
-    allowAnonymous: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
-    requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>;
-    test: RPCContextMap<never, typeof S.Never>;
+declare const SomeService_base: (abstract new (service: {
+    a: number;
+}) => Readonly<{
+    a: number;
+}> & Context.TagClassShape<"SomeService", {
+    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>;
+    };
+    toLayerScoped: {
+        (): import("effect/Layer").Layer<SomeService, never, never>;
+        <E_1, R_2>(eff: Effect.Effect<Context.TagClassShape<any, any>, E_1, R_2>): import("effect/Layer").Layer<SomeService, E_1, Exclude<R_2, Scope.Scope>>;
+    };
+    of: (service: Context.TagClassShape<any, any>) => SomeService;
+    make: Effect.Effect<SomeService, never, never>;
+} & Context.Tag<SomeService, SomeService> & {
+    a: Effect.Effect<number, never, SomeService>;
+} & {
+    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>;
+};
+export declare class SomeService extends SomeService_base {
+}
+export declare const RequestContextMap: {
+    readonly allowAnonymous: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
+    readonly requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>;
+    readonly test: RPCContextMap.RPCContextMap<never, typeof S.Never>;
 };
+type _RequestContextMap = typeof RequestContextMap;
+export interface RequestContextMap extends _RequestContextMap {
+}
 declare const AllowAnonymous_base: Middleware.TagClass<AllowAnonymous, "AllowAnonymous", {
-    readonly dynamic: {
-        key: "allowAnonymous";
-        settings: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
-    };
+    readonly dynamic: Middleware.RpcDynamic<"allowAnonymous", RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>>;
     readonly requires: typeof SomeElse;
 }> & {
     Default: import("effect/Layer").Layer<AllowAnonymous, never, never>;
@@ -84,23 +110,17 @@ declare const AllowAnonymous_base: Middleware.TagClass<AllowAnonymous, "AllowAno
 export declare class AllowAnonymous extends AllowAnonymous_base {
 }
 declare const RequireRoles_base: Middleware.TagClass<RequireRoles, "RequireRoles", {
-    readonly dynamic: {
-        key: "requireRoles";
-        settings: RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>;
-    };
+    readonly dynamic: Middleware.RpcDynamic<"requireRoles", RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>>;
     readonly wrap: true;
     readonly dependsOn: readonly [typeof AllowAnonymous];
 }> & {
-    Default: import("effect/Layer").Layer<RequireRoles, never, Some>;
+    Default: import("effect/Layer").Layer<RequireRoles, never, SomeService>;
 };
 export declare class RequireRoles extends RequireRoles_base {
 }
 declare const Test_base: Middleware.TagClass<Test, "Test", {
     readonly wrap: true;
-    readonly dynamic: {
-        key: "test";
-        settings: RPCContextMap<never, typeof S.Never>;
-    };
+    readonly dynamic: Middleware.RpcDynamic<"test", RPCContextMap.RPCContextMap<never, typeof S.Never>>;
 }> & {
     Default: import("effect/Layer").Layer<Test, never, never>;
 };
@@ -116,31 +136,5 @@ declare const CustomError2_base: S.TaggedErrorClass<NotLoggedInError, "CustomErr
 }>;
 export declare class CustomError2 extends CustomError2_base {
 }
-declare const SomeService_base: (abstract new (service: {
-    a: number;
-}) => Readonly<{
-    a: number;
-}> & Context.TagClassShape<"SomeService", {
-    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>;
-    };
-    toLayerScoped: {
-        (): import("effect/Layer").Layer<SomeService, never, never>;
-        <E_1, R_2>(eff: Effect.Effect<Context.TagClassShape<any, any>, E_1, R_2>): import("effect/Layer").Layer<SomeService, E_1, Exclude<R_2, Scope.Scope>>;
-    };
-    of: (service: Context.TagClassShape<any, any>) => SomeService;
-    make: Effect.Effect<SomeService, never, never>;
-} & Context.Tag<SomeService, SomeService> & {
-    a: Effect.Effect<number, never, SomeService>;
-} & {
-    use: <X>(body: (_: {
-        a: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, SomeService | R_3> : Effect.Effect<X, never, SomeService>;
-};
-export declare class SomeService extends SomeService_base {
-}
 export {};
 //# sourceMappingURL=fixtures.d.ts.map

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,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAE3F,OAAO,EAAc,UAAU,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;;;AAE9D,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;AAEpG,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC,OAAO,WAAW,CAAC,EAAE,OAAO,gBAAgB,CAAC,CAAA;IACrF,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;IAClF,IAAI,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAA;CAC3C,CAAA;;;;;;;;;;AAED,qBAAa,cAAe,SAAQ,mBA4BlC;CACD;;;;;;;;;;;AAGD,qBAAa,YAAa,SAAQ,iBA6BhC;CACD;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SASxB;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAGxF,qBAAa,WAAY,SAAQ,gBAAgE;CAAG"}
+{"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,EAAc,UAAU,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;;;AAE9D,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;AAOpG,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"}

package/test/dist/fixtures.js

@@ -1,5 +1,5 @@
 import { Context, Effect, Option, S, Scope } from "effect-app";
-import { NotLoggedInError, UnauthorizedError } from "effect-app/client";
+import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client";
 import { TaggedError } from "effect-app/Schema";
 import { contextMap, Middleware } from "../src/api/routing.js";
 export class UserProfile extends Context.assignTag("UserProfile")(S.Class("UserProfile")({
@@ -11,8 +11,21 @@ export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))()
 }
 export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))() {
 }
+const MakeSomeService = Effect.succeed({ a: 1 });
+export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)() {
+}
+// TODO: null as never sucks
+// why [UserProfile] is needed? AllowAnonymous triggers an error if just UserProfile without []
+// [] requires return Context, non [] requires return the Service instance
+//
+// consider if we want to support Context of one Service
+export const RequestContextMap = {
+    allowAnonymous: RPCContextMap.makeInverted([UserProfile], NotLoggedInError),
+    requireRoles: RPCContextMap.makeCustom(null, UnauthorizedError, Array()),
+    test: RPCContextMap.make(null, S.Never)
+};
 export class AllowAnonymous extends Middleware.Tag()("AllowAnonymous", {
-    dynamic: contextMap()("allowAnonymous", [UserProfile]),
+    dynamic: contextMap(RequestContextMap, "allowAnonymous"),
     requires: SomeElse
 })({
     effect: Effect.gen(function* () {
@@ -34,9 +47,10 @@ export class AllowAnonymous extends Middleware.Tag()("AllowAnonymous", {
     })
 }) {
 }
+// TODO: don't expect service when it's wrap
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 export class RequireRoles extends Middleware.Tag()("RequireRoles", {
-    dynamic: contextMap()("requireRoles", null), // TODO
+    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,
@@ -44,7 +58,7 @@ export class RequireRoles extends Middleware.Tag()("RequireRoles", {
     dependsOn: [AllowAnonymous]
 })({
     effect: Effect.gen(function* () {
-        yield* Some;
+        yield* SomeService;
         return Effect.fnUntraced(function* ({ config, next }) {
             // we don't know if the service will be provided or not, so we use option..
             const userProfile = yield* Effect.serviceOption(UserProfile);
@@ -61,9 +75,10 @@ export class RequireRoles extends Middleware.Tag()("RequireRoles", {
     })
 }) {
 }
+// TODO: don't expect service when it's wrap
 export class Test extends Middleware.Tag()("Test", {
     wrap: true,
-    dynamic: contextMap()("test", null) // TODO
+    dynamic: contextMap(RequestContextMap, "test")
 })({
     effect: Effect.gen(function* () {
         return Effect.fn(function* ({ next }) {
@@ -76,7 +91,4 @@ export class CustomError1 extends TaggedError()("CustomError1", {}) {
 }
 export class CustomError2 extends TaggedError()("CustomError1", {}) {
 }
-const MakeSomeService = Effect.succeed({ a: 1 });
-export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)() {
-}
-//# 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":"AACA,OAAO,EAAkB,KAAK,EAAK,MAAM,YAAY,CAAA;AAErD,OAAO,EAAkB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAwD,IAAI,EAAE,QAAQ,EAAQ,MAAM,eAAe,CAAA;;;;;;AAE1G,qBAAa,cAAe,SAAQ,mBAUlC;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":"AACA,OAAO,EAAkB,KAAK,EAAK,MAAM,YAAY,CAAA;AAErD,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"}

package/test/fixtures.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Option, S, Scope } from "effect-app"
-import { NotLoggedInError, type RPCContextMap, UnauthorizedError } from "effect-app/client"
+import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client"
 import { TaggedError } from "effect-app/Schema"
 import { contextMap, Middleware } from "../src/api/routing.js"
 
@@ -13,15 +13,25 @@ export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("Us
 
 export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<Some>() {}
 export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))<SomeElse>() {}
+const MakeSomeService = Effect.succeed({ a: 1 })
+export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
 
-export type RequestContextMap = {
-  allowAnonymous: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>
-  requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>
-  test: RPCContextMap<never, typeof S.Never>
-}
+// TODO: null as never sucks
+// why [UserProfile] is needed? AllowAnonymous triggers an error if just UserProfile without []
+// [] requires return Context, non [] requires return the Service instance
+//
+// consider if we want to support Context of one Service
+export const RequestContextMap = {
+  allowAnonymous: RPCContextMap.makeInverted([UserProfile], NotLoggedInError),
+  requireRoles: RPCContextMap.makeCustom(null as never, UnauthorizedError, Array<string>()),
+  test: RPCContextMap.make(null as never, S.Never)
+} as const
+
+type _RequestContextMap = typeof RequestContextMap
+export interface RequestContextMap extends _RequestContextMap {}
 
 export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnonymous", {
-  dynamic: contextMap<RequestContextMap>()("allowAnonymous", [UserProfile]),
+  dynamic: contextMap(RequestContextMap, "allowAnonymous"),
   requires: SomeElse
 })({
   effect: Effect.gen(function*() {
@@ -51,9 +61,10 @@ 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", {
-  dynamic: contextMap<RequestContextMap>()("requireRoles", null as never), // TODO
+  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,
@@ -61,7 +72,7 @@ export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles",
   dependsOn: [AllowAnonymous]
 })({
   effect: Effect.gen(function*() {
-    yield* Some
+    yield* SomeService
     return Effect.fnUntraced(
       function*({ config, next }) {
         // we don't know if the service will be provided or not, so we use option..
@@ -84,9 +95,10 @@ 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", {
   wrap: true,
-  dynamic: contextMap<RequestContextMap>()("test", null as never) // TODO
+  dynamic: contextMap(RequestContextMap, "test")
 })({
   effect: Effect.gen(function*() {
     return Effect.fn(function*({ next }) {
@@ -97,6 +109,3 @@ export class Test extends Middleware.Tag<Test>()("Test", {
 
 export class CustomError1 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
 export class CustomError2 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
-
-const MakeSomeService = Effect.succeed({ a: 1 })
-export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}

package/test/layerUtils.test.ts

@@ -1,6 +1,5 @@
-import { it } from "@effect/vitest"
+import { expectTypeOf, it } from "@effect/vitest"
 import { type Layer } from "effect"
-import { expectTypeOf } from "vitest/index.cjs"
 import { type LayerUtils } from "../src/api/layerUtils.js"
 
 it("works", () => {

package/test/requires.test.ts

@@ -1,8 +1,8 @@
-import { expect, expectTypeOf, it } from "@effect/vitest"
+import { describe, expect, expectTypeOf, it } from "@effect/vitest"
 import { Effect, Either, Layer, S } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { makeMiddleware, Middleware } from "../src/api/routing.js"
-import { AllowAnonymous, type RequestContextMap, RequireRoles, Some, SomeElse, Test } from "./fixtures.js"
+import { AllowAnonymous, RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
 
 export class SomeMiddleware extends Middleware.Tag<SomeMiddleware>()("SomeMiddleware", {
   provides: Some
@@ -17,6 +17,18 @@ export class SomeMiddleware extends Middleware.Tag<SomeMiddleware>()("SomeMiddle
 }) {
 }
 
+// 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
@@ -48,109 +60,119 @@ export class RequiresSomeMiddleware extends Middleware.Tag<RequiresSomeMiddlewar
 }) {
 }
 
-it("requires gets enforced", async () => {
-  const middleware3 = makeMiddleware<RequestContextMap>()
-    .middleware(RequiresSomeMiddleware)
-    .middleware(SomeMiddleware)
-    .middleware(RequireRoles)
-    .middleware(AllowAnonymous, Test)
-    .middleware(SomeElseMiddleware)
+const middleware3 = makeMiddleware(RequestContextMap)
+  .middleware(RequiresSomeMiddleware)
+  .middleware(SomeMiddleware)
+  .middleware(RequireRoles)
+  .middleware(AllowAnonymous, Test)
+  .middleware(SomeElseMiddleware)
 
-  const layer = middleware3.Default.pipe(Layer.provide(Layer.succeed(Some, new Some({ a: 1 }))))
+const _middlewareSideways = makeMiddleware(RequestContextMap)
+  .middleware(RequiresSomeMiddleware)
+  .middleware(SomeMiddleware)
+  .middleware(RequireRoles, AllowAnonymous, Test)
+  .middleware(SomeElseMiddleware)
 
-  type Default = typeof middleware3["Default"]
-  type LayerContext = Layer.Layer.Context<Default>
-  expectTypeOf({} as LayerContext).toEqualTypeOf<Some>()
+const _middlewareSidewaysFully = makeMiddleware(RequestContextMap)
+  .middleware(RequiresSomeMiddleware, SomeMiddleware, RequireRoles, AllowAnonymous, Test, SomeElseMiddleware)
 
-  await Effect
-    .gen(function*() {
-      const mw = yield* middleware3
-      const mwM = mw.effect(
-        Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
-        (_req) => Effect.void,
-        "some-module"
-      )
-      yield* mwM({}, { "x-user": "test-user", "x-is-manager": "true" })
-    })
-    .pipe(
-      Effect.scoped,
-      Effect.provide(layer),
-      Effect.runPromise
-    )
+const _middleware3Bis = makeMiddleware(RequestContextMap)
+  .middleware(RequiresSomeMiddleware)
+  .middleware(SomeMiddlewareWrap)
+  .middleware(RequireRoles)
+  .middleware(AllowAnonymous, Test)
+  .middleware(SomeElseMiddleware)
 
-  await Effect
-    .gen(function*() {
-      const mw = yield* middleware3
-      const mwM = mw.effect(
-        Object.assign({}, S.Any, { config: { allowAnonymous: true } }),
-        (_req) => Effect.void,
-        "some-module"
-      )
-      yield* mwM({}, {})
-    })
-    .pipe(
-      Effect.scoped,
-      Effect.provide(layer),
-      Effect.runPromise
-    )
+expectTypeOf(_middlewareSideways).toEqualTypeOf<typeof middleware3>()
+expectTypeOf(_middlewareSidewaysFully).toEqualTypeOf<typeof _middlewareSideways>()
+expectTypeOf(_middleware3Bis).toEqualTypeOf<typeof middleware3>()
+
+type Default = typeof middleware3["Default"]
+type LayerContext = Layer.Layer.Context<Default>
+expectTypeOf({} as LayerContext).toEqualTypeOf<SomeService>()
 
-  expect(
-    await Effect
-      .gen(function*() {
-        const mw = yield* middleware3
-        const mwM = mw.effect(
-          Object.assign({}, S.Any, { config: {} }),
-          (_req) => Effect.void,
-          "some-module"
+const testSuite = (_mw: typeof middleware3) =>
+  describe("middleware" + _mw, () => {
+    it.effect(
+      "works",
+      Effect.fn(function*() {
+        const layer = _mw.Default.pipe(Layer.provide(SomeService.toLayer()))
+        yield* Effect
+          .gen(function*() {
+            const mw = yield* _mw
+            const mwM = mw.effect(
+              Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
+              (_req) => Effect.void,
+              "some-module"
+            )
+            yield* mwM({}, { "x-user": "test-user", "x-is-manager": "true" })
+          })
+          .pipe(
+            Effect.scoped,
+            Effect.provide(layer)
+          )
+
+        expect(
+          yield* Effect
+            .gen(function*() {
+              const mw = yield* _mw
+              const mwM = mw.effect(
+                Object.assign({}, S.Any, { config: {} }),
+                (_req) => Effect.void,
+                "some-module"
+              )
+              yield* mwM({}, {})
+            })
+            .pipe(
+              Effect.scoped,
+              Effect.provide(layer),
+              Effect.either
+            )
         )
-        yield* mwM({}, {})
-      })
-      .pipe(
-        Effect.scoped,
-        Effect.provide(layer),
-        Effect.either,
-        Effect.runPromise
-      )
-  )
-    .toEqual(Either.left(new NotLoggedInError()))
+          .toEqual(Either.left(new NotLoggedInError()))
 
-  expect(
-    await Effect
-      .gen(function*() {
-        const mw = yield* middleware3
-        const mwM = mw.effect(
-          Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
-          (_req) => Effect.void,
-          "some-module"
+        expect(
+          yield* Effect
+            .gen(function*() {
+              const mw = yield* _mw
+              const mwM = mw.effect(
+                Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
+                (_req) => Effect.void,
+                "some-module"
+              )
+              yield* mwM({}, {})
+            })
+            .pipe(
+              Effect.scoped,
+              Effect.provide(layer),
+              Effect.either
+            )
         )
-        yield* mwM({}, {})
-      })
-      .pipe(
-        Effect.scoped,
-        Effect.provide(layer),
-        Effect.either,
-        Effect.runPromise
-      )
-  )
-    .toEqual(Either.left(new NotLoggedInError()))
+          .toEqual(Either.left(new NotLoggedInError()))
 
-  expect(
-    await Effect
-      .gen(function*() {
-        const mw = yield* middleware3
-        const mwM = mw.effect(
-          Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
-          (_req) => Effect.void,
-          "some-module"
+        expect(
+          yield* Effect
+            .gen(function*() {
+              const mw = yield* _mw
+              const mwM = mw.effect(
+                Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
+                (_req) => Effect.void,
+                "some-module"
+              )
+              yield* mwM({}, { "x-user": "test-user" })
+            })
+            .pipe(
+              Effect.scoped,
+              Effect.provide(layer),
+              Effect.either
+            )
         )
-        yield* mwM({}, { "x-user": "test-user" })
+          .toEqual(Either.left(new UnauthorizedError({ message: "don't have the right roles" })))
       })
-      .pipe(
-        Effect.scoped,
-        Effect.provide(layer),
-        Effect.either,
-        Effect.runPromise
-      )
-  )
-    .toEqual(Either.left(new UnauthorizedError({ message: "don't have the right roles" })))
-})
+    )
+  })
+
+testSuite(middleware3)
+testSuite(_middleware3Bis)
+testSuite(_middlewareSideways)
+testSuite(_middlewareSidewaysFully)