dbgate-tools
Version:
Auxiliary tools for other DbGate packages.
240 lines (239 loc) • 7.47 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.findSupportedRedisKeyType = exports.supportedRedisKeyTypes = exports.redis_getFlatList = exports.redis_clearLoadedData = exports.redis_createNewModel = exports.redis_showNextItems = exports.redis_markNodeExpanded = exports.redis_mergeNextPage = exports.DB_KEYS_SHOW_INCREMENT = void 0;
const sortBy_1 = __importDefault(require("lodash/sortBy"));
exports.DB_KEYS_SHOW_INCREMENT = 100;
function redis_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.redis_mergeNextPage = redis_mergeNextPage;
function redis_markNodeExpanded(tree, root, isExpanded) {
const node = tree.dirStateByKey[root];
return {
...tree,
dirStateByKey: {
...tree.dirStateByKey,
[root]: {
...node,
isExpanded,
},
},
};
}
exports.redis_markNodeExpanded = redis_markNodeExpanded;
function redis_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.redis_showNextItems = redis_showNextItems;
function redis_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.redis_createNewModel = redis_createNewModel;
function redis_clearLoadedData(tree) {
return {
...tree,
childrenByKey: {},
keyObjectsByKey: {},
dirsByKey: {
'': tree.root,
},
scannedKeys: 0,
dbsize: 0,
cursor: '0',
loadedAll: false,
};
}
exports.redis_clearLoadedData = redis_clearLoadedData;
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 redis_getFlatList(tree) {
const res = [];
addFlatItems(tree, '', res);
return res;
}
exports.redis_getFlatList = redis_getFlatList;
exports.supportedRedisKeyTypes = [
{
name: 'string',
label: 'String',
dbKeyFields: [{ name: 'value' }],
},
{
name: 'list',
label: 'List',
dbKeyFields: [{ name: 'value', cols: 12 }],
showItemList: true,
},
{
name: 'set',
label: 'Set',
dbKeyFields: [{ name: 'value', cols: 12 }],
keyColumn: 'value',
showItemList: true,
},
{
name: 'zset',
label: 'Sorted Set',
dbKeyFields: [
{ name: 'member', cols: 8 },
{ name: 'score', cols: 4 },
],
keyColumn: 'member',
showItemList: true,
},
{
name: 'hash',
label: 'Hash',
dbKeyFields: [
{ name: 'key', cols: 3, label: 'Field' },
{ name: 'value', cols: 7 },
{ name: 'ttl', cols: 2, label: 'TTL' },
],
keyColumn: 'key',
showItemList: true,
},
{
name: 'stream',
label: 'Stream',
dbKeyFields: [
{ name: 'field', cols: 6 },
{ name: 'value', cols: 6 },
],
dbKeyFieldsForGrid: [
{ name: 'id', cols: 6 },
{ name: 'value', cols: 6 },
],
keyColumn: 'id',
showItemList: true,
showGeneratedId: true,
},
{
name: 'json',
label: 'JSON',
dbKeyFields: [{ name: 'value' }],
},
];
function findSupportedRedisKeyType(type) {
return exports.supportedRedisKeyTypes.find(t => t.name === type);
}
exports.findSupportedRedisKeyType = findSupportedRedisKeyType;