@genesislcap/mock-server 15.51.1 → 15.53.0

package/dist/handlers/requestReply.js

@@ -1,23 +1,484 @@
-import { filterByCriteria } from "../db/criteria.js";
-import { NackError } from "../protocol/errors.js";
+// REQ_<NAME> -> REP_<NAME>, as GSF 8.15.29's request server answers it
+// (genesis-pal-requestserver). A request server is one of two kinds, and they
+// read a request differently:
+//
+// - criteria-only (`criteriaOnly`, criteriaOnlyRequest = true:
+//   EntityDbRequestReply.kt): REQUEST must be present but its fields are
+//   ignored; CRITERIA_MATCH, ORDER_BY, OFFSET / VIEW_NUMBER and MAX_ROWS run
+//   as one database read. Every reply carries MORE_ROWS, and NEXT_OFFSET while
+//   there are more (the SQL flavour, as the recordings show).
+// - plain (RequestReply.kt): REQUEST's fields select rows — exact values,
+//   `*` wildcards (WildcardFilter.kt), FIELD_FROM/FIELD_TO ranges — and an
+//   array REQUEST runs each object and concatenates the results. MAX_ROWS
+//   caps each one; OFFSET and ORDER_BY are ignored, and nothing says whether
+//   there are more rows.
+//
+// See the README's "Request servers" for every rule and its evidence.
+import { CriteriaSyntaxError, filterByCriteria, parseCriteria, parseGenesisDateTime, UnsupportedCriteriaError, } from "../db/criteria.js";
+import { withoutRecordFields } from "../db/identity.js";
+import { compareValues, parseOrderBy, rowComparator } from "../db/ordering.js";
+import { pkFieldsOf, primaryKeyIndexName, projectRow, requestReplyFieldNames, requestReplySourceSchema, } from "../db/schema.js";
+import { ErrorCode, NackError, nackPayload } from "../protocol/errors.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
+import { daoClassOf, viewEntityClassOf } from "../protocol/fieldTypes.js";
 import { ERROR_CODE } from "../protocol/messageTypes.js";
-import { resourceNotMappedNack } from "../protocol/msgNack.js";
-import { applyResourceAuth, requestingUser } from "./resourceAuth.js";
-// Keyed lookups: foundation-comms' createRequestMessage spreads RequestParams
-// onto the message, so REQUEST is a *top-level* field ({FIELD: value} pairs
-// naming the request server's index fields). A real request server only
-// returns rows matching them; '*' (Genesis's wildcard), null/undefined, and
-// '' mean "any". Arrays match any listed value.
-function matchesRequestFields(row, request) {
-    return Object.entries(request).every(([field, value]) => {
-        if (value === undefined || value === null || value === '*' || value === '')
-            return true;
-        if (Array.isArray(value))
-            return value.length === 0 || value.includes(row[field]);
-        return row[field] === value;
+import { resourceNotMappedNack, serviceMsgNack } from "../protocol/msgNack.js";
+import { applyResourceAuth, permittedQueryRow, requestingUser } from "./resourceAuth.js";
+// RequestReply.DEFAULT_MAXIMUM_ROWS: the rows a REP_ carries when neither the
+// request (DETAILS.MAX_ROWS) nor the server (rowLimit) says otherwise.
+const DEFAULT_ROW_LIMIT = 10000;
+// Request.DEFAULT_VIEW_NUMBER: 0 is "not paging by view".
+const DEFAULT_VIEW_NUMBER = 0;
+const WILDCARD = '*';
+// GSF answers an IllegalArgumentException from the request server (a failed
+// require(), a bad ORDER_BY) with StandardError REQUEST_FAILED and its message.
+const requestFailed = (text) => NackError.standard(ErrorCode.REQUEST_FAILED, text);
+// Anything else a criteria-only server hits — a REQUEST that doesn't
+// deserialize, a criteria Groovy can't compile — is INTERNAL_ERROR with the
+// code's own text ("Unexpected server error"), the message only in the log.
+const internalError = () => NackError.standard(ErrorCode.INTERNAL_ERROR);
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+// An integer DETAILS value. Jackson coerces numeric strings and truncates
+// fractions; anything else fails to deserialize the request (strict: a
+// criteria-only server's Request<Unit>) or reads as absent (lenient: a plain
+// server's GenesisSet.getInteger).
+function readInteger(value, strictness) {
+    if (value === undefined || value === null)
+        return undefined;
+    const number = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+    if (typeof number === 'number' && Number.isFinite(number))
+        return Math.trunc(number);
+    if (strictness === 'strict')
+        throw internalError();
+    return undefined;
+}
+const readText = (value) => (typeof value === 'string' ? value : '');
+function sourceOf(requestReply, config, store) {
+    const name = requestReply.source;
+    const schema = requestReplySourceSchema(requestReply, config, store);
+    return {
+        name,
+        fields: new Map(schema.fields.map((field) => [field.name, field])),
+        pkFields: store.getPkFields(name),
+    };
+}
+function isView(name, config, store) {
+    return store.views.has(name) || !!config.views?.[name];
+}
+// The generated entity class the rows are (definition.source.entityType):
+// the DAO for a table, the view entity for a view.
+function parametricTypeOf(name, config, store) {
+    return isView(name, config, store) ? viewEntityClassOf(name) : daoClassOf(name);
+}
+const byPrimaryKey = (source) => source.pkFields.map((field) => ({ field, descending: false }));
+// CRITERIA_MATCH against the entity. A malformed one fails as `onSyntaxError`
+// says (the two server kinds differ). A criteria naming a field the entity
+// doesn't have matches nothing: GSF evaluates it outside the database, where
+// the unknown variable never compares true (recorded: REPLY: []). A call to a
+// function this grammar doesn't model may be valid Groovy, so it still fails
+// open (logged), as everywhere else in the engine.
+function criteriaFilter(criteria, source, onSyntaxError) {
+    if (criteria.trim() === '')
+        return { kind: 'all' };
+    try {
+        const { predicate, fields } = parseCriteria(criteria);
+        if (fields.some((field) => !source.fields.has(field)))
+            return { kind: 'none' };
+        return { kind: 'match', predicate };
+    }
+    catch (error) {
+        if (error instanceof CriteriaSyntaxError)
+            throw onSyntaxError(error);
+        if (error instanceof UnsupportedCriteriaError) {
+            console.warn(`[mock-server] Unsupported CRITERIA_MATCH syntax, ignoring filter: ${criteria}`, error);
+            return { kind: 'all' };
+        }
+        throw error;
+    }
+}
+function applyCriteria(rows, filter) {
+    if (filter.kind === 'all')
+        return rows;
+    if (filter.kind === 'none')
+        return [];
+    return rows.filter((row) => {
+        try {
+            return filter.predicate(row);
+        }
+        catch {
+            return false;
+        }
     });
 }
+// --- ORDER_BY ----------------------------------------------------------------
+// The index names ORDER_BY may use instead of fields (OrderSpec.kt
+// replaceIndexWithFields): 'PK', the primary key's index and the table's
+// declared indexes — a view's, its base table's.
+function orderIndexes(source, config, store) {
+    const indexes = new Map([['PK', source.pkFields]]);
+    const tableName = isView(source.name, config, store)
+        ? (store.views.get(source.name) ?? config.views?.[source.name])?.base
+        : source.name;
+    const table = tableName ? config.tables?.[tableName] : undefined;
+    if (table && tableName) {
+        indexes.set(primaryKeyIndexName(tableName, table), pkFieldsOf(table));
+        for (const index of table.indexes ?? [])
+            indexes.set(index.name, index.fields);
+    }
+    return indexes;
+}
+// DETAILS.ORDER_BY on a criteria-only server: fields, each optionally ASC or
+// DESC ('INT_FIELD DESC', 'A, B DESC'). An index name (or 'PK') that isn't
+// also a field stands for its fields. A malformed string, or a field the
+// entity doesn't have, is REQUEST_FAILED with GSF's text
+// (GetByCriteriaOperation.kt prints the Kotlin list of OrderedFields).
+function orderingOf(orderBy, source, config, store) {
+    if (orderBy.trim() === '')
+        return undefined;
+    let fields;
+    try {
+        fields = parseOrderBy(orderBy);
+    }
+    catch (error) {
+        throw requestFailed(error.message);
+    }
+    const indexes = orderIndexes(source, config, store);
+    const namesIndex = ({ field }) => !source.fields.has(field) && indexes.has(field);
+    if (fields.some(namesIndex)) {
+        fields = fields.flatMap((ordered) => namesIndex(ordered)
+            ? indexes.get(ordered.field).map((field) => ({ field, descending: ordered.descending }))
+            : [ordered]);
+    }
+    const missing = fields.filter(({ field }) => !source.fields.has(field));
+    if (missing.length > 0) {
+        const listed = missing
+            .map(({ field, descending }) => `${descending ? 'Desc' : 'Asc'}(field=${field})`)
+            .join(', ');
+        throw requestFailed(`Order fields [${listed}] not found on table ${source.name}`);
+    }
+    return fields;
+}
+// EntityDbRequestReply.data(): one row past MAX_ROWS says there are more.
+// NEXT_OFFSET is the request's OFFSET plus how far the read got (offsetShift),
+// or that alone when no OFFSET was sent. A view-numbered page can't tell when
+// it was read through a filter (isNextTokenKnowable false): no MORE_ROWS then.
+function pageOf(rows, maxRows, offset, offsetShift, nextKnowable) {
+    if (rows.length === 0)
+        return { rows: [], moreRows: false };
+    if (!nextKnowable)
+        return { rows };
+    if (rows.length > maxRows) {
+        return {
+            rows: rows.slice(0, maxRows),
+            nextOffset: offset === undefined ? offsetShift : offset + offsetShift,
+            moreRows: true,
+        };
+    }
+    return { rows, moreRows: false };
+}
+function criteriaOnlyReply(resourceName, requestReply, message, config, store, user) {
+    // The request deserializes as Request<Unit>: without a REQUEST object
+    // (missing, null, nested in DETAILS) Jackson throws and the reply is
+    // INTERNAL_ERROR (recorded: KotlinInvalidNullException in the server log).
+    if (!isPlainObject(message.REQUEST))
+        throw internalError();
+    const details = isPlainObject(message.DETAILS) ? message.DETAILS : {};
+    const offset = readInteger(details.OFFSET, 'strict');
+    const viewNumber = readInteger(details.VIEW_NUMBER, 'strict') ?? DEFAULT_VIEW_NUMBER;
+    const maxRows = readInteger(details.MAX_ROWS, 'strict') ?? requestReply.rowLimit ?? DEFAULT_ROW_LIMIT;
+    // EntityDbRequestReply.process's require()s, in order.
+    if (offset !== undefined && viewNumber !== DEFAULT_VIEW_NUMBER) {
+        throw requestFailed(`You must not supply both offset and viewNumber != ${DEFAULT_VIEW_NUMBER}, ` +
+            'unable to combine offset and page request');
+    }
+    if (offset !== undefined && offset < 0) {
+        throw requestFailed('When providing an offset, you must provide an offset greater than or equal to 0');
+    }
+    if (viewNumber < 0) {
+        throw requestFailed('When providing a view number, You must provide a view number greater than or equal to 0');
+    }
+    if (maxRows <= 0)
+        throw requestFailed('maxRows should be greater than 0');
+    const source = sourceOf(requestReply, config, store);
+    const criteria = criteriaFilter(readText(details.CRITERIA_MATCH), source, internalError);
+    const ordering = orderingOf(readText(details.ORDER_BY), source, config, store);
+    const byView = viewNumber !== DEFAULT_VIEW_NUMBER;
+    // A read that skips rows (an OFFSET past 0, or a view number) is a paged
+    // read: GetByCriteriaOperation orders it by the primary key when ORDER_BY
+    // doesn't say. An unpaged read comes in the table's own order, oldest
+    // first (recorded).
+    const paged = byView || (offset ?? 0) > 0;
+    if (criteria.kind === 'none' && paged) {
+        // Criteria evaluated outside the database can't be paged
+        // (PagingSpec.pagingNotSupported).
+        throw requestFailed('Paging not supported on lazy criteria evaluation');
+    }
+    let rows = applyCriteria(store.getResourceRows(source.name), criteria);
+    const order = ordering ?? (paged ? byPrimaryKey(source) : undefined);
+    if (order)
+        rows = [...rows].sort(rowComparator(order));
+    const fieldNames = requestReplyFieldNames(requestReply, config, store);
+    let page;
+    if (!requestReply.filter && !requestReply.auth) {
+        // Eager: the database does the paging, reading one row past the page.
+        const start = byView ? maxRows * (viewNumber - 1) : (offset ?? 0);
+        const read = rows.slice(start, start + maxRows + 1);
+        page = pageOf(read, maxRows, offset, maxRows, true);
+        page.rows = page.rows.map((row) => projectRow(row, fieldNames));
+    }
+    else {
+        // Lazy: the filter and permissions run on the rows the database returns,
+        // so the read goes on until one row past the page has passed them, and
+        // NEXT_OFFSET says how many rows that took. A view-numbered read gets one
+        // database page and keeps what passes.
+        const window = byView
+            ? rows.slice(maxRows * (viewNumber - 1), maxRows * viewNumber)
+            : rows.slice(offset ?? 0);
+        const kept = [];
+        let readCount = 0;
+        for (const row of window) {
+            readCount += 1;
+            if (requestReply.filter && !requestReply.filter(row))
+                continue;
+            const permitted = permittedQueryRow(row, requestReply.auth, user, fieldNames);
+            if (!permitted)
+                continue;
+            kept.push(permitted);
+            if (kept.length > maxRows)
+                break;
+        }
+        page = pageOf(kept, maxRows, offset, readCount - 1, !byView);
+    }
+    return {
+        REPLY: page.rows,
+        PARAMETRIC_TYPE: parametricTypeOf(source.name, config, store),
+        MESSAGE_TYPE: `REP_${resourceName}`,
+        ...(byView && page.rows.length > 0 ? { NEXT_VIEW: viewNumber + 1 } : {}),
+        ...(page.nextOffset !== undefined ? { NEXT_OFFSET: page.nextOffset } : {}),
+        ...(page.moreRows !== undefined ? { MORE_ROWS: page.moreRows } : {}),
+    };
+}
+// --- plain servers (RequestReply.kt) ----------------------------------------
+// A REQUEST value as the field's type (DataTypeConverter.convert). Fails for a
+// value the type can't take.
+function convertValue(value, field) {
+    const fail = () => {
+        throw requestFailed(`Unable to convert ${String(value)} to ${field.type} for ${field.name}`);
+    };
+    switch (field.type) {
+        case 'INT':
+        case 'SHORT':
+        case 'LONG':
+        case 'NANO_TIMESTAMP':
+        case 'DOUBLE':
+        case 'BIGDECIMAL': {
+            const number = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+            return typeof number === 'number' && Number.isFinite(number) ? number : fail();
+        }
+        case 'BOOLEAN':
+            if (typeof value === 'boolean')
+                return value;
+            if (typeof value === 'string' && /^(true|false)$/i.test(value)) {
+                return value.toLowerCase() === 'true';
+            }
+            return fail();
+        case 'DATE':
+        case 'DATETIME': {
+            // yyyyMMdd as well as the criteria formats (yyyyMMdd-HH:mm[:ss[.SSS]],
+            // ISO-8601, epoch millis).
+            const day = typeof value === 'string' ? /^(\d{4})(\d{2})(\d{2})$/.exec(value) : null;
+            if (day)
+                return Date.UTC(Number(day[1]), Number(day[2]) - 1, Number(day[3]));
+            return parseGenesisDateTime(value) ?? fail();
+        }
+        case 'STRING':
+        case 'ENUM':
+        case 'RAW':
+            return typeof value === 'object' ? fail() : String(value);
+        default:
+            return value;
+    }
+}
+// What Kotlin's toString() makes of a row value, for wildcard matching: a
+// Double keeps its fraction ("2.0"), a date prints as ISO-8601, null is "null".
+function kotlinString(value, field) {
+    if (value === undefined || value === null)
+        return 'null';
+    if (typeof value === 'number') {
+        if ((field?.type === 'DATE' || field?.type === 'DATETIME') && Number.isFinite(value)) {
+            return new Date(value).toISOString();
+        }
+        if (field?.type === 'DOUBLE' && Number.isInteger(value))
+            return value.toFixed(1);
+    }
+    return String(value);
+}
+// WildcardFilter.matchesWildCard: '*' at both ends is "contains", at the start
+// "ends with", at the end "starts with" — all case-sensitive, after trimming
+// every leading and trailing '*' ('*' alone matches anything, null included).
+// A '*' only in the middle matches nothing.
+function matchesWildcard(text, wildcard) {
+    const starts = wildcard.startsWith(WILDCARD);
+    const ends = wildcard.endsWith(WILDCARD);
+    const trimmed = wildcard.replace(/^\*+|\*+$/g, '');
+    if (starts && ends)
+        return text.includes(trimmed);
+    return (starts && text.endsWith(trimmed)) || (ends && text.startsWith(trimmed));
+}
+const RANGE_SUFFIXES = ['_FROM', '_TO'];
+// tryRemoveRangeSuffix: a key that isn't a field may name one's range end.
+function fieldOfKey(key, source) {
+    if (source.fields.has(key))
+        return key;
+    let field = key;
+    for (const suffix of RANGE_SUFFIXES) {
+        if (field.endsWith(suffix))
+            field = field.slice(0, -suffix.length);
+    }
+    return field;
+}
+// One REQUEST object as a row predicate (RequestReplyBuilderImpl
+// buildFieldPredicates + FieldPredicate.buildPredicate, then the
+// WildcardFilter): undefined when it can't match anything (NoData).
+// - A string containing '*' is a wildcard on that field.
+// - Any other value must equal the field's (converted to its type; null
+//   matches null, and nothing on a non-null field).
+// - FIELD_FROM and FIELD_TO together are an inclusive range; either alone,
+//   or a value it can't convert, matches nothing.
+// - A field the entity doesn't have matches nothing — unless its value is
+//   null (always true of an unknown field) or a wildcard (it reads as "null").
+function requestPredicate(request, source) {
+    const checks = [];
+    const byField = new Map();
+    for (const [key, value] of Object.entries(request)) {
+        if (typeof value === 'string' && value.includes(WILDCARD)) {
+            const field = source.fields.get(key);
+            checks.push((row) => matchesWildcard(kotlinString(row[key], field), value));
+            continue;
+        }
+        const field = fieldOfKey(key, source);
+        byField.set(field, [...(byField.get(field) ?? []), [key, value]]);
+    }
+    for (const [name, values] of byField) {
+        const field = source.fields.get(name);
+        if (!field) {
+            if (values[0][1] === null)
+                continue;
+            return undefined;
+        }
+        if (values.length === 1) {
+            const [key, value] = values[0];
+            if (key !== name)
+                return undefined; // an incomplete range
+            if (value === null) {
+                if (!field.nullable)
+                    return undefined;
+                checks.push((row) => row[name] === undefined || row[name] === null);
+                continue;
+            }
+            const expected = convertValue(value, field);
+            checks.push((row) => compareValues(row[name], expected) === 0);
+            continue;
+        }
+        if (values.length > 2)
+            return undefined;
+        const lookup = new Map(values);
+        const range = [lookup.get(`${name}_FROM`), lookup.get(`${name}_TO`)].map((value) => {
+            if (value === undefined || value === null)
+                return undefined;
+            try {
+                return convertValue(value, field);
+            }
+            catch {
+                return undefined;
+            }
+        });
+        const [from, to] = range;
+        if (from === undefined || to === undefined)
+            return undefined;
+        checks.push((row) => {
+            const value = row[name];
+            if (value === undefined || value === null)
+                return false;
+            return compareValues(value, from) >= 0 && compareValues(value, to) <= 0;
+        });
+    }
+    return (row) => checks.every((check) => check(row));
+}
+function plainReply(resourceName, requestReply, message, config, store, user) {
+    const details = isPlainObject(message.DETAILS) ? message.DETAILS : {};
+    const rowLimit = readInteger(details.MAX_ROWS, 'lenient') ?? requestReply.rowLimit ?? DEFAULT_ROW_LIMIT;
+    // Flowable.take(-1)'s IllegalArgumentException.
+    if (rowLimit < 0)
+        throw requestFailed(`count >= 0 required but it was ${rowLimit}`);
+    // REQUEST is top level only (DETAILS.REQUEST is never read). An array runs
+    // each of its objects in turn; anything else is one request, empty when
+    // missing.
+    const requests = Array.isArray(message.REQUEST)
+        ? message.REQUEST.filter((request) => request !== null && request !== undefined).map((request) => (isPlainObject(request) ? request : {}))
+        : [isPlainObject(message.REQUEST) ? message.REQUEST : {}];
+    const source = sourceOf(requestReply, config, store);
+    // Here a criteria that doesn't compile fails the whole request with its
+    // message (handleThrowable: REQUEST_FAILED).
+    const criteria = criteriaFilter(readText(details.CRITERIA_MATCH), source, (error) => requestFailed(error.message));
+    const fieldNames = requestReplyFieldNames(requestReply, config, store);
+    // The rows come through the table's (or the view's root table's) primary
+    // key, as getBulk reads them (recorded: auth's RIGHT, in CODE order).
+    const ordered = [...store.getResourceRows(source.name)].sort(rowComparator(byPrimaryKey(source)));
+    const candidates = requestReply.filter ? ordered.filter(requestReply.filter) : ordered;
+    const reply = requests.flatMap((request) => {
+        const matches = requestPredicate(request, source);
+        if (!matches)
+            return [];
+        const rows = [];
+        for (const row of applyCriteria(candidates.filter(matches), criteria)) {
+            if (rows.length >= rowLimit)
+                break;
+            const permitted = permittedQueryRow(row, requestReply.auth, user, fieldNames);
+            if (permitted)
+                rows.push(permitted);
+        }
+        return rows;
+    });
+    // In RequestReply.kt's order: SOURCE_REF straight after MESSAGE_TYPE
+    // (connection.reply overwrites it with the same value, keeping its place).
+    return {
+        MESSAGE_TYPE: `REP_${resourceName}`,
+        SOURCE_REF: message.SOURCE_REF,
+        PARAMETRIC_TYPE: parametricTypeOf(source.name, config, store),
+        REPLY: reply,
+    };
+}
+// --- resolvers (custom request servers) -------------------------------------
+function resolverReply(resourceName, requestReply, message, store, user) {
+    // The resolver owns REQUEST interpretation entirely — no generic
+    // REQUEST/CRITERIA filtering is applied on top, since a computed reply's
+    // rows needn't echo the request's fields at all. Its rows go out exactly as
+    // returned.
+    const request = (typeof message.REQUEST === 'object' && message.REQUEST) || message.DETAILS?.REQUEST || {};
+    const rows = requestReply.resolver({ request, message, user, store });
+    return {
+        MESSAGE_TYPE: `REP_${resourceName}`,
+        REPLY: applyResourceAuth(rows, requestReply.auth, user),
+    };
+}
+// A failed request is a MSG_NACK. A NackError keeps its items. Anything else
+// is what each kind of server makes of an unexpected exception: a custom
+// request server's GENERIC_ERROR with the message (AbstractCustomReqRep.kt), a
+// plain one's REQUEST_FAILED with the message (RequestReply.kt
+// handleThrowable), a criteria-only one's INTERNAL_ERROR.
+function failureReply(error, requestReply) {
+    if (error instanceof NackError)
+        return serviceMsgNack(error.errors, error.warnings);
+    const message = error instanceof Error ? error.message : String(error);
+    const code = requestReply.resolver
+        ? ErrorCode.GENERIC_ERROR
+        : requestReply.criteriaOnly
+            ? ErrorCode.INTERNAL_ERROR
+            : ErrorCode.REQUEST_FAILED;
+    const nack = NackError.standard(code, code === ErrorCode.INTERNAL_ERROR ? undefined : message || undefined);
+    return serviceMsgNack(nack.errors, nack.warnings);
+}
 export function handleRequestReply(message, connection, config, store) {
     const resourceName = message.MESSAGE_TYPE.replace(/^REQ_/, '');
     const requestReply = config.requestReplies?.[resourceName];
@@ -35,21 +496,55 @@ export function handleRequestReply(message, connection, config, store) {
             : resourceNotMappedNack(resourceName));
         return;
     }
+    if (isLegacyFidelity(config)) {
+        legacyRequestReply(resourceName, requestReply, message, connection, store);
+        return;
+    }
+    const user = requestingUser(connection);
+    let reply;
+    try {
+        if (requestReply.resolver) {
+            reply = resolverReply(resourceName, requestReply, message, store, user);
+        }
+        else if (requestReply.criteriaOnly) {
+            reply = criteriaOnlyReply(resourceName, requestReply, message, config, store, user);
+        }
+        else {
+            reply = plainReply(resourceName, requestReply, message, config, store, user);
+        }
+    }
+    catch (error) {
+        reply = failureReply(error, requestReply);
+    }
+    connection.reply(message, reply);
+}
+// --- fidelity: 'legacy' ------------------------------------------------------
+// What this engine answered up to 15.47: REQUEST from the top level or
+// DETAILS, '*', null and '' matching anything, an array value matching any of
+// its values, CRITERIA_MATCH failing open, every row (no MAX_ROWS, OFFSET or
+// ORDER_BY), no PARAMETRIC_TYPE or MORE_ROWS, rows without RECORD_ID and
+// TIMESTAMP, and errors as a REP_ with ERROR.
+function matchesLegacyRequestFields(row, request) {
+    return Object.entries(request).every(([field, value]) => {
+        if (value === undefined || value === null || value === WILDCARD || value === '')
+            return true;
+        if (Array.isArray(value))
+            return value.length === 0 || value.includes(row[field]);
+        return row[field] === value;
+    });
+}
+function legacyRequestReply(resourceName, requestReply, message, connection, store) {
     const user = requestingUser(connection);
     const request = (typeof message.REQUEST === 'object' && message.REQUEST) || message.DETAILS?.REQUEST || {};
     try {
         let rows;
         if (requestReply.resolver) {
-            // Computed reply (date calcs, holiday roll, composite lookups...): the
-            // resolver owns REQUEST interpretation entirely — no generic REQUEST/
-            // CRITERIA filtering is applied on top, since a computed reply's rows
-            // needn't echo the request's fields at all.
             rows = requestReply.resolver({ request, message, user, store });
         }
         else {
             rows = store.getResourceRows(requestReply.source);
             if (Object.keys(request).length > 0) {
-                rows = rows.filter((row) => matchesRequestFields(row, request));
+                rows = rows.filter((row) => matchesLegacyRequestFields(row, request));
             }
             const criteria = message.DETAILS?.CRITERIA_MATCH ?? message.CRITERIA_MATCH;
             if (criteria)
@@ -57,16 +552,10 @@ export function handleRequestReply(message, connection, config, store) {
             if (requestReply.filter)
                 rows = rows.filter(requestReply.filter);
         }
-        rows = applyResourceAuth(rows, requestReply.auth, user);
-        connection.reply(message, {
-            MESSAGE_TYPE: `REP_${resourceName}`,
-            REPLY: rows,
-        });
+        rows = applyResourceAuth(rows, requestReply.auth, user).map(withoutRecordFields);
+        connection.reply(message, { MESSAGE_TYPE: `REP_${resourceName}`, REPLY: rows });
     }
     catch (error) {
-        const errors = error instanceof NackError
-            ? error.errors
-            : [{ CODE: ERROR_CODE.VALIDATION_ERROR, TEXT: error.message }];
-        connection.reply(message, { MESSAGE_TYPE: `REP_${resourceName}`, ERROR: errors });
+        connection.reply(message, { MESSAGE_TYPE: `REP_${resourceName}`, ...nackPayload(error, true) });
     }
 }

package/dist/handlers/resourceAuth.d.ts

@@ -3,3 +3,4 @@ import type { ResourceAuthDef, RequestingUser, Row } from '../types.ts';
 export declare function requestingUser(connection: Connection): RequestingUser;
 export declare function hiddenFields(auth: ResourceAuthDef | undefined, user: RequestingUser): Set<string>;
 export declare function applyResourceAuth(rows: Row[], auth: ResourceAuthDef | undefined, user: RequestingUser): Row[];
+export declare function permittedQueryRow(row: Row, auth: ResourceAuthDef | undefined, user: RequestingUser, fieldNames: string[] | undefined): Row | undefined;

package/dist/handlers/resourceAuth.js

@@ -1,3 +1,4 @@
+import { projectRow } from "../db/schema.js";
 // The identity a resource-level auth hook (rowFilter/hideFields) sees for the
 // requesting connection. userName is undefined for unauthenticated
 // connections — possible when requireAuth is off, or pre-login.
@@ -25,3 +26,16 @@ export function applyResourceAuth(rows, auth, user) {
     }
     return result;
 }
+// One dataserver row as this user sees it: undefined when rowFilter rejects
+// it, else only the query's columns (projectRow: fieldNames from
+// queryFieldNames) minus the hidden ones. rowFilter sees the whole row, so a
+// filter may read a column the query doesn't expose.
+export function permittedQueryRow(row, auth, user, fieldNames) {
+    if (auth?.rowFilter && !auth.rowFilter(row, user))
+        return undefined;
+    const projected = projectRow(row, fieldNames);
+    const hidden = hiddenFields(auth, user);
+    if (hidden.size === 0)
+        return projected;
+    return Object.fromEntries(Object.entries(projected).filter(([field]) => !hidden.has(field)));
+}

package/dist/handlers/resources.js

@@ -1,3 +1,4 @@
+import { crudEventNames } from "../db/schema.js";
 import { MESSAGE_TYPE } from "../protocol/messageTypes.js";
 // GenesisResources (foundation-comms/src/resources/genesis/genesis.ts) gates
 // every datasource/request-reply/commit call on this list first — an empty
@@ -16,6 +17,8 @@ function deriveResources(config) {
     }
     const eventNames = new Set([
         ...Object.keys(config.eventHandlers ?? {}),
+        // The generic CRUD events tables register through TableDef.events.
+        ...crudEventNames(config),
         // Events served only by eventSchemas + defaultEventHandler still need to
         // be discoverable, or the client-side resource gate blocks them before
         // the commit is ever sent.

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { createMockServer, type MockServer } from './server.ts';
 export { launchStack, type LaunchStackOptions, type LaunchedStack } from './launch.ts';
 export { Store } from './db/store.ts';
-export { NackError, type NackErrorInput, type NackErrorEntry } from './protocol/errors.ts';
+export { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from './db/identity.ts';
+export { ErrorCode, NackError, statusCodeFor, type ErrorCodeName, type GenesisErrorType, type NackErrorEntry, type NackErrorInput, type NackErrorOptions, } from './protocol/errors.ts';
 export { compileCriteria, filterByCriteria, type Predicate } from './db/criteria.ts';
-export type { AntiJoinDef, AuthConfig, AuthUser, BroadcastFn, BroadcastTableChangeFn, EventHandler, EventHandlerCtx, EventHandlerResult, EventSchemaOverride, FidelityMode, FieldMetadata, GenesisMessage, HttpRouteDef, JoinDef, MockServerConfig, OnMessageCtx, OnMessageHook, QueryDef, RequestingUser, RequestReplyDef, RequestReplyResolverCtx, ResourceAuthDef, ResourceItem, Row, SocketLike, SsoIdentityProvider, TableDef, ViewDef, } from './types.ts';
+export type { AntiJoinDef, AuthConfig, AuthUser, BroadcastFn, BroadcastTableChangeFn, CrudEventVerb, EventHandler, EventHandlerCtx, EventHandlerResult, EventSchemaOverride, FidelityMode, FieldDef, FieldMetadata, GeneratedFieldDef, GenesisFieldType, GenesisMessage, HttpRouteDef, IndexDef, JoinDef, MockServerConfig, OnMessageCtx, OnMessageHook, QueryDef, RequestingUser, RequestReplyDef, RequestReplyResolverCtx, ResourceAuthDef, ResourceItem, Row, SequenceFormat, SocketLike, SsoIdentityProvider, TableDef, ViewDef, } from './types.ts';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { createMockServer } from "./server.js";
 export { launchStack } from "./launch.js";
 export { Store } from "./db/store.js";
-export { NackError } from "./protocol/errors.js";
+export { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from "./db/identity.js";
+export { ErrorCode, NackError, statusCodeFor, } from "./protocol/errors.js";
 export { compileCriteria, filterByCriteria } from "./db/criteria.js";

package/dist/protocol/connection.d.ts

@@ -9,6 +9,8 @@ export interface Subscription {
     held?: Set<string>;
     maxRows?: number;
     maxView?: number;
+    fieldNames?: string[];
+    queueInsert?: (key: string, stamped: Row, row: Row) => boolean;
 }
 export declare class Connection {
     readonly ws: SocketLike;