@genesislcap/mock-server 15.51.1 → 15.53.0

package/dist/protocol/gsfSchemas.js

@@ -0,0 +1,423 @@
+// The parts of META_REQUEST / JSON_SCHEMA_REQUEST replies that describe the
+// platform's own message classes rather than a project's fields: the same for
+// every event, every dataserver and every request server. Copied from GSF
+// 8.15.29 recordings (test/conformance/recordings/showcase-real/meta-event,
+// json-schema-{event,dataserver,request-server}.json); the conformance suite
+// keeps them in step.
+const MESSAGE_CORE = 'global.genesis.message.core';
+const EVENT_REPLY = `${MESSAGE_CORE}.event.EventReply`;
+const EVENT_ACK = `${EVENT_REPLY}.EventAck`;
+const EVENT_APPROVABLE_ACK = `${EVENT_REPLY}.EventApprovableAck`;
+const EVENT_NACK = `${EVENT_REPLY}.EventNack`;
+const APPROVAL_ENTITY_DETAILS = `${MESSAGE_CORE}.event.ApprovalEntityDetails`;
+const APPROVAL_TYPE = `${MESSAGE_CORE}.event.ApprovalType`;
+const GENESIS_ERROR = `${MESSAGE_CORE}.error.GenesisError`;
+const STANDARD_ERROR = `${MESSAGE_CORE}.error.StandardError`;
+const HTTP_STATUS_CODE = `${MESSAGE_CORE}.HttpStatusCode`;
+const DATA_LOGON_REPLY = `${MESSAGE_CORE}.dataserver.DataLogonReply`;
+const LOGON_ACK = `${DATA_LOGON_REPLY}.LogonAck`;
+const LOGON_NACK = `${DATA_LOGON_REPLY}.LogonNack`;
+const INVALID_INDEX_NACK = `${LOGON_NACK}.InvalidIndexNack`;
+const INVALID_INDEX = `${INVALID_INDEX_NACK}.Index`;
+const QUERY_UPDATE = `${DATA_LOGON_REPLY}.QueryUpdate`;
+export const QUERY_ROW = `${MESSAGE_CORE}.dataserver.QueryRow`;
+const ROW_DETAILS = `${MESSAGE_CORE}.dataserver.RowDetails`;
+const ROW_OPERATION = `${MESSAGE_CORE}.dataserver.RowOperation`;
+const KOTLIN_STRING = 'kotlin.String';
+const KOTLIN_LIST = 'kotlin.collections.List';
+const APPROVAL_TYPES = ['NEW', 'UPDATE', 'REMOVE', 'UNKNOWN'];
+const DEFAULT_APPROVAL_MESSAGE = 'Your request was successful and has been submitted for approval';
+// global.genesis.message.core.HttpStatusCode, in declaration order.
+const HTTP_STATUS_CODES = [
+    '100 Continue',
+    '101 Switching Protocols',
+    '102 Processing',
+    '103 Early Hints',
+    '200 OK',
+    '201 Created',
+    '202 Accepted',
+    '203 Non-Authoritative Information',
+    '204 No Content',
+    '205 Reset Content',
+    '206 Partial Content',
+    '207 Multi-Status',
+    '208 Already Reported',
+    '226 IM Used',
+    '300 Multiple Choice',
+    '301 Moved Permanently',
+    '302 Found',
+    '303 See Other',
+    '304 Not Modified',
+    '305 Use Proxy',
+    '307 Temporary Redirect',
+    '308 Permanent Redirect',
+    '400 Bad Request',
+    '401 Unauthorized',
+    '402 Payment Required',
+    '403 Forbidden',
+    '404 Not Found',
+    '405 Method Not Allowed',
+    '406 Not Acceptable',
+    '407 Proxy Authentication Required',
+    '408 Request Timeout',
+    '409 Conflict',
+    '410 Gone',
+    '411 Length Required',
+    '412 Precondition Failed',
+    '413 Payload Too Large',
+    '414 URI Too Long',
+    '415 Unsupported Media Type',
+    '416 Range Not Satisfiable',
+    '417 Expectation Failed',
+    '418 I Am A Teapot',
+    '418 Enhance Your Calm',
+    '421 Misdirected Request',
+    '422 Unprocessable Entity',
+    '423 Locked',
+    '424 Failed Dependency',
+    '425 Too Early',
+    '426 Upgrade Required',
+    '428 Precondition Required',
+    '429 Too Many Requests',
+    '431 Request Header Fields Too Large',
+    '444 No Response',
+    '449 RetryWith',
+    '450 Blocked By Windows Parental Controls',
+    '451 Unavailable For Legal Reasons',
+    '499 Client Closed Request',
+    '500 Internal Server Error',
+    '501 Not Implemented',
+    '502 Bad Gateway',
+    '503 Service Unavailable',
+    '504 Gateway Timeout',
+    '505 HTTP Version Not Supported',
+    '506 Variant Also Negotiates',
+    '507 Insufficient Storage',
+    '508 Loop Detected',
+    '509 Bandwidth Limit Exceeded',
+    '510 Not Extended',
+    '511 Network Authentication Required',
+    '598 Network Read Timeout Error',
+    '599 Network Connection Timeout Error',
+];
+// --- event META: DETAILS.REPLY -----------------------------------------------
+// The META shape of a class property (EventMeta's MetaField), for the reply
+// classes below.
+function metaMessageType(constant) {
+    return {
+        NAME: 'MESSAGE_TYPE',
+        TITLE: 'Message Type',
+        DESCRIPTION: 'Message Type',
+        NULLABLE: false,
+        TYPE: 'STRING',
+        JSON_TYPE: 'string',
+        OPTIONAL: false,
+        READ_ONLY: false,
+        CONSTANT: constant,
+        GENESIS_TYPE: null,
+    };
+}
+const META_SOURCE_REF = {
+    NAME: 'SOURCE_REF',
+    TITLE: 'Source Ref',
+    DESCRIPTION: 'Source Ref',
+    NULLABLE: false,
+    TYPE: 'STRING',
+    JSON_TYPE: 'string',
+    OPTIONAL: false,
+    READ_ONLY: false,
+    GENESIS_TYPE: null,
+};
+function metaString(name, optional) {
+    return {
+        NAME: name,
+        DESCRIPTION: KOTLIN_STRING,
+        NULLABLE: false,
+        TYPE: 'STRING',
+        JSON_TYPE: 'string',
+        OPTIONAL: optional,
+        READ_ONLY: false,
+        GENESIS_TYPE: null,
+    };
+}
+function metaEnum(name, enumClass, values, optional) {
+    return {
+        NAME: name,
+        DESCRIPTION: enumClass,
+        NULLABLE: false,
+        VALID_VALUES: values,
+        DEFAULT_VALUE: values[0],
+        ENUM_CLASS: enumClass,
+        TYPE: 'ENUM',
+        JSON_TYPE: 'string',
+        OPTIONAL: optional,
+        READ_ONLY: false,
+        ...(optional ? { DEFAULT: values[0] } : {}),
+        GENESIS_TYPE: null,
+    };
+}
+function metaList(name, valueType) {
+    return {
+        NAME: name,
+        DESCRIPTION: KOTLIN_LIST,
+        NULLABLE: false,
+        VALUE_TYPE: valueType,
+        UNIQUE: false,
+        TYPE: 'ARRAY',
+        JSON_TYPE: 'array',
+        OPTIONAL: true,
+        READ_ONLY: false,
+        GENESIS_TYPE: null,
+    };
+}
+function metaReference(reference) {
+    return { NULLABLE: false, REFERENCE: reference, TYPE: 'OBJECT', JSON_TYPE: 'object' };
+}
+function metaClass(name, description, properties) {
+    return { NAME: name, DESCRIPTION: description, PROPERTIES: properties };
+}
+// DETAILS.REPLY of every event's META: what EVENT_ACK, EVENT_APPROVABLE_ACK
+// and EVENT_NACK carry. Frozen copies would be shared across replies, so this
+// builds a fresh object each time.
+export function eventReplyMeta() {
+    return {
+        NAME: 'EVENT_REPLY',
+        DESCRIPTION: EVENT_REPLY,
+        FIELD: [],
+        DEFINITIONS: {
+            [EVENT_ACK]: metaClass('EVENT_ACK', EVENT_ACK, [
+                metaMessageType('EVENT_ACK'),
+                META_SOURCE_REF,
+                metaList('GENERATED', {
+                    NULLABLE: false,
+                    KEY_TYPE: { NULLABLE: false, TYPE: 'STRING', JSON_TYPE: 'string' },
+                    VALUE_TYPE: { TYPE: 'ANY', JSON_TYPE: '{}', NULLABLE: true, DEFAULT_VALUE: null },
+                    TYPE: 'MAP',
+                    JSON_TYPE: 'object',
+                }),
+            ]),
+            [EVENT_APPROVABLE_ACK]: metaClass('EVENT_APPROVABLE_ACK', EVENT_APPROVABLE_ACK, [
+                metaMessageType('EVENT_APPROVABLE_ACK'),
+                META_SOURCE_REF,
+                metaString('ADDITIONAL_DETAILS', true),
+                metaString('APPROVAL_MESSAGE', true),
+                metaEnum('APPROVAL_TYPE', APPROVAL_TYPE, APPROVAL_TYPES, true),
+                metaList('GENERATED', metaReference(APPROVAL_ENTITY_DETAILS)),
+                {
+                    ...metaString('DEFAULT_APPROVAL_MESSAGE', true),
+                    READ_ONLY: true,
+                    DEFAULT: DEFAULT_APPROVAL_MESSAGE,
+                    GENESIS_TYPE: null,
+                },
+            ]),
+            [APPROVAL_ENTITY_DETAILS]: metaClass('APPROVAL_ENTITY_DETAILS', APPROVAL_ENTITY_DETAILS, [
+                metaEnum('APPROVAL_TYPE', APPROVAL_TYPE, APPROVAL_TYPES, false),
+                metaString('ENTITY_ID', false),
+                metaString('ENTITY_TABLE', false),
+            ]),
+            [EVENT_NACK]: metaClass('EVENT_NACK', EVENT_NACK, [
+                metaMessageType('EVENT_NACK'),
+                META_SOURCE_REF,
+                metaList('ERROR', metaReference(GENESIS_ERROR)),
+                metaList('WARNING', metaReference(GENESIS_ERROR)),
+            ]),
+            [GENESIS_ERROR]: metaClass('GENESIS_ERROR', GENESIS_ERROR, [
+                metaString('CODE', false),
+                metaEnum('STATUS_CODE', HTTP_STATUS_CODE, HTTP_STATUS_CODES, true),
+                metaString('TEXT', false),
+            ]),
+        },
+    };
+}
+// --- JSON schemas of the reply classes ---------------------------------------
+const SCHEMA_SOURCE_REF = { type: 'string', title: 'Source Ref', description: 'Source Ref' };
+const SCHEMA_STRING = { type: 'string', description: KOTLIN_STRING };
+const SCHEMA_INT = { type: 'integer', description: 'kotlin.Int' };
+const SCHEMA_BOOLEAN = { type: 'boolean', description: 'kotlin.Boolean' };
+const SCHEMA_NULLABLE_STRING = {
+    oneOf: [{ type: 'null' }, { type: 'string' }],
+    description: KOTLIN_STRING,
+};
+const ref = (definition) => `#/$defs/${definition}`;
+function schemaList(definition) {
+    return {
+        type: 'array',
+        items: { type: 'object', $ref: ref(definition) },
+        description: KOTLIN_LIST,
+    };
+}
+function schemaClass(description, properties, required, additionalProperties = false) {
+    return { type: 'object', description, properties, additionalProperties, required };
+}
+function errorClass(description) {
+    return schemaClass(description, {
+        CODE: SCHEMA_STRING,
+        STATUS_CODE: { type: 'string', enum: HTTP_STATUS_CODES, description: HTTP_STATUS_CODE },
+        TEXT: SCHEMA_STRING,
+    }, ['CODE', 'TEXT'], true);
+}
+const ENVELOPE_REQUIRED = ['MESSAGE_TYPE', 'SOURCE_REF'];
+// OUTBOUND of every event's JSON schema: the EventReply union.
+export function eventReplySchema() {
+    const approvalType = { type: 'string', enum: APPROVAL_TYPES, description: APPROVAL_TYPE };
+    return {
+        description: EVENT_REPLY,
+        type: 'object',
+        oneOf: [
+            { $ref: ref(EVENT_ACK) },
+            { $ref: ref(EVENT_APPROVABLE_ACK) },
+            { $ref: ref(EVENT_NACK) },
+        ],
+        $defs: {
+            [EVENT_ACK]: schemaClass(EVENT_ACK, {
+                MESSAGE_TYPE: { const: 'EVENT_ACK' },
+                SOURCE_REF: SCHEMA_SOURCE_REF,
+                GENERATED: { type: 'array', items: { type: 'object' }, description: KOTLIN_LIST },
+            }, ENVELOPE_REQUIRED),
+            [EVENT_APPROVABLE_ACK]: schemaClass(EVENT_APPROVABLE_ACK, {
+                MESSAGE_TYPE: { const: 'EVENT_APPROVABLE_ACK' },
+                SOURCE_REF: SCHEMA_SOURCE_REF,
+                ADDITIONAL_DETAILS: SCHEMA_STRING,
+                APPROVAL_MESSAGE: SCHEMA_STRING,
+                APPROVAL_TYPE: approvalType,
+                GENERATED: schemaList(APPROVAL_ENTITY_DETAILS),
+                DEFAULT_APPROVAL_MESSAGE: {
+                    type: 'string',
+                    readOnly: true,
+                    default: DEFAULT_APPROVAL_MESSAGE,
+                    description: KOTLIN_STRING,
+                },
+            }, ENVELOPE_REQUIRED),
+            [APPROVAL_ENTITY_DETAILS]: schemaClass(APPROVAL_ENTITY_DETAILS, { APPROVAL_TYPE: approvalType, ENTITY_ID: SCHEMA_STRING, ENTITY_TABLE: SCHEMA_STRING }, ['APPROVAL_TYPE', 'ENTITY_ID', 'ENTITY_TABLE']),
+            [EVENT_NACK]: schemaClass(EVENT_NACK, {
+                MESSAGE_TYPE: { const: 'EVENT_NACK' },
+                SOURCE_REF: SCHEMA_SOURCE_REF,
+                ERROR: schemaList(GENESIS_ERROR),
+                WARNING: schemaList(GENESIS_ERROR),
+            }, ENVELOPE_REQUIRED),
+            [GENESIS_ERROR]: errorClass(GENESIS_ERROR),
+        },
+    };
+}
+// The envelope properties of an event's INBOUND schema (EventMeta's
+// getMessageJsonSchema), around the event's own DETAILS.
+export function eventInboundProperties(eventName, details) {
+    const nullableString = { oneOf: [{ type: 'string' }, { type: 'null' }] };
+    return {
+        MESSAGE_TYPE: { const: eventName, description: 'Message type', type: 'string' },
+        SOURCE_REF: { description: 'Source reference', type: 'string' },
+        USER_NAME: { description: 'User name', type: 'string' },
+        VALIDATE: { type: 'boolean' },
+        IGNORE_WARNINGS: { type: 'boolean' },
+        REQUIRES_APPROVAL: { readOnly: true, type: 'boolean' },
+        APPROVAL_KEY: nullableString,
+        APPROVAL_MESSAGE: nullableString,
+        REASON: nullableString,
+        SCHEDULABLE: { readOnly: true, const: false, type: 'boolean' },
+        DETAILS: details,
+    };
+}
+export const GENESIS_META_SCHEMA = 'https://genesis.global/schema/v1/meta/genesis';
+// INBOUND of a dataserver's JSON schema: the DATA_LOGON message.
+export function dataLogonSchema(queryName) {
+    return {
+        $schema: 'https://json-schema.org/draft/2019-09/schema',
+        description: `GPAL Dataserver definition for ${queryName}`,
+        type: 'object',
+        properties: {
+            MESSAGE_TYPE: { const: 'DATA_LOGON' },
+            SOURCE_REF: { type: 'string' },
+            USER_NAME: { type: 'string' },
+            DETAILS: {
+                type: 'object',
+                properties: {
+                    CRITERIA_MATCH: SCHEMA_NULLABLE_STRING,
+                    DATASOURCE_NAME: { const: queryName },
+                    FIELDS: SCHEMA_NULLABLE_STRING,
+                    MAX_ROWS: SCHEMA_INT,
+                    MAX_VIEW: SCHEMA_INT,
+                    MOVING_VIEW: SCHEMA_BOOLEAN,
+                    ORDER_BY: SCHEMA_NULLABLE_STRING,
+                    REVERSE: SCHEMA_BOOLEAN,
+                    VIEW_NUMBER: SCHEMA_INT,
+                },
+                additionalProperties: false,
+                required: ['DATASOURCE_NAME'],
+            },
+        },
+        additionalProperties: false,
+        required: ['MESSAGE_TYPE', 'SOURCE_REF', 'USER_NAME', 'DETAILS'],
+    };
+}
+// OUTBOUND of a dataserver's JSON schema: the DataLogonReply union, with the
+// query's own fields in $defs[...QueryRow]. foundation-forms' filters read
+// that definition (filters/filters.ts).
+export function dataLogonReplySchema(rowProperties) {
+    return {
+        description: DATA_LOGON_REPLY,
+        type: 'object',
+        oneOf: [
+            { $ref: ref(LOGON_ACK) },
+            { $ref: ref(LOGON_NACK) },
+            { $ref: ref(INVALID_INDEX_NACK) },
+            { $ref: ref(QUERY_UPDATE) },
+        ],
+        $defs: {
+            [LOGON_ACK]: schemaClass(LOGON_ACK, {
+                MESSAGE_TYPE: { const: 'LOGON_ACK' },
+                SOURCE_REF: SCHEMA_SOURCE_REF,
+                SEQUENCE_ID: SCHEMA_INT,
+            }, ENVELOPE_REQUIRED),
+            [LOGON_NACK]: schemaClass(LOGON_NACK, {
+                MESSAGE_TYPE: { const: 'LOGON_NACK' },
+                SOURCE_REF: SCHEMA_SOURCE_REF,
+                ERROR: schemaList(STANDARD_ERROR),
+                WARNING: schemaList(STANDARD_ERROR),
+            }, ENVELOPE_REQUIRED),
+            [STANDARD_ERROR]: errorClass(STANDARD_ERROR),
+            [INVALID_INDEX_NACK]: schemaClass(INVALID_INDEX_NACK, {
+                MESSAGE_TYPE: { const: 'INVALID_INDEX_NACK' },
+                SOURCE_REF: SCHEMA_SOURCE_REF,
+                AVAILABLE_INDEXES: schemaList(INVALID_INDEX),
+                ERROR: schemaList(STANDARD_ERROR),
+                WARNING: schemaList(STANDARD_ERROR),
+            }, ['MESSAGE_TYPE', 'SOURCE_REF', 'AVAILABLE_INDEXES', 'ERROR']),
+            [INVALID_INDEX]: schemaClass(INVALID_INDEX, {
+                FIELDS: { type: 'array', items: { type: 'string' }, description: KOTLIN_LIST },
+                NAME: SCHEMA_STRING,
+            }, ['FIELDS', 'NAME']),
+            [QUERY_UPDATE]: schemaClass(QUERY_UPDATE, {
+                MESSAGE_TYPE: { const: 'QUERY_UPDATE' },
+                SOURCE_REF: SCHEMA_SOURCE_REF,
+                MORE_ROWS: SCHEMA_BOOLEAN,
+                ROW: schemaList(QUERY_ROW),
+                ROWS_COUNT: { oneOf: [{ type: 'null' }, { type: 'integer' }], description: 'kotlin.Int' },
+                SEQUENCE_ID: SCHEMA_INT,
+            }, ['MESSAGE_TYPE', 'SOURCE_REF', 'ROW', 'SEQUENCE_ID']),
+            [QUERY_ROW]: schemaClass(QUERY_ROW, {
+                DETAILS: { type: 'object', $ref: ref(ROW_DETAILS), description: ROW_DETAILS },
+                ...rowProperties,
+            }, ['DETAILS']),
+            [ROW_DETAILS]: schemaClass(ROW_DETAILS, {
+                OPERATION: {
+                    type: 'string',
+                    enum: ['INSERT', 'MODIFY', 'DELETE'],
+                    description: ROW_OPERATION,
+                },
+                // Verbatim from GSF 8.15.29, which serializes this one property as a
+                // string instead of a schema. Kept so the mock fails wherever the
+                // real server does; no client reads it.
+                ROW_REF: 'type = string\ndescription = kotlin.String\n',
+            }, ['OPERATION', 'ROW_REF']),
+        },
+    };
+}
+// The DETAILS a request server accepts besides REQUEST.
+export const REQUEST_DETAILS_SCHEMA = {
+    properties: {
+        VIEW_NUMBER: { description: 'The page / view to request', type: 'integer' },
+        MAX_ROWS: { minimum: 1, description: 'Maximum number of rows to return', type: 'integer' },
+        CRITERIA_MATCH: { description: 'Additional criteria for request server', type: 'string' },
+    },
+    type: 'object',
+};

package/dist/protocol/messageTypes.d.ts

@@ -11,6 +11,7 @@ export declare const MESSAGE_TYPE: {
     readonly HEARTBEAT_PONG: "HEARTBEAT_PONG";
     readonly DATA_LOGON: "DATA_LOGON";
     readonly LOGON_ACK: "LOGON_ACK";
+    readonly LOGON_NACK: "LOGON_NACK";
     readonly DATA_LOGOFF: "DATA_LOGOFF";
     readonly LOGOFF_ACK: "LOGOFF_ACK";
     readonly QUERY_UPDATE: "QUERY_UPDATE";

package/dist/protocol/messageTypes.js

@@ -18,6 +18,7 @@ export const MESSAGE_TYPE = {
     HEARTBEAT_PONG: 'HEARTBEAT_PONG',
     DATA_LOGON: 'DATA_LOGON',
     LOGON_ACK: 'LOGON_ACK',
+    LOGON_NACK: 'LOGON_NACK',
     DATA_LOGOFF: 'DATA_LOGOFF',
     LOGOFF_ACK: 'LOGOFF_ACK',
     QUERY_UPDATE: 'QUERY_UPDATE',

package/dist/protocol/msgNack.d.ts

@@ -1,4 +1,6 @@
 import type { Row } from '../types.ts';
+import type { NackErrorEntry } from './errors.ts';
+export declare function serviceMsgNack(errors: NackErrorEntry[], warnings?: NackErrorEntry[]): Row;
 export declare function resourceNotMappedNack(resourceName: string | undefined): Row;
 export declare function nonExistentSubscriptionNack(): Row;
 export declare function subscriptionAlreadyExistsNack(): Row;

package/dist/protocol/msgNack.js

@@ -1,4 +1,14 @@
 import { MESSAGE_TYPE } from "./messageTypes.js";
+// A service's own MSG_NACK (genesis-messages MsgNack): how a request server
+// answers a request it fails, GSF 8.15.x. Unlike the router's frame below, its
+// items are GenesisErrors (@type, a string CODE, TEXT, STATUS_CODE), there is
+// a WARNING list and no DETAILS. Recorded: a criteria-only REQ_ without
+// REQUEST answers {WARNING: [], ERROR: [{'@type': 'StandardError', CODE:
+// 'INTERNAL_ERROR', TEXT: 'Unexpected server error', STATUS_CODE: '500
+// Internal Server Error'}], MESSAGE_TYPE: 'MSG_NACK'}.
+export function serviceMsgNack(errors, warnings = []) {
+    return { WARNING: warnings, ERROR: errors, MESSAGE_TYPE: MESSAGE_TYPE.MSG_NACK };
+}
 const HTTP_NOT_FOUND = 404;
 const HTTP_CONFLICT = 409;
 // The real router's rejection frame (genesis-router MsgType.Outbound.Error,

package/dist/protocol/rowUpdate.d.ts

@@ -1,4 +1,6 @@
-import type { Row } from '../types.ts';
+import type { Store } from '../db/store.ts';
+import type { MockServerConfig, Row } from '../types.ts';
 export type RowOperation = 'INSERT' | 'MODIFY' | 'DELETE';
-export declare function stampRow(row: Row, rowRef: unknown, operation: RowOperation): Row;
-export declare function stampRows(rows: Row[], getRowRef: (row: Row) => unknown, operation: RowOperation): Row[];
+export declare function stampRow(row: Row, rowRef: unknown, operation: RowOperation, legacy?: boolean): Row;
+export declare function rowRefFor(config: MockServerConfig, store: Store, resourceName: string, row: Row): unknown;
+export declare function dataserverRow(projected: Row, source: Row, fields: string[] | undefined): Row;

package/dist/protocol/rowUpdate.js

@@ -1,17 +1,35 @@
-// Stamps each row with DETAILS.OPERATION/ROW_REF, the only fields the client's
-// dataServerResultFilter uses to distinguish INSERT/MODIFY/DELETE on a QUERY_UPDATE
-// (both for the initial snapshot and later unsolicited pushes on the same
-// SOURCE_REF — the envelope is otherwise identical). OPERATION must be exactly
-// 'INSERT' | 'MODIFY' | 'DELETE'; anything else is silently dropped client-side.
-// rowRef comes from Store.getRowRef — a single pk value, or the joined
-// composite key for multi-field pks.
-export function stampRow(row, rowRef, operation) {
-    return {
-        ...row,
-        ROW_REF: rowRef,
-        DETAILS: { OPERATION: operation, ROW_REF: rowRef },
-    };
+import { RECORD_FIELDS, withoutRecordFields } from "../db/identity.js";
+import { isLegacyFidelity } from "./fidelity.js";
+// Stamps a row with DETAILS.OPERATION/ROW_REF, the only fields the client's
+// dataServerResultFilter uses to distinguish INSERT/MODIFY/DELETE on a
+// QUERY_UPDATE (both for the snapshot pages and later unsolicited pushes on
+// the same SOURCE_REF — the envelope is otherwise identical). OPERATION must
+// be exactly 'INSERT' | 'MODIFY' | 'DELETE'; anything else is silently
+// dropped client-side. GSF puts ROW_REF in DETAILS only; clients copy it onto
+// the row themselves (`row.DETAILS[rowId] ?? row[rowId]`). Legacy mode also
+// set it on the row itself, as this engine did up to 15.47.
+export function stampRow(row, rowRef, operation, legacy = false) {
+    const DETAILS = { OPERATION: operation, ROW_REF: rowRef };
+    return legacy ? { ...row, ROW_REF: rowRef, DETAILS } : { ...row, DETAILS };
 }
-export function stampRows(rows, getRowRef, operation) {
-    return rows.map((row) => stampRow(row, getRowRef(row), operation));
+// DETAILS.ROW_REF for a row of a dataserver's source: the record's RECORD_ID
+// as a string, as GSF sends it (a view row's comes from its base row). Legacy
+// mode used the pk value, or the '|'-joined composite key. Read per call, so
+// flipping `fidelity` on a running server applies to the next push.
+export function rowRefFor(config, store, resourceName, row) {
+    return isLegacyFidelity(config)
+        ? store.getRowRef(resourceName, row)
+        : store.getRecordRef(resourceName, row);
+}
+// RECORD_ID and TIMESTAMP on a dataserver row: the real dataserver never
+// sends them unless the query's fields block names them. `projected` is the
+// row already narrowed to the query's columns; `source` the stored row the
+// values come from.
+export function dataserverRow(projected, source, fields) {
+    const row = { ...withoutRecordFields(projected) };
+    for (const field of RECORD_FIELDS) {
+        if (fields?.includes(field) && source[field] !== undefined)
+            row[field] = source[field];
+    }
+    return row;
 }

package/dist/protocol/schemaValidation.d.ts

@@ -0,0 +1,11 @@
+import type { NackErrorInput } from './errors.ts';
+type Schema = Record<string, any>;
+export interface SchemaError {
+    keyword: string;
+    instanceLocation: string;
+    property?: string;
+    message: string;
+}
+export declare function validateSchema(schema: Schema, value: unknown, location?: string): SchemaError[];
+export declare function schemaFieldErrors(errors: SchemaError[]): NackErrorInput[];
+export {};