@effect-app/infra 2.85.0 → 2.86.0

package/src/api/routing/middleware/middleware-api.ts

@@ -1,4 +1,4 @@
-import { type NonEmptyReadonlyArray } from "effect-app"
+import { Array, Either, type NonEmptyArray } from "effect-app"
 import { type RPCContextMap } from "effect-app/client"
 import { type DynamicMiddlewareMaker, type GenericMiddlewareMaker, makeMiddleware, type makeMiddlewareBasic, type RequestContextMapProvider } from "../../routing.js"
 
@@ -9,41 +9,128 @@ export const contextMap = <RequestContextMap>() => <K extends keyof RequestConte
   settings: null as any as RequestContextMap[typeof a]
 })
 
-type DynamicMiddlewareMakerrsss<
+export interface MiddlewareM<
   RequestContext extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContext,
-  Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
-  DynamicMiddlewareProviders extends RequestContextMapProvider<RequestContext>
-> = keyof Omit<RequestContext, Provided> extends never
-  ? ReturnType<typeof makeMiddlewareBasic<RequestContext, DynamicMiddlewareProviders, Middlewares>>
-  : {
-    addDynamicMiddleware: <MW extends NonEmptyReadonlyArray<DynamicMiddlewareMaker<RequestContext>>>(
-      ...middlewares: MW
-    ) => DynamicMiddlewareMakerrsss<
+  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
+  DynamicMiddlewareProviders,
+  // out MiddlewareR = never
+  MiddlewareR = never
+> {
+  middleware<MW extends NonEmptyArray<GenericMiddlewareMaker>>(
+    ...mw: MW
+  ): DynamicMiddlewareMakerrsss<
+    RequestContext,
+    Provided,
+    [...Middlewares, ...MW],
+    DynamicMiddlewareProviders,
+    GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
+  >
+}
+
+export interface MiddlewareDynamic<
+  RequestContext extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContext,
+  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
+  DynamicMiddlewareProviders,
+  out MiddlewareR
+> {
+  // TODO: this still allows to mix both types of middleware but with bad typing result
+  // either have to block it, or implement the support properly.
+  middleware<MW extends NonEmptyArray<DynamicMiddlewareMaker<RequestContext>> | NonEmptyArray<GenericMiddlewareMaker>>(
+    ...mw: MW
+  ): [MW] extends [NonEmptyArray<DynamicMiddlewareMaker<RequestContext>>] ? DynamicMiddlewareMakerrsss<
       RequestContext,
       Provided | MW[number]["dynamic"]["key"],
       Middlewares,
       & DynamicMiddlewareProviders
       & {
-        [K in keyof MW as MW[K] extends DynamicMiddlewareMaker<RequestContext> ? MW[K]["dynamic"]["key"] : never]: MW[K]
-      }
+        [U in MW[number] as U["dynamic"]["key"]]: U
+      },
+      GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
     >
-  }
+    : DynamicMiddlewareMakerrsss<
+      RequestContext,
+      Provided,
+      [...Middlewares, ...MW],
+      DynamicMiddlewareProviders,
+      GenericMiddlewareMaker.ApplyManyServices<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
+        >
+      >
+      // & {
+      //   MiddlewareR: MiddlewareR
+      //   Provided: Provided
+      //   Middlewares: Middlewares
+      //   DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
+      // }
+      & MiddlewareM<
+        RequestContext,
+        Provided,
+        Middlewares,
+        DynamicMiddlewareProviders,
+        MiddlewareR
+      >
+  : MiddlewareM<
+    RequestContext,
+    Provided,
+    Middlewares,
+    DynamicMiddlewareProviders,
+    MiddlewareR
+  >
+  : MiddlewareDynamic<
+    RequestContext,
+    Provided,
+    Middlewares,
+    DynamicMiddlewareProviders,
+    MiddlewareR
+  >
 
 export const makeNewMiddleware: <
   RequestContextMap extends Record<string, RPCContextMap.Any>
->() => <Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>>(
-  ...genericMiddlewares: Middlewares
-) => DynamicMiddlewareMakerrsss<RequestContextMap, never, Middlewares, never> = () => (...genericMiddlewares) => {
-  const dynamicMiddlewares: Record<string, any> = {} as any
+>() => DynamicMiddlewareMakerrsss<RequestContextMap> = () => {
   const make = makeMiddleware<any>()
+  let capturedMiddlewares: (DynamicMiddlewareMaker<any> | GenericMiddlewareMaker)[] = []
   const it = {
-    addDynamicMiddleware: (...middlewares: any[]) => {
-      for (const a of middlewares) {
-        console.log("Adding dynamic middleware", a, a.dynamic, Object.keys(a))
-        dynamicMiddlewares[a.dynamic.key] = a
+    middleware: (...middlewares: any[]) => {
+      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)
+        }
       }
-      return Object.assign(make({ genericMiddlewares: genericMiddlewares as any, dynamicMiddlewares }), it)
+      const [genericMiddlewares, dyn] = Array.partitionMap(
+        capturedMiddlewares,
+        (mw) =>
+          "dynamic" in mw && mw.dynamic
+            ? Either.right(mw as DynamicMiddlewareMaker<any>)
+            : Either.left(mw as GenericMiddlewareMaker)
+      )
+      const dynamicMiddlewares = dyn.reduce(
+        (prev, cur) => ({ ...prev, [cur.dynamic.key]: cur }),
+        {} as Record<string, any>
+      )
+      // TODO: support dynamic and generic intertwined. treat them as one
+      return Object.assign(make({ genericMiddlewares, dynamicMiddlewares }), it)
     }
   }
   return it as any

package/src/api/routing/middleware/middleware.ts

@@ -1,24 +1,32 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Cause, Context, Effect, ParseResult } from "effect-app"
+import { Cause, Context, Duration, Effect, Layer, ParseResult, Request } from "effect-app"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
-import { RequestCacheLayers, Tag } from "../../routing.js"
+import { Tag } from "../middleware.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")
 
+export const RequestCacheLayers = Layer.mergeAll(
+  Layer.setRequestCache(
+    Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
+  ),
+  Layer.setRequestCaching(true),
+  Layer.setRequestBatching(true)
+)
+
 export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
 
 export class RequestCacheMiddleware extends Tag<RequestCacheMiddleware>()("RequestCacheMiddleware", { wrap: true })({
-  effect: Effect.succeed((options) => options.next.pipe(Effect.provide(RequestCacheLayers)))
+  effect: Effect.succeed(({ next }) => next.pipe(Effect.provide(RequestCacheLayers)))
 }) {
 }
 
 export class ConfigureInterruptibility
   extends Tag<ConfigureInterruptibility>()("ConfigureInterruptibility", { wrap: true })({
-    effect: Effect.succeed((options) =>
-      options.next.pipe(
+    effect: Effect.succeed(({ next }) =>
+      next.pipe(
         // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
         Effect.uninterruptible
       )

package/src/api/routing.ts

@@ -4,7 +4,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { determineMethod, isCommand } from "@effect-app/infra/api/routing/utils"
 import { Rpc, RpcGroup, RpcServer } from "@effect/rpc"
-import { type Array, Duration, Effect, Layer, type NonEmptyReadonlyArray, Predicate, Request, S, Schedule, Schema, type Scope } from "effect-app"
+import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schedule, Schema, type Scope } from "effect-app"
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
@@ -819,11 +819,3 @@ export type MakeHandlers<Make, Handlers extends Record<string, any>> = Make exte
  * @since 3.9.0
  */
 export type MakeDepsOut<Make> = Contravariant.Type<MakeDeps<Make>[Layer.LayerTypeId]["_ROut"]>
-
-export const RequestCacheLayers = Layer.mergeAll(
-  Layer.setRequestCache(
-    Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
-  ),
-  Layer.setRequestCaching(true),
-  Layer.setRequestBatching(true)
-)

package/test/contextProvider.test.ts

@@ -3,8 +3,7 @@
 import { expectTypeOf } from "@effect/vitest"
 import { Context, Effect, Scope } from "effect-app"
 import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/routing.js"
-import { CustomError1, Some, SomeElse } from "./controller.test.js"
-import { SomeService } from "./query.test.js"
+import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextProvider", {

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, Layer, S, Scope } from "effect-app"
+import { InvalidStateError, makeRpcClient, NotLoggedInError, UnauthorizedError } from "effect-app/client"
+import { DefaultGenericMiddlewares, implementMiddleware, makeMiddleware, makeNewMiddleware, 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* 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))
       })
   })
 }) {
@@ -204,13 +120,13 @@ const middleware2 = makeMiddleware<RequestContextMap>()({
   }
 })
 
-export const middleware3 = makeNewMiddleware<RequestContextMap>()(
-  ...genericMiddlewares
-)
-  .addDynamicMiddleware(AllowAnonymous, RequireRoles)
-  .addDynamicMiddleware(Test)
+export const middleware3 = makeNewMiddleware<RequestContextMap>()
+  .middleware(...genericMiddlewares)
+  .middleware(AllowAnonymous, RequireRoles)
+  .middleware(Test)
+// .middleware(BogusMiddleware)
 
-expectTypeOf(middleware3).toEqualTypeOf<typeof middleware2>()
+// expectTypeOf(middleware3).toExtend<typeof middleware2>()
 
 export type RequestConfig = {
   /** Disable authentication requirement */
@@ -360,7 +276,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,7 +348,7 @@ 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>()
 
 type makeContext2 = MakeContext<typeof router2.make>
 expectTypeOf({} as MakeErrors<typeof router2.make>).toEqualTypeOf<InvalidStateError>()

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,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7D,OAAO,EAAoC,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACzG,OAAO,EAAqF,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAErJ,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;;AAGrI,cAAM,iBAAkB,SAAQ,sBA0B9B;CAAG;;;;;;AAGL,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;;AAOL,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AAoDD,eAAO,MAAM,WAAW;;;;;YAGL,CAAA;AAKnB,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;AAyJ/C,eAAO,MAAM,kBAAkB;;;;;;;;;;CAI7B,CAAA"}

package/test/dist/fixtures.d.ts

@@ -0,0 +1,144 @@
+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<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<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 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 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,WAAW,EAAE,OAAO,gBAAgB,CAAC,CAAA;IAC5E,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,mBAuBlC;CACD;;;;;;;;;;AAGD,qBAAa,YAAa,SAAQ,iBAoBhC;CACD;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAMxB;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,70 @@
+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"),
+    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, { id: "whatever", roles: ["user", "manager"] }));
+        });
+    })
+}) {
+}
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class RequireRoles extends Middleware.Tag()("RequireRoles", {
+    dynamic: contextMap()("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* ({ config }) {
+            // 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;
+            if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
+                return yield* new UnauthorizedError({ message: "don't have the right roles" });
+            }
+            return Option.none();
+        });
+    })
+}) {
+}
+export class Test extends Middleware.Tag()("Test", { dynamic: contextMap()("test") })({
+    effect: Effect.gen(function* () {
+        return Effect.fn(function* () {
+            return Option.none();
+        });
+    })
+}) {
+}
+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"}