@effect-app/infra 4.0.0-beta.8 → 4.0.0-beta.82

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"
@@ -109,7 +109,7 @@ export const RpcRealLayer = Layer
         Layer.provide(FetchHttpClient.layer)
       )
   )
-  .pipe(Layer.provide(RpcSerialization.layerJson))
+  .pipe(Layer.provide(RpcSerialization.layerNdjson))
 
 it.live(
   "require login",
@@ -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)
+  )
+)

package/test/sql-store.test.ts

@@ -0,0 +1,444 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type Sqlite from "better-sqlite3"
+import BetterSqlite from "better-sqlite3"
+import { describe, expect, it } from "vitest"
+import { buildWhereSQLQuery, pgDialect, sqliteDialect } from "../src/Store/SQL/query.js"
+
+const query = (db: Sqlite.Database, sql: string, params: unknown[] = []) =>
+  db.prepare(sql).all(...params as any[]) as any[]
+
+// --- Query builder unit tests ---
+
+describe("SQL query builder (SQLite dialect)", () => {
+  it("where eq string", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "name", op: "eq", value: "John" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("json_extract(data, '$.name') = ?")
+    expect(result.params).toContain("John")
+  })
+
+  it("where eq number", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "age", op: "eq", value: 25 as any }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("json_extract(data, '$.age') = ?")
+    expect(result.params).toContain(25)
+  })
+
+  it("where gt", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "age", op: "gt", value: 18 as any }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("json_extract(data, '$.age') > ?")
+    expect(result.params).toContain(18)
+  })
+
+  it("where or", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [
+        { t: "where", path: "name", op: "eq", value: "Alice" },
+        { t: "or", path: "name", op: "eq", value: "Bob" }
+      ],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("= ?")
+    expect(result.sql).toContain("OR")
+    expect(result.params).toEqual(expect.arrayContaining(["Alice", "Bob"]))
+  })
+
+  it("where and", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [
+        { t: "where", path: "name", op: "eq", value: "Alice" },
+        { t: "and", path: "age", op: "gt", value: 18 as any }
+      ],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("AND")
+    expect(result.params).toEqual(expect.arrayContaining(["Alice", 18]))
+  })
+
+  it("where in", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "id", op: "in", value: ["a", "b", "c"] as any }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("id IN (?, ?, ?)")
+    expect(result.params).toEqual(expect.arrayContaining(["a", "b", "c"]))
+  })
+
+  it("where null", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "status", op: "eq", value: null as any }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("IS NULL")
+  })
+
+  it("where neq null", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "status", op: "neq", value: null as any }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("IS NOT NULL")
+  })
+
+  it("where contains", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "name", op: "contains", value: "oh" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("LIKE")
+    expect(result.sql).toContain("LOWER")
+    expect(result.params).toContain("%oh%")
+  })
+
+  it("where startsWith", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "name", op: "startsWith", value: "Jo" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("LIKE")
+    expect(result.params).toContain("Jo%")
+  })
+
+  it("where endsWith", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "name", op: "endsWith", value: "hn" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("LIKE")
+    expect(result.params).toContain("%hn")
+  })
+
+  it("where includes (array contains)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "tags", op: "includes", value: "admin" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("json_each")
+    expect(result.sql).toContain("value = ?")
+    expect(result.params).toContain("admin")
+  })
+
+  it("where includes-any (array contains any)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "tags", op: "includes-any", value: ["admin", "user"] as any }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("json_each")
+    expect(result.sql).toContain("IN")
+  })
+
+  it("nested scopes", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [
+        { t: "where", path: "a", op: "eq", value: "1" },
+        {
+          t: "or-scope",
+          result: [
+            { t: "where", path: "b", op: "eq", value: "2" },
+            { t: "and", path: "c", op: "eq", value: "3" }
+          ],
+          relation: "some" as const
+        }
+      ],
+      "test",
+      {}
+    )
+    expect(result.sql).toContain("OR (")
+    expect(result.sql).toContain("AND")
+    expect(result.params).toEqual(expect.arrayContaining(["1", "2", "3"]))
+  })
+
+  it("id key maps to id column", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "myId",
+      [{ t: "where", path: "myId", op: "eq", value: "123" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("id = ?")
+    expect(result.sql).not.toContain("json_extract")
+    expect(result.params).toContain("123")
+  })
+
+  it("order + limit + skip", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      undefined,
+      [{ key: "name", direction: "ASC" }] as any,
+      5,
+      10
+    )
+    expect(result.sql).toContain("ORDER BY")
+    expect(result.sql).toContain("ASC")
+    expect(result.sql).toContain("LIMIT")
+    expect(result.sql).toContain("OFFSET")
+  })
+})
+
+describe("SQL query builder (PostgreSQL dialect)", () => {
+  it("where eq string uses ->> operator", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "name", op: "eq", value: "John" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("data->>'name'")
+    expect(result.sql).toContain("$1")
+    expect(result.params).toContain("John")
+  })
+
+  it("where contains uses ILIKE", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "name", op: "contains", value: "oh" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("ILIKE")
+    expect(result.params).toContain("%oh%")
+  })
+
+  it("where in uses $N placeholders", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "status", op: "in", value: ["active", "pending"] as any }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("$1")
+    expect(result.sql).toContain("$2")
+    expect(result.params).toEqual(expect.arrayContaining(["active", "pending"]))
+  })
+
+  it("where includes uses @> jsonb operator", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "tags", op: "includes", value: "admin" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("@>")
+    expect(result.sql).toContain("jsonb")
+  })
+
+  it("nested path uses chained -> operators", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "address.city", op: "eq", value: "NYC" }],
+      "users",
+      {}
+    )
+    expect(result.sql).toContain("data->'address'->>'city'")
+  })
+})
+
+// --- Integration tests with in-memory SQLite (direct, no Effect SQL client) ---
+
+describe("SQL Store (SQLite integration)", () => {
+  const withDb = (fn: (db: Sqlite.Database) => void) => {
+    const db = new BetterSqlite(":memory:")
+    db.pragma("journal_mode = WAL")
+    try {
+      fn(db)
+    } finally {
+      db.close()
+    }
+  }
+
+  it("creates table and seeds data", () =>
+    withDb((db) => {
+      db.exec(
+        `CREATE TABLE IF NOT EXISTS "test_items" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`
+      )
+      db.prepare(`INSERT INTO "test_items" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("1", "etag1", JSON.stringify({ id: "1", name: "Alice", age: 30 }))
+
+      const rows = db.prepare(`SELECT * FROM "test_items"`).all()
+      expect(rows.length).toBe(1)
+      expect((rows[0] as any).id).toBe("1")
+    }))
+
+  it("query builder generates valid SQL for SQLite", () =>
+    withDb((db) => {
+      db.exec(
+        `CREATE TABLE IF NOT EXISTS "test_people" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`
+      )
+
+      const people = [
+        { id: "1", name: "Alice", age: 30, tags: ["admin", "user"] },
+        { id: "2", name: "Bob", age: 25, tags: ["user"] },
+        { id: "3", name: "Charlie", age: 35, tags: ["admin"] },
+        { id: "4", name: "Diana", age: 28, tags: ["user", "editor"] }
+      ]
+
+      const insert = db.prepare(
+        `INSERT INTO "test_people" (id, _etag, data) VALUES (?, ?, ?)`
+      )
+      for (const p of people) {
+        insert.run(p.id, `etag_${p.id}`, JSON.stringify(p))
+      }
+
+      // Test eq
+      const q1 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [{ t: "where", path: "name", op: "eq", value: "Alice" }],
+        "test_people", {}
+      )
+      expect(query(db, q1.sql, q1.params).length).toBe(1)
+      expect((JSON.parse((query(db, q1.sql, q1.params)[0] as any).data) as any).name).toBe("Alice")
+
+      // Test gt
+      const q2 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [{ t: "where", path: "age", op: "gt", value: 28 as any }],
+        "test_people", {}
+      )
+      expect(query(db, q2.sql, q2.params).length).toBe(2)
+
+      // Test OR
+      const q3 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [
+          { t: "where", path: "name", op: "eq", value: "Alice" },
+          { t: "or", path: "name", op: "eq", value: "Bob" }
+        ],
+        "test_people", {}
+      )
+      expect(query(db, q3.sql, q3.params).length).toBe(2)
+
+      // Test AND
+      const q4 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [
+          { t: "where", path: "name", op: "eq", value: "Alice" },
+          { t: "and", path: "age", op: "gt", value: 25 as any }
+        ],
+        "test_people", {}
+      )
+      const r4 = query(db, q4.sql, q4.params)
+      expect(r4.length).toBe(1)
+      expect((JSON.parse((r4[0] as any).data) as any).name).toBe("Alice")
+
+      // Test IN
+      const q5 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [{ t: "where", path: "id", op: "in", value: ["1", "3"] as any }],
+        "test_people", {}
+      )
+      expect(query(db, q5.sql, q5.params).length).toBe(2)
+
+      // Test contains (string)
+      const q6 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [{ t: "where", path: "name", op: "contains", value: "li" }],
+        "test_people", {}
+      )
+      expect(query(db, q6.sql, q6.params).length).toBe(2) // Alice, Charlie
+
+      // Test startsWith
+      const q7 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [{ t: "where", path: "name", op: "startsWith", value: "Al" }],
+        "test_people", {}
+      )
+      const r7 = query(db, q7.sql, q7.params)
+      expect(r7.length).toBe(1)
+      expect((JSON.parse((r7[0] as any).data) as any).name).toBe("Alice")
+
+      // Test includes (array)
+      const q8 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [{ t: "where", path: "tags", op: "includes", value: "admin" }],
+        "test_people", {}
+      )
+      expect(query(db, q8.sql, q8.params).length).toBe(2) // Alice, Charlie
+
+      // Test nested scope: where name = Alice OR (age > 30 AND name contains 'ar')
+      const q9 = buildWhereSQLQuery(
+        sqliteDialect, "id",
+        [
+          { t: "where", path: "name", op: "eq", value: "Alice" },
+          {
+            t: "or-scope",
+            result: [
+              { t: "where", path: "age", op: "gt", value: 30 as any },
+              { t: "and", path: "name", op: "contains", value: "ar" }
+            ],
+            relation: "some"
+          }
+        ],
+        "test_people", {}
+      )
+      expect(query(db, q9.sql, q9.params).length).toBe(2) // Alice + Charlie
+
+      // Test order + limit
+      const q10 = buildWhereSQLQuery(
+        sqliteDialect, "id", [], "test_people", {},
+        undefined,
+        [{ key: "age", direction: "DESC" }] as any,
+        undefined, 2
+      )
+      const r10 = query(db, q10.sql, q10.params)
+      expect(r10.length).toBe(2)
+      expect((JSON.parse((r10[0] as any).data) as any).name).toBe("Charlie") // oldest first
+    }))
+})

package/test/validateSample.test.ts

@@ -138,7 +138,7 @@ describe("validateSample", () => {
         // schema that expects a 'status' field
         class ItemWithStatus extends S.Class<ItemWithStatus>("ItemWithStatus")({
           id: S.String,
-          status: S.Literal("active", "inactive")
+          status: S.Literals(["active", "inactive"])
         }) {}
 
         // jitM that adds default status for items

package/tsconfig.json

@@ -32,7 +32,6 @@
     "outDir": "build/dist",
     "resolveJsonModule": true,
     "moduleResolution": "Node16",
-    "downlevelIteration": true,
     "noErrorTruncation": true,
     "forceConsistentCasingInFileNames": true,
     "types": [