@genesislcap/grid-pro 14.323.0 → 14.324.0

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

@@ -1,6 +1,6 @@
 import { __awaiter, __decorate } from "tslib";
 import { Events, } from '@ag-grid-community/core';
-import { dataServerResultFilter, MessageType, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
+import { dataServerResultFilter, MessageType, normaliseCriteria, ResourceType, toFieldMetadata, } from '@genesislcap/foundation-comms';
 import { LifecycleMixin, insertDocumentCSSRule } from '@genesislcap/foundation-utils';
 import { attr, customElement, DOM, observable } from '@microsoft/fast-element';
 import { gridProGenesisDatasourceEventNames } from '../grid-pro-genesis-datasource';
@@ -11,7 +11,6 @@ import { DataserverServerSideDatasource } from './server-side.resource-dataserve
 import { ReqRepServerSideDatasource } from './server-side.resource-reqrep';
 const criteriaDelimiter = ';';
 const withoutColumnDefs = null;
-const timeoutInMs = 500;
 /**
  * Custom CSS for server-side datasource sort indicators
  * Makes sort indicators always visible with custom styling
@@ -203,7 +202,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                         if (!params.data) {
                             return null;
                         }
-                        return params.data[this.rowId];
+                        return String(params.data[this.rowId]);
                     }, getRowStyle(params) {
                         var _a, _b;
                         if ((_b = (_a = params.data) === null || _a === void 0 ? void 0 : _a.ROW_REF) === null || _b === void 0 ? void 0 : _b.includes('_deleted')) {
@@ -237,7 +236,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                             reloadResourceDataFunc: this.reloadResourceData.bind(this),
                             errorHandlerFunc: this.handleErrors.bind(this),
                             resourceName: this.resourceName,
-                            resourceParams: this.params,
+                            resourceParams: this.datasource.dataserverOnlyParams,
                             resourceIndexes: this.indexes,
                             resourceColDefs: this.datasource.originalFieldDef,
                             maxRows: +this.maxRows,
@@ -245,6 +244,8 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                             rowId: this.rowId,
                             pagination: this.pagination,
                             zeroBasedViewNumber: this.zeroBasedViewNumber,
+                            pagingMode: this.pagingMode,
+                            criteriaOnlyRequest: this.datasource.criteriaOnlyRequest,
                         });
                     }
                     else {
@@ -253,7 +254,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                             reloadResourceDataFunc: this.reloadResourceData.bind(this),
                             errorHandlerFunc: this.handleErrors.bind(this),
                             resourceName: this.resourceName,
-                            resourceParams: this.params,
+                            resourceParams: this.datasource.requestOnlyParams,
                             resourceIndexes: this.indexes,
                             resourceColDefs: this.datasource.originalFieldDef,
                             maxRows: +this.maxRows,
@@ -323,27 +324,6 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
         });
         return resourceIndexesMap;
     }
-    get params() {
-        const params = {
-            CRITERIA_MATCH: this.criteria,
-            FIELDS: this.fields,
-            MAX_ROWS: this.maxRows,
-            MAX_VIEW: this.maxView,
-            MOVING_VIEW: this.movingView,
-            REVERSE: this.reverse,
-        };
-        const keys = Array.from(this.indexes.keys());
-        if (this.orderBy) {
-            if (keys.findIndex((key) => key === this.orderBy) > -1) {
-                params.ORDER_BY = this.orderBy;
-            }
-            else {
-                const validIndexes = keys.map((key) => key);
-                logger.warn('Specified [orderBy] index is not valid and will not be used. See https://learn.genesis.global/docs/database/data-types/index-entities/ - Available indexes:', validIndexes);
-            }
-        }
-        return params;
-    }
     get rowModel() {
         return this.agGrid.gridApi.getModel();
     }
@@ -357,7 +337,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
         return __awaiter(this, arguments, void 0, function* (existingParams = null) {
             if (this.liveUpdates) {
                 const streamOnMessage = (message) => __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b;
+                    var _a, _b, _c, _d, _e, _f, _g, _h;
                     const messageType = message.MESSAGE_TYPE;
                     if (messageType === MessageType.QUERY_UPDATE && message.ROW) {
                         if (!this.ssrmDatasource) {
@@ -369,21 +349,19 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                         this.handleStreamUpdates(nextMessage.updates);
                         this.handleStreamDeletes(nextMessage.deletes);
                         if (message.SEQUENCE_ID > 1) {
-                            this.ssrmDatasource.clientRowsCount += (_a = nextMessage.inserts.length) !== null && _a !== void 0 ? _a : 0;
-                            this.ssrmDatasource.serverRowsCount += (_b = nextMessage.inserts.length) !== null && _b !== void 0 ? _b : 0;
-                        }
-                        // this.handleStreamDeletes(nextMessage.deletes);
-                        // this.ssrmDatasource.client_ROWS_COUNT -= nextMessage.deletes.length ?? 0;
-                        // this.ssrmDatasource.server_ROWS_COUNT -= nextMessage.deletes.length ?? 0;
-                        if (this.pagination) {
+                            // Calculate net row count change (inserts - deletes)
+                            const netRowChange = ((_b = (_a = nextMessage.inserts) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = nextMessage.deletes) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0);
+                            this.ssrmDatasource.serverRowsCount += netRowChange;
+                            const loadedDeletes = (_f = (_e = nextMessage.deletes) === null || _e === void 0 ? void 0 : _e.filter((deleteData) => {
+                                const rowId = deleteData[this.rowId];
+                                const rowNode = this.agGrid.gridApi.getRowNode(rowId);
+                                return rowNode != null;
+                            })) !== null && _f !== void 0 ? _f : [];
+                            // Calculate net row count change for client (inserts - loaded deletes)
+                            const clientNetRowChange = ((_h = (_g = nextMessage.inserts) === null || _g === void 0 ? void 0 : _g.length) !== null && _h !== void 0 ? _h : 0) - loadedDeletes.length;
+                            this.ssrmDatasource.clientRowsCount += clientNetRowChange;
                             this.applyAllAgTransactions();
                         }
-                        else {
-                            // TODO: Double-check this bit / DOM.queueUpdate do not work here
-                            setTimeout(() => {
-                                this.applyAllAgTransactions();
-                            }, timeoutInMs);
-                        }
                     }
                 });
                 const onError = (error) => {
@@ -392,7 +370,7 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
                     this.handleErrors(((_a = error.receivedMessage) === null || _a === void 0 ? void 0 : _a.ERROR) || error.message, 'stream');
                 };
                 this.liveUpdatesStream = this.connect
-                    .stream(this.resourceName, () => { }, onError, existingParams !== null && existingParams !== void 0 ? existingParams : this.params)
+                    .stream(this.resourceName, () => { }, onError, existingParams !== null && existingParams !== void 0 ? existingParams : this.datasource.dataserverOnlyParams)
                     .subscribe((message) => streamOnMessage(message));
                 // return this.connect.stream(
                 //   this.resourceName,
@@ -417,9 +395,16 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
     getAgColumnDefs(fieldsMetadata) {
         return __awaiter(this, void 0, void 0, function* () {
             const colDefsFromGenesisData = this.generateColumnDefsFromMetadata(fieldsMetadata, getServerSideFilterParamsByFieldType);
-            colDefsFromGenesisData.forEach((colDef) => {
-                colDef.sortable = [].concat(...this.indexes.values()).includes(colDef.field);
-            });
+            if (this.datasource.resourceType === ResourceType.DATASERVER) {
+                colDefsFromGenesisData.forEach((colDef) => {
+                    colDef.sortable = [].concat(...this.indexes.values()).includes(colDef.field);
+                });
+            }
+            else {
+                colDefsFromGenesisData.forEach((colDef) => {
+                    colDef.sortable = true;
+                });
+            }
             const colDefsMergedWithTemplateDefs = yield this.agGrid.mergeAllColumnDefsAndStates(colDefsFromGenesisData, true);
             return colDefsMergedWithTemplateDefs;
         });
@@ -440,6 +425,9 @@ __decorate([
 __decorate([
     attr({ mode: 'boolean', attribute: 'live-updates' })
 ], GridProServerSideDatasource.prototype, "liveUpdates", void 0);
+__decorate([
+    attr({ attribute: 'paging-mode' })
+], GridProServerSideDatasource.prototype, "pagingMode", void 0);
 __decorate([
     observable
 ], GridProServerSideDatasource.prototype, "request", void 0);

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

@@ -1,7 +1,6 @@
 import { __awaiter, __decorate } from "tslib";
 import { Auth, Connect, logger, } from '@genesislcap/foundation-comms';
 import { UUID } from '@genesislcap/foundation-utils';
-import { getAvailableIndexes, getAvailableIndexFields } from '../utils';
 /**
  * Base class for server-side resource datasources used in Grid Pro SSRM implementations.
  * Provides common logic for filtering, sorting, and pagination.
@@ -10,6 +9,7 @@ import { getAvailableIndexes, getAvailableIndexFields } from '../utils';
  */
 export class BaseServerSideDatasource {
     constructor(options) {
+        var _a;
         this.rowData = new Map();
         /**
          * The number of rows in the grid. THIS DO NOT CONSIDER CRITERIA_MATCH scenarios.
@@ -36,13 +36,18 @@ export class BaseServerSideDatasource {
         this.rowId = options.rowId;
         this.pagination = options.pagination;
         this.zeroBasedViewNumber = options.zeroBasedViewNumber;
+        this.pagingMode = options.pagingMode;
+        this.criteriaOnlyRequest = (_a = options.criteriaOnlyRequest) !== null && _a !== void 0 ? _a : false;
     }
     getRows(params) {
         throw new Error('Method not implemented.');
     }
-    setupFilteringAndSorting(params) {
+    /**
+     * Handles filtering setup for server-side datasources.
+     * Common logic used by both dataserver and req-rep implementations.
+     */
+    setupFiltering(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const filterModelBeingApplied = params.request.filterModel;
             const filtersAreBeingApplied = Object.keys(filterModelBeingApplied).length > 0;
             const filtersAreGettingCleaned = Object.keys(filterModelBeingApplied).length === 0;
@@ -61,40 +66,17 @@ export class BaseServerSideDatasource {
                     return;
                 }
             }
-            const toBeAppliedSortModel = params.request.sortModel;
-            if (((_a = this.currentSortModel) === null || _a === void 0 ? void 0 : _a.length) !== toBeAppliedSortModel.length ||
-                toBeAppliedSortModel.length > 0) {
-                if (toBeAppliedSortModel.length === 0 && this.currentSortModel) {
-                    this.calculatedRowsCount = 0;
-                    this.currentSortModel = null;
-                    this.resourceParams.ORDER_BY = null;
-                    this.resourceParams.REVERSE = null;
-                    yield this.refreshDatasource(params);
-                    return;
-                }
-                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.debug('Available indexes:', availableIndexes);
-                        logger.debug('Columns that can be sorted with the available indexes:', availableIndexFields);
-                        params.fail();
-                        return;
-                    }
-                    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;
-                    }
-                }
-            }
+        });
+    }
+    /**
+     * Legacy method that combines filtering and sorting.
+     * Kept for backward compatibility. New implementations should use setupFiltering and setupSorting directly.
+     * @deprecated Use setupFiltering() and setupSorting() separately instead
+     */
+    setupFilteringAndSorting(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setupFiltering(params);
+            yield this.setupSorting(params);
         });
     }
     destroy() {
@@ -245,7 +227,7 @@ export class BaseServerSideDatasource {
             .filter((k) => this.currentFilterModel[k].filterType === filterType);
     }
     getPageNumber(start, recordsPerPage, totalRecords, zeroBasedViewNumber = true) {
-        if (start > totalRecords) {
+        if (totalRecords !== undefined && start > totalRecords) {
             start = Math.floor((totalRecords - 1) / recordsPerPage) * recordsPerPage + 1;
         }
         const currentPageIndex = Math.ceil(start / recordsPerPage);
@@ -280,6 +262,22 @@ export class BaseServerSideDatasource {
     get isNotFirstViewNumber() {
         return this.zeroBasedViewNumber ? this.currentSequenceId > 0 : this.currentSequenceId > 1;
     }
+    /**
+     * Determines the effective paging mode based on criteriaOnlyRequest availability and user settings
+     */
+    getEffectivePagingMode() {
+        // If user explicitly set a paging mode
+        if (this.pagingMode) {
+            // If criteriaOnlyRequest is not available but user wants offsetBased, warn and use viewBased
+            if (this.pagingMode === 'offsetBased' && !this.criteriaOnlyRequest) {
+                logger.warn('offsetBased paging mode requires criteriaOnlyRequest support. Falling back to viewBased mode.');
+                return 'viewBased';
+            }
+            return this.pagingMode;
+        }
+        // Auto-determine based on criteriaOnlyRequest availability
+        return this.criteriaOnlyRequest ? 'offsetBased' : 'viewBased';
+    }
 }
 __decorate([
     Auth

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

@@ -1,6 +1,7 @@
 import { __awaiter } from "tslib";
 import { MessageType, dataServerResultFilter, logger, } from '@genesislcap/foundation-comms';
 import { DOM } from '@microsoft/fast-element';
+import { getAvailableIndexes, getAvailableIndexFields } from '../utils';
 import { BaseServerSideDatasource } from './server-side.resource-base';
 /**
  * The DATASERVER IServerSideDatasource implementation, used for SSRM (Server-Side Row Model) in the grid.
@@ -24,7 +25,9 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
     }
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.setupFilteringAndSorting(params);
+            // Use separated filtering and sorting setup
+            yield this.setupFiltering(params);
+            yield this.setupSorting(params);
             if (this.pagination && !this.isNewPageSize && this.currentSequenceId > 0) {
                 params.success(this.lastSuccessRowData);
                 return;
@@ -115,6 +118,49 @@ export class DataserverServerSideDatasource extends BaseServerSideDatasource {
         this.lastSuccessRowData = successRowData;
         params.success(successRowData);
     }
+    /**
+     * Dataserver-specific sorting setup that validates columns are part of an index.
+     * This is required because dataserver needs indexed columns for efficient sorting.
+     */
+    setupSorting(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const toBeAppliedSortModel = params.request.sortModel;
+            if (((_a = this.currentSortModel) === null || _a === void 0 ? void 0 : _a.length) !== toBeAppliedSortModel.length ||
+                toBeAppliedSortModel.length > 0) {
+                if (toBeAppliedSortModel.length === 0 && this.currentSortModel) {
+                    this.calculatedRowsCount = 0;
+                    this.currentSortModel = null;
+                    this.resourceParams.ORDER_BY = null;
+                    this.resourceParams.REVERSE = null;
+                    yield this.refreshDatasource(params);
+                    return;
+                }
+                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.debug('Available indexes:', availableIndexes);
+                        logger.debug('Columns that can be sorted with the available indexes:', availableIndexFields);
+                        params.fail();
+                        return;
+                    }
+                    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;
+                    }
+                }
+            }
+        });
+    }
     destroy() {
         const _super = Object.create(null, {
             destroy: { get: () => super.destroy }

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

@@ -10,41 +10,84 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
     constructor(options) {
         var _a;
         super(options);
+        // Track the total discovered row count when we reach the last page
+        this.discoveredTotalRowCount = null;
+        this.currentNextOffset = 0;
         this.createReqRepRequestFunc = options.createReqRepRequestFunc;
-        if (!((_a = options.resourceParams) === null || _a === void 0 ? void 0 : _a.VIEW_NUMBER)) {
-            this.resourceParams.VIEW_NUMBER = this.zeroBasedViewNumber ? 0 : 1;
+        const effectivePagingMode = this.getEffectivePagingMode();
+        // Initialize based on paging mode
+        if (effectivePagingMode === 'viewBased') {
+            if (!((_a = options.resourceParams) === null || _a === void 0 ? void 0 : _a.VIEW_NUMBER)) {
+                this.resourceParams.VIEW_NUMBER = this.zeroBasedViewNumber ? 0 : 1;
+            }
+        }
+        else {
+            // offsetBased
+            if (!options.resourceParams.OFFSET) {
+                this.resourceParams.OFFSET = 0;
+            }
         }
     }
     getRows(params) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            yield this.setupFilteringAndSorting(params);
+            // Use custom filtering and sorting setup for req-rep
+            yield this.setupFiltering(params);
+            yield this.setupSorting(params);
             if (this.pagination && !this.isNewPageSize && this.currentSequenceId > 0) {
                 params.success(this.lastSuccessRowData);
                 return;
             }
-            if (this.currentSequenceId !== null && this.currentSequenceId >= 0 && this.moreRows) {
-                if (this.pagination) {
-                    this.resourceParams.VIEW_NUMBER = this.getPageNumber(params.request.startRow, this.maxRows, this.maxView, this.zeroBasedViewNumber);
+            const effectivePagingMode = this.getEffectivePagingMode();
+            if (effectivePagingMode === 'viewBased') {
+                if (this.currentSequenceId !== null && this.currentSequenceId >= 0 && this.moreRows) {
+                    if (this.pagination) {
+                        this.resourceParams.VIEW_NUMBER = this.getPageNumber(params.request.startRow, this.maxRows, undefined, // Don't pass maxView as totalRecords since it's not a valid total count
+                        this.zeroBasedViewNumber);
+                    }
+                    else {
+                        this.resourceParams.VIEW_NUMBER += 1;
+                    }
+                }
+            }
+            else {
+                // offsetBased
+                if (this.currentNextOffset > 0 && this.currentNextOffset !== params.request.startRow) {
+                    this.resourceParams.OFFSET = this.currentNextOffset;
                 }
                 else {
-                    this.resourceParams.VIEW_NUMBER += 1;
+                    this.resourceParams.OFFSET = params.request.startRow;
                 }
             }
             const requestParams = {
-                DETAILS: {
-                    CRITERIA_MATCH: this.resourceParams.CRITERIA_MATCH,
-                    MAX_ROWS: this.resourceParams.MAX_ROWS,
-                    VIEW_NUMBER: this.resourceParams.VIEW_NUMBER,
-                },
+                DETAILS: this.buildRequestDetails(effectivePagingMode),
             };
             const requestResult = yield this.createReqRepRequestFunc(requestParams);
-            // TODO: massive limitation on the GSF. It should return -1 if it's already the last view/record (but it doesn't, next will have 0 rows then the NEXT_VIEW=-1).
+            // Check if MORE_ROWS is available in the response (GSF 8.14+ only)
+            const hasMoreRowsInResult = 'MORE_ROWS' in requestResult;
             let isLastView = false;
-            if (requestResult.NEXT_VIEW !== -1) {
-                const preCheckRequestParams = Object.assign(Object.assign({}, requestParams), { DETAILS: Object.assign(Object.assign({}, requestParams.DETAILS), { VIEW_NUMBER: requestResult.NEXT_VIEW }) });
-                const moreRowsPreCheck = yield this.createReqRepRequestFunc(preCheckRequestParams);
-                isLastView = moreRowsPreCheck.NEXT_VIEW === -1 && ((_a = moreRowsPreCheck.REPLY) === null || _a === void 0 ? void 0 : _a.length) === 0;
+            // Fall back to the existing logic for backwards compatibility
+            if (effectivePagingMode === 'viewBased') {
+                // Massive limitation on the GSF. It should return -1 if it's already the last view/record (but it doesn't, next will have 0 rows then the NEXT_VIEW=-1).
+                if (hasMoreRowsInResult) {
+                    // Only works with GSF 8.14+
+                    isLastView = !requestResult.MORE_ROWS;
+                }
+                else if (requestResult.NEXT_VIEW !== -1) {
+                    const preCheckRequestParams = Object.assign(Object.assign({}, requestParams), { DETAILS: Object.assign(Object.assign({}, requestParams.DETAILS), { VIEW_NUMBER: requestResult.NEXT_VIEW }) });
+                    const moreRowsPreCheck = yield this.createReqRepRequestFunc(preCheckRequestParams);
+                    isLastView = moreRowsPreCheck.NEXT_VIEW === -1 && ((_a = moreRowsPreCheck.REPLY) === null || _a === void 0 ? void 0 : _a.length) === 0;
+                }
+            }
+            else {
+                // offsetBased: check if NEXT_OFFSET exists and is valid
+                isLastView = hasMoreRowsInResult && !requestResult.MORE_ROWS;
+                if ('NEXT_OFFSET' in requestResult && requestResult.NEXT_OFFSET !== -1) {
+                    this.currentNextOffset = requestResult.NEXT_OFFSET;
+                }
+                else {
+                    this.currentNextOffset = 0;
+                }
             }
             let applyResult = true;
             if (applyResult) {
@@ -54,7 +97,7 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
         });
     }
     applyServerSideData(params, result, isLastView) {
-        var _a;
+        var _a, _b;
         const messageType = result.MESSAGE_TYPE;
         if (messageType &&
             (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
@@ -68,8 +111,27 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
             params.fail();
             return;
         }
-        this.moreRows =
-            !isLastView && result.NEXT_VIEW !== -1 && result.NEXT_VIEW > this.resourceParams.VIEW_NUMBER;
+        const effectivePagingMode = this.getEffectivePagingMode();
+        // TODO: the code below will be tweaked/removed when gsf <8.14 is no longer supported
+        if ('MORE_ROWS' in result) {
+            this.moreRows = result.MORE_ROWS;
+        }
+        else {
+            // Fall back to the existing logic for backwards compatibility
+            if (effectivePagingMode === 'viewBased') {
+                this.moreRows =
+                    !isLastView &&
+                        result.NEXT_VIEW !== -1 &&
+                        result.NEXT_VIEW > this.resourceParams.VIEW_NUMBER;
+            }
+            else {
+                // offsetBased
+                this.moreRows =
+                    !isLastView &&
+                        result.NEXT_OFFSET !== -1 &&
+                        result.NEXT_OFFSET > this.resourceParams.OFFSET;
+            }
+        }
         if (result.REPLY) {
             this.handleCurrentStreamLoad(result.REPLY);
         }
@@ -80,9 +142,27 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
             params.success(successRowData);
             return;
         }
-        this.currentSequenceId = this.resourceParams.VIEW_NUMBER; // result.NEXT_VIEW > 0 ? result.NEXT_VIEW - 1 : 0;
+        // Update current sequence ID based on paging mode
+        if (effectivePagingMode === 'viewBased') {
+            this.currentSequenceId = this.resourceParams.VIEW_NUMBER;
+        }
+        else {
+            // For offsetBased, use OFFSET / maxRows to get the sequence
+            this.currentSequenceId = Math.floor(this.resourceParams.OFFSET / this.maxRows);
+        }
         this.sourceRef = result.SOURCE_REF;
-        this.serverRowsCount += (_a = result.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
+        // For req-rep, store the total row count when we reach the last page
+        if (!this.moreRows) {
+            const currentBatchSize = this.rowData.size;
+            this.discoveredTotalRowCount = params.request.startRow + currentBatchSize;
+        }
+        // Reset serverRowsCount accumulation for req-rep pagination
+        if (this.pagination) {
+            this.serverRowsCount = (_a = result.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
+        }
+        else {
+            this.serverRowsCount += (_b = result.ROWS_COUNT) !== null && _b !== void 0 ? _b : this.rowData.size;
+        }
         const successRowData = {
             rowData: Array.from(this.rowData.values()),
         };
@@ -91,30 +171,25 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
         params.success(successRowData);
     }
     getCorrectRowCount(params) {
-        const lastRow = this.moreRows ? -1 : params.request.startRow + this.serverRowsCount;
-        const currentLastRowNumber = params.request.endRow;
-        this.calculatedRowsCount = this.serverRowsCount || currentLastRowNumber;
-        const defaultCount = Math.min(lastRow, this.maxView);
         let rowCount;
         if (this.pagination) {
-            rowCount = !this.resourceParams.CRITERIA_MATCH ? Math.min(lastRow, this.maxView) : undefined;
-            if (this.resourceParams.CRITERIA_MATCH) {
-                rowCount = defaultCount;
+            if (this.moreRows) {
+                // More data available, return -1 to indicate unknown total
+                rowCount = -1;
             }
-            if (!this.moreRows && lastRow > this.calculatedRowsCount) {
-                rowCount = this.calculatedRowsCount;
+            else {
+                // Use discovered total if available, otherwise calculate from current position
+                rowCount = this.discoveredTotalRowCount || params.request.startRow + this.rowData.size;
             }
             return rowCount;
         }
-        if (currentLastRowNumber === lastRow) {
-            rowCount = lastRow;
-        }
-        else if (currentLastRowNumber > this.maxView ||
-            currentLastRowNumber > this.calculatedRowsCount) {
-            rowCount = Math.min(defaultCount, this.calculatedRowsCount);
+        // Non-pagination mode (streaming)
+        if (this.moreRows) {
+            rowCount = -1; // More data available, unknown total
         }
-        else if (!this.moreRows && lastRow > this.calculatedRowsCount) {
-            rowCount = this.calculatedRowsCount;
+        else {
+            // Use discovered total or calculate from current batch
+            rowCount = this.discoveredTotalRowCount || params.request.startRow + this.rowData.size;
         }
         return rowCount;
     }
@@ -136,4 +211,64 @@ export class ReqRepServerSideDatasource extends BaseServerSideDatasource {
         });
         this.rowData = rows;
     }
+    /**
+     * Req-rep specific sorting setup that allows any column to be sorted
+     * (unlike dataserver which requires indexed columns only)
+     */
+    setupSorting(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const toBeAppliedSortModel = params.request.sortModel;
+            if (((_a = this.currentSortModel) === null || _a === void 0 ? void 0 : _a.length) !== toBeAppliedSortModel.length ||
+                toBeAppliedSortModel.length > 0) {
+                if (toBeAppliedSortModel.length === 0 && this.currentSortModel) {
+                    this.calculatedRowsCount = 0;
+                    this.currentSortModel = null;
+                    this.resourceParams.ORDER_BY = undefined;
+                    yield this.refreshDatasource(params);
+                    return;
+                }
+                else if (toBeAppliedSortModel.length > 0) {
+                    const coldIdBeingSorted = toBeAppliedSortModel[0].colId; // Not allowing multiple sorts by user
+                    const sortTypeBeingApplied = toBeAppliedSortModel[0].sort;
+                    // For req-rep, we can sort by any column without requiring it to be part of an index
+                    if (JSON.stringify(toBeAppliedSortModel) !== JSON.stringify(this.currentSortModel)) {
+                        this.currentSortModel = toBeAppliedSortModel;
+                        this.resourceParams.ORDER_BY =
+                            coldIdBeingSorted + (sortTypeBeingApplied === 'desc' ? ' DESC' : ' ASC'); // Use the column directly
+                        yield this.refreshDatasource(params);
+                        return;
+                    }
+                }
+            }
+        });
+    }
+    refreshDatasource(params) {
+        const _super = Object.create(null, {
+            refreshDatasource: { get: () => super.refreshDatasource }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            // Reset discovered total when refreshing (sorting/filtering changes)
+            this.discoveredTotalRowCount = null;
+            this.currentNextOffset = 0;
+            // Reset pagination parameters to start from beginning
+            this.resourceParams.VIEW_NUMBER = this.zeroBasedViewNumber ? 0 : 1;
+            this.resourceParams.OFFSET = 0;
+            yield _super.refreshDatasource.call(this, params);
+        });
+    }
+    buildRequestDetails(effectivePagingMode) {
+        const baseDetails = {
+            CRITERIA_MATCH: this.resourceParams.CRITERIA_MATCH,
+            MAX_ROWS: this.resourceParams.MAX_ROWS,
+            ORDER_BY: this.resourceParams.ORDER_BY,
+        };
+        if (effectivePagingMode === 'viewBased') {
+            return Object.assign(Object.assign({}, baseDetails), { VIEW_NUMBER: this.resourceParams.VIEW_NUMBER });
+        }
+        else {
+            // offsetBased
+            return Object.assign(Object.assign({}, baseDetails), { OFFSET: this.resourceParams.OFFSET });
+        }
+    }
 }