@effect-app/infra 2.87.1 → 2.88.0

package/test/requires.test.ts

@@ -1,8 +1,8 @@
-import { expect, expectTypeOf, it } from "@effect/vitest"
+import { describe, expect, expectTypeOf, it } from "@effect/vitest"
 import { Effect, Either, Layer, S } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { makeMiddleware, Middleware } from "../src/api/routing.js"
-import { AllowAnonymous, type RequestContextMap, RequireRoles, Some, SomeElse, Test } from "./fixtures.js"
+import { AllowAnonymous, RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
 
 export class SomeMiddleware extends Middleware.Tag<SomeMiddleware>()("SomeMiddleware", {
   provides: Some
@@ -17,6 +17,18 @@ export class SomeMiddleware extends Middleware.Tag<SomeMiddleware>()("SomeMiddle
 }) {
 }
 
+// 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
@@ -48,109 +60,119 @@ export class RequiresSomeMiddleware extends Middleware.Tag<RequiresSomeMiddlewar
 }) {
 }
 
-it("requires gets enforced", async () => {
-  const middleware3 = makeMiddleware<RequestContextMap>()
-    .middleware(RequiresSomeMiddleware)
-    .middleware(SomeMiddleware)
-    .middleware(RequireRoles)
-    .middleware(AllowAnonymous, Test)
-    .middleware(SomeElseMiddleware)
+const middleware3 = makeMiddleware(RequestContextMap)
+  .middleware(RequiresSomeMiddleware)
+  .middleware(SomeMiddleware)
+  .middleware(RequireRoles)
+  .middleware(AllowAnonymous, Test)
+  .middleware(SomeElseMiddleware)
 
-  const layer = middleware3.Default.pipe(Layer.provide(Layer.succeed(Some, new Some({ a: 1 }))))
+const _middlewareSideways = makeMiddleware(RequestContextMap)
+  .middleware(RequiresSomeMiddleware)
+  .middleware(SomeMiddleware)
+  .middleware(RequireRoles, AllowAnonymous, Test)
+  .middleware(SomeElseMiddleware)
 
-  type Default = typeof middleware3["Default"]
-  type LayerContext = Layer.Layer.Context<Default>
-  expectTypeOf({} as LayerContext).toEqualTypeOf<Some>()
+const _middlewareSidewaysFully = makeMiddleware(RequestContextMap)
+  .middleware(RequiresSomeMiddleware, SomeMiddleware, RequireRoles, AllowAnonymous, Test, SomeElseMiddleware)
 
-  await Effect
-    .gen(function*() {
-      const mw = yield* middleware3
-      const mwM = mw.effect(
-        Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
-        (_req) => Effect.void,
-        "some-module"
-      )
-      yield* mwM({}, { "x-user": "test-user", "x-is-manager": "true" })
-    })
-    .pipe(
-      Effect.scoped,
-      Effect.provide(layer),
-      Effect.runPromise
-    )
+const _middleware3Bis = makeMiddleware(RequestContextMap)
+  .middleware(RequiresSomeMiddleware)
+  .middleware(SomeMiddlewareWrap)
+  .middleware(RequireRoles)
+  .middleware(AllowAnonymous, Test)
+  .middleware(SomeElseMiddleware)
 
-  await Effect
-    .gen(function*() {
-      const mw = yield* middleware3
-      const mwM = mw.effect(
-        Object.assign({}, S.Any, { config: { allowAnonymous: true } }),
-        (_req) => Effect.void,
-        "some-module"
-      )
-      yield* mwM({}, {})
-    })
-    .pipe(
-      Effect.scoped,
-      Effect.provide(layer),
-      Effect.runPromise
-    )
+expectTypeOf(_middlewareSideways).toEqualTypeOf<typeof middleware3>()
+expectTypeOf(_middlewareSidewaysFully).toEqualTypeOf<typeof _middlewareSideways>()
+expectTypeOf(_middleware3Bis).toEqualTypeOf<typeof middleware3>()
+
+type Default = typeof middleware3["Default"]
+type LayerContext = Layer.Layer.Context<Default>
+expectTypeOf({} as LayerContext).toEqualTypeOf<SomeService>()
 
-  expect(
-    await Effect
-      .gen(function*() {
-        const mw = yield* middleware3
-        const mwM = mw.effect(
-          Object.assign({}, S.Any, { config: {} }),
-          (_req) => Effect.void,
-          "some-module"
+const testSuite = (_mw: typeof middleware3) =>
+  describe("middleware" + _mw, () => {
+    it.effect(
+      "works",
+      Effect.fn(function*() {
+        const layer = _mw.Default.pipe(Layer.provide(SomeService.toLayer()))
+        yield* Effect
+          .gen(function*() {
+            const mw = yield* _mw
+            const mwM = mw.effect(
+              Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
+              (_req) => Effect.void,
+              "some-module"
+            )
+            yield* mwM({}, { "x-user": "test-user", "x-is-manager": "true" })
+          })
+          .pipe(
+            Effect.scoped,
+            Effect.provide(layer)
+          )
+
+        expect(
+          yield* Effect
+            .gen(function*() {
+              const mw = yield* _mw
+              const mwM = mw.effect(
+                Object.assign({}, S.Any, { config: {} }),
+                (_req) => Effect.void,
+                "some-module"
+              )
+              yield* mwM({}, {})
+            })
+            .pipe(
+              Effect.scoped,
+              Effect.provide(layer),
+              Effect.either
+            )
         )
-        yield* mwM({}, {})
-      })
-      .pipe(
-        Effect.scoped,
-        Effect.provide(layer),
-        Effect.either,
-        Effect.runPromise
-      )
-  )
-    .toEqual(Either.left(new NotLoggedInError()))
+          .toEqual(Either.left(new NotLoggedInError()))
 
-  expect(
-    await Effect
-      .gen(function*() {
-        const mw = yield* middleware3
-        const mwM = mw.effect(
-          Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
-          (_req) => Effect.void,
-          "some-module"
+        expect(
+          yield* Effect
+            .gen(function*() {
+              const mw = yield* _mw
+              const mwM = mw.effect(
+                Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
+                (_req) => Effect.void,
+                "some-module"
+              )
+              yield* mwM({}, {})
+            })
+            .pipe(
+              Effect.scoped,
+              Effect.provide(layer),
+              Effect.either
+            )
         )
-        yield* mwM({}, {})
-      })
-      .pipe(
-        Effect.scoped,
-        Effect.provide(layer),
-        Effect.either,
-        Effect.runPromise
-      )
-  )
-    .toEqual(Either.left(new NotLoggedInError()))
+          .toEqual(Either.left(new NotLoggedInError()))
 
-  expect(
-    await Effect
-      .gen(function*() {
-        const mw = yield* middleware3
-        const mwM = mw.effect(
-          Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
-          (_req) => Effect.void,
-          "some-module"
+        expect(
+          yield* Effect
+            .gen(function*() {
+              const mw = yield* _mw
+              const mwM = mw.effect(
+                Object.assign({}, S.Any, { config: { requireRoles: ["manager"] } }),
+                (_req) => Effect.void,
+                "some-module"
+              )
+              yield* mwM({}, { "x-user": "test-user" })
+            })
+            .pipe(
+              Effect.scoped,
+              Effect.provide(layer),
+              Effect.either
+            )
         )
-        yield* mwM({}, { "x-user": "test-user" })
+          .toEqual(Either.left(new UnauthorizedError({ message: "don't have the right roles" })))
       })
-      .pipe(
-        Effect.scoped,
-        Effect.provide(layer),
-        Effect.either,
-        Effect.runPromise
-      )
-  )
-    .toEqual(Either.left(new UnauthorizedError({ message: "don't have the right roles" })))
-})
+    )
+  })
+
+testSuite(middleware3)
+testSuite(_middleware3Bis)
+testSuite(_middlewareSideways)
+testSuite(_middlewareSidewaysFully)