@genesislcap/mock-server 15.60.0 → 15.61.0

package/src/db/legacyCriteria.ts

@@ -0,0 +1,301 @@
+// The criteria evaluator of fidelity: 'legacy' (CriteriaOptions.lenient):
+// this engine's own semantics up to 15.47, kept as they were — JavaScript
+// comparisons (`QTY > -1` holds for a null QTY, `QTY == null` misses a
+// missing field), functions that answer false rather than throw (so
+// `!STATUS.equals('NEW')` keeps a row with no STATUS), inclusive
+// dateTimeIsAfter / dateTimeIsBefore, dates read by Date.parse too, and the
+// AND / OR / NOT, `<>` and `=` dialect. GSF's semantics are criteria.ts's.
+//
+// Only addition: the GSF functions 15.47 didn't have and so failed open on —
+// containsWordsStartingWithIgnoreCase, isNullOrBlank, notNullOrBlank,
+// dateIsAfter, dateIsBefore, dateTimeIsInRange — in the same false-not-throw
+// style.
+
+import type { Row } from '../types.ts';
+import {
+  CriteriaSyntaxError,
+  parseGenesisDateTime,
+  tokenizeCriteria,
+  UnsupportedCriteriaError,
+} from './criteriaTokens.ts';
+import * as gsf from './gsfExpr.ts';
+
+type Predicate = (record: Row) => boolean;
+
+function parseLiteral(token: string): unknown {
+  if (/^['"]/.test(token)) return token.slice(1, -1).replace(/\\(.)/g, '$1');
+  if (/^-?\d+(?:\.\d+)?$/.test(token)) return Number(token);
+  if (token === 'true') return true;
+  if (token === 'false') return false;
+  if (token === 'null') return null;
+  return undefined; // not a literal -> treat as a field reference
+}
+
+const COMPARATORS = new Set(['==', '=', '!=', '<>', '<', '<=', '>', '>=']);
+
+function toEpochDay(value: unknown): number | null {
+  const epoch = parseGenesisDateTime(value);
+  return epoch === null ? null : gsf.epochDay(epoch);
+}
+
+type ExprResolver = (token: string, record: Row) => unknown;
+type LegacyFunction = (record: Row, args: string[], resolve: ExprResolver) => boolean;
+
+function compareByDay(cmp: (a: number, b: number) => boolean): LegacyFunction {
+  return (record, args, resolve) => {
+    const a = toEpochDay(resolve(args[0], record));
+    const b = toEpochDay(resolve(args[1], record));
+    return a !== null && b !== null && cmp(a, b);
+  };
+}
+
+function compareByTime(cmp: (a: number, b: number) => boolean): LegacyFunction {
+  return (record, args, resolve) => {
+    const a = parseGenesisDateTime(resolve(args[0], record));
+    const b = parseGenesisDateTime(resolve(args[1], record));
+    return a !== null && b !== null && cmp(a, b);
+  };
+}
+
+const isBlankValue = (value: unknown) =>
+  value === null || value === undefined || (typeof value === 'string' && gsf.isBlank(value));
+
+// Expr.<fn>(field, value), and the same functions as <FIELD>.<fn>(value)
+// with the receiver as the first argument.
+const LEGACY_FUNCTIONS: Record<string, LegacyFunction> = {
+  // Multi-value fields (e.g. DEAL_CURRENCIES) may hold an array — treat
+  // "contains" as membership there, substring match on strings.
+  contains: (record, args, resolve) => {
+    const value = resolve(args[0], record);
+    const needle = resolve(args[1], record);
+    if (typeof needle !== 'string') return false;
+    if (Array.isArray(value)) return value.some((v) => typeof v === 'string' && v === needle);
+    return typeof value === 'string' && value.includes(needle);
+  },
+  containsIgnoreCase: (record, args, resolve) => {
+    const value = resolve(args[0], record);
+    const needle = resolve(args[1], record);
+    if (typeof needle !== 'string') return false;
+    const lowered = needle.toLowerCase();
+    if (Array.isArray(value)) {
+      return value.some((v) => typeof v === 'string' && v.toLowerCase() === lowered);
+    }
+    return typeof value === 'string' && value.toLowerCase().includes(lowered);
+  },
+  equals: (record, args, resolve) => resolve(args[0], record) === resolve(args[1], record),
+  equalsIgnoreCase: (record, args, resolve) => {
+    const value = resolve(args[0], record);
+    const other = resolve(args[1], record);
+    if (typeof value !== 'string' || typeof other !== 'string') return value === other;
+    return value.toLowerCase() === other.toLowerCase();
+  },
+  startsWith: (record, args, resolve) => {
+    const value = resolve(args[0], record);
+    const prefix = resolve(args[1], record);
+    return typeof value === 'string' && typeof prefix === 'string' && value.startsWith(prefix);
+  },
+  endsWith: (record, args, resolve) => {
+    const value = resolve(args[0], record);
+    const suffix = resolve(args[1], record);
+    return typeof value === 'string' && typeof suffix === 'string' && value.endsWith(suffix);
+  },
+  dateIsToday: (record, args, resolve) => {
+    const day = toEpochDay(resolve(args[0], record));
+    return day !== null && day === toEpochDay(Date.now());
+  },
+  dateIsEqual: compareByDay((a, b) => a === b),
+  dateIsGreaterEqual: compareByDay((a, b) => a >= b),
+  dateIsLessEqual: compareByDay((a, b) => a <= b),
+  dateTimeIsEqual: compareByTime((a, b) => a === b),
+  dateTimeIsGreaterEqual: compareByTime((a, b) => a >= b),
+  dateTimeIsLessEqual: compareByTime((a, b) => a <= b),
+  dateTimeIsAfter: compareByTime((a, b) => a >= b),
+  dateTimeIsBefore: compareByTime((a, b) => a <= b),
+  // GSF's, which 15.47 didn't have.
+  dateIsAfter: compareByDay((a, b) => a > b),
+  dateIsBefore: compareByDay((a, b) => a < b),
+  isNullOrBlank: (record, args, resolve) => isBlankValue(resolve(args[0], record)),
+  notNullOrBlank: (record, args, resolve) => !isBlankValue(resolve(args[0], record)),
+  containsWordsStartingWithIgnoreCase: (record, args, resolve) => {
+    const value = resolve(args[0], record);
+    const search = resolve(args[1], record);
+    const delimiter = args.length > 2 ? resolve(args[2], record) : ' ';
+    if (typeof value !== 'string' || typeof search !== 'string') return false;
+    if (typeof delimiter !== 'string' || delimiter === '') return false;
+    return gsf.containsWordsStartingWithIgnoreCase(value, search, delimiter[0]);
+  },
+  dateTimeIsInRange: (record, args, resolve) => {
+    const millis = parseGenesisDateTime(resolve(args[0], record));
+    const [range, context] = [resolve(args[1], record), resolve(args[2], record)];
+    if (millis === null || typeof range !== 'string' || typeof context !== 'string') return false;
+    try {
+      return gsf.dateTimeIsInRange(millis, range, context);
+    } catch {
+      return false;
+    }
+  },
+};
+
+class Parser {
+  private tokens: string[];
+  private pos = 0;
+  readonly fields = new Set<string>();
+
+  constructor(tokens: string[]) {
+    this.tokens = tokens;
+  }
+
+  get position(): number {
+    return this.pos;
+  }
+
+  private peek(): string | undefined {
+    return this.tokens[this.pos];
+  }
+
+  private next(): string | undefined {
+    const token = this.tokens[this.pos];
+    this.pos += 1;
+    return token;
+  }
+
+  parseOr(): Predicate {
+    let left = this.parseAnd();
+    while (this.peek() === '||' || this.peek()?.toUpperCase() === 'OR') {
+      this.next();
+      const right = this.parseAnd();
+      const prev = left;
+      left = (record) => prev(record) || right(record);
+    }
+    return left;
+  }
+
+  private parseAnd(): Predicate {
+    let left = this.parseNot();
+    while (this.peek() === '&&' || this.peek()?.toUpperCase() === 'AND') {
+      this.next();
+      const right = this.parseNot();
+      const prev = left;
+      left = (record) => prev(record) && right(record);
+    }
+    return left;
+  }
+
+  private parseNot(): Predicate {
+    const next = this.peek();
+    if (next === '!' || next?.toUpperCase() === 'NOT') {
+      this.next();
+      const operand = this.parseNot();
+      return (record) => !operand(record);
+    }
+    return this.parseComparison();
+  }
+
+  private parseComparison(): Predicate {
+    if (this.peek() === '(') {
+      this.next();
+      const inner = this.parseOr();
+      if (this.next() !== ')')
+        throw new CriteriaSyntaxError('Missing closing parenthesis in criteria');
+      return inner;
+    }
+
+    const leftToken = this.next();
+    if (leftToken === undefined) {
+      throw new CriteriaSyntaxError('Expected operand on the left side of comparison');
+    }
+    if (leftToken.includes('.') && this.peek() === '(') return this.parseFunctionCall(leftToken);
+
+    const op = this.peek();
+    if (!op || !COMPARATORS.has(op))
+      throw new CriteriaSyntaxError(`Expected comparator, got: ${op}`);
+    this.next();
+    const rightToken = this.next();
+    if (rightToken === undefined) {
+      throw new CriteriaSyntaxError('Expected operand on the right side of comparison');
+    }
+
+    this.noteField(leftToken);
+    this.noteField(rightToken);
+    const resolveLeft = (record: Row) => this.resolveValue(leftToken, record);
+    const resolveRight = (record: Row) => this.resolveValue(rightToken, record);
+
+    return (record: Row) => {
+      const a = resolveLeft(record);
+      const b = resolveRight(record);
+      switch (op) {
+        case '==':
+        case '=':
+          return a === b;
+        case '!=':
+        case '<>':
+          return a !== b;
+        case '>':
+          return (a as any) > (b as any);
+        case '>=':
+          return (a as any) >= (b as any);
+        case '<':
+          return (a as any) < (b as any);
+        case '<=':
+          return (a as any) <= (b as any);
+        default:
+          return false;
+      }
+    };
+  }
+
+  private noteField(token: string): void {
+    if (parseLiteral(token) === undefined) this.fields.add(token);
+  }
+
+  private resolveValue(token: string, record: Row): unknown {
+    const literal = parseLiteral(token);
+    if (literal !== undefined) return literal;
+    return record[token];
+  }
+
+  private parseFunctionCall(name: string): Predicate {
+    this.next(); // consume '('
+    const args: string[] = [];
+    if (this.peek() !== ')') {
+      const arg = this.next();
+      if (arg === undefined)
+        throw new CriteriaSyntaxError(`Unterminated argument list in ${name}(...)`);
+      args.push(arg);
+      while (this.peek() === ',') {
+        this.next();
+        const nextArg = this.next();
+        if (nextArg === undefined) {
+          throw new CriteriaSyntaxError(`Unterminated argument list in ${name}(...)`);
+        }
+        args.push(nextArg);
+      }
+    }
+    if (this.next() !== ')')
+      throw new CriteriaSyntaxError(`Missing closing parenthesis in ${name}(...)`);
+
+    const dotIndex = name.lastIndexOf('.');
+    const receiver = name.slice(0, dotIndex);
+    const fnName = name.slice(dotIndex + 1);
+    const handler = Object.hasOwn(LEGACY_FUNCTIONS, fnName) ? LEGACY_FUNCTIONS[fnName] : undefined;
+    if (!handler) throw new UnsupportedCriteriaError(`Unsupported criteria function: ${name}`);
+    const allArgs = receiver === 'Expr' ? args : [receiver, ...args];
+    for (const arg of allArgs) this.noteField(arg);
+
+    const resolve: ExprResolver = (token, record) => this.resolveValue(token, record);
+    return (record: Row) => handler(record, allArgs, resolve);
+  }
+}
+
+// A criteria as fidelity: 'legacy' evaluates it: its predicate and the fields
+// it reads. Throws CriteriaSyntaxError for what this grammar can't parse
+// and UnsupportedCriteriaError for a function it doesn't have.
+export function parseLegacyCriteria(criteria: string): { predicate: Predicate; fields: string[] } {
+  const tokens = tokenizeCriteria(criteria.trim()).map((token) => token.text);
+  const parser = new Parser(tokens);
+  const predicate = parser.parseOr();
+  if (parser.position !== tokens.length) {
+    throw new CriteriaSyntaxError(`Unexpected trailing tokens in criteria: ${criteria}`);
+  }
+  return { predicate, fields: [...parser.fields] };
+}

package/src/db/ordering.ts

@@ -1,5 +1,6 @@
-// Row ordering shared by the dataserver (DATA_LOGON ORDER_BY, an index name)
-// and request servers (REQ_ DETAILS.ORDER_BY, fields with a direction).
+// Row ordering shared by the dataserver (DATA_LOGON ORDER_BY, an index name;
+// without one, RECORD_ID) and request servers (REQ_ DETAILS.ORDER_BY, fields
+// with a direction).
 
 import type { Row } from '../types.ts';
 import { RECORD_ID } from './identity.ts';
@@ -22,6 +23,29 @@ export interface OrderedField {
   descending: boolean;
 }
 
+const INTEGER_TEXT = /^-?\d+$/;
+
+// RECORD_IDs compared as the integers they are: the engine's own stamps are
+// numbers, but a seed may bring the real server's ~7.5e18 ids as strings,
+// which neither a string nor a float comparison orders correctly. Anything
+// that isn't an integer falls back to compareValues.
+export function compareRecordIds(a: unknown, b: unknown): number {
+  const asInteger = (value: unknown) =>
+    typeof value === 'number' && Number.isSafeInteger(value)
+      ? BigInt(value)
+      : typeof value === 'string' && INTEGER_TEXT.test(value)
+        ? BigInt(value)
+        : undefined;
+  const [left, right] = [asInteger(a), asInteger(b)];
+  if (left === undefined || right === undefined) return compareValues(a, b);
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// Oldest first: RECORD_ID ascending, the order rows were written in.
+export function byRecordId(a: Row, b: Row): number {
+  return compareRecordIds(a[RECORD_ID], b[RECORD_ID]);
+}
+
 // Sorts by the fields in turn, then by RECORD_ID ascending: the tie-breaker
 // column GSF's SQL ordering always appends (GetByCriteriaOperation.kt,
 // tieBreakerColumn = "RECORD_ID", v8.15.29), whatever the direction.
@@ -31,7 +55,7 @@ export function rowComparator(fields: OrderedField[]): (a: Row, b: Row) => numbe
       const result = compareValues(a[field], b[field]);
       if (result !== 0) return descending ? -result : result;
     }
-    return compareValues(a[RECORD_ID], b[RECORD_ID]);
+    return byRecordId(a, b);
   };
 }
 

package/src/db/schema.ts

@@ -21,6 +21,7 @@ import type {
 import { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from './identity.ts';
 import { deriveFields } from './metadata.ts';
 import type { Store } from './store.ts';
+import { columnScale } from './values.ts';
 import { planView } from './views.ts';
 
 export interface ResolvedField {
@@ -35,6 +36,9 @@ export interface ResolvedField {
   default?: unknown;
   maxSize?: number;
   minLength?: number;
+  // A BIGDECIMAL's scale: a table column's always (default 5), a derived or
+  // DTO field's only when declared. See db/values.ts.
+  scale?: number;
   description?: string;
   title?: string;
   // FieldDef.optional; for an event field, resolved by eventFields.
@@ -90,6 +94,7 @@ function fromFieldDef(
     ...(field.default !== undefined ? { default: field.default } : {}),
     ...(field.maxSize !== undefined ? { maxSize: field.maxSize } : {}),
     ...(field.minLength !== undefined ? { minLength: field.minLength } : {}),
+    ...(field.scale !== undefined ? { scale: field.scale } : {}),
     ...(field.description !== undefined ? { description: field.description } : {}),
     ...(field.title !== undefined ? { title: field.title } : {}),
     ...(field.optional !== undefined ? { optional: field.optional } : {}),
@@ -100,14 +105,16 @@ function fromFieldDef(
 function declaredTableFields(tableName: string, def: TableDef): ResolvedField[] {
   const pkFields = pkFieldsOf(def);
   const generated = generatedFieldsOf(def);
-  return (def.fields ?? []).map((field) =>
-    fromFieldDef(
+  return (def.fields ?? []).map((field) => {
+    const resolved = fromFieldDef(
       field,
       tableName,
       pkFields.includes(field.name) || generated.has(field.name),
       generated.has(field.name),
-    ),
-  );
+    );
+    const scale = columnScale(field);
+    return scale === undefined ? resolved : { ...resolved, scale };
+  });
 }
 
 // Inference from rows: a type per column (metadata.ts), nothing nullable but
@@ -264,7 +271,9 @@ export function resolveSourceSchema(
   return { fields, declared: false };
 }
 
-// fieldTypes overrides the TYPE of the named fields, declared or inferred.
+// fieldTypes overrides the TYPE of the named fields, declared or inferred. A
+// table column made a BIGDECIMAL takes the default scale, as every column of
+// that type has one (see db/values.ts).
 export function withTypeOverrides(
   schema: ResolvedSchema,
   fieldTypes: Record<string, string> | undefined,
@@ -272,9 +281,12 @@ export function withTypeOverrides(
   if (!fieldTypes) return schema;
   return {
     ...schema,
-    fields: schema.fields.map((field) =>
-      fieldTypes[field.name] ? { ...field, type: fieldTypes[field.name] } : field,
-    ),
+    fields: schema.fields.map((field) => {
+      const type = fieldTypes[field.name];
+      if (!type) return field;
+      const scale = field.table ? columnScale({ type, scale: field.scale }) : field.scale;
+      return { ...field, type, ...(scale !== undefined ? { scale } : {}) };
+    }),
   };
 }
 
@@ -303,6 +315,29 @@ export function querySchema(
   );
 }
 
+// The Genesis type of each field a query's criteria may read, where it is
+// known — what GSF compiles a criteria against (criteria.ts): every column of
+// a declared source, else only the fields its fieldTypes, or its view's
+// derivedTypes, name. A type inferred from the rows is only a guess.
+export function queryCriteriaTypes(
+  query: QueryDef,
+  config: MockServerConfig,
+  store: Store,
+): Map<string, string> {
+  if (isDeclared(query.source, config, store)) {
+    return new Map(
+      querySchema(query, config, store).fields.map((field) => [field.name, field.type]),
+    );
+  }
+  const types = new Map<string, string>();
+  const derived = viewOf(query.source, config, store)?.derivedTypes ?? {};
+  for (const [name, entry] of Object.entries(derived)) {
+    types.set(name, typeof entry === 'string' ? entry : entry.type);
+  }
+  for (const [name, type] of Object.entries(query.fieldTypes ?? {})) types.set(name, type);
+  return types;
+}
+
 // A resolver-only request server has no table: its fields come from the
 // def's metadataRows sample.
 export function requestReplySchema(

package/src/db/store.ts

@@ -3,6 +3,7 @@
 
 import type { Row, SequenceFormat, TableDef, ViewDef } from '../types.ts';
 import { RECORD_ID, RecordClock, recordKey, TIMESTAMP, withoutRecordFields } from './identity.ts';
+import { columnScale, storedValue, unlistedEnumValue, type ValueField } from './values.ts';
 import {
   materializeEntries,
   planView,
@@ -33,6 +34,15 @@ interface TableConfig {
   sequenceWidth: number;
   sequenceFormat: SequenceFormat;
   generators: Generator[];
+  // The declared columns (TableDef.fields), whose values are held by type.
+  columns?: ValueField[];
+}
+
+export interface StoreOptions {
+  // Whether values written to a declared column are held by its type (see
+  // db/values.ts). Read on every write; the mock server turns it off under
+  // fidelity: 'legacy', where rows are kept as given. Default: on.
+  normalizeValues?: () => boolean;
 }
 
 // The generators of a table, the key's own sequence first. A SEQUENCE with
@@ -155,6 +165,13 @@ export class Store {
   // as it was before.
   private savepoint: Map<string, TableSavepoint> | undefined;
   readonly views = new Map<string, ViewDef>();
+  private readonly normalizeValues: () => boolean;
+  // ENUM values already warned about, as 'TABLE.FIELD=value'.
+  private readonly unlistedWarned = new Set<string>();
+
+  constructor({ normalizeValues = () => true }: StoreOptions = {}) {
+    this.normalizeValues = normalizeValues;
+  }
 
   // Opens a transaction: the commit-event path wraps every handler in one
   // (handlers/commitEvent.ts), so an event that NACKs leaves the tables as
@@ -219,11 +236,26 @@ export class Store {
       sequenceWidth,
       sequenceFormat,
       generators: generatorsOf(pkFields, definition),
+      ...(definition.fields
+        ? {
+            // Key columns stay as given: every lookup (getRow, updateRow,
+            // broadcastTableChange) names a row by the key the caller has.
+            columns: definition.fields
+              .filter((field) => !pkFields.includes(field.name))
+              .map((field) => ({
+                name: field.name,
+                type: field.type,
+                scale: columnScale(field),
+                values: field.values,
+              })),
+          }
+        : {}),
     };
+    const seeded = rows.map((row) => this.withStoredValues(tableName, config, { ...row }));
     const table = new Map<Pk, Row>();
     const seenIds = new Set<string>();
     let restamped = 0;
-    for (const row of rows) {
+    for (const row of seeded) {
       const stamped = this.stampSeedRow({ ...row }, seenIds);
       if (stamped.restamped) restamped += 1;
       table.set(keyFor(pkFields, row), stamped.row);
@@ -242,7 +274,7 @@ export class Store {
     this.previousRows.delete(tableName);
     this.seedRows.set(
       tableName,
-      rows.map((row) => ({ ...row })),
+      seeded.map((row) => ({ ...row })),
     );
 
     // Each counter starts after the highest value the seed rows carry (two
@@ -251,7 +283,7 @@ export class Store {
     const starts = new Map<string, number>();
     for (const generator of config.generators) {
       let maxN = 0;
-      for (const row of rows) {
+      for (const row of seeded) {
         const n = this.generatedNumber(config, generator, row[generator.field]);
         if (n !== undefined) maxN = Math.max(maxN, n);
       }
@@ -284,7 +316,10 @@ export class Store {
     if (generator.kind === 'SEQUENCE') {
       return sequenceNumber(generator.prefix, config.sequenceFormat, value);
     }
-    return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
+    // A key column keeps a seeded '2' as given, but the counter still has to
+    // start after it.
+    const number = typeof value === 'string' && /^\d+$/.test(value) ? Number(value) : value;
+    return typeof number === 'number' && Number.isSafeInteger(number) ? number : undefined;
   }
 
   // Throws on a join model GSF would refuse to compile (see planView).
@@ -318,6 +353,28 @@ export class Store {
     return { row, restamped: !missing && !keep };
   }
 
+  // Each declared column's value as the store holds it (db/values.ts
+  // storedValue): dates as epoch millis, BigDecimals rounded to their scale,
+  // numbers and booleans given as strings read as such. An ENUM value its
+  // field doesn't list is kept, with a warning (once per value): the real
+  // table could never hold it. Changes `row` in place and returns it.
+  private withStoredValues(tableName: string, config: TableConfig, row: Row): Row {
+    if (!config.columns || !this.normalizeValues()) return row;
+    for (const column of config.columns) {
+      if (!Object.hasOwn(row, column.name)) continue;
+      row[column.name] = storedValue(column, row[column.name]);
+      const unlisted = unlistedEnumValue(column, row[column.name]);
+      const warning = `${tableName}.${column.name}=${String(unlisted)}`;
+      if (unlisted === undefined || this.unlistedWarned.has(warning)) continue;
+      this.unlistedWarned.add(warning);
+      console.warn(
+        `[mock-server] ${tableName}.${column.name}: ${JSON.stringify(unlisted)} is not one of ` +
+          `its ENUM values (${column.values!.join(', ')})`,
+      );
+    }
+    return row;
+  }
+
   // A newly inserted row gets RECORD_ID = TIMESTAMP = a fresh stamp, whatever
   // it was given — as on the real server — appended after its own fields.
   private stampNewRow(row: Row): Row {
@@ -457,7 +514,8 @@ export class Store {
 
   // Generates every missing (undefined or null) sequence and auto-increment
   // field — the sequencePrefix key and TableDef.generated — and keeps a
-  // supplied one, as GSF does; stamps RECORD_ID/TIMESTAMP. A row already
+  // supplied one, as GSF does; stamps RECORD_ID/TIMESTAMP. Declared columns
+  // are held by type (withStoredValues), as updateRow's patch is. A row already
   // stored under the same key is replaced (the real database would reject the
   // insert with DUPLICATE_KEY — check first and throw NackError.duplicateKey
   // for that, as the generic CRUD events do).
@@ -467,7 +525,7 @@ export class Store {
     if (!table || !config) throw new Error(`Unknown table: ${tableName}`);
 
     this.save(tableName);
-    const row = { ...record };
+    const row = this.withStoredValues(tableName, config, { ...record });
     this.generateValues(tableName, config, row);
     const missing = config.pkFields.filter((field) => row[field] === undefined);
     if (missing.length > 0) {
@@ -493,7 +551,7 @@ export class Store {
     this.save(tableName);
     const existing = table.get(pk)!;
     this.notePrevious(tableName, existing);
-    const updated = { ...existing, ...patch };
+    const updated = { ...existing, ...this.withStoredValues(tableName, config, { ...patch }) };
     updated[RECORD_ID] = existing[RECORD_ID];
     updated[TIMESTAMP] = this.clock.next();
     // A patch that changes a pk field (e.g. an entity-management form posting