@ultimat3/entity 2.0.0 → 4.0.0

package/src/pg-sql.ts

@@ -4,7 +4,7 @@
 // declared. That is the whole reason this file exists instead of a template literal per method.
 
 import { identifier, join, raw, type SqlFragment, sql } from '@ultimat3/db';
-import { snake } from './column';
+import { columnFor, columnName } from './column';
 import type { EntityCore } from './entity';
 import { SOFT_DELETE_COLUMN } from './entity';
 import { allColumns, columnsOf, physicalName } from './pg-row';
@@ -33,10 +33,23 @@ const predicateSql = <Row>(entity: EntityCore<Row>, predicate: Predicate): SqlFr
       // `is distinct from` so a null on either side compares as a value, not as unknown.
       return sql`${column} is distinct from ${value}`;
     case 'in': {
-      const values = Array.isArray(value) ? value : [value];
-      return values.length === 0
-        ? NEVER
-        : sql`${column} in (${join(values.map((each) => sql`${each}`))})`;
+      // `in` reads a LIST or nothing. A scalar used to be wrapped into a one-element list, which
+      // matched a row here that `memoryRepo`'s `matches` refuses outright — 0 rows in memory, 1 in
+      // Postgres, from a call `andWhere(column, op, value: unknown)` compiles. One answer, and it
+      // is the one `@ultimat3/query`'s `filterClause` already gives: no rows.
+      if (!Array.isArray(value)) return NEVER;
+      // A NULL bound as a parameter is `col = null`, which is UNKNOWN and therefore excludes the
+      // very row the caller listed — while memory's `sameValue(null, null)` includes it. Postgres
+      // has no `in` that compares a null as a value, so the list is partitioned and the nulls are
+      // asked for as `is null`: the `(… in (…) or … is null)` pair `eq` and `neq` already emit.
+      const present = value.filter((each) => each !== null && each !== undefined);
+      const list =
+        present.length === 0
+          ? undefined
+          : sql`${column} in (${join(present.map((e) => sql`${e}`))})`;
+      const nulls = present.length === value.length ? undefined : sql`${column} is null`;
+      if (list === undefined) return nulls ?? NEVER;
+      return nulls === undefined ? list : sql`(${list} or ${nulls})`;
     }
     case 'gt':
       return sql`${column} > ${value}`;
@@ -111,7 +124,7 @@ const conditions = <Row>(
 ): SqlFragment => {
   const parts = plan.where.map((predicate) => predicateSql(entity, predicate));
   if (entity.$softDelete && !shape.includeDeleted) {
-    parts.push(sql`${identifier(snake(SOFT_DELETE_COLUMN))} is null`);
+    parts.push(sql`${identifier(physicalName(entity, SOFT_DELETE_COLUMN))} is null`);
   }
   if (shape.seek !== undefined) parts.push(seekSql(entity, plan.orderBy, shape.seek));
   return parts.length === 0 ? sql`true` : join(parts, ' and ');
@@ -137,7 +150,7 @@ const projection = <Row>(entity: EntityCore<Row>, plan: QueryPlan): SqlFragment
     ...plan.orderBy.map((entry) => entry.column.split('.')[0] ?? entry.column),
   ]);
   const names = [...wanted].flatMap((property) => {
-    const column = entity.$columns[property];
+    const column = columnFor(entity.$columns, property);
     return column === undefined ? [] : columnsOf(property, column);
   });
   return join(names.map(identifier));
@@ -224,6 +237,35 @@ const conflictSql = (conflict: ConflictTarget): SqlFragment => {
       )}`;
 };
 
+/**
+ * The one column that cannot be bound as itself. A `jsonb` value is a plain object, and the
+ * driver seam refuses one as a parameter (`X_SQL_UNSAFE` — `isBoundValue` takes scalars, a `Date`,
+ * a `Uint8Array` and arrays of those); so `bindValues` hands over the JSON TEXT and the cell says
+ * what to do with it.
+ *
+ * `::text::jsonb` and not `::jsonb`, and the double cast is load-bearing rather than defensive.
+ * Measured against Postgres 17.10 through Bun's `sql`: with `$1::jsonb` the server describes the
+ * parameter as `jsonb`, the client JSON-ENCODES the string it was given, and `{"a":1}` is stored
+ * as the JSON *string* `"{\"a\":1}"` — `jsonb_typeof` says `string`. Pinning the parameter to
+ * `text` first makes the client send the characters and the server parse them, which is the one
+ * spelling that stores an object.
+ */
+/** Physical names of this entity's `jsonb` columns. Resolved ONCE per statement, never per cell. */
+const jsonColumns = <Row>(entity: EntityCore<Row>): ReadonlySet<string> => {
+  const names = new Set<string>();
+  for (const [property, column] of Object.entries(entity.$columns)) {
+    if (column.$meta.kind === 'jsonb') names.add(columnName(property, column.$meta));
+  }
+  return names;
+};
+
+/**
+ * `${value}`, plus the cast that column needs. The `raw()` argument is a literal written here and
+ * nowhere else — the audit point that call is stays a two-word constant, never a value.
+ */
+const cell = (json: ReadonlySet<string>, column: string, value: unknown): SqlFragment =>
+  json.has(column) ? sql`${value}${raw('::text::jsonb')}` : sql`${value}`;
+
 /**
  * One statement for any number of rows. A single row compiles to exactly the text it always did,
  * which is the point: `insertAll([row])` and `insert(row)` are one code path, so there is no
@@ -234,10 +276,13 @@ export const insertStatement = <Row>(
   rows: readonly ReadonlyMap<string, unknown>[],
   shape: InsertShape,
 ): SqlFragment => {
+  const json = jsonColumns(entity);
   const tuples = rows.map(
     (row) =>
       sql`(${join(
-        shape.columns.map((column) => (row.has(column) ? sql`${row.get(column)}` : DEFAULT_CELL)),
+        shape.columns.map((column) =>
+          row.has(column) ? cell(json, column, row.get(column)) : DEFAULT_CELL,
+        ),
       )})`,
   );
   const conflict = shape.conflict === undefined ? sql`` : conflictSql(shape.conflict);
@@ -259,10 +304,12 @@ export const updateStatement = <Row>(
   values: ReadonlyMap<string, unknown>,
   shape: ReadShape,
   returning: boolean,
-): SqlFragment =>
-  sql`update ${identifier(entity.$table)} set ${join(
-    [...values].map(([column, value]) => sql`${identifier(column)} = ${value}`),
+): SqlFragment => {
+  const json = jsonColumns(entity);
+  return sql`update ${identifier(entity.$table)} set ${join(
+    [...values].map(([column, value]) => sql`${identifier(column)} = ${cell(json, column, value)}`),
   )} where ${conditions(entity, plan, shape)}${returning ? sql` returning *` : sql``}`;
+};
 
 /** Only reached when the entity has no soft-delete column, so there is no filter to apply. */
 export const deleteStatement = <Row>(entity: EntityCore<Row>, plan: QueryPlan): SqlFragment =>

package/src/plan.ts

@@ -8,6 +8,7 @@ import { EntityError, invariantViolated, patchEmpty, writeUnfiltered } from './e
 import type { FindManyArgs, RepoOptions } from './repo';
 import type { Predicate, QueryPlan, SortKey } from './tenancy';
 import { scopedPlan } from './tenancy';
+import type { RowPatch } from './types';
 
 /** A page is bounded by default; an unbounded read is a production incident waiting for traffic. */
 export const DEFAULT_PAGE_SIZE = 50;
@@ -146,7 +147,7 @@ export const namedColumns = (values: unknown): readonly (readonly [string, unkno
 /** The filter a filtered write is allowed to run with: never the empty one. */
 const boundedWhere = <Row>(
   entity: EntityCore<Row>,
-  filter: Partial<Row>,
+  filter: RowPatch<Row>,
   operation: string,
 ): Predicate[] => {
   const where = namedColumns(filter).map(
@@ -166,7 +167,7 @@ const boundedWhere = <Row>(
  */
 export const deletePlan = <Row>(
   entity: EntityCore<Row>,
-  filter: Partial<Row>,
+  filter: RowPatch<Row>,
   options: RepoOptions | undefined,
   operation: string,
 ): QueryPlan =>
@@ -179,8 +180,8 @@ export const deletePlan = <Row>(
  */
 export const updatePlan = <Row>(
   entity: EntityCore<Row>,
-  filter: Partial<Row>,
-  patch: Partial<Row>,
+  filter: RowPatch<Row>,
+  patch: RowPatch<Row>,
   options: RepoOptions | undefined,
   operation: string,
 ): QueryPlan => {

package/src/query.ts

@@ -4,9 +4,9 @@
 // concurrent writes an insert before the offset shifts every later page, so a client silently
 // skips and repeats rows.
 
-import { systemClock } from '@ultimat3/core';
 import type { BatchIterator } from './batch';
 import { assertBatchable, batchIterator } from './batch';
+import { entityNow } from './clock';
 import type { EntityCore } from './entity';
 import { assertPageSize, DEFAULT_PAGE_SIZE, namedColumns } from './plan';
 import type { RelatedTables } from './preload';
@@ -15,7 +15,7 @@ import type { Relation } from './relations';
 import { relationNamed } from './relations';
 import type { Page, Repo, RepoOptions, UpsertArgs } from './repo';
 import type { Operator, Predicate, QueryPlan, SortDirection, SortKey } from './tenancy';
-import type { ColumnMap, IdOf, Insertable } from './types';
+import type { ColumnMap, IdOf, Insertable, RowPatch } from './types';
 
 /**
  * What a preloaded relation adds to a row. `unknown` because the name is a string resolved at
@@ -26,7 +26,7 @@ export type Preloaded<Name extends string> = { readonly [K in Name]: unknown };
 
 export interface ReadBuilder<Row> {
   /** Equality on the columns given. `where({ orgId })` is what satisfies the tenancy guard. */
-  where(filter: Partial<Row>): ReadBuilder<Row>;
+  where(filter: RowPatch<Row>): ReadBuilder<Row>;
   andWhere(column: keyof Row & string, op: Operator, value: unknown): ReadBuilder<Row>;
   orderBy(column: keyof Row & string, direction?: SortDirection): ReadBuilder<Row>;
   limit(rows: number): ReadBuilder<Row>;
@@ -106,21 +106,21 @@ export interface Table<Row, C extends ColumnMap = ColumnMap> extends ReadBuilder
    */
   upsertAll(rows: readonly Insertable<C>[], args: UpsertArgs<Row>): Promise<readonly Row[]>;
   /** `IdOf<Row>`: an entity that declared `uuid<PostId>()` is addressed by a `PostId` only. */
-  update(id: IdOf<Row>, patch: Partial<Row>, options?: RepoOptions): Promise<Row>;
+  update(id: IdOf<Row>, patch: RowPatch<Row>, options?: RepoOptions): Promise<Row>;
   delete(id: IdOf<Row>, options?: RepoOptions): Promise<void>;
   /**
    * Delete by equality filter; resolves with the number of rows removed. The only way to remove a
    * row from an entity whose primary key is composite — `likes`, `blocks`, a join table — where
    * one id cannot name it. `deleteWhere({})` is `X_WRITE_UNFILTERED`, never every row.
    */
-  deleteWhere(filter: Partial<Row>, options?: RepoOptions): Promise<number>;
+  deleteWhere(filter: RowPatch<Row>, options?: RepoOptions): Promise<number>;
   /**
    * Update by equality filter; resolves with the number of rows written. The `update(id, patch)`
    * a composite primary key cannot express — `participants.updateWhere({ conversationId, userId },
    * { lastReadAt })` is the reference case. Empty filter: `X_WRITE_UNFILTERED`. Empty patch:
    * `X_PATCH_EMPTY`. `onUpdateNow()` columns are stamped exactly as `update(id, patch)` stamps them.
    */
-  updateWhere(filter: Partial<Row>, patch: Partial<Row>, options?: RepoOptions): Promise<number>;
+  updateWhere(filter: RowPatch<Row>, patch: RowPatch<Row>, options?: RepoOptions): Promise<number>;
 }
 
 interface State {
@@ -311,7 +311,7 @@ const touch = <Row, Patch>(entity: EntityCore<Row>, patch: Patch): Patch => {
   if (namedColumns(patch).length === 0) return patch;
   const stamped: Record<string, unknown> = {};
   for (const [property, column] of Object.entries(entity.$columns)) {
-    if (column.$meta.onUpdate !== undefined) stamped[property] = systemClock.now();
+    if (column.$meta.onUpdate !== undefined) stamped[property] = entityNow();
   }
   return Object.assign({}, patch, stamped);
 };

package/src/registry.ts

@@ -5,6 +5,7 @@
 
 import { entityDuplicate } from './errors';
 import type { InvariantKind } from './invariants';
+import type { OnDelete } from './types';
 
 export interface ColumnDescription {
   readonly property: string;
@@ -16,6 +17,13 @@ export interface ColumnDescription {
   readonly hasDefault: boolean;
   readonly check: string | null;
   readonly references: string | null;
+  /**
+   * The `references()` rule, `null` when the key declared none. Beside `references` rather than
+   * inside it because that field is a flat `"<table>.<column>"` string with no room for it, and
+   * `@ultimat3/db` is tier 1: it cannot import this package, so a rule that is not on this
+   * projection reaches no `alter table` at all. It reached none until 3.0.
+   */
+  readonly onDelete: OnDelete | null;
 }
 
 /**
@@ -35,6 +43,8 @@ export interface ReferenceDescription {
   readonly targetEntity: string;
   readonly targetProperty: string;
   readonly targetColumn: string;
+  /** What the database does to this row when the target goes. `null` is Postgres' `no action`. */
+  readonly onDelete: OnDelete | null;
 }
 
 export interface InvariantDescription {

package/src/relations.ts

@@ -204,7 +204,10 @@ export const relationsFor = (entityName: string): EntityRelations =>
  */
 export const relationNamed = (entityName: string, name: string): Relation => {
   const relations = relationsFor(entityName);
-  const relation = relations[name];
+  // `relations[name]` walks the prototype: `preload('toString')` used to hand back
+  // `Function.prototype.toString` AS a `Relation`, past the refusal, to be read for a `.through`
+  // it does not have. A relation map is derived from foreign keys, so a name is caller data here.
+  const relation = Object.hasOwn(relations, name) ? relations[name] : undefined;
   if (relation === undefined) {
     throw preloadUnknownRelation(entityName, name, Object.keys(relations));
   }

package/src/repo.ts

@@ -7,17 +7,19 @@
 //     table silently skips and repeats rows. A keyset cursor is stable because it names a
 //     position in the sort order, not a row count.
 
-import { systemClock } from '@ultimat3/core';
+import { keyOf } from './batch-read';
 import { conflictKeyOf, conflictKeys, upsertPlan } from './bulk-write';
+import { entityNow } from './clock';
 import { narrowMoney } from './columns';
 import { countsFrom, groupColumnOf } from './count-by';
-import { cursorFor, seekFrom, valueAt } from './cursor';
+import { cursorFor, kindOf, seekFrom, valueAt } from './cursor';
 import { type EntityCore, SOFT_DELETE_COLUMN } from './entity';
 import { notFound } from './errors';
+import { compareByKind, matchesPredicate } from './memory-match';
 import { deletePlan, idPlan, readPlan, singleKeyOf, updatePlan } from './plan';
 import type { Predicate, QueryPlan, SortKey } from './tenancy';
 import { assertRowTenant } from './tenancy';
-import type { IdOf } from './types';
+import type { IdOf, RowPatch } from './types';
 
 export interface Tx {
   readonly id: string;
@@ -52,12 +54,26 @@ export interface UpsertArgs<T = unknown> extends RepoOptions {
   readonly onMatch?: 'update' | 'nothing';
 }
 
-export interface FindManyArgs extends RepoOptions {
+/**
+ * `findById`'s options: `RepoOptions`, plus the one knob a point READ has and a write must not.
+ *
+ * `includeDeleted` lives here and deliberately NOT on `RepoOptions`. It has always been honoured
+ * on this path — `idPlan` spreads the options straight into `FindManyArgs`, and both drivers read
+ * `args.includeDeleted === true` — but `RepoOptions` never declared it, so the only documented way
+ * to read a soft-deleted row by its id did not typecheck. Putting it on `RepoOptions` instead would
+ * have offered it to `update(id, patch)` and `delete(id)`, which reach the same `idPlan`: that is
+ * the resurrection those two carry `deleted_at is null` to refuse.
+ */
+export interface FindByIdOptions extends RepoOptions {
+  /** Soft-deleted rows are hidden unless the caller asks for them. */
+  readonly includeDeleted?: boolean;
+}
+
+export interface FindManyArgs extends FindByIdOptions {
   readonly where?: readonly Predicate[];
   readonly orderBy?: readonly SortKey[];
   readonly limit?: number;
   readonly cursor?: string | null;
-  readonly includeDeleted?: boolean;
   readonly select?: readonly string[];
 }
 
@@ -76,7 +92,7 @@ export interface Page<T> {
  * both `string`, so a row-agnostic consumer sees the signature it always saw.
  */
 export interface Repo<T = unknown> {
-  findById(id: IdOf<T>, options?: RepoOptions): Promise<T | null>;
+  findById(id: IdOf<T>, options?: FindByIdOptions): Promise<T | null>;
   findMany(args?: FindManyArgs): Promise<Page<T>>;
   insert(values: T, options?: RepoOptions): Promise<T>;
   /**
@@ -93,7 +109,7 @@ export interface Repo<T = unknown> {
    * which is what `returning *` says on the Postgres side.
    */
   upsertAll(rows: readonly T[], args: UpsertArgs<T>): Promise<readonly T[]>;
-  update(id: IdOf<T>, patch: Partial<T>, options?: RepoOptions): Promise<T>;
+  update(id: IdOf<T>, patch: RowPatch<T>, options?: RepoOptions): Promise<T>;
   delete(id: IdOf<T>, options?: RepoOptions): Promise<void>;
   /**
    * Delete by filter, returning how many rows went. The only way to remove a row from an entity
@@ -101,14 +117,14 @@ export interface Repo<T = unknown> {
    * to be able to tell "nothing matched" from "it worked", and an empty filter is
    * `X_WRITE_UNFILTERED` rather than every row.
    */
-  deleteWhere(filter: Partial<T>, options?: RepoOptions): Promise<number>;
+  deleteWhere(filter: RowPatch<T>, options?: RepoOptions): Promise<number>;
   /**
    * Update by filter, returning how many rows were written. The `update(id, patch)` a composite
    * primary key cannot express — `participants.lastReadAt` is the reference case. Same two guards
    * as `deleteWhere`, plus `X_PATCH_EMPTY` for a patch that names no columns, and soft-deleted
    * rows are not reachable, exactly as they are not by `update(id, patch)`.
    */
-  updateWhere(filter: Partial<T>, patch: Partial<T>, options?: RepoOptions): Promise<number>;
+  updateWhere(filter: RowPatch<T>, patch: RowPatch<T>, options?: RepoOptions): Promise<number>;
   count(args?: FindManyArgs): Promise<number>;
   /**
    * The grouped count: one statement, one entry per distinct value of `column`, over exactly the
@@ -142,79 +158,22 @@ export interface Transactor {
 const field = (row: unknown, property: string): unknown =>
   typeof row === 'object' && row !== null ? (row as Record<string, unknown>)[property] : undefined;
 
-/**
- * `===` on two Dates compares identity, so `where({ publishedAt })` would match nothing here
- * and every row in Postgres. Equality has to mean the same thing in both drivers or the
- * in-memory one stops being a preview of production.
- */
-const sameValue = (left: unknown, right: unknown): boolean =>
-  left instanceof Date && right instanceof Date
-    ? left.getTime() === right.getTime()
-    : left === right;
-
-const matches = (row: unknown, predicate: Predicate): boolean => {
-  const actual = field(row, predicate.column);
-  switch (predicate.op) {
-    case 'eq':
-      return sameValue(actual, predicate.value);
-    case 'neq':
-      return !sameValue(actual, predicate.value);
-    case 'in':
-      return (
-        Array.isArray(predicate.value) &&
-        predicate.value.some((candidate) => sameValue(candidate, actual))
-      );
-    case 'gt':
-      return compare(actual, predicate.value) > 0;
-    case 'gte':
-      return compare(actual, predicate.value) >= 0;
-    case 'lt':
-      return compare(actual, predicate.value) < 0;
-    case 'lte':
-      return compare(actual, predicate.value) <= 0;
-    // Real LIKE semantics, so `'draft%'` means "starts with" here exactly as it does in
-    // Postgres. Treating the pattern as a substring would make the two drivers disagree.
-    case 'like':
-      return likePattern(String(predicate.value)).test(String(actual));
-    case 'is-null':
-      return actual === null || actual === undefined;
-    case 'is-not-null':
-      return actual !== null && actual !== undefined;
-  }
-};
-
-/**
- * `%` and `_` are the wildcards; everything else in the pattern is literal, as in SQL.
- *
- * A RUN of `%` is one `.*`, not one each: `%%%…x` compiled to twenty adjacent `.*` groups, and an
- * anchored regex with twenty of them takes exponential time to fail on a long value — a filter
- * value an app forwards from a search box is then a CPU stall in the process, on the in-memory
- * driver. Postgres reads a run of `%` as one wildcard too, so this is the two drivers agreeing
- * rather than a defensive narrowing.
- */
-const likePattern = (pattern: string): RegExp =>
-  new RegExp(
-    `^${pattern
-      .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-      .replaceAll(/%+/g, '.*')
-      .replaceAll('_', '.')}$`,
-    's',
-  );
-
-const compare = (left: unknown, right: unknown): number => {
-  if (left instanceof Date && right instanceof Date) return left.getTime() - right.getTime();
-  if (typeof left === 'number' && typeof right === 'number') return left - right;
-  if (typeof left === 'bigint' && typeof right === 'bigint') {
-    return left < right ? -1 : left > right ? 1 : 0;
-  }
-  const [a, b] = [String(left), String(right)];
-  return a < b ? -1 : a > b ? 1 : 0;
-};
-
 /** Lexicographic over the sort keys, direction applied. `> 0` means "after the cursor". */
-const compareToSeek = (plan: QueryPlan, row: unknown, seek: readonly unknown[]): number => {
+const compareToSeek = <Row>(
+  entity: EntityCore<Row>,
+  plan: QueryPlan,
+  row: unknown,
+  seek: readonly unknown[],
+): number => {
   for (const [index, entry] of plan.orderBy.entries()) {
-    const order = compare(valueAt(row, entry.column), seek[index]);
+    // The COLUMN's kind, not the value's: the seek was revived from the same kind (`cursor.ts`),
+    // so a `bigint` column compares its stored decimal string against a revived `BigInt` as one
+    // number instead of as two pieces of text.
+    const order = compareByKind(
+      kindOf(entity, entry.column),
+      valueAt(row, entry.column),
+      seek[index],
+    );
     if (order !== 0) return entry.direction === 'desc' ? -order : order;
   }
   return 0;
@@ -232,7 +191,7 @@ const afterCursor = <Row>(
 ): number => {
   const seek = seekFrom(entity, plan);
   if (seek === undefined) return 0;
-  const start = found.findIndex((row) => compareToSeek(plan, row, seek) > 0);
+  const start = found.findIndex((row) => compareToSeek(entity, plan, row, seek) > 0);
   return start === -1 ? found.length : start;
 };
 
@@ -245,9 +204,20 @@ export const memoryRepo = <Row>(
   entity: EntityCore<Row>,
   seed: readonly Row[] = [],
 ): MemoryRepo<Row> => {
-  const keyOf = (row: unknown): string =>
-    entity.$primaryKey.map((property) => String(field(row, property))).join('
');
-  const rows = new Map<string, Row>(seed.map((row) => [keyOf(row), row]));
+  /**
+   * A stored row's key, spelled the way `batch-read.ts` spells an id — because Postgres compares a
+   * `uuid` as a VALUE and prints it lower-cased, so `findById(UPPER)` reads the row there while
+   * `String(...)` missed it here: `null` from a read and `X_NOT_FOUND` from a write, against a row
+   * that exists, reachable from a path parameter, a client-supplied id or a legacy import.
+   */
+  const storeKey = (row: unknown): string =>
+    entity.$primaryKey
+      .map((property) => keyOf(kindOf(entity, property) ?? '', field(row, property)))
+      .join('
');
+  /** The same key, from the id a caller named rather than from a row it has in hand. */
+  const idStoreKey = (id: unknown, operation: string): string =>
+    keyOf(kindOf(entity, singleKeyOf(entity, operation)) ?? '', id);
+  const rows = new Map<string, Row>(seed.map((row) => [storeKey(row), row]));
 
   const rowsOf = (plan: QueryPlan, args: FindManyArgs): Row[] => {
     const visible = (row: Row): boolean =>
@@ -256,11 +226,15 @@ export const memoryRepo = <Row>(
       field(row, SOFT_DELETE_COLUMN) === null ||
       field(row, SOFT_DELETE_COLUMN) === undefined;
     return [...rows.values()]
-      .filter((row) => plan.where.every((predicate) => matches(row, predicate)))
+      .filter((row) => plan.where.every((predicate) => matchesPredicate(entity, row, predicate)))
       .filter(visible)
       .sort((left, right) => {
         for (const entry of plan.orderBy) {
-          const order = compare(valueAt(left, entry.column), valueAt(right, entry.column));
+          const order = compareByKind(
+            kindOf(entity, entry.column),
+            valueAt(left, entry.column),
+            valueAt(right, entry.column),
+          );
           if (order !== 0) return entry.direction === 'desc' ? -order : order;
         }
         return 0;
@@ -283,7 +257,7 @@ export const memoryRepo = <Row>(
     // out of this tenant is refused by the same call that refuses an insert into another one.
     assertRowTenant(entity.$name, entity.$tenantColumn, operation, row);
     entity.$assert(row);
-    const key = keyOf(row);
+    const key = storeKey(row);
     const previous = rows.get(key);
     options?.tx?.onRollback(() => {
       if (previous === undefined) rows.delete(key);
@@ -297,7 +271,7 @@ export const memoryRepo = <Row>(
   // to name a row, so `update`/`delete` resolve through a plan rather than through the map.
   const addressed = (id: string, options: RepoOptions | undefined, operation: string): Row => {
     const plan = idPlan(entity, id, options, operation);
-    const current = rows.get(id);
+    const current = rows.get(idStoreKey(id, operation));
     // A soft-deleted row is hidden from writes too — `delete` on one is `X_NOT_FOUND`, not a
     // second stamp, which is what the Postgres driver's `deleted_at is null` clause already says.
     const hidden =
@@ -308,7 +282,7 @@ export const memoryRepo = <Row>(
     if (
       current === undefined ||
       hidden ||
-      !plan.where.every((predicate) => matches(current, predicate))
+      !plan.where.every((predicate) => matchesPredicate(entity, current, predicate))
     ) {
       throw notFound(entity.$name, id);
     }
@@ -334,7 +308,8 @@ export const memoryRepo = <Row>(
       const more = start + page.length < found.length;
       return {
         rows: page,
-        nextCursor: more && last !== undefined ? cursorFor(entity, plan, last, keyOf(last)) : null,
+        nextCursor:
+          more && last !== undefined ? cursorFor(entity, plan, last, storeKey(last)) : null,
       };
     },
 
@@ -407,14 +382,10 @@ export const memoryRepo = <Row>(
       const current = addressed(id, options, 'delete');
       // Soft delete hides the row without losing it; the column's presence is the switch.
       if (entity.$softDelete) {
-        write(
-          Object.assign({}, current, { [SOFT_DELETE_COLUMN]: systemClock.now() }),
-          options,
-          'delete',
-        );
+        write(Object.assign({}, current, { [SOFT_DELETE_COLUMN]: entityNow() }), options, 'delete');
         return;
       }
-      const key = keyOf(current);
+      const key = storeKey(current);
       options?.tx?.onRollback(() => rows.set(key, current));
       rows.delete(key);
     },
@@ -428,13 +399,13 @@ export const memoryRepo = <Row>(
       for (const row of doomed) {
         if (entity.$softDelete) {
           write(
-            Object.assign({}, row, { [SOFT_DELETE_COLUMN]: systemClock.now() }),
+            Object.assign({}, row, { [SOFT_DELETE_COLUMN]: entityNow() }),
             options,
             'deleteWhere',
           );
           continue;
         }
-        const key = keyOf(row);
+        const key = storeKey(row);
         options?.tx?.onRollback(() => rows.set(key, row));
         rows.delete(key);
       }
@@ -471,7 +442,7 @@ export const memoryRepo = <Row>(
 
     reset() {
       rows.clear();
-      for (const row of seed) rows.set(keyOf(row), row);
+      for (const row of seed) rows.set(storeKey(row), row);
     },
   };
 };