@genesislcap/mock-server 15.59.0 → 15.61.0

package/dist/db/gsfExpr.js

@@ -0,0 +1,333 @@
+// What GSF's criteria functions compute (genesis-commons v8.15.29: Expr.java,
+// TimeUtils.java, ExtraOperators.kt, TimeRange.kt, TimeContext.kt), for the
+// evaluator in criteria.ts. GSF runs criteria in UTC (Joda's default zone,
+// set by RxDb.kt), so every date here is a UTC one.
+//
+// A Java exception inside a compiled criteria (a date that doesn't parse, a
+// null field, an unknown TimeRange) makes the row not match, however the
+// expression goes on: `!Expr.dateIsEqual(F, 'bad')` matches nothing. These
+// functions throw CriteriaEvaluationError for those, and the evaluator's
+// predicate answers false.
+export class CriteriaEvaluationError extends Error {
+    name = 'CriteriaEvaluationError';
+}
+export const evaluationError = (message) => {
+    throw new CriteriaEvaluationError(message);
+};
+const HOURS_PER_DAY = 24;
+const MINUTES_PER_HOUR = 60;
+const SECONDS_PER_MINUTE = 60;
+const MS_PER_SECOND = 1000;
+const MS_PER_MINUTE = SECONDS_PER_MINUTE * MS_PER_SECOND;
+const MS_PER_HOUR = MINUTES_PER_HOUR * MS_PER_MINUTE;
+export const MS_PER_DAY = HOURS_PER_DAY * MS_PER_HOUR;
+const DAYS_PER_WEEK = 7;
+const MONTHS_PER_YEAR = 12;
+// --- the calendar (proleptic Gregorian, as Joda's ISO chronology) ------------
+const DAYS_PER_ERA = 146_097;
+const YEARS_PER_ERA = 400;
+const MARCH_BASED_SHIFT = 3; // months before March belong to the year before
+const DAYS_IN_FIVE_MONTHS = 153;
+const FIVE_MONTHS = 5;
+const DAYS_TO_1970 = 719_468;
+const LEAP_EVERY = 4;
+const CENTURY = 100;
+const DAYS_PER_YEAR = 365;
+const DAYS_PER_4_YEARS = 1460;
+const DAYS_PER_100_YEARS = 36_524;
+const DAYS_PER_400_YEARS_MINUS_ONE = 146_096;
+const FEBRUARY = 2;
+const LONG_FEBRUARY = 29;
+const SHORT_FEBRUARY = 28;
+const APRIL = 4;
+const JUNE = 6;
+const SEPTEMBER = 9;
+const NOVEMBER = 11;
+const THIRTY_DAY_MONTHS = new Set([APRIL, JUNE, SEPTEMBER, NOVEMBER]);
+const SHORT_MONTH = 30;
+const LONG_MONTH = 31;
+// Days since 1970-01-01 of a date (month 1-12), any year.
+export function daysFromCivil(year, month, day) {
+    const y = month <= 2 ? year - 1 : year;
+    const era = Math.floor(y / YEARS_PER_ERA);
+    const yearOfEra = y - era * YEARS_PER_ERA;
+    const monthFromMarch = (month + MONTHS_PER_YEAR - MARCH_BASED_SHIFT) % MONTHS_PER_YEAR;
+    const dayOfYear = Math.floor((DAYS_IN_FIVE_MONTHS * monthFromMarch + 2) / FIVE_MONTHS) + day - 1;
+    const dayOfEra = yearOfEra * DAYS_PER_YEAR +
+        Math.floor(yearOfEra / LEAP_EVERY) -
+        Math.floor(yearOfEra / CENTURY) +
+        dayOfYear;
+    return era * DAYS_PER_ERA + dayOfEra - DAYS_TO_1970;
+}
+// The date of a day since 1970-01-01.
+export function civilFromDays(days) {
+    const z = days + DAYS_TO_1970;
+    const era = Math.floor(z / DAYS_PER_ERA);
+    const dayOfEra = z - era * DAYS_PER_ERA;
+    const yearOfEra = Math.floor((dayOfEra -
+        Math.floor(dayOfEra / DAYS_PER_4_YEARS) +
+        Math.floor(dayOfEra / DAYS_PER_100_YEARS) -
+        Math.floor(dayOfEra / DAYS_PER_400_YEARS_MINUS_ONE)) /
+        DAYS_PER_YEAR);
+    const dayOfYear = dayOfEra -
+        (DAYS_PER_YEAR * yearOfEra +
+            Math.floor(yearOfEra / LEAP_EVERY) -
+            Math.floor(yearOfEra / CENTURY));
+    const monthFromMarch = Math.floor((FIVE_MONTHS * dayOfYear + 2) / DAYS_IN_FIVE_MONTHS);
+    const day = dayOfYear - Math.floor((DAYS_IN_FIVE_MONTHS * monthFromMarch + 2) / FIVE_MONTHS) + 1;
+    const month = monthFromMarch < MONTHS_PER_YEAR - 2
+        ? monthFromMarch + MARCH_BASED_SHIFT
+        : monthFromMarch - (MONTHS_PER_YEAR - MARCH_BASED_SHIFT);
+    const year = yearOfEra + era * YEARS_PER_ERA + (month <= 2 ? 1 : 0);
+    return { year, month, day };
+}
+const isLeapYear = (year) => year % LEAP_EVERY === 0 && (year % CENTURY !== 0 || year % YEARS_PER_ERA === 0);
+function daysInMonth(year, month) {
+    if (month === FEBRUARY)
+        return isLeapYear(year) ? LONG_FEBRUARY : SHORT_FEBRUARY;
+    return THIRTY_DAY_MONTHS.has(month) ? SHORT_MONTH : LONG_MONTH;
+}
+export const epochDay = (millis) => Math.floor(millis / MS_PER_DAY);
+// `yyyy` reads at most four digits when another number follows it, and nine
+// otherwise (DateTimeFormat.parsePatternTo); MM, dd, HH, mm and ss two;
+// SSS three.
+const YEAR = { field: 'year', max: 4 };
+const LONG_YEAR = { field: 'year', max: 9 };
+const MONTH = { field: 'month', max: 2 };
+const DAY = { field: 'day', max: 2 };
+const HOUR = { field: 'hour', max: 2 };
+const MINUTE = { field: 'minute', max: 2 };
+const SECOND = { field: 'second', max: 2 };
+const FRACTION = { field: 'fraction', max: 3 };
+// ProcessConstants: DATE_FORMAT_FULL, _TO_SECONDS, _TO_MINUTES, _TO_DATE
+// and DATE_FORMAT_ISO8601_TO_DATE, in ALLOWED_DATE_PARSER's order.
+const TO_DATE = [YEAR, MONTH, DAY];
+const TO_MINUTES = [...TO_DATE, '-', HOUR, ':', MINUTE];
+const TO_SECONDS = [...TO_MINUTES, ':', SECOND];
+const FULL = [...TO_SECONDS, '.', FRACTION];
+const ISO8601_TO_DATE = [LONG_YEAR, '-', MONTH, '-', DAY];
+const ALLOWED_PATTERNS = [FULL, TO_SECONDS, TO_MINUTES, TO_DATE, ISO8601_TO_DATE];
+const DIGIT = /\d/;
+const FRACTION_DIGITS = 3;
+// The fields of `text` when the pattern reads all of it, else undefined.
+function readPattern(text, pattern) {
+    const fields = {
+        year: 0,
+        month: 1,
+        day: 1,
+        hour: 0,
+        minute: 0,
+        second: 0,
+        millis: 0,
+    };
+    let at = 0;
+    for (const part of pattern) {
+        if (typeof part === 'string') {
+            if (text[at] !== part)
+                return undefined;
+            at += 1;
+            continue;
+        }
+        let sign = 1;
+        if (part.field === 'year' && (text[at] === '-' || text[at] === '+')) {
+            if (!DIGIT.test(text[at + 1] ?? ''))
+                return undefined;
+            sign = text[at] === '-' ? -1 : 1;
+            at += 1;
+        }
+        let digits = '';
+        while (digits.length < part.max && DIGIT.test(text[at] ?? '')) {
+            digits += text[at];
+            at += 1;
+        }
+        if (digits === '')
+            return undefined;
+        if (part.field === 'fraction') {
+            fields.millis = Number(digits.padEnd(FRACTION_DIGITS, '0'));
+        }
+        else {
+            fields[part.field] = sign * Number(digits);
+        }
+    }
+    return at === text.length ? fields : undefined;
+}
+// Joda's ISO chronology years.
+const MIN_YEAR = -292_275_054;
+const MAX_YEAR = 292_278_993;
+const MAX_HOUR = 23;
+const MAX_MINUTE = 59;
+const MAX_SECOND = 59;
+// The fields' instant, or a Joda IllegalFieldValueException.
+function instantOf(fields, text) {
+    const { year, month, day, hour, minute, second, millis } = fields;
+    const valid = year >= MIN_YEAR &&
+        year <= MAX_YEAR &&
+        month >= 1 &&
+        month <= MONTHS_PER_YEAR &&
+        day >= 1 &&
+        day <= daysInMonth(year, month) &&
+        hour <= MAX_HOUR &&
+        minute <= MAX_MINUTE &&
+        second <= MAX_SECOND;
+    if (!valid)
+        evaluationError(`Cannot parse "${text}": a field value is out of range`);
+    return (daysFromCivil(year, month, day) * MS_PER_DAY +
+        hour * MS_PER_HOUR +
+        minute * MS_PER_MINUTE +
+        second * MS_PER_SECOND +
+        millis);
+}
+function parseWith(text, patterns) {
+    for (const pattern of patterns) {
+        const fields = readPattern(text, pattern);
+        if (fields)
+            return instantOf(fields, text);
+    }
+    return evaluationError(`Invalid format: "${text}"`);
+}
+// Expr.stringDateTime / TimeUtils.parseDateTime: the instant a criteria date
+// names — yyyyMMdd-HH:mm:ss.SSS, yyyyMMdd-HH:mm:ss, yyyyMMdd-HH:mm, yyyyMMdd
+// or yyyy-MM-dd, in UTC. Joda reads fewer digits than the pattern shows
+// ('2024-1-1', '20240101-9:5') and a fraction of a second ('.5' is 500 ms),
+// nothing else: no 'T', no offset, no spaces.
+export const stringDateTime = (text) => parseWith(text, ALLOWED_PATTERNS);
+// Expr.stringLocalDate / TimeUtils.parseLocalDate: the same formats, as a day
+// (days since 1970-01-01).
+export const stringLocalDate = (text) => epochDay(stringDateTime(text));
+// Expr.singlePatternLocalDate: the day a yyyyMMdd date names — the only form
+// the Long and DateTime overloads of dateIs* take for the date compared to.
+export const singlePatternLocalDate = (text) => epochDay(parseWith(text, [TO_DATE]));
+// DateTime.now().toLocalDate() in UTC.
+export const today = () => epochDay(Date.now());
+// --- strings -----------------------------------------------------------------
+// Character.isWhitespace: the Unicode space separators except the no-break
+// ones, and the ASCII controls \t \n \v \f \r and \u001C-\u001F.
+const JAVA_WHITESPACE = /^[\t\n\v\f\r\p{Zl}\p{Zp}\p{Zs}]$/u;
+const NO_BREAK_SPACE = /^[\u00A0\u2007\u202F]$/u;
+const FILE_SEPARATOR = 0x1c;
+const UNIT_SEPARATOR = 0x1f;
+const isJavaWhitespace = (char) => {
+    const code = char.charCodeAt(0);
+    if (code >= FILE_SEPARATOR && code <= UNIT_SEPARATOR)
+        return true;
+    return JAVA_WHITESPACE.test(char) && !NO_BREAK_SPACE.test(char);
+};
+// String.isBlank.
+export const isBlank = (text) => [...text].every(isJavaWhitespace);
+const upper = (char) => {
+    const result = char.toUpperCase();
+    return result.length === 1 ? result : char;
+};
+const lower = (char) => {
+    const result = char.toLowerCase();
+    return result.length === 1 ? result : char;
+};
+// String.regionMatches(true, ...): char by char, equal as they are, upper
+// cased, or upper then lower cased.
+function regionMatchesIgnoreCase(text, offset, other, length) {
+    for (let index = 0; index < length; index += 1) {
+        const a = text[offset + index];
+        const b = other[index];
+        if (a === b)
+            continue;
+        const [ua, ub] = [upper(a), upper(b)];
+        if (ua === ub || lower(ua) === lower(ub))
+            continue;
+        return false;
+    }
+    return true;
+}
+// Expr.containsIgnoreCase and the String?.containsIgnoreCase extension.
+export function containsIgnoreCase(text, search) {
+    if (text === null || search === null)
+        return false;
+    if (search.length === 0)
+        return true;
+    for (let at = text.length - search.length; at >= 0; at -= 1) {
+        if (regionMatchesIgnoreCase(text, at, search, search.length))
+            return true;
+    }
+    return false;
+}
+// Expr.containsWordsStartingWithIgnoreCase and its String? extension: whether
+// a word of `text` — split on the delimiter, ' ' by default — starts with
+// `search`, ignoring case. A word is never shorter than the search.
+export function containsWordsStartingWithIgnoreCase(text, search, delimiter = ' ') {
+    if (text === null || search === null)
+        return false;
+    const length = search.length;
+    if (length === 0)
+        return true;
+    let start = 0;
+    let end;
+    do {
+        end = text.indexOf(delimiter, start);
+        if (end === -1)
+            end = text.length;
+        if (end - start >= length && regionMatchesIgnoreCase(text, start, search, length)) {
+            return true;
+        }
+        start = end + 1;
+    } while (end !== text.length);
+    return false;
+}
+// --- Expr.dateTimeIsInRange --------------------------------------------------
+const TIME_CONTEXT_OFFSETS = { PREVIOUS: 1, CURRENT: 0 };
+const SATURDAY = 6;
+const SUNDAY = 7;
+const THURSDAY_OFFSET = 3; // 1970-01-01 was a Thursday
+// ISO day of week, Monday 1 to Sunday 7.
+const dayOfWeek = (day) => ((((day + THURSDAY_OFFSET) % DAYS_PER_WEEK) + DAYS_PER_WEEK) % DAYS_PER_WEEK) + 1;
+const startOfMonth = (year, month) => {
+    const months = year * MONTHS_PER_YEAR + (month - 1);
+    const y = Math.floor(months / MONTHS_PER_YEAR);
+    return daysFromCivil(y, months - y * MONTHS_PER_YEAR + 1, 1) * MS_PER_DAY;
+};
+// TimeRange.getTimeBounds: [beginning, end) in epoch millis. An enum name
+// TimeRange.valueOf / TimeContext.valueOf doesn't know (they are case
+// sensitive) throws.
+export function timeBounds(range, context, now) {
+    const offset = Object.hasOwn(TIME_CONTEXT_OFFSETS, context)
+        ? TIME_CONTEXT_OFFSETS[context]
+        : evaluationError(`No enum constant TimeContext.${context}`);
+    const day = epochDay(now);
+    const { year, month } = civilFromDays(day);
+    switch (range) {
+        case 'HOUR': {
+            const beginning = Math.floor(now / MS_PER_HOUR) * MS_PER_HOUR - offset * MS_PER_HOUR;
+            return [beginning, beginning + MS_PER_HOUR];
+        }
+        case 'DAY': {
+            const beginning = (day - offset) * MS_PER_DAY;
+            return [beginning, beginning + MS_PER_DAY];
+        }
+        case 'WEEK': {
+            const shifted = day - offset * DAYS_PER_WEEK;
+            const monday = shifted - (dayOfWeek(shifted) - 1);
+            return [monday * MS_PER_DAY, (monday + DAYS_PER_WEEK) * MS_PER_DAY];
+        }
+        case 'WEEK_DAY': {
+            const base = day - offset;
+            if (offset === 0) {
+                return dayOfWeek(base) >= SATURDAY ? [0, 0] : [base * MS_PER_DAY, (base + 1) * MS_PER_DAY];
+            }
+            const weekday = dayOfWeek(base);
+            const friday = weekday === SATURDAY ? base - 1 : weekday === SUNDAY ? base - 2 : base;
+            return [friday * MS_PER_DAY, (friday + 1) * MS_PER_DAY];
+        }
+        case 'MONTH':
+            return [startOfMonth(year, month - offset), startOfMonth(year, month - offset + 1)];
+        case 'YEAR':
+            return [
+                daysFromCivil(year - offset, 1, 1) * MS_PER_DAY,
+                daysFromCivil(year - offset + 1, 1, 1) * MS_PER_DAY,
+            ];
+        default:
+            return evaluationError(`No enum constant TimeRange.${range}`);
+    }
+}
+// TimeRange.valueOf(range).isInTimeRange(dateTime, TimeContext.valueOf(context)).
+export function dateTimeIsInRange(millis, range, context) {
+    const [beginning, end] = timeBounds(range, context, Date.now());
+    return millis >= beginning && millis < end;
+}

package/dist/db/identity.d.ts

@@ -4,7 +4,8 @@ export declare const TIMESTAMP = "TIMESTAMP";
 export declare const RECORD_FIELDS: readonly string[];
 export declare class RecordClock {
     private last;
-    next(): number;
+    private beyondSafe;
+    next(): number | string;
     observe(value: unknown): void;
 }
 export declare function withoutRecordFields(row: Row): Row;

package/dist/db/identity.js

@@ -13,19 +13,40 @@
 export const RECORD_ID = 'RECORD_ID';
 export const TIMESTAMP = 'TIMESTAMP';
 export const RECORD_FIELDS = [RECORD_ID, TIMESTAMP];
+const INTEGER_TEXT = /^-?\d+$/;
 // Hands out RECORD_ID/TIMESTAMP values: the current epoch millis, or one more
 // than the last value when that is not ahead of it (seeding a thousand rows
-// runs the counter a second or so ahead of the clock).
+// runs the counter a second or so ahead of the clock). Once a seed brings a
+// real server's id above 2^53 (as a string, which JSON can't carry exactly as
+// a number), later stamps continue from it as strings, so a new row is still
+// the newest one.
 export class RecordClock {
     last = 0;
+    beyondSafe;
     next() {
+        if (this.beyondSafe !== undefined) {
+            this.beyondSafe += 1n;
+            return String(this.beyondSafe);
+        }
         this.last = Math.max(Date.now(), this.last + 1);
         return this.last;
     }
     // Keeps later stamps above a value a seed row brought with it.
     observe(value) {
-        if (typeof value === 'number' && Number.isSafeInteger(value) && value > this.last) {
-            this.last = value;
+        if (typeof value === 'number' && Number.isSafeInteger(value)) {
+            if (value > this.last)
+                this.last = value;
+            return;
+        }
+        if (typeof value !== 'string' || !INTEGER_TEXT.test(value))
+            return;
+        const big = BigInt(value);
+        if (big <= BigInt(Number.MAX_SAFE_INTEGER)) {
+            if (Number(big) > this.last)
+                this.last = Number(big);
+        }
+        else if (this.beyondSafe === undefined || big > this.beyondSafe) {
+            this.beyondSafe = big;
         }
     }
 }

package/dist/db/legacyCriteria.d.ts

@@ -0,0 +1,7 @@
+import type { Row } from '../types.ts';
+type Predicate = (record: Row) => boolean;
+export declare function parseLegacyCriteria(criteria: string): {
+    predicate: Predicate;
+    fields: string[];
+};
+export {};

package/dist/db/legacyCriteria.js

@@ -0,0 +1,280 @@
+// 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 { CriteriaSyntaxError, parseGenesisDateTime, tokenizeCriteria, UnsupportedCriteriaError, } from "./criteriaTokens.js";
+import * as gsf from "./gsfExpr.js";
+function parseLiteral(token) {
+    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) {
+    const epoch = parseGenesisDateTime(value);
+    return epoch === null ? null : gsf.epochDay(epoch);
+}
+function compareByDay(cmp) {
+    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) {
+    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) => 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 = {
+    // 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 {
+    tokens;
+    pos = 0;
+    fields = new Set();
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    get position() {
+        return this.pos;
+    }
+    peek() {
+        return this.tokens[this.pos];
+    }
+    next() {
+        const token = this.tokens[this.pos];
+        this.pos += 1;
+        return token;
+    }
+    parseOr() {
+        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;
+    }
+    parseAnd() {
+        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;
+    }
+    parseNot() {
+        const next = this.peek();
+        if (next === '!' || next?.toUpperCase() === 'NOT') {
+            this.next();
+            const operand = this.parseNot();
+            return (record) => !operand(record);
+        }
+        return this.parseComparison();
+    }
+    parseComparison() {
+        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) => this.resolveValue(leftToken, record);
+        const resolveRight = (record) => this.resolveValue(rightToken, record);
+        return (record) => {
+            const a = resolveLeft(record);
+            const b = resolveRight(record);
+            switch (op) {
+                case '==':
+                case '=':
+                    return a === b;
+                case '!=':
+                case '<>':
+                    return a !== b;
+                case '>':
+                    return a > b;
+                case '>=':
+                    return a >= b;
+                case '<':
+                    return a < b;
+                case '<=':
+                    return a <= b;
+                default:
+                    return false;
+            }
+        };
+    }
+    noteField(token) {
+        if (parseLiteral(token) === undefined)
+            this.fields.add(token);
+    }
+    resolveValue(token, record) {
+        const literal = parseLiteral(token);
+        if (literal !== undefined)
+            return literal;
+        return record[token];
+    }
+    parseFunctionCall(name) {
+        this.next(); // consume '('
+        const args = [];
+        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 = (token, record) => this.resolveValue(token, record);
+        return (record) => 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) {
+    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/dist/db/ordering.d.ts

@@ -4,5 +4,7 @@ export interface OrderedField {
     field: string;
     descending: boolean;
 }
+export declare function compareRecordIds(a: unknown, b: unknown): number;
+export declare function byRecordId(a: Row, b: Row): number;
 export declare function rowComparator(fields: OrderedField[]): (a: Row, b: Row) => number;
 export declare function parseOrderBy(orderBy: string): OrderedField[];