@effect-app/infra 4.0.0-beta.83 → 4.0.0-beta.85

package/test/sql-store.test.ts

@@ -2,7 +2,9 @@
 import type Sqlite from "better-sqlite3"
 import BetterSqlite from "better-sqlite3"
 import { describe, expect, it } from "vitest"
+import { parseRow } from "../src/Store/SQL.js"
 import { buildWhereSQLQuery, pgDialect, sqliteDialect } from "../src/Store/SQL/query.js"
+import { makeETag } from "../src/Store/utils.js"
 
 const query = (db: Sqlite.Database, sql: string, params: unknown[] = []) =>
   db.prepare(sql).all(...params as any[]) as any[]
@@ -309,7 +311,8 @@ describe("SQL Store (SQLite integration)", () => {
       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 (?, ?, ?)`)
+      db
+        .prepare(`INSERT INTO "test_items" (id, _etag, data) VALUES (?, ?, ?)`)
         .run("1", "etag1", JSON.stringify({ name: "Alice", age: 30 }))
 
       const rows = db.prepare(`SELECT * FROM "test_items"`).all()
@@ -324,7 +327,8 @@ describe("SQL Store (SQLite integration)", () => {
       )
       // Simulate what toRow now produces: data without id or _etag
       const data = { name: "Alice", age: 30, tags: ["admin"] }
-      db.prepare(`INSERT INTO "test_clean" (id, _etag, data) VALUES (?, ?, ?)`)
+      db
+        .prepare(`INSERT INTO "test_clean" (id, _etag, data) VALUES (?, ?, ?)`)
         .run("1", "etag1", JSON.stringify(data))
 
       const row = db.prepare(`SELECT * FROM "test_clean" WHERE id = ?`).get("1") as any
@@ -345,26 +349,32 @@ describe("SQL Store (SQLite integration)", () => {
         `CREATE TABLE IF NOT EXISTS "test_compat" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`
       )
       // Old format: id and _etag inside data
-      db.prepare(`INSERT INTO "test_compat" (id, _etag, data) VALUES (?, ?, ?)`)
+      db
+        .prepare(`INSERT INTO "test_compat" (id, _etag, data) VALUES (?, ?, ?)`)
         .run("1", "etag1", JSON.stringify({ id: "1", _etag: "old_etag", name: "Alice", age: 30 }))
       // New format: id and _etag stripped from data
-      db.prepare(`INSERT INTO "test_compat" (id, _etag, data) VALUES (?, ?, ?)`)
+      db
+        .prepare(`INSERT INTO "test_compat" (id, _etag, data) VALUES (?, ?, ?)`)
         .run("2", "etag2", JSON.stringify({ name: "Bob", age: 25 }))
 
       // Both should be queryable by name
       const q1 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "name", op: "eq", value: "Alice" }],
-        "test_compat", {}
+        "test_compat",
+        {}
       )
       const r1 = query(db, q1.sql, q1.params)
       expect(r1.length).toBe(1)
       expect((r1[0] as any).id).toBe("1")
 
       const q2 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "name", op: "eq", value: "Bob" }],
-        "test_compat", {}
+        "test_compat",
+        {}
       )
       const r2 = query(db, q2.sql, q2.params)
       expect(r2.length).toBe(1)
@@ -372,9 +382,11 @@ describe("SQL Store (SQLite integration)", () => {
 
       // Both queryable by id column
       const q3 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "id", op: "in", value: ["1", "2"] as any }],
-        "test_compat", {}
+        "test_compat",
+        {}
       )
       expect(query(db, q3.sql, q3.params).length).toBe(2)
     }))
@@ -396,17 +408,21 @@ describe("SQL Store (SQLite integration)", () => {
 
       // Filter by field in data
       const q1 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "age", op: "gt", value: 28 as any }],
-        "test_noid", {}
+        "test_noid",
+        {}
       )
       expect(query(db, q1.sql, q1.params).length).toBe(2) // Alice(30), Charlie(35)
 
       // Filter by id column
       const q2 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "id", op: "eq", value: "2" }],
-        "test_noid", {}
+        "test_noid",
+        {}
       )
       const r2 = query(db, q2.sql, q2.params)
       expect(r2.length).toBe(1)
@@ -415,10 +431,15 @@ describe("SQL Store (SQLite integration)", () => {
 
       // Order + limit still works
       const q3 = buildWhereSQLQuery(
-        sqliteDialect, "id", [], "test_noid", {},
+        sqliteDialect,
+        "id",
+        [],
+        "test_noid",
+        {},
         undefined,
         [{ key: "age", direction: "ASC" }] as any,
-        undefined, 2
+        undefined,
+        2
       )
       const r3 = query(db, q3.sql, q3.params)
       expect(r3.length).toBe(2)
@@ -448,40 +469,48 @@ describe("SQL Store (SQLite integration)", () => {
 
       // Test eq
       const q1 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "name", op: "eq", value: "Alice" }],
-        "test_people", {}
+        "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",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "age", op: "gt", value: 28 as any }],
-        "test_people", {}
+        "test_people",
+        {}
       )
       expect(query(db, q2.sql, q2.params).length).toBe(2)
 
       // Test OR
       const q3 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [
           { t: "where", path: "name", op: "eq", value: "Alice" },
           { t: "or", path: "name", op: "eq", value: "Bob" }
         ],
-        "test_people", {}
+        "test_people",
+        {}
       )
       expect(query(db, q3.sql, q3.params).length).toBe(2)
 
       // Test AND
       const q4 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [
           { t: "where", path: "name", op: "eq", value: "Alice" },
           { t: "and", path: "age", op: "gt", value: 25 as any }
         ],
-        "test_people", {}
+        "test_people",
+        {}
       )
       const r4 = query(db, q4.sql, q4.params)
       expect(r4.length).toBe(1)
@@ -489,25 +518,31 @@ describe("SQL Store (SQLite integration)", () => {
 
       // Test IN
       const q5 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "id", op: "in", value: ["1", "3"] as any }],
-        "test_people", {}
+        "test_people",
+        {}
       )
       expect(query(db, q5.sql, q5.params).length).toBe(2)
 
       // Test contains (string)
       const q6 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "name", op: "contains", value: "li" }],
-        "test_people", {}
+        "test_people",
+        {}
       )
       expect(query(db, q6.sql, q6.params).length).toBe(2) // Alice, Charlie
 
       // Test startsWith
       const q7 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "name", op: "startsWith", value: "Al" }],
-        "test_people", {}
+        "test_people",
+        {}
       )
       const r7 = query(db, q7.sql, q7.params)
       expect(r7.length).toBe(1)
@@ -515,15 +550,18 @@ describe("SQL Store (SQLite integration)", () => {
 
       // Test includes (array)
       const q8 = buildWhereSQLQuery(
-        sqliteDialect, "id",
+        sqliteDialect,
+        "id",
         [{ t: "where", path: "tags", op: "includes", value: "admin" }],
-        "test_people", {}
+        "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",
+        sqliteDialect,
+        "id",
         [
           { t: "where", path: "name", op: "eq", value: "Alice" },
           {
@@ -535,19 +573,204 @@ describe("SQL Store (SQLite integration)", () => {
             relation: "some"
           }
         ],
-        "test_people", {}
+        "test_people",
+        {}
       )
       expect(query(db, q9.sql, q9.params).length).toBe(2) // Alice + Charlie
 
       // Test order + limit
       const q10 = buildWhereSQLQuery(
-        sqliteDialect, "id", [], "test_people", {},
+        sqliteDialect,
+        "id",
+        [],
+        "test_people",
+        {},
         undefined,
         [{ key: "age", direction: "DESC" }] as any,
-        undefined, 2
+        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
     }))
+
+  it("namespace param is in correct position for SQLite positional placeholders", () =>
+    withDb((db) => {
+      db.exec(
+        `CREATE TABLE IF NOT EXISTS "test_ns" (id TEXT NOT NULL, _namespace TEXT NOT NULL DEFAULT 'primary', _etag TEXT, data JSON NOT NULL, PRIMARY KEY (id, _namespace))`
+      )
+      const insert = db.prepare(
+        `INSERT INTO "test_ns" (id, _namespace, _etag, data) VALUES (?, ?, ?, ?)`
+      )
+      insert.run("1", "primary", "e1", JSON.stringify({ name: "Alice", role: "admin" }))
+      insert.run("2", "primary", "e2", JSON.stringify({ name: "Bob", role: "user" }))
+      insert.run("3", "other", "e3", JSON.stringify({ name: "Charlie", role: "admin" }))
+
+      // Build a filter query: role != 'deleted'
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [{ t: "where", path: "role", op: "neq", value: "deleted" }],
+        "test_ns",
+        {}
+      )
+
+      // Simulate what SQL.ts does: prepend _namespace = ? and put ns FIRST in params
+      const hasWhere = q.sql.includes("WHERE")
+      const nsSql = hasWhere
+        ? q.sql.replace("WHERE", `WHERE _namespace = ? AND`)
+        : q.sql.replace(`FROM "test_ns"`, `FROM "test_ns" WHERE _namespace = ?`)
+      const params = ["primary", ...q.params]
+
+      const results = query(db, nsSql, params)
+      // Should only get Alice and Bob (primary namespace), not Charlie (other namespace)
+      expect(results.length).toBe(2)
+      const names = results.map((r) => (JSON.parse((r as any).data) as any).name).sort()
+      expect(names).toEqual(["Alice", "Bob"])
+    }))
+})
+
+// --- toRow stripping and parseRow reconstruction tests ---
+
+describe("toRow strips _etag and id from data", () => {
+  // Replicate the toRow logic from SQL.ts to test in isolation
+  const toRow = <IdKey extends PropertyKey>(e: any, idKey: IdKey) => {
+    const newE = makeETag(e)
+    const id = newE[idKey] as string
+    const { _etag, [idKey]: _id, ...rest } = newE as any
+    const data = JSON.stringify(rest)
+    return { id, _etag: newE._etag!, data, item: newE }
+  }
+
+  it("data JSON does not contain _etag", () => {
+    const row = toRow({ id: "1", _etag: undefined, name: "Alice", age: 30 }, "id")
+    const parsed = JSON.parse(row.data) as any
+    expect(parsed).not.toHaveProperty("_etag")
+    expect(parsed.name).toBe("Alice")
+    expect(parsed.age).toBe(30)
+  })
+
+  it("data JSON does not contain id field", () => {
+    const row = toRow({ id: "1", _etag: undefined, name: "Alice" }, "id")
+    const parsed = JSON.parse(row.data) as any
+    expect(parsed).not.toHaveProperty("id")
+    expect(parsed.name).toBe("Alice")
+  })
+
+  it("data JSON does not contain custom idKey field", () => {
+    const row = toRow({ myId: "abc", _etag: undefined, name: "Bob" }, "myId")
+    const parsed = JSON.parse(row.data) as any
+    expect(parsed).not.toHaveProperty("myId")
+    expect(parsed.name).toBe("Bob")
+    expect(row.id).toBe("abc")
+  })
+
+  it("id and _etag are returned as separate fields", () => {
+    const row = toRow({ id: "1", _etag: undefined, name: "Alice" }, "id")
+    expect(row.id).toBe("1")
+    expect(typeof row._etag).toBe("string")
+    expect(row._etag.length).toBeGreaterThan(0)
+  })
+
+  it("item still contains all fields including _etag and id", () => {
+    const row = toRow({ id: "1", _etag: undefined, name: "Alice" }, "id")
+    expect(row.item.id).toBe("1")
+    expect(row.item._etag).toBe(row._etag)
+    expect(row.item.name).toBe("Alice")
+  })
+
+  it("preserves nested objects in data", () => {
+    const row = toRow({ id: "1", _etag: undefined, address: { city: "NYC", zip: "10001" } }, "id")
+    const parsed = JSON.parse(row.data) as any
+    expect(parsed.address).toEqual({ city: "NYC", zip: "10001" })
+    expect(parsed).not.toHaveProperty("id")
+    expect(parsed).not.toHaveProperty("_etag")
+  })
+})
+
+describe("parseRow reconstructs full object from row", () => {
+  it("re-injects id from row column using idKey", () => {
+    const result: any = parseRow(
+      { id: "42", _etag: "etag1", data: JSON.stringify({ name: "Alice", age: 30 }) },
+      "id",
+      {}
+    )
+    expect(result.id).toBe("42")
+    expect(result.name).toBe("Alice")
+    expect(result.age).toBe(30)
+    expect(result._etag).toBe("etag1")
+  })
+
+  it("re-injects custom idKey from row column", () => {
+    const result: any = parseRow(
+      { id: "abc", _etag: "etag2", data: JSON.stringify({ name: "Bob" }) },
+      "myId",
+      {}
+    )
+    expect(result.myId).toBe("abc")
+    expect(result.name).toBe("Bob")
+    expect(result._etag).toBe("etag2")
+  })
+
+  it("uses _etag from row column, not from data", () => {
+    const result: any = parseRow(
+      { id: "1", _etag: "column_etag", data: JSON.stringify({ _etag: "stale_data_etag", name: "Alice" }) },
+      "id",
+      {}
+    )
+    expect(result._etag).toBe("column_etag")
+  })
+
+  it("uses id from row column, not from data", () => {
+    const result: any = parseRow(
+      { id: "correct_id", _etag: "e1", data: JSON.stringify({ id: "wrong_id", name: "Alice" }) },
+      "id",
+      {}
+    )
+    expect(result.id).toBe("correct_id")
+  })
+
+  it("applies defaultValues for missing fields", () => {
+    const result: any = parseRow(
+      { id: "1", _etag: "e1", data: JSON.stringify({ name: "Alice" }) },
+      "id",
+      { status: "active", role: "user" }
+    )
+    expect(result.name).toBe("Alice")
+    expect(result.status).toBe("active")
+    expect(result.role).toBe("user")
+  })
+
+  it("data fields override defaultValues", () => {
+    const result: any = parseRow(
+      { id: "1", _etag: "e1", data: JSON.stringify({ name: "Alice", status: "inactive" }) },
+      "id",
+      { status: "active" }
+    )
+    expect(result.status).toBe("inactive")
+  })
+
+  it("handles null _etag from row", () => {
+    const result: any = parseRow(
+      { id: "1", _etag: null, data: JSON.stringify({ name: "Alice" }) },
+      "id",
+      {}
+    )
+    expect(result._etag).toBeUndefined()
+  })
+
+  it("round-trip: toRow then parseRow reconstructs the original", () => {
+    const original = { id: "1", _etag: undefined as string | undefined, name: "Alice", age: 30, tags: ["admin"] }
+    const newE = makeETag(original)
+    const { _etag, id: _id, ...rest } = newE as any
+    const row = { id: newE.id, _etag: newE._etag!, data: JSON.stringify(rest) }
+
+    const reconstructed: any = parseRow(row, "id", {})
+    expect(reconstructed.id).toBe("1")
+    expect(reconstructed.name).toBe("Alice")
+    expect(reconstructed.age).toBe(30)
+    expect(reconstructed.tags).toEqual(["admin"])
+    expect(reconstructed._etag).toBe(newE._etag)
+  })
 })