@effect-app/infra 2.94.0 → 3.0.0

package/test/fixtures.ts

@@ -1,7 +1,7 @@
-import { Context, Effect, Option, S, Scope } from "effect-app"
+import { Context, Effect, Layer, Option, S, Scope } from "effect-app"
 import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client"
 import { TaggedError } from "effect-app/Schema"
-import { contextMap, getConfig, Middleware } from "../src/api/routing.js"
+import { contextMap, getConfig, Tag } from "../src/api/routing.js"
 
 export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
   S.Class<UserProfile>("UserProfile")({
@@ -16,6 +16,53 @@ export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b:
 const MakeSomeService = Effect.succeed({ a: 1 })
 export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
 
+export class SomeMiddleware extends Tag<SomeMiddleware>()("SomeMiddleware", {
+  provides: Some
+}) {}
+
+export const SomeMiddlewareLive = Layer.effect(
+  SomeMiddleware,
+  Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return () =>
+      Effect.gen(function*() {
+        return new Some({ a: 1 })
+      })
+  })
+)
+
+// functionally equivalent to the one above
+export class SomeMiddlewareWrap extends Tag<SomeMiddlewareWrap>()("SomeMiddlewareWrap", {
+  provides: Some,
+  wrap: true
+}) {
+}
+
+export const SomeMiddlewareWrapLive = Layer.effect(
+  SomeMiddlewareWrap,
+  Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) => next.pipe(Effect.provideService(Some, new Some({ a: 1 })))
+  })
+)
+
+export class SomeElseMiddleware extends Tag<SomeElseMiddleware>()("SomeElseMiddleware", {
+  provides: SomeElse,
+  wrap: true
+}) {}
+
+export const SomeElseMiddlewareLive = Layer.effect(
+  SomeElseMiddleware,
+  Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) =>
+      Effect.gen(function*() {
+        // yield* Effect.context<"test-dep2">()
+        return yield* next.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })))
+      })
+  })
+)
+
 const requestConfig = getConfig<RequestContextMap>()
 
 // TODO: null as never sucks
@@ -32,11 +79,14 @@ export const RequestContextMap = {
 type _RequestContextMap = typeof RequestContextMap
 export interface RequestContextMap extends _RequestContextMap {}
 
-export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnonymous", {
+export class AllowAnonymous extends Tag<AllowAnonymous>()("AllowAnonymous", {
   dynamic: contextMap(RequestContextMap, "allowAnonymous"),
   requires: SomeElse
-})({
-  effect: Effect.gen(function*() {
+}) {}
+
+export const AllowAnonymousLive = Layer.effect(
+  AllowAnonymous,
+  Effect.gen(function*() {
     return Effect.fnUntraced(
       function*({ headers, rpc }) {
         yield* SomeElse
@@ -60,20 +110,22 @@ export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnony
       }
     )
   })
-}) {
-}
+)
 
 // TODO: don't expect service when it's wrap
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles", {
+export class RequireRoles extends Tag<RequireRoles>()("RequireRoles", {
   dynamic: contextMap(RequestContextMap, "requireRoles"),
   wrap: true,
   // wrap: true,
   // had to move this in here, because once you put it manually as a readonly static property on the class,
   // there's a weird issue where the fluent api stops behaving properly after adding this middleware via `addDynamicMiddleware`
   dependsOn: [AllowAnonymous]
-})({
-  effect: Effect.gen(function*() {
+}) {}
+
+export const RequireRolesLive = Layer.effect(
+  RequireRoles,
+  Effect.gen(function*() {
     yield* SomeService
     return Effect.fnUntraced(
       function*({ next, rpc }) {
@@ -94,20 +146,22 @@ export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles",
       }
     )
   })
-}) {
-}
+)
 
 // TODO: don't expect service when it's wrap
-export class Test extends Middleware.Tag<Test>()("Test", {
+export class Test extends Tag<Test>()("Test", {
   wrap: true,
   dynamic: contextMap(RequestContextMap, "test")
-})({
-  effect: Effect.gen(function*() {
+}) {}
+
+export const TestLive = Layer.effect(
+  Test,
+  Effect.gen(function*() {
     return Effect.fn(function*({ next }) {
       return yield* next
     })
   })
-}) {}
+)
 
 export class CustomError1 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
 export class CustomError2 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}

package/test/requires.test.ts

@@ -5,49 +5,9 @@ import { Context, Effect, Either, Layer, S } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { HttpHeaders } from "effect-app/http"
 import { makeMiddleware, Middleware } from "../src/api/routing.js"
-import { AllowAnonymous, RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
+import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeMiddlewareWrap, SomeService, Test, TestLive } from "./fixtures.js"
 
-export class SomeMiddleware extends Middleware.Tag<SomeMiddleware>()("SomeMiddleware", {
-  provides: Some
-})({
-  effect: Effect.gen(function*() {
-    // yield* Effect.context<"test-dep">()
-    return () =>
-      Effect.gen(function*() {
-        return new Some({ a: 1 })
-      })
-  })
-}) {
-}
-
-// functionally equivalent to the one above
-export class SomeMiddlewareWrap extends Middleware.Tag<SomeMiddlewareWrap>()("SomeMiddlewareWrap", {
-  provides: Some,
-  wrap: true
-})({
-  effect: Effect.gen(function*() {
-    // yield* Effect.context<"test-dep">()
-    return ({ next }) => next.pipe(Effect.provideService(Some, new Some({ a: 1 })))
-  })
-}) {
-}
-
-export class SomeElseMiddleware extends Middleware.Tag<SomeElseMiddleware>()("SomeElseMiddleware", {
-  provides: SomeElse,
-  wrap: true
-})({
-  effect: Effect.gen(function*() {
-    // yield* Effect.context<"test-dep">()
-    return ({ next }) =>
-      Effect.gen(function*() {
-        // yield* Effect.context<"test-dep2">()
-        return yield* next.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })))
-      })
-  })
-}) {
-}
-
-export class RequiresSomeMiddleware extends Middleware.Tag<RequiresSomeMiddleware>()("RequiresSomeMiddleware", {
+export class RequiresSomeMiddleware extends Middleware.TagService<RequiresSomeMiddleware>()("RequiresSomeMiddleware", {
   requires: [Some],
   wrap: true
 })({
@@ -79,7 +39,7 @@ const _middlewareSideways = makeMiddleware(RequestContextMap)
 const _middlewareSidewaysFully = makeMiddleware(RequestContextMap)
   .middleware(RequiresSomeMiddleware, SomeMiddleware, RequireRoles, AllowAnonymous, Test, SomeElseMiddleware)
 
-const _middleware3Bis = makeMiddleware(RequestContextMap)
+export const _middleware3Bis = makeMiddleware(RequestContextMap)
   .middleware(RequiresSomeMiddleware)
   .middleware(SomeMiddlewareWrap)
   .middleware(RequireRoles)
@@ -88,11 +48,7 @@ const _middleware3Bis = makeMiddleware(RequestContextMap)
 
 expectTypeOf(_middlewareSideways).toEqualTypeOf<typeof middleware3>()
 expectTypeOf(_middlewareSidewaysFully).toEqualTypeOf<typeof _middlewareSideways>()
-// expectTypeOf(_middleware3Bis).toEqualTypeOf<typeof middleware3>() // is not the same because SomeMiddlewareWrap is not SomeMiddleware
-
-type Default = typeof middleware3["Default"]
-type LayerContext = Layer.Layer.Context<Default>
-expectTypeOf({} as LayerContext).toEqualTypeOf<SomeService>()
+expectTypeOf(_middleware3Bis).not.toEqualTypeOf<typeof middleware3>() // is not the same because SomeMiddlewareWrap is not SomeMiddleware
 
 class TestRequest extends S.TaggedRequest<Test>("Test")("Test", {
   payload: {},
@@ -112,7 +68,16 @@ const testSuite = (_mw: typeof middleware3) =>
           rpc: { ...Rpc.fromTaggedRequest(TestRequest), annotations: Context.make(_mw.requestContext, {}) },
           next: Effect.void as unknown as Effect<SuccessValue, never, any>
         }
-        const layer = _mw.Default.pipe(Layer.provide(SomeService.toLayer()))
+        const layer = _mw.layer.pipe(
+          Layer.provide([
+            RequiresSomeMiddleware.Default,
+            SomeMiddlewareLive,
+            RequireRolesLive.pipe(Layer.provide(SomeService.toLayer())),
+            AllowAnonymousLive,
+            TestLive,
+            SomeElseMiddlewareLive
+          ])
+        )
         yield* Effect
           .gen(function*() {
             const mw = yield* _mw
@@ -194,6 +159,6 @@ const testSuite = (_mw: typeof middleware3) =>
   })
 
 testSuite(middleware3)
-testSuite(_middleware3Bis)
+// testSuite(_middleware3Bis)
 testSuite(_middlewareSideways)
 testSuite(_middlewareSidewaysFully)

package/test/rpc-multi-middleware.test.ts

@@ -0,0 +1,134 @@
+import { FetchHttpClient } from "@effect/platform"
+import { NodeHttpServer } from "@effect/platform-node"
+import { RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "@effect/rpc"
+import { expect, expectTypeOf, it } from "@effect/vitest"
+import { Console, Effect, Either, Layer } from "effect"
+import { S } from "effect-app"
+import { NotLoggedInError } from "effect-app/client"
+import { HttpLayerRouter } from "effect-app/http"
+import { createServer } from "http"
+import { DefaultGenericMiddlewaresLive, makeMiddleware, middlewareGroup } from "../src/api/routing.js"
+import { DefaultGenericMiddlewares } from "../src/api/routing/middleware/middleware-native.js"
+import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddlewareWrap, SomeMiddlewareWrapLive, SomeService, Test, TestLive, UserProfile } from "./fixtures.js"
+
+const middleware = makeMiddleware(RequestContextMap)
+  .middleware(RequireRoles)
+  .middleware(AllowAnonymous, Test)
+  .middleware(SomeElseMiddleware, SomeMiddlewareWrap)
+  .middleware(...DefaultGenericMiddlewares)
+
+const UserRpcs = middlewareGroup(middleware)(RpcGroup
+  .make(
+    middleware.rpc("getUser", {
+      success: S.Literal("awesome")
+    }),
+    middleware.rpc("doSomething", {
+      success: S.Literal("also-awesome"),
+      config: { allowAnonymous: true }
+    })
+  ))
+
+const impl = Effect
+  .gen(function*() {
+    const impl = UserRpcs
+      .toLayerDynamic({
+        getUser: Effect.fn(function*(_payload, _headers) {
+          yield* Some
+          yield* UserProfile // we only access it while protected by allowAnonymous: false
+          return "awesome" as const
+        }),
+        doSomething: Effect.fn(function*() {
+          console.log(yield* Effect.serviceOption(UserProfile)) // we access it optionally, while allowAnonymous: true
+          return "also-awesome" as const
+        })
+      })
+    return impl
+  })
+  .pipe(Layer.unwrapEffect)
+
+expectTypeOf<Layer.Layer.Context<typeof impl>>().toEqualTypeOf<never>()
+
+const UserRpcsBad = middlewareGroup(middleware)(RpcGroup
+  .make(
+    middleware.rpc("doSomethingElse", {
+      success: S.Literal("also-awesome2"),
+      config: { allowAnonymous: true }
+    })
+  ))
+export const badImpl = Effect
+  .gen(function*() {
+    const impl = UserRpcsBad
+      .toLayerDynamic({
+        doSomethingElse: Effect.fn(function*() {
+          console.log(yield* UserProfile) // bad boy! allowAnonymous: false, so `UserProfile` must fall through to the Layer R.
+          return "also-awesome2" as const
+        })
+      })
+    return impl
+  })
+  .pipe(Layer.unwrapEffect)
+
+expectTypeOf<Layer.Layer.Context<typeof badImpl>>().toEqualTypeOf<UserProfile>()
+
+const middlwareLayer = middleware
+  .layer
+  .pipe(
+    Layer.provide([
+      DefaultGenericMiddlewaresLive,
+      SomeElseMiddlewareLive,
+      SomeMiddlewareWrapLive,
+      TestLive,
+      RequireRolesLive.pipe(Layer.provide(SomeService.toLayer())),
+      AllowAnonymousLive
+    ])
+  )
+
+export const RpcTestLayer = Layer
+  .mergeAll(
+    impl,
+    middlwareLayer
+  )
+
+export const RpcRealLayer = Layer
+  .mergeAll(
+    HttpLayerRouter
+      .serve(
+        RpcServer
+          .layerHttpRouter({ group: UserRpcs, path: "/rpc", protocol: "http" })
+          .pipe(Layer.provide(impl))
+          .pipe(Layer.provide(middlwareLayer))
+      )
+      .pipe(Layer.provide(NodeHttpServer.layer(() => createServer(), { port: 5918 }))),
+    RpcClient
+      .layerProtocolHttp({ url: "http://localhost:5918/rpc" })
+      .pipe(
+        Layer.provide(FetchHttpClient.layer)
+      )
+  )
+  .pipe(Layer.provide(RpcSerialization.layerJson))
+
+it.scopedLive(
+  "require login",
+  Effect.fnUntraced(
+    function*() {
+      const userClient = yield* RpcTest.makeClient(UserRpcs) // RpcTest.makeClient(UserRpcs) // RpcClient.make(UserRpcs)
+
+      const user = yield* Effect.either(userClient.getUser().pipe(Effect.onExit((_) => Console.dir(_, { depth: 10 }))))
+      expect(user).toStrictEqual(Either.left(new NotLoggedInError("Not logged in")))
+    },
+    Effect.provide(RpcTestLayer)
+  )
+)
+
+it.scopedLive(
+  "allow anonymous, optional UserProfile",
+  Effect.fnUntraced(
+    function*() {
+      const userClient = yield* RpcTest.makeClient(UserRpcs) // RpcTest.makeClient(UserRpcs) // RpcClient.make(UserRpcs)
+
+      const user = yield* userClient.doSomething().pipe(Effect.onExit((_) => Console.dir(_, { depth: 10 })))
+      expect(user).toBe("also-awesome")
+    },
+    Effect.provide(RpcTestLayer)
+  )
+)