dbgate-datalib 5.0.9 → 5.1.0

package/lib/PerspectiveDisplay.d.ts

@@ -0,0 +1,55 @@
+import { PerspectiveTreeNode } from './PerspectiveTreeNode';
+export declare class PerspectiveDisplayColumn {
+    display: PerspectiveDisplay;
+    title: string;
+    dataField: string;
+    parentNodes: PerspectiveTreeNode[];
+    colSpanAtLevel: {};
+    columnIndex: number;
+    dataNode: PerspectiveTreeNode;
+    constructor(display: PerspectiveDisplay);
+    get rowSpan(): number;
+    showParent(level: number): boolean;
+    getColSpan(level: number): any;
+    isVisible(level: number): boolean;
+    get columnLevel(): number;
+    getParentName(level: any): any;
+    getParentNode(level: any): PerspectiveTreeNode;
+    getParentTableUniqueName(level: any): any;
+}
+interface PerspectiveSubRowCollection {
+    rows: CollectedPerspectiveDisplayRow[];
+}
+interface CollectedPerspectiveDisplayRow {
+    columnIndexes: number[];
+    rowData: any[];
+    subRowCollections: PerspectiveSubRowCollection[];
+    incompleteRowsIndicator?: string[];
+}
+export declare class PerspectiveDisplayRow {
+    display: PerspectiveDisplay;
+    constructor(display: PerspectiveDisplay);
+    rowData: any[];
+    rowSpans: number[];
+    rowCellSkips: boolean[];
+    rowJoinIds: number[];
+}
+export declare class PerspectiveDisplay {
+    root: PerspectiveTreeNode;
+    columns: PerspectiveDisplayColumn[];
+    rows: PerspectiveDisplayRow[];
+    readonly columnLevelCount: number;
+    loadIndicatorsCounts: {
+        [uniqueName: string]: number;
+    };
+    constructor(root: PerspectiveTreeNode, rows: any[]);
+    private getRowAt;
+    fillColumns(children: PerspectiveTreeNode[], parentNodes: PerspectiveTreeNode[]): void;
+    processColumn(node: PerspectiveTreeNode, parentNodes: PerspectiveTreeNode[]): void;
+    findColumnIndexFromNode(node: PerspectiveTreeNode): number;
+    collectRows(sourceRows: any[], nodes: PerspectiveTreeNode[]): CollectedPerspectiveDisplayRow[];
+    fillRowSpans(): void;
+    mergeRows(collectedRows: CollectedPerspectiveDisplayRow[]): void;
+    mergeRow(collectedRow: CollectedPerspectiveDisplayRow, rowIndex: number): number;
+}
+export {};

package/lib/PerspectiveDisplay.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerspectiveDisplay = exports.PerspectiveDisplayRow = exports.PerspectiveDisplayColumn = void 0;
+const max_1 = __importDefault(require("lodash/max"));
+const fill_1 = __importDefault(require("lodash/fill"));
+const findIndex_1 = __importDefault(require("lodash/findIndex"));
+const debug_1 = __importDefault(require("debug"));
+const dbg = (0, debug_1.default)('dbgate:PerspectiveDisplay');
+let lastJoinId = 0;
+function getJoinId() {
+    lastJoinId += 1;
+    return lastJoinId;
+}
+class PerspectiveDisplayColumn {
+    constructor(display) {
+        this.display = display;
+        this.parentNodes = [];
+        this.colSpanAtLevel = {};
+        this.columnIndex = 0;
+        this.dataNode = null;
+    }
+    get rowSpan() {
+        return this.display.columnLevelCount - this.parentNodes.length;
+    }
+    showParent(level) {
+        return !!this.colSpanAtLevel[level];
+    }
+    getColSpan(level) {
+        return this.colSpanAtLevel[level];
+    }
+    isVisible(level) {
+        return level == this.columnLevel;
+    }
+    get columnLevel() {
+        return this.parentNodes.length;
+    }
+    getParentName(level) {
+        var _a;
+        return (_a = this.parentNodes[level]) === null || _a === void 0 ? void 0 : _a.title;
+    }
+    getParentNode(level) {
+        return this.parentNodes[level];
+    }
+    getParentTableUniqueName(level) {
+        var _a, _b;
+        return ((_a = this.parentNodes[level]) === null || _a === void 0 ? void 0 : _a.headerTableAttributes) ? (_b = this.parentNodes[level]) === null || _b === void 0 ? void 0 : _b.uniqueName : '';
+    }
+}
+exports.PerspectiveDisplayColumn = PerspectiveDisplayColumn;
+class PerspectiveDisplayRow {
+    constructor(display) {
+        this.display = display;
+        this.rowData = [];
+        this.rowSpans = null;
+        this.rowCellSkips = null;
+        this.rowJoinIds = [];
+        this.rowData = (0, fill_1.default)(Array(display.columns.length), undefined);
+        this.rowSpans = (0, fill_1.default)(Array(display.columns.length), 1);
+        this.rowJoinIds = (0, fill_1.default)(Array(display.columns.length), 0);
+        this.rowCellSkips = (0, fill_1.default)(Array(display.columns.length), false);
+    }
+}
+exports.PerspectiveDisplayRow = PerspectiveDisplayRow;
+class PerspectiveDisplay {
+    constructor(root, rows) {
+        this.root = root;
+        this.columns = [];
+        this.rows = [];
+        this.loadIndicatorsCounts = {};
+        // dbg('source rows', rows);
+        this.fillColumns(root.childNodes, [root]);
+        if (this.columns.length > 0) {
+            this.columns[0].colSpanAtLevel[0] = this.columns.length;
+        }
+        this.columnLevelCount = (0, max_1.default)(this.columns.map(x => x.parentNodes.length)) + 1;
+        const collectedRows = this.collectRows(rows, root.childNodes);
+        dbg('collected rows', collectedRows);
+        // console.log('COLLECTED', JSON.stringify(collectedRows, null, 2));
+        // this.mergeRows(collectedRows);
+        this.mergeRows(collectedRows);
+        // dbg('merged rows', this.rows);
+        // console.log(
+        //   'MERGED',
+        //   this.rows.map(r =>
+        //     r.incompleteRowsIndicator
+        //       ? `************************************ ${r.incompleteRowsIndicator.join('|')}`
+        //       : r.rowData.join('|')
+        //   )
+        // );
+    }
+    getRowAt(rowIndex) {
+        while (this.rows.length <= rowIndex) {
+            this.rows.push(new PerspectiveDisplayRow(this));
+        }
+        return this.rows[rowIndex];
+    }
+    fillColumns(children, parentNodes) {
+        for (const child of children) {
+            if (child.isChecked) {
+                this.processColumn(child, parentNodes);
+            }
+        }
+    }
+    processColumn(node, parentNodes) {
+        if (node.isExpandable) {
+            const countBefore = this.columns.length;
+            this.fillColumns(node.childNodes, [...parentNodes, node]);
+            if (this.columns.length > countBefore) {
+                this.columns[countBefore].colSpanAtLevel[parentNodes.length] = this.columns.length - countBefore;
+            }
+        }
+        else {
+            const column = new PerspectiveDisplayColumn(this);
+            column.title = node.columnTitle;
+            column.dataField = node.dataField;
+            column.parentNodes = parentNodes;
+            column.display = this;
+            column.columnIndex = this.columns.length;
+            column.dataNode = node;
+            this.columns.push(column);
+        }
+    }
+    findColumnIndexFromNode(node) {
+        return (0, findIndex_1.default)(this.columns, x => x.dataNode.uniqueName == node.uniqueName);
+    }
+    collectRows(sourceRows, nodes) {
+        const columnNodes = nodes.filter(x => x.isChecked && !x.isExpandable);
+        const treeNodes = nodes.filter(x => x.isChecked && x.isExpandable);
+        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 subRowCollections = [];
+            for (const node of treeNodes) {
+                if (sourceRow[node.fieldName]) {
+                    const subrows = {
+                        rows: this.collectRows(sourceRow[node.fieldName], node.childNodes),
+                    };
+                    subRowCollections.push(subrows);
+                }
+            }
+            res.push({
+                rowData,
+                columnIndexes,
+                subRowCollections,
+                incompleteRowsIndicator: sourceRow.incompleteRowsIndicator,
+            });
+        }
+        return res;
+    }
+    fillRowSpans() {
+        for (let col = 0; col < this.columns.length; col++) {
+            // let lastFilledJoinId = null;
+            let lastFilledRow = 0;
+            let rowIndex = 0;
+            for (const row of this.rows) {
+                if (row.rowData[col] === undefined &&
+                    row.rowJoinIds[col] == this.rows[lastFilledRow].rowJoinIds[col] &&
+                    row.rowJoinIds[col]) {
+                    row.rowCellSkips[col] = true;
+                    this.rows[lastFilledRow].rowSpans[col] = rowIndex - lastFilledRow + 1;
+                }
+                else {
+                    lastFilledRow = rowIndex;
+                }
+                rowIndex++;
+            }
+        }
+    }
+    mergeRows(collectedRows) {
+        let rowIndex = 0;
+        for (const collectedRow of collectedRows) {
+            const count = this.mergeRow(collectedRow, rowIndex);
+            rowIndex += count;
+        }
+        this.fillRowSpans();
+    }
+    mergeRow(collectedRow, rowIndex) {
+        var _a;
+        if (((_a = collectedRow.incompleteRowsIndicator) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const indicator of collectedRow.incompleteRowsIndicator) {
+                if (!this.loadIndicatorsCounts[indicator]) {
+                    this.loadIndicatorsCounts[indicator] = rowIndex;
+                }
+                if (rowIndex < this.loadIndicatorsCounts[indicator]) {
+                    this.loadIndicatorsCounts[indicator] = rowIndex;
+                }
+            }
+            return 0;
+        }
+        const mainRow = this.getRowAt(rowIndex);
+        for (let i = 0; i < collectedRow.columnIndexes.length; i++) {
+            mainRow.rowData[collectedRow.columnIndexes[i]] = collectedRow.rowData[i];
+        }
+        let rowCount = 1;
+        for (const subrows of collectedRow.subRowCollections) {
+            let additionalRowCount = 0;
+            let currentRowIndex = rowIndex;
+            for (const subrow of subrows.rows) {
+                const count = this.mergeRow(subrow, currentRowIndex);
+                additionalRowCount += count;
+                currentRowIndex += count;
+            }
+            if (additionalRowCount > rowCount) {
+                rowCount = additionalRowCount;
+            }
+        }
+        const joinId = getJoinId();
+        for (let radd = 0; radd < rowCount; radd++) {
+            const row = this.getRowAt(rowIndex + radd);
+            for (let i = 0; i < collectedRow.columnIndexes.length; i++) {
+                row.rowJoinIds[collectedRow.columnIndexes[i]] = joinId;
+            }
+        }
+        return rowCount;
+    }
+}
+exports.PerspectiveDisplay = PerspectiveDisplay;

package/lib/PerspectiveTreeNode.d.ts

@@ -0,0 +1,146 @@
+import { ColumnInfo, DatabaseInfo, ForeignKeyInfo, NamedObjectInfo, TableInfo, ViewInfo } from 'dbgate-types';
+import { ChangePerspectiveConfigFunc, MultipleDatabaseInfo, PerspectiveConfig, PerspectiveConfigColumns, PerspectiveCustomJoinConfig, PerspectiveFilterColumnInfo } from './PerspectiveConfig';
+import { PerspectiveDatabaseConfig, PerspectiveDataLoadProps, PerspectiveDataProvider } from './PerspectiveDataProvider';
+import { FilterType } from 'dbgate-filterparser/lib/types';
+import { Condition } from 'dbgate-sqltree';
+export interface PerspectiveDataLoadPropsWithNode {
+    props: PerspectiveDataLoadProps;
+    node: PerspectiveTreeNode;
+}
+export declare abstract class PerspectiveTreeNode {
+    dbs: MultipleDatabaseInfo;
+    config: PerspectiveConfig;
+    setConfig: ChangePerspectiveConfigFunc;
+    parentNode: PerspectiveTreeNode;
+    dataProvider: PerspectiveDataProvider;
+    databaseConfig: PerspectiveDatabaseConfig;
+    constructor(dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, parentNode: PerspectiveTreeNode, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig);
+    defaultChecked: boolean;
+    abstract get title(): any;
+    abstract get codeName(): any;
+    abstract get isExpandable(): any;
+    abstract get childNodes(): PerspectiveTreeNode[];
+    abstract get icon(): string;
+    get fieldName(): any;
+    get headerTableAttributes(): any;
+    get dataField(): any;
+    get tableCode(): any;
+    get namedObject(): NamedObjectInfo;
+    abstract getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get isRoot(): boolean;
+    get rootNode(): PerspectiveTreeNode;
+    matchChildRow(parentRow: any, childRow: any): boolean;
+    hasTableCode(code: string): any;
+    get uniqueName(): any;
+    get level(): any;
+    get isExpanded(): boolean;
+    get isChecked(): boolean;
+    get columnTitle(): any;
+    get filterType(): FilterType;
+    get columnName(): any;
+    get customJoinConfig(): PerspectiveCustomJoinConfig;
+    get db(): DatabaseInfo;
+    getChildMatchColumns(): any[];
+    getParentMatchColumns(): any[];
+    parseFilterCondition(source?: any): any;
+    get childDataColumn(): any;
+    toggleExpanded(value?: boolean): void;
+    toggleChecked(value?: boolean): void;
+    includeInColumnSet(field: keyof PerspectiveConfigColumns, uniqueName: string, isIncluded: boolean): void;
+    getFilter(): string;
+    getDataLoadColumns(): any[];
+    getChildrenCondition(source?: any): Condition;
+    getOrderBy(table: TableInfo | ViewInfo): PerspectiveDataLoadProps['orderBy'];
+    getBaseTables(): any[];
+    getBaseTableFromThis(): any;
+    get filterInfo(): PerspectiveFilterColumnInfo;
+    findChildNodeByUniquePath(uniquePath: string[]): any;
+    findNodeByUniqueName(uniqueName: string): PerspectiveTreeNode;
+    get supportsParentFilter(): boolean;
+    get isParentFilter(): boolean;
+    buildParentFilterConditions(): Condition[];
+    getParentJoinCondition(alias: string, parentAlias: string): Condition[];
+}
+export declare class PerspectiveTableColumnNode extends PerspectiveTreeNode {
+    column: ColumnInfo;
+    table: TableInfo | ViewInfo;
+    foreignKey: ForeignKeyInfo;
+    refTable: TableInfo;
+    isView: boolean;
+    isTable: boolean;
+    constructor(column: ColumnInfo, table: TableInfo | ViewInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, parentNode: PerspectiveTreeNode);
+    matchChildRow(parentRow: any, childRow: any): boolean;
+    getChildMatchColumns(): string[];
+    getParentMatchColumns(): string[];
+    getParentJoinCondition(alias: string, parentAlias: string): Condition[];
+    getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get icon(): "img circular" | "img autoincrement" | "img foreign-key" | "img column";
+    get codeName(): string;
+    get columnName(): string;
+    get fieldName(): string;
+    get title(): string;
+    get isExpandable(): boolean;
+    get filterType(): FilterType;
+    get isCircular(): boolean;
+    get childNodes(): PerspectiveTreeNode[];
+    getBaseTableFromThis(): TableInfo;
+    get filterInfo(): PerspectiveFilterColumnInfo;
+    parseFilterCondition(source?: any): Condition;
+    get headerTableAttributes(): {
+        schemaName: string;
+        pureName: string;
+        conid: string;
+        database: string;
+    };
+    get tableCode(): string;
+    get namedObject(): NamedObjectInfo;
+}
+export declare class PerspectiveTableNode extends PerspectiveTreeNode {
+    table: TableInfo | ViewInfo;
+    dataProvider: PerspectiveDataProvider;
+    constructor(table: TableInfo | ViewInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, parentNode: PerspectiveTreeNode);
+    getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get codeName(): string;
+    get title(): string;
+    get isExpandable(): boolean;
+    get childNodes(): PerspectiveTreeNode[];
+    get icon(): string;
+    getBaseTableFromThis(): TableInfo | ViewInfo;
+    get headerTableAttributes(): {
+        schemaName: string;
+        pureName: string;
+        conid: string;
+        database: string;
+    };
+    get tableCode(): string;
+    get namedObject(): NamedObjectInfo;
+}
+export declare class PerspectiveTableReferenceNode extends PerspectiveTableNode {
+    foreignKey: ForeignKeyInfo;
+    dataProvider: PerspectiveDataProvider;
+    isMultiple: boolean;
+    constructor(foreignKey: ForeignKeyInfo, table: TableInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, isMultiple: boolean, parentNode: PerspectiveTreeNode);
+    matchChildRow(parentRow: any, childRow: any): boolean;
+    getChildMatchColumns(): string[];
+    getParentMatchColumns(): string[];
+    getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get columnTitle(): string;
+    get title(): string;
+    get codeName(): string;
+    getParentJoinCondition(alias: string, parentAlias: string): Condition[];
+}
+export declare class PerspectiveCustomJoinTreeNode extends PerspectiveTableNode {
+    customJoin: PerspectiveCustomJoinConfig;
+    dataProvider: PerspectiveDataProvider;
+    constructor(customJoin: PerspectiveCustomJoinConfig, table: TableInfo | ViewInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, parentNode: PerspectiveTreeNode);
+    matchChildRow(parentRow: any, childRow: any): boolean;
+    getChildMatchColumns(): string[];
+    getParentMatchColumns(): string[];
+    getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get title(): string;
+    get icon(): string;
+    get codeName(): string;
+    get customJoinConfig(): PerspectiveCustomJoinConfig;
+    getParentJoinCondition(alias: string, parentAlias: string): Condition[];
+}
+export declare function getTableChildPerspectiveNodes(table: TableInfo | ViewInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, parentColumn: PerspectiveTreeNode): any[];