dbgate-tools 6.2.1 → 6.3.2

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/ScriptWriter.d.ts

@@ -10,8 +10,7 @@ export declare class ScriptWriter {
     assign(variableName: any, functionName: any, props: any): void;
     assignValue(variableName: any, jsonValue: any): void;
     requirePackage(packageName: any): void;
-    copyStream(sourceVar: any, targetVar: any, colmapVar?: any): void;
-    dumpDatabase(options: any): void;
+    copyStream(sourceVar: any, targetVar: any, colmapVar?: any, progressName?: string): void;
     importDatabase(options: any): void;
     dataDuplicator(options: any): void;
     comment(s: any): void;
@@ -27,9 +26,8 @@ export declare class ScriptWriterJson {
     endLine(): void;
     assign(variableName: any, functionName: any, props: any): void;
     assignValue(variableName: any, jsonValue: any): void;
-    copyStream(sourceVar: any, targetVar: any, colmapVar?: any): void;
+    copyStream(sourceVar: any, targetVar: any, colmapVar?: any, progressName?: string): void;
     comment(text: any): void;
-    dumpDatabase(options: any): void;
     importDatabase(options: any): void;
     dataDuplicator(options: any): void;
     getScript(schedule?: any): {

package/lib/ScriptWriter.js

@@ -37,16 +37,14 @@ class ScriptWriter {
     requirePackage(packageName) {
         this.packageNames.push(packageName);
     }
-    copyStream(sourceVar, targetVar, colmapVar = null) {
-        if (colmapVar) {
-            this._put(`await dbgateApi.copyStream(${sourceVar}, ${targetVar}, {columns: ${colmapVar}});`);
-        }
-        else {
-            this._put(`await dbgateApi.copyStream(${sourceVar}, ${targetVar});`);
-        }
-    }
-    dumpDatabase(options) {
-        this._put(`await dbgateApi.dumpDatabase(${JSON.stringify(options)});`);
+    copyStream(sourceVar, targetVar, colmapVar = null, progressName) {
+        let opts = '{';
+        if (colmapVar)
+            opts += `columns: ${colmapVar}, `;
+        if (progressName)
+            opts += `progressName: "${progressName}", `;
+        opts += '}';
+        this._put(`await dbgateApi.copyStream(${sourceVar}, ${targetVar}, ${opts});`);
     }
     importDatabase(options) {
         this._put(`await dbgateApi.importDatabase(${JSON.stringify(options)});`);
@@ -103,12 +101,13 @@ class ScriptWriterJson {
             jsonValue,
         });
     }
-    copyStream(sourceVar, targetVar, colmapVar = null) {
+    copyStream(sourceVar, targetVar, colmapVar = null, progressName) {
         this.commands.push({
             type: 'copyStream',
             sourceVar,
             targetVar,
             colmapVar,
+            progressName,
         });
     }
     comment(text) {
@@ -117,12 +116,6 @@ class ScriptWriterJson {
             text,
         });
     }
-    dumpDatabase(options) {
-        this.commands.push({
-            type: 'dumpDatabase',
-            options,
-        });
-    }
     importDatabase(options) {
         this.commands.push({
             type: 'importDatabase',
@@ -163,7 +156,7 @@ function jsonScriptToJavascript(json) {
                 script.assignValue(cmd.variableName, cmd.jsonValue);
                 break;
             case 'copyStream':
-                script.copyStream(cmd.sourceVar, cmd.targetVar, cmd.colmapVar);
+                script.copyStream(cmd.sourceVar, cmd.targetVar, cmd.colmapVar, cmd.progressName);
                 break;
             case 'endLine':
                 script.endLine();
@@ -171,9 +164,6 @@ function jsonScriptToJavascript(json) {
             case 'comment':
                 script.comment(cmd.text);
                 break;
-            case 'dumpDatabase':
-                script.dumpDatabase(cmd.options);
-                break;
             case 'importDatabase':
                 script.importDatabase(cmd.options);
                 break;

package/lib/createBulkInsertStreamBase.js

@@ -17,6 +17,8 @@ const intersection_1 = __importDefault(require("lodash/intersection"));
 const fromPairs_1 = __importDefault(require("lodash/fromPairs"));
 const getLogger_1 = require("./getLogger");
 const tableTransforms_1 = require("./tableTransforms");
+const rowProgressReporter_1 = require("./rowProgressReporter");
+const stringTools_1 = require("./stringTools");
 const logger = (0, getLogger_1.getLogger)('bulkStreamBase');
 function createBulkInsertStreamBase(driver, stream, dbhan, name, options) {
     const fullNameQuoted = name.schemaName
@@ -31,6 +33,7 @@ function createBulkInsertStreamBase(driver, stream, dbhan, name, options) {
     writable.columnNames = null;
     writable.columnDataTypes = null;
     writable.requireFixedStructure = driver.databaseEngineTypes.includes('sql');
+    writable.rowsReporter = new rowProgressReporter_1.RowProgressReporter(options.progressName);
     writable.addRow = (row) => __awaiter(this, void 0, void 0, function* () {
         if (writable.structure) {
             writable.buffer.push(row);
@@ -42,77 +45,91 @@ function createBulkInsertStreamBase(driver, stream, dbhan, name, options) {
     });
     writable.checkStructure = () => __awaiter(this, void 0, void 0, function* () {
         var _a;
-        let structure = (_a = options.targetTableStructure) !== null && _a !== void 0 ? _a : (yield driver.analyseSingleTable(dbhan, name));
-        if (structure) {
-            writable.structure = structure;
-        }
-        if (structure && options.dropIfExists) {
-            logger.info(`Dropping table ${fullNameQuoted}`);
-            yield driver.script(dbhan, `DROP TABLE ${fullNameQuoted}`);
-        }
-        if (options.createIfNotExists && (!structure || options.dropIfExists)) {
-            const dmp = driver.createDumper();
-            const createdTableInfo = driver.adaptTableInfo((0, tableTransforms_1.prepareTableForImport)(Object.assign(Object.assign({}, writable.structure), name)));
-            dmp.createTable(createdTableInfo);
-            logger.info({ sql: dmp.s }, `Creating table ${fullNameQuoted}`);
-            yield driver.script(dbhan, dmp.s);
-            structure = yield driver.analyseSingleTable(dbhan, name);
-            writable.structure = structure;
-        }
-        if (!writable.structure) {
-            throw new Error(`Error importing table - ${fullNameQuoted} not found`);
+        try {
+            let structure = (_a = options.targetTableStructure) !== null && _a !== void 0 ? _a : (yield driver.analyseSingleTable(dbhan, name));
+            if (structure) {
+                writable.structure = structure;
+            }
+            if (structure && options.dropIfExists) {
+                logger.info(`Dropping table ${fullNameQuoted}`);
+                yield driver.script(dbhan, `DROP TABLE ${fullNameQuoted}`);
+            }
+            if (options.createIfNotExists && (!structure || options.dropIfExists)) {
+                const dmp = driver.createDumper();
+                const createdTableInfo = driver.adaptTableInfo((0, tableTransforms_1.prepareTableForImport)(Object.assign(Object.assign({}, writable.structure), name)));
+                dmp.createTable(createdTableInfo);
+                logger.info({ sql: dmp.s }, `Creating table ${fullNameQuoted}`);
+                yield driver.script(dbhan, dmp.s);
+                structure = yield driver.analyseSingleTable(dbhan, name);
+                writable.structure = structure;
+            }
+            if (!writable.structure) {
+                throw new Error(`Error importing table - ${fullNameQuoted} not found`);
+            }
+            if (options.truncate) {
+                yield driver.script(dbhan, `TRUNCATE TABLE ${fullNameQuoted}`);
+            }
+            writable.columnNames = (0, intersection_1.default)(structure.columns.map(x => x.columnName), writable.structure.columns.map(x => x.columnName));
+            writable.columnDataTypes = (0, fromPairs_1.default)(writable.columnNames.map(colName => {
+                var _a;
+                return [
+                    colName,
+                    (_a = writable.structure.columns.find(x => x.columnName == colName)) === null || _a === void 0 ? void 0 : _a.dataType,
+                ];
+            }));
         }
-        if (options.truncate) {
-            yield driver.script(dbhan, `TRUNCATE TABLE ${fullNameQuoted}`);
+        catch (err) {
+            logger.error((0, stringTools_1.extractErrorLogData)(err), 'Error during preparing bulk insert table, stopped');
+            writable.destroy(err);
         }
-        writable.columnNames = (0, intersection_1.default)(structure.columns.map(x => x.columnName), writable.structure.columns.map(x => x.columnName));
-        writable.columnDataTypes = (0, fromPairs_1.default)(writable.columnNames.map(colName => {
-            var _a;
-            return [
-                colName,
-                (_a = writable.structure.columns.find(x => x.columnName == colName)) === null || _a === void 0 ? void 0 : _a.dataType,
-            ];
-        }));
     });
     writable.send = () => __awaiter(this, void 0, void 0, function* () {
         const rows = writable.buffer;
         writable.buffer = [];
-        if (driver.dialect.allowMultipleValuesInsert) {
-            const dmp = driver.createDumper();
-            dmp.putRaw(`INSERT INTO ${fullNameQuoted} (`);
-            dmp.putCollection(',', writable.columnNames, col => dmp.putRaw(driver.dialect.quoteIdentifier(col)));
-            dmp.putRaw(')\n VALUES\n');
-            let wasRow = false;
-            for (const row of rows) {
-                if (wasRow)
-                    dmp.putRaw(',\n');
-                dmp.putRaw('(');
-                dmp.putCollection(',', writable.columnNames, col => { var _a; return dmp.putValue(row[col], (_a = writable.columnDataTypes) === null || _a === void 0 ? void 0 : _a[col]); });
-                dmp.putRaw(')');
-                wasRow = true;
-            }
-            dmp.putRaw(';');
-            // require('fs').writeFileSync('/home/jena/test.sql', dmp.s);
-            // console.log(dmp.s);
-            yield driver.query(dbhan, dmp.s, { discardResult: true });
-        }
-        else {
-            for (const row of rows) {
+        try {
+            if (driver.dialect.allowMultipleValuesInsert) {
                 const dmp = driver.createDumper();
                 dmp.putRaw(`INSERT INTO ${fullNameQuoted} (`);
                 dmp.putCollection(',', writable.columnNames, col => dmp.putRaw(driver.dialect.quoteIdentifier(col)));
                 dmp.putRaw(')\n VALUES\n');
-                dmp.putRaw('(');
-                dmp.putCollection(',', writable.columnNames, col => { var _a; return dmp.putValue(row[col], (_a = writable.columnDataTypes) === null || _a === void 0 ? void 0 : _a[col]); });
-                dmp.putRaw(')');
+                let wasRow = false;
+                for (const row of rows) {
+                    if (wasRow)
+                        dmp.putRaw(',\n');
+                    dmp.putRaw('(');
+                    dmp.putCollection(',', writable.columnNames, col => { var _a; return dmp.putValue(row[col], (_a = writable.columnDataTypes) === null || _a === void 0 ? void 0 : _a[col]); });
+                    dmp.putRaw(')');
+                    wasRow = true;
+                }
+                dmp.putRaw(';');
+                // require('fs').writeFileSync('/home/jena/test.sql', dmp.s);
                 // console.log(dmp.s);
                 yield driver.query(dbhan, dmp.s, { discardResult: true });
+                writable.rowsReporter.add(rows.length);
+            }
+            else {
+                for (const row of rows) {
+                    const dmp = driver.createDumper();
+                    dmp.putRaw(`INSERT INTO ${fullNameQuoted} (`);
+                    dmp.putCollection(',', writable.columnNames, col => dmp.putRaw(driver.dialect.quoteIdentifier(col)));
+                    dmp.putRaw(')\n VALUES\n');
+                    dmp.putRaw('(');
+                    dmp.putCollection(',', writable.columnNames, col => { var _a; return dmp.putValue(row[col], (_a = writable.columnDataTypes) === null || _a === void 0 ? void 0 : _a[col]); });
+                    dmp.putRaw(')');
+                    // console.log(dmp.s);
+                    yield driver.query(dbhan, dmp.s, { discardResult: true });
+                    writable.rowsReporter.add(1);
+                }
+            }
+            if (options.commitAfterInsert) {
+                const dmp = driver.createDumper();
+                dmp.commitTransaction();
+                yield driver.query(dbhan, dmp.s, { discardResult: true });
             }
         }
-        if (options.commitAfterInsert) {
-            const dmp = driver.createDumper();
-            dmp.commitTransaction();
-            yield driver.query(dbhan, dmp.s, { discardResult: true });
+        catch (err) {
+            logger.error((0, stringTools_1.extractErrorLogData)(err), 'Error during base bulk insert, insert stopped');
+            writable.destroy(err);
         }
     });
     writable.sendIfFull = () => __awaiter(this, void 0, void 0, function* () {
@@ -127,6 +144,7 @@ function createBulkInsertStreamBase(driver, stream, dbhan, name, options) {
     });
     writable._final = (callback) => __awaiter(this, void 0, void 0, function* () {
         yield writable.send();
+        writable.rowsReporter.finish();
         callback();
     });
     return writable;

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/getConnectionLabel.d.ts

@@ -3,3 +3,4 @@ export declare function getConnectionLabel(connection: any, { allowExplicitDatab
     allowExplicitDatabase?: boolean;
     showUnsaved?: boolean;
 }): any;
+export declare function getEngineLabel(connection: any): any;

package/lib/getConnectionLabel.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConnectionLabel = exports.getDatabaseFileLabel = void 0;
+exports.getEngineLabel = exports.getConnectionLabel = exports.getDatabaseFileLabel = void 0;
 function getDatabaseFileLabel(databaseFile) {
     if (!databaseFile)
         return databaseFile;
@@ -45,3 +45,11 @@ function getConnectionLabel(connection, { allowExplicitDatabase = true, showUnsa
     return res;
 }
 exports.getConnectionLabel = getConnectionLabel;
+function getEngineLabel(connection) {
+    const match = ((connection === null || connection === void 0 ? void 0 : connection.engine) || '').match(/^([^@]*)@/);
+    if (match) {
+        return match[1];
+    }
+    return connection === null || connection === void 0 ? void 0 : connection.engine;
+}
+exports.getEngineLabel = getEngineLabel;

package/lib/index.d.ts

@@ -25,3 +25,5 @@ export * from './detectSqlFilterBehaviour';
 export * from './filterBehaviours';
 export * from './schemaInfoTools';
 export * from './dbKeysLoader';
+export * from './rowProgressReporter';
+export * from './diagramTools';

package/lib/index.js

@@ -41,3 +41,5 @@ __exportStar(require("./detectSqlFilterBehaviour"), exports);
 __exportStar(require("./filterBehaviours"), exports);
 __exportStar(require("./schemaInfoTools"), exports);
 __exportStar(require("./dbKeysLoader"), exports);
+__exportStar(require("./rowProgressReporter"), exports);
+__exportStar(require("./diagramTools"), exports);

package/lib/rowProgressReporter.d.ts

@@ -0,0 +1,10 @@
+export declare class RowProgressReporter {
+    progressName: any;
+    field: string;
+    counter: number;
+    timeoutHandle: any;
+    constructor(progressName: any, field?: string);
+    add(count: number): void;
+    finish(): void;
+    send(): void;
+}

package/lib/rowProgressReporter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowProgressReporter = void 0;
+class RowProgressReporter {
+    constructor(progressName, field = 'writtenRowCount') {
+        this.progressName = progressName;
+        this.field = field;
+        this.counter = 0;
+        this.timeoutHandle = null;
+    }
+    add(count) {
+        this.counter += count;
+        if (!this.progressName) {
+            return;
+        }
+        if (this.timeoutHandle) {
+            return;
+        }
+        this.timeoutHandle = setTimeout(() => {
+            this.timeoutHandle = null;
+            this.send();
+        }, 1000);
+    }
+    finish() {
+        if (!this.progressName) {
+            return;
+        }
+        if (this.timeoutHandle) {
+            clearTimeout(this.timeoutHandle);
+            this.timeoutHandle = null;
+        }
+        this.send();
+    }
+    send() {
+        if (!this.progressName) {
+            return;
+        }
+        process.send({
+            msgtype: 'progress',
+            progressName: this.progressName,
+            [this.field]: this.counter,
+        });
+    }
+}
+exports.RowProgressReporter = RowProgressReporter;

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.2.1",
+  "version": "6.3.2",
   "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.2.1",
-    "jest": "^24.9.0",
-    "ts-jest": "^25.2.1",
+    "dbgate-types": "^6.3.2",
+    "jest": "^28.1.3",
+    "ts-jest": "^28.0.7",
     "typescript": "^4.4.3"
   },
   "dependencies": {
     "dbgate-query-splitter": "^4.11.3",
-    "dbgate-sqltree": "^6.2.1",
+    "dbgate-sqltree": "^6.3.2",
     "debug": "^4.3.4",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.21",