@genesislcap/mock-server 15.48.0 → 15.50.0

package/dist/handlers/requestReply.js

@@ -1,6 +1,8 @@
 import { filterByCriteria } from "../db/criteria.js";
 import { NackError } from "../protocol/errors.js";
+import { isLegacyFidelity } from "../protocol/fidelity.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
@@ -20,15 +22,17 @@ export function handleRequestReply(message, connection, config, store) {
     const resourceName = message.MESSAGE_TYPE.replace(/^REQ_/, '');
     const requestReply = config.requestReplies?.[resourceName];
     if (!requestReply || (!requestReply.resolver && !requestReply.source)) {
-        connection.reply(message, {
-            MESSAGE_TYPE: `REP_${resourceName}`,
-            ERROR: [
-                {
-                    CODE: ERROR_CODE.UNKNOWN_RESOURCE,
-                    TEXT: `Unknown request-reply resource: ${resourceName}`,
-                },
-            ],
-        });
+        connection.reply(message, isLegacyFidelity(config)
+            ? {
+                MESSAGE_TYPE: `REP_${resourceName}`,
+                ERROR: [
+                    {
+                        CODE: ERROR_CODE.UNKNOWN_RESOURCE,
+                        TEXT: `Unknown request-reply resource: ${resourceName}`,
+                    },
+                ],
+            }
+            : resourceNotMappedNack(resourceName));
         return;
     }
     const user = requestingUser(connection);

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export { launchStack, type LaunchStackOptions, type LaunchedStack } from './laun
 export { Store } from './db/store.ts';
 export { NackError, type NackErrorInput, type NackErrorEntry } from './protocol/errors.ts';
 export { compileCriteria, filterByCriteria, type Predicate } from './db/criteria.ts';
-export type { AntiJoinDef, AuthConfig, AuthUser, BroadcastFn, BroadcastTableChangeFn, EventHandler, EventHandlerCtx, EventHandlerResult, EventSchemaOverride, 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, 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';

package/dist/protocol/connection.d.ts

@@ -5,6 +5,10 @@ export interface Subscription {
     getRowRef: (row: Row) => unknown;
     predicate: Predicate;
     sequenceId: number;
+    pending?: Map<string, Row>;
+    held?: Set<string>;
+    maxRows?: number;
+    maxView?: number;
 }
 export declare class Connection {
     readonly ws: SocketLike;

package/dist/protocol/fidelity.d.ts

@@ -0,0 +1,2 @@
+import type { MockServerConfig } from '../types.ts';
+export declare function isLegacyFidelity(config: MockServerConfig): boolean;

package/dist/protocol/fidelity.js

@@ -0,0 +1,6 @@
+// True when the config opts back into the envelopes this engine sent up to
+// 15.47 (see FidelityMode in types.ts). Read per message, like every other
+// config field, so flipping it on a running server takes effect immediately.
+export function isLegacyFidelity(config) {
+    return config.fidelity === 'legacy';
+}

package/dist/protocol/messageTypes.d.ts

@@ -10,10 +10,17 @@ export declare const MESSAGE_TYPE: {
     readonly HEARTBEAT_PING: "HEARTBEAT_PING";
     readonly HEARTBEAT_PONG: "HEARTBEAT_PONG";
     readonly DATA_LOGON: "DATA_LOGON";
+    readonly LOGON_ACK: "LOGON_ACK";
     readonly DATA_LOGOFF: "DATA_LOGOFF";
+    readonly LOGOFF_ACK: "LOGOFF_ACK";
     readonly QUERY_UPDATE: "QUERY_UPDATE";
+    readonly MORE_ROWS: "MORE_ROWS";
+    readonly MORE_ROWS_ACK: "MORE_ROWS_ACK";
     readonly META_REQUEST: "META_REQUEST";
+    readonly FEATURE_ACK: "FEATURE_ACK";
     readonly JSON_SCHEMA_REQUEST: "JSON_SCHEMA_REQUEST";
+    readonly JSON_SCHEMA_FEATURE_ACK: "JSON_SCHEMA_FEATURE_ACK";
+    readonly MSG_NACK: "MSG_NACK";
     readonly RESOURCES_REQUEST: "RESOURCES_REQUEST";
     readonly RESOURCES_REQUEST_ACK: "RESOURCES_REQUEST_ACK";
     readonly RESOURCES_REQUEST_NACK: "RESOURCES_REQUEST_NACK";

package/dist/protocol/messageTypes.js

@@ -17,10 +17,19 @@ export const MESSAGE_TYPE = {
     HEARTBEAT_PING: 'HEARTBEAT_PING',
     HEARTBEAT_PONG: 'HEARTBEAT_PONG',
     DATA_LOGON: 'DATA_LOGON',
+    LOGON_ACK: 'LOGON_ACK',
     DATA_LOGOFF: 'DATA_LOGOFF',
+    LOGOFF_ACK: 'LOGOFF_ACK',
     QUERY_UPDATE: 'QUERY_UPDATE',
+    MORE_ROWS: 'MORE_ROWS',
+    MORE_ROWS_ACK: 'MORE_ROWS_ACK',
     META_REQUEST: 'META_REQUEST',
+    FEATURE_ACK: 'FEATURE_ACK',
     JSON_SCHEMA_REQUEST: 'JSON_SCHEMA_REQUEST',
+    JSON_SCHEMA_FEATURE_ACK: 'JSON_SCHEMA_FEATURE_ACK',
+    // The router's generic rejection (unknown resource, missing or duplicate
+    // dataserver subscription) — see protocol/msgNack.ts.
+    MSG_NACK: 'MSG_NACK',
     RESOURCES_REQUEST: 'RESOURCES_REQUEST',
     RESOURCES_REQUEST_ACK: 'RESOURCES_REQUEST_ACK',
     RESOURCES_REQUEST_NACK: 'RESOURCES_REQUEST_NACK',

package/dist/protocol/msgNack.d.ts

@@ -0,0 +1,4 @@
+import type { Row } from '../types.ts';
+export declare function resourceNotMappedNack(resourceName: string | undefined): Row;
+export declare function nonExistentSubscriptionNack(): Row;
+export declare function subscriptionAlreadyExistsNack(): Row;

package/dist/protocol/msgNack.js

@@ -0,0 +1,36 @@
+import { MESSAGE_TYPE } from "./messageTypes.js";
+const HTTP_NOT_FOUND = 404;
+const HTTP_CONFLICT = 409;
+// The real router's rejection frame (genesis-router MsgType.Outbound.Error,
+// GSF 8.15.x): an integer HTTP status CODE, and the status line as
+// STATUS_CODE, repeated under DETAILS. It is a different family from the
+// handler-level EVENT_NACK/REP_ errors (string CODEs such as
+// VALIDATION_ERROR) — the router sends it before a request ever reaches a
+// service. foundation-comms' socket REJECTS the pending promise on MSG_NACK
+// (connect/socket.ts), where a typed reply carrying ERROR resolves it.
+function routerNack(code, reason, text) {
+    const STATUS_CODE = `${code} ${reason}`;
+    return {
+        MESSAGE_TYPE: MESSAGE_TYPE.MSG_NACK,
+        ERROR: [{ CODE: code, TEXT: text, STATUS_CODE }],
+        DETAILS: { ERROR: text, STATUS_CODE },
+    };
+}
+// The router resolves every message to a resource name first and answers this
+// when no service serves it: DETAILS.DATASOURCE_NAME for DATA_LOGON, the name
+// after REQ_ for request servers, DETAILS.FEATURE for META_REQUEST /
+// JSON_SCHEMA_REQUEST, and the MESSAGE_TYPE itself for commit events. A
+// missing name is the empty string, as on the real router.
+export function resourceNotMappedNack(resourceName) {
+    return routerNack(HTTP_NOT_FOUND, 'Not Found', `Resource ${resourceName ?? ''} is not mapped to a service`);
+}
+// MORE_ROWS or DATA_LOGOFF naming a SOURCE_REF this connection has no live
+// subscription on (never logged on, already logged off, or another socket's).
+export function nonExistentSubscriptionNack() {
+    return routerNack(HTTP_NOT_FOUND, 'Not Found', 'Dataserver subscription does not exist');
+}
+// DATA_LOGON on a SOURCE_REF that already has a live subscription on this
+// connection. The existing subscription is left untouched.
+export function subscriptionAlreadyExistsNack() {
+    return routerNack(HTTP_CONFLICT, 'Conflict', 'Subscription exists for source ref. If using HTTP, try HTTP GET instead of HTTP POST');
+}

package/dist/protocol/router.js

@@ -1,11 +1,12 @@
 import { handleLogin, handleLogout } from "../handlers/auth.js";
 import { handleCommitEvent } from "../handlers/commitEvent.js";
-import { handleDataLogon, handleDataLogoff } from "../handlers/dataLogon.js";
+import { handleDataLogon, handleDataLogoff, handleMoreRows } from "../handlers/dataLogon.js";
 import { handleHeartbeat } from "../handlers/heartbeat.js";
 import { handleJsonSchemaRequest } from "../handlers/jsonSchema.js";
 import { handleMetaRequest } from "../handlers/meta.js";
 import { handleRequestReply } from "../handlers/requestReply.js";
 import { handleResourcesRequest } from "../handlers/resources.js";
+import { isLegacyFidelity } from "./fidelity.js";
 import { MESSAGE_TYPE, ERROR_CODE, isCommitEvent, isRequestReply } from "./messageTypes.js";
 // Message types a connection may send before authenticating when the OPT-IN
 // auth gate (config.auth.requireAuth = true) is enabled. Everything else
@@ -13,7 +14,11 @@ import { MESSAGE_TYPE, ERROR_CODE, isCommitEvent, isRequestReply } from "./messa
 // requires the connection to have logged in over WS — or to present a
 // SESSION_AUTH_TOKEN this server issued (over either transport).
 // RESOURCES_REQUEST is allowed pre-auth so resource discovery can't deadlock
-// a client that fetches it before (or while) logging in.
+// a client that fetches it before (or while) logging in. MORE_ROWS, like
+// DATA_LOGOFF, can only act on a subscription the connection already opened
+// through the gate (logout clears them), so it answers with its own precise
+// 404 rather than a NOT_LOGGED_ON echo — except under fidelity: 'legacy',
+// which keeps the 15.47 gate (see isPreAuth).
 //
 // The gate is OFF by default because real clients can't be assumed to
 // satisfy it: browser frame captures show that after logging in over
@@ -29,6 +34,11 @@ const PRE_AUTH_MESSAGE_TYPES = new Set([
     MESSAGE_TYPE.DATA_LOGOFF,
     MESSAGE_TYPE.RESOURCES_REQUEST,
 ]);
+function isPreAuth(messageType, config) {
+    if (messageType === MESSAGE_TYPE.MORE_ROWS)
+        return !isLegacyFidelity(config);
+    return PRE_AUTH_MESSAGE_TYPES.has(messageType);
+}
 function ensureAuthenticated(message, connection, tokens) {
     if (connection.authenticated)
         return true;
@@ -69,9 +79,7 @@ export function routeMessage(message, connection, config, store, ctx, tokens = n
     // away; the gate itself only applies to data traffic.
     ensureAuthenticated(message, connection, tokens);
     const requireAuth = config.auth?.requireAuth ?? false;
-    if (requireAuth &&
-        !PRE_AUTH_MESSAGE_TYPES.has(message.MESSAGE_TYPE) &&
-        !connection.authenticated) {
+    if (requireAuth && !isPreAuth(message.MESSAGE_TYPE, config) && !connection.authenticated) {
         return replyNotLoggedOn(message, connection);
     }
     switch (message.MESSAGE_TYPE) {
@@ -84,7 +92,9 @@ export function routeMessage(message, connection, config, store, ctx, tokens = n
         case MESSAGE_TYPE.DATA_LOGON:
             return handleDataLogon(message, connection, config, store);
         case MESSAGE_TYPE.DATA_LOGOFF:
-            return handleDataLogoff(message, connection);
+            return handleDataLogoff(message, connection, config);
+        case MESSAGE_TYPE.MORE_ROWS:
+            return handleMoreRows(message, connection, config);
         case MESSAGE_TYPE.META_REQUEST:
             return handleMetaRequest(message, connection, config, store);
         case MESSAGE_TYPE.JSON_SCHEMA_REQUEST:

package/dist/server.js

@@ -1,9 +1,11 @@
 import http from 'node:http';
 import { WebSocketServer } from 'ws';
 import { Store } from "./db/store.js";
+import { pendingKey } from "./handlers/dataLogon.js";
 import { createHttpRequestListener } from "./handlers/http.js";
 import { applyResourceAuth, requestingUser } from "./handlers/resourceAuth.js";
 import { Connection } from "./protocol/connection.js";
+import { isLegacyFidelity } from "./protocol/fidelity.js";
 import { routeMessage } from "./protocol/router.js";
 import { stampRow } from "./protocol/rowUpdate.js";
 export function createMockServer(config) {
@@ -21,8 +23,9 @@ export function createMockServer(config) {
     // grids reflect inserts/amends/deletes without the client re-querying.
     // DELETE rows are PK-only stubs (see broadcastTableChange), so a criteria
     // predicate would evaluate against missing fields and drop the push —
-    // leaving the client holding a ghost row. Deliver every DELETE instead: a
-    // client that never held that ROW_REF ignores it.
+    // leaving the client holding a ghost row. A DELETE therefore skips the
+    // predicate; which subscriptions it reaches is decided by what each client
+    // holds (trackClientView), or, in legacy mode, it reaches all of them.
     // 'error' is kept distinct from 'no-match' because only a clean no-match may
     // be turned into a DELETE below; a broken predicate must not evict rows.
     function evaluateSubscription(subscription, sourceRef, row) {
@@ -49,6 +52,53 @@ export function createMockServer(config) {
             return null;
         return operation === 'MODIFY' ? 'DELETE' : null;
     }
+    // Decides what one 'gsf' subscription's client gets for a live change, from
+    // what that client holds — as the real dataserver does with its client
+    // index — and keeps the subscription's pending/held sets up to date.
+    // `operation` is the change after the query filter and CRITERIA_MATCH
+    // (a MODIFY that left them arrives as a DELETE); the user's rowFilter is
+    // applied here too, so leaving it counts as leaving the subscription.
+    // - A row still waiting for MORE_ROWS (past the page, or past MAX_VIEW) is
+    //   never pushed: the client has never seen it. A change replaces the
+    //   waiting copy in place, so the page later delivers current values; a
+    //   DELETE drops it.
+    // - A held row gets the MODIFY, or a DELETE when it is gone or out of scope.
+    // - A row the client doesn't hold that is (now) in scope is pushed as an
+    //   INSERT and becomes held: a brand-new row, or one a MODIFY brought back
+    //   into the criteria. Out of scope, the client is told nothing.
+    // An INSERT is pushed even when the view already holds MAX_VIEW rows; the
+    // real server would also evict the oldest row in the same frame (moving
+    // view), which this engine doesn't, so the view can grow past MAX_VIEW.
+    // A row without a ROW_REF can't be matched to anything the client holds,
+    // so changes to it aren't pushed.
+    // Returns the operation to push, or null to push nothing.
+    function trackClientView(subscription, connection, query, operation, row, rowRef) {
+        const key = pendingKey(rowRef);
+        const pending = subscription.pending;
+        const held = subscription.held;
+        if (key === undefined || !pending || !held)
+            return null;
+        const permitted = operation === 'DELETE'
+            ? undefined
+            : applyResourceAuth([row], query?.auth, requestingUser(connection))[0];
+        if (pending.has(key)) {
+            if (permitted)
+                pending.set(key, stampRow(permitted, rowRef, 'INSERT'));
+            else
+                pending.delete(key);
+            return null;
+        }
+        if (held.has(key)) {
+            if (permitted)
+                return 'MODIFY';
+            held.delete(key);
+            return 'DELETE';
+        }
+        if (!permitted)
+            return null;
+        held.add(key);
+        return 'INSERT';
+    }
     const broadcast = (resourceName, operation, row) => {
         const query = config.queries?.[resourceName];
         // The query's own filter (where-clause equivalent) applies to live pushes
@@ -57,7 +107,6 @@ export function createMockServer(config) {
         // rather than dropped: a swallowed removal leaves the client rendering the
         // row with its stale pre-modify values until a full reload. An INSERT
         // outside the filter is simply dropped (the client never held it).
-        // DELETEs always go through: dropping an unknown ROW_REF is a no-op.
         let effectiveOperation = operation;
         if (operation !== 'DELETE' && query?.filter && !query.filter(row)) {
             if (operation !== 'MODIFY')
@@ -68,32 +117,42 @@ export function createMockServer(config) {
             for (const [sourceRef, subscription] of connection.subscriptions) {
                 if (subscription.resourceName !== resourceName)
                     continue;
-                const rowOperation = resolveSubscriptionOperation(subscription, sourceRef, effectiveOperation, row);
-                if (rowOperation === null)
+                const resolved = resolveSubscriptionOperation(subscription, sourceRef, effectiveOperation, row);
+                if (resolved === null)
                     continue;
                 // Per-user permissioning (auth maps / hideFields equivalent): the
                 // ROW_REF is computed from the unstripped row, since pk fields may
                 // themselves be hidden from this user.
                 const rowRef = subscription.getRowRef(row);
+                const rowOperation = subscription.held
+                    ? trackClientView(subscription, connection, query, resolved, row, rowRef)
+                    : resolved;
+                if (rowOperation === null)
+                    continue;
                 let outRow = row;
-                if (rowOperation !== operation) {
-                    // Converted to a DELETE: send the row identity only — it is all the
-                    // client needs to drop the row, and the full row may carry columns
-                    // this user's hideFields strips.
-                    outRow = query ? store.rowStubFromKey(query.source, rowRef) : row;
+                if (rowOperation === 'DELETE') {
+                    // A change turned into a DELETE: send the row identity only — it is
+                    // all the client needs to drop the row, and the full row may carry
+                    // columns this user's hideFields strips. (A real DELETE's row is a
+                    // stub already.)
+                    if (operation !== 'DELETE') {
+                        outRow = query ? store.rowStubFromKey(query.source, rowRef) : row;
+                    }
                 }
-                else if (rowOperation !== 'DELETE' && query?.auth) {
+                else if (query?.auth) {
                     const [permitted] = applyResourceAuth([row], query.auth, requestingUser(connection));
                     if (!permitted)
                         continue;
                     outRow = permitted;
                 }
                 subscription.sequenceId += 1;
+                // A live push carries neither MORE_ROWS nor ROWS_COUNT on the real
+                // server — those describe the snapshot. Legacy mode sent ROWS_COUNT: 1.
                 connection.send({
                     MESSAGE_TYPE: 'QUERY_UPDATE',
                     SOURCE_REF: sourceRef,
                     ROW: [stampRow(outRow, rowRef, rowOperation)],
-                    ROWS_COUNT: 1,
+                    ...(isLegacyFidelity(config) ? { ROWS_COUNT: 1 } : {}),
                     SEQUENCE_ID: subscription.sequenceId,
                 });
             }

package/dist/types.d.ts

@@ -118,7 +118,9 @@ export interface OnMessageCtx {
     broadcastTableChange: BroadcastTableChangeFn;
 }
 export type OnMessageHook = (message: GenesisMessage, ctx: OnMessageCtx) => GenesisMessage | false | void;
+export type FidelityMode = 'gsf' | 'legacy';
 export interface MockServerConfig {
+    fidelity?: FidelityMode;
     tables?: Record<string, TableDef>;
     views?: Record<string, ViewDef>;
     queries?: Record<string, QueryDef>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genesislcap/mock-server",
-  "version": "15.48.0",
+  "version": "15.50.0",
   "description": "Reusable in-memory Genesis WebSocket protocol mock server for client automation/CI, without a JVM or database.",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,9 @@
     "build:watch": "tsc -p tsconfig.build.json --watch",
     "lint": "echo \"@genesislcap/mock-server: no lint step\"",
     "typecheck": "tsc --noEmit",
-    "test": "node --experimental-strip-types --test"
+    "test": "node --experimental-strip-types --test \"test/**/*.test.ts\"",
+    "test:conformance": "node --experimental-strip-types --test \"test/conformance/**/*.test.ts\"",
+    "conformance:record": "node --experimental-strip-types test/conformance/record.ts"
   },
   "dependencies": {
     "ws": "^8.18.0"

package/src/handlers/commitEvent.ts

@@ -1,7 +1,9 @@
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
 import { NackError } from '../protocol/errors.ts';
+import { isLegacyFidelity } from '../protocol/fidelity.ts';
 import { ERROR_CODE, MESSAGE_TYPE } from '../protocol/messageTypes.ts';
+import { resourceNotMappedNack } from '../protocol/msgNack.ts';
 import type {
   BroadcastFn,
   BroadcastTableChangeFn,
@@ -36,13 +38,23 @@ export function handleCommitEvent(
   // real consumers (foundation-comms' kv.service, entity-management) match
   // these names exactly, so a name-suffixed <EVENT>_ACK reads as failure and
   // a <EVENT>_NACK passes as silent success.
+  // An event nothing handles never reaches an event handler on the real
+  // server: the router rejects it by name with MSG_NACK 404.
   if (!handler) {
-    connection.reply(message, {
-      MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
-      ERROR: [
-        { CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `No event handler registered for ${eventName}` },
-      ],
-    });
+    connection.reply(
+      message,
+      isLegacyFidelity(config)
+        ? {
+            MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
+            ERROR: [
+              {
+                CODE: ERROR_CODE.UNKNOWN_RESOURCE,
+                TEXT: `No event handler registered for ${eventName}`,
+              },
+            ],
+          }
+        : resourceNotMappedNack(eventName),
+    );
     return;
   }