dbgate-tools 4.7.4-alpha.1 → 4.7.4-alpha.14

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

@@ -26,4 +26,5 @@ export declare const driverBase: {
         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

@@ -123,4 +123,9 @@ exports.driverBase = {
             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/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.4-alpha.1",
+  "version": "4.7.4-alpha.14",
   "name": "dbgate-tools",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -25,15 +25,15 @@
   ],
   "devDependencies": {
     "@types/node": "^13.7.0",
-    "dbgate-types": "^4.7.4-alpha.1",
+    "dbgate-types": "^4.7.4-alpha.14",
     "jest": "^24.9.0",
     "ts-jest": "^25.2.1",
     "typescript": "^4.4.3"
   },
   "dependencies": {
     "lodash": "^4.17.21",
-    "dbgate-query-splitter": "^4.7.4-alpha.1",
-    "dbgate-sqltree": "^4.7.4-alpha.1",
+    "dbgate-query-splitter": "^4.7.4-alpha.14",
+    "dbgate-sqltree": "^4.7.4-alpha.14",
     "uuid": "^3.4.0"
   }
 }