dbgate-tools 6.0.0 → 6.1.1

package/lib/DatabaseAnalyser.js

@@ -339,7 +339,7 @@ class DatabaseAnalyser {
         };
     }
     static byTableFilter(table) {
-        return x => x.pureName == table.pureName && x.schemaName == x.schemaName;
+        return x => x.pureName == table.pureName && x.schemaName == table.schemaName;
     }
     static extractPrimaryKeys(table, pkColumns) {
         const filtered = pkColumns.filter(DatabaseAnalyser.byTableFilter(table));

package/lib/diffTools.js

@@ -519,7 +519,7 @@ function sortViewsByDependency(views) {
 }
 function createAlterDatabasePlan(oldDb, newDb, opts, wholeOldDb, wholeNewDb, driver) {
     const plan = new alterPlan_1.AlterPlan(wholeOldDb, wholeNewDb, driver.dialect, opts);
-    for (const objectTypeField of ['tables', 'views', 'procedures', 'matviews', 'functions']) {
+    for (const objectTypeField of ['tables', 'views', 'procedures', 'matviews', 'functions', 'triggers']) {
         for (const oldobj of oldDb[objectTypeField] || []) {
             const newobj = (newDb[objectTypeField] || []).find(x => x.pairingId == oldobj.pairingId);
             if (objectTypeField == 'tables') {

package/lib/driverBase.d.ts

@@ -1,7 +1,8 @@
 import { SqlDumper } from './SqlDumper';
 import { EngineDriver, QueryResult, RunScriptOptions } from 'dbgate-types';
-export declare function runCommandOnDriver(pool: any, driver: EngineDriver, cmd: (dmp: SqlDumper) => void): Promise<void>;
+export declare function runCommandOnDriver(pool: any, driver: EngineDriver, cmd: (dmp: SqlDumper) => void | string): Promise<void>;
 export declare function runQueryOnDriver(pool: any, driver: EngineDriver, cmd: (dmp: SqlDumper) => void): Promise<QueryResult>;
+export declare function formatQueryWithoutParams(driver: EngineDriver, sql: string): string;
 export declare const driverBase: {
     analyserClass: any;
     dumperClass: typeof SqlDumper;

package/lib/driverBase.js

@@ -12,8 +12,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.driverBase = exports.runQueryOnDriver = exports.runCommandOnDriver = void 0;
+exports.driverBase = exports.formatQueryWithoutParams = exports.runQueryOnDriver = exports.runCommandOnDriver = void 0;
 const compact_1 = __importDefault(require("lodash/compact"));
+const isString_1 = __importDefault(require("lodash/isString"));
 const SqlDumper_1 = require("./SqlDumper");
 const dbgate_query_splitter_1 = require("dbgate-query-splitter");
 const dbgate_sqltree_1 = require("dbgate-sqltree");
@@ -40,7 +41,12 @@ const dialect = {
 function runCommandOnDriver(pool, driver, cmd) {
     return __awaiter(this, void 0, void 0, function* () {
         const dmp = driver.createDumper();
-        cmd(dmp);
+        if ((0, isString_1.default)(cmd)) {
+            dmp.put(cmd);
+        }
+        else {
+            cmd(dmp);
+        }
         // console.log('CMD:', dmp.s);
         yield driver.query(pool, dmp.s, { discardResult: true });
     });
@@ -49,12 +55,23 @@ exports.runCommandOnDriver = runCommandOnDriver;
 function runQueryOnDriver(pool, driver, cmd) {
     return __awaiter(this, void 0, void 0, function* () {
         const dmp = driver.createDumper();
-        cmd(dmp);
+        if ((0, isString_1.default)(cmd)) {
+            dmp.put(cmd);
+        }
+        else {
+            cmd(dmp);
+        }
         // console.log('QUERY:', dmp.s);
         return yield driver.query(pool, dmp.s);
     });
 }
 exports.runQueryOnDriver = runQueryOnDriver;
+function formatQueryWithoutParams(driver, sql) {
+    const dmp = driver.createDumper();
+    dmp.put(sql);
+    return dmp.s;
+}
+exports.formatQueryWithoutParams = formatQueryWithoutParams;
 exports.driverBase = {
     analyserClass: null,
     dumperClass: SqlDumper_1.SqlDumper,

package/lib/filterName.d.ts

@@ -1,4 +1,6 @@
-export interface FilterNameDefinition {
-    childName: string;
-}
-export declare function filterName(filter: string, ...names: (string | FilterNameDefinition)[]): boolean;
+export declare function filterName(filter: string, ...names: string[]): boolean;
+export declare function filterNameCompoud(filter: string, namesMain: string[], namesChild: string[]): 'main' | 'child' | 'both' | 'none';
+export declare function tokenizeBySearchFilter(text: string, filter: string): {
+    text: string;
+    isMatch: boolean;
+}[];

package/lib/filterName.js

@@ -3,10 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterName = void 0;
+exports.tokenizeBySearchFilter = exports.filterNameCompoud = exports.filterName = void 0;
 const compact_1 = __importDefault(require("lodash/compact"));
-const isString_1 = __importDefault(require("lodash/isString"));
 const startCase_1 = __importDefault(require("lodash/startCase"));
+// export interface FilterNameDefinition {
+//   childName: string;
+// }
 function camelMatch(filter, text) {
     if (!text)
         return false;
@@ -28,24 +30,129 @@ function filterName(filter, ...names) {
     // const camelVariants = [name.replace(/[^A-Z]/g, '')]
     const tokens = filter.split(' ').map(x => x.trim());
     const namesCompacted = (0, compact_1.default)(names);
-    // @ts-ignore
-    const namesOwn = namesCompacted.filter(x => (0, isString_1.default)(x));
-    // @ts-ignore
-    const namesChild = namesCompacted.filter(x => x.childName).map(x => x.childName);
     for (const token of tokens) {
-        // const tokenUpper = token.toUpperCase();
-        if (token.startsWith('#')) {
-            // const tokenUpperSub = tokenUpper.substring(1);
-            const found = namesChild.find(name => camelMatch(token.substring(1), name));
-            if (!found)
-                return false;
+        const found = namesCompacted.find(name => camelMatch(token, name));
+        if (!found)
+            return false;
+    }
+    return true;
+}
+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);
+    let isMainOnly = true;
+    let isChildOnly = true;
+    for (const token of tokens) {
+        const foundMain = namesCompactedMain.find(name => camelMatch(token, name));
+        const foundChild = namesCompactedChild.find(name => camelMatch(token, name));
+        if (!foundMain && !foundChild)
+            return 'none';
+        if (!foundMain)
+            isMainOnly = false;
+        if (!foundChild)
+            isChildOnly = false;
+    }
+    if (isMainOnly && isChildOnly)
+        return 'both';
+    if (isMainOnly)
+        return 'main';
+    if (isChildOnly)
+        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())) {
+        if (token.replace(/[A-Z]/g, '').length == 0) {
+            camelTokens.push(token);
         }
         else {
-            const found = namesOwn.find(name => camelMatch(token, name));
-            if (!found)
-                return false;
+            stdTokens.push(token.toUpperCase());
         }
     }
-    return true;
+    let res = [
+        {
+            text,
+            isMatch: false,
+        },
+    ];
+    for (const token of camelTokens) {
+        const nextres = [];
+        for (const item of res) {
+            const indexes = [];
+            for (const char of token) {
+                if (indexes.length == 0 && char == ((_a = item.text[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase())) {
+                    // handle first letter of camelcase
+                    indexes.push(0);
+                }
+                else {
+                    const index = item.text.indexOf(char, indexes.length > 0 ? indexes[indexes.length - 1] + 1 : 0);
+                    if (index < 0) {
+                        indexes.push(-1);
+                    }
+                    else {
+                        indexes.push(index);
+                    }
+                }
+            }
+            if (indexes.some(x => x < 0)) {
+                nextres.push(item);
+            }
+            else {
+                let lastIndex = 0;
+                for (let i = 0; i < indexes.length; i++) {
+                    if (indexes[i] > lastIndex) {
+                        nextres.push({ text: item.text.substring(lastIndex, indexes[i]), isMatch: false });
+                    }
+                    nextres.push({ text: item.text.substring(indexes[i], indexes[i] + 1), isMatch: true });
+                    lastIndex = indexes[i] + 1;
+                }
+                nextres.push({ text: item.text.substring(lastIndex), isMatch: false });
+            }
+        }
+        res = nextres;
+    }
+    for (const token of stdTokens) {
+        const nextres = [];
+        for (const item of res) {
+            const index = (_b = item.text) === null || _b === void 0 ? void 0 : _b.toUpperCase().indexOf(token);
+            if (index < 0) {
+                nextres.push(item);
+            }
+            else {
+                nextres.push({ text: item.text.substring(0, index), isMatch: false });
+                nextres.push({ text: item.text.substring(index, index + token.length), isMatch: true });
+                nextres.push({ text: item.text.substring(index + token.length), isMatch: false });
+            }
+        }
+        res = nextres;
+    }
+    res = res.filter(x => x.text.length > 0);
+    if (res.length == 1 && !res[0].isMatch) {
+        return null;
+    }
+    return res;
+    // const result = [];
+    // let lastMatch = 0;
+    // for (const token of tokens) {
+    //   const index = text.indexOf(token, lastMatch);
+    //   if (index < 0) {
+    //     result.push({ token, isMatch: false });
+    //     continue;
+    //   }
+    //   result.push({ token: text.substring(lastMatch, index), isMatch: false });
+    //   result.push({ token: text.substring(index, index + token.length), isMatch: true });
+    //   lastMatch = index + token.length;
+    // }
+    // result.push({ token: text.substring(lastMatch), isMatch: false });
+    // return result;
 }
-exports.filterName = filterName;
+exports.tokenizeBySearchFilter = tokenizeBySearchFilter;

package/lib/yamlModelConv.js

@@ -175,6 +175,7 @@ function databaseInfoFromYamlModel(filesOrDbInfo) {
             }
             if (file.name.endsWith('.trigger.sql')) {
                 model.triggers.push({
+                    objectId: `triggers:${file.name.slice(0, -'.trigger.sql'.length)}`,
                     pureName: file.name.slice(0, -'.trigger.sql'.length),
                     createSql: file.text,
                 });

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "6.0.0",
+  "version": "6.1.1",
   "name": "dbgate-tools",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -25,14 +25,14 @@
   ],
   "devDependencies": {
     "@types/node": "^13.7.0",
-    "dbgate-types": "^6.0.0",
+    "dbgate-types": "^6.1.1",
     "jest": "^24.9.0",
     "ts-jest": "^25.2.1",
     "typescript": "^4.4.3"
   },
   "dependencies": {
     "dbgate-query-splitter": "^4.11.2",
-    "dbgate-sqltree": "^6.0.0",
+    "dbgate-sqltree": "^6.1.1",
     "debug": "^4.3.4",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.21",