@effect-app/infra 2.92.3 → 2.94.0

package/src/api/routing.ts

@@ -2,10 +2,10 @@
 /* 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"
+import { type HttpHeaders } from "effect-app/http"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
 import { type Service } from "effect/Effect"
 import type { Contravariant } from "effect/Types"
@@ -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 [
@@ -155,8 +158,6 @@ export type RouteMatcher<
     }
 }
 
-export class Router extends HttpRouter.Tag("@effect-app/Rpc")<Router>() {}
-
 export const makeRouter = <
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   MakeMiddlewareE,
@@ -352,7 +353,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,58 +416,44 @@ 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.provideMerge(
-                RpcServer.layerProtocolHttp(
-                  { path: ("/" + meta.moduleName) as `/${typeof meta.moduleName}`, routerTag: Router }
-                )
-              )
-            )
+            .layerHttpRouter({
+              spanPrefix: "RpcServer." + meta.moduleName,
+              group: rpcs,
+              path: ("/rpc/" + meta.moduleName) as `/${typeof meta.moduleName}`,
+              protocol: "http"
+            })
+            .pipe(Layer.provide(rpc))
         })
         .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>>
-      >)
-
-      // Effect.Effect<HttpRouter.HttpRouter<unknown, HttpRouter.HttpRouter.DefaultServices>, never, UserRouter>
+      const routes = layer.pipe(
+        Layer.provide([
+          dependenciesL,
+          middleware.Default
+        ]),
+        Layer.provide(Layer.succeed(DevMode, devMode))
+      )
 
       return {
         moduleName: meta.moduleName,
@@ -494,7 +486,7 @@ export const makeRouter = <
         moduleName: ModuleName
 
         routes: Layer.Layer<
-          RouterShape<Resource>,
+          never,
           | MakeErrors<Make>
           | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
@@ -504,169 +496,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 +523,7 @@ export const makeRouter = <
         moduleName: ModuleName
 
         routes: Layer.Layer<
-          RouterShape<Resource>,
+          never,
           | MakeErrors<Make>
           | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
@@ -698,39 +533,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 +549,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 +562,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/contextProvider.test.ts

@@ -12,7 +12,7 @@ class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextPr
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return Effect.gen(function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
@@ -63,7 +63,7 @@ class MyContextProviderGen extends Effect.Service<MyContextProviderGen>()("MyCon
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
@@ -87,7 +87,7 @@ export const someContextProvider = ContextProvider({
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return Effect.gen(function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       // not allowed
@@ -106,7 +106,7 @@ export const someContextProviderGen = ContextProvider({
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       // not allowed

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"
@@ -19,7 +20,7 @@ class MyContextProvider extends Middleware.Tag<MyContextProvider>()("MyContextPr
 
     return Effect.fnUntraced(function*() {
       yield* SomeElse
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
@@ -49,7 +50,7 @@ class MyContextProvider3 extends Middleware.Tag<MyContextProvider3>()("MyContext
 
     return Effect.fnUntraced(function*() {
       yield* SomeElse
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
@@ -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/test2.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test2.test.d.ts","sourceRoot":"","sources":["../../controller/test2.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAA8B,MAAM,+BAA+B,CAAA;AAC7G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAY,MAAM,YAAY,CAAA;AAChE,OAAO,EAAE,KAAK,gBAAgB,EAAoC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAClI,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAGxD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;;;;;;;;AAE9C,cAAM,WAAY,SAAQ,gBAIzB;CACA;;;;;;AAED,cAAM,gBAAiB,SAAQ,qBAE7B;CAAG;AAKL,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;AAExF,qBAAa,YAAa,SAAQ,iBAQhC;CAAG;AAEL,MAAM,MAAM,MAAM,GAAG;IACnB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,EAAE,OAAO,gBAAgB,CAAC,CAAA;IAE3F,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AAsGD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAE1B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFAAiC,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"controller.legacy3.test.d.ts","sourceRoot":"","sources":["../controller.legacy3.test.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAEjC,OAAO,EAAW,MAAM,EAAY,KAAK,EAAE,CAAC,EAAY,MAAM,YAAY,CAAA;AAC1E,OAAO,EAAwC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAC/G,OAAO,EAAe,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAOhE,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;AAED,MAAM,MAAM,MAAM,GAAG;IAGnB,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AAmGD,eAAO,MAAQ,QAAQ;;;;;gBA0EgwD,MAAO,KAAK;;;;;;GA1E1wD,QAAQ;;;;;;iDA0Eq0F,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAA2yD,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CA1E1oU,CAAA;AAElE,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;yCAxEL,EAAG,MAAM,CAAC,MAAM;iBAgClC,EA/BK,MACb,CA8BQ,GA9BJ,GA8BI,EA9BC,MAEV,CA4BS,MA5BF;iBAAuB,EAAE,MAC9B,CA2BO,GA3BH,GA2BG,EA3BG,MAAK,CAAC,MAAM;;;;;;2CASkB,EAAG,MAAM,CAAC,MAAM;iBAkBjD,EAAA,MAjBA,CAAC,GAAG,GAAE,EAAG,MAAM,CAAC,MAAM;;;;;;2CAiBtB,EAPO,MAAC,CAAC,MAAM;iBACA,EAAG,MAAM,CAAC,GAAG,GAAE,EAAG,MAAM,CAAC,MAAM;;;;;;2CAc1C,EAAA,MAAL,CAAK,MAAE;;;;;2CAMqC,EAAG,MAAM,CAAC,MAAM;;;;;CA6BnE,CAAA;;;;;;;;;;AAEF,qBAAa,YAAa,SAAQ,iBAEX;CAAG;;;;;;;;;;AAE1B,qBAAa,gBAAiB,SAAQ,qBAEb;CAAG;;;;;AAI5B,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG"}

package/test/dist/controller.test copy.js

@@ -0,0 +1,129 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import { Rpc } from "@effect/rpc";
+import { Context, Effect, FiberRef, Layer, S, Schedule } from "effect-app";
+import { makeRpcClient, UnauthorizedError } from "effect-app/client";
+import { HttpHeaders, HttpServerRequest } from "effect-app/http";
+import { makeMiddleware, makeRouter } from "../src/api/routing5.js";
+const optimisticConcurrencySchedule = Schedule.once
+    && Schedule.recurWhile((a) => a?._tag === "OptimisticConcurrencyException");
+const middleware = makeMiddleware({
+    contextMap: null,
+    // helper to deal with nested generic lmitations
+    context: null,
+    execute: Effect.gen(function* () {
+        return (schema, handler, moduleName) => (req) => Effect
+            .gen(function* () {
+            const headers = yield* Rpc.currentHeaders;
+            const ctx = Context.empty();
+            const config = "config" in schema ? schema.config : undefined;
+            // Check JWT
+            // TODO
+            // if (!fakeLogin && !request.allowAnonymous) {
+            //   yield* Effect.catchAll(
+            //     checkJWTI({
+            //       ...authConfig,
+            //       issuer: authConfig.issuer + "/",
+            //       jwksUri: `${authConfig.issuer}/.well-known/jwks.json`
+            //     }),
+            //     (err) => Effect.fail(new JWTError({ error: err }))
+            //   )
+            // }
+            // const fakeLogin = true
+            // const r = (fakeLogin
+            //   ? makeUserProfileFromUserHeader(headers["x-user"])
+            //   : makeUserProfileFromAuthorizationHeader(
+            //     headers["authorization"]
+            //   ))
+            //   .pipe(Effect.exit, basicRuntime.runSync)
+            // if (!Exit.isSuccess(r)) {
+            //   yield* Effect.logWarning("Parsing userInfo failed").pipe(Effect.annotateLogs("r", r))
+            // }
+            // const userProfile = Option.fromNullable(Exit.isSuccess(r) ? r.value : undefined)
+            // if (Option.isSome(userProfile)) {
+            //   // yield* rcc.update((_) => ({ ..._, userPorfile: userProfile.value }))
+            //   ctx = ctx.pipe(Context.add(UserProfile, userProfile.value))
+            // } else if (!config?.allowAnonymous) {
+            //   return yield* new NotLoggedInError({ message: "no auth" })
+            // }
+            // if (config?.requireRoles) {
+            //   // TODO
+            //   if (
+            //     !userProfile.value
+            //     || !config.requireRoles.every((role: any) => userProfile.value!.roles.includes(role))
+            //   ) {
+            //     return yield* new UnauthorizedError()
+            //   }
+            // }
+            return yield* handler(req).pipe(Effect.retry(optimisticConcurrencySchedule), Effect.provide(ctx));
+        })
+            .pipe(Effect.provide(Effect
+            .gen(function* () {
+            yield* Effect.annotateCurrentSpan("request.name", moduleName ? `${moduleName}.${req._tag}` : req._tag);
+            // yield* RequestContextContainer.update((_) => ({
+            //   ..._,
+            //   name: NonEmptyString255(moduleName ? `${moduleName}.${req._tag}` : req._tag)
+            // }))
+            const httpReq = yield* HttpServerRequest.HttpServerRequest;
+            // TODO: only pass Authentication etc, or move headers to actual Rpc Headers
+            yield* FiberRef.update(Rpc.currentHeaders, (headers) => HttpHeaders.merge(httpReq.headers, headers));
+        })
+            .pipe(Layer.effectDiscard)));
+        // .pipe(Effect.provide(RequestCacheLayers)) as any
+    })
+});
+export const { matchAll, matchFor } = makeRouter(middleware, true);
+export const { TaggedRequest: Req } = makeRpcClient({
+    // allowAnonymous: NotLoggedInError,
+    requireRoles: UnauthorizedError
+});
+export class GetSomething extends Req()("GetSomething", {
+    id: S.String
+}, { success: S.Void }) {
+}
+export class GetSomethingElse extends Req()("GetSomethingElse", {
+    id: S.String
+}, { success: S.String }) {
+}
+const Something = { GetSomething, GetSomethingElse, meta: { moduleName: "Something" } };
+export class SomethingService extends Effect.Service()("SomethingService", {
+    dependencies: [],
+    effect: Effect.gen(function* () {
+        return {};
+    })
+}) {
+}
+const c = a({ a: 5 });
+export class SomethingRepo extends Effect.Service()("SomethingRepo", {
+    dependencies: [SomethingService.Default],
+    effect: Effect.gen(function* () {
+        const smth = yield* SomethingService;
+        return {};
+    })
+}) {
+}
+export class SomethingService2 extends Effect.Service()("SomethingService2", {
+    dependencies: [],
+    effect: Effect.gen(function* () {
+        return {};
+    })
+}) {
+}
+const { handle, routes } = matchFor(Something);
+const d = handle({
+    dependencies: [
+        SomethingRepo.Default,
+        SomethingService.Default
+        // SomethingService2.Default
+    ],
+    effect: Effect.gen(function* () {
+        const repo = yield* SomethingRepo;
+        const smth = yield* SomethingService;
+        const smth2 = yield* SomethingService2;
+        const { GetSomething, GetSomethingElse } = routes;
+        return {
+            GetSomething: GetSomething(Effect.void),
+            GetSomethingElse: GetSomethingElse(Effect.succeed("12"))
+        };
+    })
+});
+//# sourceMappingURL=data:application/json;base64,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