@genesislcap/grid-pro 15.30.0 → 15.30.2

package/dist/esm/datasource/infinite.resource.js

@@ -1,6 +1,8 @@
 import { __awaiter } from "tslib";
-import { dataServerResultFilter, MessageType, } from '@genesislcap/foundation-comms';
+import { MessageType, } from '@genesislcap/foundation-comms';
 import { logger } from '../utils';
+import { filterDataserverResult } from './dataserver-result.filter';
+import { DeliveredBlockLedger } from './delivered-block.ledger';
 import { convertFilterModelToCriteria } from './filter.utils';
 /**
  * Converts an AG Grid sort model to the Genesis ORDER_BY form the resource expects.
@@ -39,12 +41,71 @@ export function convertSortModelToOrderBy(sortModel, resourceIndexes, isRequestS
     logger.warn(`Column '${colId}' is not part of any named INDEX. Server-side sorting is not available for this column.`);
     return { orderBy: null, reverse: false };
 }
+/**
+ * Turns whatever a rejected resource read produced into a message worth showing.
+ * @remarks Genesis rejects with a message object (`{ ERROR: [{ TEXT }], MESSAGE_TYPE }`), not an
+ * `Error`, so stringifying it naively yields "[object Object]" in the grid's error dialog.
+ * @internal
+ */
+export function describeResourceError(error) {
+    var _a, _b, _c;
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    const details = error;
+    for (const candidate of [details, details === null || details === void 0 ? void 0 : details.receivedMessage]) {
+        const texts = (_a = candidate === null || candidate === void 0 ? void 0 : candidate.ERROR) === null || _a === void 0 ? void 0 : _a.map((entry) => entry === null || entry === void 0 ? void 0 : entry.TEXT).filter(Boolean);
+        if (texts === null || texts === void 0 ? void 0 : texts.length) {
+            return texts.join('; ');
+        }
+    }
+    if (typeof (details === null || details === void 0 ? void 0 : details.message) === 'string' && details.message) {
+        return details.message;
+    }
+    const messageType = (_b = details === null || details === void 0 ? void 0 : details.MESSAGE_TYPE) !== null && _b !== void 0 ? _b : (_c = details === null || details === void 0 ? void 0 : details.receivedMessage) === null || _c === void 0 ? void 0 : _c.MESSAGE_TYPE;
+    if (messageType) {
+        return messageType;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch (_d) {
+        return String(error);
+    }
+}
 /**
  * AG Grid Infinite Row Model datasource implementation.
  * This class implements the IDatasource interface required by AG Grid's Infinite Row Model.
  */
 export class GenesisInfiniteDatasource {
     constructor(options) {
+        var _a;
+        /** The `reverse` attribute, applied alongside `defaultOrderBy` on DATASERVER. @internal */
+        this.defaultReverse = false;
+        /**
+         * Bumped whenever the rows this datasource was reading for are dropped (a teardown, or a
+         * filter/sort change). A REQUEST_SERVER reply that resolves for an earlier generation was read
+         * for a cache the grid no longer has.
+         * @remarks Deliberately a generation rather than a "destroyed" flag: AG Grid calls `destroy()`
+         * on the datasource bean it then keeps using (`InfiniteRowModel.start()` re-applies the
+         * `datasource` grid option, and `setDatasource` destroys the previous one first), so a sticky
+         * flag would disable the instance the grid is still driving.
+         * @internal
+         */
+        this.loadGeneration = 0;
+        /**
+         * Set once the host has dropped this instance for a replacement (a criteria change, a resource
+         * change, teardown). AG Grid keeps calling the bean it was given until the new one is attached,
+         * and its purge re-requests blocks immediately, so without this the replaced instance keeps
+         * reading with its captured criteria and reporting those rows to the host as delivered.
+         * @remarks Distinct from `destroy()`, which AG Grid itself calls on a bean it then keeps using;
+         * only the host calls `detach()`, and only when it will never use this instance again.
+         * @internal
+         */
+        this.detached = false;
         /**
          * Session-cumulative row cache, keyed by row id. A Map preserves insertion order, so the
          * cache can be sliced by block range; Genesis splits batches across messages and later
@@ -69,7 +130,11 @@ export class GenesisInfiniteDatasource {
         this.getMoreRowsFunc = options.getMoreRowsFunc;
         this.onRowsInvalidatedFunc = options.onRowsInvalidatedFunc;
         this.onRowsUpdatedFunc = options.onRowsUpdatedFunc;
+        this.onRowsDeliveredFunc = options.onRowsDeliveredFunc;
+        this.onRowsWithdrawnFunc = options.onRowsWithdrawnFunc;
+        this.onRowCacheResetFunc = options.onRowCacheResetFunc;
         this.errorHandlerFunc = options.errorHandlerFunc;
+        this.ledger = new DeliveredBlockLedger(options.rowId);
         this.resourceName = options.resourceName;
         this.resourceParams = Object.assign({}, options.resourceParams);
         this.resourceIndexes = options.resourceIndexes;
@@ -78,6 +143,10 @@ export class GenesisInfiniteDatasource {
         this.rowId = options.rowId;
         this.baseCriteria = options.baseCriteria || '';
         this.isRequestServer = options.isRequestServer;
+        this.defaultOrderBy = options.defaultOrderBy || undefined;
+        this.defaultReverse = (_a = options.defaultReverse) !== null && _a !== void 0 ? _a : false;
+        this.onNoDataAvailableFunc = options.onNoDataAvailableFunc;
+        this.onDataAvailableFunc = options.onDataAvailableFunc;
     }
     /**
      * Builds request parameters for REQUEST_SERVER resources.
@@ -153,6 +222,15 @@ export class GenesisInfiniteDatasource {
      */
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // The host has replaced this instance; the grid is only still asking because the replacement
+            // has not been attached yet. Reading would use this instance's captured criteria and report
+            // rows the grid will drop. fail() releases AG Grid's request slot for the new datasource.
+            if (this.detached) {
+                logger.debug('Infinite getRows ignored: the datasource was detached by its host');
+                params.failCallback();
+                return;
+            }
             logger.debug('Infinite getRows called', {
                 startRow: params.startRow,
                 endRow: params.endRow,
@@ -163,7 +241,8 @@ export class GenesisInfiniteDatasource {
                 const filterCriteria = convertFilterModelToCriteria(params.filterModel, this.resourceColDefs);
                 const combinedCriteria = [this.baseCriteria, filterCriteria].filter(Boolean).join(' && ');
                 // Build sort config
-                const sortConfig = convertSortModelToOrderBy(params.sortModel, this.resourceIndexes, this.isRequestServer);
+                const sortConfig = this.resolveSortConfig(params.sortModel);
+                this.noteRequestKey(combinedCriteria, sortConfig);
                 // DATASERVER pages through a persistent subscription; REQUEST_SERVER is stateless and
                 // pages by OFFSET on a fresh request each time.
                 if (!this.isRequestServer) {
@@ -172,25 +251,51 @@ export class GenesisInfiniteDatasource {
                 }
                 const requestParams = this.buildRequestServerParams(params.startRow, combinedCriteria, sortConfig);
                 logger.debug('Infinite datasource request params', requestParams);
+                // Taken after noteRequestKey, so this is the generation the request belongs to: only a
+                // reset that lands while it is in flight invalidates the reply.
+                const generation = this.loadGeneration;
                 const result = yield this.createSnapshotFunc(requestParams);
+                // The rows this block was read for have since been dropped (a filter or sort change): AG
+                // Grid has purged the block, and the host must not learn of rows the grid will never hold.
+                // The block is still failed rather than left hanging - AG Grid caps concurrent requests
+                // and frees a slot only on success or fail, so a silent return stops it ever asking again.
+                if (generation !== this.loadGeneration) {
+                    logger.debug('Infinite REQUEST_SERVER reply discarded: the block cache was reset');
+                    params.failCallback();
+                    return;
+                }
                 if (!result) {
                     params.failCallback();
                     return;
                 }
+                // A rejected request answers with a message, not a REPLY. Settling it as an empty block
+                // would tell the grid the dataset simply ends here, so the user sees a short grid with no
+                // indication that anything failed.
+                const messageType = result.MESSAGE_TYPE;
+                if (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK) {
+                    const message = messageType === MessageType.LOGOFF_ACK
+                        ? `Connection lost to ${this.resourceName}`
+                        : `Request rejected by ${this.resourceName}`;
+                    logger.error(`Infinite REQUEST_SERVER block failed: ${message}`, result);
+                    (_a = this.errorHandlerFunc) === null || _a === void 0 ? void 0 : _a.call(this, message, 'connection');
+                    params.failCallback();
+                    return;
+                }
                 if ('REPLY' in result && Array.isArray(result.REPLY)) {
                     const rowData = result.REPLY;
                     const lastRow = this.getLastRow(result, params.startRow, rowData.length, Boolean(combinedCriteria));
                     params.successCallback(rowData, lastRow);
+                    this.deliverRows(params.startRow, rowData);
+                    this.notifyDataAvailability(params.startRow, rowData.length);
                     return;
                 }
                 // Fallback - empty result
                 params.successCallback([], params.startRow);
+                this.notifyDataAvailability(params.startRow, 0);
             }
             catch (error) {
                 logger.error('Error in infinite getRows:', error);
-                if (this.errorHandlerFunc) {
-                    this.errorHandlerFunc(error instanceof Error ? error.message : String(error), 'unknown');
-                }
+                (_b = this.errorHandlerFunc) === null || _b === void 0 ? void 0 : _b.call(this, describeResourceError(error), 'unknown');
                 params.failCallback();
             }
         });
@@ -202,20 +307,57 @@ export class GenesisInfiniteDatasource {
      * outstanding at once, and each settles as soon as the cache covers its range.
      * @internal
      */
+    /**
+     * Notes the CRITERIA_MATCH/ORDER_BY a block is being read with. A change means AG Grid has
+     * purged its cache and restarted from block 0: on DATASERVER the subscription is re-opened
+     * (those are DATA_LOGON parameters), and on both transports the host is told the rows it held
+     * are gone, so the rows read under the new filter or sort are reported as new.
+     * @internal
+     */
+    /**
+     * The sort a block is read with: the grid's own sort model when the user has sorted, and the
+     * `order-by` / `reverse` attributes otherwise.
+     * @remarks Without the fallback those attributes reached the comms datasource but were then
+     * dropped, because the logon builder removes ORDER_BY and REVERSE whenever the grid is
+     * unsorted. Sorting from the grid still wins, as it is the more specific instruction.
+     * @internal
+     */
+    resolveSortConfig(sortModel) {
+        const fromGrid = convertSortModelToOrderBy(sortModel, this.resourceIndexes, this.isRequestServer);
+        if (fromGrid.orderBy || !this.defaultOrderBy) {
+            return fromGrid;
+        }
+        return { orderBy: this.defaultOrderBy, reverse: this.defaultReverse };
+    }
+    noteRequestKey(criteria, sortConfig) {
+        var _a;
+        const key = JSON.stringify(Object.assign({ criteria }, sortConfig));
+        // Tracked separately from `subscriptionKey`, which a teardown clears: `reset()` tears the
+        // subscription down on every structural push, and a filter change landing between that and
+        // the next block read would otherwise look like the very first request - leaving the host
+        // holding every row read under the old filter.
+        if (this.rowCacheKey !== undefined && this.rowCacheKey !== key) {
+            // Whatever is in flight was read for the old filter or sort.
+            this.loadGeneration += 1;
+            this.ledger.clear();
+            (_a = this.onRowCacheResetFunc) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        this.rowCacheKey = key;
+        // CRITERIA_MATCH and ORDER_BY are DATA_LOGON parameters, so a change needs a fresh
+        // subscription. A teardown has already left `subscriptionKey` undefined.
+        if (!this.isRequestServer &&
+            this.subscriptionKey !== undefined &&
+            this.subscriptionKey !== key) {
+            this.teardownDataserverSubscription();
+        }
+        this.subscriptionKey = key;
+    }
     getDataserverRows(params, criteria, sortConfig) {
         if (!this.createDataserverStreamFunc || !this.getMoreRowsFunc) {
             logger.error('Infinite DATASERVER paging requires a stream and a getMoreRows function');
             params.failCallback();
             return;
         }
-        // CRITERIA_MATCH and ORDER_BY are DATA_LOGON parameters, so a filter or sort change needs a
-        // fresh subscription and a fresh cache. AG Grid purges its own cache on those changes and
-        // restarts from block 0, so nothing is lost.
-        const key = JSON.stringify(Object.assign({ criteria }, sortConfig));
-        if (this.subscriptionKey !== undefined && this.subscriptionKey !== key) {
-            this.teardownDataserverSubscription();
-        }
-        this.subscriptionKey = key;
         const startRow = Number.isFinite(Number(params.startRow)) ? Number(params.startRow) : 0;
         const endRow = Number.isFinite(Number(params.endRow))
             ? Number(params.endRow)
@@ -318,7 +460,7 @@ export class GenesisInfiniteDatasource {
             return;
         }
         this.sourceRef = (_b = message === null || message === void 0 ? void 0 : message.SOURCE_REF) !== null && _b !== void 0 ? _b : this.sourceRef;
-        const filtered = (message === null || message === void 0 ? void 0 : message.ROW) ? dataServerResultFilter(message, this.rowId) : undefined;
+        const filtered = (message === null || message === void 0 ? void 0 : message.ROW) ? filterDataserverResult(message, this.rowId) : undefined;
         // A DATASERVER subscription is live by definition: batches answering the logon or a
         // MORE_ROWS carry the rows we asked for, and anything else is a change pushed by the server.
         // Replies only ever deliver view rows (INSERT operations), so a batch carrying a MODIFY or
@@ -380,7 +522,7 @@ export class GenesisInfiniteDatasource {
                 deletes: (_k = (_j = result.deletes) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : 0,
             });
             this.reset();
-            (_l = this.onRowsInvalidatedFunc) === null || _l === void 0 ? void 0 : _l.call(this);
+            (_l = this.onRowsInvalidatedFunc) === null || _l === void 0 ? void 0 : _l.call(this, result);
             return;
         }
         if (modified) {
@@ -388,7 +530,7 @@ export class GenesisInfiniteDatasource {
             logger.debug('Infinite DATASERVER live update patched into the cache', {
                 updates: (_o = (_m = result.updates) === null || _m === void 0 ? void 0 : _m.length) !== null && _o !== void 0 ? _o : 0,
             });
-            (_p = this.onRowsUpdatedFunc) === null || _p === void 0 ? void 0 : _p.call(this);
+            (_p = this.onRowsUpdatedFunc) === null || _p === void 0 ? void 0 : _p.call(this, result);
         }
     }
     /**
@@ -506,6 +648,46 @@ export class GenesisInfiniteDatasource {
             lastRow,
         });
         block.success(rows, lastRow);
+        this.deliverRows(block.startRow, rows);
+        this.notifyDataAvailability(block.startRow, rows.length);
+    }
+    /**
+     * Raises the no-data / data-available hooks for the first block, as the server-side resource
+     * does. Later blocks say nothing: the question is whether the resource has any rows at all,
+     * and the answer cannot change once the first block has been served.
+     * @internal
+     */
+    notifyDataAvailability(startRow, rowCount) {
+        var _a, _b;
+        if (startRow !== 0 || this.detached) {
+            return;
+        }
+        if (rowCount === 0) {
+            (_a = this.onNoDataAvailableFunc) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        else {
+            (_b = this.onDataAvailableFunc) === null || _b === void 0 ? void 0 : _b.call(this);
+        }
+    }
+    /**
+     * Reports rows handed to the grid for a block, then the rows a re-read of that block no longer
+     * carries and the rows whose block the grid evicted.
+     * @internal
+     */
+    deliverRows(startRow, rows) {
+        var _a, _b;
+        // A reply that resolves after the host dropped this instance belongs to a cache the grid no
+        // longer has; reporting it would tell consumers about rows the grid will never show.
+        if (this.detached) {
+            return;
+        }
+        const { withdrawnRowIds } = this.ledger.record(startRow, rows);
+        if (rows.length > 0) {
+            (_a = this.onRowsDeliveredFunc) === null || _a === void 0 ? void 0 : _a.call(this, rows);
+        }
+        if (withdrawnRowIds.length > 0) {
+            (_b = this.onRowsWithdrawnFunc) === null || _b === void 0 ? void 0 : _b.call(this, withdrawnRowIds);
+        }
     }
     /**
      * Warns when the view filled up before the data ran out.
@@ -566,10 +748,33 @@ export class GenesisInfiniteDatasource {
         this.moreRows = undefined;
         this.moreRowsInFlight = false;
     }
+    /**
+     * Drops the subscription and the cached rows.
+     * @remarks AG Grid calls this on the bean it then keeps using (`InfiniteRowModel.start()`
+     * re-applies the `datasource` grid option, and `setDatasource` destroys the previous one
+     * first), and it can land while a block request is in flight. So it must leave the datasource
+     * able to serve that reply and the next `getRows`: it drops the subscription, not the instance.
+     */
     destroy() {
         this.teardownDataserverSubscription();
+        this.ledger.clear();
         logger.debug('GenesisInfiniteDatasource destroyed');
     }
+    /**
+     * Drops this instance for good: the host is replacing it, so it must stop serving the grid and
+     * stop reporting rows, even though AG Grid still holds it as its `datasource` until the
+     * replacement is attached.
+     * @remarks Deliberately separate from `destroy()`, which AG Grid calls on a bean it then keeps
+     * using (`InfiniteRowModel.start()` re-applies the `datasource` grid option, and `setDatasource`
+     * destroys the previous one first).
+     */
+    detach() {
+        this.detached = true;
+        this.loadGeneration += 1;
+        this.rowCacheKey = undefined;
+        this.destroy();
+        logger.debug('GenesisInfiniteDatasource detached by its host');
+    }
 }
 /**
  * Max time a DATASERVER block may stay pending before the safety valve resolves it with the

package/dist/esm/datasource/server-side.datasource.js

@@ -1,11 +1,12 @@
 import { __awaiter, __decorate } from "tslib";
-import { dataServerResultFilter, Datasource, MessageType, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
-import { JSONSerializer, LifecycleMixin } from '@genesislcap/foundation-utils';
+import { Datasource, MessageType, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
 import { attr, customElement, DOM, observable } from '@microsoft/fast-element';
 import { gridProGenesisDatasourceEventNames } from '../grid-pro-genesis-datasource';
 import { datasourceEventNames, } from '../grid-pro-genesis-datasource/datasource-events.types';
 import { logger } from '../utils';
 import { GridProBaseDatasource } from './base.datasource';
+import { filterDataserverResult } from './dataserver-result.filter';
 import { getFilterByFieldType, getServerSideFilterParamsByFieldType, } from './server-side.grid-definitions';
 import { DataserverServerSideDatasource } from './server-side.resource-dataserver';
 import { ReqRepServerSideDatasource } from './server-side.resource-reqrep';
@@ -30,7 +31,7 @@ const withoutColumnDefs = null;
  * @fires base-datasource-connected - Fired when error state is cleared after connection succeeds
  * @fires datasource-loading-finished - Fired when pending stream transactions are flushed with no row changes
  * @fires datasource-no-data-available - Fired when loading finishes with an empty row set
- * @fires datasource-data-changed - Fired when row data changes from applied stream transactions. detail: `DataChangedEventDetail`
+ * @fires datasource-data-changed - Fired when rows are delivered to the grid, a live stream pushes a change, a poll detects one, or a re-read no longer returns a row; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`
  * @fires cache-filter-config - Fired to persist filter configuration for the grid
  * @fires refresh-server-side - Fired to request a server-side refresh. detail: `RefreshServerSideEventDetail`
  * @fires set-server-side-datasource - Fired to attach or clear the server-side row model datasource
@@ -41,7 +42,7 @@ const withoutColumnDefs = null;
  * @fires datasource-init - Fired when the server-side grid model should initialize data
  * @fires datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`
  * @fires datasource-filters-restored - Fired when persisted filters are reapplied
- * @fires datasource-data-cleared - Fired when server-side row data is cleared. detail: `DataClearedEventDetail`
+ * @fires datasource-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`
  * @fires apply-server-side-transaction - Fired to apply a server-side row transaction
  * @fires datasource-ready - Fired when the host grid is ready to start loading data
  */
@@ -91,6 +92,8 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                     errorHandlerFunc: this.handleErrors.bind(this),
                     onNoDataAvailableFunc: () => this.$emit(datasourceEventNames.noDataAvailable),
                     onDataAvailableFunc: () => this.$emit(datasourceEventNames.loadingFinished),
+                    onRowsDeliveredFunc: this.reportDeliveredRows.bind(this),
+                    onRowsWithdrawnFunc: this.reportWithdrawnRows.bind(this),
                     resourceName: this.resourceName,
                     resourceParams: this.datasource.requestOnlyParams,
                     resourceIndexes: this.indexes,
@@ -107,6 +110,8 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                     errorHandlerFunc: this.handleErrors.bind(this),
                     onNoDataAvailableFunc: () => this.$emit(datasourceEventNames.noDataAvailable),
                     onDataAvailableFunc: () => this.$emit(datasourceEventNames.loadingFinished),
+                    onRowsDeliveredFunc: this.reportDeliveredRows.bind(this),
+                    onRowsWithdrawnFunc: this.reportWithdrawnRows.bind(this),
                     resourceName: this.resourceName,
                     resourceParams: this.datasource.dataserverOnlyParams,
                     resourceIndexes: this.indexes,
@@ -195,9 +200,12 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
      */
     reloadResourceData(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c;
             this.datasource.destroy();
-            (_a = this.liveUpdatesStream) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+            // A block request still in flight was read for the cache being dropped here; its reply must
+            // not be reported as rows the grid holds.
+            (_b = (_a = this.ssrmDatasource) === null || _a === void 0 ? void 0 : _a.invalidatePendingLoads) === null || _b === void 0 ? void 0 : _b.call(_a);
+            (_c = this.liveUpdatesStream) === null || _c === void 0 ? void 0 : _c.unsubscribe();
             this.liveUpdatesStream = undefined;
             // Emit event to cache current filter model before clearing data
             this.$emit(datasourceEventNames.cacheFilterConfig);
@@ -329,20 +337,22 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
             yield this.init();
         });
     }
+    /**
+     * Forgets every held row and tells consumers, as the client-side datasource does: the grid is
+     * dropping its rows (a reload, a filter or sort change, or teardown). `withColumnDefs` also
+     * clears the column definitions.
+     * @internal
+     */
     clearRowData(withColumnDefs = true) {
         this.rowData = new Map();
-        if (withColumnDefs) {
-            // Emit event to clear column definitions
-            this.$emit(datasourceEventNames.dataCleared, {
-                includeSchema: true,
-            });
-        }
-        this.transactionData = { remove: [] };
+        this.resetTransaction();
+        this.$emit(datasourceEventNames.dataCleared, {
+            includeSchema: Boolean(withColumnDefs),
+        });
         // Emit event to apply server side transaction for removing all data
         this.$emit(datasourceEventNames.applyServerSideTransaction, {
-            transaction: this.transactionData,
+            transaction: { remove: [] },
         });
-        this.transactionData = undefined;
     }
     /**
      * Checks whether the resolved resource can be served through the Server-Side Row Model.
@@ -471,7 +481,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
             const rowId = row[this.rowId];
             if (this.previousPollResult.has(rowId)) {
                 const previousRow = this.previousPollResult.get(rowId);
-                if (this.serializer.serialize(previousRow) !== this.serializer.serialize(row)) {
+                if (this.hasRowContentChanged(previousRow, row)) {
                     rowsToUpdate.push(row);
                 }
             }
@@ -492,6 +502,31 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                 removed: rowsToDelete.length,
                 totalInPoll: currentPollMap.size,
             });
+            // The poll has already classified the rows against the previous poll, so re-classify the
+            // inserts against the rows actually held: a row shifted into the polled page from a block
+            // above is new to the poll but not to the grid, and reporting it as `add` would duplicate
+            // it for consumers.
+            const transaction = this.resetTransaction();
+            rowsToInsert.forEach((row) => {
+                const rowId = row[this.rowId];
+                const known = this.rowData.get(rowId);
+                if (!known) {
+                    transaction.add.push(row);
+                }
+                else if (this.hasRowContentChanged(known, row)) {
+                    transaction.update.push(row);
+                }
+            });
+            transaction.update.push(...rowsToUpdate);
+            transaction.remove.push(...rowsToDelete.map((row) => ({ [this.rowId]: row[this.rowId] })));
+            [...rowsToInsert, ...rowsToUpdate].forEach((row) => this.rowData.set(row[this.rowId], row));
+            rowsToDelete.forEach((row) => this.rowData.delete(row[this.rowId]));
+            this.emitTransaction(transaction);
+            // A consumer's handler may have reloaded or destroyed this datasource synchronously; the
+            // grid is then being purged and the transaction belongs to rows it no longer holds.
+            if (this.transactionData !== transaction) {
+                return;
+            }
             this.$emit(datasourceEventNames.applyServerSideTransaction, {
                 transaction: {
                     add: rowsToInsert,
@@ -514,25 +549,41 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
             this.ssrmDatasource.serverRowsCount += netRowChange;
             this.ssrmDatasource.clientRowsCount += netRowChange;
         }
-        this.transactionData = { add: [], remove: [], update: [] };
+        const transaction = this.resetTransaction();
         this.handleStreamInserts(inserts);
         this.handleStreamUpdates(updates);
         this.handleStreamDeletes(deletes);
-        if (this.transactionData.add.length > 0) {
+        // A MODIFY for a row this element has not seen delivered is not reported to consumers (they
+        // do not hold it), but it still goes to the grid, which ignores rows outside its store: the
+        // stream pre-merge above made it a full row, and the grid may hold it from a block loaded
+        // before this element started mirroring deliveries.
+        const gridOnlyUpdates = updates.filter((row) => {
+            const rowId = row === null || row === void 0 ? void 0 : row[this.rowId];
+            return rowId !== undefined && rowId !== null && !this.rowData.has(rowId);
+        });
+        // Consumers hear the change first; the grid transactions below then catch the grid up.
+        this.emitTransaction(transaction);
+        // A consumer's handler may have reloaded or destroyed this datasource synchronously; the
+        // grid is then being purged and the transaction belongs to rows it no longer holds.
+        if (this.transactionData !== transaction) {
+            return;
+        }
+        if (transaction.add.length > 0) {
             this.$emit(datasourceEventNames.applyServerSideTransaction, {
                 transaction: {
                     route: [],
-                    add: this.transactionData.add,
-                    addIndex: this.reverse ? 0 : this.transactionData.addIndex,
+                    add: transaction.add,
+                    addIndex: this.reverse ? 0 : transaction.addIndex,
                 },
             });
         }
-        if (this.transactionData.update.length > 0 || this.transactionData.remove.length > 0) {
+        const gridUpdates = [...transaction.update, ...gridOnlyUpdates];
+        if (gridUpdates.length > 0 || transaction.remove.length > 0) {
             this.$emit(datasourceEventNames.applyServerSideTransaction, {
                 transaction: {
                     route: [],
-                    update: this.transactionData.update,
-                    remove: this.transactionData.remove,
+                    update: gridUpdates,
+                    remove: transaction.remove,
                 },
             });
         }
@@ -563,9 +614,12 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                     // a complete row — without this, unchanged columns are cleared on every update.
                     const rowData = this.ssrmDatasource.rowData;
                     const mergedRows = normalizedRows.map((row) => {
-                        var _a;
+                        var _a, _b;
                         const details = (_a = row.DETAILS) !== null && _a !== void 0 ? _a : {};
-                        const rowRef = details[this.rowId];
+                        // Genesis keys pushes by the default id. Under a custom `row-id` DETAILS carries no
+                        // custom id at all, so fall back to the held row that carries this ROW_REF.
+                        const defaultRowId = this.defaultRowIdByResourceType;
+                        const rowRef = ((_b = details[this.rowId]) !== null && _b !== void 0 ? _b : this.resolveRowId(Object.assign(Object.assign({}, row), { [defaultRowId]: details[defaultRowId] })));
                         const existingRow = rowRef != null ? rowData === null || rowData === void 0 ? void 0 : rowData.get(rowRef) : undefined;
                         if (!existingRow)
                             return row;
@@ -577,7 +631,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                         return Object.assign(Object.assign({}, merged), { DETAILS: details });
                     });
                     const normalizedMessage = Object.assign(Object.assign({}, rawMessage), { ROW: mergedRows });
-                    const nextMessage = dataServerResultFilter(normalizedMessage, this.rowId);
+                    const nextMessage = filterDataserverResult(normalizedMessage, this.rowId);
                     this.applyLiveServerSideUpdate(nextMessage);
                 });
                 const onError = (error) => {
@@ -611,9 +665,6 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
         throw new Error('loadMore() method is not supported for server-side datasource');
     }
 };
-__decorate([
-    JSONSerializer
-], GridProServerSideDatasource.prototype, "serializer", void 0);
 __decorate([
     Datasource
 ], GridProServerSideDatasource.prototype, "pollingDatasource", void 0);