@effect-app/infra 4.0.0-beta.215 → 4.0.0-beta.217

package/test/rawQuery.test.ts

@@ -1,3 +1,4 @@
+import { SqliteClient } from "@effect/sql-sqlite-node"
 import { describe, expect, it } from "@effect/vitest"
 import { Array, Config, Context, Effect, flow, Layer, ManagedRuntime, Redacted, References, Result, S, Struct } from "effect-app"
 import { LogLevels } from "effect-app/utils"
@@ -7,6 +8,7 @@ import { makeRepo } from "../src/Model/Repository/makeRepo.js"
 import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
 import { CosmosStoreLayer } from "../src/Store/Cosmos.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
+import { SQLiteStoreLayer } from "../src/Store/SQL.js"
 
 export const rt = ManagedRuntime.make(Layer.mergeAll(
   Layer.effect(
@@ -517,6 +519,22 @@ class OrderRepo extends Context.Service<OrderRepo>()(
   static readonly Test = this
     .layer
     .pipe(Layer.provide(Layer.merge(MemoryStoreLive, RepositoryRegistryLive)))
+
+  static readonly TestSqlite = this
+    .layer
+    .pipe(
+      Layer.provide(
+        Layer.merge(
+          SQLiteStoreLayer({
+            url: Redacted.make("sqlite://"),
+            prefix: "test_",
+            dbName: "test"
+          }),
+          RepositoryRegistryLive
+        )
+      ),
+      Layer.provide(SqliteClient.layer({ filename: ":memory:" }))
+    )
 }
 
 describe("scanner-style AllPickList computed projections", () => {
@@ -578,8 +596,9 @@ describe("scanner-style AllPickList computed projections", () => {
     })
     .pipe(setupRequestContextFromCurrent())
 
-  it("works well in Memory", () =>
-    test.pipe(Effect.provide(OrderRepo.Test), rt.runPromise))
+  it("works well in Memory", () => test.pipe(Effect.provide(OrderRepo.Test), rt.runPromise))
+
+  it("works well in SQLite", () => test.pipe(Effect.provide(OrderRepo.TestSqlite), rt.runPromise))
 })
 
 // Same but mimics the FULL controller projection: includes `items` array
@@ -626,8 +645,9 @@ describe("scanner-style AllPickList — items + computed combined", () => {
     })
     .pipe(setupRequestContextFromCurrent())
 
-  it("works well in Memory", () =>
-    test.pipe(Effect.provide(OrderRepo.Test), rt.runPromise))
+  it("works well in Memory", () => test.pipe(Effect.provide(OrderRepo.Test), rt.runPromise))
+
+  it("works well in SQLite", () => test.pipe(Effect.provide(OrderRepo.TestSqlite), rt.runPromise))
 })
 
 describe("removeByIds", () => {

package/test/sql-store.test.ts

@@ -345,6 +345,90 @@ describe("SQL query builder (SQLite dialect)", () => {
     expect(result.sql).toContain(`AS "totalWeight"`)
   })
 
+  it("computed relation-sum-expr projection (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalWeighted",
+        computed: {
+          _tag: "relation-sum-expr",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(
+      `COALESCE(SUM((CAST(json_extract(_items.value, '$.weight') AS REAL) * CAST(json_extract(_items.value, '$.tradeUnit.amount') AS REAL))), 0)`
+    )
+    expect(result.sql).toContain(`AS "totalWeighted"`)
+  })
+
+  it("computed relation-sum-expr-by projection (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalsByUnit",
+        computed: {
+          _tag: "relation-sum-expr-by",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          unit: "tradeUnit.unit",
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(`json_group_array(json_object('unit', __unit, 'total', __total))`)
+    expect(result.sql).toContain(`GROUP BY json_extract(_items.value, '$.tradeUnit.unit')`)
+    expect(result.sql).toContain(`AS "totalsByUnit"`)
+  })
+
+  it("computed relation-sum-expr-normalized projection (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalKg",
+        computed: {
+          _tag: "relation-sum-expr-normalized",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          unit: "tradeUnit.unit",
+          toBase: "kg",
+          factors: { g: 0.001 },
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(
+      `CASE json_extract(_items.value, '$.tradeUnit.unit') WHEN 'kg' THEN 1 WHEN 'g' THEN 0.001 ELSE NULL END`
+    )
+    expect(result.sql).toContain(`AS "totalKg"`)
+  })
+
   it("computed relation-collect (non-distinct) projection (sqlite)", () => {
     const result = buildWhereSQLQuery(
       sqliteDialect,
@@ -515,6 +599,88 @@ describe("SQL query builder (PostgreSQL dialect)", () => {
     expect(result.sql).toContain(`AS "totalWeight"`)
   })
 
+  it("computed relation-sum-expr (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalWeighted",
+        computed: {
+          _tag: "relation-sum-expr",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(
+      `COALESCE(SUM(((_items->>'weight')::numeric * (_items->'tradeUnit'->>'amount')::numeric)), 0)`
+    )
+    expect(result.sql).toContain(`AS "totalWeighted"`)
+  })
+
+  it("computed relation-sum-expr-by (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalsByUnit",
+        computed: {
+          _tag: "relation-sum-expr-by",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          unit: "tradeUnit.unit",
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(`jsonb_agg(jsonb_build_object('unit', __unit, 'total', __total))`)
+    expect(result.sql).toContain(`GROUP BY _items->'tradeUnit'->>'unit'`)
+    expect(result.sql).toContain(`AS "totalsByUnit"`)
+  })
+
+  it("computed relation-sum-expr-normalized (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalKg",
+        computed: {
+          _tag: "relation-sum-expr-normalized",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          unit: "tradeUnit.unit",
+          toBase: "kg",
+          factors: { g: 0.001 },
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(`CASE _items->'tradeUnit'->>'unit' WHEN 'kg' THEN 1 WHEN 'g' THEN 0.001 ELSE NULL END`)
+    expect(result.sql).toContain(`AS "totalKg"`)
+  })
+
   it("computed relation-collect (pg jsonb_agg)", () => {
     const result = buildWhereSQLQuery(
       pgDialect,