@genesislcap/mock-server 15.54.0 → 15.55.0

package/src/server.ts

@@ -1,6 +1,14 @@
 import http from 'node:http';
 import { WebSocketServer, type WebSocket } from 'ws';
+import { recordKey } from './db/identity.ts';
 import { Store } from './db/store.ts';
+import {
+  entriesReading,
+  planView,
+  type PlannedAntiJoin,
+  type PlannedJoin,
+  type ViewEntry,
+} from './db/views.ts';
 import { crudEventHandler } from './handlers/crudEvents.ts';
 import { pendingKey } from './handlers/dataLogon.ts';
 import { createHttpRequestListener } from './handlers/http.ts';
@@ -21,6 +29,28 @@ import type {
   ViewDef,
 } from './types.ts';
 
+// One view row a live change pushes, and how.
+type ViewChange = [RowOperation, Row];
+
+// A broadcast change to one table (see tableChange in createMockServer).
+interface TableChange {
+  before: () => Row[];
+  after: () => Row[];
+  records: Set<string>;
+}
+
+// Whether two rows carry the same columns and values (a value compared as
+// JSON when it isn't the same primitive).
+function sameValues(a: Row, b: Row): boolean {
+  const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of keys) {
+    if (!Object.is(a[key], b[key]) && JSON.stringify(a[key]) !== JSON.stringify(b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 export interface MockServer {
   start(port: number): WebSocketServer;
   // Like start(), but resolves with the ACTUAL bound port once listening —
@@ -258,6 +288,118 @@ export function createMockServer(config: MockServerConfig): MockServer {
     for (const record of records) pushChange(resourceName, 'DELETE', record);
   };
 
+  // A change being broadcast to a table, as the views that join it see it:
+  // the table's rows before and after it, and the RECORD_IDs it touched (the
+  // changed record and every record its key lost). The store's
+  // previous-record entries are consumed straight away, so the next change
+  // starts from this one; the rows are only gathered if a view needs them.
+  function tableChange(
+    tableName: string,
+    operation: RowOperation,
+    current: Row | undefined,
+    removed: Row[],
+  ): TableChange {
+    const currentId = recordKey(current);
+    const previous = current ? store.takePreviousRecord(tableName, current) : undefined;
+    const lost = new Map(
+      removed.map((record) => [
+        recordKey(record),
+        store.takePreviousRecord(tableName, record) ?? record,
+      ]),
+    );
+    // The changed record was in the table before as it was before its first
+    // modify — or as it is, when nothing modified it. An INSERT's wasn't, nor
+    // was one that replaced another record under its key.
+    const currentWasThere = operation !== 'INSERT' && (previous !== undefined || lost.size === 0);
+    const records = new Set(
+      [currentId, ...lost.keys()].filter((id): id is string => id !== undefined),
+    );
+    let before: Row[] | undefined;
+    return {
+      records,
+      before: () => {
+        if (before) return before;
+        const restored = new Set<string | undefined>();
+        before = store.getAllRows(tableName).flatMap((row) => {
+          const id = recordKey(row);
+          if (id !== undefined && id === currentId) {
+            return currentWasThere ? [previous ?? row] : [];
+          }
+          // A record a DELETE names before it is removed.
+          if (lost.has(id)) {
+            restored.add(id);
+            return [lost.get(id)!];
+          }
+          return [row];
+        });
+        for (const [id, record] of lost) if (!restored.has(id)) before.push(record);
+        return before;
+      },
+      // Without the records the key lost, even one still stored when its
+      // DELETE is broadcast.
+      after: () => store.getAllRows(tableName).filter((row) => !lost.has(recordKey(row))),
+    };
+  }
+
+  // A live change to a table a view joins (at any depth) or anti-joins, under
+  // fidelity 'gsf'. Only the joins that read the table with `backwardsJoin`
+  // listen to it — GSF listens to no other joined table — and every
+  // anti-join does. The view is rebuilt through them as it was before the
+  // change and as it is after it, and compared, row by base record (the
+  // ROW_REF): a row the change brought in (an INNER join that now matches) is
+  // pushed as an INSERT, one it took out as a DELETE, and one joined to a
+  // changed record before or after, or whose values changed, as a MODIFY.
+  // A row joined to the changed record is pushed even when its values look
+  // the same: the before-state is the store's (a record as it was before its
+  // first unannounced modify), and a client may hold newer values than that.
+  // A view that joins its own base table gets the changed base rows
+  // themselves from broadcastTableChange's base path, not from here.
+  function joinedViewChanges(
+    viewName: string,
+    view: ViewDef,
+    tableName: string,
+    change: TableChange,
+  ): ViewChange[] {
+    const plan = planView(viewName, view);
+    const listening = entriesReading(plan, tableName).filter(
+      (entry) => !('backwardsJoin' in entry) || entry.backwardsJoin,
+    );
+    if (listening.length === 0) return [];
+    // By definition: every materialization plans the view afresh.
+    const listeningDefs = new Set<object>(listening.map((entry) => entry.def));
+    const listeningJoins = plan.joins.flatMap((join, index) =>
+      listeningDefs.has(join.def) ? [index] : [],
+    );
+    const touched = ({ matches }: ViewEntry) =>
+      listeningJoins.some((index) => {
+        const id = recordKey(matches[index]);
+        return id !== undefined && change.records.has(id);
+      });
+    const rowsOf = (rows: () => Row[]) => (entry: PlannedJoin | PlannedAntiJoin) =>
+      listeningDefs.has(entry.def) ? rows() : undefined;
+    const was = store.getViewEntriesFrom(viewName, { rowsOf: rowsOf(change.before) });
+    const now = store.getViewEntriesFrom(viewName, { rowsOf: rowsOf(change.after) });
+    const ownRow = (entry: ViewEntry) =>
+      view.base === tableName && change.records.has(recordKey(entry.row) ?? '');
+    const wasByRecord = new Map(was.map((entry) => [recordKey(entry.row), entry]));
+    const nowRecords = new Set(now.map((entry) => recordKey(entry.row)));
+    const changes: ViewChange[] = [];
+    for (const entry of now) {
+      if (ownRow(entry)) continue;
+      const old = wasByRecord.get(recordKey(entry.row));
+      if (!old) changes.push(['INSERT', entry.row]);
+      else if (touched(old) || touched(entry) || !sameValues(old.row, entry.row)) {
+        changes.push(['MODIFY', entry.row]);
+      }
+    }
+    for (const entry of was) {
+      if (!ownRow(entry) && !nowRecords.has(recordKey(entry.row))) {
+        changes.push(['DELETE', entry.row]);
+      }
+    }
+    return changes;
+  }
+
   // Event handlers mutate one table (e.g. TRADE) but grids may be subscribed to
   // a view built on top of it (e.g. ALL_TRADES -> TRADE_VIEW). This finds every
   // query resource backed by that table — directly or via a view — and pushes
@@ -270,9 +412,12 @@ export function createMockServer(config: MockServerConfig): MockServer {
   // re-inserted, before one broadcast) gets a DELETE of its old ROW_REF before
   // the new one goes out. A view row is built from the changed base row
   // alone, so it is found whatever the view's own pkField; a MODIFY that takes
-  // it out of the view (an anti-join) is pushed as a DELETE. Legacy ROW_REFs
-  // are the key itself, so there a DELETE is the pk stub and a replacement is
-  // the one INSERT/MODIFY, as before.
+  // it out of the view (an INNER join or an anti-join that no longer lets it
+  // through) is pushed as a DELETE, and an INSERT that doesn't make it into
+  // the view isn't pushed at all. A table a view joins is handled by
+  // joinedViewChanges. Legacy ROW_REFs are the key itself, so there a DELETE
+  // is the pk stub and a replacement is the one INSERT/MODIFY, as before; and
+  // a change to a joined table pushes every view row as a MODIFY.
   const broadcastTableChange: BroadcastTableChangeFn = (tableName, operation, pk) => {
     const legacy = isLegacyFidelity(config);
     const current = operation === 'DELETE' ? undefined : store.getRow(tableName, pk);
@@ -282,30 +427,39 @@ export function createMockServer(config: MockServerConfig): MockServer {
     // A DELETE broadcast before the row is removed still names it.
     const live = store.getRow(tableName, pk);
     if (operation === 'DELETE' && removed.length === 0 && live) removed = [live];
+    const change = tableChange(tableName, operation, current, removed);
     if (legacy) removed = [];
+    const viewChanges = new Map<string, ViewChange[]>();
     for (const [queryName, query] of Object.entries(config.queries ?? {})) {
       const isDirect = query.source === tableName;
       const view = store.views.get(query.source);
       const isViewOnTable = view?.base === tableName;
-      // A view that JOINS (or anti-joins) the mutated table denormalizes its
-      // columns into every matching base row, so one change can affect any
-      // number of view rows — none of them keyed by `pk`. Re-materialize and
-      // push the refreshed view instead of dropping the change, or e.g.
-      // renaming a COUNTERPARTY never updates COUNTERPARTY_NAME in an open
-      // ALL_TRADES grid.
-      const isViewJoiningTable =
+
+      if (view && !legacy) {
+        let changes = viewChanges.get(query.source);
+        if (!changes) {
+          changes = joinedViewChanges(query.source, view, tableName, change);
+          viewChanges.set(query.source, changes);
+        }
+        for (const [rowOperation, row] of changes) pushChange(queryName, rowOperation, row);
+      }
+
+      // Legacy: a view that JOINS (or anti-joins) the mutated table
+      // denormalizes its columns into any number of view rows, so the view is
+      // re-materialized and every row pushed as a MODIFY.
+      if (
+        legacy &&
         !isDirect &&
         !isViewOnTable &&
         ((view?.joins ?? []).some((join) => join.table === tableName) ||
-          (view?.antiJoins ?? []).some((antiJoin) => antiJoin.table === tableName));
-      if (!isDirect && !isViewOnTable && !isViewJoiningTable) continue;
-
-      if (isViewJoiningTable) {
+          (view?.antiJoins ?? []).some((antiJoin) => antiJoin.table === tableName))
+      ) {
         for (const viewRow of store.getViewRows(query.source)) {
           pushChange(queryName, 'MODIFY', viewRow);
         }
         continue;
       }
+      if (!isDirect && !isViewOnTable) continue;
 
       // The removed base records carry the RECORD_ID a view row's ROW_REF
       // comes from too; the DELETE body is DETAILS only either way.
@@ -322,7 +476,9 @@ export function createMockServer(config: MockServerConfig): MockServer {
         pushChange(queryName, operation, current);
         continue;
       }
-      const viewRow = store.getViewRows(query.source, { [tableName]: [current] })[0];
+      // Only the base read is narrowed: a view that also joins its base table
+      // still joins every row of it.
+      const viewRow = store.getViewRowsFrom(query.source, { base: [current] })[0];
       if (viewRow) {
         pushChange(queryName, operation, viewRow);
       } else if (operation === 'MODIFY') {

package/src/types.ts

@@ -133,42 +133,120 @@ export interface TableDef {
 // '000000000000001TRLO1'.
 export type SequenceFormat = 'prefix' | 'genesis';
 
+// A join's key: `[sourceField, joinedField]` — the field of the row the join
+// starts from that must equal the field of the joined table (GPAL
+// `on(TRADE.COUNTERPARTY_ID to COUNTERPARTY { COUNTERPARTY_ID })`). With the
+// join's `fromAlias`, the source is that table's row; without one, the view
+// row built so far — the base row's columns, overlaid by the selects of the
+// joins before — so a join can also key on an earlier join's column, as
+// chained joins were written before `fromAlias`.
+export type JoinFieldLink = [string, string];
+
+// The same as an object, whose source may be any table joined before this
+// one (GPAL `.and(TRADE { INSTRUMENT_ID } to IP { BID_PRICE })` inside a
+// join nested under INSTRUMENT). `fromAlias` defaults to the join's own.
+export interface JoinAliasedFieldLink {
+  fromAlias?: string;
+  from: string;
+  to: string;
+}
+
+// A joined-table field that must equal a constant (GPAL
+// `and(ALT_INSTRUMENT_ID.ALTERNATE_TYPE to "BLOOMBERG")`), compared with ===:
+// give it the column's own type (a number for an INT, not "1").
+export interface JoinValueLink {
+  to: string;
+  value: unknown;
+}
+
+export type JoinLink = JoinFieldLink | JoinAliasedFieldLink | JoinValueLink;
+
+// INNER drops a view row when the join finds no match; OUTER (GSF's default)
+// keeps it, with the join's columns null.
+export type JoinType = 'INNER' | 'OUTER';
+
+// What a `where` predicate and a derived field see beside the rows: every
+// table of the view row by its alias (the base table's, then each join's
+// joined so far), undefined for an OUTER join that found no match.
+export interface ViewRowSources {
+  tables: Record<string, Row | undefined>;
+}
+
+// One `joining(...)` of a GSF view. See the README's "Views: the join model".
 export interface JoinDef {
   table: string;
-  on: [string, string];
+  // The table's name inside this view (GPAL `TABLE withAlias "ALIAS"`): what
+  // a nested join's `fromAlias` and the derived fields' `tables` call it.
+  // Defaults to `table`. A table joined twice, or the base table joined to
+  // itself, needs one to be read by name: without one, a join whose table
+  // name is taken still joins, but goes by no name (as before aliases).
+  alias?: string;
+  // The table the join starts from: the base table (the default) or an
+  // earlier join's alias — a nested join (GPAL `.joining(...)` inside a join).
+  fromAlias?: string;
+  // One key pair, or several (GPAL `on(...).and(...)`): field pairs, field
+  // links from another table of the view, constants. All of them must hold.
+  on: JoinFieldLink | JoinLink[];
+  // Default 'OUTER', as in GSF.
+  type?: JoinType;
+  // GSF's `backwardsJoin = true`: a change to this join's table is pushed to
+  // subscribed views. Without it (GSF's default) only changes to the base
+  // table are, and the client sees a joined table's new values when the
+  // view row's base row next changes. Ignored under fidelity: 'legacy',
+  // where every join's changes are pushed.
+  backwardsJoin?: boolean;
+  // The view columns this join adds: { [viewField]: joinedTableField } —
+  // `NAME withAlias "COUNTERPARTY_NAME"` is { COUNTERPARTY_NAME: 'NAME' },
+  // `NAME withPrefix "CP"` is { CP_NAME: 'NAME' }, a plain `INSTRUMENT.NAME`
+  // is { NAME: 'NAME' }.
   select?: Record<string, string>;
-  // Extra join predicate beyond the `on` equality — receives the candidate
-  // join row and the base row, e.g. side-specific joins like
-  // (price, rfq) => price.SIDE === 'SALES'. When present, matching scans the
-  // join table per base row instead of using a prebuilt index (fine at mock
-  // scale).
-  where?: (joinRow: Row, baseRow: Row) => boolean;
+  // Extra join predicate beyond `on` (not a GSF construct: GSF expresses
+  // these as constant links) — receives the candidate join row, the view row
+  // so far (the base row's columns and the selects of the joins before this
+  // one) and the tables joined so far, e.g. side-specific joins like
+  // (price, rfq) => price.SIDE === 'SALES'. The first candidate (in table
+  // order) that passes is the match.
+  where?: (joinRow: Row, viewRow: Row, sources: ViewRowSources) => boolean;
 }
 
 // Keeps only base rows with NO match in `table` (e.g. USER_WITHOUT_DETAIL:
-// users lacking a USER_DETAIL row). `where` narrows what counts as a match,
-// same contract as JoinDef.where.
+// users lacking a USER_DETAIL row). `on` and `where` match as on a join
+// starting from the base table. Not a GSF view construct: a change to the
+// anti-joined table is always pushed.
 export interface AntiJoinDef {
   table: string;
-  on: [string, string];
-  where?: (joinRow: Row, baseRow: Row) => boolean;
+  on: JoinFieldLink | JoinLink[];
+  where?: (joinRow: Row, baseRow: Row, sources: ViewRowSources) => boolean;
 }
 
+// A GSF view (`view("NAME", TABLE) { joins { } fields { } }`). See the
+// README's "Views: the join model".
 export interface ViewDef {
   base: string;
+  // The base table's name inside this view, for `fromAlias` and the derived
+  // fields' `tables`. Defaults to `base`.
+  baseAlias?: string;
   pkField?: string | string[];
+  // Applied in order: a join can start from an earlier one (`fromAlias`).
   joins?: JoinDef[];
   antiJoins?: AntiJoinDef[];
-  derived?: Record<string, (row: Row) => any>;
+  // Aliased base-table columns, { [viewField]: baseField } (GPAL
+  // `TRADE.PRICE withAlias "TRADE_PRICE"`), added beside the base columns.
+  // List the view's `fields` to expose only the aliased name.
+  select?: Record<string, string>;
+  // Computed columns. `row` is the view row before its derived fields (base
+  // columns and every join's select); `tables` holds each table's source row
+  // by alias, for inputs the view doesn't expose (GPAL `withInput`).
+  derived?: Record<string, (row: Row, sources: ViewRowSources) => any>;
   // Types of the `derived` fields (`derivedField("TOTAL", DOUBLE)`): a type,
   // or a full field definition without its name. Columns from the base table
   // and from `joins[].select` take their declared types from their source
   // tables; a derived field with no entry here is inferred from the rows.
   derivedTypes?: Record<string, GenesisFieldType | Omit<FieldDef, 'name'>>;
   // The view's fields { } block: the only columns it exposes, in this order
-  // (base, joined and derived alike). Unset: every base column, then each
-  // join's select, then the derived fields. Keep the key fields in it — they
-  // are the ROW_REF.
+  // (base, joined and derived alike). Unset: every base column, then the
+  // base `select`, then each join's select, then the derived fields. Keep the
+  // key fields in it — they are the ROW_REF.
   fields?: string[];
 }