@genesislcap/grid-pro 14.199.2-alpha-0c81553.0 → 14.199.2

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

@@ -1,17 +1,286 @@
 import { __awaiter, __decorate } from "tslib";
-import { Events, } from '@ag-grid-community/core';
-import { dataServerResultFilter, MessageType, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
+import { Auth, Connect, dataServerResultFilter, extractFieldDefinitions, MessageType, normaliseCriteria, toFieldMetadata, } from '@genesislcap/foundation-comms';
 import { LifecycleMixin } from '@genesislcap/foundation-utils';
-import { attr, customElement, DOM, observable } from '@microsoft/fast-element';
-import { gridProGenesisDatasourceEventNames } from '../grid-pro-genesis-datasource';
-import { logger } from '../utils';
-import { GridProBaseDatasource } from './base.datasource';
+import { attr, customElement, DOM } from '@microsoft/fast-element';
+import { getAvailableIndexes, getAvailableIndexFields, logger } from '../utils';
+import { GridProBaseDatasource, StreamBaseDatasource } from './base.datasource';
 import { getServerSideFilterParamsByFieldType } from './server-side.grid-definitions';
-import { DataserverServerSideDatasource } from './server-side.resource-dataserver';
-import { ReqRepServerSideDatasource } from './server-side.resource-reqrep';
+/**
+ * The IServerSideDatasource implementation, used for SSRM (Server-Side Row Model) in the grid.
+ * @alpha
+ */
+export class StreamDatasource extends StreamBaseDatasource {
+    constructor(options) {
+        super();
+        /**
+         * The number of rows in the grid. THIS DO NOT CONSIDER CRITERIA_MATCH scenarios.
+         * @internal
+         */
+        this.server_ROWS_COUNT = 0;
+        /**
+         * The number of rows in the grid. THIS IS A LOCAL COUNT CONSIDERING CONSIDER CRITERIA_MATCH scenarios.
+         * @internal
+         */
+        this.client_ROWS_COUNT = 0;
+        this.moreRows = false;
+        this.calculatedRowsCount = 0;
+        this.lastSequenceId = 0;
+        this.createDataserverStreamFunc = options.createDataserverStreamFunc;
+        this.resourceName = options.resourceName;
+        this.resourceParams = options.resourceParams;
+        this.originalCriteriaMatch = options.resourceParams.CRITERIA_MATCH;
+        this.resourceIndexes = options.resourceIndexes;
+        this.resourceColDefs = options.resourceColDefs;
+        this.maxRows = options.maxRows;
+        this.maxView = options.maxView;
+        this.rowId = options.rowId;
+        this.pagination = options.pagination;
+    }
+    getRows(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const filterModelBeingApplied = params.request.filterModel;
+            const filtersAreBeingApplied = Object.keys(filterModelBeingApplied).length > 0;
+            const filtersAreGettingCleaned = Object.keys(filterModelBeingApplied).length === 0;
+            const filterModelBeingAppliedDiffersFromCurrent = JSON.stringify(filterModelBeingApplied) !== JSON.stringify(this.currentFilterModel);
+            if (filterModelBeingAppliedDiffersFromCurrent || filtersAreBeingApplied) {
+                if (filtersAreGettingCleaned && this.currentFilterModel) {
+                    this.currentFilterModel = null;
+                    this.resourceParams.CRITERIA_MATCH = this.originalCriteriaMatch;
+                    yield this.refreshDatasource(params);
+                    return;
+                }
+                else if (filterModelBeingAppliedDiffersFromCurrent && filtersAreBeingApplied) {
+                    this.currentFilterModel = filterModelBeingApplied;
+                    this.resourceParams.CRITERIA_MATCH = this.buildCriteriaMatchFromFilters();
+                    yield this.refreshDatasource(params);
+                    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) {
+                    this.currentSortModel = toBeAppliedSortModel;
+                    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.resourceParams.ORDER_BY = orderByAndToBeSortedColIds.orderBy;
+                        this.resourceParams.REVERSE = sortTypeBeingApplied === 'desc' ? true : false;
+                        yield this.refreshDatasource(params);
+                        return;
+                    }
+                }
+            }
+            if (this.moreRows && params.request.startRow >= Number(this.maxRows)) {
+                this.connect.getMoreRows(this.streamSourceRef);
+            }
+            if (!this.dataserverStream) {
+                this.dataserverStream = yield this.createDataserverStreamFunc(this.resourceParams);
+            }
+            let applyResult = true;
+            this.dataserverStreamSubscription = this.dataserverStream.subscribe((dataserverResult) => {
+                if (applyResult) {
+                    this.applyServerSideData(params, dataserverResult);
+                    applyResult = false;
+                }
+            });
+        });
+    }
+    applyServerSideData(params, result) {
+        var _a;
+        const messageType = result.MESSAGE_TYPE;
+        if (messageType &&
+            (messageType === MessageType.LOGOFF_ACK || messageType === MessageType.MSG_NACK)) {
+            params.fail();
+            return;
+        }
+        this.moreRows = result.MORE_ROWS;
+        if (result.ROW) {
+            const nextMessage = dataServerResultFilter(result);
+            this.handleCurrentStreamLoad(nextMessage);
+        }
+        else {
+            this.rowData = new Map();
+            const successRowData = { rowData: [] };
+            successRowData.rowCount = 0;
+            params.success(successRowData);
+            return;
+        }
+        this.lastSequenceId = result.SEQUENCE_ID;
+        if (this.lastSequenceId === 1) {
+            this.streamSourceRef = result.SOURCE_REF;
+            this.server_ROWS_COUNT = (_a = result.ROWS_COUNT) !== null && _a !== void 0 ? _a : this.rowData.size;
+        }
+        const successRowData = {
+            rowData: Array.from(this.sortMapByNumericKey(this.rowData).values()),
+            rowCount: this.pagination && !this.resourceParams.CRITERIA_MATCH
+                ? Math.min(this.server_ROWS_COUNT, this.maxView)
+                : undefined,
+        };
+        this.calculatedRowsCount = this.client_ROWS_COUNT;
+        if (this.calculatedRowsCount === 0) {
+            this.calculatedRowsCount = params.request.endRow;
+        }
+        if (params.request.endRow > this.maxView || params.request.endRow > this.calculatedRowsCount) {
+            successRowData.rowCount = this.calculatedRowsCount;
+        }
+        else if (params.request.endRow === this.server_ROWS_COUNT) {
+            successRowData.rowCount = this.server_ROWS_COUNT;
+        }
+        else if (!this.moreRows && this.server_ROWS_COUNT > this.calculatedRowsCount) {
+            successRowData.rowCount = this.calculatedRowsCount;
+        }
+        params.success(successRowData);
+    }
+    sortMapByNumericKey(inputMap) {
+        // Convert Map to array of key-value pairs
+        const sortedArray = Array.from(inputMap.entries()).sort(([key1], [key2]) => +key2 - +key1);
+        // Create a new Map from the sorted array
+        const sortedMap = new Map(sortedArray);
+        return sortedMap;
+    }
+    deinit() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.rowData = new Map();
+            this.client_ROWS_COUNT = 0;
+            this.calculatedRowsCount = 0;
+            this.server_ROWS_COUNT = 0;
+            this.dataserverStream = undefined;
+            (_a = this.dataserverStreamSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+            this.dataserverStreamSubscription = undefined;
+            this.streamSourceRef = undefined;
+        });
+    }
+    refreshDatasource(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deinit();
+            (_a = params.api) === null || _a === void 0 ? void 0 : _a.refreshServerSide({ purge: true });
+            params.fail();
+        });
+    }
+    getOrderByAndToBeSortedColIds(map, searchValue) {
+        for (const [key, value] of map.entries()) {
+            const searchIndex = value.findIndex((x) => x === searchValue);
+            if (searchIndex !== -1) {
+                const copy = [...value];
+                const toBeSorted = copy.splice(searchIndex, 1);
+                return { orderBy: key, toBeSorted };
+            }
+        }
+    }
+    handleCurrentStreamLoad(result) {
+        var _a;
+        if (!result)
+            return;
+        const rows = new Map();
+        (_a = result.inserts) === null || _a === void 0 ? void 0 : _a.forEach((insertData) => {
+            rows.set(insertData[this.rowId], insertData);
+        });
+        this.rowData = rows;
+    }
+    buildCriteriaMatchFromFilters() {
+        this.resourceParams.CRITERIA_MATCH = this.originalCriteriaMatch;
+        if (this.resourceParams.CRITERIA_MATCH &&
+            typeof this.resourceParams.CRITERIA_MATCH === 'string') {
+            this.resourceParams.CRITERIA_MATCH = this.resourceParams.CRITERIA_MATCH.split(';');
+        }
+        if (!this.resourceParams.CRITERIA_MATCH) {
+            this.resourceParams.CRITERIA_MATCH = [];
+        }
+        const criteria = this.resourceParams.CRITERIA_MATCH.concat(this.criteriaFromFilters());
+        return criteria.join(' && ');
+    }
+    // TODO: update this following https://learn.genesis.global/docs/server/data-server/advanced/#common-expressions
+    criteriaFromFilters() {
+        const filters = [];
+        this.getFiltersByType('text').forEach((k) => {
+            // TODO: no official "boolean" filter type, it's a "text"
+            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 'equals':
+                        filters.push(`${k} == '${this.currentFilterModel[k].filter}'`);
+                        break;
+                    case 'contains':
+                        filters.push(`Expr.containsIgnoreCase(${k}, '${this.currentFilterModel[k].filter}')`);
+                        break;
+                }
+            }
+        });
+        this.getFiltersByType('number').forEach((k) => {
+            const value = this.currentFilterModel[k].filter;
+            switch (this.currentFilterModel[k].type) {
+                case 'equals':
+                    !isNaN(value) && filters.push(`${k} == ${value}`);
+                    break;
+                case 'lessThan':
+                    !isNaN(value) && filters.push(`${k} < ${value}`);
+                    break;
+                case 'greaterThan':
+                    !isNaN(value) && filters.push(`${k} > ${value}`);
+                    break;
+            }
+        });
+        this.getFiltersByType('date').forEach((k) => {
+            const dateFrom = this.currentFilterModel[k].dateFrom
+                .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;
+                default:
+                    break;
+            }
+        });
+        return filters;
+    }
+    getFiltersByType(filterType) {
+        return Object.keys(this.currentFilterModel)
+            .filter((k) => this.resourceColDefs.findIndex((o) => o.NAME === k) !== -1)
+            .filter((k) => this.currentFilterModel[k].filterType === filterType);
+    }
+}
+__decorate([
+    Auth
+], StreamDatasource.prototype, "auth", void 0);
+__decorate([
+    Connect
+], StreamDatasource.prototype, "connect", void 0);
 const criteriaDelimiter = ';';
 const withoutColumnDefs = null;
-const timeoutInMs = 500;
 /**
  * A Genesis Datasource element, for server-side | SSRM-compatible data fetching and used exclusively by the GridPro element.
  * @remarks Only supports Server-Side Row Model. Requires `@ag-grid-enterprise/server-side-row-model` setup and valid AG Grid Enterprise license.
@@ -23,33 +292,34 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
         this.applyFuncName = 'applyServerSideTransaction';
         this.applyAsyncFuncName = 'applyServerSideTransactionAsync';
         this.pagination = false;
-        /**
-         * The starting VIEW_NUMBER of the data to be fetched.
-         * @remarks The VIEW_NUMBER isincremented by the grid as the user scrolls or changes pages.
-         */
-        this.zeroBasedViewNumber = false;
-        /**
-         * Enable live updates for the grid.
-         * @remarks Only works with DATASERVER resources (StreamDatasource) right now.
-         */
-        this.liveUpdates = false;
-        this.request = {};
-    }
-    resourceNameChanged(oldValue, newValue) {
-        if (!oldValue || oldValue === newValue)
-            return;
-        DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
-            yield this.restart();
-        }));
     }
     criteriaChanged(oldCriteria, newCriteria) {
         const criteriaIsNotDuplicate = oldCriteria !== normaliseCriteria(newCriteria, criteriaDelimiter);
         if (this.ssrmDatasource && criteriaIsNotDuplicate) {
-            DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
-                yield this.reloadResourceData();
-            }));
+            this.reloadResourceData();
         }
     }
+    /**
+     * Resets the grid data while keeping columnDefs and sends a DATA_LOGOFF message if it's a stream.
+     * @remarks This is used when the grid is already initialized and we want to reload the data due to a criteria/filter change.
+     * @internal
+     */
+    reloadResourceData() {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clearRowData(withoutColumnDefs);
+            this.ssrmDatasource.streamSourceRef = undefined;
+            this.ssrmDatasource = undefined;
+            (_a = this.agGrid.gridApi) === null || _a === void 0 ? void 0 : _a.refreshServerSide({ purge: true });
+            (_c = (_b = this.agGrid) === null || _b === void 0 ? void 0 : _b.gridApi) === null || _c === void 0 ? void 0 : _c.showLoadingOverlay();
+            this.init();
+        });
+    }
+    resourceNameChanged(oldValue, newValue) {
+        if (!oldValue || oldValue === newValue)
+            return;
+        this.restart();
+    }
     connectedCallback() {
         super.connectedCallback();
         const shouldRunConnect = this.shouldRunConnect;
@@ -62,11 +332,11 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
     disconnectedCallback() {
         super.disconnectedCallback();
         const shouldRunDisconnect = this.shouldRunDisconnect;
-        DOM.queueUpdate(() => __awaiter(this, void 0, void 0, function* () {
+        DOM.queueUpdate(() => {
             if (!shouldRunDisconnect)
                 return;
-            yield this.destroy();
-        }));
+            this.deinit();
+        });
     }
     deepClone() {
         const copy = super.deepClone();
@@ -74,134 +344,68 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
         copy.deferredColumnStates = structuredClone(this.deferredColumnStates);
         return copy;
     }
-    /**
-     * Resets the grid data while keeping columnDefs and sends a DATA_LOGOFF message if it's a stream.
-     * @remarks This is used when the grid is already initialized and we want to reload the data due to a criteria/filter change.
-     * @internal
-     */
-    reloadResourceData(params) {
-        var _a, _b, _c, _d, _e, _f;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.datasource.destroy();
-            (_a = this.liveUpdatesStream) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-            this.liveUpdatesStream = undefined;
-            this.clearRowData(withoutColumnDefs);
-            if (params) {
-                // this.datasource.stream = undefined;
-                const options = Object.assign(Object.assign({}, this.datasourceOptions()), params);
-                const initOK = yield this.datasource.init(options, true, false);
-                // this.$emit(gridProGenesisDatasourceEventNames.dataInit);
-                if (!initOK) {
-                    (_b = this.agGrid.gridApi) === null || _b === void 0 ? void 0 : _b.setServerSideDatasource(null);
-                    logger.error('Genesis Datasource re-init failed on filtering/sorting.');
-                }
-            }
-            else {
-                if (this.ssrmDatasource) {
-                    yield this.ssrmDatasource.destroy();
-                    this.ssrmDatasource = undefined;
-                }
-                (_c = this.agGrid.gridApi) === null || _c === void 0 ? void 0 : _c.setServerSideDatasource(null);
-                (_d = this.agGrid.gridApi) === null || _d === void 0 ? void 0 : _d.refreshServerSide({ purge: true });
-                (_f = (_e = this.agGrid) === null || _e === void 0 ? void 0 : _e.gridApi) === null || _f === void 0 ? void 0 : _f.showLoadingOverlay();
-                yield this.init();
-            }
-        });
+    deinit() {
+        var _a;
+        this.clearRowData();
+        this.ssrmDatasource.deinit();
+        this.ssrmDatasource = undefined;
+        this.originalFieldDef = undefined;
+        (_a = this.agGrid.gridApi) === null || _a === void 0 ? void 0 : _a.refreshServerSide({ purge: true });
     }
     init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.agGrid) {
-                this.agGrid.gridOptions = Object.assign(Object.assign({ getRowId: (params) => {
-                        if (!params.data) {
-                            return null;
-                        }
-                        return 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')) {
-                            return { color: 'grey' };
-                        }
-                    }, cacheBlockSize: this.maxRows, defaultColDef: {
-                        filter: true,
-                        resizable: true,
-                        sortable: false,
-                    }, pagination: this.pagination, paginationPageSize: this.maxRows, rowBuffer: 0, rowModelType: 'serverSide', suppressServerSideInfiniteScroll: false, suppressMultiSort: true, onFilterChanged: (params) => { }, onSortChanged: (params) => { }, onPaginationChanged: (event) => this.onPaginationChanged(event) }, this.agGrid['agGridOptions']), this.deferredGridOptions);
-                this.agGrid['initGrid']();
-                this.agGrid.addEventListener(Events.EVENT_GRID_READY, () => __awaiter(this, void 0, void 0, function* () {
-                    const initOK = yield this.datasource.init(this.datasourceOptions(), true, false);
-                    if (!initOK) {
-                        logger.debug(`Genesis Datasource init failed for ${this.resourceName}`);
-                        this.clearRowData();
-                        return;
-                    }
-                    this.$emit(gridProGenesisDatasourceEventNames.dataInit);
-                    this.indexes = this.getResourceIndexes(this.datasource.availableIndexes);
-                    const fieldMetadata = toFieldMetadata(this.datasource.originalFieldDef);
-                    const agColumnDefs = yield this.getAgColumnDefs(fieldMetadata);
-                    this.agGrid.gridApi.setColumnDefs(agColumnDefs);
-                    if (this.isRequestServer) {
-                        this.ssrmDatasource = new ReqRepServerSideDatasource({
-                            createReqRepRequestFunc: this.createReqRepRequest.bind(this),
-                            reloadResourceDataFunc: this.reloadResourceData.bind(this),
-                            resourceName: this.resourceName,
-                            resourceParams: this.params,
-                            resourceIndexes: this.indexes,
-                            resourceColDefs: this.datasource.originalFieldDef,
-                            maxRows: +this.maxRows,
-                            maxView: +this.maxView,
-                            rowId: this.rowId,
-                            pagination: this.pagination,
-                            zeroBasedViewNumber: this.zeroBasedViewNumber,
-                        });
+        if (this.agGrid && this.resourceName && this.connect.isConnected) {
+            this.agGrid.gridOptions = Object.assign(Object.assign({ getRowId: (params) => {
+                    if (!params.data) {
+                        return null;
                     }
-                    else {
-                        this.ssrmDatasource = new DataserverServerSideDatasource({
-                            createDataserverStreamFunc: this.createDataserverStream.bind(this),
-                            reloadResourceDataFunc: this.reloadResourceData.bind(this),
-                            resourceName: this.resourceName,
-                            resourceParams: this.params,
-                            resourceIndexes: this.indexes,
-                            resourceColDefs: this.datasource.originalFieldDef,
-                            maxRows: +this.maxRows,
-                            maxView: +this.maxView,
-                            rowId: this.rowId,
-                            pagination: this.pagination,
-                            zeroBasedViewNumber: this.zeroBasedViewNumber,
-                        });
+                    return 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')) {
+                        return { color: 'grey' };
                     }
-                    this.agGrid.gridApi.setServerSideDatasource(this.ssrmDatasource);
-                }), { once: true });
-                return;
-            }
-            logger.warn(`Application not connected, falling back to local columnDefs/rowData`);
-        });
-    }
-    onPaginationChanged(event) {
-        var _a;
-        if (this.agGrid.gridApi && this.ssrmDatasource) {
-            this.ssrmDatasource.isNewPageSize = (_a = event.newPage) !== null && _a !== void 0 ? _a : false;
+                }, cacheBlockSize: this.maxRows, defaultColDef: {
+                    filter: true,
+                    resizable: true,
+                    sortable: false,
+                }, pagination: this.pagination, paginationPageSize: this.maxRows, rowBuffer: 0, rowModelType: 'serverSide', suppressServerSideInfiniteScroll: false, suppressMultiSort: true, onFilterChanged: (params) => { }, onSortChanged: (params) => { } }, this.agGrid['agGridOptions']), this.deferredGridOptions);
+            this.agGrid['initGrid']();
+            this.agGrid.addEventListener('onGridReady', () => __awaiter(this, void 0, void 0, function* () {
+                /**
+                 * We should have all the metadata via Datasource, ie.
+                 * Datasource.availableIndexes, Datasource.originalFieldDef etc.
+                 * Could this not leverage that?
+                 */
+                const meta = yield this.connect
+                    .getMetadata(this.resourceName)
+                    .catch((e) => logger.error(e));
+                if (!meta)
+                    return false;
+                this.indexes = this.getResourceIndexes(meta.INDEXES);
+                this.originalFieldDef = extractFieldDefinitions(meta);
+                const fieldMetadata = toFieldMetadata(this.originalFieldDef);
+                const agColumnDefs = yield this.getAgColumnDefs(fieldMetadata);
+                this.agGrid.gridApi.setColumnDefs(agColumnDefs);
+                this.ssrmDatasource = new StreamDatasource({
+                    createDataserverStreamFunc: this.createDataserverStream.bind(this),
+                    resourceName: this.resourceName,
+                    resourceParams: this.params,
+                    resourceIndexes: this.indexes,
+                    resourceColDefs: this.originalFieldDef,
+                    maxRows: +this.maxRows,
+                    maxView: +this.maxView,
+                    rowId: this.rowId,
+                    pagination: this.pagination,
+                });
+                this.agGrid.gridApi.setServerSideDatasource(this.ssrmDatasource);
+            }), { once: true });
+            return;
         }
-    }
-    destroy() {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.datasource.destroy();
-            (_a = this.liveUpdatesStream) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-            this.liveUpdatesStream = undefined;
-            this.clearRowData();
-            if (this.ssrmDatasource) {
-                yield this.ssrmDatasource.destroy();
-                this.ssrmDatasource = undefined;
-            }
-            (_b = this.agGrid.gridApi) === null || _b === void 0 ? void 0 : _b.setServerSideDatasource(null);
-            (_c = this.agGrid.gridApi) === null || _c === void 0 ? void 0 : _c.refreshServerSide({ purge: true });
-        });
+        logger.warn(`Application not connected, falling back to local columnDefs/rowData`);
     }
     restart() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.destroy();
-            this.init();
-        });
+        this.deinit();
+        this.init();
     }
     clearRowData(withColumnDefs = true) {
         var _a, _b, _c, _d;
@@ -248,69 +452,50 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
     get rowModel() {
         return this.agGrid.gridApi.getModel();
     }
-    createReqRepRequest(existingParams = null) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const reqRep = yield this.datasource.snapshot(existingParams);
-            return reqRep;
-        });
-    }
     createDataserverStream(existingParams = null) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.liveUpdates) {
-                const streamOnMessage = (message) => __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b;
-                    const messageType = message.MESSAGE_TYPE;
-                    if (messageType === MessageType.QUERY_UPDATE && message.ROW) {
-                        if (!this.ssrmDatasource) {
-                            return;
-                        }
-                        const nextMessage = dataServerResultFilter(message);
-                        this.agTransaction = { add: [], remove: [], update: [] };
-                        this.handleStreamInserts(nextMessage.inserts);
-                        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) {
-                            this.applyAllAgTransactions();
-                        }
-                        else {
-                            // TODO: Double-check this bit / DOM.queueUpdate do not work here
-                            setTimeout(() => {
-                                this.applyAllAgTransactions();
-                            }, timeoutInMs);
-                        }
+            const streamOnMessage = (message) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const messageType = message.MESSAGE_TYPE;
+                if (messageType === MessageType.QUERY_UPDATE && message.ROW) {
+                    if (!this.ssrmDatasource) {
+                        return;
                     }
-                });
-                const onError = (error) => logger.error(error);
-                this.liveUpdatesStream = this.connect
-                    .stream(this.resourceName, () => { }, onError, existingParams !== null && existingParams !== void 0 ? existingParams : this.params)
-                    .subscribe((message) => streamOnMessage(message));
-                // return this.connect.stream(
-                //   this.resourceName,
-                //   (message) => streamOnMessage(message),
-                //   onError,
-                //   existingParams ?? this.params,
-                // );
+                    const nextMessage = dataServerResultFilter(message);
+                    this.agTransaction = { add: [], remove: [], update: [] };
+                    this.handleStreamInserts(nextMessage.inserts);
+                    // TODO: deletion flow not being handled yet.
+                    // this.handleStreamDeletes(nextMessage.deletes);
+                    this.handleStreamDeletesTemp(nextMessage.deletes);
+                    this.handleStreamUpdates(nextMessage.updates);
+                    this.ssrmDatasource.client_ROWS_COUNT += (_a = nextMessage.inserts.length) !== null && _a !== void 0 ? _a : 0;
+                    if (message.SEQUENCE_ID > 1) {
+                        const updatedInfo = yield this.connect.snapshot(this.resourceName, {
+                            MAX_ROWS: 1,
+                            MAX_VIEW: 1,
+                            CRITERIA_MATCH: this.criteria,
+                        });
+                        this.ssrmDatasource.server_ROWS_COUNT = updatedInfo.ROWS_COUNT;
+                    }
+                    this.applyAllAgTransactions();
+                }
+            });
+            const onError = (error) => logger.error(error);
+            return this.connect.stream(this.resourceName, (message) => {
+                streamOnMessage(message);
+            }, onError, existingParams !== null && existingParams !== void 0 ? existingParams : this.params);
+        });
+    }
+    handleStreamDeletesTemp(deletes) {
+        if (!deletes)
+            return;
+        deletes.forEach((deleteData) => {
+            const rowNode = this.agGrid.gridApi.getRowNode(deleteData.ROW_REF);
+            if (rowNode) {
+                rowNode.setData(Object.assign(Object.assign({}, rowNode.data), { ROW_REF: deleteData.ROW_REF + '_deleted' }));
             }
-            yield this.datasource.startStream();
-            return this.datasource.stream;
         });
     }
-    // private handleStreamDeletesTemp(deletes: RowData[]) {
-    //   if (!deletes) return;
-    //   deletes.forEach((deleteData) => {
-    //     const rowNode = this.agGrid.gridApi.getRowNode(deleteData.ROW_REF);
-    //     if (rowNode) {
-    //       rowNode.setData({ ...rowNode.data, ROW_REF: deleteData.ROW_REF + '_deleted' });
-    //     }
-    //   });
-    // }
     getAgColumnDefs(fieldsMetadata) {
         return __awaiter(this, void 0, void 0, function* () {
             const colDefsFromGenesisData = this.generateColumnDefsFromMetadata(fieldsMetadata, getServerSideFilterParamsByFieldType);
@@ -333,15 +518,6 @@ let GridProServerSideDatasource = class GridProServerSideDatasource extends Life
 __decorate([
     attr({ mode: 'boolean' })
 ], GridProServerSideDatasource.prototype, "pagination", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'zero-based-view-number' })
-], GridProServerSideDatasource.prototype, "zeroBasedViewNumber", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'live-updates' })
-], GridProServerSideDatasource.prototype, "liveUpdates", void 0);
-__decorate([
-    observable
-], GridProServerSideDatasource.prototype, "request", void 0);
 GridProServerSideDatasource = __decorate([
     customElement({
         name: 'grid-pro-server-side-datasource',