@genesislcap/grid-pro 15.30.0 → 15.30.2

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

@@ -1,6 +1,7 @@
 import { __awaiter, __decorate } from "tslib";
 import { Auth, Connect } from '@genesislcap/foundation-comms';
 import { UUID } from '@genesislcap/foundation-utils';
+import { DeliveredBlockLedger } from './delivered-block.ledger';
 import { convertDateFilterToCriteria, convertNumberFilterToCriteria, convertSetFilterToCriteria, convertTextFilterToCriteria, } from './filter.utils';
 /**
  * Base class for server-side resource datasources used in Grid Pro SSRM implementations.
@@ -11,6 +12,12 @@ import { convertDateFilterToCriteria, convertNumberFilterToCriteria, convertSetF
 export class BaseServerSideDatasource {
     constructor(options) {
         this.rowData = new Map();
+        /**
+         * Bumped whenever the rows the grid holds are dropped (destroy, refresh, reload). A req/rep
+         * reply that resolves for an earlier generation belongs to a cache the grid no longer has.
+         * @internal
+         */
+        this.loadGeneration = 0;
         /**
          * The number of rows in the grid. THIS DO NOT CONSIDER CRITERIA_MATCH scenarios.
          * @internal
@@ -28,6 +35,8 @@ export class BaseServerSideDatasource {
         this.errorHandlerFunc = options.errorHandlerFunc;
         this.onNoDataAvailableFunc = options.onNoDataAvailableFunc;
         this.onDataAvailableFunc = options.onDataAvailableFunc;
+        this.onRowsDeliveredFunc = options.onRowsDeliveredFunc;
+        this.onRowsWithdrawnFunc = options.onRowsWithdrawnFunc;
         this.resourceName = options.resourceName;
         this.resourceParams = options.resourceParams;
         this.originalCriteriaMatch = this.getResourceParam('CRITERIA_MATCH');
@@ -36,6 +45,7 @@ export class BaseServerSideDatasource {
         this.maxRows = options.maxRows;
         this.maxView = options.maxView;
         this.rowId = options.rowId;
+        this.ledger = new DeliveredBlockLedger(options.rowId);
     }
     /**
      * Gets a resource parameter, handling both REQUEST_SERVER (DETAILS structure) and DATASERVER (flat structure)
@@ -116,6 +126,7 @@ export class BaseServerSideDatasource {
         });
     }
     destroy() {
+        this.invalidatePendingLoads();
         this.rowData = new Map();
         this.clientRowsCount = 0;
         this.calculatedRowsCount = 0;
@@ -125,6 +136,15 @@ export class BaseServerSideDatasource {
         this.sourceRef = undefined;
         this.lastSuccessRowData = undefined;
     }
+    /**
+     * Marks every block request still in flight as stale: the grid is dropping the cache they were
+     * read for, so their replies must not be handed to the host as held rows.
+     * @internal
+     */
+    invalidatePendingLoads() {
+        this.loadGeneration += 1;
+        this.ledger.clear();
+    }
     refreshDatasource(params) {
         return __awaiter(this, void 0, void 0, function* () {
             this.destroy();
@@ -287,6 +307,9 @@ export class BaseServerSideDatasource {
     completeEmptyResult(params) {
         var _a, _b;
         if ((_b = (_a = this.lastSuccessRowData) === null || _a === void 0 ? void 0 : _a.rowData) === null || _b === void 0 ? void 0 : _b.length) {
+            // Re-serving the previous block's snapshot keeps the SSRM request from hanging; it is not a
+            // delivery of new rows, so it is not reported - the snapshot may predate a poll that has
+            // since reported those rows changed or removed.
             params.success(this.lastSuccessRowData);
             return;
         }
@@ -295,6 +318,22 @@ export class BaseServerSideDatasource {
         params.success(successRowData);
         this.notifyNoDataAvailableIfEmpty(params, successRowData);
     }
+    /**
+     * Reports rows handed to the grid for the block at `startRow`, 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;
+        const delivered = rows !== null && rows !== void 0 ? rows : [];
+        const { withdrawnRowIds } = this.ledger.record(startRow, delivered);
+        if (delivered.length > 0) {
+            (_a = this.onRowsDeliveredFunc) === null || _a === void 0 ? void 0 : _a.call(this, delivered);
+        }
+        if (withdrawnRowIds.length > 0) {
+            (_b = this.onRowsWithdrawnFunc) === null || _b === void 0 ? void 0 : _b.call(this, withdrawnRowIds);
+        }
+    }
     /** Invokes `onNoDataAvailableFunc` when the first SSRM block has no rows. @internal */
     notifyNoDataAvailableIfEmpty(params, successRowData) {
         var _a;

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

@@ -1,13 +1,24 @@
 import { __awaiter } from "tslib";
-import { MessageType, dataServerResultFilter, logger, } from '@genesislcap/foundation-comms';
+import { MessageType, logger, } from '@genesislcap/foundation-comms';
 import { DOM } from '@microsoft/fast-element';
 import { getAvailableIndexes, getAvailableIndexFields } from '../utils';
+import { filterDataserverResult } from './dataserver-result.filter';
 import { BaseServerSideDatasource } from './server-side.resource-base';
 /**
  * The DATASERVER IServerSideDatasource implementation, used for SSRM (Server-Side Row Model) in the grid.
  * @beta
  */
 export class DataserverServerSideDatasource extends BaseServerSideDatasource {
+    /**
+     * Whether the cache holds a change the grid's rows do not reflect (a tombstoned DELETE), in
+     * which case a block must not be served from it: the slice would hand back a deleted row.
+     * @remarks Derived rather than a flag of its own, so an INSERT that brings a tombstoned id
+     * back clears it along with the tombstone instead of leaving the cache marked stale forever.
+     * @internal
+     */
+    get cacheOutOfStep() {
+        return this.retainedDeletedRowIds.size > 0 || this.structuralPushPending;
+    }
     constructor(options) {
         super(options);
         /**
@@ -23,6 +34,24 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
          * @internal
          */
         this.deliveredRowCount = 0;
+        /**
+         * Ids of rows the server deleted that stay in the cache because the grid was not told
+         * (`live-updates` off) and they sit below the delivered watermark - see
+         * handleCurrentStreamLoad. They are not reported to the host as rows the grid holds, and
+         * their presence marks the cache out of step, so a re-read purges rather than serves them.
+         * @internal
+         */
+        this.retainedDeletedRowIds = new Set();
+        /**
+         * Set when a pushed INSERT landed after rows were handed to the grid, so the cache's insertion
+         * order no longer matches the grid's row indices. Cleared when the cache is rebuilt.
+         * @internal
+         */
+        this.structuralPushPending = false;
+        /** Whether the first batch of the current subscription has arrived. @internal */
+        this.streamStarted = false;
+        /** Whether a MORE_ROWS request is awaiting its batch. @internal */
+        this.moreRowsInFlight = false;
         this.createDataserverStreamFunc = options.createDataserverStreamFunc;
     }
     refreshDatasource(params) {
@@ -36,6 +65,10 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             this.dataserverStreamSubscription = undefined;
             this.dataserverStream = undefined;
             this.deliveredRowCount = 0;
+            this.retainedDeletedRowIds.clear();
+            this.structuralPushPending = false;
+            this.streamStarted = false;
+            this.moreRowsInFlight = false;
             yield _super.refreshDatasource.call(this, params);
         });
     }
@@ -69,6 +102,16 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             // when it already covers this block, or the stream ended, no further stream messages
             // will arrive for this request - resolve it synchronously from the cache.
             const blockAlreadyCovered = this.currentSequenceId >= 1 && (this.rowData.size >= blockEndRow || !this.moreRows);
+            // A re-read is the moment the grid asks for current rows. When the cache holds a change the
+            // grid never saw (a DELETE it was not told about), serving the slice would hand back the
+            // deleted row, so refresh instead: the grid drops every block and re-reads from the server.
+            // fail() releases the request slot, as for a superseded filter or sort change above.
+            if (blockAlreadyCovered && this.cacheOutOfStep) {
+                logger.debug(`SSRM block ${blockStartRow}-${blockEndRow} for ${this.resourceName} re-read while the cache is out of step with the grid; refreshing`);
+                yield this.refreshDatasource(params);
+                params.fail();
+                return;
+            }
             if (this.currentSequenceId >= 1 &&
                 !blockAlreadyCovered &&
                 (this.moreRows || params.request.startRow >= Number(this.maxRows))) {
@@ -76,6 +119,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                     ? Number(this.resourceParams.VIEW_NUMBER)
                     : 0;
                 if (Number.isFinite(viewNumber)) {
+                    this.moreRowsInFlight = true;
                     this.connect.getMoreRows(this.sourceRef, viewNumber);
                 }
             }
@@ -109,6 +153,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                 successRowData.rowCount = this.getCorrectRowCount(params);
                 this.lastSuccessRowData = successRowData;
                 params.success(successRowData);
+                this.deliverRows(blockStartRow, successRowData.rowData.filter((row) => !this.retainedDeletedRowIds.has(row === null || row === void 0 ? void 0 : row[this.rowId])));
                 this.notifyNoDataAvailableIfEmpty(params, successRowData);
             };
             const failBlock = (timer) => {
@@ -191,7 +236,7 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
      * @internal
      */
     dispatchStreamMessage(dataserverResult) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         const messageType = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MESSAGE_TYPE;
         if (messageType &&
             (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
@@ -204,13 +249,28 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             this.moreRows = dataserverResult.MORE_ROWS;
         }
         if (dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) {
-            const nextMessage = dataServerResultFilter(dataserverResult, this.rowId);
-            this.handleCurrentStreamLoad(nextMessage);
+            const nextMessage = filterDataserverResult(dataserverResult, this.rowId);
+            // A DATASERVER subscription is live by definition, so every batch is either the page a
+            // block asked for or a change the server pushed. Replies only ever carry view rows
+            // (INSERTs), so a batch holding a MODIFY or a DELETE is a push whenever it arrives.
+            // Otherwise the batch is the reply we are waiting on: a request is outstanding
+            // (`moreRowsInFlight`), a block is pending, or this is the logon batch.
+            //
+            // `pendingBlocks.size === 0` alone is not enough: the 10s safety valve settles a block
+            // short while its MORE_ROWS is still outstanding, and GSF splits one reply across
+            // messages, so the real page can arrive with no block waiting. Treating that as a push
+            // prepended it to the cache and shifted every later block's slice against the grid.
+            const carriesPushedChanges = ((_b = (_a = nextMessage.updates) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0 || ((_d = (_c = nextMessage.deletes) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;
+            const solicited = !carriesPushedChanges &&
+                (this.moreRowsInFlight || this.pendingBlocks.size > 0 || !this.streamStarted);
+            this.moreRowsInFlight = false;
+            this.streamStarted = true;
+            this.handleCurrentStreamLoad(nextMessage, solicited);
             this.currentSequenceId = dataserverResult.SEQUENCE_ID;
             if (this.currentSequenceId === 1) {
                 this.sourceRef = dataserverResult.SOURCE_REF;
                 if (this.serverRowsCount === 0) {
-                    this.serverRowsCount = (_a = dataserverResult.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
+                    this.serverRowsCount = (_e = dataserverResult.ROWS_COUNT) !== null && _e !== void 0 ? _e : this.rowData.size;
                 }
             }
         }
@@ -290,22 +350,40 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             (_a = this.dataserverStreamSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
             this.dataserverStreamSubscription = undefined;
             this.deliveredRowCount = 0;
+            this.retainedDeletedRowIds.clear();
+            this.structuralPushPending = false;
+            this.streamStarted = false;
+            this.moreRowsInFlight = false;
             yield _super.destroy.call(this);
         });
     }
-    handleCurrentStreamLoad(result) {
+    handleCurrentStreamLoad(result, solicited) {
         var _a, _b, _c, _d, _e;
         if (!result)
             return;
         // Infinite scroll accumulates a session-cumulative cache, as GSF splits batches across
         // messages and later batches append. Map preserves insertion order, so the cache can be
-        // sliced by block range.
+        // sliced by block range - which only works while the cache and the grid agree on where
+        // every delivered row sits, so a pushed change below the delivered watermark is kept out of
+        // the delivered region and deferred to a refresh.
         const rows = new Map(this.rowData);
         (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
-            rows.set(insertData[this.rowId], insertData);
+            const key = insertData[this.rowId];
+            this.retainedDeletedRowIds.delete(key);
+            // A key the cache already holds keeps its slot, so nothing shifts - that is how a DELETE
+            // that was tombstoned and then re-inserted puts the cache back in step with the grid.
+            const isNewToCache = !rows.has(key);
+            rows.set(key, insertData);
+            if (!solicited && isNewToCache && this.deliveredRowCount > 0) {
+                // A page appends in view order, so it keeps the cache and the grid aligned. A push does
+                // not: nothing in the batch says where the server sorts the new row, and the host puts
+                // it at the top of a live grid, so from here on the cache cannot be sliced against the
+                // grid's indices. Mark it, and let the next read of a covered block refresh instead.
+                this.structuralPushPending = true;
+            }
         });
         // Live QUERY_UPDATE messages can arrive while a block is pending: MODIFY rows may be
-        // partial, so merge into the cached row instead of clobbering it; DELETE rows drop out.
+        // partial, so merge into the cached row instead of clobbering it.
         (_b = result.updates) === null || _b === void 0 ? void 0 : _b.forEach((updateData) => {
             const key = updateData === null || updateData === void 0 ? void 0 : updateData[this.rowId];
             if (key === undefined) {
@@ -316,28 +394,37 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
         });
         (_c = result.deletes) === null || _c === void 0 ? void 0 : _c.forEach((deleteData) => {
             const key = deleteData === null || deleteData === void 0 ? void 0 : deleteData[this.rowId];
-            if (key === undefined) {
+            if (key === undefined || !rows.has(key)) {
                 return;
             }
-            // Rows already handed to AG Grid sit at fixed absolute indices; removing them from
-            // the cumulative cache would shift slice() offsets for later blocks.
-            if (this.deliveredRowCount > 0) {
-                let index = 0;
-                for (const mapKey of rows.keys()) {
-                    if (mapKey === key) {
-                        if (index < this.deliveredRowCount) {
-                            return;
-                        }
-                        break;
-                    }
-                    index += 1;
-                }
+            const index = this.cacheIndexOf(rows, key);
+            if (index < this.deliveredRowCount) {
+                // The grid still shows the row at this index. Dropping it would shift every later
+                // block's slice against the grid, so keep its slot and let the next re-read refresh.
+                //
+                // Whether the host also removed it from the grid is not knowable here: the host applies
+                // live updates from a second, independent DATA_LOGON whose view is not paged with this
+                // one, so a delete this stream sees need not have reached the grid at all. Keeping the
+                // slot is correct either way - the refresh reconciles both.
+                this.retainedDeletedRowIds.add(key);
+                return;
             }
             rows.delete(key);
         });
         this.clientRowsCount += (_e = (_d = result.inserts) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0;
         this.rowData = rows;
     }
+    /** Position of a key in the cache's insertion order. @internal */
+    cacheIndexOf(rows, key) {
+        let index = 0;
+        for (const mapKey of rows.keys()) {
+            if (mapKey === key) {
+                return index;
+            }
+            index += 1;
+        }
+        return -1;
+    }
 }
 /**
  * Max time a non-paginated SSRM block may stay pending before the safety valve in

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

@@ -39,6 +39,9 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
     }
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Taken before the first await: a reload that lands anywhere between here and the reply
+            // means the block cache this request was read for is gone.
+            const generation = this.loadGeneration;
             if (yield this.setupFiltering(params)) {
                 params.fail();
                 return;
@@ -54,6 +57,14 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
                 DETAILS: this.buildRequestDetails(),
             };
             const requestResult = yield this.createReqRepRequestFunc(requestParams);
+            // The cache this block was read for was dropped while the request was in flight (a filter,
+            // sort or criteria change): the reply must not be handed to the host as rows the grid holds.
+            // fail() still frees AG Grid's concurrent-request slot; the purge already dropped the block.
+            if (generation !== this.loadGeneration) {
+                logger.debug('SSRM req/rep reply discarded: the block cache was reset while it was in flight');
+                params.fail();
+                return;
+            }
             // Apply the result to the grid
             this.applyServerSideData(params, requestResult);
             // If polling enabled, schedule stream creation after user stops scrolling
@@ -117,13 +128,18 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
         successRowData.rowCount = this.getCorrectRowCount(params);
         this.lastSuccessRowData = successRowData;
         params.success(successRowData);
+        this.deliverRows(params.request.startRow, successRowData.rowData);
         this.notifyNoDataAvailableIfEmpty(params, successRowData);
     }
     getCorrectRowCount(params) {
         let rowCount;
         if (this.moreRows) {
-            // More data available, return -1 to indicate unknown total
-            rowCount = -1;
+            // More data may follow, so the total is not known yet. It has to be left undefined:
+            // `rowCount` is a row count, not the infinite row model's `lastRow`, so -1 is taken
+            // literally. A store told it holds -1 rows never reaches the block it just received,
+            // so AG Grid asks for the same blocks again as fast as it can - a request loop that
+            // pins the main thread and floods the server with REQUEST_SERVER snapshots.
+            rowCount = undefined;
         }
         else {
             // Use discovered total if available, otherwise calculate from current position
@@ -281,7 +297,13 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
         return {
             CRITERIA_MATCH: this.resourceParams.DETAILS.CRITERIA_MATCH,
             MAX_ROWS: this.resourceParams.DETAILS.MAX_ROWS,
-            ORDER_BY: this.resourceParams.DETAILS.ORDER_BY,
+            // Fall back to the row id when the user has not sorted, as the infinite datasource does.
+            // OFFSET paging is only correct over a stable order: an unsorted req/rep returns rows in
+            // an unspecified order that differs between requests, so consecutive pages overlap and
+            // skip. AG Grid then receives the same row id in two blocks, refuses the store it just
+            // built, and re-requests both blocks - a loop that runs as fast as the server can answer.
+            // The row id is unique and always sortable, giving every page a deterministic window.
+            ORDER_BY: this.resourceParams.DETAILS.ORDER_BY || `${this.rowId} ASC`,
             OFFSET: this.resourceParams.DETAILS.OFFSET,
         };
     }

package/dist/esm/grid-pro-beta.js

@@ -484,11 +484,25 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      */
     handleDataChanged(event) {
         const { changes } = event.detail;
-        if (!this.gridApi)
+        // Every datasource emits this for consumers, but only the client-side row model takes row
+        // transactions: the infinite and server-side datasources drive the grid through
+        // refresh-infinite-cache / apply-server-side-transaction, and applyTransaction on those
+        // models is a no-op that logs an AG Grid warning per event.
+        if (!this.gridApi || !this.isClientSideRowModel)
             return;
         const result = this.gridApi.applyTransaction(changes);
         this.flashAddedCells(result === null || result === void 0 ? void 0 : result.add);
     }
+    /**
+     * Whether the live grid runs AG Grid's client-side row model (the default when the datasource
+     * set no `rowModelType`).
+     * @internal
+     */
+    get isClientSideRowModel() {
+        var _a, _b, _c;
+        const rowModelType = (_c = (_b = (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.getGridOption) === null || _b === void 0 ? void 0 : _b.call(_a, 'rowModelType')) !== null && _c !== void 0 ? _c : 'clientSide';
+        return rowModelType === 'clientSide';
+    }
     flashAddedCells(rowNodes) {
         if (this.enableRowFlashing && (rowNodes === null || rowNodes === void 0 ? void 0 : rowNodes.length)) {
             this.gridApi.flashCells({ rowNodes });
@@ -601,7 +615,11 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         if (includeSchema) {
             this.gridApi.setGridOption('columnDefs', []);
         }
-        this.gridApi.setGridOption('rowData', []);
+        // rowData belongs to the client-side row model; the infinite and server-side caches are
+        // cleared by their own refresh / transaction events.
+        if (this.isClientSideRowModel) {
+            this.gridApi.setGridOption('rowData', []);
+        }
         this.gridApi.refreshCells({ force: true });
     }
     /**

package/dist/esm/grid-pro.js

@@ -414,7 +414,10 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
     handleDataChanged(event) {
         var _a, _b, _c;
         const { changes } = event.detail;
-        if (!this.gridApi)
+        // Every datasource emits this for consumers, but row transactions are a client-side row
+        // model API: the server-side datasource drives the grid through apply-server-side-transaction,
+        // and applyTransaction on that model is a no-op that logs an AG Grid warning per event.
+        if (!this.gridApi || this.isServerSide)
             return;
         if (((_a = changes.add) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             if (this.asyncAdd) {