dbgate-tools 6.1.3 → 6.1.4

package/lib/SqlGenerator.js

@@ -237,7 +237,8 @@ class SqlGenerator {
         });
     }
     extract(objectTypeField) {
-        return this.dbinfo[objectTypeField].filter(x => this.objects.find(y => x.pureName == y.pureName && x.schemaName == y.schemaName && y.objectTypeField == objectTypeField));
+        var _a, _b;
+        return ((_b = (_a = this.dbinfo[objectTypeField]) === null || _a === void 0 ? void 0 : _a.filter(x => this.objects.find(y => x.pureName == y.pureName && x.schemaName == y.schemaName && y.objectTypeField == objectTypeField))) !== null && _b !== void 0 ? _b : []);
     }
     enableConstraints(enabled) {
         if (this.options.disableConstraints) {

package/lib/dbKeysLoader.d.ts

@@ -0,0 +1,35 @@
+export interface DbKeysNodeModelBase {
+    text?: string;
+    count?: number;
+    level: number;
+}
+export interface DbKeysLeafNodeModel extends DbKeysNodeModelBase {
+    key: string;
+    type: 'string' | 'hash' | 'set' | 'list' | 'zset' | 'stream' | 'binary' | 'ReJSON-RL';
+}
+export interface DbKeysFolderNodeModel extends DbKeysNodeModelBase {
+    root: string;
+    type: 'dir';
+    maxShowCount?: number;
+    isExpanded?: boolean;
+    shouldLoadNext?: boolean;
+    hasNext?: boolean;
+}
+export interface DbKeysTreeModel {
+    root: DbKeysFolderNodeModel;
+    dirsByKey: {
+        [key: string]: DbKeysFolderNodeModel;
+    };
+    childrenByKey: {
+        [key: string]: DbKeysNodeModel[];
+    };
+    refreshAll?: boolean;
+}
+export type DbKeysNodeModel = DbKeysLeafNodeModel | DbKeysFolderNodeModel;
+export type DbKeysLoadFunction = (root: string, limit: number) => Promise<DbKeysNodeModel[]>;
+export type DbKeysChangeModelFunction = (func: (model: DbKeysTreeModel) => DbKeysTreeModel) => void;
+export declare function dbKeys_loadMissing(tree: DbKeysTreeModel, loader: DbKeysLoadFunction): Promise<DbKeysTreeModel>;
+export declare function dbKeys_markNodeExpanded(tree: DbKeysTreeModel, root: string, isExpanded: boolean): DbKeysTreeModel;
+export declare function dbKeys_refreshAll(tree?: DbKeysTreeModel): DbKeysTreeModel;
+export declare function dbKeys_reloadFolder(tree: DbKeysTreeModel, root: string): DbKeysTreeModel;
+export declare function dbKeys_getFlatList(tree: DbKeysTreeModel): DbKeysNodeModel[];

package/lib/dbKeysLoader.js

@@ -0,0 +1,132 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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.dbKeys_getFlatList = exports.dbKeys_reloadFolder = exports.dbKeys_refreshAll = exports.dbKeys_markNodeExpanded = exports.dbKeys_loadMissing = void 0;
+const omit_1 = __importDefault(require("lodash/omit"));
+const SHOW_INCREMENT = 100;
+// function dbKeys_findFolderNode(node: DbKeysNodeModel, root: string) {
+//   if (node.type != 'dir') {
+//     return null;
+//   }
+//   if (node.root === root) {
+//     return node;
+//   }
+//   for (const child of node.children ?? []) {
+//     const res = dbKeys_findFolderNode(child, root);
+//     if (res) {
+//       return res;
+//     }
+//   }
+//   return null;
+// }
+// export async function dbKeys_loadKeysFromNode(
+//   tree: DbKeysTreeModel,
+//   callingRoot: string,
+//   separator: string,
+//   loader: DbKeysLoadFunction
+// ): Promise<DbKeysTreeModel> {
+//   const callingRootNode = tree.dirsByKey[callingRoot];
+//   if (!callingRootNode) {
+//     return tree;
+//   }
+//   const newItems = await loader(callingRoot, callingRootNode.maxShowCount ?? SHOW_INCREMENT);
+//   return {
+//     ...tree,
+//     childrenByKey: {
+//       ...tree.childrenByKey,
+//       [callingRoot]: newItems,
+//     },
+//   };
+// }
+function dbKeys_loadMissing(tree, loader) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const childrenByKey = Object.assign({}, tree.childrenByKey);
+        const dirsByKey = Object.assign({}, tree.dirsByKey);
+        for (const root in tree.dirsByKey) {
+            const dir = tree.dirsByKey[root];
+            if (dir.isExpanded && dir.shouldLoadNext) {
+                if (!tree.childrenByKey[root] || dir.hasNext) {
+                    const loadCount = dir.maxShowCount && dir.shouldLoadNext ? dir.maxShowCount + SHOW_INCREMENT : SHOW_INCREMENT;
+                    const items = yield loader(root, loadCount + 1);
+                    childrenByKey[root] = items.slice(0, loadCount);
+                    dirsByKey[root] = Object.assign(Object.assign({}, dir), { shouldLoadNext: false, maxShowCount: loadCount, hasNext: items.length > loadCount });
+                    for (const child of items.slice(0, loadCount)) {
+                        if (child.type == 'dir' && !dirsByKey[child.root]) {
+                            dirsByKey[child.root] = {
+                                shouldLoadNext: false,
+                                maxShowCount: null,
+                                hasNext: false,
+                                isExpanded: false,
+                                type: 'dir',
+                                level: dir.level + 1,
+                                root: child.root,
+                                text: child.text,
+                            };
+                        }
+                    }
+                }
+                else {
+                    dirsByKey[root] = Object.assign(Object.assign({}, dir), { shouldLoadNext: false });
+                }
+            }
+        }
+        return Object.assign(Object.assign({}, tree), { dirsByKey,
+            childrenByKey, refreshAll: false });
+    });
+}
+exports.dbKeys_loadMissing = dbKeys_loadMissing;
+function dbKeys_markNodeExpanded(tree, root, isExpanded) {
+    const node = tree.dirsByKey[root];
+    if (!node) {
+        return tree;
+    }
+    return Object.assign(Object.assign({}, tree), { dirsByKey: Object.assign(Object.assign({}, tree.dirsByKey), { [root]: Object.assign(Object.assign({}, node), { isExpanded, shouldLoadNext: isExpanded }) }) });
+}
+exports.dbKeys_markNodeExpanded = dbKeys_markNodeExpanded;
+function dbKeys_refreshAll(tree) {
+    const root = {
+        isExpanded: true,
+        level: 0,
+        root: '',
+        type: 'dir',
+        shouldLoadNext: true,
+    };
+    return Object.assign(Object.assign({}, tree), { childrenByKey: {}, dirsByKey: {
+            '': root,
+        }, refreshAll: true, root });
+}
+exports.dbKeys_refreshAll = dbKeys_refreshAll;
+function dbKeys_reloadFolder(tree, root) {
+    return Object.assign(Object.assign({}, tree), { childrenByKey: (0, omit_1.default)(tree.childrenByKey, root), dirsByKey: Object.assign(Object.assign({}, tree.dirsByKey), { [root]: Object.assign(Object.assign({}, tree.dirsByKey[root]), { shouldLoadNext: true, hasNext: undefined }) }) });
+}
+exports.dbKeys_reloadFolder = dbKeys_reloadFolder;
+function addFlatItems(tree, root, res) {
+    const item = tree.dirsByKey[root];
+    if (!item.isExpanded) {
+        return false;
+    }
+    const children = tree.childrenByKey[root] || [];
+    for (const child of children) {
+        res.push(child);
+        if (child.type == 'dir') {
+            addFlatItems(tree, child.root, res);
+        }
+    }
+}
+function dbKeys_getFlatList(tree) {
+    const res = [];
+    addFlatItems(tree, '', res);
+    return res;
+}
+exports.dbKeys_getFlatList = dbKeys_getFlatList;

package/lib/index.d.ts

@@ -24,3 +24,4 @@ export * from './getConnectionLabel';
 export * from './detectSqlFilterBehaviour';
 export * from './filterBehaviours';
 export * from './schemaInfoTools';
+export * from './dbKeysLoader';

package/lib/index.js

@@ -40,3 +40,4 @@ __exportStar(require("./getConnectionLabel"), exports);
 __exportStar(require("./detectSqlFilterBehaviour"), exports);
 __exportStar(require("./filterBehaviours"), exports);
 __exportStar(require("./schemaInfoTools"), exports);
+__exportStar(require("./dbKeysLoader"), exports);

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "6.1.3",
+  "version": "6.1.4",
   "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.1.3",
+    "dbgate-types": "^6.1.4",
     "jest": "^24.9.0",
     "ts-jest": "^25.2.1",
     "typescript": "^4.4.3"
   },
   "dependencies": {
     "dbgate-query-splitter": "^4.11.3",
-    "dbgate-sqltree": "^6.1.3",
+    "dbgate-sqltree": "^6.1.4",
     "debug": "^4.3.4",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.21",