@effect-app/infra 2.85.0 → 2.87.0

package/test/controller.test.ts

@@ -1,46 +1,24 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
-import type { RequestContext } from "@effect-app/infra/RequestContext"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { type Array, Context, Effect, Layer, Option, S, Scope } from "effect-app"
-import { InvalidStateError, makeRpcClient, type RPCContextMap, UnauthorizedError } from "effect-app/client"
-import { Class, TaggedError } from "effect-app/Schema"
-import { contextMap, DefaultGenericMiddlewares, implementMiddleware, makeMiddleware, makeNewMiddleware, Middleware, Tag } from "../src/api/routing/middleware.js"
+import { Context, Effect, type Layer, S, Scope } from "effect-app"
+import { InvalidStateError, makeRpcClient, NotLoggedInError, UnauthorizedError } from "effect-app/client"
+import { DefaultGenericMiddlewares, makeMiddleware, Middleware, Tag } from "../src/api/routing/middleware.js"
 import { sort } from "../src/api/routing/tsort.js"
-import { SomeService } from "./query.test.js"
-
-export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
-  Class<UserProfile>("UserProfile")({
-    id: S.String,
-    roles: S.Array(S.String)
-  })
-) {
-}
-
-export class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLoggedInError", {
-  message: S.String
-}) {}
-
-export class CustomError1 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
-export class CustomError2 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
-
-export interface CTX {
-  context: RequestContext
-}
-
-export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<Some>() {}
-export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))<SomeElse>() {}
+import { AllowAnonymous, CustomError1, type RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 class MyContextProvider extends Middleware.Tag<MyContextProvider>()("MyContextProvider", {
-  provides: [Some]
+  provides: [Some],
+  requires: [SomeElse]
 })({
   effect: Effect.gen(function*() {
     yield* SomeService
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return Effect.fnUntraced(function*() {
+      yield* SomeElse
       // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
       yield* Scope.Scope
 
@@ -74,81 +52,19 @@ class MyContextProvider2 extends Middleware.Tag<MyContextProvider2>()("MyContext
 
 //
 
-export type RequestContextMap = {
-  allowAnonymous: RPCContextMap.Inverted<UserProfile, typeof NotLoggedInError>
-  requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>
-  test: RPCContextMap<never, typeof S.Never>
-}
-
 const Str = Context.GenericTag<"str", "str">("str")
-const Str2 = Context.GenericTag<"str2", "str">("str2")
-
-class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnonymous", {
-  dynamic: contextMap<RequestContextMap>()("allowAnonymous")
-})({
-  effect: Effect.gen(function*() {
-    return Effect.fnUntraced(
-      function*(options) {
-        yield* Scope.Scope // provided by HttpRouter.HttpRouter.Provided
-        const isLoggedIn = !!options.headers["x-user"]
-        if (!isLoggedIn) {
-          if (!options.config.allowAnonymous) {
-            return yield* new NotLoggedInError({ message: "Not logged in" })
-          }
-          return Option.none()
-        }
-        return Option.some(Context.make(
-          UserProfile,
-          { id: "whatever", roles: ["user", "manager"] }
-        ))
-      }
-    )
-  })
-}) {
-}
-
-// @effect-diagnostics-next-line missingEffectServiceDependency:off
-class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles", {
-  dynamic: contextMap<RequestContextMap>()("requireRoles"),
-  // 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* Some
-    return Effect.fnUntraced(
-      function*(options) {
-        // we don't know if the service will be provided or not, so we use option..
-        const userProfile = yield* Effect.serviceOption(UserProfile)
-        const { requireRoles } = options.config
-        if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
-          return yield* new UnauthorizedError({ message: "don't have the right roles" })
-        }
-        return Option.none<Context<never>>()
-      }
-    )
-  })
-}) {
-}
-
-class Test extends Middleware.Tag<Test>()("Test", { dynamic: contextMap<RequestContextMap>()("test") })({
-  effect: Effect.gen(function*() {
-    return Effect.fn(function*(_options) {
-      return Option.none<Context<never>>()
-    })
-  })
-}) {}
 
 export class BogusMiddleware extends Tag<BogusMiddleware>()("BogusMiddleware", {
   provides: SomeService,
   wrap: true
 })({
   effect: Effect.gen(function*() {
+    yield* Str
     // yield* Effect.context<"test-dep">()
-    return (options) =>
+    return ({ next }) =>
       Effect.gen(function*() {
         // yield* Effect.context<"test-dep2">()
-        return yield* options.next.pipe(Effect.provideService(SomeService, null as any))
+        return yield* next.pipe(Effect.provideService(SomeService, null as any))
       })
   })
 }) {
@@ -156,61 +72,31 @@ export class BogusMiddleware extends Tag<BogusMiddleware>()("BogusMiddleware", {
 
 const genericMiddlewares = [
   ...DefaultGenericMiddlewares,
-  // BogusMiddleware,
-  MyContextProvider2,
-  MyContextProvider
+  BogusMiddleware,
+  MyContextProvider2
 ] as const
 
-// TODO: eventually it might be nice if we have total control over order somehow..
-// [ AddRequestNameToSpanContext, RequestCacheContext, UninterruptibleMiddleware, Dynamic(or individual, AllowAnonymous, RequireRoles, Test - or whichever order) ]
-const middleware = makeMiddleware<RequestContextMap>()({
-  genericMiddlewares,
-
-  dynamicMiddlewares: {
-    requireRoles: RequireRoles,
-    allowAnonymous: AllowAnonymous,
-    test: Test
-  },
-
-  dependencies: [Layer.effect(Str2, Str)],
-  execute: (maker) =>
-    Effect.gen(function*() {
-      return maker(
-        (_schema, handler) => (req, headers) =>
-          // contextProvider and dynamicMiddlewares are already provided here.
-          // aka this runs "last"
-          Effect
-            .gen(function*() {
-              // you can use only HttpRouter.HttpRouter.Provided here as additional context
-              // and what ContextProvider provides too
-              // const someElse = yield* SomeElse
-              yield* Some // provided by ContextProvider
-              yield* Scope.Scope // provided by HttpRouter.HttpRouter.Provided
-
-              return yield* handler(req, headers)
-            })
-      )
-    })
-})
-
-const middleware2 = makeMiddleware<RequestContextMap>()({
-  // TODO: I guess it makes sense to support just passing array of context providers too, like dynamicMiddlewares?
-  genericMiddlewares: [...DefaultGenericMiddlewares, BogusMiddleware, MyContextProvider2, MyContextProvider],
-  // or is the better api to use constructors outside, like how contextProvider is used now?
-  dynamicMiddlewares: {
-    requireRoles: RequireRoles,
-    allowAnonymous: AllowAnonymous,
-    test: Test
-  }
-})
-
-export const middleware3 = makeNewMiddleware<RequestContextMap>()(
-  ...genericMiddlewares
-)
-  .addDynamicMiddleware(AllowAnonymous, RequireRoles)
-  .addDynamicMiddleware(Test)
-
-expectTypeOf(middleware3).toEqualTypeOf<typeof middleware2>()
+const middleware = makeMiddleware<RequestContextMap>()
+  .middleware(MyContextProvider)
+  .middleware(
+    RequireRoles,
+    Test
+  )
+  .middleware(AllowAnonymous)
+  .middleware(...genericMiddlewares)
+// dependencies: [Layer.effect(Str2, Str)],
+
+const middleware2 = makeMiddleware<RequestContextMap>()
+  .middleware(MyContextProvider)
+  .middleware(RequireRoles, Test)
+  .middleware(AllowAnonymous)
+  .middleware(...DefaultGenericMiddlewares, BogusMiddleware, MyContextProvider2)
+
+export const middleware3 = makeMiddleware<RequestContextMap>()
+  .middleware(...genericMiddlewares)
+  .middleware(AllowAnonymous, RequireRoles)
+  .middleware(Test)
+  .middleware(BogusMiddleware)
 
 export type RequestConfig = {
   /** Disable authentication requirement */
@@ -360,7 +246,7 @@ it("sorts based on requirements", () => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched = matchAll({ router })
-expectTypeOf({} as Layer.Context<typeof matched>).toEqualTypeOf<SomeService | "str">()
+expectTypeOf({} as Layer.Context<typeof matched>).toEqualTypeOf<SomeService | Some | "str">()
 
 type makeContext = MakeContext<typeof router.make>
 expectTypeOf({} as MakeErrors<typeof router.make>).toEqualTypeOf<InvalidStateError>()
@@ -432,16 +318,10 @@ const router2 = r2.Router(Something)({
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched2 = matchAll({ router: router2 })
-expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<SomeService>()
+expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<Some | SomeService | "str">()
 
 type makeContext2 = MakeContext<typeof router2.make>
 expectTypeOf({} as MakeErrors<typeof router2.make>).toEqualTypeOf<InvalidStateError>()
 expectTypeOf({} as makeContext2).toEqualTypeOf<
   SomethingService | SomethingRepo | SomethingService2
 >()
-
-export const dynamicMiddlewares = implementMiddleware<RequestContextMap>()({
-  requireRoles: RequireRoles,
-  allowAnonymous: AllowAnonymous,
-  test: Test
-})

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

@@ -1 +1 @@
-{"version":3,"file":"contextProvider.test.d.ts","sourceRoot":"","sources":["../contextProvider.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEnD,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AA8E7C,eAAO,MAAM,mBAAmB;;CAkB9B,CAAA;AACF,eAAO,MAAM,sBAAsB;;CAkBjC,CAAA;AAMF,eAAO,MAAM,gBAAgB;;CAA0B,CAAA;AACvD,eAAO,MAAM,gBAAgB,kMAA2C,CAAA;AAIxE,eAAO,MAAM,mBAAmB;;CAA6B,CAAA;AAC7D,eAAO,MAAM,mBAAmB,kMAA8C,CAAA;AAQ9E,eAAO,MAAM,iBAAiB;;CAA2B,CAAA;AACzD,eAAO,MAAM,iBAAiB,6MAA+D,CAAA;AAI7F,eAAO,MAAM,oBAAoB;;CAA8B,CAAA;AAC/D,eAAO,MAAM,oBAAoB,6MAAqE,CAAA"}
+{"version":3,"file":"contextProvider.test.d.ts","sourceRoot":"","sources":["../contextProvider.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEnD,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AA8EzE,eAAO,MAAM,mBAAmB;;CAkB9B,CAAA;AACF,eAAO,MAAM,sBAAsB;;CAkBjC,CAAA;AAMF,eAAO,MAAM,gBAAgB;;CAA0B,CAAA;AACvD,eAAO,MAAM,gBAAgB,kMAA2C,CAAA;AAIxE,eAAO,MAAM,mBAAmB;;CAA6B,CAAA;AAC7D,eAAO,MAAM,mBAAmB,kMAA8C,CAAA;AAQ9E,eAAO,MAAM,iBAAiB;;CAA2B,CAAA;AACzD,eAAO,MAAM,iBAAiB,6MAA+D,CAAA;AAI7F,eAAO,MAAM,oBAAoB;;CAA8B,CAAA;AAC/D,eAAO,MAAM,oBAAoB,6MAAqE,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAE7F,OAAO,EAAW,MAAM,EAAE,KAAK,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElE,OAAO,EAA6C,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAE7G,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;AAgCrI,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAanC;CACD;AAwBD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;YAIM,CAAA;AAE9B,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;2HAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAiC,CAAA;AAE1E,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA"}

package/test/dist/fixtures.d.ts

@@ -0,0 +1,146 @@
+import { Context, Effect, S, Scope } from "effect-app";
+import { NotLoggedInError, type 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> & {
+        withDefault: S.PropertySignature<":", readonly string[], never, ":", readonly string[], true, never>;
+    };
+}, {
+    readonly id: string;
+    readonly roles: readonly string[];
+}, never, {
+    readonly id: string;
+    readonly roles: readonly string[];
+}, {}, {}> & Context.Tag<UserProfile, UserProfile>;
+export declare class UserProfile extends UserProfile_base {
+}
+declare const Some_base: (abstract new (service: {
+    a: number;
+}) => Readonly<{
+    a: number;
+}> & Context.TagClassShape<"Some", {
+    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>;
+    };
+    toLayerScoped: {
+        (): import("effect/Layer").Layer<Some, never, never>;
+        <E_1, R_2>(eff: Effect.Effect<Context.TagClassShape<any, any>, E_1, R_2>): import("effect/Layer").Layer<Some, E_1, Exclude<R_2, Scope.Scope>>;
+    };
+    of: (service: Context.TagClassShape<any, any>) => Some;
+    make: Effect.Effect<Some, never, never>;
+} & Context.Tag<Some, Some> & {
+    a: Effect.Effect<number, never, Some>;
+} & {
+    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>;
+};
+export declare class Some extends Some_base {
+}
+declare const SomeElse_base: (abstract new (service: {
+    b: number;
+}) => Readonly<{
+    b: number;
+}> & Context.TagClassShape<"SomeElse", {
+    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>;
+    };
+    toLayerScoped: {
+        (): import("effect/Layer").Layer<SomeElse, never, never>;
+        <E_1, R_2>(eff: Effect.Effect<Context.TagClassShape<any, any>, E_1, R_2>): import("effect/Layer").Layer<SomeElse, E_1, Exclude<R_2, Scope.Scope>>;
+    };
+    of: (service: Context.TagClassShape<any, any>) => SomeElse;
+    make: Effect.Effect<SomeElse, never, never>;
+} & Context.Tag<SomeElse, SomeElse> & {
+    b: Effect.Effect<number, never, SomeElse>;
+} & {
+    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>;
+};
+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 AllowAnonymous_base: Middleware.TagClass<AllowAnonymous, "AllowAnonymous", {
+    readonly dynamic: {
+        key: "allowAnonymous";
+        settings: 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: {
+        key: "requireRoles";
+        settings: RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>;
+    };
+    readonly wrap: true;
+    readonly dependsOn: readonly [typeof AllowAnonymous];
+}> & {
+    Default: import("effect/Layer").Layer<RequireRoles, never, Some>;
+};
+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>;
+    };
+}> & {
+    Default: import("effect/Layer").Layer<Test, never, never>;
+};
+export declare class Test extends Test_base {
+}
+declare const CustomError1_base: S.TaggedErrorClass<NotLoggedInError, "CustomError1", {
+    readonly _tag: S.tag<"CustomError1">;
+}>;
+export declare class CustomError1 extends CustomError1_base {
+}
+declare const CustomError2_base: S.TaggedErrorClass<NotLoggedInError, "CustomError1", {
+    readonly _tag: S.tag<"CustomError1">;
+}>;
+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, R_3 | SomeService> : 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

@@ -0,0 +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"}

package/test/dist/fixtures.js

@@ -0,0 +1,82 @@
+import { Context, Effect, Option, S, Scope } from "effect-app";
+import { NotLoggedInError, 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")({
+    id: S.String,
+    roles: S.Array(S.String)
+})) {
+}
+export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))() {
+}
+export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))() {
+}
+export class AllowAnonymous extends Middleware.Tag()("AllowAnonymous", {
+    dynamic: contextMap()("allowAnonymous", [UserProfile]),
+    requires: SomeElse
+})({
+    effect: Effect.gen(function* () {
+        return Effect.fnUntraced(function* ({ config, headers }) {
+            yield* SomeElse;
+            yield* Scope.Scope; // provided by HttpRouter.HttpRouter.Provided
+            const isLoggedIn = !!headers["x-user"];
+            if (!isLoggedIn) {
+                if (!config.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"] : []]
+            })));
+        });
+    })
+}) {
+}
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class RequireRoles extends Middleware.Tag()("RequireRoles", {
+    dynamic: contextMap()("requireRoles", null), // TODO
+    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* Some;
+        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);
+            const { requireRoles } = config;
+            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 class Test extends Middleware.Tag()("Test", {
+    wrap: true,
+    dynamic: contextMap()("test", null) // TODO
+})({
+    effect: Effect.gen(function* () {
+        return Effect.fn(function* ({ next }) {
+            return yield* next;
+        });
+    })
+}) {
+}
+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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

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

@@ -0,0 +1 @@
+{"version":3,"file":"layerUtils.test.d.ts","sourceRoot":"","sources":["../layerUtils.test.ts"],"names":[],"mappings":""}

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

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAU,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYlF,qBAAa,SAAU,SAAQ,cAM7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IAEjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACvE;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAAgE;CAAG"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAqC,CAAC,EAAU,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAazE,qBAAa,SAAU,SAAQ,cAM7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IAEjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACvE"}

package/test/dist/requires.d.ts

@@ -0,0 +1,21 @@
+import { type RPCContextMap } from "effect-app/client";
+import { type DynamicMiddlewareMaker, type GenericMiddlewareMaker, type makeMiddlewareBasic, type RequestContextMapProvider } from "../src/api/routing.js";
+export interface MiddlewareM<RequestContext extends Record<string, RPCContextMap.Any>, Provided extends keyof RequestContext, Middlewares extends ReadonlyArray<GenericMiddlewareMaker>, DynamicMiddlewareProviders, MiddlewareR = never> {
+    middleware: <MW extends GenericMiddlewareMaker>(mw: MW) => DynamicMiddlewareMakerrsss<RequestContext, Provided, [
+        ...Middlewares,
+        MW
+    ], DynamicMiddlewareProviders, GenericMiddlewareMaker.ApplyServices<MW, MiddlewareR>>;
+}
+export interface Dynamic<RequestContext extends Record<string, RPCContextMap.Any>, Provided extends keyof RequestContext, Middlewares extends ReadonlyArray<GenericMiddlewareMaker>, DynamicMiddlewareProviders, out MiddlewareR> extends MiddlewareM<RequestContext, Provided, Middlewares, DynamicMiddlewareProviders, MiddlewareR> {
+    middleware: <MW extends DynamicMiddlewareMaker<RequestContext> | GenericMiddlewareMaker>(mw: MW) => MW extends DynamicMiddlewareMaker<RequestContext> ? DynamicMiddlewareMakerrsss<RequestContext, Provided | MW["dynamic"]["key"], Middlewares, DynamicMiddlewareProviders & {
+        [K in MW["dynamic"]["key"]]: MW;
+    }, GenericMiddlewareMaker.ApplyServices<MW, MiddlewareR>> : DynamicMiddlewareMakerrsss<RequestContext, Provided, [
+        ...Middlewares,
+        MW
+    ], DynamicMiddlewareProviders, GenericMiddlewareMaker.ApplyServices<MW, MiddlewareR>>;
+}
+type GetDynamicMiddleware<T, RequestContext extends Record<string, RPCContextMap.Any>> = T extends RequestContextMapProvider<RequestContext> ? T : never;
+type DynamicMiddlewareMakerrsss<RequestContext extends Record<string, RPCContextMap.Any>, Provided extends keyof RequestContext = never, Middlewares extends ReadonlyArray<GenericMiddlewareMaker> = [], DynamicMiddlewareProviders = unknown, MiddlewareR = never> = keyof Omit<RequestContext, Provided> extends never ? [MiddlewareR] extends [never] ? ReturnType<typeof makeMiddlewareBasic<RequestContext, GetDynamicMiddleware<DynamicMiddlewareProviders, RequestContext>, Middlewares>> & MiddlewareM<RequestContext, Provided, Middlewares, DynamicMiddlewareProviders, MiddlewareR> : MiddlewareM<RequestContext, Provided, Middlewares, DynamicMiddlewareProviders, MiddlewareR> : Dynamic<RequestContext, Provided, Middlewares, DynamicMiddlewareProviders, MiddlewareR>;
+export declare const makeNewMiddleware: <RequestContextMap extends Record<string, RPCContextMap.Any>>() => DynamicMiddlewareMakerrsss<RequestContextMap>;
+export {};
+//# sourceMappingURL=requires.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requires.d.ts","sourceRoot":"","sources":["../requires.ts"],"names":[],"mappings":"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"}

package/test/dist/requires.js

@@ -0,0 +1,27 @@
+import { Array, Either } from "effect-app";
+import { makeMiddleware } from "../src/api/routing.js";
+export const makeNewMiddleware = () => {
+    const make = makeMiddleware();
+    let capturedMiddlewares = [];
+    const it = {
+        middleware: (...middlewares) => {
+            for (const mw of middlewares) {
+                capturedMiddlewares = [mw, ...capturedMiddlewares];
+                if (mw.dynamic) {
+                    console.log("Adding dynamic middleware", mw.key, mw.dynamic.key);
+                }
+                else {
+                    console.log("Adding generic middleware", mw.key);
+                }
+            }
+            const [genericMiddlewares, dyn] = Array.partitionMap(capturedMiddlewares, (mw) => "dynamic" in mw && mw.dynamic
+                ? Either.right(mw)
+                : Either.left(mw));
+            const dynamicMiddlewares = dyn.reduce((prev, cur) => ({ ...prev, [cur.dynamic.key]: cur }), {});
+            // TODO: support dynamic and generic intertwined. treat them as one
+            return Object.assign(make({ genericMiddlewares, dynamicMiddlewares }), it);
+        }
+    };
+    return it;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWlyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9yZXF1aXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLFlBQVksQ0FBQTtBQUUxQyxPQUFPLEVBQTRELGNBQWMsRUFBNEQsTUFBTSx1QkFBdUIsQ0FBQTtBQWtIMUssTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBRXlCLEdBQUcsRUFBRTtJQUMxRCxNQUFNLElBQUksR0FBRyxjQUFjLEVBQU8sQ0FBQTtJQUNsQyxJQUFJLG1CQUFtQixHQUE2RCxFQUFFLENBQUE7SUFDdEYsTUFBTSxFQUFFLEdBQUc7UUFDVCxVQUFVLEVBQUUsQ0FBQyxHQUFHLFdBQWtCLEVBQUUsRUFBRTtZQUNwQyxLQUFLLE1BQU0sRUFBRSxJQUFJLFdBQVcsRUFBRSxDQUFDO2dCQUM3QixtQkFBbUIsR0FBRyxDQUFDLEVBQUUsRUFBRSxHQUFHLG1CQUFtQixDQUFDLENBQUE7Z0JBQ2xELElBQUksRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDO29CQUNmLE9BQU8sQ0FBQyxHQUFHLENBQUMsMkJBQTJCLEVBQUUsRUFBRSxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFBO2dCQUNsRSxDQUFDO3FCQUFNLENBQUM7b0JBQ04sT0FBTyxDQUFDLEdBQUcsQ0FBQywyQkFBMkIsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUE7Z0JBQ2xELENBQUM7WUFDSCxDQUFDO1lBQ0QsTUFBTSxDQUFDLGtCQUFrQixFQUFFLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQyxZQUFZLENBQ2xELG1CQUFtQixFQUNuQixDQUFDLEVBQUUsRUFBRSxFQUFFLENBQ0wsU0FBUyxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsT0FBTztnQkFDM0IsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBaUMsQ0FBQztnQkFDakQsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBNEIsQ0FBQyxDQUNoRCxDQUFBO1lBQ0QsTUFBTSxrQkFBa0IsR0FBRyxHQUFHLENBQUMsTUFBTSxDQUNuQyxDQUFDLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxHQUFHLElBQUksRUFBRSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsRUFDcEQsRUFBeUIsQ0FDMUIsQ0FBQTtZQUNELG1FQUFtRTtZQUNuRSxPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsa0JBQWtCLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFBO1FBQzVFLENBQUM7S0FDRixDQUFBO0lBQ0QsT0FBTyxFQUFTLENBQUE7QUFDbEIsQ0FBQyxDQUFBIn0=

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

@@ -0,0 +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"}