@effect-app/infra 2.92.2 → 2.93.0

package/src/api/routing.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Rpc, RpcGroup, RpcServer } from "@effect/rpc"
+import { Rpc, RpcGroup, type RpcSerialization, RpcServer } from "@effect/rpc"
 import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schema, type Scope } from "effect-app"
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
@@ -15,6 +15,14 @@ import { DevMode, type RouterMiddleware } from "./routing/middleware.js"
 
 export * from "./routing/middleware.js"
 
+// Nice way to underline types that are only there for type testing, not for production use
+// sadly with unique symbols we get weird issues in app projects.
+// api/src/X/PackList.Controllers.ts:21:1 - error TS4082: Default export of the module has or is using private name 'TypeTestId'
+// export const TypeTestId: unique symbol = Symbol.for("@effect/infra/type-test")
+// export type TypeTestId = typeof TypeTestId
+export const TypeTestId = "@effect-app/infra/type-test" as const
+export type TypeTestId = typeof TypeTestId
+
 // it's the result of extending S.Req setting success, config
 // it's a schema plus some metadata
 export type AnyRequestModule = S.Schema.Any & {
@@ -91,11 +99,6 @@ type FilterRequestModules<T> = {
   [K in keyof T as T[K] extends AnyRequestModule ? K : never]: T[K]
 }
 
-export const RouterSymbol = Symbol()
-export interface RouterShape<Resource> {
-  [RouterSymbol]: Resource
-}
-
 type RPCRouteR<
   T extends [any, (req: any, headers: HttpHeaders.Headers) => Effect<any, any, any>]
 > = T extends [
@@ -352,7 +355,12 @@ export const makeRouter = <
         match: any
       ) => Effect<THandlers, MakeE, MakeR> | Generator<YieldWrap<Effect<any, MakeE, MakeR>>, THandlers, any>
     ) => {
-      type Router = RouterShape<Resource>
+      const dependenciesL = Layer.mergeAll(...dependencies as any) as Layer.Layer<
+        LayerUtils.GetLayersSuccess<MakeDependencies>,
+        LayerUtils.GetLayersError<MakeDependencies>,
+        LayerUtils.GetLayersContext<MakeDependencies>
+      >
+
       const layer = Effect
         .gen(function*() {
           const finalMake = ((make as any)[Symbol.toStringTag] === "GeneratorFunction"
@@ -410,28 +418,29 @@ export const makeRouter = <
           const rpcs = RpcGroup
             .make(
               ...typedValuesOf(mapped).map(([resource]) => {
-                return Rpc.fromTaggedRequest(resource).annotate(middleware.requestContext, resource.config ?? {})
+                return Rpc
+                  .fromTaggedRequest(resource)
+                  .annotate(middleware.requestContext, resource.config ?? {})
               })
             )
             .prefix(`${meta.moduleName}.`)
             .middleware(middleware as any)
-          const rpcLayer = rpcs.toLayer(Effect.gen(function*() {
-            return typedValuesOf(mapped).reduce((acc, [resource, handler]) => {
-              acc[`${meta.moduleName}.${resource._tag}`] = handler
-              return acc
-            }, {} as Record<string, any>) as any // TODO
-          })) as unknown as Layer<
-            { [K in keyof RequestModules]: Rpc.Handler<K> },
-            | Layer.Error<typeof middleware.Default>
-            | LayerUtils.GetLayersError<MakeDependencies>,
-            | RPCRouteR<typeof mapped[keyof typeof mapped]>
-            | Layer.Context<typeof middleware.Default>
-            | LayerUtils.GetLayersContext<MakeDependencies>
-          >
+
+          const rpc = rpcs
+            .toLayer(Effect.gen(function*() {
+              return typedValuesOf(mapped).reduce((acc, [resource, handler]) => {
+                acc[`${meta.moduleName}.${resource._tag}`] = handler
+                return acc
+              }, {} as Record<string, any>) as any // TODO
+            })) as unknown as Layer<
+              { [K in keyof RequestModules]: Rpc.Handler<K> },
+              MakeE,
+              RPCRouteR<typeof mapped[keyof typeof mapped]>
+            >
 
           return RpcServer
             .layer(rpcs, { spanPrefix: "RpcServer." + meta.moduleName })
-            .pipe(Layer.provide(rpcLayer))
+            .pipe(Layer.provide(rpc))
             .pipe(
               Layer.provideMerge(
                 RpcServer.layerProtocolHttp(
@@ -442,24 +451,13 @@ export const makeRouter = <
         })
         .pipe(Layer.unwrapEffect)
 
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-      const routes = (
-        layer.pipe(
-          Layer.provide([
-            ...dependencies ?? [],
-            middleware.Default
-          ] as any) as any,
-          Layer.provide(Layer.succeed(DevMode, devMode))
-        )
-      ) as (Layer.Layer<
-        Router,
-        | LayerUtils.GetLayersError<MakeDependencies>
-        | MakeE
-        | Layer.Error<typeof middleware.Default>,
-        | LayerUtils.GetLayersContext<MakeDependencies>
-        | Layer.Context<typeof middleware.Default>
-        | Exclude<MakeR, LayerUtils.GetLayersSuccess<MakeDependencies>>
-      >)
+      const routes = layer.pipe(
+        Layer.provide([
+          dependenciesL,
+          middleware.Default
+        ]),
+        Layer.provide(Layer.succeed(DevMode, devMode))
+      )
 
       // Effect.Effect<HttpRouter.HttpRouter<unknown, HttpRouter.HttpRouter.DefaultServices>, never, UserRouter>
 
@@ -494,7 +492,7 @@ export const makeRouter = <
         moduleName: ModuleName
 
         routes: Layer.Layer<
-          RouterShape<Resource>,
+          never,
           | MakeErrors<Make>
           | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
@@ -504,169 +502,12 @@ export const makeRouter = <
             MakeContext<Make>,
             MakeDepsOut<Make>
           >
+          | RpcSerialization.RpcSerialization
         >
 
         // just for type testing purposes
-        make: Make
+        [TypeTestId]: Make
       }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //     /** @deprecated */
-      //     readonly ಠ_ಠ: never
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //     /** @deprecated */
-      //     readonly ಠ_ಠ: never
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //     /** @deprecated */
-      //     readonly ಠ_ಠ: never
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //     /** @deprecated */
-      //     readonly ಠ_ಠ: never
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
       <
         const Make extends {
           dependencies?: Array<Layer.Layer.Any>
@@ -688,7 +529,7 @@ export const makeRouter = <
         moduleName: ModuleName
 
         routes: Layer.Layer<
-          RouterShape<Resource>,
+          never,
           | MakeErrors<Make>
           | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
@@ -698,39 +539,12 @@ export const makeRouter = <
             MakeContext<Make>,
             MakeDepsOut<Make>
           >
+          | RpcSerialization.RpcSerialization
         >
 
         // just for type testing purposes
-        make: Make
+        readonly [TypeTestId]: Make
       }
-      // <
-      //   const Make extends {
-      //     dependencies: [
-      //       ...Make["dependencies"],
-      //       ...Exclude<Effect.Context<ReturnType<Make["effect"]>>, MakeDepsOut<Make>> extends never ? []
-      //         : [Layer.Layer<Exclude<Effect.Context<ReturnType<Make["effect"]>>, MakeDepsOut<Make>>, never, never>]
-      //     ]
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-      //   Router: HttpRouter.HttpRouter.TagClass<
-      //     RouterShape<Resource>,
-      //     `${ModuleName}Router`,
-      //     never,
-      //     never
-      //   >
-      //   routes: any
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
     } =
       ((make: { dependencies: any; effect: any }) =>
         Object.assign(makeRoutes(make.dependencies, make.effect), { make })) as any
@@ -741,8 +555,7 @@ export const makeRouter = <
   function matchAll<
     T extends {
       [key: string]: {
-        //      Router: { router: Effect<HttpRouter.HttpRouter<any, any>, any, any> }
-        routes: Layer.Layer<any, any, any>
+        routes: Layer.Layer<never, any, any>
         moduleName: string
       }
     }
@@ -755,7 +568,7 @@ export const makeRouter = <
       never,
       Layer.Layer.Error<typeof handlers[keyof typeof handlers]["routes"]>,
       Layer.Layer.Context<typeof handlers[keyof typeof handlers]["routes"]>
-    > // TODO
+    >
   }
 
   return {

package/test/controller.test.ts

@@ -1,6 +1,7 @@
 /* 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 MakeContext, type MakeErrors, makeRouter, TypeTestId } from "@effect-app/infra/api/routing"
+import { type RpcSerialization } from "@effect/rpc"
 import { expect, expectTypeOf, it } from "@effect/vitest"
 import { Context, Effect, Layer, S, Scope } from "effect-app"
 import { InvalidStateError, makeRpcClient, NotLoggedInError, UnauthorizedError } from "effect-app/client"
@@ -132,8 +133,7 @@ const middlewareTrisWip = makeMiddleware<RequestContextMap>(RequestContextMap)
     MyContextProvider,
     RequireRoles,
     Test
-  )
-  .missing
+  )[TypeTestId]
 
 expectTypeOf(middlewareTrisWip).toEqualTypeOf<{
   missingDynamicMiddlewares: "allowAnonymous"
@@ -312,10 +312,12 @@ 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<
+  RpcSerialization.RpcSerialization | SomeService | "str"
+>()
 
-type makeContext = MakeContext<typeof router.make>
-expectTypeOf({} as MakeErrors<typeof router.make>).toEqualTypeOf<InvalidStateError>()
+type makeContext = MakeContext<typeof router[TypeTestId]>
+expectTypeOf({} as MakeErrors<typeof router[TypeTestId]>).toEqualTypeOf<InvalidStateError>()
 expectTypeOf({} as makeContext).toEqualTypeOf<
   SomethingService | SomethingRepo | SomethingService2
 >()
@@ -368,7 +370,9 @@ 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 | "str">()
+expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<
+  RpcSerialization.RpcSerialization | SomeService | "str"
+>()
 
-type makeContext2 = MakeContext<typeof router2.make>
+type makeContext2 = MakeContext<typeof router2[TypeTestId]>
 expectTypeOf({} as makeContext2).toEqualTypeOf<never>()

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

@@ -1 +1 @@
-{"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,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAE7D,OAAO,EAA6C,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAE7G,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;AAgEhI,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AA2DD,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;;;;;yHAAiC,CAAA;AAEhE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAA0B,MAAM,+BAA+B,CAAA;AACzG,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,EAAW,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAE7D,OAAO,EAA6C,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAE7G,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;AAgEhI,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AA0DD,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;;;;;yHAAiC,CAAA;AAEhE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA"}

package/test/dist/fixtures.d.ts

@@ -28,7 +28,7 @@ declare const Some_base: (abstract new (service: {
     };
     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>>;
+        <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>>;
     };
     of: (service: Context.TagClassShape<any, any>) => Some;
     make: Effect.Effect<Some, never, never>;
@@ -54,7 +54,7 @@ declare const SomeElse_base: (abstract new (service: {
     };
     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>>;
+        <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>>;
     };
     of: (service: Context.TagClassShape<any, any>) => SomeElse;
     make: Effect.Effect<SomeElse, never, never>;
@@ -80,7 +80,7 @@ declare const SomeService_base: (abstract new (service: {
     };
     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>>;
+        <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>>;
     };
     of: (service: Context.TagClassShape<any, any>) => SomeService;
     make: Effect.Effect<SomeService, never, never>;

package/dist/api/routing/middleware/dynamic-middleware.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=dynamic-middleware.d.ts.map

package/dist/api/routing/middleware/dynamic-middleware.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dynamic-middleware.d.ts","sourceRoot":"","sources":["../../../../src/api/routing/middleware/dynamic-middleware.ts"],"names":[],"mappings":""}

package/dist/api/routing/middleware/dynamic-middleware.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1taWRkbGV3YXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FwaS9yb3V0aW5nL21pZGRsZXdhcmUvZHluYW1pYy1taWRkbGV3YXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==