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

package/src/Store/Cosmos.ts

@@ -19,6 +19,8 @@ import { DatabaseError, OptimisticConcurrencyException } from "../errors.ts"
 import { InfraLogger } from "../logger.ts"
 import { annotateCosmosResponse, annotateDb } from "../otel.ts"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.ts"
+import { makeJsonDocumentCodec } from "./jsonDocument.ts"
+import { makeJsonLower } from "./utils.ts"
 
 const makeMapId =
   <IdKey extends keyof Encoded, Encoded extends FieldValues>(idKey: IdKey) => ({ [idKey]: id, ...e }: Encoded) => ({
@@ -96,6 +98,10 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
     ) {
       const mapId = makeMapId<IdKey, Encoded>(idKey)
       const mapReverseId = makeReverseMapId<IdKey, Encoded>(idKey)
+      const codec = makeJsonDocumentCodec<Encoded>(config?.schema)
+      const json = makeJsonLower(config)
+      const defaultValues = json.toJson(config?.defaultValues ?? {}) as Partial<Encoded>
+      const fromStored = (raw: Encoded) => codec.decode({ ...defaultValues, ...mapReverseId(raw as any) })
       type PM = PersistenceModelType<Encoded>
       type PMCosmos = PersistenceModelType<Omit<Encoded, IdKey> & { id: string }>
       const containerId = `${prefix}${name}`
@@ -128,7 +134,6 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
           return namespace
         }))
 
-      const defaultValues = config?.defaultValues ?? {}
       const container = db.container(containerId)
       const bulk = container.items.bulk.bind(container.items)
       const execBatch = container.items.batch.bind(container.items)
@@ -205,7 +210,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                         dropUndefinedT({
                           operationType: "Create" as const,
                           resourceBody: {
-                            ...Struct.omit(x, ["_etag", idKey]),
+                            ...Struct.omit(codec.encode(x), ["_etag", idKey]),
                             id: x[idKey],
                             _partitionKey: nsPartitionValue(ns, x)
                           }
@@ -217,7 +222,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                           operationType: "Replace" as const,
                           id: x[idKey],
                           resourceBody: {
-                            ...Struct.omit(x, ["_etag", idKey]),
+                            ...Struct.omit(codec.encode(x), ["_etag", idKey]),
                             id: x[idKey],
                             _partitionKey: nsPartitionValue(ns, x)
                           },
@@ -314,7 +319,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                         onNone: () => ({
                           operationType: "Create" as const,
                           resourceBody: {
-                            ...Struct.omit(x, ["_etag", idKey]),
+                            ...Struct.omit(codec.encode(x), ["_etag", idKey]),
                             id: x[idKey],
                             _partitionKey: nsPartitionValue(ns, x)
                           }
@@ -325,7 +330,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                           operationType: "Replace" as const,
                           id: x[idKey],
                           resourceBody: {
-                            ...Struct.omit(x, ["_etag", idKey]),
+                            ...Struct.omit(codec.encode(x), ["_etag", idKey]),
                             id: x[idKey],
                             _partitionKey: nsPartitionValue(ns, x)
                           },
@@ -447,7 +452,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                     container.items.query<PMCosmos>(q, { partitionKey: nsBasePartitionKey(ns) }).fetchAll()
                   )
                   yield* annotateFeed(response)
-                  return response.resources.map((_) => ({ ...defaultValues, ...mapReverseId(_) }))
+                  return response.resources.map((_) => fromStored(_ as unknown as Encoded))
                 })
                 .pipe(
                   annotateDb({
@@ -492,7 +497,8 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                     | undefined,
                   f.order as NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }> | undefined,
                   skip,
-                  limit
+                  limit,
+                  json
                 )
               ),
               ns: resolveNamespace
@@ -520,7 +526,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                         container.items.query<{ f: M }>(q, { partitionKey: nsBasePartitionKey(ns) }).fetchAll()
                       )
                       yield* annotateFeed(response)
-                      return response.resources.map(({ f }) => ({ ...defaultValues, ...mapReverseId(f as any) }) as any)
+                      return response.resources.map(({ f }) => fromStored(f as Encoded) as any)
                     })
                     .pipe(
                       annotateDb({
@@ -546,7 +552,7 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                 )
                 yield* annotateItem(response)
                 return Option.fromNullishOr(response.resource).pipe(
-                  Option.map((_) => ({ ...defaultValues, ...mapReverseId(_) }))
+                  Option.map((_) => fromStored(_))
                 )
               })
               .pipe(annotateDb({
@@ -573,12 +579,12 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                   {
                     onNone: () =>
                       container.items.create({
-                        ...mapId(e),
+                        ...mapId(codec.encode(e)),
                         _partitionKey: nsPartitionValue(ns, e)
                       }),
                     onSome: (eTag) =>
                       container.item(e[idKey], nsPartitionValue(ns, e)).replace(
-                        { ...mapId(e), _partitionKey: nsPartitionValue(ns, e) },
+                        { ...mapId(codec.encode(e)), _partitionKey: nsPartitionValue(ns, e) },
                         {
                           accessCondition: {
                             type: "IfMatch",

package/src/Store/Disk.ts

@@ -10,7 +10,9 @@ import * as Console from "effect/Console"
 import { flow } from "effect/Function"
 import * as Semaphore from "effect/Semaphore"
 import { annotateDb } from "../otel.ts"
+import { makeJsonDocumentCodec } from "./jsonDocument.ts"
 import { makeMemoryStoreInt } from "./Memory.ts"
+import { type JsonLower, makeJsonLower } from "./utils.ts"
 
 function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValues, R, E>(
   prefix: string,
@@ -19,9 +21,12 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
   dir: string,
   name: string,
   seed?: Effect.Effect<Iterable<Encoded>, E, R>,
-  defaultValues?: Partial<Encoded>
+  defaultValues?: Partial<Encoded>,
+  schema?: StoreConfig<Encoded>["schema"],
+  json?: JsonLower
 ) {
   type PM = PersistenceModelType<Encoded>
+  const codec = makeJsonDocumentCodec<Encoded>(schema)
   return Effect.gen(function*() {
     if (namespace !== "primary") {
       dir = dir + "/" + namespace
@@ -44,7 +49,7 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
             extra: fileExtra
           }),
           Effect.flatMap((x) =>
-            Effect.sync(() => JSON.parse(x) as PM[]).pipe(
+            Effect.sync(() => (JSON.parse(x) as PM[]).map((row) => codec.decode(row))).pipe(
               annotateDb({
                 operation: "read.parse",
                 system: "disk",
@@ -67,7 +72,7 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
         ),
       setRaw: (v: Iterable<PM>) =>
         Effect
-          .sync(() => JSON.stringify([...v], undefined, 2))
+          .sync(() => JSON.stringify([...v].map((row) => codec.encode(row)), undefined, 2))
           .pipe(
             annotateDb({
               operation: "stringify",
@@ -117,7 +122,9 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
           shouldSeed
             ? seed
             : fsStore.get,
-          defaultValues
+          defaultValues,
+          schema,
+          json
         )
         if (shouldSeed) {
           yield* store.all.pipe(Effect.flatMap(fsStore.setRaw))
@@ -175,9 +182,21 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
         seed?: Effect.Effect<Iterable<Encoded>, E, R>,
         config?: StoreConfig<Encoded>
       ) {
-        const primary = yield* makeDiskStoreInt(prefix, idKey, "primary", dir, name, seed, config?.defaultValues).pipe(
-          Effect.orDie
+        const json = makeJsonLower(config)
+        const primary = yield* makeDiskStoreInt(
+          prefix,
+          idKey,
+          "primary",
+          dir,
+          name,
+          seed,
+          config?.defaultValues,
+          config?.schema,
+          json
         )
+          .pipe(
+            Effect.orDie
+          )
         const stores = new Map<string, Store<IdKey, Encoded>>([["primary", primary]])
         const ctx = yield* Effect.context<R>()
         const semaphores = new Map<string, Semaphore.Semaphore>()
@@ -204,7 +223,9 @@ export function makeDiskStore({ prefix }: StorageConfig, dir: string) {
                 dir,
                 name,
                 seed,
-                config?.defaultValues
+                config?.defaultValues,
+                config?.schema,
+                json
               )
                 .pipe(
                   Effect.orDie,

package/src/Store/Memory.ts

@@ -18,7 +18,8 @@ import * as Struct from "effect/Struct"
 import { InfraLogger } from "../logger.ts"
 import { annotateDb } from "../otel.ts"
 import { codeFilter, codeFilter3_ } from "./codeFilter.ts"
-import { get, makeUpdateETag } from "./utils.ts"
+import { makeJsonDocumentCodec } from "./jsonDocument.ts"
+import { get, jsonifyFilter, type JsonLower, makeJsonLower, makeUpdateETag, toJsonQueryValue } from "./utils.ts"
 
 export { get } from "./utils.ts"
 
@@ -332,25 +333,38 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
   idKey: IdKey,
   namespace: string,
   seed?: Effect.Effect<Iterable<Encoded>, E, R>,
-  _defaultValues?: Partial<Encoded>
+  _defaultValues?: Partial<Encoded>,
+  schema?: StoreConfig<Encoded>["schema"],
+  json?: JsonLower
 ) {
   type PM = PersistenceModelType<Encoded>
   return Effect.gen(function*() {
     const updateETag = makeUpdateETag(modelName)
+    const codec = makeJsonDocumentCodec<Encoded>(schema)
+    const encodeDoc = (e: Encoded | PM): PM => codec.encode({ _etag: undefined, ...e })
+    const decodeDoc = (e: PM): PM => codec.decode(e)
     const items_ = yield* seed ?? Effect.sync(() => [])
-    const defaultValues = _defaultValues ?? {}
+    const toJson = json?.toJson ?? toJsonQueryValue
+    const lowerFilter = json?.jsonifyFilter ?? jsonifyFilter
+    const encodedDefaults = toJson(_defaultValues ?? {}) as Partial<Encoded>
 
-    const items = new Map([...items_].map((_) => [_[idKey], { _etag: undefined, ...defaultValues, ..._ }] as const))
+    const items = new Map(
+      [...items_].map((_) => {
+        const encoded = encodeDoc({ ...encodedDefaults, ..._ })
+        return [encoded[idKey], encoded] as const
+      })
+    )
     const store = Ref.makeUnsafe<ReadonlyMap<Encoded[IdKey], PM>>(items)
     const sem = Semaphore.makeUnsafe(1)
     const withPermit = sem.withPermits(1)
     const values = Effect.map(Ref.get(store), (s) => s.values())
 
-    const all = Effect.map(values, Array.fromIterable)
+    const allStored = Effect.map(values, Array.fromIterable)
+    const all = Effect.map(allStored, (rows) => rows.map(decodeDoc))
 
     const batchSet = (items: NonEmptyReadonlyArray<PM>) =>
       Effect
-        .forEach(items, (i) => Effect.flatMap(s.find(i[idKey]), (current) => updateETag(i, idKey, current)))
+        .forEach(items, (i) => Effect.flatMap(s.find(i[idKey]), (current) => updateETag(encodeDoc(i), idKey, current)))
         .pipe(
           Effect
             .tap((items) =>
@@ -368,7 +382,7 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
                 )
             ),
           Effect
-            .map((_) => _),
+            .map((items) => items.map(decodeDoc) as unknown as NonEmptyReadonlyArray<PM>),
           withPermit
         )
 
@@ -414,7 +428,7 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
         Ref
           .get(store)
           .pipe(
-            Effect.map((_) => Option.fromNullishOr(_.get(id))),
+            Effect.map((_) => Option.fromNullishOr(_.get(id)).pipe(Option.map(decodeDoc))),
             annotateDb({
               operation: "find",
               system: "memory",
@@ -424,11 +438,16 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
               extra: { "app.entity.id": id }
             })
           ),
-      filter: (f) =>
-        all
+      filter: <U extends keyof Encoded = never>(f: FilterArgs<Encoded, U>) =>
+        allStored
           .pipe(
-            Effect.tap(() => logQuery(f, defaultValues)),
-            Effect.map(memFilter(f)),
+            Effect.tap(() => logQuery(f, encodedDefaults)),
+            Effect.map(memFilter({ ...f, filter: f.filter ? lowerFilter(f.filter) : f.filter })),
+            Effect.map((rows): (U extends undefined ? Encoded : Pick<Encoded, U>)[] =>
+              f.select
+                ? rows as (U extends undefined ? Encoded : Pick<Encoded, U>)[]
+                : rows.map(decodeDoc) as (U extends undefined ? Encoded : Pick<Encoded, U>)[]
+            ),
             annotateDb({
               operation: "filter",
               system: "memory",
@@ -441,14 +460,15 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
         s
           .find(e[idKey])
           .pipe(
-            Effect.flatMap((current) => updateETag(e, idKey, current)),
+            Effect.flatMap((current) => updateETag(encodeDoc(e), idKey, current.pipe(Option.map(encodeDoc)))),
             Effect
-              .tap((e) =>
+              .tap((stored) =>
                 Ref.get(store).pipe(
-                  Effect.map((_) => new Map([..._, [e[idKey], e]])),
+                  Effect.map((_) => new Map([..._, [stored[idKey], stored]])),
                   Effect.flatMap((_) => Ref.set(store, _))
                 )
               ),
+            Effect.map(decodeDoc),
             withPermit,
             annotateDb({
               operation: "set",
@@ -518,12 +538,15 @@ export const makeMemoryStore = () => ({
     seed?: Effect.Effect<Iterable<Encoded>, E, R>,
     config?: StoreConfig<Encoded>
   ) {
+    const json = makeJsonLower(config)
     const primary = yield* makeMemoryStoreInt<IdKey, Encoded, R, E>(
       modelName,
       idKey,
       "primary",
       seed,
-      config?.defaultValues
+      config?.defaultValues,
+      config?.schema,
+      json
     )
     const ctx = yield* Effect.context<R>()
     const stores = new Map([["primary", primary]])
@@ -543,7 +566,7 @@ export const makeMemoryStore = () => ({
         if (config?.allowNamespace && !config.allowNamespace(namespace)) {
           throw new Error(`Namespace ${namespace} not allowed!`)
         }
-        return makeMemoryStoreInt(modelName, idKey, namespace, seed, config?.defaultValues)
+        return makeMemoryStoreInt(modelName, idKey, namespace, seed, config?.defaultValues, config?.schema, json)
           .pipe(
             Effect.orDie,
             Effect.provide(ctx),

package/src/Store/SQL/Pg.ts

@@ -12,7 +12,8 @@ import { SqlClient } from "effect/unstable/sql"
 import { DatabaseError, OptimisticConcurrencyException } from "../../errors.ts"
 import { InfraLogger } from "../../logger.ts"
 import { annotateDb } from "../../otel.ts"
-import { makeETag } from "../utils.ts"
+import { makeJsonDocumentCodec } from "../jsonDocument.ts"
+import { makeETag, makeJsonLower, toJsonQueryValue } from "../utils.ts"
 import { buildWhereSQLQuery, logQuery, pgDialect } from "./query.ts"
 
 const sqlErrorMessage = (e: unknown) => (e as any)?.message ? String((e as any).message) : String(e)
@@ -36,10 +37,14 @@ const preserveStoreError = (e: unknown): DatabaseError | OptimisticConcurrencyEx
 const parseRow = <Encoded extends FieldValues>(
   row: { id: string; _etag: string | null; data: unknown },
   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 = (
@@ -70,7 +75,9 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
     ) {
       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")
@@ -96,11 +103,11 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
         )
 
       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[]) =>
@@ -193,7 +200,9 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
             const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = $1`
             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: "postgresql",
@@ -215,7 +224,7 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                   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({
@@ -256,7 +265,9 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                     | undefined,
                   f.order,
                   f.skip,
-                  f.limit
+                  f.limit,
+                  ns,
+                  json
                 )
                 const nsPlaceholder = pgDialect.placeholder(q.params.length + 1)
                 const hasWhere = q.sql.includes("WHERE")
@@ -286,7 +297,9 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                           } 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/SQL/query.ts

@@ -6,6 +6,7 @@ import type { AggregateIrExpression, ComputedProjectionIrExpression, ComputedPro
 import { assertUnreachable } from "effect-app/utils"
 import { InfraLogger } from "../../logger.ts"
 import { isRelationCheck } from "../codeFilter.ts"
+import { jsonifyFilter, type JsonLower, toJsonQueryValue } from "../utils.ts"
 
 export interface SQLDialect {
   readonly jsonExtract: (path: string) => string
@@ -17,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"
@@ -45,6 +49,11 @@ 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",
@@ -112,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",
@@ -149,6 +179,14 @@ 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(
@@ -175,8 +213,12 @@ export function buildWhereSQLQuery(
   order?: NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }>,
   skip?: number,
   limit?: number,
-  namespace?: string
+  namespace?: string,
+  json?: JsonLower
 ) {
+  const toJson = json?.toJson ?? toJsonQueryValue
+  filter = (json?.jsonifyFilter ?? jsonifyFilter)(filter)
+  defaultValues = toJson(defaultValues) as Record<string, unknown>
   const params: unknown[] = []
   let paramIndex = 1
 
@@ -214,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[] = []
@@ -226,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[] = []
@@ -251,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)