@effect-app/infra 4.0.0-beta.98 → 4.0.0

package/src/Store/SQL/query.ts

@@ -1,9 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, type NonEmptyReadonlyArray } from "effect-app"
+import type { NonEmptyReadonlyArray } from "effect-app/Array"
+import * as Effect from "effect-app/Effect"
+import type { FilterR, FilterResult } from "effect-app/Model/filter/filterApi"
+import type { AggregateIrExpression, ComputedProjectionIrExpression, ComputedProjectionMathIrExpression } from "effect-app/Model/query"
 import { assertUnreachable } from "effect-app/utils"
-import { InfraLogger } from "../../logger.js"
-import type { FilterR, FilterResult } from "../../Model/filter/filterApi.js"
-import { isRelationCheck } from "../codeFilter.js"
+import { InfraLogger } from "../../logger.ts"
+import { isRelationCheck } from "../codeFilter.ts"
+import { jsonifyFilter, type JsonLower } from "../utils.ts"
 
 export interface SQLDialect {
   readonly jsonExtract: (path: string) => string
@@ -15,6 +18,9 @@ export interface SQLDialect {
   readonly jsonArrayNotContainsAny: (arrPath: string, valPlaceholders: readonly string[]) => string
   readonly jsonArrayContainsAll: (arrPath: string, valPlaceholders: readonly string[]) => string
   readonly jsonArrayNotContainsAll: (arrPath: string, valPlaceholders: readonly string[]) => string
+  readonly jsonMapHasKey: (arrPath: string, valPlaceholder: string) => string
+  readonly jsonMapHasValue: (arrPath: string, valPlaceholder: string) => string
+  readonly jsonMapHasPair: (arrPath: string, valPlaceholder: string) => string
   readonly caseInsensitiveLike: (expr: string, valPlaceholder: string) => string
   readonly caseInsensitiveNotLike: (expr: string, valPlaceholder: string) => string
   readonly jsonColumnType: "JSON" | "JSONB"
@@ -22,11 +28,13 @@ export interface SQLDialect {
   readonly jsonEachFrom: (arrPath: string, alias: string) => string
   readonly jsonExtractElement: (alias: string, subPath: string) => string
   readonly serializeJsonValue: (v: unknown) => unknown
+  readonly serializeScalar: (v: unknown) => unknown
 }
 
 export const sqliteDialect: SQLDialect = {
   jsonExtract: (path) => `json_extract(data, '$.${path}')`,
-  jsonExtractJson: (path) => `json_quote(json_extract(data, '$.${path}'))`,
+  jsonExtractJson: (path) =>
+    `CASE json_type(data, '$.${path}') WHEN 'true' THEN 'true' WHEN 'false' THEN 'false' ELSE json_quote(json_extract(data, '$.${path}')) END`,
   placeholder: (_index) => "?",
   jsonArrayContains: (arrPath, val) => `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value = ${val})`,
   jsonArrayNotContains: (arrPath, val) =>
@@ -41,13 +49,21 @@ export const sqliteDialect: SQLDialect = {
     `NOT (${
       vals.map((v) => `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value = ${v})`).join(" AND ")
     })`,
+  jsonMapHasKey: (arrPath, val) =>
+    `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE json_extract(value, '$[0]') = ${val})`,
+  jsonMapHasValue: (arrPath, val) =>
+    `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE json_extract(value, '$[1]') = ${val})`,
+  jsonMapHasPair: (arrPath, val) => `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value = ${val})`,
   caseInsensitiveLike: (expr, val) => `LOWER(${expr}) LIKE LOWER(${val})`,
   caseInsensitiveNotLike: (expr, val) => `LOWER(${expr}) NOT LIKE LOWER(${val})`,
   jsonColumnType: "JSON",
   arrayLength: (path) => `json_array_length(data, '$.${path}')`,
   jsonEachFrom: (arrPath, alias) => `json_each(data, '$.${arrPath}') AS ${alias}`,
   jsonExtractElement: (alias, subPath) => `json_extract(${alias}.value, '$.${subPath}')`,
-  serializeJsonValue: (v) => v
+  serializeJsonValue: (v) => v,
+  // SQLite stores JSON booleans as integers (0/1) and better-sqlite3 refuses
+  // to bind JS booleans, so coerce them to integers for WHERE params.
+  serializeScalar: (v) => typeof v === "boolean" ? (v ? 1 : 0) : v
 }
 
 export const pgDialect: SQLDialect = {
@@ -105,6 +121,27 @@ export const pgDialect: SQLDialect = {
       : `data${parts.map((p) => `->'${p}'`).join("")}`
     return `NOT (${vals.map((v) => `${jsonPath} @> ${v}::jsonb`).join(" AND ")})`
   },
+  jsonMapHasKey: (arrPath, val) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return `EXISTS(SELECT 1 FROM jsonb_array_elements(${jsonPath}) e WHERE e->0 = ${val}::jsonb)`
+  },
+  jsonMapHasValue: (arrPath, val) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return `EXISTS(SELECT 1 FROM jsonb_array_elements(${jsonPath}) e WHERE e->1 = ${val}::jsonb)`
+  },
+  jsonMapHasPair: (arrPath, val) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return `${jsonPath} @> jsonb_build_array(${val}::jsonb)`
+  },
   caseInsensitiveLike: (expr, val) => `${expr} ILIKE ${val}`,
   caseInsensitiveNotLike: (expr, val) => `${expr} NOT ILIKE ${val}`,
   jsonColumnType: "JSONB",
@@ -122,7 +159,9 @@ export const pgDialect: SQLDialect = {
     const last = parts.pop()!
     return `${alias}${parts.map((p) => `->'${p}'`).join("")}->>'${last}'`
   },
-  serializeJsonValue: (v) => JSON.stringify(v)
+  serializeJsonValue: (v) => JSON.stringify(v),
+  // PG's ->> operator yields text, so compare booleans as 'true'/'false' text.
+  serializeScalar: (v) => typeof v === "boolean" ? (v ? "true" : "false") : v
 }
 
 export function logQuery(q: { sql: string; params: unknown[] }) {
@@ -140,22 +179,51 @@ const dottedToJsonPath = (path: string) =>
     .filter((p) => p !== "-1")
     .join(".")
 
+const mapItemParam = (dialect: SQLDialect, value: unknown) =>
+  dialect.jsonColumnType === "JSONB" ? dialect.serializeJsonValue(value) : value
+
+const mapPairParam = (dialect: SQLDialect, value: unknown) => {
+  const encoded = dialect.serializeJsonValue(value)
+  return typeof encoded === "string" ? encoded : JSON.stringify(value)
+}
+
+const sqlStringLiteral = (value: string) => `'${value.replaceAll("'", "''")}'`
+
 export function buildWhereSQLQuery(
   dialect: SQLDialect,
   idKey: PropertyKey,
   filter: readonly FilterResult[],
   tableName: string,
   defaultValues: Record<string, unknown>,
-  select?: NonEmptyReadonlyArray<string | { key: string; subKeys: readonly string[] }>,
+  select?: NonEmptyReadonlyArray<
+    string | {
+      key: string
+      subKeys: readonly string[]
+    } | {
+      key: string
+      computed: ComputedProjectionIrExpression
+    } | {
+      key: string
+      path: string
+    } | {
+      key: string
+      aggregate: AggregateIrExpression
+    }
+  >,
   order?: NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }>,
   skip?: number,
-  limit?: number
+  limit?: number,
+  namespace?: string,
+  json?: JsonLower
 ) {
+  // defaultValues are already JSON-lowered at store construction; a second
+  // schema encode of an ISO Date string throws "Expected a valid Date".
+  filter = (json?.jsonifyFilter ?? jsonifyFilter)(filter)
   const params: unknown[] = []
   let paramIndex = 1
 
   const addParam = (value: unknown): string => {
-    params.push(value)
+    params.push(dialect.serializeScalar(value))
     return dialect.placeholder(paramIndex++)
   }
 
@@ -188,7 +256,7 @@ export function buildWhereSQLQuery(
 
     switch (x.op) {
       case "in": {
-        const vals = x.value as unknown as readonly unknown[]
+        const vals = x.value as readonly unknown[]
         const hasNull = vals.some((v) => v == null)
         const nonNullVals = vals.filter((v) => v != null)
         const parts: string[] = []
@@ -200,7 +268,7 @@ export function buildWhereSQLQuery(
         return parts.length > 1 ? `(${parts.join(" OR ")})` : parts[0] ?? "1=0"
       }
       case "notIn": {
-        const vals = x.value as unknown as readonly unknown[]
+        const vals = x.value as readonly unknown[]
         const hasNull = vals.some((v) => v == null)
         const nonNullVals = vals.filter((v) => v != null)
         const parts: string[] = []
@@ -225,30 +293,133 @@ export function buildWhereSQLQuery(
 
       case "includes-any": {
         const arrPath = dottedToJsonPath(resolvedPath)
-        const vals = x.value as unknown as readonly unknown[]
+        const vals = x.value as readonly unknown[]
         const placeholders = vals.map((v) => addParam(dialect.serializeJsonValue(v)))
         return dialect.jsonArrayContainsAny(arrPath, placeholders)
       }
       case "notIncludes-any": {
         const arrPath = dottedToJsonPath(resolvedPath)
-        const vals = x.value as unknown as readonly unknown[]
+        const vals = x.value as readonly unknown[]
         const placeholders = vals.map((v) => addParam(dialect.serializeJsonValue(v)))
         return dialect.jsonArrayNotContainsAny(arrPath, placeholders)
       }
 
       case "includes-all": {
         const arrPath = dottedToJsonPath(resolvedPath)
-        const vals = x.value as unknown as readonly unknown[]
+        const vals = x.value as readonly unknown[]
         const placeholders = vals.map((v) => addParam(dialect.serializeJsonValue(v)))
         return dialect.jsonArrayContainsAll(arrPath, placeholders)
       }
       case "notIncludes-all": {
         const arrPath = dottedToJsonPath(resolvedPath)
-        const vals = x.value as unknown as readonly unknown[]
+        const vals = x.value as readonly unknown[]
         const placeholders = vals.map((v) => addParam(dialect.serializeJsonValue(v)))
         return dialect.jsonArrayNotContainsAll(arrPath, placeholders)
       }
 
+      case "hasKey": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const v = addParam(mapItemParam(dialect, x.value))
+        return dialect.jsonMapHasKey(arrPath, v)
+      }
+      case "notHasKey": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const v = addParam(mapItemParam(dialect, x.value))
+        return `NOT (${dialect.jsonMapHasKey(arrPath, v)})`
+      }
+      case "hasValue": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const v = addParam(mapItemParam(dialect, x.value))
+        return dialect.jsonMapHasValue(arrPath, v)
+      }
+      case "notHasValue": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const v = addParam(mapItemParam(dialect, x.value))
+        return `NOT (${dialect.jsonMapHasValue(arrPath, v)})`
+      }
+      case "hasKeyValue": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const v = addParam(mapPairParam(dialect, x.value))
+        return dialect.jsonMapHasPair(arrPath, v)
+      }
+      case "notHasKeyValue": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const v = addParam(mapPairParam(dialect, x.value))
+        return `NOT (${dialect.jsonMapHasPair(arrPath, v)})`
+      }
+      case "hasKey-any": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        const parts = vals.map((val) => dialect.jsonMapHasKey(arrPath, addParam(mapItemParam(dialect, val))))
+        return `(${parts.join(" OR ")})`
+      }
+      case "notHasKey-any": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        const parts = vals.map((val) => dialect.jsonMapHasKey(arrPath, addParam(mapItemParam(dialect, val))))
+        return `NOT (${parts.join(" OR ")})`
+      }
+      case "hasKey-all": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        return vals.map((val) => dialect.jsonMapHasKey(arrPath, addParam(mapItemParam(dialect, val)))).join(" AND ")
+      }
+      case "notHasKey-all": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        return `NOT (${
+          vals.map((val) => dialect.jsonMapHasKey(arrPath, addParam(mapItemParam(dialect, val)))).join(" AND ")
+        })`
+      }
+      case "hasValue-any": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        const parts = vals.map((val) => dialect.jsonMapHasValue(arrPath, addParam(mapItemParam(dialect, val))))
+        return `(${parts.join(" OR ")})`
+      }
+      case "notHasValue-any": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        const parts = vals.map((val) => dialect.jsonMapHasValue(arrPath, addParam(mapItemParam(dialect, val))))
+        return `NOT (${parts.join(" OR ")})`
+      }
+      case "hasValue-all": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        return vals.map((val) => dialect.jsonMapHasValue(arrPath, addParam(mapItemParam(dialect, val)))).join(" AND ")
+      }
+      case "notHasValue-all": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        return `NOT (${
+          vals.map((val) => dialect.jsonMapHasValue(arrPath, addParam(mapItemParam(dialect, val)))).join(" AND ")
+        })`
+      }
+      case "hasKeyValue-any": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        const parts = vals.map((val) => dialect.jsonMapHasPair(arrPath, addParam(mapPairParam(dialect, val))))
+        return `(${parts.join(" OR ")})`
+      }
+      case "notHasKeyValue-any": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        const parts = vals.map((val) => dialect.jsonMapHasPair(arrPath, addParam(mapPairParam(dialect, val))))
+        return `NOT (${parts.join(" OR ")})`
+      }
+      case "hasKeyValue-all": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        return vals.map((val) => dialect.jsonMapHasPair(arrPath, addParam(mapPairParam(dialect, val)))).join(" AND ")
+      }
+      case "notHasKeyValue-all": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as readonly unknown[]
+        return `NOT (${
+          vals.map((val) => dialect.jsonMapHasPair(arrPath, addParam(mapPairParam(dialect, val)))).join(" AND ")
+        })`
+      }
+
       case "contains": {
         const v = addParam(`%${x.value}%`)
         return dialect.caseInsensitiveLike(k, v)
@@ -371,6 +542,136 @@ export function buildWhereSQLQuery(
     return s
   }
 
+  const computedSelectExpr = (key: string, computed: ComputedProjectionIrExpression): string => {
+    const relationPath = dottedToJsonPath(computed.path)
+    const relationAlias = `_${computed.path}`
+    const relationFrom = dialect.jsonEachFrom(relationPath, relationAlias)
+    const toNumber = (expr: string) =>
+      dialect.jsonColumnType === "JSON" ? `CAST(${expr} AS REAL)` : `(${expr})::numeric`
+    const compileExpr = (expression: ComputedProjectionMathIrExpression): string => {
+      switch (expression._tag) {
+        case "field":
+          return toNumber(dialect.jsonExtractElement(relationAlias, expression.field))
+        case "mul":
+          return `(${compileExpr(expression.left)} * ${compileExpr(expression.right)})`
+        default:
+          return assertUnreachable(expression)
+      }
+    }
+    const factorCaseExpr = (unitExpr: string, toBase: string, factors: Readonly<Record<string, number>>) => {
+      const entries = Object.entries(factors).filter(([, factor]) => Number.isFinite(factor))
+      const cases = entries.map(([unit, factor]) => ` WHEN ${sqlStringLiteral(unit)} THEN ${factor}`).join("")
+      return `CASE ${unitExpr} WHEN ${sqlStringLiteral(toBase)} THEN 1${cases} ELSE NULL END`
+    }
+    const filter = "filter" in computed ? computed.filter : []
+    const whereClause = () =>
+      filter.length > 0
+        ? ` WHERE ${print(filter, computed.path, false)}`
+        : ""
+    const boolExpr = (sqlExpr: string) =>
+      dialect.jsonColumnType === "JSON"
+        ? `CASE WHEN ${sqlExpr} THEN 'true' ELSE 'false' END AS "${key}"`
+        : `${sqlExpr} AS "${key}"`
+    switch (computed._tag) {
+      case "relation-count":
+        return `(SELECT COUNT(1) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      case "relation-any":
+        return boolExpr(`EXISTS(SELECT 1 FROM ${relationFrom}${whereClause()})`)
+      case "relation-every":
+        // ∀x.P(x) ≡ ¬∃x.¬P(x). When no filter, no element exists that violates ⊤ → true.
+        return boolExpr(
+          filter.length === 0
+            ? `1=1`
+            : `NOT EXISTS(SELECT 1 FROM ${relationFrom} WHERE NOT (${print(filter, computed.path, false)}))`
+        )
+      case "relation-distinct-count": {
+        const fieldExtract = dialect.jsonExtractElement(relationAlias, computed.field)
+        return `(SELECT COUNT(DISTINCT ${fieldExtract}) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-sum": {
+        const fieldExtract = dialect.jsonExtractElement(relationAlias, computed.field)
+        return `(SELECT COALESCE(SUM(${toNumber(fieldExtract)}), 0) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-sum-expr": {
+        const expression = compileExpr(computed.expression)
+        return `(SELECT COALESCE(SUM(${expression}), 0) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-sum-expr-by": {
+        const expression = compileExpr(computed.expression)
+        const unitExpr = dialect.jsonExtractElement(relationAlias, computed.unit)
+        if (dialect.jsonColumnType === "JSON") {
+          return `(SELECT COALESCE(json_group_array(json_object('unit', __unit, 'total', __total)), json_array()) FROM (SELECT ${unitExpr} AS __unit, COALESCE(SUM(${expression}), 0) AS __total FROM ${relationFrom}${whereClause()} GROUP BY ${unitExpr})) AS "${key}"`
+        }
+        return `(SELECT COALESCE(jsonb_agg(jsonb_build_object('unit', __unit, 'total', __total)), '[]'::jsonb) FROM (SELECT ${unitExpr} AS __unit, COALESCE(SUM(${expression}), 0) AS __total FROM ${relationFrom}${whereClause()} GROUP BY ${unitExpr}) __grouped) AS "${key}"`
+      }
+      case "relation-sum-expr-normalized": {
+        const expression = compileExpr(computed.expression)
+        const unitExpr = dialect.jsonExtractElement(relationAlias, computed.unit)
+        const factorExpr = factorCaseExpr(unitExpr, computed.toBase, computed.factors)
+        return `(SELECT COALESCE(SUM((${expression}) * (${factorExpr})), 0) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-collect": {
+        const fieldExtract = dialect.jsonExtractElement(relationAlias, computed.field)
+        if (dialect.jsonColumnType === "JSON") {
+          // sqlite: json_group_array does not accept DISTINCT; emulate via inner DISTINCT subquery
+          if (computed.distinct) {
+            return `(SELECT COALESCE(json_group_array(__v), json_array()) FROM (SELECT DISTINCT ${fieldExtract} AS __v FROM ${relationFrom}${whereClause()})) AS "${key}"`
+          }
+          return `(SELECT COALESCE(json_group_array(${fieldExtract}), json_array()) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+        }
+        const aggArg = computed.distinct ? `DISTINCT ${fieldExtract}` : fieldExtract
+        return `(SELECT COALESCE(jsonb_agg(${aggArg}), '[]'::jsonb) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-length": {
+        const arrPath = dottedToJsonPath(computed.path)
+        return `${dialect.arrayLength(arrPath)} AS "${key}"`
+      }
+      case "relation-collect-fields": {
+        const branches = computed.fields.map((field) => {
+          const fieldExtract = dialect.jsonExtractElement(relationAlias, field)
+          return `SELECT ${fieldExtract} AS __v FROM ${relationFrom}${whereClause()}`
+        })
+        const unionQuery = branches.join(" UNION ALL ")
+        if (dialect.jsonColumnType === "JSON") {
+          if (computed.distinct) {
+            return `(SELECT COALESCE(json_group_array(__v), json_array()) FROM (SELECT DISTINCT __v FROM (${unionQuery}))) AS "${key}"`
+          }
+          return `(SELECT COALESCE(json_group_array(__v), json_array()) FROM (${unionQuery})) AS "${key}"`
+        }
+        if (computed.distinct) {
+          return `(SELECT COALESCE(jsonb_agg(__v), '[]'::jsonb) FROM (SELECT DISTINCT __v FROM (${unionQuery}) inner_q) outer_q) AS "${key}"`
+        }
+        return `(SELECT COALESCE(jsonb_agg(__v), '[]'::jsonb) FROM (${unionQuery}) t) AS "${key}"`
+      }
+      default:
+        return assertUnreachable(computed)
+    }
+  }
+
+  const aggregateSelectExpr = (key: string, agg: AggregateIrExpression): string => {
+    switch (agg._tag) {
+      case "agg-count":
+        return `COUNT(1) AS "${key}"`
+      case "agg-count-when": {
+        if (agg.filter.length === 0) return `COUNT(1) AS "${key}"`
+        const cond = print([{ t: "where-scope", result: agg.filter, relation: "some" }], null, false)
+        return `COUNT(CASE WHEN ${cond} THEN 1 END) AS "${key}"`
+      }
+      case "agg-sum":
+        return `COALESCE(SUM(${fieldExpr(agg.field)}), 0) AS "${key}"`
+      case "agg-min":
+        return `MIN(${fieldExpr(agg.field)}) AS "${key}"`
+      case "agg-max":
+        return `MAX(${fieldExpr(agg.field)}) AS "${key}"`
+      default:
+        return assertUnreachable(agg)
+    }
+  }
+
+  const hasAggregates = select
+    ? select.some((s) => typeof s === "object" && s !== null && "aggregate" in s)
+    : false
+
   const getSelectExpr = (): string => {
     if (!select) return "id, _etag, data"
     const fields = select.map((s) => {
@@ -379,24 +680,69 @@ export function buildWhereSQLQuery(
         if (s === "_etag") return `_etag`
         return `${dialect.jsonExtractJson(s)} AS "${s}"`
       }
+      if ("computed" in s) {
+        return computedSelectExpr(s.key, s.computed)
+      }
+      if ("aggregate" in s) {
+        return aggregateSelectExpr(s.key, s.aggregate)
+      }
+      if ("path" in s) {
+        // Group-by fields: extract as scalar (not JSON-encoded) so grouping works and values compare as plain strings/numbers
+        return `${fieldExpr(dottedToJsonPath(s.path))} AS "${s.key}"`
+      }
       return `${dialect.jsonExtractJson(s.key)} AS "${s.key}"`
     })
     return fields.join(", ")
   }
 
-  const whereClause = filter.length
-    ? `WHERE ${print([{ t: "where-scope", result: filter, relation: "some" }], null, false)}`
+  // Order matters: projection params must be emitted BEFORE user-filter
+  // params so positional `?` placeholders in SQLite match `params[]` order.
+  const selectExpr = getSelectExpr()
+
+  const namespaceClause = namespace !== undefined
+    ? `_namespace = ${addParam(namespace)}`
+    : ""
+  const userWhere = filter.length
+    ? print([{ t: "where-scope", result: filter, relation: "some" }], null, false)
+    : ""
+  const whereClause = namespaceClause && userWhere
+    ? `WHERE ${namespaceClause} AND ${userWhere}`
+    : namespaceClause
+    ? `WHERE ${namespaceClause}`
+    : userWhere
+    ? `WHERE ${userWhere}`
+    : ""
+
+  const groupByClause = hasAggregates && select
+    ? (() => {
+      const groupByExprs = select
+        .filter((s): s is string | { key: string; path: string } =>
+          typeof s === "string" || (typeof s === "object" && s !== null && "path" in s)
+        )
+        .map((s) => typeof s === "string" ? fieldExpr(s) : fieldExpr(dottedToJsonPath(s.path)))
+      return groupByExprs.length > 0 ? `GROUP BY ${groupByExprs.join(", ")}` : ""
+    })()
     : ""
 
   const orderClause = order
-    ? `ORDER BY ${order.map((_) => `${fieldExpr(_.key)} ${_.direction}`).join(", ")}`
+    ? `ORDER BY ${
+      order
+        .map((_) =>
+          hasAggregates
+            ? `"${_.key}" ${_.direction}`
+            : `${fieldExpr(_.key)} ${_.direction}`
+        )
+        .join(", ")
+    }`
     : ""
 
   const limitClause = limit !== undefined || skip !== undefined
     ? `LIMIT ${addParam(limit ?? 999999)} OFFSET ${addParam(skip ?? 0)}`
     : ""
 
-  const sql = `SELECT ${getSelectExpr()} FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause}`.trim()
+  const sql = `SELECT ${selectExpr} FROM "${tableName}" ${whereClause} ${groupByClause} ${orderClause} ${limitClause}`
+    .replace(/\s+/g, " ")
+    .trim()
 
   return { sql, params }
 }