@genesislcap/grid-pro 15.20.2 → 15.21.0

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

@@ -0,0 +1,581 @@
+import { __awaiter } from "tslib";
+import { dataServerResultFilter, MessageType, } from '@genesislcap/foundation-comms';
+import { logger } from '../utils';
+import { convertFilterModelToCriteria } from './filter.utils';
+/**
+ * Converts an AG Grid sort model to the Genesis ORDER_BY form the resource expects.
+ * @remarks The two transports order rows differently, matching what the SSRM datasources send:
+ * - REQUEST_SERVER takes the column directly with the direction inline (`NAME DESC`) and no
+ *   REVERSE flag; the column does not have to belong to an index.
+ * - DATASERVER takes the name of an INDEX containing the column, plus REVERSE. A column outside
+ *   every index cannot be ordered server-side, and neither can an unnamed index.
+ * @param sortModel - The AG Grid sort model
+ * @param resourceIndexes - Available indexes for sorting (DATASERVER)
+ * @param isRequestServer - Whether the resource is a REQUEST_SERVER
+ * @returns Object with orderBy and reverse properties
+ */
+export function convertSortModelToOrderBy(sortModel, resourceIndexes, isRequestServer = false) {
+    if (!sortModel || sortModel.length === 0) {
+        return { orderBy: null, reverse: false };
+    }
+    const sortColumn = sortModel[0]; // Only support single column sort for infinite model
+    const colId = sortColumn.colId;
+    const descending = sortColumn.sort === 'desc';
+    if (isRequestServer) {
+        return { orderBy: `${colId} ${descending ? 'DESC' : 'ASC'}`, reverse: false };
+    }
+    // Find the index that contains this column. An index with no NAME cannot be named in
+    // ORDER_BY, so it is no use for sorting even when it covers the column.
+    for (const [indexName, fields] of resourceIndexes.entries()) {
+        if (indexName && fields.includes(colId)) {
+            return {
+                orderBy: indexName,
+                reverse: descending,
+            };
+        }
+    }
+    // Column not in any usable index - carry on unsorted rather than sending an ORDER_BY the
+    // server will reject, which would empty the grid.
+    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 };
+}
+/**
+ * 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) {
+        /**
+         * 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
+         * batches append.
+         * @internal
+         */
+        this.rowData = new Map();
+        /** Blocks waiting for the cache to reach their range. @internal */
+        this.pendingBlocks = new Set();
+        /** Highest absolute row index already handed to AG Grid. @internal */
+        this.deliveredRowCount = 0;
+        /** False until the first message arrives on the subscription. @internal */
+        this.streamStarted = false;
+        /** Whether a MORE_ROWS request is awaiting its batch. @internal */
+        this.moreRowsInFlight = false;
+        /** Whether the current subscription was opened with a CRITERIA_MATCH. @internal */
+        this.hasCriteria = false;
+        /** So the MAX_VIEW truncation warning is logged once per subscription. @internal */
+        this.viewTruncationWarned = false;
+        this.createSnapshotFunc = options.createSnapshotFunc;
+        this.createDataserverStreamFunc = options.createDataserverStreamFunc;
+        this.getMoreRowsFunc = options.getMoreRowsFunc;
+        this.onRowsInvalidatedFunc = options.onRowsInvalidatedFunc;
+        this.onRowsUpdatedFunc = options.onRowsUpdatedFunc;
+        this.errorHandlerFunc = options.errorHandlerFunc;
+        this.resourceName = options.resourceName;
+        this.resourceParams = Object.assign({}, options.resourceParams);
+        this.resourceIndexes = options.resourceIndexes;
+        this.resourceColDefs = options.resourceColDefs;
+        this.maxRows = options.maxRows;
+        this.rowId = options.rowId;
+        this.baseCriteria = options.baseCriteria || '';
+        this.isRequestServer = options.isRequestServer;
+    }
+    /**
+     * Builds request parameters for REQUEST_SERVER resources.
+     * Uses OFFSET-based pagination.
+     */
+    buildRequestServerParams(startRow, criteria, sortConfig) {
+        const requestParams = Object.assign({}, this.resourceParams);
+        // The captured resourceParams object is reused across getRows calls, so its nested DETAILS
+        // must not be mutated: a CRITERIA_MATCH/ORDER_BY written into it would keep being sent after
+        // the user clears the filter or sort. Copy it, and remove stale keys rather than leaving them.
+        requestParams.DETAILS = Object.assign({}, requestParams.DETAILS);
+        requestParams.DETAILS.MAX_ROWS = this.maxRows;
+        requestParams.DETAILS.OFFSET = startRow;
+        if (criteria) {
+            requestParams.DETAILS.CRITERIA_MATCH = criteria;
+        }
+        else {
+            delete requestParams.DETAILS.CRITERIA_MATCH;
+        }
+        // ORDER_BY already carries the direction for REQUEST_SERVER, so no REVERSE is sent.
+        // Fall back to the row id when the user has not sorted: OFFSET paging is only correct over a
+        // stable order, and an unsorted req/rep returns rows in an unspecified order that can differ
+        // between requests, so consecutive blocks overlap or skip rows. The row id (RECORD_ID by
+        // default) is unique and always sortable, giving every page a deterministic window.
+        requestParams.DETAILS.ORDER_BY = sortConfig.orderBy || `${this.rowId} ASC`;
+        return requestParams;
+    }
+    /**
+     * Builds the DATA_LOGON parameters for the DATASERVER subscription.
+     * @remarks No VIEW_NUMBER is sent: any non-zero value switches the server into pagination
+     * mode, which is not safe to combine with CRITERIA_MATCH (see dataserverStream). MAX_VIEW is
+     * passed through from the resource params and still caps how many rows one view will hold.
+     */
+    buildDataserverLogonParams(criteria, sortConfig) {
+        const params = Object.assign({}, this.resourceParams);
+        params.MAX_ROWS = this.maxRows;
+        delete params.VIEW_NUMBER;
+        if (criteria) {
+            params.CRITERIA_MATCH = criteria;
+        }
+        else {
+            delete params.CRITERIA_MATCH;
+        }
+        if (sortConfig.orderBy) {
+            params.ORDER_BY = sortConfig.orderBy;
+            params.REVERSE = sortConfig.reverse;
+        }
+        else {
+            delete params.ORDER_BY;
+            delete params.REVERSE;
+        }
+        return params;
+    }
+    /**
+     * Determines the last row index from the server response.
+     * @remarks ROWS_COUNT is only trusted when no criteria is in effect - the same rule the
+     * DATASERVER path applies to serverRowsCount - because a server-reported total may ignore
+     * CRITERIA_MATCH, which would give a filtered grid a scrollbar over rows that never arrive.
+     * Under a filter the count stays open-ended until MORE_ROWS reports the end.
+     */
+    getLastRow(result, startRow, rowDataLength, hasCriteria) {
+        if ('MORE_ROWS' in result && result.MORE_ROWS === false) {
+            return startRow + rowDataLength;
+        }
+        if (!hasCriteria && 'ROWS_COUNT' in result && typeof result.ROWS_COUNT === 'number') {
+            return result.ROWS_COUNT;
+        }
+        return -1;
+    }
+    /**
+     * Called by AG Grid when more rows are needed.
+     * Implements the IDatasource.getRows method.
+     */
+    getRows(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug('Infinite getRows called', {
+                startRow: params.startRow,
+                endRow: params.endRow,
+                isRequestServer: this.isRequestServer,
+            });
+            try {
+                // Build filter criteria
+                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);
+                // DATASERVER pages through a persistent subscription; REQUEST_SERVER is stateless and
+                // pages by OFFSET on a fresh request each time.
+                if (!this.isRequestServer) {
+                    this.getDataserverRows(params, combinedCriteria, sortConfig);
+                    return;
+                }
+                const requestParams = this.buildRequestServerParams(params.startRow, combinedCriteria, sortConfig);
+                logger.debug('Infinite datasource request params', requestParams);
+                const result = yield this.createSnapshotFunc(requestParams);
+                if (!result) {
+                    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);
+                    return;
+                }
+                // Fallback - empty result
+                params.successCallback([], params.startRow);
+            }
+            catch (error) {
+                logger.error('Error in infinite getRows:', error);
+                if (this.errorHandlerFunc) {
+                    this.errorHandlerFunc(error instanceof Error ? error.message : String(error), 'unknown');
+                }
+                params.failCallback();
+            }
+        });
+    }
+    /**
+     * Loads one AG Grid block from a DATASERVER resource.
+     * @remarks Blocks are served out of the session-cumulative cache. When the cache does not yet
+     * reach the block, MORE_ROWS pulls the next batch and the block waits; several blocks can be
+     * outstanding at once, and each settles as soon as the cache covers its range.
+     * @internal
+     */
+    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)
+            : startRow + this.maxRows;
+        const block = {
+            startRow,
+            endRow,
+            settled: false,
+            success: params.successCallback,
+            fail: params.failCallback,
+        };
+        // The cache may already cover this block - one batch can span several blocks, and blocks are
+        // re-requested after a purge - and once the stream has ended nothing more will arrive.
+        if (this.streamStarted && (this.rowData.size >= endRow || this.moreRows === false)) {
+            this.settleBlock(block, true);
+            return;
+        }
+        // Safety valve: never leave a block pending forever if the stream goes quiet.
+        block.timer = this.createBlockTimer(block);
+        this.pendingBlocks.add(block);
+        if (!this.dataserverStream) {
+            const logonParams = this.buildDataserverLogonParams(criteria, sortConfig);
+            this.hasCriteria = Boolean(logonParams.CRITERIA_MATCH);
+            this.dataserverStream = this.createDataserverStreamFunc(logonParams);
+            this.dataserverStreamSubscription = this.dataserverStream.subscribe((message) => this.handleDataserverMessage(message));
+            return;
+        }
+        this.pumpMoreRows();
+    }
+    /**
+     * Keeps pulling batches while blocks are still waiting.
+     * @remarks Sequential paging cannot seek, so reaching a block the cache does not cover means
+     * walking to it one batch at a time. One request is kept in flight; each arriving batch drives
+     * the next, until the blocks are covered or the stream ends.
+     * @internal
+     */
+    pumpMoreRows() {
+        if (this.moreRowsInFlight || this.moreRows === false || this.pendingBlocks.size === 0) {
+            return;
+        }
+        // No subscription, or none that has identified itself yet: a MORE_ROWS against a stale
+        // SOURCE_REF is answered with MSG_NACK 404 "Dataserver subscription does not exist", which
+        // then fails every waiting block.
+        if (!this.dataserverStream || !this.dataserverStreamSubscription || !this.sourceRef) {
+            return;
+        }
+        this.moreRowsInFlight = true;
+        void this.requestMoreRows();
+    }
+    /**
+     * Asks the server for the next batch of rows on the current subscription.
+     * @internal
+     */
+    requestMoreRows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The subscription can be torn down between scheduling and running this.
+            if (!this.dataserverStreamSubscription || !this.sourceRef) {
+                this.moreRowsInFlight = false;
+                return;
+            }
+            try {
+                yield this.getMoreRowsFunc(this.sourceRef);
+            }
+            catch (error) {
+                this.moreRowsInFlight = false;
+                // MORE_ROWS only exists as an interaction on a live socket subscription; over HTTP
+                // (feature.forceHttp) the router has no such endpoint and answers 404. Treat the rows
+                // already delivered as the whole view - waiting blocks settle with what arrived and the
+                // grid stops asking - rather than failing every block and erroring again on each scroll.
+                if ((error === null || error === void 0 ? void 0 : error.status) === GenesisInfiniteDatasource.HTTP_NOT_FOUND) {
+                    logger.warn(`Infinite DATASERVER paging is not available on this connection (MORE_ROWS answered 404, expected over HTTP/feature.forceHttp). ${this.resourceName} is truncated to the ${this.rowData.size} row(s) already delivered; use a websocket connection, or a REQUEST_SERVER resource, to page further.`);
+                    this.moreRows = false;
+                    // The MAX_VIEW warning would misdiagnose this truncation as a view cap.
+                    this.viewTruncationWarned = true;
+                    this.settleCoveredBlocks();
+                    return;
+                }
+                logger.error('Infinite DATASERVER MORE_ROWS failed:', error);
+                this.failAllPendingBlocks();
+            }
+        });
+    }
+    /**
+     * Accumulates a stream batch into the cumulative cache and settles whatever it covers.
+     * @internal
+     */
+    handleDataserverMessage(message) {
+        var _a, _b, _c, _d, _e, _f;
+        const messageType = message === null || message === void 0 ? void 0 : message.MESSAGE_TYPE;
+        if (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK) {
+            // Report it (same messages as the SSRM dataserver resource) - without this a logged-off
+            // session just shows an empty grid with no banner.
+            (_a = this.errorHandlerFunc) === null || _a === void 0 ? void 0 : _a.call(this, messageType === MessageType.LOGOFF_ACK
+                ? `Connection lost to ${this.resourceName}`
+                : `Authentication failed for ${this.resourceName}`, 'connection');
+            // The subscription is dead on the server, so drop it - keeping it would make every later
+            // scroll send MORE_ROWS against the stale SOURCE_REF, NACK again and fail its blocks
+            // silently. The teardown fails the waiting blocks and lets the next block re-log on.
+            this.teardownDataserverSubscription();
+            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;
+        // 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
+        // DELETE is a push no matter when it arrives - even while a request is in flight. Treating
+        // one as the reply would merge it into the cache at the wrong position and clear
+        // moreRowsInFlight while the real reply is still outstanding, letting a second MORE_ROWS
+        // race the first. (A pushed batch of only new INSERTs arriving while rows are due is
+        // indistinguishable from the reply; the reset issued for the next structural push
+        // reconciles that residual case.)
+        const containsPushedChanges = ((_d = (_c = filtered === null || filtered === void 0 ? void 0 : filtered.updates) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0 || ((_f = (_e = filtered === null || filtered === void 0 ? void 0 : filtered.deletes) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0) > 0;
+        if (containsPushedChanges) {
+            // What happens to the pending blocks depends on the push:
+            // - MODIFY-only: the cache is patched in place and the awaited reply is still due, so
+            //   moreRowsInFlight stays up and the blocks are left to it.
+            // - structural (any DELETE): notifyLiveChange resets the subscription, which fails the
+            //   pending blocks and clears moreRowsInFlight; the purge that follows re-requests them
+            //   on a fresh logon, and the in-flight reply lands on the unsubscribed stream.
+            this.streamStarted = true;
+            this.notifyLiveChange(filtered);
+            return;
+        }
+        const solicited = this.moreRowsInFlight || this.pendingBlocks.size > 0 || !this.streamStarted;
+        this.moreRowsInFlight = false;
+        if ((message === null || message === void 0 ? void 0 : message.MORE_ROWS) !== undefined) {
+            this.moreRows = message.MORE_ROWS;
+        }
+        if (filtered) {
+            if (message.ROWS_COUNT !== undefined && this.serverRowsCount === undefined) {
+                this.serverRowsCount = message.ROWS_COUNT;
+            }
+            if (solicited) {
+                this.accumulate(filtered);
+                // Rows arriving is progress: give the blocks still waiting a fresh deadline so a long
+                // walk to a distant block is not cut short by the safety valve.
+                this.refreshPendingDeadlines();
+            }
+            else {
+                this.streamStarted = true;
+                this.notifyLiveChange(filtered);
+                return;
+            }
+        }
+        this.streamStarted = true;
+        this.settleCoveredBlocks();
+        this.pumpMoreRows();
+    }
+    /**
+     * Reports a server-pushed change to the host so the grid can catch up.
+     * @internal
+     */
+    notifyLiveChange(result) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const structural = ((_b = (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0 || ((_d = (_c = result.deletes) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;
+        const modified = ((_f = (_e = result.updates) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0) > 0;
+        if (structural) {
+            // No point patching the cache first: it is about to be dropped and re-read.
+            logger.debug('Infinite DATASERVER live change invalidates the cache', {
+                inserts: (_h = (_g = result.inserts) === null || _g === void 0 ? void 0 : _g.length) !== null && _h !== void 0 ? _h : 0,
+                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);
+            return;
+        }
+        if (modified) {
+            this.accumulate(result);
+            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);
+        }
+    }
+    /**
+     * Restarts the safety valve for every block still waiting.
+     * @internal
+     */
+    refreshPendingDeadlines() {
+        for (const block of this.pendingBlocks) {
+            clearTimeout(block.timer);
+            block.timer = this.createBlockTimer(block);
+        }
+    }
+    /** @internal */
+    createBlockTimer(block) {
+        return setTimeout(() => {
+            logger.warn(`Infinite DATASERVER block ${block.startRow}-${block.endRow} for ${this.resourceName} timed out waiting for rows; resolving with ${this.rowData.size} accumulated row(s).`);
+            this.settleBlock(block, true);
+        }, GenesisInfiniteDatasource.BLOCK_RESOLVE_TIMEOUT_MS);
+    }
+    /**
+     * Merges a batch into the cumulative cache.
+     * @internal
+     */
+    accumulate(result) {
+        var _a, _b, _c;
+        const rows = new Map(this.rowData);
+        (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((row) => {
+            const key = row === null || row === void 0 ? void 0 : row[this.rowId];
+            if (key === undefined) {
+                // Without the guard a misconfigured rowId collapses every insert onto one undefined
+                // key, and blocks only ever resolve through the safety valve.
+                return;
+            }
+            rows.set(key, row);
+        });
+        // Live MODIFY rows may be partial, so merge into the cached row instead of clobbering it.
+        (_b = result.updates) === null || _b === void 0 ? void 0 : _b.forEach((row) => {
+            const key = row === null || row === void 0 ? void 0 : row[this.rowId];
+            if (key === undefined) {
+                return;
+            }
+            const existing = rows.get(key);
+            rows.set(key, existing ? Object.assign(Object.assign({}, existing), row) : row);
+        });
+        (_c = result.deletes) === null || _c === void 0 ? void 0 : _c.forEach((row) => {
+            const key = row === null || row === void 0 ? void 0 : row[this.rowId];
+            if (key === undefined) {
+                return;
+            }
+            // Rows already handed to AG Grid sit at fixed absolute indices; removing one from the
+            // cache would shift the slice offsets of every later block.
+            const index = this.cacheIndexOf(rows, key);
+            if (index === -1 || (this.deliveredRowCount > 0 && index < this.deliveredRowCount)) {
+                return;
+            }
+            rows.delete(key);
+        });
+        this.rowData = rows;
+    }
+    /** Position of a key in the cache, or -1. @internal */
+    cacheIndexOf(rows, key) {
+        let index = 0;
+        for (const mapKey of rows.keys()) {
+            if (mapKey === key) {
+                return index;
+            }
+            index += 1;
+        }
+        return -1;
+    }
+    /**
+     * Settles every pending block the cache now covers.
+     * @internal
+     */
+    settleCoveredBlocks() {
+        // Iterate a copy: settling a block removes it from the set.
+        for (const block of [...this.pendingBlocks]) {
+            if (this.rowData.size >= block.endRow || this.moreRows === false) {
+                this.settleBlock(block, true);
+            }
+        }
+    }
+    /**
+     * Hands a block its slice of the cache, or fails it.
+     * @internal
+     */
+    settleBlock(block, success) {
+        var _a;
+        if (block.settled) {
+            return;
+        }
+        block.settled = true;
+        this.pendingBlocks.delete(block);
+        clearTimeout(block.timer);
+        if (!success) {
+            block.fail();
+            return;
+        }
+        const rows = [...this.rowData.values()].slice(block.startRow, block.endRow);
+        this.deliveredRowCount = Math.max(this.deliveredRowCount, block.startRow + rows.length);
+        // Once the stream reports no more rows the cache is the whole dataset, filter included.
+        // Before that, an unfiltered total gives the grid an accurate scrollbar, while a filtered
+        // view has to stay open-ended - see serverRowsCount.
+        const lastRow = this.moreRows === false
+            ? this.rowData.size
+            : this.hasCriteria
+                ? -1
+                : ((_a = this.serverRowsCount) !== null && _a !== void 0 ? _a : -1);
+        this.warnIfViewTruncated();
+        logger.debug('Infinite DATASERVER block settled', {
+            startRow: block.startRow,
+            endRow: block.endRow,
+            rows: rows.length,
+            cached: this.rowData.size,
+            lastRow,
+        });
+        block.success(rows, lastRow);
+    }
+    /**
+     * Warns when the view filled up before the data ran out.
+     * @remarks The server stops sending at MAX_VIEW rows and reports MORE_ROWS false, which is
+     * indistinguishable from the end of the data - the grid would silently show a truncated view
+     * and a row count smaller than the resource's. Raising `max-view` past the row count is the
+     * fix, so say so rather than leaving it to be discovered.
+     * @internal
+     */
+    warnIfViewTruncated() {
+        var _a, _b;
+        if (this.viewTruncationWarned ||
+            this.moreRows !== false ||
+            this.hasCriteria ||
+            this.serverRowsCount === undefined ||
+            this.rowData.size >= this.serverRowsCount) {
+            return;
+        }
+        this.viewTruncationWarned = true;
+        logger.warn(`${this.resourceName} stopped at ${this.rowData.size} of ${this.serverRowsCount} rows: the DATASERVER view is capped by MAX_VIEW (${(_b = (_a = this.resourceParams) === null || _a === void 0 ? void 0 : _a.MAX_VIEW) !== null && _b !== void 0 ? _b : 'server default'}). Raise max-view past the row count to reach the rest.`);
+    }
+    /** @internal */
+    failAllPendingBlocks() {
+        // Iterate a copy: settling a block removes it from the set.
+        for (const block of [...this.pendingBlocks]) {
+            this.settleBlock(block, false);
+        }
+    }
+    /**
+     * Drops the accumulated rows and the subscription, so the next block re-reads from the server.
+     * @remarks Needed after a write: the cumulative cache is what blocks are served from, so a
+     * created row would otherwise appear only at the end of the cache (the server pushes it as an
+     * INSERT, not in sort position) and a deleted row that has already been displayed would never
+     * disappear, because dropping it from the cache would shift later blocks' slice offsets.
+     * @public
+     */
+    reset() {
+        this.teardownDataserverSubscription();
+    }
+    /**
+     * Drops the subscription and its cache so the next block re-logs on with fresh parameters.
+     * @internal
+     */
+    teardownDataserverSubscription() {
+        var _a;
+        this.failAllPendingBlocks();
+        (_a = this.dataserverStreamSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.dataserverStreamSubscription = undefined;
+        this.dataserverStream = undefined;
+        this.subscriptionKey = undefined;
+        this.sourceRef = undefined;
+        this.rowData = new Map();
+        this.deliveredRowCount = 0;
+        this.streamStarted = false;
+        this.serverRowsCount = undefined;
+        this.hasCriteria = false;
+        this.viewTruncationWarned = false;
+        this.moreRows = undefined;
+        this.moreRowsInFlight = false;
+    }
+    destroy() {
+        this.teardownDataserverSubscription();
+        logger.debug('GenesisInfiniteDatasource destroyed');
+    }
+}
+/**
+ * Max time a DATASERVER block may stay pending before the safety valve resolves it with the
+ * rows accumulated so far.
+ * @internal
+ */
+GenesisInfiniteDatasource.BLOCK_RESOLVE_TIMEOUT_MS = 10000;
+/** MORE_ROWS answered 404: the connection has no such endpoint (HTTP mode). @internal */
+GenesisInfiniteDatasource.HTTP_NOT_FOUND = 404;

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

@@ -428,41 +428,6 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
         this.clearRowData();
         this.$emit(datasourceEventNames.setServerSideDatasource, { datasource: null });
     }
-    getResourceIndexes(avaialbleIndexes, availableSortableFields) {
-        const resourceIndexesMap = new Map();
-        const allSortableFields = new Set();
-        // Add indexes from INDEXES metadata
-        avaialbleIndexes === null || avaialbleIndexes === void 0 ? void 0 : avaialbleIndexes.forEach((index) => {
-            const fields = index.FIELDS.split(' ');
-            resourceIndexesMap.set(index.NAME, fields);
-            fields.forEach((field) => allSortableFields.add(field));
-        });
-        // Add fields from SORTABLE_FIELDS metadata if available
-        if (availableSortableFields && availableSortableFields.length > 0) {
-            availableSortableFields.forEach((field) => allSortableFields.add(field));
-        }
-        // If we have SORTABLE_FIELDS but no indexes, create a synthetic index entry
-        // This ensures compatibility with existing code that expects a Map structure
-        if (resourceIndexesMap.size === 0 && allSortableFields.size > 0) {
-            resourceIndexesMap.set('SORTABLE_FIELDS', Array.from(allSortableFields));
-        }
-        else if (availableSortableFields &&
-            availableSortableFields.length > 0 &&
-            resourceIndexesMap.size > 0) {
-            // If we have both indexes and SORTABLE_FIELDS, merge them
-            // Add any additional fields from SORTABLE_FIELDS that aren't already in any index
-            const fieldsFromIndexes = new Set();
-            resourceIndexesMap.forEach((fields) => {
-                fields.forEach((field) => fieldsFromIndexes.add(field));
-            });
-            const additionalFields = availableSortableFields.filter((field) => !fieldsFromIndexes.has(field));
-            if (additionalFields.length > 0) {
-                // Add additional sortable fields as a separate entry
-                resourceIndexesMap.set('SORTABLE_FIELDS', additionalFields);
-            }
-        }
-        return resourceIndexesMap;
-    }
     createReqRepRequest() {
         return __awaiter(this, arguments, void 0, function* (existingParams = null) {
             const reqRep = yield this.datasource.snapshot(existingParams);
@@ -694,9 +659,6 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
             return colDefsFromGenesisData;
         });
     }
-    applyTransaction(transaction) {
-        this.$emit(datasourceEventNames.applyServerSideTransaction, { transaction });
-    }
     loadMore() {
         throw new Error('loadMore() method is not supported for server-side datasource');
     }

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

@@ -37,8 +37,8 @@ export function getServerSideFilterParamsByFieldType(field) {
                 closeOnApply: true,
                 closeOnClear: true,
                 maxNumConditions: 1,
+                defaultOption: 'true',
                 filterOptions: [
-                    'contains',
                     {
                         displayKey: 'true',
                         displayName: 'True',