@effect-app/infra 4.0.0-beta.32 → 4.0.0-beta.321

package/src/Store/codeFilter.ts

@@ -1,58 +1,107 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { Array, Option } from "effect-app"
-import { assertUnreachable, get } from "effect-app/utils"
-import type { FilterR, FilterResult } from "../Model/filter/filterApi.js"
-import type { FieldValues } from "../Model/filter/types.js"
-import type { Filter } from "./service.js"
-import { compare, greaterThan, greaterThanExclusive, lowerThan, lowerThanExclusive } from "./utils.js"
+import * as Array from "effect-app/Array"
+import type { FilterR, FilterResult } from "effect-app/Model/filter/filterApi"
+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, 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)
     }
@@ -186,6 +235,7 @@ export const codeFilter3_ = <E>(state: readonly FilterResult[], sut: E): boolean
   const statements: any[] = [] // must be defined here to be used by eval.
   // always put everything inside a root scope.
   const s = codeFilter3__([{ t: "where-scope", result: state, relation: "some" }], sut, statements, null, false)
+  // oxlint-disable-next-line no-eval
   return eval(s)
 }
 

package/src/Store/index.ts

@@ -1,12 +1,21 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, Redacted } from "effect-app"
-import { CosmosStoreLayer } from "./Cosmos.js"
-import { DiskStoreLayer } from "./Disk.js"
-import { MemoryStoreLive } from "./Memory.js"
-// import { RedisStoreLayer } from "./Redis.js"
-import type { StorageConfig } from "./service.js"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { RepositoryRegistryLive } from "effect-app/Model"
+import type { StorageConfig } from "effect-app/Store"
+import * as Redacted from "effect/Redacted"
+import type { SqlClient } from "effect/unstable/sql"
+import { CosmosStoreLayer } from "./Cosmos.ts"
+import { DiskStoreLayer } from "./Disk.ts"
+import { MemoryStoreLive } from "./Memory.ts"
+// import { RedisStoreLayer } from "./Redis.ts"
+import { SQLiteStoreLayer } from "./SQL.ts"
+import { PgStoreLayer } from "./SQL/Pg.ts"
 
-export function StoreMakerLayer(cfg: StorageConfig) {
+export function StoreMakerLayer(
+  cfg: StorageConfig,
+  options?: { makeSqlClientLayer?: (namespace: string) => Layer.Layer<SqlClient.SqlClient> }
+) {
   return Effect
     .sync(() => {
       const storageUrl = Redacted.value(cfg.url)
@@ -19,6 +28,14 @@ export function StoreMakerLayer(cfg: StorageConfig) {
         console.log("Using disk store at " + dir)
         return DiskStoreLayer(cfg, dir)
       }
+      if (storageUrl.startsWith("sqlite://")) {
+        console.log("Using SQLite store")
+        return SQLiteStoreLayer(cfg, options)
+      }
+      if (storageUrl.startsWith("pg://")) {
+        console.log("Using PostgreSQL store")
+        return PgStoreLayer(cfg)
+      }
       // if (storageUrl.startsWith("redis://")) {
       //   console.log("Using Redis store")
       //   return RedisStoreLayer(cfg)
@@ -27,7 +44,5 @@ export function StoreMakerLayer(cfg: StorageConfig) {
       console.log("Using Cosmos DB store")
       return CosmosStoreLayer(cfg)
     })
-    .pipe(Layer.unwrap)
+    .pipe(Layer.unwrap, Layer.merge(RepositoryRegistryLive))
 }
-
-export * from "./service.js"

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,7 +1,283 @@
 import crypto from "crypto"
-import { Effect, Option } from "effect-app"
-import { OptimisticConcurrencyException } from "../errors.js"
-import type { PersistenceModelType, SupportedValues2 } from "./service.js"
+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)
+}
 
 export const makeETag = <E extends PersistenceModelType<{}>>(
   { _etag, ...e }: E
@@ -12,33 +288,34 @@ export const makeETag = <E extends PersistenceModelType<{}>>(
     _etag: crypto.createHash("sha256").update(JSON.stringify(e)).digest("hex")
   }) as any
 
-export const makeUpdateETag =
-  (type: string) =>
-  <IdKey extends keyof E, E extends PersistenceModelType<{}>>(e: E, idKey: IdKey, current: Option.Option<E>) =>
-    Effect.gen(function*() {
-      if (e._etag) {
-        if (Option.isNone(current)) {
-          return yield* new OptimisticConcurrencyException({
-            type,
-            id: e[idKey] as string,
-            current: "",
-            found: e._etag,
-            code: 409
-          })
-        }
-      }
-      if (Option.isSome(current) && current.value._etag !== e._etag) {
+export const makeUpdateETag = (type: string) =>
+  Effect.fnUntraced(function*<IdKey extends keyof E, E extends PersistenceModelType<{}>>(
+    e: E,
+    idKey: IdKey,
+    current: Option.Option<E>
+  ) {
+    if (e._etag) {
+      if (Option.isNone(current)) {
         return yield* new OptimisticConcurrencyException({
           type,
-          id: current.value[idKey] as string,
-          current: current.value._etag,
+          id: e[idKey] as string,
+          current: "",
           found: e._etag,
-          code: 412
+          code: 409
         })
       }
-      const newE = makeETag(e)
-      return newE
-    })
+    }
+    if (Option.isSome(current) && current.value._etag !== e._etag) {
+      return yield* new OptimisticConcurrencyException({
+        type,
+        id: current.value[idKey] as string,
+        current: current.value._etag,
+        found: e._etag,
+        code: 412
+      })
+    }
+    return makeETag(e)
+  })
 
 export function lowercaseIfString<T>(val: T) {
   if (typeof val === "string") {
@@ -48,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)
 }