Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

19.7 KB
Raw Blame
import type { RedisKeyInfo } from "@/lib/backend/api";

// A hierarchy duplicates key metadata and indexes; above this limit keep
// fuzzy results virtualized as flat rows instead of exhausting desktop memory.
export const REDIS_FUZZY_TREE_MAX_KEYS = 200_000;

export function canBuildRedisFuzzyTree(loadedKeyCount: number): boolean {
  return loadedKeyCount <= REDIS_FUZZY_TREE_MAX_KEYS;
}

/**
 * Membership of the "no expiry" filter.
 *
 * An unknown expiry means the expiry is *unknown*, not "it expires": rows
 * loaded without inline metadata (the "fetch all" sweep skips TYPE/TTL for
 * large keyspaces) must stay in the projection until a metadata backfill
 * resolves them. Dropping them here would silently hide every unresolved key
 * instead of showing it as "not yet known".
 *
 * The unknown TTL arrives in two shapes and both mean the same thing: the
 * payload leaves the field out entirely (`undefined`) and the Rust side uses
 * -2 as its "no answer" sentinel. They are normalised here so the predicate
 * and the metadata backfill agree on what "unresolved" looks like.
 */
export function redisKeyPassesNoExpiryFilter(key: Pick<RedisKeyInfo, "ttl">): boolean {
  const ttl = key.ttl ?? -2;
  return ttl === -1 || ttl === -2;
}

export interface RedisKeyTreeLeafNode {
  kind: "leaf";
  id: string;
  label: string;
  fullKeyDisplay: string;
  keyRaw: string;
  db: number;
  keyType: string;
  ttl: number;
  size: number;
  valuePreview: string;
  pathSegments: string[];
}

export interface RedisKeyTreeGroupNode {
  kind: "group";
  id: string;
  label: string;
  pathSegments: string[];
  children: RedisKeyTreeNode[];
  // The rendered count must not recursively walk an entire visible subtree.
  loadedLeafCount: number;
}

export type RedisKeyTreeNode = RedisKeyTreeLeafNode | RedisKeyTreeGroupNode;

export interface RedisKeyTreeRow {
  id: string;
  node: RedisKeyTreeNode;
  depth: number;
}

export interface RedisKeyTreeIndex {
  root: RedisKeyTreeNode[];
  groupById: Map<string, RedisKeyTreeGroupNode>;
  leafByKeyRaw: Map<string, RedisKeyTreeLeafNode>;
  ancestorGroupIdsByKeyRaw: Map<string, readonly string[]>;
}

export interface AppendRedisKeysResult {
  addedGroupIds: Set<string>;
}

export interface RedisKeySnapshot {
  flatKeys: RedisKeyInfo[];
  flatKeyByRaw: Map<string, RedisKeyInfo>;
  loadedKeyRaws: Set<string>;
  filteredKeyCount: number;
  treeIndex: RedisKeyTreeIndex | null;
  expandedGroupIds: Set<string>;
  visibleRows: RedisKeyTreeRow[];
}

export interface CooperativeRedisKeySnapshotOptions {
  /** Maximum records handled before yielding back to the browser. */
  workChunkSize?: number;
  /** Production yields to a paint-capable browser turn; tests inject a deterministic scheduler. */
  yieldControl?: () => Promise<void>;
  /** Checked before work, after every yield, and before returning the completed snapshot. */
  shouldContinue?: () => boolean;
}

export function redisKeyNameCopyText(node: RedisKeyTreeNode): string | null {
  // keyRaw is base64-encoded for backend roundtrips; copy the user-visible
  // Redis key name instead of the internal transport value.
  return node.kind === "leaf" ? node.fullKeyDisplay : null;
}

function buildGroupId(db: number, pathSegments: string[]): string {
  return `group:${db}:${JSON.stringify(pathSegments)}`;
}

function buildLeafId(db: number, keyRaw: string): string {
  return `leaf:${db}:${keyRaw}`;
}

export function redisKeyToFlatTreeRow(key: RedisKeyInfo, db: number): RedisKeyTreeRow {
  const nodeId = buildLeafId(db, key.key_raw);
  return {
    id: nodeId,
    node: {
      kind: "leaf",
      id: nodeId,
      label: key.key_display,
      fullKeyDisplay: key.key_display,
      keyRaw: key.key_raw,
      db,
      keyType: key.key_type ?? "",
      ttl: key.ttl ?? -2,
      size: key.size ?? 0,
      valuePreview: key.value_preview ?? "",
      pathSegments: [key.key_display],
    },
    depth: 0,
  };
}

function compareRedisTreeNodes(a: RedisKeyTreeNode, b: RedisKeyTreeNode): number {
  if (a.kind !== b.kind) return a.kind === "group" ? -1 : 1;
  return a.label.localeCompare(b.label);
}

function defaultYieldControl(): Promise<void> {
  return new Promise((resolve) => {
    if (typeof requestAnimationFrame === "function") {
      requestAnimationFrame(() => resolve());
      return;
    }
    setTimeout(resolve, 0);
  });
}

interface MutableTreeBuildState {
  index: RedisKeyTreeIndex;
  touchedLevels: Set<RedisKeyTreeNode[]>;
  addedGroupIds: Set<string>;
}

class CooperativeWorkController {
  private completedUnits = 0;

  constructor(
    readonly chunkSize: number,
    private readonly yieldControl: () => Promise<void>,
    private readonly shouldContinue: () => boolean,
  ) {}

  isActive(): boolean {
    return this.shouldContinue();
  }

  recordCompleted(units: number) {
    this.completedUnits += units;
  }

  needsYield(): boolean {
    return this.completedUnits >= this.chunkSize;
  }

  async yieldIfNeeded(): Promise<boolean> {
    if (!this.isActive()) return false;
    if (!this.needsYield()) return true;
    this.completedUnits = 0;
    await this.yieldControl();
    return this.isActive();
  }
}

function appendRedisKeyUnsorted(state: MutableTreeBuildState, key: RedisKeyInfo, db: number, separator: string) {
  const { index, touchedLevels, addedGroupIds } = state;
  if (index.leafByKeyRaw.has(key.key_raw)) return;

  const pathSegments = separator ? key.key_display.split(separator) : [key.key_display];
  const ancestorGroupIds: string[] = [];
  let currentLevel = index.root;

  if (pathSegments.length > 1) {
    const groupSegments: string[] = [];
    for (const segment of pathSegments.slice(0, -1)) {
      groupSegments.push(segment);
      const groupId = buildGroupId(db, groupSegments);
      let group = index.groupById.get(groupId);
      if (!group) {
        group = {
          kind: "group",
          id: groupId,
          label: segment,
          pathSegments: [...groupSegments],
          children: [],
          loadedLeafCount: 0,
        };
        index.groupById.set(groupId, group);
        currentLevel.push(group);
        touchedLevels.add(currentLevel);
        addedGroupIds.add(groupId);
      }
      group.loadedLeafCount++;
      ancestorGroupIds.push(groupId);
      currentLevel = group.children;
    }
  }

  const leaf: RedisKeyTreeLeafNode = {
    kind: "leaf",
    id: buildLeafId(db, key.key_raw),
    label: pathSegments[pathSegments.length - 1],
    fullKeyDisplay: key.key_display,
    keyRaw: key.key_raw,
    db,
    keyType: key.key_type ?? "",
    ttl: key.ttl ?? -2,
    size: key.size ?? 0,
    valuePreview: key.value_preview ?? "",
    pathSegments,
  };
  currentLevel.push(leaf);
  touchedLevels.add(currentLevel);
  index.leafByKeyRaw.set(key.key_raw, leaf);
  index.ancestorGroupIdsByKeyRaw.set(key.key_raw, ancestorGroupIds);
}

async function sortRedisTreeLevelCooperatively(nodes: RedisKeyTreeNode[], controller: CooperativeWorkController): Promise<boolean> {
  if (nodes.length < 2) {
    controller.recordCompleted(nodes.length);
    return controller.isActive();
  }

  let runs: RedisKeyTreeNode[][] = [];
  for (let offset = 0; offset < nodes.length; offset += controller.chunkSize) {
    if (!controller.isActive() || (controller.needsYield() && !(await controller.yieldIfNeeded()))) return false;
    const run = nodes.slice(offset, offset + controller.chunkSize);
    run.sort(compareRedisTreeNodes);
    runs.push(run);
    controller.recordCompleted(run.length);
  }

  while (runs.length > 1) {
    const mergedRuns: RedisKeyTreeNode[][] = [];
    for (let runIndex = 0; runIndex < runs.length; runIndex += 2) {
      const left = runs[runIndex];
      const right = runs[runIndex + 1];
      if (!right) {
        mergedRuns.push(left);
        continue;
      }

      const merged: RedisKeyTreeNode[] = [];
      merged.length = left.length + right.length;
      let leftIndex = 0;
      let rightIndex = 0;
      let outputIndex = 0;
      while (leftIndex < left.length || rightIndex < right.length) {
        if (!controller.isActive() || (controller.needsYield() && !(await controller.yieldIfNeeded()))) return false;
        const start = outputIndex;
        const end = Math.min(outputIndex + controller.chunkSize, merged.length);
        while (outputIndex < end) {
          if (rightIndex >= right.length || (leftIndex < left.length && compareRedisTreeNodes(left[leftIndex], right[rightIndex]) <= 0)) {
            merged[outputIndex++] = left[leftIndex++];
          } else {
            merged[outputIndex++] = right[rightIndex++];
          }
        }
        controller.recordCompleted(outputIndex - start);
      }
      mergedRuns.push(merged);
    }
    runs = mergedRuns;
  }

  const sorted = runs[0];
  for (let offset = 0; offset < sorted.length; offset += controller.chunkSize) {
    if (!controller.isActive() || (controller.needsYield() && !(await controller.yieldIfNeeded()))) return false;
    const end = Math.min(offset + controller.chunkSize, sorted.length);
    for (let index = offset; index < end; index++) nodes[index] = sorted[index];
    controller.recordCompleted(end - offset);
  }
  return controller.isActive();
}

async function flattenVisibleRedisKeyTreeCooperatively(nodes: RedisKeyTreeNode[], expandedGroupIds: ReadonlySet<string>, controller: CooperativeWorkController): Promise<RedisKeyTreeRow[] | null> {
  const rows: RedisKeyTreeRow[] = [];
  const stack: Array<{ nodes: RedisKeyTreeNode[]; nextIndex: number; depth: number }> = [{ nodes, nextIndex: 0, depth: 0 }];

  while (stack.length > 0) {
    if (!controller.isActive() || (controller.needsYield() && !(await controller.yieldIfNeeded()))) return null;
    const start = rows.length;
    const end = rows.length + controller.chunkSize;
    while (stack.length > 0 && rows.length < end) {
      const frame = stack[stack.length - 1];
      if (frame.nextIndex >= frame.nodes.length) {
        stack.pop();
        continue;
      }
      const node = frame.nodes[frame.nextIndex++];
      rows.push({ id: node.id, node, depth: frame.depth });
      if (node.kind === "group" && expandedGroupIds.has(node.id) && node.children.length > 0) {
        // Keep only a cursor for the child collection. Pushing every child of
        // one expanded million-key group would itself be an unbounded O(N)
        // task before the outer cooperative loop gets another yield point.
        stack.push({ nodes: node.children, nextIndex: 0, depth: frame.depth + 1 });
      }
    }
    controller.recordCompleted(rows.length - start);
  }
  return controller.isActive() ? rows : null;
}

/**
 * Builds the complete Fetch All snapshot without exposing partially-built
 * structures to Vue. Every linear stage is divided into bounded work units so
 * the browser can paint and dispatch input between them.
 */
export async function buildRedisKeySnapshotCooperatively(
  keyBatches: readonly (readonly RedisKeyInfo[])[],
  config: {
    db: number;
    separator?: string;
    flatRows: boolean;
    expandAll: boolean;
    expandedGroupIds: ReadonlySet<string>;
    noExpiryOnly?: boolean;
  },
  options: CooperativeRedisKeySnapshotOptions = {},
): Promise<RedisKeySnapshot | null> {
  const chunkSize = Math.max(1, options.workChunkSize ?? 25_000);
  const yieldControl = options.yieldControl ?? defaultYieldControl;
  const shouldContinue = options.shouldContinue ?? (() => true);
  const controller = new CooperativeWorkController(chunkSize, yieldControl, shouldContinue);
  const separator = config.separator ?? ":";
  if (!shouldContinue()) return null;

  const flatKeys: RedisKeyInfo[] = [];
  const flatKeyByRaw = new Map<string, RedisKeyInfo>();
  const loadedKeyRaws = new Set<string>();
  let filteredKeyCount = 0;
  const treeState: MutableTreeBuildState | null = config.flatRows
    ? null
    : {
        index: { root: [], groupById: new Map(), leafByKeyRaw: new Map(), ancestorGroupIdsByKeyRaw: new Map() },
        touchedLevels: new Set(),
        addedGroupIds: new Set(),
      };
  const filteredTreeState: MutableTreeBuildState | null =
    !config.flatRows && config.noExpiryOnly
      ? {
          index: { root: [], groupById: new Map(), leafByKeyRaw: new Map(), ancestorGroupIdsByKeyRaw: new Map() },
          touchedLevels: new Set(),
          addedGroupIds: new Set(),
        }
      : null;

  for (const batch of keyBatches) {
    for (let offset = 0; offset < batch.length; offset += chunkSize) {
      if (!controller.isActive() || (controller.needsYield() && !(await controller.yieldIfNeeded()))) return null;
      const end = Math.min(offset + chunkSize, batch.length);
      for (let index = offset; index < end; index++) {
        const key = batch[index];
        if (flatKeyByRaw.has(key.key_raw)) continue;
        flatKeyByRaw.set(key.key_raw, key);
        loadedKeyRaws.add(key.key_raw);
        flatKeys.push(key);
        if (!config.noExpiryOnly || redisKeyPassesNoExpiryFilter(key)) filteredKeyCount++;
        if (treeState) appendRedisKeyUnsorted(treeState, key, config.db, separator);
        if (filteredTreeState && redisKeyPassesNoExpiryFilter(key)) appendRedisKeyUnsorted(filteredTreeState, key, config.db, separator);
      }
      controller.recordCompleted(end - offset);
    }
  }

  for (const state of [treeState, filteredTreeState]) {
    if (!state) continue;
    for (const level of state.touchedLevels) {
      if (level.length <= controller.chunkSize) {
        if (!controller.isActive() || (controller.needsYield() && !(await controller.yieldIfNeeded()))) return null;
        if (level.length > 1) level.sort(compareRedisTreeNodes);
        controller.recordCompleted(level.length);
        continue;
      }
      if (!(await sortRedisTreeLevelCooperatively(level, controller))) return null;
    }
  }

  const treeIndex = treeState?.index ?? null;
  const expandedGroupIds = new Set<string>();
  if (treeIndex) {
    if (config.expandAll) {
      for (const id of treeIndex.groupById.keys()) {
        if (controller.needsYield() && !(await controller.yieldIfNeeded())) return null;
        expandedGroupIds.add(id);
        controller.recordCompleted(1);
      }
    } else {
      for (const id of config.expandedGroupIds) {
        if (controller.needsYield() && !(await controller.yieldIfNeeded())) return null;
        if (treeIndex.groupById.has(id)) expandedGroupIds.add(id);
        controller.recordCompleted(1);
      }
    }
  }

  let visibleRows: RedisKeyTreeRow[];
  if (config.flatRows) {
    visibleRows = [];
    for (let offset = 0; offset < flatKeys.length; offset += chunkSize) {
      if (!controller.isActive() || (controller.needsYield() && !(await controller.yieldIfNeeded()))) return null;
      const end = Math.min(offset + chunkSize, flatKeys.length);
      for (let index = offset; index < end; index++) {
        const key = flatKeys[index];
        if (!config.noExpiryOnly || redisKeyPassesNoExpiryFilter(key)) visibleRows.push(redisKeyToFlatTreeRow(key, config.db));
      }
      controller.recordCompleted(end - offset);
    }
  } else {
    const visibleTree = filteredTreeState?.index.root ?? treeIndex?.root ?? [];
    const rows = await flattenVisibleRedisKeyTreeCooperatively(visibleTree, expandedGroupIds, controller);
    if (!rows) return null;
    visibleRows = rows;
  }

  if (!shouldContinue()) return null;
  return { flatKeys, flatKeyByRaw, loadedKeyRaws, filteredKeyCount, treeIndex, expandedGroupIds, visibleRows };
}

function redisKeyInfoFromLeaf(node: RedisKeyTreeLeafNode): RedisKeyInfo {
  return {
    key_display: node.fullKeyDisplay,
    key_raw: node.keyRaw,
    key_type: node.keyType,
    ttl: node.ttl,
    size: node.size,
    value_preview: node.valuePreview,
  };
}

export function createRedisKeyTreeIndex(keys: readonly RedisKeyInfo[], db: number, separator = ":"): RedisKeyTreeIndex {
  const index: RedisKeyTreeIndex = {
    root: [],
    groupById: new Map(),
    leafByKeyRaw: new Map(),
    ancestorGroupIdsByKeyRaw: new Map(),
  };
  appendRedisKeysToTreeIndex(index, keys, db, separator);
  return index;
}

/**
 * Inserts one SCAN batch while sorting only sibling arrays changed by that
 * batch. This keeps repeated "load more" merges from re-sorting the full tree.
 */
export function appendRedisKeysToTreeIndex(index: RedisKeyTreeIndex, keys: readonly RedisKeyInfo[], db: number, separator = ":"): AppendRedisKeysResult {
  const state: MutableTreeBuildState = { index, touchedLevels: new Set(), addedGroupIds: new Set() };
  for (const key of keys) appendRedisKeyUnsorted(state, key, db, separator);
  for (const nodes of state.touchedLevels) nodes.sort(compareRedisTreeNodes);
  return { addedGroupIds: state.addedGroupIds };
}

/**
 * Refreshes metadata for an existing tree leaf without changing namespace
 * identity, hierarchy, ordering, or aggregate counts.
 */
export function updateRedisKeyTreeLeafMetadata(index: RedisKeyTreeIndex, key: RedisKeyInfo): boolean {
  const leaf = index.leafByKeyRaw.get(key.key_raw);
  if (!leaf) return false;

  leaf.keyType = key.key_type ?? "";
  leaf.ttl = key.ttl ?? -2;
  leaf.size = key.size ?? 0;
  leaf.valuePreview = key.value_preview ?? "";
  return true;
}

/**
 * Refreshes metadata on the canonical flat-list record through its identity
 * index. The existing object is retained so large shallow collections do not
 * need to be copied for a single-key refresh.
 */
export function updateRedisKeyInfoMetadataByRaw(keyByRaw: ReadonlyMap<string, RedisKeyInfo>, key: RedisKeyInfo): boolean {
  const existing = keyByRaw.get(key.key_raw);
  if (!existing) return false;

  existing.key_type = key.key_type;
  existing.ttl = key.ttl;
  existing.size = key.size;
  existing.value_preview = key.value_preview;
  return true;
}

export function buildRedisKeyTree(keys: RedisKeyInfo[], db: number, separator = ":"): RedisKeyTreeNode[] {
  return createRedisKeyTreeIndex(keys, db, separator).root;
}

export function mergeKeysIntoRedisKeyTree(existingTree: RedisKeyTreeNode[], newKeys: RedisKeyInfo[], db: number, separator = ":"): RedisKeyTreeNode[] {
  const existingKeys: RedisKeyInfo[] = [];
  const stack = [...existingTree];
  while (stack.length > 0) {
    const node = stack.pop()!;
    if (node.kind === "leaf") {
      existingKeys.push(redisKeyInfoFromLeaf(node));
    } else {
      for (const child of node.children) stack.push(child);
    }
  }

  const index = createRedisKeyTreeIndex(existingKeys, db, separator);
  appendRedisKeysToTreeIndex(index, newKeys, db, separator);
  return index.root;
}

export function collectExpandedGroupIds(nodes: RedisKeyTreeNode[]): Set<string> {
  const ids = new Set<string>();
  const stack = [...nodes];
  while (stack.length > 0) {
    const node = stack.pop()!;
    if (node.kind !== "group") continue;
    ids.add(node.id);
    for (const child of node.children) stack.push(child);
  }
  return ids;
}

export function collectRedisGroupKeyRaws(group: RedisKeyTreeGroupNode): string[] {
  const keyRaws: string[] = [];
  const stack = [...group.children].reverse();
  while (stack.length > 0) {
    const node = stack.pop()!;
    if (node.kind === "leaf") {
      keyRaws.push(node.keyRaw);
    } else {
      // Push in reverse so the iterative walk keeps the rendered tree order.
      for (let index = node.children.length - 1; index >= 0; index--) {
        stack.push(node.children[index]);
      }
    }
  }
  return keyRaws;
}

export function flattenVisibleRedisKeyTree(nodes: RedisKeyTreeNode[], expandedGroupIds: ReadonlySet<string>, depth = 0): RedisKeyTreeRow[] {
  const rows: RedisKeyTreeRow[] = [];
  const stack: RedisKeyTreeRow[] = [];

  for (let index = nodes.length - 1; index >= 0; index--) {
    stack.push({ id: nodes[index].id, node: nodes[index], depth });
  }

  while (stack.length > 0) {
    const row = stack.pop()!;
    rows.push(row);

    if (row.node.kind !== "group" || !expandedGroupIds.has(row.node.id)) continue;

    const childDepth = row.depth + 1;
    for (let index = row.node.children.length - 1; index >= 0; index--) {
      const child = row.node.children[index];
      stack.push({ id: child.id, node: child, depth: childDepth });
    }
  }

  return rows;
}