dbgate-tools 4.7.3-alpha.5 → 4.7.4-alpha.10

package/lib/ScriptWriter.d.ts

@@ -0,0 +1,36 @@
+export declare class ScriptWriter {
+    s: string;
+    packageNames: string[];
+    varCount: number;
+    constructor(varCount?: string);
+    allocVariable(prefix?: string): string;
+    _put(s?: string): void;
+    endLine(): void;
+    assignCore(variableName: any, functionName: any, props: any): void;
+    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;
+    comment(s: any): void;
+    getScript(schedule?: any): string;
+}
+export declare class ScriptWriterJson {
+    s: string;
+    packageNames: string[];
+    varCount: number;
+    commands: any[];
+    constructor(varCount?: string);
+    allocVariable(prefix?: string): string;
+    endLine(): void;
+    assign(variableName: any, functionName: any, props: any): void;
+    assignValue(variableName: any, jsonValue: any): void;
+    copyStream(sourceVar: any, targetVar: any, colmapVar?: any): void;
+    comment(text: any): void;
+    getScript(schedule?: any): {
+        type: string;
+        schedule: any;
+        commands: any[];
+        packageNames: string[];
+    };
+}
+export declare function jsonScriptToJavascript(json: any): string;

package/lib/ScriptWriter.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonScriptToJavascript = exports.ScriptWriterJson = exports.ScriptWriter = void 0;
+const uniq_1 = __importDefault(require("lodash/uniq"));
+const packageTools_1 = require("./packageTools");
+class ScriptWriter {
+    constructor(varCount = '0') {
+        this.s = '';
+        this.packageNames = [];
+        this.varCount = 0;
+        this.varCount = parseInt(varCount) || 0;
+    }
+    allocVariable(prefix = 'var') {
+        this.varCount += 1;
+        return `${prefix}${this.varCount}`;
+    }
+    _put(s = '') {
+        this.s += s;
+        this.s += '\n';
+    }
+    endLine() {
+        this._put();
+    }
+    assignCore(variableName, functionName, props) {
+        this._put(`const ${variableName} = await ${functionName}(${JSON.stringify(props)});`);
+    }
+    assign(variableName, functionName, props) {
+        this.assignCore(variableName, (0, packageTools_1.extractShellApiFunctionName)(functionName), props);
+        this.packageNames.push(...(0, packageTools_1.extractShellApiPlugins)(functionName, props));
+    }
+    assignValue(variableName, jsonValue) {
+        this._put(`const ${variableName} = ${JSON.stringify(jsonValue)};`);
+    }
+    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});`);
+        }
+    }
+    comment(s) {
+        this._put(`// ${s}`);
+    }
+    getScript(schedule = null) {
+        const packageNames = this.packageNames;
+        let prefix = (0, uniq_1.default)(packageNames)
+            .map(packageName => `// @require ${packageName}\n`)
+            .join('');
+        if (schedule)
+            prefix += `// @schedule ${schedule}`;
+        if (prefix)
+            prefix += '\n';
+        return prefix + this.s;
+    }
+}
+exports.ScriptWriter = ScriptWriter;
+class ScriptWriterJson {
+    constructor(varCount = '0') {
+        this.s = '';
+        this.packageNames = [];
+        this.varCount = 0;
+        this.commands = [];
+        this.varCount = parseInt(varCount) || 0;
+    }
+    allocVariable(prefix = 'var') {
+        this.varCount += 1;
+        return `${prefix}${this.varCount}`;
+    }
+    endLine() {
+        this.commands.push({
+            type: 'endline',
+        });
+    }
+    assign(variableName, functionName, props) {
+        this.commands.push({
+            type: 'assign',
+            variableName,
+            functionName: (0, packageTools_1.extractShellApiFunctionName)(functionName),
+            props,
+        });
+        this.packageNames.push(...(0, packageTools_1.extractShellApiPlugins)(functionName, props));
+    }
+    assignValue(variableName, jsonValue) {
+        this.commands.push({
+            type: 'assignValue',
+            variableName,
+            jsonValue,
+        });
+    }
+    copyStream(sourceVar, targetVar, colmapVar = null) {
+        this.commands.push({
+            type: 'copyStream',
+            sourceVar,
+            targetVar,
+            colmapVar,
+        });
+    }
+    comment(text) {
+        this.commands.push({
+            type: 'comment',
+            text,
+        });
+    }
+    getScript(schedule = null) {
+        return {
+            type: 'json',
+            schedule,
+            commands: this.commands,
+            packageNames: this.packageNames,
+        };
+    }
+}
+exports.ScriptWriterJson = ScriptWriterJson;
+function jsonScriptToJavascript(json) {
+    const { schedule, commands, packageNames } = json;
+    const script = new ScriptWriter();
+    for (const packageName of packageNames) {
+        if (!/^dbgate-plugin-.*$/.test(packageName)) {
+            throw new Error('Unallowed package name:' + packageName);
+        }
+        script.packageNames.push(packageName);
+    }
+    for (const cmd of commands) {
+        switch (cmd.type) {
+            case 'assign':
+                script.assignCore(cmd.variableName, cmd.functionName, cmd.props);
+                break;
+            case 'assignValue':
+                script.assignValue(cmd.variableName, cmd.jsonValue);
+                break;
+            case 'copyStream':
+                script.copyStream(cmd.sourceVar, cmd.targetVar, cmd.colmapVar);
+                break;
+            case 'endLine':
+                script.endLine();
+                break;
+            case 'comment':
+                script.comment(cmd.text);
+                break;
+        }
+    }
+    return script.getScript(schedule);
+}
+exports.jsonScriptToJavascript = jsonScriptToJavascript;

package/lib/createBulkInsertStreamBase.js

@@ -25,7 +25,7 @@ function createBulkInsertStreamBase(driver, stream, pool, name, options) {
     writable.buffer = [];
     writable.structure = null;
     writable.columnNames = null;
-    writable.requireFixedStructure = !driver.dialect.nosql;
+    writable.requireFixedStructure = driver.databaseEngineTypes.includes('sql');
     writable.addRow = (row) => __awaiter(this, void 0, void 0, function* () {
         if (writable.structure) {
             writable.buffer.push(row);

package/lib/driverBase.d.ts

@@ -14,6 +14,7 @@ export declare const driverBase: {
             isPersisted: boolean;
         };
     };
+    databaseEngineTypes: string[];
     analyseFull(pool: any, version: any): Promise<any>;
     analyseSingleObject(pool: any, name: any, typeField?: string): Promise<any>;
     analyseSingleTable(pool: any, name: any): any;
@@ -24,4 +25,6 @@ export declare const driverBase: {
         label: string;
         sql: string;
     }[];
+    loadFieldValues(pool: any, name: any, columnName: any, search: any): Promise<any>;
+    readJsonQuery(pool: any, select: any, structure: any): any;
 };

package/lib/driverBase.js

@@ -8,10 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.driverBase = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
 const SqlDumper_1 = require("./SqlDumper");
 const dbgate_query_splitter_1 = require("dbgate-query-splitter");
+const dbgate_sqltree_1 = require("dbgate-sqltree");
 const dialect = {
     limitSelect: true,
     rangeSelect: true,
@@ -30,6 +35,7 @@ exports.driverBase = {
     analyserClass: null,
     dumperClass: SqlDumper_1.SqlDumper,
     dialect,
+    databaseEngineTypes: ['sql'],
     analyseFull(pool, version) {
         return __awaiter(this, void 0, void 0, function* () {
             const analyser = new this.analyserClass(pool, this, version);
@@ -62,10 +68,64 @@ exports.driverBase = {
         });
     },
     getNewObjectTemplates() {
-        var _a;
-        if (!((_a = this.dialect) === null || _a === void 0 ? void 0 : _a.nosql)) {
+        if (this.databaseEngineTypes.includes('sql')) {
             return [{ label: 'New view', sql: 'CREATE VIEW myview\nAS\nSELECT * FROM table1' }];
         }
         return [];
     },
+    loadFieldValues(pool, name, columnName, search) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dmp = this.createDumper();
+            const select = {
+                commandType: 'select',
+                distinct: true,
+                topRecords: 100,
+                from: {
+                    name,
+                },
+                columns: [
+                    {
+                        exprType: 'column',
+                        columnName,
+                        alias: 'value',
+                    },
+                ],
+                orderBy: [
+                    {
+                        exprType: 'column',
+                        columnName,
+                    },
+                ],
+            };
+            if (search) {
+                const tokens = (0, compact_1.default)(search.split(' ').map(x => x.trim()));
+                if (tokens.length > 0) {
+                    // @ts-ignore
+                    select.where = {
+                        conditionType: 'and',
+                        conditions: tokens.map(token => ({
+                            conditionType: 'like',
+                            left: {
+                                exprType: 'column',
+                                columnName,
+                            },
+                            right: {
+                                exprType: 'value',
+                                value: `%${token}%`,
+                            },
+                        })),
+                    };
+                }
+            }
+            // @ts-ignore
+            (0, dbgate_sqltree_1.dumpSqlSelect)(dmp, select);
+            const resp = yield this.query(pool, dmp.s);
+            return resp.rows;
+        });
+    },
+    readJsonQuery(pool, select, structure) {
+        const dmp = this.createDumper();
+        (0, dbgate_sqltree_1.dumpSqlSelect)(dmp, select);
+        return this.readQuery(pool, dmp.s, structure);
+    },
 };

package/lib/index.d.ts

@@ -17,3 +17,4 @@ export * from './yamlModelConv';
 export * from './stringTools';
 export * from './computeDiffRows';
 export * from './preloadedRowsTools';
+export * from './ScriptWriter';

package/lib/index.js

@@ -29,3 +29,4 @@ __exportStar(require("./yamlModelConv"), exports);
 __exportStar(require("./stringTools"), exports);
 __exportStar(require("./computeDiffRows"), exports);
 __exportStar(require("./preloadedRowsTools"), exports);
+__exportStar(require("./ScriptWriter"), exports);

package/lib/stringTools.d.ts

@@ -4,3 +4,4 @@ export declare function parseCellValue(value: any): any;
 export declare function stringifyCellValue(value: any): any;
 export declare function safeJsonParse(json: any, defaultValue?: any, logError?: boolean): any;
 export declare function isJsonLikeLongString(value: any): RegExpMatchArray;
+export declare function getIconForRedisType(type: any): "img folder" | "img type-string" | "img type-hash" | "img type-set" | "img type-list" | "img type-zset" | "img type-stream" | "img type-binary" | "img type-rejson";

package/lib/stringTools.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isJsonLikeLongString = exports.safeJsonParse = exports.stringifyCellValue = exports.parseCellValue = exports.hexStringToArray = exports.arrayToHexString = void 0;
+exports.getIconForRedisType = exports.isJsonLikeLongString = exports.safeJsonParse = exports.stringifyCellValue = exports.parseCellValue = exports.hexStringToArray = exports.arrayToHexString = void 0;
 const isString_1 = __importDefault(require("lodash/isString"));
 const isArray_1 = __importDefault(require("lodash/isArray"));
 const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
@@ -69,3 +69,28 @@ function isJsonLikeLongString(value) {
     return (0, isString_1.default)(value) && value.length > 100 && value.match(/^\s*\{.*\}\s*$|^\s*\[.*\]\s*$/);
 }
 exports.isJsonLikeLongString = isJsonLikeLongString;
+function getIconForRedisType(type) {
+    switch (type) {
+        case 'dir':
+            return 'img folder';
+        case 'string':
+            return 'img type-string';
+        case 'hash':
+            return 'img type-hash';
+        case 'set':
+            return 'img type-set';
+        case 'list':
+            return 'img type-list';
+        case 'zset':
+            return 'img type-zset';
+        case 'stream':
+            return 'img type-stream';
+        case 'binary':
+            return 'img type-binary';
+        case 'ReJSON-RL':
+            return 'img type-rejson';
+        default:
+            return null;
+    }
+}
+exports.getIconForRedisType = getIconForRedisType;

package/lib/testPermission.d.ts

@@ -1,2 +1,10 @@
-export declare function compilePermissions(permissions: string[] | string): RegExp[];
-export declare function testPermission(tested: string, permissions: RegExp[]): boolean;
+interface CompiledPermissionLevel {
+    re: RegExp;
+    type: 'allow' | 'deny';
+}
+interface CompiledPermissions {
+    levels: CompiledPermissionLevel[];
+}
+export declare function compilePermissions(permissions: string[] | string): CompiledPermissions;
+export declare function testPermission(tested: string, permissions: CompiledPermissions): boolean;
+export {};

package/lib/testPermission.js

@@ -6,21 +6,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.testPermission = exports.compilePermissions = void 0;
 const escapeRegExp_1 = __importDefault(require("lodash/escapeRegExp"));
 const isString_1 = __importDefault(require("lodash/isString"));
+const compact_1 = __importDefault(require("lodash/compact"));
+const flatten_1 = __importDefault(require("lodash/flatten"));
+function compileRegexp(permissions) {
+    if (permissions.length == 0)
+        return null;
+    return new RegExp(permissions.map(x => '^' + (0, escapeRegExp_1.default)(x).replace(/\\\*/g, '.*') + '$').join('|'));
+}
 function compilePermissions(permissions) {
     if (!permissions)
         return null;
     if ((0, isString_1.default)(permissions))
-        permissions = permissions.split(',');
-    return permissions.map(x => new RegExp('^' + (0, escapeRegExp_1.default)(x).replace(/\\\*/g, '.*') + '$'));
+        permissions = permissions.split(/,|;|\||\s/);
+    else
+        permissions = (0, flatten_1.default)(permissions.map(x => x.split(/,|;|\||\s/)));
+    permissions = (0, compact_1.default)(permissions.map(x => x.trim()));
+    let lastType = null;
+    let lastItems = [];
+    const res = {
+        levels: [],
+    };
+    for (const item of permissions) {
+        const type = item.startsWith('~') ? 'deny' : 'allow';
+        const perm = item.startsWith('~') ? item.substring(1) : item;
+        if (lastType != null && type != lastType) {
+            res.levels.push({
+                re: compileRegexp(lastItems),
+                type: lastType,
+            });
+            lastItems = [];
+        }
+        lastItems.push(perm);
+        lastType = type;
+    }
+    if (lastItems.length > 0) {
+        res.levels.push({
+            re: compileRegexp(lastItems),
+            type: lastType,
+        });
+    }
+    return res;
 }
 exports.compilePermissions = compilePermissions;
 function testPermission(tested, permissions) {
-    if (!permissions)
+    let allow = true;
+    if (!permissions) {
         return true;
-    for (const permission of permissions) {
-        if (tested.match(permission))
-            return true;
     }
-    return false;
+    for (const level of permissions.levels) {
+        if (tested.match(level.re)) {
+            if (level.type == 'allow')
+                allow = true;
+            if (level.type == 'deny')
+                allow = false;
+        }
+    }
+    return allow;
 }
 exports.testPermission = testPermission;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.7.3-alpha.5",
+  "version": "4.7.4-alpha.10",
   "name": "dbgate-tools",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -25,14 +25,15 @@
   ],
   "devDependencies": {
     "@types/node": "^13.7.0",
-    "dbgate-types": "^4.7.3-alpha.5",
+    "dbgate-types": "^4.7.4-alpha.10",
     "jest": "^24.9.0",
     "ts-jest": "^25.2.1",
     "typescript": "^4.4.3"
   },
   "dependencies": {
     "lodash": "^4.17.21",
-    "dbgate-query-splitter": "^4.7.3-alpha.5",
+    "dbgate-query-splitter": "^4.7.4-alpha.10",
+    "dbgate-sqltree": "^4.7.4-alpha.10",
     "uuid": "^3.4.0"
   }
 }