@effect-app/infra 4.0.0-beta.316 → 4.0.0-beta.317

package/src/Store/SQL.ts

@@ -15,8 +15,9 @@ import { SqlClient } from "effect/unstable/sql"
 import { DatabaseError, OptimisticConcurrencyException } from "../errors.ts"
 import { InfraLogger } from "../logger.ts"
 import { annotateDb, type DbSystem } from "../otel.ts"
+import { makeJsonDocumentCodec } from "./jsonDocument.ts"
 import { buildWhereSQLQuery, logQuery, type SQLDialect, sqliteDialect } from "./SQL/query.ts"
-import { makeETag } from "./utils.ts"
+import { makeETag, makeJsonLower, toJsonQueryValue } from "./utils.ts"
 
 const sqlErrorMessage = (e: unknown) => (e as any)?.message ? String((e as any).message) : String(e)
 const sqlIsTransient = (e: unknown) =>
@@ -46,10 +47,14 @@ export class WithNsTransaction
 export const parseRow = <Encoded extends FieldValues>(
   row: { id: string; _etag: string | null; data: string },
   idKey: PropertyKey,
-  defaultValues: Partial<Encoded>
+  defaultValues: Partial<Encoded>,
+  decode: (doc: PersistenceModelType<Encoded>) => PersistenceModelType<Encoded> = (doc) => doc
 ): PersistenceModelType<Encoded> => {
   const data = (typeof row.data === "string" ? JSON.parse(row.data) : row.data) as object
-  return { ...defaultValues, ...data, [idKey]: row.id, _etag: row._etag ?? undefined } as PersistenceModelType<Encoded>
+  const jsonDefaults = toJsonQueryValue(defaultValues) as Partial<Encoded>
+  return decode(
+    { ...jsonDefaults, ...data, [idKey]: row.id, _etag: row._etag ?? undefined } as PersistenceModelType<Encoded>
+  )
 }
 
 const parseSelectRow = (
@@ -86,7 +91,9 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
       ) {
         type PM = PersistenceModelType<Encoded>
         const tableName = `${prefix}${name}`
-        const defaultValues = config?.defaultValues ?? {}
+        const json = makeJsonLower(config)
+        const defaultValues = json.toJson(config?.defaultValues ?? {}) as Partial<Encoded>
+        const codec = makeJsonDocumentCodec<Encoded>(config?.schema)
 
         const resolveNamespace = !config?.allowNamespace
           ? Effect.succeed("primary")
@@ -112,11 +119,11 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
           )
 
         const toRow = (e: PM) => {
-          const newE = makeETag(e)
+          const newE = makeETag(codec.encode(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 }
+          return { id, _etag: newE._etag!, data, item: codec.decode(newE) }
         }
 
         const exec = (query: string, params?: readonly unknown[]) =>
@@ -209,7 +216,9 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
               const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = ?`
               return exec(sqlText, [ns])
                 .pipe(
-                  Effect.map((rows) => (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues))),
+                  Effect.map((rows) =>
+                    (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues, codec.decode))
+                  ),
                   annotateDb({
                     operation: "all",
                     system,
@@ -231,7 +240,7 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
                     Effect.map((rows) => {
                       const row = (rows as any[])[0]
                       return row
-                        ? Option.some(parseRow<Encoded>(row, idKey, defaultValues))
+                        ? Option.some(parseRow<Encoded>(row, idKey, defaultValues, codec.decode))
                         : Option.none()
                     }),
                     annotateDb({
@@ -281,7 +290,8 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
                           .skip,
                         f
                           .limit,
-                        ns
+                        ns,
+                        json
                       )
                     })
                     .pipe(
@@ -303,7 +313,9 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
                                 } as M
                               })
                             }
-                            return (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues) as any as M)
+                            return (rows as any[]).map((r) =>
+                              parseRow<Encoded>(r, idKey, defaultValues, codec.decode) as any as M
+                            )
                           })
                         )
                       ),
@@ -418,7 +430,9 @@ function makeSQLiteStorePerNs(
     ) {
       type PM = PersistenceModelType<Encoded>
       const tableName = `${prefix}${name}`
-      const defaultValues = config?.defaultValues ?? {}
+      const json = makeJsonLower(config)
+      const defaultValues = json.toJson(config?.defaultValues ?? {}) as Partial<Encoded>
+      const codec = makeJsonDocumentCodec<Encoded>(config?.schema)
 
       const resolveNamespace = !config?.allowNamespace
         ? Effect.succeed("primary")
@@ -430,11 +444,11 @@ function makeSQLiteStorePerNs(
         }))
 
       const toRow = (e: PM) => {
-        const newE = makeETag(e)
+        const newE = makeETag(codec.encode(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 }
+        return { id, _etag: newE._etag!, data, item: codec.decode(newE) }
       }
 
       const exec = (ns: string, query: string, params?: readonly unknown[]) =>
@@ -549,7 +563,9 @@ function makeSQLiteStorePerNs(
           const sqlText = `SELECT id, _etag, data FROM "${tableName}"`
           return exec(ns, sqlText)
             .pipe(
-              Effect.map((rows) => (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues))),
+              Effect.map((rows) =>
+                (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues, codec.decode))
+              ),
               annotateDb({
                 operation: "all",
                 system: "sqlite",
@@ -570,7 +586,7 @@ function makeSQLiteStorePerNs(
                   Effect.map((rows) => {
                     const row = (rows as any[])[0]
                     return row
-                      ? Option.some(parseRow<Encoded>(row, idKey, defaultValues))
+                      ? Option.some(parseRow<Encoded>(row, idKey, defaultValues, codec.decode))
                       : Option.none()
                   }),
                   annotateDb({
@@ -619,7 +635,9 @@ function makeSQLiteStorePerNs(
                       f
                         .skip,
                       f
-                        .limit
+                        .limit,
+                      undefined,
+                      json
                     )
                   )
                   .pipe(
@@ -641,7 +659,9 @@ function makeSQLiteStorePerNs(
                               } as M
                             })
                           }
-                          return (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues) as any as M)
+                          return (rows as any[]).map((r) =>
+                            parseRow<Encoded>(r, idKey, defaultValues, codec.decode) as any as M
+                          )
                         })
                       )
                     ),

package/src/Store/codeFilter.ts

@@ -6,54 +6,102 @@ import type { FieldValues } from "effect-app/Model/filter/types"
 import * as Option from "effect-app/Option"
 import type { Filter } from "effect-app/Store"
 import { assertUnreachable } from "effect-app/utils"
-import { compare, get, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.ts"
+import { compare, get, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive, toJsonQueryValue } from "./utils.ts"
 
-const vAsArr = (v: string) => v as unknown as any[]
+const vAsArr = (v: unknown) => toJsonQueryValue(v) as any[]
+
+const mapEntries = (value: unknown): readonly [unknown, unknown][] => {
+  const json = toJsonQueryValue(value)
+  if (!Array.isArray(json)) return []
+  return json.filter((entry): entry is [unknown, unknown] => Array.isArray(entry) && entry.length >= 2)
+}
+
+const pairEq = (entry: readonly [unknown, unknown], pair: unknown) => {
+  const json = toJsonQueryValue(pair)
+  return Array.isArray(json) && json.length >= 2 && compare(entry[0], json[0]) && compare(entry[1], json[1])
+}
 
 const filterStatement = (x: any, p: FilterR) => {
-  const k = get(x, p.path)
+  const k = toJsonQueryValue(get(x, p.path))
+  const v = toJsonQueryValue(p.value)
   switch (p.op) {
     case "in":
-      return p.value.includes(k)
+      return (v as unknown[]).includes(k)
     case "notIn":
-      return !p.value.includes(k)
+      return !(v as unknown[]).includes(k)
     case "lt":
-      return lowerThan(k, p.value)
+      return lowerThan(k as any, v as any)
     case "lte":
-      return lowerThanExclusive(k, p.value)
+      return lowerThanExclusive(k as any, v as any)
     case "gt":
-      return greaterThan(k, p.value)
+      return greaterThan(k as any, v as any)
     case "gte":
-      return greaterThanExclusive(k, p.value)
+      return greaterThanExclusive(k as any, v as any)
     case "includes":
-      return (k as Array<string>).includes(p.value)
+      return (k as Array<unknown>).includes(v)
     case "notIncludes":
-      return !(k as Array<string>).includes(p.value)
+      return !(k as Array<unknown>).includes(v)
     case "includes-any":
-      return (vAsArr(p.value)).some((_) => (k as Array<string>)?.includes(_))
+      return (vAsArr(p.value)).some((_) => (k as Array<unknown>)?.includes(_))
     case "notIncludes-any":
-      return !(vAsArr(p.value)).some((_) => (k as Array<string>)?.includes(_))
+      return !(vAsArr(p.value)).some((_) => (k as Array<unknown>)?.includes(_))
     case "includes-all":
-      return (vAsArr(p.value)).every((_) => (k as Array<string>)?.includes(_))
+      return (vAsArr(p.value)).every((_) => (k as Array<unknown>)?.includes(_))
     case "notIncludes-all":
-      return !(vAsArr(p.value)).every((_) => (k as Array<string>)?.includes(_))
+      return !(vAsArr(p.value)).every((_) => (k as Array<unknown>)?.includes(_))
+    case "hasKey":
+      return mapEntries(k).some(([key]) => compare(key, v))
+    case "notHasKey":
+      return !mapEntries(k).some(([key]) => compare(key, v))
+    case "hasValue":
+      return mapEntries(k).some(([, val]) => compare(val, v))
+    case "notHasValue":
+      return !mapEntries(k).some(([, val]) => compare(val, v))
+    case "hasKeyValue":
+      return mapEntries(k).some((entry) => pairEq(entry, v))
+    case "notHasKeyValue":
+      return !mapEntries(k).some((entry) => pairEq(entry, v))
+    case "hasKey-any":
+      return vAsArr(p.value).some((key) => mapEntries(k).some(([k0]) => compare(k0, key)))
+    case "notHasKey-any":
+      return !vAsArr(p.value).some((key) => mapEntries(k).some(([k0]) => compare(k0, key)))
+    case "hasKey-all":
+      return vAsArr(p.value).every((key) => mapEntries(k).some(([k0]) => compare(k0, key)))
+    case "notHasKey-all":
+      return !vAsArr(p.value).every((key) => mapEntries(k).some(([k0]) => compare(k0, key)))
+    case "hasValue-any":
+      return vAsArr(p.value).some((val) => mapEntries(k).some(([, v0]) => compare(v0, val)))
+    case "notHasValue-any":
+      return !vAsArr(p.value).some((val) => mapEntries(k).some(([, v0]) => compare(v0, val)))
+    case "hasValue-all":
+      return vAsArr(p.value).every((val) => mapEntries(k).some(([, v0]) => compare(v0, val)))
+    case "notHasValue-all":
+      return !vAsArr(p.value).every((val) => mapEntries(k).some(([, v0]) => compare(v0, val)))
+    case "hasKeyValue-any":
+      return vAsArr(p.value).some((pair) => mapEntries(k).some((entry) => pairEq(entry, pair)))
+    case "notHasKeyValue-any":
+      return !vAsArr(p.value).some((pair) => mapEntries(k).some((entry) => pairEq(entry, pair)))
+    case "hasKeyValue-all":
+      return vAsArr(p.value).every((pair) => mapEntries(k).some((entry) => pairEq(entry, pair)))
+    case "notHasKeyValue-all":
+      return !vAsArr(p.value).every((pair) => mapEntries(k).some((entry) => pairEq(entry, pair)))
     case "contains":
-      return (k as string).toLowerCase().includes(p.value.toLowerCase())
+      return (k as string).toLowerCase().includes((v as string).toLowerCase())
     case "endsWith":
-      return (k as string).toLowerCase().endsWith(p.value.toLowerCase())
+      return (k as string).toLowerCase().endsWith((v as string).toLowerCase())
     case "startsWith":
-      return (k as string).toLowerCase().startsWith(p.value.toLowerCase())
+      return (k as string).toLowerCase().startsWith((v as string).toLowerCase())
     case "notContains":
-      return !(k as string).toLowerCase().includes(p.value.toLowerCase())
+      return !(k as string).toLowerCase().includes((v as string).toLowerCase())
     case "notEndsWith":
-      return !(k as string).toLowerCase().endsWith(p.value.toLowerCase())
+      return !(k as string).toLowerCase().endsWith((v as string).toLowerCase())
     case "notStartsWith":
-      return !(k as string).toLowerCase().startsWith(p.value.toLowerCase())
+      return !(k as string).toLowerCase().startsWith((v as string).toLowerCase())
     case "neq":
-      return !compare(k, p.value)
+      return !compare(k, v)
     case "eq":
     case undefined:
-      return compare(k, p.value)
+      return compare(k, v)
     default: {
       return assertUnreachable(p.op)
     }

package/src/Store/jsonDocument.ts

@@ -0,0 +1,43 @@
+import type { FieldValues } from "effect-app/Model/filter/types"
+import * as S from "effect-app/Schema"
+import type { PersistenceModelType } from "effect-app/Store"
+import { toJsonQueryValue } from "./utils.ts"
+
+export interface JsonDocumentCodec<E extends FieldValues> {
+  readonly encode: (doc: PersistenceModelType<E>) => PersistenceModelType<E>
+  readonly decode: (doc: PersistenceModelType<E>) => PersistenceModelType<E>
+}
+
+const splitEtag = <E extends FieldValues>(doc: PersistenceModelType<E>) => {
+  const { _etag, ...rest } = doc
+  return { rest: rest as E, _etag }
+}
+
+const joinEtag = <E extends FieldValues>(
+  rest: E,
+  _etag: string | undefined
+): PersistenceModelType<E> => (_etag === undefined ? rest : { ...rest, _etag })
+
+/**
+ * Encoded document ↔ JSON document. Prefer `Schema.toCodecJson(toEncoded(schema))`
+ * when the store has a schema; otherwise lower Date/Map/Set structurally.
+ */
+export const makeJsonDocumentCodec = <E extends FieldValues>(schema?: S.Top): JsonDocumentCodec<E> => {
+  if (schema) {
+    const codec = S.toCodecJson(S.toEncoded(schema)) as S.Codec<E, S.Json>
+    return {
+      encode: (doc) => {
+        const { rest, _etag } = splitEtag(doc)
+        return joinEtag(S.encodeSync(codec)(rest) as E, _etag)
+      },
+      decode: (doc) => {
+        const { rest, _etag } = splitEtag(doc)
+        return joinEtag(S.decodeSync(codec)(rest as S.Json), _etag)
+      }
+    }
+  }
+  return {
+    encode: (doc) => toJsonQueryValue(doc) as PersistenceModelType<E>,
+    decode: (doc) => doc
+  }
+}

package/src/Store/utils.ts

@@ -1,9 +1,279 @@
 import crypto from "crypto"
 import * as Effect from "effect-app/Effect"
+import type { FilterResult, Ops } from "effect-app/Model/filter/filterApi"
 import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
+import * as SchemaAST from "effect-app/SchemaAST"
 import type { PersistenceModelType, SupportedValues2 } from "effect-app/Store"
 import { OptimisticConcurrencyException } from "../errors.ts"
 
+const dateJson = S.toCodecJson(S.Date)
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false
+  if (value instanceof Date || value instanceof Map || value instanceof Set) return false
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+const unwrapAst = (ast: SchemaAST.AST): SchemaAST.AST => SchemaAST.isSuspend(ast) ? unwrapAst(ast.thunk()) : ast
+
+const unionAst = (hits: readonly SchemaAST.AST[]): SchemaAST.AST | undefined => {
+  if (hits.length === 0) return undefined
+  if (hits.length === 1) return hits[0]
+  return S.Union(hits.map((hit) => S.make(hit)) as [S.Top, S.Top, ...Array<S.Top>]).ast
+}
+
+const encodedObjects = (ast: SchemaAST.AST): SchemaAST.Objects | undefined => {
+  const current = unwrapAst(ast)
+  if (SchemaAST.isObjects(current)) return current
+  if (SchemaAST.isDeclaration(current)) {
+    const encoded = unwrapAst(SchemaAST.toEncoded(current))
+    if (SchemaAST.isObjects(encoded)) return encoded
+  }
+  return undefined
+}
+
+const astAtPath = (ast: SchemaAST.AST | undefined, path: readonly string[]): SchemaAST.AST | undefined => {
+  if (ast === undefined) return undefined
+  if (path.length === 0) return unwrapAst(ast)
+  const current = unwrapAst(ast)
+  const [head, ...tail] = path
+  if (head === undefined) return current
+  if (SchemaAST.isUnion(current)) {
+    return unionAst(
+      current.types.flatMap((member) => {
+        const hit = astAtPath(member, path)
+        return hit === undefined ? [] : [hit]
+      })
+    )
+  }
+  if (head === "-1" || /^\d+$/.test(head)) {
+    if (SchemaAST.isArrays(current)) {
+      const element = current.rest[0] ?? current.elements[Number(head)] ?? current.elements[0]
+      return astAtPath(element, tail)
+    }
+    if (SchemaAST.isDeclaration(current) && current.typeParameters.length === 1) {
+      return astAtPath(current.typeParameters[0], tail)
+    }
+    return undefined
+  }
+  const objects = encodedObjects(current)
+  if (objects !== undefined) {
+    const property = objects.propertySignatures.find((p) => p.name === head)
+    return property === undefined ? undefined : astAtPath(property.type, tail)
+  }
+  return undefined
+}
+
+const elementAst = (ast: SchemaAST.AST | undefined): SchemaAST.AST | undefined => {
+  if (ast === undefined) return undefined
+  const current = unwrapAst(ast)
+  if (SchemaAST.isUnion(current)) {
+    return unionAst(
+      current.types.flatMap((member) => {
+        const hit = elementAst(member)
+        return hit === undefined ? [] : [hit]
+      })
+    )
+  }
+  if (SchemaAST.isArrays(current)) return unwrapAst(current.rest[0] ?? current.elements[0] ?? current)
+  if (SchemaAST.isDeclaration(current) && current.typeParameters.length === 1) {
+    return unwrapAst(current.typeParameters[0]!)
+  }
+  return current
+}
+
+const mapKeyAst = (ast: SchemaAST.AST | undefined): SchemaAST.AST | undefined => {
+  if (ast === undefined) return undefined
+  const current = unwrapAst(ast)
+  if (SchemaAST.isUnion(current)) {
+    return unionAst(
+      current.types.flatMap((member) => {
+        const hit = mapKeyAst(member)
+        return hit === undefined ? [] : [hit]
+      })
+    )
+  }
+  if (SchemaAST.isDeclaration(current) && current.typeParameters.length >= 2) {
+    return unwrapAst(current.typeParameters[0]!)
+  }
+  return current
+}
+
+const mapValueAst = (ast: SchemaAST.AST | undefined): SchemaAST.AST | undefined => {
+  if (ast === undefined) return undefined
+  const current = unwrapAst(ast)
+  if (SchemaAST.isUnion(current)) {
+    return unionAst(
+      current.types.flatMap((member) => {
+        const hit = mapValueAst(member)
+        return hit === undefined ? [] : [hit]
+      })
+    )
+  }
+  if (SchemaAST.isDeclaration(current) && current.typeParameters.length >= 2) {
+    return unwrapAst(current.typeParameters[1]!)
+  }
+  return current
+}
+
+const asArray = (value: unknown): readonly unknown[] =>
+  Array.isArray(value) ? value : value instanceof Set ? [...value] : [value]
+
+const encodeJson = (ast: SchemaAST.AST | undefined, value: unknown): unknown => {
+  if (ast === undefined) return toJsonQueryValue(value)
+  const current = unwrapAst(ast)
+  if (isPlainObject(value)) {
+    const out: Record<string, unknown> = {}
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = encodeJson(astAtPath(current, [key]), child)
+    }
+    return out
+  }
+  if (Array.isArray(value)) {
+    const element = SchemaAST.isArrays(current) || SchemaAST.isUnion(current)
+      ? elementAst(current)
+      : current
+    return value.map((item) => encodeJson(element, item))
+  }
+  if (value instanceof Set) {
+    return [...value].map((item) => encodeJson(elementAst(current), item))
+  }
+  if (value instanceof Map) {
+    return [...value.entries()].map(([k, v]) => [
+      encodeJson(mapKeyAst(current), k),
+      encodeJson(mapValueAst(current), v)
+    ])
+  }
+  return Effect.runSync(
+    S.encodeUnknownEffect(S.toCodecJson(S.make(current)))(value) as Effect.Effect<S.Json>
+  )
+}
+
+const encodeFilterValue = (fieldAst: SchemaAST.AST | undefined, op: Ops, value: unknown): unknown => {
+  if (fieldAst === undefined) return toJsonQueryValue(value)
+  if (op === "in" || op === "notIn") {
+    return asArray(value).map((item) => encodeJson(fieldAst, item))
+  }
+  if (
+    op === "includes"
+    || op === "notIncludes"
+    || op === "includes-any"
+    || op === "notIncludes-any"
+    || op === "includes-all"
+    || op === "notIncludes-all"
+  ) {
+    const element = elementAst(fieldAst)
+    return op === "includes" || op === "notIncludes"
+      ? encodeJson(element, value)
+      : asArray(value).map((item) => encodeJson(element, item))
+  }
+  if (
+    op === "hasKeyValue"
+    || op === "notHasKeyValue"
+    || op === "hasKeyValue-any"
+    || op === "notHasKeyValue-any"
+    || op === "hasKeyValue-all"
+    || op === "notHasKeyValue-all"
+  ) {
+    const keyAst = mapKeyAst(fieldAst)
+    const valueAst = mapValueAst(fieldAst)
+    const pair = (item: unknown) =>
+      Array.isArray(item) && item.length >= 2
+        ? [encodeJson(keyAst, item[0]), encodeJson(valueAst, item[1])]
+        : toJsonQueryValue(item)
+    return op === "hasKeyValue" || op === "notHasKeyValue" ? pair(value) : asArray(value).map(pair)
+  }
+  if (
+    op === "hasKey"
+    || op === "notHasKey"
+    || op === "hasKey-any"
+    || op === "notHasKey-any"
+    || op === "hasKey-all"
+    || op === "notHasKey-all"
+  ) {
+    const keyAst = mapKeyAst(fieldAst)
+    return op === "hasKey" || op === "notHasKey"
+      ? encodeJson(keyAst, value)
+      : asArray(value).map((item) => encodeJson(keyAst, item))
+  }
+  if (
+    op === "hasValue"
+    || op === "notHasValue"
+    || op === "hasValue-any"
+    || op === "notHasValue-any"
+    || op === "hasValue-all"
+    || op === "notHasValue-all"
+  ) {
+    const valueAst = mapValueAst(fieldAst)
+    return op === "hasValue" || op === "notHasValue"
+      ? encodeJson(valueAst, value)
+      : asArray(value).map((item) => encodeJson(valueAst, item))
+  }
+  return encodeJson(fieldAst, value)
+}
+
+/**
+ * Lower Date / Map / Set to JSON when no field schema is available.
+ * Prefer {@link encodeWithSchema} / {@link jsonifyFilter} with the store schema.
+ */
+export function toJsonQueryValue(value: unknown): unknown {
+  if (value instanceof Date) {
+    return S.encodeSync(dateJson)(value)
+  }
+  if (value instanceof Map) {
+    return [...value.entries()].map(([k, v]) => [toJsonQueryValue(k), toJsonQueryValue(v)])
+  }
+  if (value instanceof Set) {
+    return [...value].map((v) => toJsonQueryValue(v))
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => toJsonQueryValue(v))
+  }
+  if (isPlainObject(value)) {
+    const out: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = toJsonQueryValue(v)
+    }
+    return out
+  }
+  if (value !== null && typeof value === "object") {
+    const toJSON = (value as { toJSON?: () => unknown }).toJSON
+    if (typeof toJSON === "function") {
+      return toJsonQueryValue(toJSON.call(value))
+    }
+  }
+  return value
+}
+
+export function encodeWithSchema(schema: S.Top | undefined, value: unknown): unknown {
+  if (schema === undefined) return toJsonQueryValue(value)
+  return encodeJson(SchemaAST.toEncoded(schema.ast), value)
+}
+
+export function jsonifyFilter(
+  filter: readonly FilterResult[],
+  schema?: S.Top
+): FilterResult[] {
+  const ast = schema === undefined ? undefined : SchemaAST.toEncoded(schema.ast)
+  return filter.map((r) =>
+    r.t === "and-scope" || r.t === "or-scope" || r.t === "where-scope"
+      ? { ...r, result: jsonifyFilter(r.result, schema) }
+      : { ...r, value: encodeFilterValue(astAtPath(ast, r.path.split(".")), r.op, r.value) }
+  )
+}
+
+export type JsonLower = {
+  readonly toJson: (value: unknown) => unknown
+  readonly jsonifyFilter: (filter: readonly FilterResult[]) => FilterResult[]
+}
+
+export const makeJsonLower = (config?: { readonly schema?: S.Top }): JsonLower => ({
+  toJson: (value) => encodeWithSchema(config?.schema, value),
+  jsonifyFilter: (filter) => jsonifyFilter(filter, config?.schema)
+})
+
 /** Traverse an object by a dot-separated path string, e.g. `"a.b.c"`. */
 export function get(obj: any, path: string): any {
   return path.split(".").reduce((res: any, key: string) => (res != null ? res[key] : res), obj)
@@ -55,21 +325,21 @@ export function lowercaseIfString<T>(val: T) {
 }
 
 export function compare(valA: unknown, valB: unknown) {
-  return valA === valB
+  return toJsonQueryValue(valA) === toJsonQueryValue(valB)
 }
 
 export function lowerThan(valA: SupportedValues2, valB: SupportedValues2) {
-  return valA < valB
+  return (toJsonQueryValue(valA) as SupportedValues2) < (toJsonQueryValue(valB) as SupportedValues2)
 }
 
 export function lowerThanExclusive(valA: SupportedValues2, valB: SupportedValues2) {
-  return valA <= valB
+  return (toJsonQueryValue(valA) as SupportedValues2) <= (toJsonQueryValue(valB) as SupportedValues2)
 }
 
 export function greaterThan(valA: SupportedValues2, valB: SupportedValues2) {
-  return valA > valB
+  return (toJsonQueryValue(valA) as SupportedValues2) > (toJsonQueryValue(valB) as SupportedValues2)
 }
 
 export function greaterThanExclusive(valA: SupportedValues2, valB: SupportedValues2) {
-  return valA >= valB
+  return (toJsonQueryValue(valA) as SupportedValues2) >= (toJsonQueryValue(valB) as SupportedValues2)
 }