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

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

@@ -24,6 +24,12 @@ export class BaseServerSideDatasource {
         this.moreRows = false;
         this.calculatedRowsCount = 0;
         this.currentSequenceId = null;
+        /**
+         * Whether the corrective ROWS_COUNT snapshot() has already resolved for the current
+         * CRITERIA_MATCH. Reset in destroy() so it re-resolves whenever the filter/sort changes.
+         * @internal
+         */
+        this.criteriaRowCountResolved = false;
         this.reloadResourceDataFunc = options.reloadResourceDataFunc;
         this.errorHandlerFunc = options.errorHandlerFunc;
         this.onNoDataAvailableFunc = options.onNoDataAvailableFunc;
@@ -79,6 +85,10 @@ export class BaseServerSideDatasource {
     /**
      * Handles filtering setup for server-side datasources.
      * Common logic used by both dataserver and req-rep implementations.
+     *
+     * @returns `true` when a filter change triggered {@link refreshDatasource} - in that case
+     * the current getRows() request is superseded and the caller MUST stop processing it
+     * (see the corresponding handling in the dataserver implementation's getRows()).
      */
     setupFiltering(params) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -91,15 +101,21 @@ export class BaseServerSideDatasource {
                     this.currentFilterModel = null;
                     this.setResourceParam('CRITERIA_MATCH', this.originalCriteriaMatch);
                     yield this.refreshDatasource(params);
-                    return;
+                    // A refresh was triggered and this request is superseded: refreshDatasource() ->
+                    // reloadResourceDataFunc has already re-initialized the underlying datasource and
+                    // purged AG Grid's SSRM cache, so AG Grid re-invokes getRows() with fresh params
+                    // on its own. Continuing with THIS invocation's stale params would attach a
+                    // duplicate subscription to the freshly-created stream.
+                    return true;
                 }
                 else if (filterModelBeingAppliedDiffersFromCurrent && filtersAreBeingApplied) {
                     this.currentFilterModel = filterModelBeingApplied;
                     this.setResourceParam('CRITERIA_MATCH', this.buildCriteriaMatchFromFilters());
                     yield this.refreshDatasource(params);
-                    return;
+                    return true;
                 }
             }
+            return false;
         });
     }
     /**
@@ -122,6 +138,7 @@ export class BaseServerSideDatasource {
         this.moreRows = false;
         this.sourceRef = undefined;
         this.lastSuccessRowData = undefined;
+        this.criteriaRowCountResolved = false;
     }
     refreshDatasource(params) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -173,142 +190,184 @@ export class BaseServerSideDatasource {
     criteriaFromFilters() {
         const filters = [];
         this.getFiltersByType('text').forEach((k) => {
-            if (!this.currentFilterModel[k].filter &&
-                (this.currentFilterModel[k].type === 'false' || this.currentFilterModel[k].type === 'true')) {
-                filters.push(`${k} == ${this.currentFilterModel[k].type}`);
-            }
-            else {
-                switch (this.currentFilterModel[k].type) {
-                    case 'blank':
-                        filters.push(`(${k} == '' || ${k} == null)`);
-                        break;
-                    case 'contains':
-                        filters.push(`Expr.containsIgnoreCase(${k}, '${this.currentFilterModel[k].filter}')`);
-                        break;
-                    case 'equals':
-                        filters.push(`${k} == '${this.currentFilterModel[k].filter}'`);
-                        break;
-                    case 'notBlank':
-                        filters.push(`(${k} != '' && ${k} != null)`);
-                        break;
-                    case 'notEqual':
-                        filters.push(`${k} != '${this.currentFilterModel[k].filter}'`);
-                        break;
-                    case 'wordStartsWith':
-                        filters.push(`Expr.containsWordsStartingWithIgnoreCase(${k}, '${this.currentFilterModel[k].filter}')`);
-                        break;
-                }
+            const fragment = this.criteriaForSingleModel(k, this.currentFilterModel[k]);
+            if (fragment) {
+                filters.push(fragment);
             }
         });
-        // TODO: Handle multi filters if we decide we want to use them in SSRM
         // Handle set filters (typically used for enum fields with ag-set-column-filter)
         this.getFiltersByType('set').forEach((k) => {
-            var _a, _b, _c;
-            const model = (_a = this.currentFilterModel) === null || _a === void 0 ? void 0 : _a[k];
-            const selectedValues = ((_b = model === null || model === void 0 ? void 0 : model.values) !== null && _b !== void 0 ? _b : []);
-            if (!selectedValues || selectedValues.length === 0) {
-                // Nothing selected means no additional criteria
-                return;
-            }
-            // Try to detect "all values selected" using VALID_VALUES from metadata.
-            // In that case we don't want to send any criteria, as it would be equivalent
-            // to no filter at all.
-            const colMeta = (_c = this.resourceColDefs) === null || _c === void 0 ? void 0 : _c.find((o) => o.NAME === k);
-            let allValues;
-            if (colMeta === null || colMeta === void 0 ? void 0 : colMeta.VALID_VALUES) {
-                try {
-                    allValues = Array.isArray(colMeta.VALID_VALUES)
-                        ? colMeta.VALID_VALUES
-                        : colMeta.VALID_VALUES.split('|');
-                }
-                catch (_d) {
-                    allValues = undefined;
-                }
-            }
-            if (allValues &&
-                allValues.length === selectedValues.length &&
-                allValues.every((v) => selectedValues.includes(v))) {
-                // All enum options are selected – skip adding criteria for this column
-                return;
-            }
-            const orConditions = selectedValues.map((val) => {
-                const safeVal = String(val).replace(/'/g, "\\'");
-                return `${k} == '${safeVal}'`;
-            });
-            if (orConditions.length > 0) {
-                filters.push(`(${orConditions.join(' || ')})`);
+            const fragment = this.criteriaForSingleModel(k, this.currentFilterModel[k]);
+            if (fragment) {
+                filters.push(fragment);
             }
         });
         this.getFiltersByType('number').forEach((k) => {
-            const value = this.currentFilterModel[k].filter;
-            const valueTwo = this.currentFilterModel[k].filterTo;
-            switch (this.currentFilterModel[k].type) {
-                case 'equals':
-                    !isNaN(value) && filters.push(`${k} == ${value}`);
-                    break;
-                case 'notEqual':
-                    !isNaN(value) && filters.push(`${k} != ${value}`);
-                    break;
-                case 'greaterThan':
-                    !isNaN(value) && filters.push(`${k} > ${value}`);
-                    break;
-                case 'greaterThanOrEqual':
-                    !isNaN(value) && filters.push(`${k} >= ${value}`);
-                    break;
-                case 'lessThan':
-                    !isNaN(value) && filters.push(`${k} < ${value}`);
-                    break;
-                case 'lessThanOrEqual':
-                    !isNaN(value) && filters.push(`${k} <= ${value}`);
-                    break;
-                case 'inRange':
-                    !isNaN(value) &&
-                        !isNaN(valueTwo) &&
-                        filters.push(`${k} >= ${value} && ${k} <= ${valueTwo}`);
-                    break;
-                case 'blank':
-                    filters.push(`${k} == 0`);
-                    break;
-                case 'notBlank':
-                    filters.push(`${k} != 0`);
-                    break;
+            const fragment = this.criteriaForSingleModel(k, this.currentFilterModel[k]);
+            if (fragment) {
+                filters.push(fragment);
             }
         });
         this.getFiltersByType('date').forEach((k) => {
-            var _a, _b;
-            const dateFrom = (_a = this.currentFilterModel[k].dateFrom) === null || _a === void 0 ? void 0 : _a.replace(/-/g, '').replace('T', '-').split(' ')[0];
-            const dateTo = (_b = this.currentFilterModel[k].dateTo) === null || _b === void 0 ? void 0 : _b.replace(/-/g, '').replace('T', '-').split(' ')[0];
-            switch (this.currentFilterModel[k].type) {
-                case 'equals':
-                    filters.push(`Expr.dateIsEqual(${k}, '${dateFrom}')`);
-                    break;
-                case 'lessThan':
-                    filters.push(`Expr.dateIsBefore(${k}, '${dateFrom}')`);
-                    break;
-                case 'greaterThan':
-                    filters.push(`Expr.dateIsAfter(${k}, '${dateFrom}')`);
-                    break;
-                case 'inRange':
-                    filters.push(`Expr.dateIsAfter(${k}, '${dateFrom}') && Expr.dateIsBefore(${k}, '${dateTo}')`);
-                    break;
-                case 'isToday':
-                    const now = new Date();
-                    const year = now.getFullYear();
-                    const month = (now.getMonth() + 1).toString().padStart(2, '0');
-                    const day = now.getDate().toString().padStart(2, '0');
-                    const todayStr = `${year}-${month}-${day} 00:00:00`;
-                    filters.push(`Expr.dateIsEqual(${k}, '${todayStr}')`);
-                    break;
-                case 'blank':
-                    filters.push(`${k} == null`);
-                    break;
-                case 'notBlank':
-                    filters.push(`${k} != null`);
-                    break;
+            const fragment = this.criteriaForSingleModel(k, this.currentFilterModel[k]);
+            if (fragment) {
+                filters.push(fragment);
+            }
+        });
+        // Handle multi filters (ag-multi-column-filter, e.g. text+set combos on enum/currency columns).
+        // AG Grid wraps these as { filterType: 'multi', filterModels: [...] } which none of the
+        // per-type branches above recognize, so the filter was previously silently dropped and
+        // CRITERIA_MATCH never reflected it - the grid kept showing unfiltered server-side data.
+        this.getFiltersByType('multi').forEach((k) => {
+            var _a;
+            const subModels = (_a = this.currentFilterModel[k].filterModels) !== null && _a !== void 0 ? _a : [];
+            const operator = (this.currentFilterModel[k].operator || 'AND').toUpperCase();
+            const joiner = operator === 'OR' ? ' || ' : ' && ';
+            const fragments = subModels
+                .map((subModel) => this.criteriaForSingleModel(k, subModel))
+                .filter((f) => !!f);
+            if (fragments.length === 1) {
+                filters.push(fragments[0]);
+            }
+            else if (fragments.length > 1) {
+                filters.push(`(${fragments.join(joiner)})`);
             }
         });
         return filters;
     }
+    /**
+     * Builds a single criteria fragment for one filter model. Used both for flat per-column
+     * filter models and to unwrap the sub-filters inside an ag-multi-column-filter's
+     * `filterModels` array.
+     * @internal
+     */
+    criteriaForSingleModel(k, model) {
+        if (!model)
+            return null;
+        switch (model.filterType) {
+            case 'text':
+                return this.criteriaForTextModel(k, model);
+            case 'set':
+                return this.criteriaForSetModel(k, model);
+            case 'number':
+                return this.criteriaForNumberModel(k, model);
+            case 'date':
+                return this.criteriaForDateModel(k, model);
+            default:
+                return null;
+        }
+    }
+    criteriaForTextModel(k, model) {
+        const type = model.type;
+        const val = model.filter;
+        if (!val && (type === 'false' || type === 'true')) {
+            return `${k} == ${type}`;
+        }
+        switch (type) {
+            case 'blank':
+                return `(${k} == '' || ${k} == null)`;
+            case 'contains':
+                return `Expr.containsIgnoreCase(${k}, '${val}')`;
+            case 'equals':
+                return `${k} == '${val}'`;
+            case 'notBlank':
+                return `(${k} != '' && ${k} != null)`;
+            case 'notEqual':
+                return `${k} != '${val}'`;
+            case 'wordStartsWith':
+                return `Expr.containsWordsStartingWithIgnoreCase(${k}, '${val}')`;
+            default:
+                return null;
+        }
+    }
+    criteriaForSetModel(k, model) {
+        var _a, _b;
+        const selectedValues = ((_a = model.values) !== null && _a !== void 0 ? _a : []);
+        if (!selectedValues.length) {
+            // Nothing selected means no additional criteria
+            return null;
+        }
+        // Try to detect "all values selected" using VALID_VALUES from metadata.
+        // In that case we don't want to send any criteria, as it would be equivalent
+        // to no filter at all.
+        const colMeta = (_b = this.resourceColDefs) === null || _b === void 0 ? void 0 : _b.find((o) => o.NAME === k);
+        let allValues;
+        if (colMeta === null || colMeta === void 0 ? void 0 : colMeta.VALID_VALUES) {
+            try {
+                allValues = Array.isArray(colMeta.VALID_VALUES)
+                    ? colMeta.VALID_VALUES
+                    : colMeta.VALID_VALUES.split('|');
+            }
+            catch (_c) {
+                allValues = undefined;
+            }
+        }
+        if (allValues &&
+            allValues.length === selectedValues.length &&
+            allValues.every((v) => selectedValues.includes(v))) {
+            // All enum options are selected – skip adding criteria for this column
+            return null;
+        }
+        const orConditions = selectedValues.map((val) => {
+            const safeVal = String(val).replace(/'/g, "\\'");
+            return `${k} == '${safeVal}'`;
+        });
+        return orConditions.length ? `(${orConditions.join(' || ')})` : null;
+    }
+    criteriaForNumberModel(k, model) {
+        const value = model.filter;
+        const valueTwo = model.filterTo;
+        switch (model.type) {
+            case 'equals':
+                return !isNaN(value) ? `${k} == ${value}` : null;
+            case 'notEqual':
+                return !isNaN(value) ? `${k} != ${value}` : null;
+            case 'greaterThan':
+                return !isNaN(value) ? `${k} > ${value}` : null;
+            case 'greaterThanOrEqual':
+                return !isNaN(value) ? `${k} >= ${value}` : null;
+            case 'lessThan':
+                return !isNaN(value) ? `${k} < ${value}` : null;
+            case 'lessThanOrEqual':
+                return !isNaN(value) ? `${k} <= ${value}` : null;
+            case 'inRange':
+                return !isNaN(value) && !isNaN(valueTwo) ? `${k} >= ${value} && ${k} <= ${valueTwo}` : null;
+            case 'blank':
+                return `${k} == 0`;
+            case 'notBlank':
+                return `${k} != 0`;
+            default:
+                return null;
+        }
+    }
+    criteriaForDateModel(k, model) {
+        var _a, _b;
+        const dateFrom = (_a = model.dateFrom) === null || _a === void 0 ? void 0 : _a.replace(/-/g, '').replace('T', '-').split(' ')[0];
+        const dateTo = (_b = model.dateTo) === null || _b === void 0 ? void 0 : _b.replace(/-/g, '').replace('T', '-').split(' ')[0];
+        switch (model.type) {
+            case 'equals':
+                return `Expr.dateIsEqual(${k}, '${dateFrom}')`;
+            case 'lessThan':
+                return `Expr.dateIsBefore(${k}, '${dateFrom}')`;
+            case 'greaterThan':
+                return `Expr.dateIsAfter(${k}, '${dateFrom}')`;
+            case 'inRange':
+                return `Expr.dateIsAfter(${k}, '${dateFrom}') && Expr.dateIsBefore(${k}, '${dateTo}')`;
+            case 'isToday': {
+                const now = new Date();
+                const year = now.getFullYear();
+                const month = (now.getMonth() + 1).toString().padStart(2, '0');
+                const day = now.getDate().toString().padStart(2, '0');
+                return `Expr.dateIsEqual(${k}, '${year}-${month}-${day} 00:00:00')`;
+            }
+            case 'blank':
+                return `${k} == null`;
+            case 'notBlank':
+                return `${k} != null`;
+            default:
+                return null;
+        }
+    }
     getFiltersByType(filterType) {
         var _a;
         return Object.keys((_a = this.currentFilterModel) !== null && _a !== void 0 ? _a : {})
@@ -336,19 +395,29 @@ export class BaseServerSideDatasource {
             }
             return rowCount;
         }
-        if (currentLastRowNumber === this.serverRowsCount && !this.moreRows) {
-            rowCount = this.serverRowsCount;
+        // Infinite scroll: getRows() only resolves a block once the session-cumulative row cache
+        // covers the block's full extent, or the stream reported no more data (see the accumulation
+        // logic in server-side.resource-dataserver.ts getRows()). So by construction, blocks handed
+        // to AG Grid are either FULL (more may follow) or FINAL (dataset ended) - which lets the
+        // count logic stay simple and honest:
+        if (!this.moreRows) {
+            // Dataset genuinely ends here. rowData is a Map keyed by rowId, so .size is the true
+            // unique-row count. Deliberately NOT serverRowsCount - GSF's ROWS_COUNT ignores
+            // CRITERIA_MATCH entirely (confirmed: it returns the full unfiltered total regardless of
+            // any filter). Deliberately NOT clientRowsCount either - it's a non-deduplicated running
+            // sum of inserts across stream messages and overcounts on live/reactive streams.
+            rowCount = Math.min(this.rowData.size, this.maxView);
         }
-        else if (currentLastRowNumber > this.maxView) {
-            rowCount = Math.min(defaultCount, this.calculatedRowsCount);
+        else if (this.rowData.size >= this.maxView) {
+            // Hard cap - the view can't grow past maxView, stop AG Grid from requesting further.
+            rowCount = this.maxView;
         }
-        else if (!this.moreRows && currentLastRowNumber > this.calculatedRowsCount) {
-            // No more data from server and request is beyond what has been counted.
-            // Return the actual loaded count so AG Grid knows the dataset ends here.
-            rowCount = this.clientRowsCount || this.calculatedRowsCount;
-        }
-        else if (!this.moreRows && this.serverRowsCount > this.calculatedRowsCount) {
-            rowCount = this.calculatedRowsCount;
+        else {
+            // Full block delivered and the stream says more may follow: leave rowCount undefined so
+            // AG Grid keeps its own "returned block was full, more may exist" heuristic - this both
+            // keeps infinite scroll going and preserves the open-ended "100+"-style count display,
+            // for filtered views exactly the same as for unfiltered ones.
+            rowCount = undefined;
         }
         return rowCount;
     }