dbgate-datalib 5.0.8 → 5.1.1

package/lib/FreeTableGridDisplay.d.ts

@@ -14,8 +14,8 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         uniquePath: string[];
         pairingId?: string;
         columnName: string;
-        notNull: boolean;
-        autoIncrement: boolean;
+        notNull?: boolean;
+        autoIncrement?: boolean;
         dataType: string;
         precision?: number;
         scale?: number;
@@ -28,6 +28,8 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         columnComment?: string;
         isUnsigned?: boolean;
         isZerofill?: boolean;
+        contentHash?: string;
+        engine?: string;
     }[];
     getDisplayColumn(col: ColumnInfo): {
         pureName: string;
@@ -37,8 +39,8 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         uniquePath: string[];
         pairingId?: string;
         columnName: string;
-        notNull: boolean;
-        autoIncrement: boolean;
+        notNull?: boolean;
+        autoIncrement?: boolean;
         dataType: string;
         precision?: number;
         scale?: number;
@@ -51,5 +53,7 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         columnComment?: string;
         isUnsigned?: boolean;
         isZerofill?: boolean;
+        contentHash?: string;
+        engine?: string;
     };
 }

package/lib/GridDisplay.d.ts

@@ -9,7 +9,7 @@ export interface DisplayColumn {
     headerText: string;
     uniqueName: string;
     uniquePath: string[];
-    notNull: boolean;
+    notNull?: boolean;
     autoIncrement?: boolean;
     isPrimaryKey?: boolean;
     foreignKey?: ForeignKeyInfo;

package/lib/PerspectiveCache.d.ts

@@ -0,0 +1,39 @@
+import { PerspectiveDataLoadProps } from './PerspectiveDataProvider';
+export declare class PerspectiveBindingGroup {
+    table: PerspectiveCacheTable;
+    constructor(table: PerspectiveCacheTable);
+    groupSize?: number;
+    loadedAll: boolean;
+    loadedRows: any[];
+    bindingValues: any[];
+    matchRow(row: any): boolean;
+}
+export declare class PerspectiveCacheTable {
+    cache: PerspectiveCache;
+    constructor(props: PerspectiveDataLoadProps, cache: PerspectiveCache);
+    schemaName: string;
+    pureName: string;
+    bindingColumns?: string[];
+    dataColumns: string[];
+    loadedAll: boolean;
+    loadedRows: any[];
+    bindingGroups: {
+        [bindingKey: string]: PerspectiveBindingGroup;
+    };
+    get loadedCount(): number;
+    getRowsResult(props: PerspectiveDataLoadProps): {
+        rows: any[];
+        incomplete: boolean;
+    };
+    getBindingGroup(groupValues: any[]): PerspectiveBindingGroup;
+    getUncachedBindingGroups(props: PerspectiveDataLoadProps): any[][];
+    storeGroupSize(props: PerspectiveDataLoadProps, bindingValues: any[], count: number): void;
+}
+export declare class PerspectiveCache {
+    constructor();
+    tables: {
+        [tableKey: string]: PerspectiveCacheTable;
+    };
+    getTableCache(props: PerspectiveDataLoadProps): PerspectiveCacheTable;
+    clear(): void;
+}

package/lib/PerspectiveCache.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerspectiveCache = exports.PerspectiveCacheTable = exports.PerspectiveBindingGroup = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const zip_1 = __importDefault(require("lodash/zip"));
+const difference_1 = __importDefault(require("lodash/difference"));
+const debug_1 = __importDefault(require("debug"));
+const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
+const dbg = (0, debug_1.default)('dbgate:PerspectiveCache');
+class PerspectiveBindingGroup {
+    constructor(table) {
+        this.table = table;
+        this.loadedRows = [];
+    }
+    matchRow(row) {
+        return this.table.bindingColumns.every((column, index) => row[column] == this.bindingValues[index]);
+    }
+}
+exports.PerspectiveBindingGroup = PerspectiveBindingGroup;
+class PerspectiveCacheTable {
+    constructor(props, cache) {
+        this.cache = cache;
+        this.loadedRows = [];
+        this.bindingGroups = {};
+        this.schemaName = props.schemaName;
+        this.pureName = props.pureName;
+        this.bindingColumns = props.bindingColumns;
+        this.dataColumns = props.dataColumns;
+        this.loadedAll = false;
+    }
+    get loadedCount() {
+        return this.loadedRows.length;
+    }
+    getRowsResult(props) {
+        return {
+            rows: this.loadedRows.slice(0, props.topCount),
+            incomplete: props.topCount < this.loadedCount || !this.loadedAll,
+        };
+    }
+    getBindingGroup(groupValues) {
+        const key = (0, json_stable_stringify_1.default)(groupValues);
+        return this.bindingGroups[key];
+    }
+    getUncachedBindingGroups(props) {
+        const uncached = [];
+        for (const group of props.bindingValues) {
+            const key = (0, json_stable_stringify_1.default)(group);
+            const item = this.bindingGroups[key];
+            if (!item) {
+                uncached.push(group);
+            }
+        }
+        return uncached;
+    }
+    storeGroupSize(props, bindingValues, count) {
+        const originalBindingValue = props.bindingValues.find(v => (0, zip_1.default)(v, bindingValues).every(([x, y]) => x == y));
+        if (originalBindingValue) {
+            const key = (0, json_stable_stringify_1.default)(originalBindingValue);
+            // console.log('SET SIZE', originalBindingValue, bindingValues, key, count);
+            const group = new PerspectiveBindingGroup(this);
+            group.bindingValues = bindingValues;
+            group.groupSize = count;
+            this.bindingGroups[key] = group;
+        }
+        else {
+            dbg('Group not found', bindingValues);
+        }
+    }
+}
+exports.PerspectiveCacheTable = PerspectiveCacheTable;
+class PerspectiveCache {
+    constructor() {
+        this.tables = {};
+    }
+    getTableCache(props) {
+        const tableKey = (0, json_stable_stringify_1.default)((0, pick_1.default)(props, ['schemaName', 'pureName', 'bindingColumns', 'databaseConfig', 'orderBy', 'condition']));
+        let res = this.tables[tableKey];
+        if (res && (0, difference_1.default)(props.dataColumns, res.dataColumns).length > 0) {
+            dbg('Delete cache because incomplete columns', props.pureName, res.dataColumns);
+            // we have incomplete cache
+            delete this.tables[tableKey];
+            res = null;
+        }
+        if (!res) {
+            res = new PerspectiveCacheTable(props, this);
+            this.tables[tableKey] = res;
+            return res;
+        }
+        // cache could be used
+        return res;
+    }
+    clear() {
+        this.tables = {};
+    }
+}
+exports.PerspectiveCache = PerspectiveCache;

package/lib/PerspectiveConfig.d.ts

@@ -0,0 +1,85 @@
+import { DatabaseInfo, ForeignKeyInfo } from 'dbgate-types';
+export interface PerspectiveCustomJoinConfig {
+    refNodeDesignerId: string;
+    referenceDesignerId: string;
+    joinName: string;
+    baseDesignerId: string;
+    conid?: string;
+    database?: string;
+    refSchemaName?: string;
+    refTableName: string;
+    columns: {
+        baseColumnName: string;
+        refColumnName: string;
+    }[];
+}
+export interface PerspectiveFilterColumnInfo {
+    columnName: string;
+    filterType: string;
+    pureName: string;
+    schemaName: string;
+    foreignKey: ForeignKeyInfo;
+}
+export interface PerspectiveNodeConfig {
+    designerId: string;
+    schemaName?: string;
+    pureName: string;
+    defaultColumnsProcessed?: boolean;
+    alias?: string;
+    conid?: string;
+    database?: string;
+    isParentFilter?: boolean;
+    expandedColumns: string[];
+    checkedColumns: string[];
+    sort: {
+        columnName: string;
+        order: 'ASC' | 'DESC';
+    }[];
+    filters: {
+        [uniqueName: string]: string;
+    };
+    isAutoGenerated?: true | undefined;
+    isNodeChecked?: boolean;
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+export interface PerspectiveReferenceConfig {
+    designerId: string;
+    sourceId: string;
+    targetId: string;
+    columns: {
+        source: string;
+        target: string;
+    }[];
+    isAutoGenerated?: true | undefined;
+}
+export interface PerspectiveConfig {
+    rootDesignerId: string;
+    isArranged: boolean;
+    nodes: PerspectiveNodeConfig[];
+    references: PerspectiveReferenceConfig[];
+}
+export declare function createPerspectiveNodeConfig(name: {
+    schemaName?: string;
+    pureName: string;
+}): PerspectiveNodeConfig;
+export declare function createPerspectiveConfig(rootObject?: {
+    schemaName?: string;
+    pureName: string;
+}): PerspectiveConfig;
+export declare type ChangePerspectiveConfigFunc = (changeFunc: (config: PerspectiveConfig) => PerspectiveConfig, reload?: boolean) => void;
+export declare function extractPerspectiveDatabases({ conid, database }: {
+    conid: any;
+    database: any;
+}, cfg: PerspectiveConfig): {
+    conid: string;
+    database: string;
+}[];
+export interface MultipleDatabaseInfo {
+    [conid: string]: {
+        [database: string]: DatabaseInfo;
+    };
+}
+export declare function switchPerspectiveReferenceDirection(ref: PerspectiveReferenceConfig): PerspectiveReferenceConfig;

package/lib/PerspectiveConfig.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.switchPerspectiveReferenceDirection = exports.extractPerspectiveDatabases = exports.createPerspectiveConfig = exports.createPerspectiveNodeConfig = void 0;
+const v1_1 = __importDefault(require("uuid/v1"));
+function createPerspectiveNodeConfig(name) {
+    const node = Object.assign(Object.assign({}, name), { designerId: (0, v1_1.default)(), expandedColumns: [], checkedColumns: [], sort: [], filters: {}, isNodeChecked: true });
+    return node;
+}
+exports.createPerspectiveNodeConfig = createPerspectiveNodeConfig;
+function createPerspectiveConfig(rootObject) {
+    if (!rootObject) {
+        return {
+            nodes: [],
+            references: [],
+            isArranged: true,
+            rootDesignerId: null,
+        };
+    }
+    const rootNode = createPerspectiveNodeConfig(rootObject);
+    return {
+        nodes: [rootNode],
+        references: [],
+        rootDesignerId: rootNode.designerId,
+        isArranged: true,
+    };
+}
+exports.createPerspectiveConfig = createPerspectiveConfig;
+function extractPerspectiveDatabases({ conid, database }, cfg) {
+    const res = [];
+    res.push({ conid, database });
+    function add(conid, database) {
+        if (res.find(x => x.conid == conid && x.database == database))
+            return;
+        res.push({ conid, database });
+    }
+    for (const node of cfg.nodes) {
+        add(node.conid || conid, node.database || database);
+    }
+    return res;
+}
+exports.extractPerspectiveDatabases = extractPerspectiveDatabases;
+function switchPerspectiveReferenceDirection(ref) {
+    return {
+        designerId: ref.designerId,
+        sourceId: ref.targetId,
+        targetId: ref.sourceId,
+        isAutoGenerated: ref.isAutoGenerated,
+        columns: ref.columns.map(x => ({ source: x.target, target: x.source })),
+    };
+}
+exports.switchPerspectiveReferenceDirection = switchPerspectiveReferenceDirection;

package/lib/PerspectiveDataLoader.d.ts

@@ -0,0 +1,9 @@
+import { Condition } from 'dbgate-sqltree';
+import { PerspectiveDataLoadProps } from './PerspectiveDataProvider';
+export declare class PerspectiveDataLoader {
+    apiCall: any;
+    constructor(apiCall: any);
+    buildCondition(props: PerspectiveDataLoadProps): Condition;
+    loadGrouping(props: PerspectiveDataLoadProps): Promise<any>;
+    loadData(props: PerspectiveDataLoadProps): Promise<any>;
+}

package/lib/PerspectiveDataLoader.js

@@ -0,0 +1,139 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerspectiveDataLoader = void 0;
+const debug_1 = __importDefault(require("debug"));
+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;
+        const conditions = [];
+        if (condition) {
+            conditions.push(condition);
+        }
+        if ((bindingColumns === null || bindingColumns === void 0 ? void 0 : bindingColumns.length) == 1) {
+            conditions.push({
+                conditionType: 'in',
+                expr: {
+                    exprType: 'column',
+                    columnName: bindingColumns[0],
+                    source: {
+                        name: { schemaName, pureName },
+                    },
+                },
+                values: bindingValues.map(x => x[0]),
+            });
+        }
+        return conditions.length > 0
+            ? {
+                conditionType: 'and',
+                conditions,
+            }
+            : null;
+    }
+    loadGrouping(props) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns } = props;
+            const bindingColumnExpressions = bindingColumns.map(columnName => ({
+                exprType: 'column',
+                columnName,
+                source: {
+                    name: { schemaName, pureName },
+                },
+            }));
+            const select = {
+                commandType: 'select',
+                from: {
+                    name: { schemaName, pureName },
+                },
+                columns: [
+                    {
+                        exprType: 'call',
+                        func: 'COUNT',
+                        args: [
+                            {
+                                exprType: 'raw',
+                                sql: '*',
+                            },
+                        ],
+                        alias: '_perspective_group_size_',
+                    },
+                    ...bindingColumnExpressions,
+                ],
+                where: this.buildCondition(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(',')}`);
+            }
+            const response = yield this.apiCall('database-connections/sql-select', {
+                conid: props.databaseConfig.conid,
+                database: props.databaseConfig.database,
+                select,
+            });
+            if (response.errorMessage)
+                return response;
+            return response.rows.map(row => (Object.assign(Object.assign({}, row), { _perspective_group_size_: parseInt(row._perspective_group_size_) })));
+        });
+    }
+    loadData(props) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, condition } = props;
+            if ((dataColumns === null || dataColumns === void 0 ? void 0 : dataColumns.length) == 0) {
+                return [];
+            }
+            const select = {
+                commandType: 'select',
+                from: {
+                    name: { schemaName, pureName },
+                },
+                columns: dataColumns === null || dataColumns === void 0 ? void 0 : dataColumns.map(columnName => ({
+                    exprType: 'column',
+                    columnName,
+                    source: {
+                        name: { schemaName, pureName },
+                    },
+                })),
+                selectAll: !dataColumns,
+                orderBy: orderBy === null || orderBy === void 0 ? void 0 : orderBy.map(({ columnName, order }) => ({
+                    exprType: 'column',
+                    columnName,
+                    direction: order,
+                    source: {
+                        name: { schemaName, pureName },
+                    },
+                })),
+                range: props.range,
+                where: this.buildCondition(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}`);
+            }
+            const response = yield this.apiCall('database-connections/sql-select', {
+                conid: props.databaseConfig.conid,
+                database: props.databaseConfig.database,
+                select,
+            });
+            if (response.errorMessage)
+                return response;
+            return response.rows;
+        });
+    }
+}
+exports.PerspectiveDataLoader = PerspectiveDataLoader;

package/lib/PerspectiveDataProvider.d.ts

@@ -0,0 +1,42 @@
+import { Condition } from 'dbgate-sqltree';
+import { RangeDefinition } from 'dbgate-types';
+import { PerspectiveCache } from './PerspectiveCache';
+import { PerspectiveDataLoader } from './PerspectiveDataLoader';
+export declare const PERSPECTIVE_PAGE_SIZE = 100;
+export interface PerspectiveDatabaseConfig {
+    conid: string;
+    database: string;
+}
+export interface PerspectiveDataLoadProps {
+    databaseConfig: PerspectiveDatabaseConfig;
+    schemaName: string;
+    pureName: string;
+    dataColumns: string[];
+    orderBy: {
+        columnName: string;
+        order: 'ASC' | 'DESC';
+    }[];
+    bindingColumns?: string[];
+    bindingValues?: any[][];
+    range?: RangeDefinition;
+    topCount?: number;
+    condition?: Condition;
+}
+export declare class PerspectiveDataProvider {
+    cache: PerspectiveCache;
+    loader: PerspectiveDataLoader;
+    constructor(cache: PerspectiveCache, loader: PerspectiveDataLoader);
+    loadData(props: PerspectiveDataLoadProps): Promise<{
+        rows: any[];
+        incomplete: boolean;
+    }>;
+    loadDataNested(props: PerspectiveDataLoadProps): Promise<{
+        rows: any[];
+        incomplete: boolean;
+    }>;
+    loadNextGroup(props: PerspectiveDataLoadProps, groupIndex: number): Promise<void>;
+    loadDataFlat(props: PerspectiveDataLoadProps): Promise<{
+        rows: any[];
+        incomplete: boolean;
+    }>;
+}