@effect-app/infra 4.0.0-beta.13 → 4.0.0-beta.130

package/test/repository-ext.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Layer, S } from "effect-app"
+import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
+import { makeRepo } from "../src/Model/Repository.js"
+import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
+import { MemoryStoreLive } from "../src/Store/Memory.js"
+
+class BatchItem extends S.Class<BatchItem>("BatchItem")({
+  id: S.String,
+  label: S.String
+}) {}
+
+const TestStoreLive = Layer.merge(MemoryStoreLive, RepositoryRegistryLive)
+
+describe("repository ext save/remove batching", () => {
+  it.effect("supports save batching overload", () =>
+    Effect.gen(function*() {
+      const repo = yield* makeRepo("BatchItem", BatchItem, {})
+      const items = [
+        new BatchItem({ id: "1", label: "one" }),
+        new BatchItem({ id: "2", label: "two" }),
+        new BatchItem({ id: "3", label: "three" }),
+        new BatchItem({ id: "4", label: "four" })
+      ] as const
+
+      yield* repo.save(items, { batch: 2 })
+
+      const all = yield* repo.all
+      expect(all).toHaveLength(4)
+      expect(all.map((_) => _.id).toSorted()).toEqual(["1", "2", "3", "4"])
+    }).pipe(
+      setupRequestContextFromCurrent(),
+      Effect.provide(TestStoreLive)
+    )
+  )
+
+  it.effect("supports remove batching overload", () =>
+    Effect.gen(function*() {
+      const repo = yield* makeRepo("BatchItem", BatchItem, {})
+      const items = [
+        new BatchItem({ id: "1", label: "one" }),
+        new BatchItem({ id: "2", label: "two" }),
+        new BatchItem({ id: "3", label: "three" }),
+        new BatchItem({ id: "4", label: "four" })
+      ] as const
+
+      yield* repo.save(items)
+      yield* repo.remove([items[0], items[1], items[2]], { batch: true })
+
+      const all = yield* repo.all
+      expect(all).toHaveLength(1)
+      expect(all[0]?.id).toBe("4")
+    }).pipe(
+      setupRequestContextFromCurrent(),
+      Effect.provide(TestStoreLive)
+    )
+  )
+})

package/test/requires.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Result, S, ServiceMap } from "effect-app"
+import { Context, Effect, Layer, Result, S } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { HttpHeaders } from "effect-app/http"
 import * as RpcX from "effect-app/rpc"
@@ -63,11 +63,12 @@ const testSuite = (_mw: typeof middleware3) =>
       "works",
       Effect.fn(function*() {
         const defaultOpts = {
+          client: null as any, // TODO?
           headers: HttpHeaders.fromRecordUnsafe({}),
           payload: { _tag: "Test" },
           clientId: 0,
           requestId: "test-id" as any,
-          rpc: { ...TestRpc, annotations: ServiceMap.make(_mw.requestContext, {}) }
+          rpc: { ...TestRpc, annotations: Context.make(_mw.requestContext, {}) }
         }
         const next = Effect.void as unknown as Effect.Effect<SuccessValue, unhandled, never>
         const layer = _mw.layer.pipe(
@@ -89,7 +90,7 @@ const testSuite = (_mw: typeof middleware3) =>
                 headers: HttpHeaders.fromRecordUnsafe({ "x-user": "test-user", "x-is-manager": "true" }),
                 rpc: {
                   ...defaultOpts.rpc,
-                  annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                  annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                 }
               })
             )
@@ -127,7 +128,7 @@ const testSuite = (_mw: typeof middleware3) =>
                 Object.assign({ ...defaultOpts }, {
                   rpc: {
                     ...defaultOpts.rpc,
-                    annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                    annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                   }
                 })
               )
@@ -153,7 +154,7 @@ const testSuite = (_mw: typeof middleware3) =>
                   {
                     rpc: {
                       ...defaultOpts.rpc,
-                      annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                      annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                     }
                   }
                 )

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

@@ -1,14 +1,14 @@
 import { NodeHttpServer } from "@effect/platform-node"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { Console, Effect, Layer, Result } from "effect"
-import { S } from "effect-app"
+import { Console, Effect, Layer, Ref, Result } from "effect"
+import { Context, S } from "effect-app"
 import { NotLoggedInError } from "effect-app/client"
 import { HttpRouter } from "effect-app/http"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
 import { MiddlewareMaker } from "effect-app/rpc"
 import { middlewareGroup } from "effect-app/rpc/MiddlewareMaker"
 import { FetchHttpClient } from "effect/unstable/http"
-import { RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc"
+import { Rpc, RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc"
 import { createServer } from "http"
 import { DefaultGenericMiddlewaresLive } from "../src/api/routing.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive, UserProfile } from "./fixtures.js"
@@ -136,3 +136,72 @@ it.live(
     Effect.provide(RpcTestLayer)
   )
 )
+
+// Per-request service isolation test
+
+class PerRequestCounter extends Context.Service<PerRequestCounter>()(
+  "PerRequestCounter",
+  { make: Effect.sync(() => ({ a: 0 })) }
+) {
+  static Default = Layer.effect(this, this.make)
+}
+
+class GlobalCounter extends Context.Service<GlobalCounter, {
+  readonly ref: Ref.Ref<number>
+}>()("GlobalCounter") {}
+
+const CounterRpcs = RpcGroup.make(
+  Rpc.make("incrementA", {
+    success: S.Number
+  }),
+  Rpc.make("incrementB", {
+    success: S.Number
+  })
+)
+
+const counterImpl = CounterRpcs
+  .toLayer({
+    incrementA: Effect.fn(function*() {
+      const counter = yield* PerRequestCounter
+      counter.a++
+      const global = yield* GlobalCounter
+      yield* Ref.update(global.ref, (n) => n + 1)
+      return counter.a
+    }, Effect.provide(PerRequestCounter.Default)),
+    incrementB: Effect.fn(function*() {
+      const counter = yield* PerRequestCounter
+      counter.a++
+      const global = yield* GlobalCounter
+      yield* Ref.update(global.ref, (n) => n + 1)
+      return counter.a
+    }, Effect.provide(PerRequestCounter.Default))
+  })
+
+const GlobalCounterLive = Layer.effect(
+  GlobalCounter,
+  Ref.make(0).pipe(Effect.map((ref) => ({ ref })))
+)
+
+const CounterTestLayer = counterImpl.pipe(Layer.provideMerge(GlobalCounterLive))
+
+it.live(
+  "per-request service isolation with shared global counter",
+  Effect.fnUntraced(
+    function*() {
+      const client = yield* RpcTest.makeClient(CounterRpcs)
+      const global = yield* GlobalCounter
+
+      const r1 = yield* client.incrementA()
+      const r2 = yield* client.incrementB()
+
+      // per-request counter is fresh each time → both return 1
+      expect(r1).toBe(1)
+      expect(r2).toBe(1)
+
+      // global counter is shared across requests → accumulates to 2
+      const globalCount = yield* Ref.get(global.ref)
+      expect(globalCount).toBe(2)
+    },
+    Effect.provide(CounterTestLayer)
+  )
+)