dbgate-datalib 5.0.7 → 5.1.0

package/lib/PerspectiveTreeNode.js

@@ -0,0 +1,727 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableChildPerspectiveNodes = exports.PerspectiveCustomJoinTreeNode = exports.PerspectiveTableReferenceNode = exports.PerspectiveTableNode = exports.PerspectiveTableColumnNode = exports.PerspectiveTreeNode = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
+const uniq_1 = __importDefault(require("lodash/uniq"));
+const flatten_1 = __importDefault(require("lodash/flatten"));
+const uniqBy_1 = __importDefault(require("lodash/uniqBy"));
+const sortBy_1 = __importDefault(require("lodash/sortBy"));
+const cloneDeepWith_1 = __importDefault(require("lodash/cloneDeepWith"));
+const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
+const dbgate_filterparser_1 = require("dbgate-filterparser");
+const getPerspectiveDefaultColumns_1 = require("./getPerspectiveDefaultColumns");
+// export function groupPerspectiveLoadProps(
+//   ...list: PerspectiveDataLoadPropsWithNode[]
+// ): PerspectiveDataLoadPropsWithNode[] {
+//   const res: PerspectiveDataLoadPropsWithNode[] = [];
+//   for (const item of list) {
+//     const existing = res.find(
+//       x =>
+//         x.node == item.node &&
+//         x.props.schemaName == item.props.schemaName &&
+//         x.props.pureName == item.props.pureName &&
+//         _isEqual(x.props.bindingColumns, item.props.bindingColumns)
+//     );
+//     if (existing) {
+//       existing.props.bindingValues.push(...item.props.bindingValues);
+//     } else {
+//       res.push(_cloneDeep(item));
+//     }
+//   }
+//   return res;
+// }
+class PerspectiveTreeNode {
+    constructor(dbs, config, setConfig, parentNode, dataProvider, databaseConfig) {
+        this.dbs = dbs;
+        this.config = config;
+        this.setConfig = setConfig;
+        this.parentNode = parentNode;
+        this.dataProvider = dataProvider;
+        this.databaseConfig = databaseConfig;
+    }
+    get fieldName() {
+        return this.codeName;
+    }
+    get headerTableAttributes() {
+        return null;
+    }
+    get dataField() {
+        return this.codeName;
+    }
+    get tableCode() {
+        return null;
+    }
+    get namedObject() {
+        return null;
+    }
+    get isRoot() {
+        return this.parentNode == null;
+    }
+    get rootNode() {
+        var _a;
+        if (this.isRoot)
+            return this;
+        return (_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.rootNode;
+    }
+    matchChildRow(parentRow, childRow) {
+        return true;
+    }
+    hasTableCode(code) {
+        var _a;
+        return code == this.tableCode || ((_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.hasTableCode(code));
+    }
+    get uniqueName() {
+        if (this.parentNode)
+            return `${this.parentNode.uniqueName}::${this.codeName}`;
+        return this.codeName;
+    }
+    get level() {
+        if (this.parentNode)
+            return this.parentNode.level + 1;
+        return 0;
+    }
+    get isExpanded() {
+        return this.config.expandedColumns.includes(this.uniqueName);
+    }
+    get isChecked() {
+        if (this.config.checkedColumns.includes(this.uniqueName))
+            return true;
+        if (this.config.uncheckedColumns.includes(this.uniqueName))
+            return false;
+        return this.defaultChecked;
+    }
+    get columnTitle() {
+        return this.title;
+    }
+    get filterType() {
+        return 'string';
+    }
+    get columnName() {
+        return null;
+    }
+    get customJoinConfig() {
+        return null;
+    }
+    get db() {
+        var _a, _b;
+        return (_b = (_a = this.dbs) === null || _a === void 0 ? void 0 : _a[this.databaseConfig.conid]) === null || _b === void 0 ? void 0 : _b[this.databaseConfig.database];
+    }
+    getChildMatchColumns() {
+        return [];
+    }
+    getParentMatchColumns() {
+        return [];
+    }
+    parseFilterCondition(source = null) {
+        return null;
+    }
+    get childDataColumn() {
+        if (!this.isExpandable && this.isChecked) {
+            return this.codeName;
+        }
+        return null;
+    }
+    toggleExpanded(value) {
+        this.includeInColumnSet('expandedColumns', this.uniqueName, value == null ? !this.isExpanded : value);
+    }
+    toggleChecked(value) {
+        if (this.defaultChecked) {
+            this.includeInColumnSet('uncheckedColumns', this.uniqueName, value == null ? this.isChecked : value);
+        }
+        else {
+            this.includeInColumnSet('checkedColumns', this.uniqueName, value == null ? !this.isChecked : value);
+        }
+    }
+    includeInColumnSet(field, uniqueName, isIncluded) {
+        if (isIncluded) {
+            this.setConfig(cfg => (Object.assign(Object.assign({}, cfg), { [field]: [...(cfg[field] || []), uniqueName] })));
+        }
+        else {
+            this.setConfig(cfg => (Object.assign(Object.assign({}, cfg), { [field]: (cfg[field] || []).filter(x => x != uniqueName) })));
+        }
+    }
+    getFilter() {
+        return this.config.filters[this.uniqueName];
+    }
+    getDataLoadColumns() {
+        return (0, compact_1.default)((0, uniq_1.default)([
+            ...this.childNodes.map(x => x.childDataColumn),
+            ...(0, flatten_1.default)(this.childNodes.filter(x => x.isExpandable && x.isChecked).map(x => x.getChildMatchColumns())),
+            ...this.getParentMatchColumns(),
+        ]));
+    }
+    getChildrenCondition(source = null) {
+        const conditions = (0, compact_1.default)([
+            ...this.childNodes.map(x => x.parseFilterCondition(source)),
+            ...this.buildParentFilterConditions(),
+        ]);
+        if (conditions.length == 0) {
+            return null;
+        }
+        if (conditions.length == 1) {
+            return conditions[0];
+        }
+        return {
+            conditionType: 'and',
+            conditions,
+        };
+    }
+    getOrderBy(table) {
+        var _a;
+        const res = (0, compact_1.default)(this.childNodes.map(node => {
+            var _a, _b, _c, _d;
+            const sort = (_d = (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.sort) === null || _b === void 0 ? void 0 : _b[(_c = node === null || node === void 0 ? void 0 : node.parentNode) === null || _c === void 0 ? void 0 : _c.uniqueName]) === null || _d === void 0 ? void 0 : _d.find(x => x.uniqueName == node.uniqueName);
+            if (sort) {
+                return {
+                    columnName: node.columnName,
+                    order: sort.order,
+                };
+            }
+        }));
+        return res.length > 0
+            ? res
+            : ((_a = table === null || table === void 0 ? void 0 : table.primaryKey) === null || _a === void 0 ? void 0 : _a.columns.map(x => ({ columnName: x.columnName, order: 'ASC' }))) || [
+                { columnName: table === null || table === void 0 ? void 0 : table.columns[0].columnName, order: 'ASC' },
+            ];
+    }
+    getBaseTables() {
+        const res = [];
+        const table = this.getBaseTableFromThis();
+        if (table)
+            res.push({ table, node: this });
+        for (const child of this.childNodes) {
+            if (!child.isChecked)
+                continue;
+            res.push(...child.getBaseTables());
+        }
+        return res;
+    }
+    getBaseTableFromThis() {
+        return null;
+    }
+    get filterInfo() {
+        return null;
+    }
+    findChildNodeByUniquePath(uniquePath) {
+        if (uniquePath.length == 0) {
+            return this;
+        }
+        const child = this.childNodes.find(x => x.codeName == uniquePath[0]);
+        return child === null || child === void 0 ? void 0 : child.findChildNodeByUniquePath(uniquePath.slice(1));
+    }
+    findNodeByUniqueName(uniqueName) {
+        if (!uniqueName)
+            return null;
+        const uniquePath = uniqueName.split('::');
+        if (uniquePath[0] != this.codeName)
+            return null;
+        return this.findChildNodeByUniquePath(uniquePath.slice(1));
+    }
+    get supportsParentFilter() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return ((((_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.isRoot) || ((_b = this.parentNode) === null || _b === void 0 ? void 0 : _b.supportsParentFilter)) &&
+            ((_d = (_c = this.parentNode) === null || _c === void 0 ? void 0 : _c.databaseConfig) === null || _d === void 0 ? void 0 : _d.conid) == ((_e = this.databaseConfig) === null || _e === void 0 ? void 0 : _e.conid) &&
+            ((_g = (_f = this.parentNode) === null || _f === void 0 ? void 0 : _f.databaseConfig) === null || _g === void 0 ? void 0 : _g.database) == ((_h = this.databaseConfig) === null || _h === void 0 ? void 0 : _h.database));
+    }
+    get isParentFilter() {
+        return !!(this.config.parentFilters || []).find(x => x.uniqueName == this.uniqueName);
+    }
+    buildParentFilterConditions() {
+        var _a;
+        const leafNodes = (0, compact_1.default)((((_a = this.config) === null || _a === void 0 ? void 0 : _a.parentFilters) || []).map(x => this.rootNode.findNodeByUniqueName(x.uniqueName)));
+        const conditions = (0, compact_1.default)(leafNodes.map(leafNode => {
+            var _a, _b;
+            if (leafNode == this)
+                return null;
+            const select = {
+                commandType: 'select',
+                from: {
+                    name: leafNode.namedObject,
+                    alias: 'pert_0',
+                    relations: [],
+                },
+                selectAll: true,
+            };
+            let lastNode = leafNode;
+            let node = leafNode;
+            let index = 1;
+            let lastAlias = 'pert_0';
+            while ((node === null || node === void 0 ? void 0 : node.parentNode) && ((_a = node === null || node === void 0 ? void 0 : node.parentNode) === null || _a === void 0 ? void 0 : _a.uniqueName) != (this === null || this === void 0 ? void 0 : this.uniqueName)) {
+                node = node.parentNode;
+                let alias = `pert_${index}`;
+                select.from.relations.push({
+                    joinType: 'INNER JOIN',
+                    alias,
+                    name: node.namedObject,
+                    conditions: lastNode.getParentJoinCondition(lastAlias, alias),
+                });
+                lastAlias = alias;
+                lastNode = node;
+            }
+            if (((_b = node === null || node === void 0 ? void 0 : node.parentNode) === null || _b === void 0 ? void 0 : _b.uniqueName) != (this === null || this === void 0 ? void 0 : this.uniqueName))
+                return null;
+            select.where = {
+                conditionType: 'and',
+                conditions: (0, compact_1.default)([
+                    ...lastNode.getParentJoinCondition(lastAlias, this.namedObject.pureName),
+                    leafNode.getChildrenCondition({ alias: 'pert_0' }),
+                ]),
+            };
+            return {
+                conditionType: 'exists',
+                subQuery: select,
+            };
+        }));
+        return conditions;
+    }
+    getParentJoinCondition(alias, parentAlias) {
+        return [];
+    }
+}
+exports.PerspectiveTreeNode = PerspectiveTreeNode;
+class PerspectiveTableColumnNode extends PerspectiveTreeNode {
+    constructor(column, table, dbs, config, setConfig, dataProvider, databaseConfig, parentNode) {
+        var _a, _b, _c, _d, _e;
+        super(dbs, config, setConfig, parentNode, dataProvider, databaseConfig);
+        this.column = column;
+        this.table = table;
+        this.isTable = !!((_b = (_a = this.db) === null || _a === void 0 ? void 0 : _a.tables) === null || _b === void 0 ? void 0 : _b.find(x => x.schemaName == table.schemaName && x.pureName == table.pureName));
+        this.isView = !!((_d = (_c = this.db) === null || _c === void 0 ? void 0 : _c.views) === null || _d === void 0 ? void 0 : _d.find(x => x.schemaName == table.schemaName && x.pureName == table.pureName));
+        this.foreignKey = (_e = table === null || table === void 0 ? void 0 : table.foreignKeys) === null || _e === void 0 ? void 0 : _e.find(fk => fk.columns.length == 1 && fk.columns[0].columnName == column.columnName);
+        this.refTable = this.db.tables.find(x => { var _a, _b; return x.pureName == ((_a = this.foreignKey) === null || _a === void 0 ? void 0 : _a.refTableName) && x.schemaName == ((_b = this.foreignKey) === null || _b === void 0 ? void 0 : _b.refSchemaName); });
+    }
+    matchChildRow(parentRow, childRow) {
+        if (!this.foreignKey)
+            return false;
+        return parentRow[this.foreignKey.columns[0].columnName] == childRow[this.foreignKey.columns[0].refColumnName];
+    }
+    getChildMatchColumns() {
+        if (!this.foreignKey)
+            return [];
+        return [this.foreignKey.columns[0].columnName];
+    }
+    getParentMatchColumns() {
+        if (!this.foreignKey)
+            return [];
+        return [this.foreignKey.columns[0].refColumnName];
+    }
+    getParentJoinCondition(alias, parentAlias) {
+        if (!this.foreignKey)
+            return [];
+        return this.foreignKey.columns.map(column => {
+            const res = {
+                conditionType: 'binary',
+                operator: '=',
+                left: {
+                    exprType: 'column',
+                    columnName: column.columnName,
+                    source: { alias: parentAlias },
+                },
+                right: {
+                    exprType: 'column',
+                    columnName: column.refColumnName,
+                    source: { alias },
+                },
+            };
+            return res;
+        });
+    }
+    getNodeLoadProps(parentRows) {
+        if (!this.foreignKey)
+            return null;
+        return {
+            schemaName: this.foreignKey.refSchemaName,
+            pureName: this.foreignKey.refTableName,
+            bindingColumns: [this.foreignKey.columns[0].refColumnName],
+            bindingValues: (0, uniqBy_1.default)(parentRows.map(row => [row[this.foreignKey.columns[0].columnName]]), json_stable_stringify_1.default),
+            dataColumns: this.getDataLoadColumns(),
+            databaseConfig: this.databaseConfig,
+            orderBy: this.getOrderBy(this.refTable),
+            condition: this.getChildrenCondition(),
+        };
+    }
+    get icon() {
+        if (this.isCircular)
+            return 'img circular';
+        if (this.column.autoIncrement)
+            return 'img autoincrement';
+        if (this.foreignKey)
+            return 'img foreign-key';
+        return 'img column';
+    }
+    get codeName() {
+        return this.column.columnName;
+    }
+    get columnName() {
+        return this.column.columnName;
+    }
+    get fieldName() {
+        return this.codeName + 'Ref';
+    }
+    get title() {
+        return this.column.columnName;
+    }
+    get isExpandable() {
+        return !!this.foreignKey;
+    }
+    get filterType() {
+        return (0, dbgate_filterparser_1.getFilterType)(this.column.dataType);
+    }
+    get isCircular() {
+        var _a, _b;
+        return !!((_b = (_a = this.parentNode) === null || _a === void 0 ? void 0 : _a.parentNode) === null || _b === void 0 ? void 0 : _b.hasTableCode(this.tableCode));
+    }
+    get childNodes() {
+        var _a, _b;
+        if (!this.foreignKey)
+            return [];
+        const tbl = (_b = (_a = this === null || this === void 0 ? void 0 : this.db) === null || _a === void 0 ? void 0 : _a.tables) === null || _b === void 0 ? void 0 : _b.find(x => { var _a, _b; return x.pureName == ((_a = this.foreignKey) === null || _a === void 0 ? void 0 : _a.refTableName) && x.schemaName == ((_b = this.foreignKey) === null || _b === void 0 ? void 0 : _b.refSchemaName); });
+        return getTableChildPerspectiveNodes(tbl, this.dbs, this.config, this.setConfig, this.dataProvider, this.databaseConfig, this);
+    }
+    getBaseTableFromThis() {
+        return this.refTable;
+    }
+    get filterInfo() {
+        return {
+            columnName: this.columnName,
+            filterType: this.filterType,
+            pureName: this.column.pureName,
+            schemaName: this.column.schemaName,
+            foreignKey: this.foreignKey,
+        };
+    }
+    parseFilterCondition(source = null) {
+        const filter = this.getFilter();
+        if (!filter)
+            return null;
+        const condition = (0, dbgate_filterparser_1.parseFilter)(filter, this.filterType);
+        if (!condition)
+            return null;
+        return (0, cloneDeepWith_1.default)(condition, (expr) => {
+            if (expr.exprType == 'placeholder') {
+                return {
+                    exprType: 'column',
+                    columnName: this.column.columnName,
+                    source,
+                };
+            }
+        });
+    }
+    get headerTableAttributes() {
+        if (this.foreignKey) {
+            return {
+                schemaName: this.foreignKey.refSchemaName,
+                pureName: this.foreignKey.refTableName,
+                conid: this.databaseConfig.conid,
+                database: this.databaseConfig.database,
+            };
+        }
+        return null;
+    }
+    get tableCode() {
+        if (this.foreignKey) {
+            return `${this.foreignKey.refSchemaName}|${this.foreignKey.refTableName}`;
+        }
+        return `${this.table.schemaName}|${this.table.pureName}`;
+    }
+    get namedObject() {
+        if (this.foreignKey) {
+            return {
+                schemaName: this.foreignKey.refSchemaName,
+                pureName: this.foreignKey.refTableName,
+            };
+        }
+        return null;
+    }
+}
+exports.PerspectiveTableColumnNode = PerspectiveTableColumnNode;
+class PerspectiveTableNode extends PerspectiveTreeNode {
+    constructor(table, dbs, config, setConfig, dataProvider, databaseConfig, parentNode) {
+        super(dbs, config, setConfig, parentNode, dataProvider, databaseConfig);
+        this.table = table;
+        this.dataProvider = dataProvider;
+    }
+    getNodeLoadProps(parentRows) {
+        return {
+            schemaName: this.table.schemaName,
+            pureName: this.table.pureName,
+            dataColumns: this.getDataLoadColumns(),
+            databaseConfig: this.databaseConfig,
+            orderBy: this.getOrderBy(this.table),
+            condition: this.getChildrenCondition(),
+        };
+    }
+    get codeName() {
+        return this.table.schemaName ? `${this.table.schemaName}:${this.table.pureName}` : this.table.pureName;
+    }
+    get title() {
+        return this.table.pureName;
+    }
+    get isExpandable() {
+        return true;
+    }
+    get childNodes() {
+        return getTableChildPerspectiveNodes(this.table, this.dbs, this.config, this.setConfig, this.dataProvider, this.databaseConfig, this);
+    }
+    get icon() {
+        return 'img table';
+    }
+    getBaseTableFromThis() {
+        return this.table;
+    }
+    get headerTableAttributes() {
+        return {
+            schemaName: this.table.schemaName,
+            pureName: this.table.pureName,
+            conid: this.databaseConfig.conid,
+            database: this.databaseConfig.database,
+        };
+    }
+    get tableCode() {
+        return `${this.table.schemaName}|${this.table.pureName}`;
+    }
+    get namedObject() {
+        return {
+            schemaName: this.table.schemaName,
+            pureName: this.table.pureName,
+        };
+    }
+}
+exports.PerspectiveTableNode = PerspectiveTableNode;
+// export class PerspectiveViewNode extends PerspectiveTreeNode {
+//   constructor(
+//     public view: ViewInfo,
+//     dbs: MultipleDatabaseInfo,
+//     config: PerspectiveConfig,
+//     setConfig: ChangePerspectiveConfigFunc,
+//     public dataProvider: PerspectiveDataProvider,
+//     databaseConfig: PerspectiveDatabaseConfig,
+//     parentNode: PerspectiveTreeNode
+//   ) {
+//     super(dbs, config, setConfig, parentNode, dataProvider, databaseConfig);
+//   }
+//   getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps {
+//     return {
+//       schemaName: this.view.schemaName,
+//       pureName: this.view.pureName,
+//       dataColumns: this.getDataLoadColumns(),
+//       databaseConfig: this.databaseConfig,
+//       orderBy: this.getOrderBy(this.view),
+//       condition: this.getChildrenCondition(),
+//     };
+//   }
+//   get codeName() {
+//     return this.view.schemaName ? `${this.view.schemaName}:${this.view.pureName}` : this.view.pureName;
+//   }
+//   get title() {
+//     return this.view.pureName;
+//   }
+//   get isExpandable() {
+//     return true;
+//   }
+//   get childNodes(): PerspectiveTreeNode[] {
+//     return getTableChildPerspectiveNodes(
+//       this.view,
+//       this.dbs,
+//       this.config,
+//       this.setConfig,
+//       this.dataProvider,
+//       this.databaseConfig,
+//       this
+//     );
+//   }
+//   get icon() {
+//     return 'img table';
+//   }
+//   getBaseTableFromThis() {
+//     return this.view;
+//   }
+// }
+class PerspectiveTableReferenceNode extends PerspectiveTableNode {
+    constructor(foreignKey, table, dbs, config, setConfig, dataProvider, databaseConfig, isMultiple, parentNode) {
+        super(table, dbs, config, setConfig, dataProvider, databaseConfig, parentNode);
+        this.foreignKey = foreignKey;
+        this.dataProvider = dataProvider;
+        this.isMultiple = isMultiple;
+    }
+    matchChildRow(parentRow, childRow) {
+        if (!this.foreignKey)
+            return false;
+        return parentRow[this.foreignKey.columns[0].refColumnName] == childRow[this.foreignKey.columns[0].columnName];
+    }
+    getChildMatchColumns() {
+        if (!this.foreignKey)
+            return [];
+        return [this.foreignKey.columns[0].refColumnName];
+    }
+    getParentMatchColumns() {
+        if (!this.foreignKey)
+            return [];
+        return [this.foreignKey.columns[0].columnName];
+    }
+    getNodeLoadProps(parentRows) {
+        if (!this.foreignKey)
+            return null;
+        return {
+            schemaName: this.table.schemaName,
+            pureName: this.table.pureName,
+            bindingColumns: [this.foreignKey.columns[0].columnName],
+            bindingValues: (0, uniqBy_1.default)(parentRows.map(row => [row[this.foreignKey.columns[0].refColumnName]]), json_stable_stringify_1.default),
+            dataColumns: this.getDataLoadColumns(),
+            databaseConfig: this.databaseConfig,
+            orderBy: this.getOrderBy(this.table),
+            condition: this.getChildrenCondition(),
+        };
+    }
+    get columnTitle() {
+        return this.table.pureName;
+    }
+    get title() {
+        if (this.isMultiple) {
+            return `${super.title} (${this.foreignKey.columns.map(x => x.columnName).join(', ')})`;
+        }
+        return super.title;
+    }
+    get codeName() {
+        if (this.isMultiple) {
+            return `${super.codeName}-${this.foreignKey.columns.map(x => x.columnName).join('_')}`;
+        }
+        return super.codeName;
+    }
+    getParentJoinCondition(alias, parentAlias) {
+        if (!this.foreignKey)
+            return [];
+        return this.foreignKey.columns.map(column => {
+            const res = {
+                conditionType: 'binary',
+                operator: '=',
+                left: {
+                    exprType: 'column',
+                    columnName: column.refColumnName,
+                    source: { alias: parentAlias },
+                },
+                right: {
+                    exprType: 'column',
+                    columnName: column.columnName,
+                    source: { alias },
+                },
+            };
+            return res;
+        });
+    }
+}
+exports.PerspectiveTableReferenceNode = PerspectiveTableReferenceNode;
+class PerspectiveCustomJoinTreeNode extends PerspectiveTableNode {
+    constructor(customJoin, table, dbs, config, setConfig, dataProvider, databaseConfig, parentNode) {
+        super(table, dbs, config, setConfig, dataProvider, databaseConfig, parentNode);
+        this.customJoin = customJoin;
+        this.dataProvider = dataProvider;
+    }
+    matchChildRow(parentRow, childRow) {
+        for (const column of this.customJoin.columns) {
+            if (parentRow[column.baseColumnName] != childRow[column.refColumnName]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getChildMatchColumns() {
+        return this.customJoin.columns.map(x => x.baseColumnName);
+    }
+    getParentMatchColumns() {
+        return this.customJoin.columns.map(x => x.refColumnName);
+    }
+    getNodeLoadProps(parentRows) {
+        // console.log('CUSTOM JOIN', this.customJoin);
+        // console.log('this.getDataLoadColumns()', this.getDataLoadColumns());
+        return {
+            schemaName: this.table.schemaName,
+            pureName: this.table.pureName,
+            bindingColumns: this.getParentMatchColumns(),
+            bindingValues: (0, uniqBy_1.default)(parentRows.map(row => this.customJoin.columns.map(x => row[x.baseColumnName])), json_stable_stringify_1.default),
+            dataColumns: this.getDataLoadColumns(),
+            databaseConfig: this.databaseConfig,
+            orderBy: this.getOrderBy(this.table),
+            condition: this.getChildrenCondition(),
+        };
+    }
+    get title() {
+        return this.customJoin.joinName;
+    }
+    get icon() {
+        return 'icon custom-join';
+    }
+    get codeName() {
+        return this.customJoin.joinid;
+    }
+    get customJoinConfig() {
+        return this.customJoin;
+    }
+    getParentJoinCondition(alias, parentAlias) {
+        return this.customJoin.columns.map(column => {
+            const res = {
+                conditionType: 'binary',
+                operator: '=',
+                left: {
+                    exprType: 'column',
+                    columnName: column.baseColumnName,
+                    source: { alias: parentAlias },
+                },
+                right: {
+                    exprType: 'column',
+                    columnName: column.refColumnName,
+                    source: { alias },
+                },
+            };
+            return res;
+        });
+    }
+}
+exports.PerspectiveCustomJoinTreeNode = PerspectiveCustomJoinTreeNode;
+function getTableChildPerspectiveNodes(table, dbs, config, setConfig, dataProvider, databaseConfig, parentColumn) {
+    var _a, _b, _c;
+    if (!table)
+        return [];
+    const db = parentColumn.db;
+    const columnNodes = table.columns.map(col => new PerspectiveTableColumnNode(col, table, dbs, config, setConfig, dataProvider, databaseConfig, parentColumn));
+    const circularColumns = columnNodes.filter(x => x.isCircular).map(x => x.columnName);
+    const defaultColumns = (0, getPerspectiveDefaultColumns_1.getPerspectiveDefaultColumns)(table, db, circularColumns);
+    for (const node of columnNodes) {
+        node.defaultChecked = defaultColumns.includes(node.columnName);
+    }
+    const res = [];
+    res.push(...columnNodes);
+    const dependencies = [];
+    if (db && (table === null || table === void 0 ? void 0 : table.dependencies)) {
+        for (const fk of table === null || table === void 0 ? void 0 : table.dependencies) {
+            const tbl = db.tables.find(x => x.pureName == fk.pureName && x.schemaName == fk.schemaName);
+            if (tbl) {
+                const isMultiple = (table === null || table === void 0 ? void 0 : table.dependencies.filter(x => x.pureName == fk.pureName && x.schemaName == fk.schemaName).length) >= 2;
+                dependencies.push(new PerspectiveTableReferenceNode(fk, tbl, dbs, config, setConfig, dataProvider, databaseConfig, isMultiple, parentColumn));
+            }
+        }
+    }
+    res.push(...(0, sortBy_1.default)(dependencies, 'title'));
+    const customs = [];
+    for (const join of config.customJoins || []) {
+        if (join.baseUniqueName == parentColumn.uniqueName) {
+            const newConfig = Object.assign({}, databaseConfig);
+            if (join.conid)
+                newConfig.conid = join.conid;
+            if (join.database)
+                newConfig.database = join.database;
+            const db = (_a = dbs === null || dbs === void 0 ? void 0 : dbs[newConfig.conid]) === null || _a === void 0 ? void 0 : _a[newConfig.database];
+            const table = (_b = db === null || db === void 0 ? void 0 : db.tables) === null || _b === void 0 ? void 0 : _b.find(x => x.pureName == join.refTableName && x.schemaName == join.refSchemaName);
+            const view = (_c = db === null || db === void 0 ? void 0 : db.views) === null || _c === void 0 ? void 0 : _c.find(x => x.pureName == join.refTableName && x.schemaName == join.refSchemaName);
+            if (table || view) {
+                customs.push(new PerspectiveCustomJoinTreeNode(join, table || view, dbs, config, setConfig, dataProvider, newConfig, parentColumn));
+            }
+        }
+    }
+    res.push(...(0, sortBy_1.default)(customs, 'title'));
+    return res;
+}
+exports.getTableChildPerspectiveNodes = getTableChildPerspectiveNodes;