@genesislcap/grid-pro 14.480.0 → 14.481.1-alpha-69af5f8.0

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

@@ -27,9 +27,32 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            // Use separated filtering and sorting setup
-            yield this.setupFiltering(params);
-            yield this.setupSorting(params);
+            // setupFiltering()/setupSorting() return true when they triggered refreshDatasource()
+            // internally (a filter/sort change). In that case reloadResourceData() has already
+            // re-initialized the underlying datasource and - only AFTER that init completed - purged
+            // AG Grid's SSRM cache, which makes AG Grid re-invoke getRows() with fresh params. This
+            // (now superseded) invocation must therefore stop here: continuing would race the re-init
+            // and attach a second subscription for stale params. That race was the root cause of two
+            // observed bugs: rows from the PREVIOUS criteria leaking into the new filter's result set,
+            // and broken loads when the stale call recreated the stream on a destroyed datasource.
+            //
+            // CRITICAL: the superseded request MUST still be resolved via params.fail() - never left
+            // dangling. AG Grid's RowNodeBlockLoader caps concurrent datasource requests
+            // (maxConcurrentDatasourceRequests, default 2) and only releases a slot when
+            // success()/fail() is invoked. A silent return leaks the slot FOREVER; after two
+            // filter/sort changes both slots are gone and the grid permanently stops issuing
+            // getRows() - no purge, scroll or new filter can ever revive it (observed as: clearing
+            // a filter leaves an empty grid, re-filtering does nothing). fail() here is safe: the
+            // purge already destroyed the cache this request belongs to, and LazyCache.onLoadFailed
+            // no-ops on a dead cache (guarded internally) - so the only effect is freeing the slot.
+            if (yield this.setupFiltering(params)) {
+                params.fail();
+                return;
+            }
+            if (yield this.setupSorting(params)) {
+                params.fail();
+                return;
+            }
             if (this.pagination && !this.isNewPageSize && this.currentSequenceId > 0) {
                 const requestFilter = JSON.stringify((_a = params.request.filterModel) !== null && _a !== void 0 ? _a : {});
                 const currentFilter = JSON.stringify((_b = this.currentFilterModel) !== null && _b !== void 0 ? _b : {});
@@ -41,7 +64,21 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             if (!this.dataserverStream) {
                 this.dataserverStream = yield this.createDataserverStreamFunc(this.resourceParams);
             }
+            const blockStartRow = Number.isFinite(Number(params.request.startRow))
+                ? Number(params.request.startRow)
+                : 0;
+            const blockEndRow = Number.isFinite(Number(params.request.endRow))
+                ? Number(params.request.endRow)
+                : blockStartRow + Number(this.maxRows);
+            // Infinite scroll keeps a session-cumulative row cache (see handleCurrentStreamLoad);
+            // when it already covers this block (AG Grid re-requesting a purged block, or an earlier
+            // over-delivery prefetched it), or the stream already ended, no further stream messages
+            // may ever arrive for this request - it must be resolved from the cache, synchronously.
+            const blockAlreadyCovered = !this.pagination &&
+                this.currentSequenceId >= 1 &&
+                (this.rowData.size >= blockEndRow || !this.moreRows);
             if (this.currentSequenceId >= 1 &&
+                !blockAlreadyCovered &&
                 (this.moreRows || params.request.startRow >= Number(this.maxRows))) {
                 if (this.pagination) {
                     const startRow = Number.isFinite(Number(params.request.startRow))
@@ -58,16 +95,80 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                     this.connect.getMoreRows(this.sourceRef, viewNumber);
                 }
             }
+            // NOTE: getRows() deliberately does NOT unsubscribe previous subscriptions here - this
+            // stream is tied to a live server-side feed (a DATA_LOGON session), and .unsubscribe()
+            // sends DATA_LOGOFF to the SERVER, killing the whole session (confirmed: every later
+            // block request failed outright after an experimental per-block unsubscribe). Earlier
+            // subscriptions go inert via their own applyResult flag once resolved.
             let applyResult = true;
+            const clearSafetyTimer = (timer) => {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+            };
+            const resolveBlock = (timer) => {
+                if (!applyResult) {
+                    return;
+                }
+                applyResult = false;
+                clearSafetyTimer(timer);
+                const allRows = Array.from(this.rowData.values());
+                const successRowData = {
+                    // Non-pagination: deliver only THIS block's slice of the session-cumulative
+                    // cache - AG Grid SSRM expects each request to receive exactly the rows for its
+                    // own startRow..endRow range, not everything loaded so far.
+                    rowData: this.pagination ? allRows : allRows.slice(blockStartRow, blockEndRow),
+                };
+                successRowData.rowCount = this.getCorrectRowCount(params);
+                this.lastSuccessRowData = successRowData;
+                params.success(successRowData);
+                this.notifyNoDataAvailableIfEmpty(params, successRowData);
+            };
+            if (blockAlreadyCovered) {
+                resolveBlock();
+                return;
+            }
+            // Safety valve: a block must never stay pending forever if the stream goes quiet without
+            // delivering a full batch (anomalous, but an eternally-spinning grid is the worst outcome).
+            // Resolving short with the honest accumulated count makes AG Grid end the dataset there.
+            const safetyTimer = setTimeout(() => {
+                if (applyResult) {
+                    logger.warn(`SSRM block ${blockStartRow}-${blockEndRow} for ${this.resourceName} timed out waiting for a full batch; resolving with ${this.rowData.size} accumulated row(s).`);
+                    resolveBlock(safetyTimer);
+                }
+            }, DataserverServerSideDatasource.BLOCK_RESOLVE_TIMEOUT_MS);
             this.dataserverStreamSubscription = this.dataserverStream.subscribe((dataserverResult) => {
                 var _a;
-                const incomingRowCount = (_a = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.ROW) === null || _a === void 0 ? void 0 : _a.length;
-                const shouldApply = applyResult || (incomingRowCount > 0 && this.rowData.size === 0);
-                if (shouldApply) {
+                if (!applyResult) {
+                    // This request already resolved - later messages belong to the next block's
+                    // subscription, which processes them itself.
+                    return;
+                }
+                const messageType = dataserverResult === null || dataserverResult === void 0 ? void 0 : dataserverResult.MESSAGE_TYPE;
+                if (messageType &&
+                    (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
+                    applyResult = false;
+                    clearSafetyTimer(safetyTimer);
+                    if (this.errorHandlerFunc) {
+                        const errorMessage = messageType === MessageType.LOGOFF_ACK
+                            ? `Connection lost to ${this.resourceName}`
+                            : `Authentication failed for ${this.resourceName}`;
+                        this.errorHandlerFunc(errorMessage, 'connection');
+                    }
+                    params.fail();
+                    return;
+                }
+                if (this.pagination) {
+                    // Original vendor behaviour for paginated mode: each message resolves the
+                    // request (page swap), including the corrective snapshot() workaround for GSF's
+                    // criteria-blind ROWS_COUNT.
                     DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
                         var _a, _b;
+                        if (!applyResult) {
+                            return;
+                        }
                         // TODO: this is a bit of hack, due GSF not returning a different ROWS_COUNT when there is a CRITERIA_MATCH
-                        if (this.resourceParams.CRITERIA_MATCH && this.pagination) {
+                        if (this.resourceParams.CRITERIA_MATCH && !this.criteriaRowCountResolved) {
                             const updatedInfo = yield this.connect.snapshot(this.resourceName, {
                                 MAX_ROWS: this.maxView,
                                 MAX_VIEW: this.maxView,
@@ -79,14 +180,55 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                                 this.clientRowsCount = 0;
                             }
                             else {
-                                this.serverRowsCount = this.resourceParams.CRITERIA_MATCH
-                                    ? ((_b = (_a = updatedInfo.ROW) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : updatedInfo.ROWS_COUNT)
-                                    : updatedInfo.ROWS_COUNT;
+                                // Neither field alone is trustworthy: GSF's ROWS_COUNT ignores
+                                // CRITERIA_MATCH (full unfiltered total), while ROW.length is capped at the
+                                // server's page size. Math.max can over-report (safe/self-correcting once
+                                // the stream signals no more rows) but never under-reports - the dangerous
+                                // direction, as AG Grid stops requesting blocks once the count is reached.
+                                const rowsCount = (_a = updatedInfo.ROWS_COUNT) !== null && _a !== void 0 ? _a : 0;
+                                const rowLength = (_b = updatedInfo.ROW) === null || _b === void 0 ? void 0 : _b.length;
+                                this.serverRowsCount =
+                                    rowLength !== undefined ? Math.max(rowsCount, rowLength) : rowsCount;
                             }
+                            this.criteriaRowCountResolved = true;
                         }
+                        clearSafetyTimer(safetyTimer);
                         this.applyServerSideData(params, dataserverResult);
                         applyResult = false;
                     }));
+                    return;
+                }
+                // Infinite scroll: GSF delivers one MAX_ROWS batch split across SEVERAL stream
+                // messages when a selective CRITERIA_MATCH makes matches sparse (observed on a live
+                // trace: SEQUENCE_IDs 1-7 carrying 14+17+7+12+22+25+3 = exactly 100 = MAX_ROWS rows).
+                // Resolving on the first message - the previous behaviour - handed AG Grid a fraction
+                // of the block and dropped the rest, which rendered as "ERR" stub rows. Instead,
+                // accumulate every message into the session cache and resolve only once this block's
+                // full extent is covered or the dataset genuinely ended.
+                if (dataserverResult && dataserverResult.MORE_ROWS !== undefined) {
+                    this.moreRows = dataserverResult.MORE_ROWS;
+                }
+                if (dataserverResult && dataserverResult.ROW) {
+                    const nextMessage = dataServerResultFilter(dataserverResult);
+                    this.handleCurrentStreamLoad(nextMessage);
+                    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;
+                        }
+                    }
+                }
+                else if (this.currentSequenceId === 0 && !this.moreRows) {
+                    // The session's very first response carries no rows at all - the criteria
+                    // matches nothing; resolve as empty instead of waiting for the timeout.
+                    applyResult = false;
+                    clearSafetyTimer(safetyTimer);
+                    this.completeEmptyResult(params);
+                    return;
+                }
+                if (this.rowData.size >= blockEndRow || !this.moreRows) {
+                    DOM.queueUpdate(() => resolveBlock(safetyTimer));
                 }
             });
         });
@@ -134,10 +276,11 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
             if (this.serverRowsCount === 0) {
                 this.serverRowsCount = (_a = result.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
             }
-            if (this.getResourceParam('CRITERIA_MATCH') && result.ROW) {
-                this.serverRowsCount = result.ROW.length;
-                this.clientRowsCount = result.ROW.length;
-            }
+            // NOTE: deliberately NOT overriding serverRowsCount with result.ROW.length under
+            // CRITERIA_MATCH here (previous behaviour). ROW.length is just the first batch's size,
+            // not the total match count - the override clobbered the corrected count resolved by
+            // the snapshot() workaround in getRows() and made AG Grid stop requesting further
+            // blocks after the first one.
         }
         const successRowData = {
             rowData: Array.from(this.rowData.values()),
@@ -163,31 +306,39 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
                     this.resourceParams.ORDER_BY = null;
                     this.resourceParams.REVERSE = null;
                     yield this.refreshDatasource(params);
-                    return;
+                    // true = this request is superseded; the caller (getRows) must stop - see the
+                    // matching contract on setupFiltering() in server-side.resource-base.ts.
+                    return true;
                 }
                 else if (toBeAppliedSortModel.length > 0) {
                     const coldIdBeingSorted = toBeAppliedSortModel[0].colId; // Not allowing multiple sorts by user
                     const sortTypeBeingApplied = toBeAppliedSortModel[0].sort;
                     const orderByAndToBeSortedColIds = this.getOrderByAndToBeSortedColIds(this.resourceIndexes, coldIdBeingSorted);
                     if (!orderByAndToBeSortedColIds) {
-                        this.calculatedRowsCount = 0;
                         const availableIndexes = getAvailableIndexes(this.resourceIndexes);
                         const availableIndexFields = getAvailableIndexFields(this.resourceIndexes);
-                        logger.warn(`The FIELD/column (${coldIdBeingSorted}) being sorted is not part of an INDEX, required for the [orderBy] operation. See https://learn.genesis.global/docs/database/data-types/index-entities/`);
+                        logger.warn(`The FIELD/column (${coldIdBeingSorted}) being sorted is not part of an INDEX, required for the [orderBy] operation - ignoring this sort and loading unsorted data. See https://learn.genesis.global/docs/database/data-types/index-entities/`);
                         logger.debug('Available indexes:', availableIndexes);
                         logger.debug('Columns that can be sorted with the available indexes:', availableIndexFields);
-                        params.fail();
-                        return;
+                        // Ignore the un-sortable sort instead of failing the request. Failing here killed
+                        // the ENTIRE first load (single "ERR" row, nothing ever loads) when a RESTORED
+                        // grid workspace/settings carried a sort on a non-indexed column - the user had no
+                        // way to recover except clearing the sort manually. Remember the model so
+                        // identical follow-up requests don't re-warn, leave ORDER_BY/REVERSE untouched,
+                        // and let getRows() carry on unsorted.
+                        this.currentSortModel = toBeAppliedSortModel;
+                        return false;
                     }
                     else if (JSON.stringify(toBeAppliedSortModel) !== JSON.stringify(this.currentSortModel)) {
                         this.currentSortModel = toBeAppliedSortModel;
                         this.resourceParams.ORDER_BY = orderByAndToBeSortedColIds.orderBy;
                         this.resourceParams.REVERSE = sortTypeBeingApplied === 'desc' ? true : false;
                         yield this.refreshDatasource(params);
-                        return;
+                        return true;
                     }
                 }
             }
+            return false;
         });
     }
     destroy() {
@@ -203,14 +354,45 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
         });
     }
     handleCurrentStreamLoad(result) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         if (!result)
             return;
-        const rows = new Map();
+        // Pagination swaps whole pages, so each message replaces the buffer (original behaviour).
+        // Infinite scroll instead accumulates a session-cumulative cache: GSF splits one MAX_ROWS
+        // batch across several incremental messages when a CRITERIA_MATCH filter is selective, and
+        // later batches append after earlier ones - replacing the buffer on every message threw
+        // away all but the latest fragment (see the accumulation comment in getRows()). Maps
+        // preserve insertion order, so the cache stays in server delivery order and can be sliced
+        // by block range.
+        const rows = this.pagination ? new Map() : new Map(this.rowData);
         (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
             rows.set(insertData[this.rowId], insertData);
         });
-        this.clientRowsCount += (_b = result.inserts.length) !== null && _b !== void 0 ? _b : 0;
+        // Live QUERY_UPDATE messages can arrive on this stream while a block is pending: MODIFY
+        // rows may be partial (only changed fields), so merge them into the cached row rather than
+        // clobbering it; DELETE rows drop out of the cache. (Previously an update/delete-only
+        // message replaced the whole buffer with an EMPTY map, wiping every loaded row.)
+        (_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) {
+                return;
+            }
+            const existing = rows.get(key);
+            rows.set(key, existing ? Object.assign(Object.assign({}, existing), updateData) : updateData);
+        });
+        (_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) {
+                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;
     }
 }
+/**
+ * How long a non-paginated SSRM block may stay pending before it is force-resolved with
+ * whatever rows have accumulated so far. See the safety valve in getRows().
+ * @internal
+ */
+DataserverServerSideDatasource.BLOCK_RESOLVE_TIMEOUT_MS = 10000;

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

@@ -255,7 +255,7 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
                     this.currentSortModel = null;
                     this.resourceParams.DETAILS.ORDER_BY = undefined;
                     yield this.refreshDatasource(params);
-                    return;
+                    return true;
                 }
                 else if (toBeAppliedSortModel.length > 0) {
                     const coldIdBeingSorted = toBeAppliedSortModel[0].colId; // Not allowing multiple sorts by user
@@ -266,10 +266,11 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
                         this.resourceParams.DETAILS.ORDER_BY =
                             coldIdBeingSorted + (sortTypeBeingApplied === 'desc' ? ' DESC' : ' ASC'); // Use the column directly
                         yield this.refreshDatasource(params);
-                        return;
+                        return true;
                     }
                 }
             }
+            return false;
         });
     }
     refreshDatasource(params) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/grid-pro",
   "description": "Genesis Foundation AG Grid",
-  "version": "14.480.0",
+  "version": "14.481.1-alpha-69af5f8.0",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -40,20 +40,20 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "14.480.0",
-    "@genesislcap/genx": "14.480.0",
-    "@genesislcap/rollup-builder": "14.480.0",
-    "@genesislcap/ts-builder": "14.480.0",
-    "@genesislcap/uvu-playwright-builder": "14.480.0",
-    "@genesislcap/vite-builder": "14.480.0",
-    "@genesislcap/webpack-builder": "14.480.0"
+    "@genesislcap/foundation-testing": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/genx": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/rollup-builder": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/ts-builder": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/uvu-playwright-builder": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/vite-builder": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/webpack-builder": "14.481.1-alpha-69af5f8.0"
   },
   "dependencies": {
-    "@genesislcap/foundation-comms": "14.480.0",
-    "@genesislcap/foundation-criteria": "14.480.0",
-    "@genesislcap/foundation-logger": "14.480.0",
-    "@genesislcap/foundation-ui": "14.480.0",
-    "@genesislcap/foundation-utils": "14.480.0",
+    "@genesislcap/foundation-comms": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/foundation-criteria": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/foundation-logger": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/foundation-ui": "14.481.1-alpha-69af5f8.0",
+    "@genesislcap/foundation-utils": "14.481.1-alpha-69af5f8.0",
     "@microsoft/fast-colors": "5.3.1",
     "@microsoft/fast-components": "2.30.6",
     "@microsoft/fast-element": "1.14.0",
@@ -91,5 +91,5 @@
       "require": "./dist/react.cjs"
     }
   },
-  "gitHead": "6d2bc60f9700ab9f5a6d8c1834baebbd66ae5e6b"
+  "gitHead": "ace4f24de5b1fabb4c07b24fb601a5b797ac6876"
 }