dbgate-datalib 5.1.4 → 5.1.5

package/lib/PerspectiveCache.d.ts

@@ -1,4 +1,5 @@
 import { PerspectiveDataLoadProps } from './PerspectiveDataProvider';
+import { PerspectiveDataPattern } from './PerspectiveDataPattern';
 export declare class PerspectiveBindingGroup {
     table: PerspectiveCacheTable;
     constructor(table: PerspectiveCacheTable);
@@ -15,6 +16,7 @@ export declare class PerspectiveCacheTable {
     pureName: string;
     bindingColumns?: string[];
     dataColumns: string[];
+    allColumns?: boolean;
     loadedAll: boolean;
     loadedRows: any[];
     bindingGroups: {
@@ -35,6 +37,7 @@ export declare class PerspectiveCache {
     tables: {
         [tableKey: string]: PerspectiveCacheTable;
     };
+    dataPatterns: PerspectiveDataPattern[];
     getTableCache(props: PerspectiveDataLoadProps): PerspectiveCacheTable;
     clear(): void;
 }

package/lib/PerspectiveCache.js

@@ -75,11 +75,20 @@ exports.PerspectiveCacheTable = PerspectiveCacheTable;
 class PerspectiveCache {
     constructor() {
         this.tables = {};
+        this.dataPatterns = [];
     }
     getTableCache(props) {
-        const tableKey = (0, json_stable_stringify_1.default)((0, pick_1.default)(props, ['schemaName', 'pureName', 'bindingColumns', 'databaseConfig', 'orderBy', 'condition']));
+        const tableKey = (0, json_stable_stringify_1.default)((0, pick_1.default)(props, [
+            'schemaName',
+            'pureName',
+            'bindingColumns',
+            'databaseConfig',
+            'orderBy',
+            'sqlCondition',
+            'mongoCondition',
+        ]));
         let res = this.tables[tableKey];
-        if (res && (0, difference_1.default)(props.dataColumns, res.dataColumns).length > 0) {
+        if (res && (0, difference_1.default)(props.dataColumns, res.dataColumns).length > 0 && !res.allColumns) {
             dbg('Delete cache because incomplete columns', props.pureName, res.dataColumns);
             // we have incomplete cache
             delete this.tables[tableKey];
@@ -95,6 +104,7 @@ class PerspectiveCache {
     }
     clear() {
         this.tables = {};
+        this.dataPatterns = [];
     }
 }
 exports.PerspectiveCache = PerspectiveCache;

package/lib/PerspectiveConfig.d.ts

@@ -1,4 +1,9 @@
 import { DatabaseInfo, ForeignKeyInfo } from 'dbgate-types';
+export declare type PerspectiveDatabaseEngineType = 'sqldb' | 'docdb';
+export interface PerspectiveDatabaseConfig {
+    conid: string;
+    database: string;
+}
 export interface PerspectiveCustomJoinConfig {
     refNodeDesignerId: string;
     referenceDesignerId: string;

package/lib/PerspectiveDataLoader.d.ts

@@ -3,8 +3,16 @@ import { PerspectiveDataLoadProps } from './PerspectiveDataProvider';
 export declare class PerspectiveDataLoader {
     apiCall: any;
     constructor(apiCall: any);
-    buildCondition(props: PerspectiveDataLoadProps): Condition;
+    buildSqlCondition(props: PerspectiveDataLoadProps): Condition;
+    buildMongoCondition(props: PerspectiveDataLoadProps): {};
+    loadGroupingSqlDb(props: PerspectiveDataLoadProps): Promise<any>;
+    loadGroupingDocDb(props: PerspectiveDataLoadProps): Promise<any>;
     loadGrouping(props: PerspectiveDataLoadProps): Promise<any>;
+    loadDataSqlDb(props: PerspectiveDataLoadProps): Promise<any>;
+    getDocDbLoadOptions(props: PerspectiveDataLoadProps, useSort: boolean): any;
+    loadDataDocDb(props: PerspectiveDataLoadProps): Promise<any>;
     loadData(props: PerspectiveDataLoadProps): Promise<any>;
+    loadRowCountSqlDb(props: PerspectiveDataLoadProps): Promise<any>;
+    loadRowCountDocDb(props: PerspectiveDataLoadProps): Promise<any>;
     loadRowCount(props: PerspectiveDataLoadProps): Promise<any>;
 }

package/lib/PerspectiveDataLoader.js

@@ -14,16 +14,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PerspectiveDataLoader = void 0;
 const debug_1 = __importDefault(require("debug"));
+const zipObject_1 = __importDefault(require("lodash/zipObject"));
+const mapValues_1 = __importDefault(require("lodash/mapValues"));
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const dbgate_tools_1 = require("dbgate-tools");
+function normalizeLoadedRow(row) {
+    return (0, mapValues_1.default)(row, v => (0, dbgate_tools_1.safeJsonParse)(v) || v);
+}
+function normalizeResult(result) {
+    if ((0, isArray_1.default)(result)) {
+        return result.map(normalizeLoadedRow);
+    }
+    if (result.errorMessage) {
+        return result;
+    }
+    return Object.assign(Object.assign({}, result), { errorMessage: 'Unspecified error' });
+}
 const dbg = (0, debug_1.default)('dbgate:PerspectiveDataLoader');
 class PerspectiveDataLoader {
     constructor(apiCall) {
         this.apiCall = apiCall;
     }
-    buildCondition(props) {
-        const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, condition } = props;
+    buildSqlCondition(props) {
+        const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, sqlCondition } = props;
         const conditions = [];
-        if (condition) {
-            conditions.push(condition);
+        if (sqlCondition) {
+            conditions.push(sqlCondition);
         }
         if ((bindingColumns === null || bindingColumns === void 0 ? void 0 : bindingColumns.length) == 1) {
             conditions.push({
@@ -45,10 +61,22 @@ class PerspectiveDataLoader {
             }
             : null;
     }
-    loadGrouping(props) {
-        var _a;
+    buildMongoCondition(props) {
+        const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, mongoCondition } = props;
+        const conditions = [];
+        if (mongoCondition) {
+            conditions.push(mongoCondition);
+        }
+        if ((bindingColumns === null || bindingColumns === void 0 ? void 0 : bindingColumns.length) == 1) {
+            conditions.push({
+                [bindingColumns[0]]: { $in: bindingValues.map(x => x[0]) },
+            });
+        }
+        return conditions.length == 1 ? conditions[0] : conditions.length > 0 ? { $and: conditions } : null;
+    }
+    loadGroupingSqlDb(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns } = props;
+            const { schemaName, pureName, bindingColumns } = props;
             const bindingColumnExpressions = bindingColumns.map(columnName => ({
                 exprType: 'column',
                 columnName,
@@ -75,11 +103,11 @@ class PerspectiveDataLoader {
                     },
                     ...bindingColumnExpressions,
                 ],
-                where: this.buildCondition(props),
+                where: this.buildSqlCondition(props),
             };
             select.groupBy = bindingColumnExpressions;
             if (dbg === null || dbg === void 0 ? void 0 : dbg.enabled) {
-                dbg(`LOAD COUNTS, table=${props.pureName}, columns=${(_a = props.dataColumns) === null || _a === void 0 ? void 0 : _a.join(',')}`);
+                dbg(`LOAD COUNTS, table=${props.pureName}, columns=${bindingColumns === null || bindingColumns === void 0 ? void 0 : bindingColumns.join(',')}`);
             }
             const response = yield this.apiCall('database-connections/sql-select', {
                 conid: props.databaseConfig.conid,
@@ -91,10 +119,49 @@ class PerspectiveDataLoader {
             return response.rows.map(row => (Object.assign(Object.assign({}, row), { _perspective_group_size_: parseInt(row._perspective_group_size_) })));
         });
     }
-    loadData(props) {
+    loadGroupingDocDb(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { schemaName, pureName, bindingColumns } = props;
+            const aggregate = [
+                { $match: this.buildMongoCondition(props) },
+                {
+                    $group: {
+                        _id: (0, zipObject_1.default)(bindingColumns, bindingColumns.map(col => '$' + col)),
+                        count: { $sum: 1 },
+                    },
+                },
+            ];
+            if (dbg === null || dbg === void 0 ? void 0 : dbg.enabled) {
+                dbg(`LOAD COUNTS, table=${props.pureName}, columns=${bindingColumns === null || bindingColumns === void 0 ? void 0 : bindingColumns.join(',')}`);
+            }
+            const response = yield this.apiCall('database-connections/collection-data', {
+                conid: props.databaseConfig.conid,
+                database: props.databaseConfig.database,
+                options: {
+                    pureName,
+                    aggregate,
+                },
+            });
+            if (response.errorMessage)
+                return response;
+            return response.rows.map(row => (Object.assign(Object.assign({}, row._id), { _perspective_group_size_: parseInt(row.count) })));
+        });
+    }
+    loadGrouping(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { engineType } = props;
+            switch (engineType) {
+                case 'sqldb':
+                    return this.loadGroupingSqlDb(props);
+                case 'docdb':
+                    return this.loadGroupingDocDb(props);
+            }
+        });
+    }
+    loadDataSqlDb(props) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, condition } = props;
+            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, sqlCondition: condition, engineType, } = props;
             if ((dataColumns === null || dataColumns === void 0 ? void 0 : dataColumns.length) == 0) {
                 return [];
             }
@@ -111,16 +178,18 @@ class PerspectiveDataLoader {
                     },
                 })),
                 selectAll: !dataColumns,
-                orderBy: orderBy === null || orderBy === void 0 ? void 0 : orderBy.map(({ columnName, order }) => ({
-                    exprType: 'column',
-                    columnName,
-                    direction: order,
-                    source: {
-                        name: { schemaName, pureName },
-                    },
-                })),
+                orderBy: (orderBy === null || orderBy === void 0 ? void 0 : orderBy.length) > 0
+                    ? orderBy === null || orderBy === void 0 ? void 0 : orderBy.map(({ columnName, order }) => ({
+                        exprType: 'column',
+                        columnName,
+                        direction: order,
+                        source: {
+                            name: { schemaName, pureName },
+                        },
+                    }))
+                    : null,
                 range: props.range,
-                where: this.buildCondition(props),
+                where: this.buildSqlCondition(props),
             };
             if (dbg === null || dbg === void 0 ? void 0 : dbg.enabled) {
                 dbg(`LOAD DATA, table=${props.pureName}, columns=${(_a = props.dataColumns) === null || _a === void 0 ? void 0 : _a.join(',')}, range=${(_b = props.range) === null || _b === void 0 ? void 0 : _b.offset},${(_c = props.range) === null || _c === void 0 ? void 0 : _c.limit}`);
@@ -135,9 +204,52 @@ class PerspectiveDataLoader {
             return response.rows;
         });
     }
-    loadRowCount(props) {
+    getDocDbLoadOptions(props, useSort) {
+        var _a, _b, _c;
+        const { pureName } = props;
+        const res = {
+            pureName,
+            condition: this.buildMongoCondition(props),
+            skip: (_a = props.range) === null || _a === void 0 ? void 0 : _a.offset,
+            limit: (_b = props.range) === null || _b === void 0 ? void 0 : _b.limit,
+        };
+        if (useSort && ((_c = props.orderBy) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+            res.sort = (0, zipObject_1.default)(props.orderBy.map(col => col.columnName), props.orderBy.map(col => (col.order == 'DESC' ? -1 : 1)));
+        }
+        return res;
+    }
+    loadDataDocDb(props) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, sqlCondition: condition, engineType, } = props;
+            if (dbg === null || dbg === void 0 ? void 0 : dbg.enabled) {
+                dbg(`LOAD DATA, collection=${props.pureName}, columns=${(_a = props.dataColumns) === null || _a === void 0 ? void 0 : _a.join(',')}, range=${(_b = props.range) === null || _b === void 0 ? void 0 : _b.offset},${(_c = props.range) === null || _c === void 0 ? void 0 : _c.limit}`);
+            }
+            const options = this.getDocDbLoadOptions(props, true);
+            const response = yield this.apiCall('database-connections/collection-data', {
+                conid: props.databaseConfig.conid,
+                database: props.databaseConfig.database,
+                options,
+            });
+            if (response.errorMessage)
+                return response;
+            return response.rows;
+        });
+    }
+    loadData(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, condition } = props;
+            const { engineType } = props;
+            switch (engineType) {
+                case 'sqldb':
+                    return normalizeResult(yield this.loadDataSqlDb(props));
+                case 'docdb':
+                    return normalizeResult(yield this.loadDataDocDb(props));
+            }
+        });
+    }
+    loadRowCountSqlDb(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, sqlCondition: condition, } = props;
             const select = {
                 commandType: 'select',
                 from: {
@@ -150,7 +262,7 @@ class PerspectiveDataLoader {
                         alias: 'count',
                     },
                 ],
-                where: this.buildCondition(props),
+                where: this.buildSqlCondition(props),
             };
             const response = yield this.apiCall('database-connections/sql-select', {
                 conid: props.databaseConfig.conid,
@@ -162,5 +274,28 @@ class PerspectiveDataLoader {
             return response.rows[0];
         });
     }
+    loadRowCountDocDb(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, sqlCondition: condition, } = props;
+            const options = Object.assign(Object.assign({}, this.getDocDbLoadOptions(props, false)), { countDocuments: true });
+            const response = yield this.apiCall('database-connections/collection-data', {
+                conid: props.databaseConfig.conid,
+                database: props.databaseConfig.database,
+                options,
+            });
+            return response;
+        });
+    }
+    loadRowCount(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { engineType } = props;
+            switch (engineType) {
+                case 'sqldb':
+                    return this.loadRowCountSqlDb(props);
+                case 'docdb':
+                    return this.loadRowCountDocDb(props);
+            }
+        });
+    }
 }
 exports.PerspectiveDataLoader = PerspectiveDataLoader;

package/lib/PerspectiveDataPattern.d.ts

@@ -0,0 +1,17 @@
+export declare type PerspectiveDataPatternColumnType = 'null' | 'oid' | 'string' | 'number' | 'boolean' | 'json';
+export interface PerspectiveDataPatternColumn {
+    name: string;
+    types: PerspectiveDataPatternColumnType[];
+    columns: PerspectiveDataPatternColumn[];
+}
+export interface PerspectiveDataPattern {
+    conid: string;
+    database: string;
+    schemaName?: string;
+    pureName: string;
+    columns: PerspectiveDataPatternColumn[];
+}
+export declare type PerspectiveDataPatternDict = {
+    [designerId: string]: PerspectiveDataPattern;
+};
+export declare function analyseDataPattern(patternBase: Omit<PerspectiveDataPattern, 'columns'>, rows: any[]): PerspectiveDataPattern;

package/lib/PerspectiveDataPattern.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyseDataPattern = void 0;
+const isString_1 = __importDefault(require("lodash/isString"));
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const isNumber_1 = __importDefault(require("lodash/isNumber"));
+const isBoolean_1 = __importDefault(require("lodash/isBoolean"));
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const dbgate_tools_1 = require("dbgate-tools");
+function detectValueType(value) {
+    if ((0, isString_1.default)(value))
+        return 'string';
+    if ((0, isNumber_1.default)(value))
+        return 'number';
+    if ((0, isBoolean_1.default)(value))
+        return 'boolean';
+    if (value === null || value === void 0 ? void 0 : value.$oid)
+        return 'oid';
+    if ((0, isPlainObject_1.default)(value) || (0, isArray_1.default)(value))
+        return 'json';
+    if (value == null)
+        return 'null';
+}
+function addObjectToColumns(columns, row) {
+    if ((0, isPlainObject_1.default)(row)) {
+        for (const key of Object.keys(row)) {
+            let column = columns.find(x => x.name == key);
+            if (!column) {
+                column = {
+                    name: key,
+                    types: [],
+                    columns: [],
+                };
+                columns.push(column);
+            }
+            const value = row[key];
+            const type = detectValueType(value);
+            if (!column.types.includes(type)) {
+                column.types.push(type);
+            }
+            if ((0, isPlainObject_1.default)(value)) {
+                addObjectToColumns(column.columns, value);
+            }
+            if ((0, isArray_1.default)(value)) {
+                for (const item of value) {
+                    addObjectToColumns(column.columns, item);
+                }
+            }
+            if ((0, isString_1.default)(value)) {
+                const json = (0, dbgate_tools_1.safeJsonParse)(value);
+                if (json && ((0, isPlainObject_1.default)(json) || (0, isArray_1.default)(json))) {
+                    if (!column.types.includes('json')) {
+                        column.types.push('json');
+                    }
+                    if ((0, isPlainObject_1.default)(json)) {
+                        addObjectToColumns(column.columns, json);
+                    }
+                    if ((0, isArray_1.default)(json)) {
+                        for (const item of json) {
+                            addObjectToColumns(column.columns, item);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function analyseDataPattern(patternBase, rows) {
+    const res = Object.assign(Object.assign({}, patternBase), { columns: [] });
+    // console.log('ROWS', rows);
+    for (const row of rows) {
+        addObjectToColumns(res.columns, row);
+    }
+    return res;
+}
+exports.analyseDataPattern = analyseDataPattern;

package/lib/PerspectiveDataProvider.d.ts

@@ -2,16 +2,15 @@ import { Condition } from 'dbgate-sqltree';
 import { RangeDefinition } from 'dbgate-types';
 import { PerspectiveCache } from './PerspectiveCache';
 import { PerspectiveDataLoader } from './PerspectiveDataLoader';
+import { PerspectiveDataPatternDict } from './PerspectiveDataPattern';
+import { PerspectiveDatabaseConfig, PerspectiveDatabaseEngineType } from './PerspectiveConfig';
 export declare const PERSPECTIVE_PAGE_SIZE = 100;
-export interface PerspectiveDatabaseConfig {
-    conid: string;
-    database: string;
-}
 export interface PerspectiveDataLoadProps {
     databaseConfig: PerspectiveDatabaseConfig;
-    schemaName: string;
+    schemaName?: string;
     pureName: string;
-    dataColumns: string[];
+    dataColumns?: string[];
+    allColumns?: boolean;
     orderBy: {
         columnName: string;
         order: 'ASC' | 'DESC';
@@ -20,12 +19,15 @@ export interface PerspectiveDataLoadProps {
     bindingValues?: any[][];
     range?: RangeDefinition;
     topCount?: number;
-    condition?: Condition;
+    sqlCondition?: Condition;
+    mongoCondition?: any;
+    engineType: PerspectiveDatabaseEngineType;
 }
 export declare class PerspectiveDataProvider {
     cache: PerspectiveCache;
     loader: PerspectiveDataLoader;
-    constructor(cache: PerspectiveCache, loader: PerspectiveDataLoader);
+    dataPatterns: PerspectiveDataPatternDict;
+    constructor(cache: PerspectiveCache, loader: PerspectiveDataLoader, dataPatterns: PerspectiveDataPatternDict);
     loadData(props: PerspectiveDataLoadProps): Promise<{
         rows: any[];
         incomplete: boolean;

package/lib/PerspectiveDataProvider.js

@@ -28,9 +28,10 @@ const debug_1 = __importDefault(require("debug"));
 exports.PERSPECTIVE_PAGE_SIZE = 100;
 const dbg = (0, debug_1.default)('dbgate:PerspectiveDataProvider');
 class PerspectiveDataProvider {
-    constructor(cache, loader) {
+    constructor(cache, loader, dataPatterns) {
         this.cache = cache;
         this.loader = loader;
+        this.dataPatterns = dataPatterns;
     }
     loadData(props) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -164,6 +165,7 @@ class PerspectiveDataProvider {
             }
             // load missing rows
             tableCache.dataColumns = props.dataColumns;
+            tableCache.allColumns = props.allColumns;
             const nextRows = yield this.loader.loadData(Object.assign(Object.assign({}, props), { topCount: null, range: {
                     offset: tableCache.loadedCount,
                     limit: props.topCount - tableCache.loadedCount,

package/lib/PerspectiveDisplay.d.ts

@@ -48,6 +48,7 @@ export declare class PerspectiveDisplay {
     fillColumns(children: PerspectiveTreeNode[], parentNodes: PerspectiveTreeNode[]): void;
     processColumn(node: PerspectiveTreeNode, parentNodes: PerspectiveTreeNode[]): void;
     findColumnIndexFromNode(node: PerspectiveTreeNode): number;
+    extractArray(value: any): any[];
     collectRows(sourceRows: any[], nodes: PerspectiveTreeNode[]): CollectedPerspectiveDisplayRow[];
     fillRowSpans(): void;
     mergeRows(collectedRows: CollectedPerspectiveDisplayRow[]): void;

package/lib/PerspectiveDisplay.js

@@ -7,6 +7,8 @@ exports.PerspectiveDisplay = exports.PerspectiveDisplayRow = exports.Perspective
 const max_1 = __importDefault(require("lodash/max"));
 const fill_1 = __importDefault(require("lodash/fill"));
 const findIndex_1 = __importDefault(require("lodash/findIndex"));
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const isArray_1 = __importDefault(require("lodash/isArray"));
 const debug_1 = __importDefault(require("debug"));
 const dbg = (0, debug_1.default)('dbgate:PerspectiveDisplay');
 let lastJoinId = 0;
@@ -99,14 +101,14 @@ class PerspectiveDisplay {
     }
     fillColumns(children, parentNodes) {
         for (const child of children) {
-            if (child.isCheckedColumn || child.isCheckedNode) {
+            if (child.generatesHiearchicGridColumn || child.generatesDataGridColumn) {
                 this.processColumn(child, parentNodes);
             }
         }
     }
     processColumn(node, parentNodes) {
         var _a, _b;
-        if (node.isCheckedColumn) {
+        if (node.generatesDataGridColumn) {
             const column = new PerspectiveDisplayColumn(this);
             column.title = node.columnTitle;
             column.dataField = node.dataField;
@@ -117,7 +119,7 @@ class PerspectiveDisplay {
             column.displayType = (_b = (_a = node.parentNodeConfig) === null || _a === void 0 ? void 0 : _a.columnDisplays) === null || _b === void 0 ? void 0 : _b[node.columnName];
             this.columns.push(column);
         }
-        if (node.isExpandable && node.isCheckedNode) {
+        if (node.generatesHiearchicGridColumn) {
             const countBefore = this.columns.length;
             this.fillColumns(node.childNodes, [...parentNodes, node]);
             if (this.columns.length > countBefore) {
@@ -131,23 +133,41 @@ class PerspectiveDisplay {
     // findColumnIndexFromNode(node: PerspectiveTreeNode) {
     //   return _findIndex(this.columns, x => x.dataNode.designerId == node.designerId);
     // }
+    extractArray(value) {
+        if ((0, isArray_1.default)(value))
+            return value;
+        if ((0, isPlainObject_1.default)(value))
+            return [value];
+        return [];
+    }
     collectRows(sourceRows, nodes) {
         // console.log('********** COLLECT ROWS', sourceRows);
-        const columnNodes = nodes.filter(x => x.isCheckedColumn);
-        const treeNodes = nodes.filter(x => x.isCheckedNode);
-        // console.log('columnNodes', columnNodes);
-        // console.log('treeNodes', treeNodes);
+        const columnNodes = nodes.filter(x => x.generatesDataGridColumn);
+        const treeNodes = nodes.filter(x => x.generatesHiearchicGridColumn);
+        // console.log(
+        //   'columnNodes',
+        //   columnNodes.map(x => x.title)
+        // );
+        // console.log(
+        //   'treeNodes',
+        //   treeNodes.map(x => x.title)
+        // );
+        // console.log(
+        //   'nodes',
+        //   nodes.map(x => x.title)
+        // );
         const columnIndexes = columnNodes.map(node => this.findColumnIndexFromNode(node));
         const res = [];
         for (const sourceRow of sourceRows) {
             // console.log('PROCESS SOURCE', sourceRow);
             // row.startIndex = startIndex;
-            const rowData = columnNodes.map(node => sourceRow[node.codeName]);
+            const rowData = columnNodes.map(node => sourceRow[node.columnName]);
             const subRowCollections = [];
             for (const node of treeNodes) {
+                // console.log('sourceRow[node.fieldName]', node.fieldName, sourceRow[node.fieldName]);
                 if (sourceRow[node.fieldName]) {
                     const subrows = {
-                        rows: this.collectRows(sourceRow[node.fieldName], node.childNodes),
+                        rows: this.collectRows(this.extractArray(sourceRow[node.fieldName]), node.childNodes),
                     };
                     subRowCollections.push(subrows);
                 }