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。

6.3 KB
Raw Blame
import type { KvKeySummary, KvValue } from "@/lib/backend/api";

export interface KvKeyTreeLeafNode {
  kind: "leaf";
  id: string;
  label: string;
  key: string;
  leadingSlash: boolean;
  keyIdentity?: string | null;
  keyBytes?: KvValue | null;
  pathSegments: string[];
  createRevision?: string | number | null;
  modRevision?: string | number | null;
  version?: string | number | null;
  lease?: string | number | null;
  valueSize?: number | null;
}

export interface KvKeyTreeGroupNode {
  kind: "group";
  id: string;
  label: string;
  leadingSlash: boolean;
  pathSegments: string[];
  children: KvKeyTreeNode[];
  key?: string;
  keyIdentity?: string | null;
  keyBytes?: KvValue | null;
  createRevision?: string | number | null;
  modRevision?: string | number | null;
  version?: string | number | null;
  lease?: string | number | null;
  valueSize?: number | null;
}

export type KvKeyTreeNode = KvKeyTreeLeafNode | KvKeyTreeGroupNode;

export interface KvKeyTreeRow {
  node: KvKeyTreeNode;
  depth: number;
}

function keyPath(key: string): { segments: string[]; leadingSlash: boolean } {
  return {
    segments: key.split("/").filter(Boolean),
    leadingSlash: key.startsWith("/"),
  };
}

function groupId(pathSegments: string[], leadingSlash: boolean): string {
  return `group:${leadingSlash ? "/" : ""}${pathSegments.join("\u0000")}`;
}

function nodePathIdentity(pathSegments: string[], leadingSlash: boolean): string {
  return `${leadingSlash ? "/" : ""}${pathSegments.join("\u0000")}`;
}

function treeLabel(segment: string, index: number, leadingSlash: boolean): string {
  return leadingSlash && index === 0 ? `/${segment}` : segment;
}

function summaryIdentity(key: KvKeySummary): string {
  return key.keyIdentity ?? key.key;
}

function leafId(key: KvKeySummary): string {
  return `leaf:${summaryIdentity(key)}`;
}

function sortNodes(nodes: KvKeyTreeNode[]): KvKeyTreeNode[] {
  return [...nodes]
    .sort((a, b) => {
      if (a.kind !== b.kind) return a.kind === "group" ? -1 : 1;
      return a.label.localeCompare(b.label);
    })
    .map((node) => (node.kind === "group" ? { ...node, children: sortNodes(node.children) } : node));
}

export function buildKvKeyTree(keys: KvKeySummary[]): KvKeyTreeNode[] {
  const root: KvKeyTreeNode[] = [];
  const groups = new Map<string, KvKeyTreeGroupNode>();

  for (const key of keys) {
    const { segments, leadingSlash } = keyPath(key.key);
    if (segments.length <= 1) {
      root.push({
        kind: "leaf",
        id: leafId(key),
        label: segments[0] ? treeLabel(segments[0], 0, leadingSlash) : key.key || "/",
        key: key.key,
        leadingSlash,
        keyIdentity: key.keyIdentity,
        keyBytes: key.keyBytes,
        pathSegments: segments,
        createRevision: key.createRevision,
        modRevision: key.modRevision,
        version: key.version,
        lease: key.lease,
        valueSize: key.valueSize,
      });
      continue;
    }

    let current = root;
    const groupSegments: string[] = [];
    for (const [index, segment] of segments.slice(0, -1).entries()) {
      groupSegments.push(segment);
      const id = groupId(groupSegments, leadingSlash);
      let group = groups.get(id);
      if (!group) {
        const leafIndex = current.findIndex((candidate) => candidate.kind === "leaf" && nodePathIdentity(candidate.pathSegments, candidate.leadingSlash) === nodePathIdentity(groupSegments, leadingSlash));
        const existingLeaf = leafIndex >= 0 ? (current.splice(leafIndex, 1)[0] as KvKeyTreeLeafNode) : null;
        group = {
          kind: "group",
          id,
          label: treeLabel(segment, index, leadingSlash),
          leadingSlash,
          pathSegments: [...groupSegments],
          children: [],
          key: existingLeaf?.key,
          keyIdentity: existingLeaf?.keyIdentity,
          keyBytes: existingLeaf?.keyBytes,
          createRevision: existingLeaf?.createRevision,
          modRevision: existingLeaf?.modRevision,
          version: existingLeaf?.version,
          lease: existingLeaf?.lease,
          valueSize: existingLeaf?.valueSize,
        };
        groups.set(id, group);
        current.push(group);
      }
      current = group.children;
    }

    const existingGroup = groups.get(groupId(segments, leadingSlash));
    if (existingGroup) {
      existingGroup.key = key.key;
      existingGroup.keyIdentity = key.keyIdentity;
      existingGroup.keyBytes = key.keyBytes;
      existingGroup.createRevision = key.createRevision;
      existingGroup.modRevision = key.modRevision;
      existingGroup.version = key.version;
      existingGroup.lease = key.lease;
      existingGroup.valueSize = key.valueSize;
      continue;
    }

    current.push({
      kind: "leaf",
      id: leafId(key),
      label: segments[segments.length - 1],
      key: key.key,
      leadingSlash,
      keyIdentity: key.keyIdentity,
      keyBytes: key.keyBytes,
      pathSegments: segments,
      createRevision: key.createRevision,
      modRevision: key.modRevision,
      version: key.version,
      lease: key.lease,
      valueSize: key.valueSize,
    });
  }

  return sortNodes(root);
}

export function collectKvGroupIds(nodes: KvKeyTreeNode[]): Set<string> {
  const ids = new Set<string>();
  const walk = (entries: KvKeyTreeNode[]) => {
    for (const node of entries) {
      if (node.kind !== "group") continue;
      ids.add(node.id);
      walk(node.children);
    }
  };
  walk(nodes);
  return ids;
}

export function preserveKvExpandedGroupIds(nodes: KvKeyTreeNode[], previous: ReadonlySet<string>, expandAll = false): Set<string> {
  const available = collectKvGroupIds(nodes);
  const next = new Set<string>();
  for (const id of expandAll ? available : previous) {
    if (available.has(id)) next.add(id);
  }
  return next;
}

export function flattenVisibleKvKeyTree(nodes: KvKeyTreeNode[], expandedGroupIds: ReadonlySet<string>, depth = 0): KvKeyTreeRow[] {
  const rows: KvKeyTreeRow[] = [];
  for (const node of nodes) {
    rows.push({ node, depth });
    if (node.kind === "group" && expandedGroupIds.has(node.id)) {
      rows.push(...flattenVisibleKvKeyTree(node.children, expandedGroupIds, depth + 1));
    }
  }
  return rows;
}

export function kvKeyTreeNodePath(node: KvKeyTreeNode): string {
  if (node.kind === "leaf") return node.key;
  if (node.key) return node.key;

  const joined = node.pathSegments.join("/");
  return node.leadingSlash ? `/${joined}` : joined;
}