dbgate-tools/lib/dbKeysLoader.js

Auxiliary tools for other DbGate packages.

"use strict";
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_clearLoadedData = exports.dbKeys_createNewModel = exports.dbKeys_showNextItems = exports.dbKeys_markNodeExpanded = exports.dbKeys_mergeNextPage = exports.DB_KEYS_SHOW_INCREMENT = void 0;
const sortBy_1 = __importDefault(require("lodash/sortBy"));
exports.DB_KEYS_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,
//     },
//   };
// }
// export async function dbKeys_loadMissing(tree: DbKeysTreeModel, loader: DbKeysLoadFunction): Promise<DbKeysTreeModel> {
//   const childrenByKey = { ...tree.childrenByKey };
//   const dirsByKey = { ...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 = await loader(root, loadCount + 1);
//         childrenByKey[root] = items.slice(0, loadCount);
//         dirsByKey[root] = {
//           ...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] = {
//           ...dir,
//           shouldLoadNext: false,
//         };
//       }
//     }
//   }
//   return {
//     ...tree,
//     dirsByKey,
//     childrenByKey,
//     refreshAll: false,
//   };
// }
function dbKeys_mergeNextPage(tree, nextPage) {
    const keyObjectsByKey = { ...tree.keyObjectsByKey };
    for (const keyObj of nextPage.keys) {
        const keyPath = keyObj.key.split(tree.treeKeySeparator);
        keyObjectsByKey[keyObj.key] = {
            ...keyObj,
            level: keyPath.length,
            text: keyPath[keyPath.length - 1],
            sortKey: keyPath[keyPath.length - 1],
            keyPath,
            parentKey: keyPath.slice(0, -1).join(tree.treeKeySeparator),
        };
    }
    const dirsByKey = {};
    const childrenByKey = {};
    dirsByKey[''] = tree.root;
    for (const keyObj of Object.values(keyObjectsByKey)) {
        const dirPath = keyObj.keyPath.slice(0, -1);
        const dirKey = dirPath.join(tree.treeKeySeparator);
        let dirDepth = keyObj.keyPath.length - 1;
        while (dirDepth > 0) {
            const newDirPath = keyObj.keyPath.slice(0, dirDepth);
            const newDirKey = newDirPath.join(tree.treeKeySeparator);
            if (!dirsByKey[newDirKey]) {
                dirsByKey[newDirKey] = {
                    level: keyObj.level - 1,
                    keyPath: newDirPath,
                    parentKey: newDirPath.slice(0, -1).join(tree.treeKeySeparator),
                    type: 'dir',
                    key: newDirKey,
                    text: `${newDirPath[newDirPath.length - 1]}${tree.treeKeySeparator}*`,
                    sortKey: newDirPath[newDirPath.length - 1],
                };
            }
            dirDepth -= 1;
        }
        if (!childrenByKey[dirKey]) {
            childrenByKey[dirKey] = [];
        }
        childrenByKey[dirKey].push(keyObj);
    }
    for (const dirObj of Object.values(dirsByKey)) {
        if (dirObj.key == '') {
            continue;
        }
        if (!childrenByKey[dirObj.parentKey]) {
            childrenByKey[dirObj.parentKey] = [];
        }
        childrenByKey[dirObj.parentKey].push(dirObj);
        // set key count
        dirsByKey[dirObj.key].count = childrenByKey[dirObj.key].length;
    }
    for (const key in childrenByKey) {
        childrenByKey[key] = (0, sortBy_1.default)(childrenByKey[key], 'sortKey');
    }
    return {
        ...tree,
        cursor: nextPage.nextCursor,
        dirsByKey,
        childrenByKey,
        keyObjectsByKey,
        scannedKeys: tree.scannedKeys + tree.loadCount,
        loadedAll: nextPage.nextCursor == '0',
        dbsize: nextPage.dbsize,
    };
}
exports.dbKeys_mergeNextPage = dbKeys_mergeNextPage;
function dbKeys_markNodeExpanded(tree, root, isExpanded) {
    const node = tree.dirStateByKey[root];
    return {
        ...tree,
        dirStateByKey: {
            ...tree.dirStateByKey,
            [root]: {
                ...node,
                isExpanded,
            },
        },
    };
}
exports.dbKeys_markNodeExpanded = dbKeys_markNodeExpanded;
function dbKeys_showNextItems(tree, root) {
    var _a;
    const node = tree.dirStateByKey[root];
    return {
        ...tree,
        dirStateByKey: {
            ...tree.dirStateByKey,
            [root]: {
                ...node,
                visibleCount: ((_a = node === null || node === void 0 ? void 0 : node.visibleCount) !== null && _a !== void 0 ? _a : exports.DB_KEYS_SHOW_INCREMENT) + exports.DB_KEYS_SHOW_INCREMENT,
            },
        },
    };
}
exports.dbKeys_showNextItems = dbKeys_showNextItems;
function dbKeys_createNewModel(treeKeySeparator) {
    const root = {
        level: 0,
        type: 'dir',
        keyPath: [],
        parentKey: '',
        key: '',
        sortKey: '',
    };
    return {
        treeKeySeparator,
        childrenByKey: {},
        keyObjectsByKey: {},
        dirsByKey: {
            '': root,
        },
        dirStateByKey: {
            '': {
                key: '',
                visibleCount: exports.DB_KEYS_SHOW_INCREMENT,
                isExpanded: true,
            },
        },
        scannedKeys: 0,
        dbsize: 0,
        loadCount: 2000,
        cursor: '0',
        root,
        loadedAll: false,
    };
}
exports.dbKeys_createNewModel = dbKeys_createNewModel;
function dbKeys_clearLoadedData(tree) {
    return {
        ...tree,
        childrenByKey: {},
        keyObjectsByKey: {},
        dirsByKey: {
            '': tree.root,
        },
        scannedKeys: 0,
        dbsize: 0,
        cursor: '0',
        loadedAll: false,
    };
}
exports.dbKeys_clearLoadedData = dbKeys_clearLoadedData;
// export function dbKeys_reloadFolder(tree: DbKeysTreeModel, root: string): DbKeysTreeModel {
//   return {
//     ...tree,
//     childrenByKey: _omit(tree.childrenByKey, root),
//     dirsByKey: {
//       ...tree.dirsByKey,
//       [root]: {
//         ...tree.dirsByKey[root],
//         shouldLoadNext: true,
//         hasNext: undefined,
//       },
//     },
//   };
// }
function addFlatItems(tree, root, res, visitedRoots = []) {
    const item = tree.dirStateByKey[root];
    if (!(item === null || item === void 0 ? void 0 : item.isExpanded)) {
        return false;
    }
    const children = tree.childrenByKey[root] || [];
    for (const child of children) {
        res.push(child);
        if (child.type == 'dir') {
            if (visitedRoots.includes(child.key)) {
                console.warn('Redis: preventing infinite loop for root', child.key);
                return false;
            }
            addFlatItems(tree, child.key, res, [...visitedRoots, root]);
        }
    }
}
function dbKeys_getFlatList(tree) {
    const res = [];
    addFlatItems(tree, '', res);
    return res;
}
exports.dbKeys_getFlatList = dbKeys_getFlatList;