dbgate-tools 6.3.0 → 6.3.3

package/lib/DatabaseAnalyser.d.ts

@@ -27,7 +27,10 @@ export declare class DatabaseAnalyser {
     getDeletedObjects(snapshot: any): any[];
     feedback(obj: any): void;
     getModifications(): Promise<any[]>;
-    analyserQuery(template: any, typeFields: any, replacements?: {}): Promise<import("dbgate-types").QueryResult>;
+    analyserQuery(template: any, typeFields: any, replacements?: {}): Promise<import("dbgate-types").QueryResult | {
+        rows: any[];
+        isError: boolean;
+    }>;
     static createEmptyStructure(): DatabaseInfo;
     static byTableFilter(table: any): (x: any) => boolean;
     static extractPrimaryKeys(table: any, pkColumns: any): {

package/lib/DatabaseAnalyser.js

@@ -333,6 +333,7 @@ class DatabaseAnalyser {
                 logger.error((0, stringTools_1.extractErrorLogData)(err, { template }), 'Error running analyser query');
                 return {
                     rows: [],
+                    isError: true,
                 };
             }
         });

package/lib/diagramTools.d.ts

@@ -0,0 +1,4 @@
+import { TableInfo } from 'dbgate-types';
+export declare function chooseTopTables(tables: TableInfo[], count: number, tableFilter: string, omitTablesFilter: string): TableInfo[];
+export declare const DIAGRAM_ZOOMS: number[];
+export declare const DIAGRAM_DEFAULT_WATERMARK = "Powered by [dbgate.io](https://dbgate.io)";

package/lib/diagramTools.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIAGRAM_DEFAULT_WATERMARK = exports.DIAGRAM_ZOOMS = exports.chooseTopTables = void 0;
+const structureTools_1 = require("./structureTools");
+const sortBy_1 = __importDefault(require("lodash/sortBy"));
+const uniq_1 = __importDefault(require("lodash/uniq"));
+const filterName_1 = require("./filterName");
+function tableWeight(table, maxRowcount) {
+    var _a, _b;
+    let weight = 0;
+    const tableDependenciesCount = (0, uniq_1.default)(((_a = table.dependencies) === null || _a === void 0 ? void 0 : _a.map(x => x.pureName)) || []).length;
+    const tableFkCount = (0, uniq_1.default)(((_b = table.foreignKeys) === null || _b === void 0 ? void 0 : _b.map(x => x.refTableName)) || []).length;
+    if (table.primaryKey)
+        weight += 1;
+    if (tableFkCount)
+        weight += tableFkCount * 1;
+    if (maxRowcount && table.tableRowCount) {
+        const rowcount = parseInt(table.tableRowCount);
+        if (rowcount > 0)
+            weight += Math.log(rowcount) * table.columns.length * (tableFkCount || 1) * (tableDependenciesCount || 1);
+    }
+    else {
+        if (table.columns)
+            weight += table.columns.length * 2;
+    }
+    if (table.dependencies)
+        weight += tableDependenciesCount * 10;
+    if (maxRowcount)
+        return weight;
+}
+function chooseTopTables(tables, count, tableFilter, omitTablesFilter) {
+    const filteredTables = tables.filter(table => {
+        if (tableFilter) {
+            if (!(0, filterName_1.filterName)(tableFilter, table === null || table === void 0 ? void 0 : table.pureName))
+                return false;
+        }
+        if (omitTablesFilter) {
+            if ((0, filterName_1.filterName)(omitTablesFilter, table === null || table === void 0 ? void 0 : table.pureName))
+                return false;
+        }
+        return true;
+    });
+    if (!(count > 0)) {
+        return filteredTables;
+    }
+    const dbinfo = {
+        tables: filteredTables,
+    };
+    const extended = (0, structureTools_1.extendDatabaseInfo)(dbinfo);
+    const maxRowcount = Math.max(...extended.tables
+        .map(x => x.tableRowCount || 0)
+        .map(x => parseInt(x))
+        .filter(x => x > 0));
+    const sorted = (0, sortBy_1.default)((0, sortBy_1.default)(extended.tables, x => `${x.schemaName}.${x.pureName}`), table => -tableWeight(table, maxRowcount));
+    return sorted.slice(0, count);
+}
+exports.chooseTopTables = chooseTopTables;
+exports.DIAGRAM_ZOOMS = [0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1, 1.25, 1.5, 1.75, 2];
+exports.DIAGRAM_DEFAULT_WATERMARK = 'Powered by [dbgate.io](https://dbgate.io)';

package/lib/filterName.js

@@ -6,9 +6,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokenizeBySearchFilter = exports.filterNameCompoud = exports.filterName = void 0;
 const compact_1 = __importDefault(require("lodash/compact"));
 const startCase_1 = __importDefault(require("lodash/startCase"));
-// export interface FilterNameDefinition {
-//   childName: string;
-// }
+function parseTokenTree(filter) {
+    const factors = filter
+        .split(',')
+        .map(x => x.trim())
+        .filter(x => x.length > 0);
+    return {
+        factors: factors.map(x => ({
+            tokens: x
+                .split(' ')
+                .map(x => x.trim())
+                .filter(x => x.length > 0),
+        })),
+    };
+}
 function camelMatch(filter, text) {
     if (!text)
         return false;
@@ -28,23 +39,25 @@ function filterName(filter, ...names) {
     if (!filter)
         return true;
     // const camelVariants = [name.replace(/[^A-Z]/g, '')]
-    const tokens = filter.split(' ').map(x => x.trim());
+    const tree = parseTokenTree(filter);
+    if (tree.factors.length == 0)
+        return true;
     const namesCompacted = (0, compact_1.default)(names);
-    for (const token of tokens) {
-        const found = namesCompacted.find(name => camelMatch(token, name));
-        if (!found)
-            return false;
+    for (const factor of tree.factors) {
+        let factorOk = true;
+        for (const token of factor.tokens) {
+            const found = namesCompacted.find(name => camelMatch(token, name));
+            if (!found)
+                factorOk = false;
+        }
+        if (factorOk) {
+            return true;
+        }
     }
-    return true;
+    return false;
 }
 exports.filterName = filterName;
-function filterNameCompoud(filter, namesMain, namesChild) {
-    if (!filter)
-        return 'both';
-    // const camelVariants = [name.replace(/[^A-Z]/g, '')]
-    const tokens = filter.split(' ').map(x => x.trim());
-    const namesCompactedMain = (0, compact_1.default)(namesMain);
-    const namesCompactedChild = (0, compact_1.default)(namesChild);
+function clasifyCompoudCategory(tokens, namesCompactedMain, namesCompactedChild) {
     let isMainOnly = true;
     let isChildOnly = true;
     for (const token of tokens) {
@@ -65,12 +78,39 @@ function filterNameCompoud(filter, namesMain, namesChild) {
         return 'child';
     return 'none';
 }
+function filterNameCompoud(filter, namesMain, namesChild) {
+    if (!filter)
+        return 'both';
+    // const camelVariants = [name.replace(/[^A-Z]/g, '')]
+    const tree = parseTokenTree(filter);
+    const namesCompactedMain = (0, compact_1.default)(namesMain);
+    const namesCompactedChild = (0, compact_1.default)(namesChild);
+    if (tree.factors.length == 0)
+        return 'both';
+    const factorRes = [];
+    for (const factor of tree.factors) {
+        const category = clasifyCompoudCategory(factor.tokens, namesCompactedMain, namesCompactedChild);
+        factorRes.push(category);
+    }
+    if (factorRes.includes('both'))
+        return 'both';
+    if (factorRes.includes('main') && factorRes.includes('child'))
+        return 'both';
+    if (factorRes.includes('main'))
+        return 'main';
+    if (factorRes.includes('child'))
+        return 'child';
+    return 'none';
+}
 exports.filterNameCompoud = filterNameCompoud;
 function tokenizeBySearchFilter(text, filter) {
     var _a, _b;
     const camelTokens = [];
     const stdTokens = [];
-    for (const token of filter.split(' ').map(x => x.trim())) {
+    for (const token of filter
+        .split(/[ ,]/)
+        .map(x => x.trim())
+        .filter(x => x.length > 0)) {
         if (token.replace(/[A-Z]/g, '').length == 0) {
             camelTokens.push(token);
         }

package/lib/filterName.test.d.ts

@@ -0,0 +1 @@
+declare const tokenizeBySearchFilter: any;

package/lib/filterName.test.js

@@ -0,0 +1,18 @@
+const { tokenizeBySearchFilter } = require('./filterName');
+test('tokenize single token', () => {
+    const tokenized = tokenizeBySearchFilter('Album', 'al');
+    // console.log(JSON.stringify(tokenized, null, 2));
+    expect(tokenized).toEqual([
+        { text: 'Al', isMatch: true },
+        { text: 'bum', isMatch: false },
+    ]);
+});
+test('tokenize two tokens', () => {
+    const tokenized = tokenizeBySearchFilter('Album', 'al,um');
+    // console.log(JSON.stringify(tokenized, null, 2));
+    expect(tokenized).toEqual([
+        { text: 'Al', isMatch: true },
+        { text: 'b', isMatch: false },
+        { text: 'um', isMatch: true },
+    ]);
+});

package/lib/index.d.ts

@@ -26,3 +26,4 @@ export * from './filterBehaviours';
 export * from './schemaInfoTools';
 export * from './dbKeysLoader';
 export * from './rowProgressReporter';
+export * from './diagramTools';

package/lib/index.js

@@ -42,3 +42,4 @@ __exportStar(require("./filterBehaviours"), exports);
 __exportStar(require("./schemaInfoTools"), exports);
 __exportStar(require("./dbKeysLoader"), exports);
 __exportStar(require("./rowProgressReporter"), exports);
+__exportStar(require("./diagramTools"), exports);

package/lib/structureTools.js

@@ -7,12 +7,13 @@ exports.skipDbGateInternalObjects = exports.removePreloadedRowsFromStructure = e
 const flatten_1 = __importDefault(require("lodash/flatten"));
 const uniq_1 = __importDefault(require("lodash/uniq"));
 const keys_1 = __importDefault(require("lodash/keys"));
+const compact_1 = __importDefault(require("lodash/compact"));
 function addTableDependencies(db) {
     if (!db.tables) {
         return db;
     }
-    const allForeignKeys = (0, flatten_1.default)(db.tables.map(x => x.foreignKeys || []));
-    return Object.assign(Object.assign({}, db), { tables: db.tables.map(table => (Object.assign(Object.assign({}, table), { dependencies: allForeignKeys.filter(x => x.refSchemaName == table.schemaName && x.refTableName == table.pureName) }))) });
+    const allForeignKeys = (0, flatten_1.default)(db.tables.map(x => (x === null || x === void 0 ? void 0 : x.foreignKeys) || []));
+    return Object.assign(Object.assign({}, db), { tables: (0, compact_1.default)(db.tables).map(table => (Object.assign(Object.assign({}, table), { dependencies: allForeignKeys.filter(x => x.refSchemaName == table.schemaName && x.refTableName == table.pureName) }))) });
 }
 exports.addTableDependencies = addTableDependencies;
 function extendTableInfo(table) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "6.3.0",
+  "version": "6.3.3",
   "name": "dbgate-tools",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -17,22 +17,23 @@
   "scripts": {
     "build": "tsc",
     "start": "tsc --watch",
+    "prepublishOnly": "yarn build",
     "test": "jest",
-    "prepublishOnly": "yarn build"
+    "test:ci": "jest --json --outputFile=result.json --testLocationInResults"
   },
   "files": [
     "lib"
   ],
   "devDependencies": {
     "@types/node": "^13.7.0",
-    "dbgate-types": "^6.3.0",
-    "jest": "^24.9.0",
-    "ts-jest": "^25.2.1",
+    "dbgate-types": "^6.3.3",
+    "jest": "^28.1.3",
+    "ts-jest": "^28.0.7",
     "typescript": "^4.4.3"
   },
   "dependencies": {
     "dbgate-query-splitter": "^4.11.3",
-    "dbgate-sqltree": "^6.3.0",
+    "dbgate-sqltree": "^6.3.3",
     "debug": "^4.3.4",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.21",