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。

5.2 KB
Raw Blame
export interface SidebarDataOpenRequest {
  isCurrent: () => boolean;
  signal: AbortSignal;
  registerCancel: (cancel: () => void | Promise<void>) => void;
}

export interface SidebarDataOpenOptions {
  connectionKey: string;
  supersede?: boolean;
}

type OpenDataRunner = (request: SidebarDataOpenRequest) => void | Promise<void>;

interface QueuedOpen {
  id: number;
  connectionKey: string;
  superseding: boolean;
  controller: AbortController;
  runner: OpenDataRunner;
  cancel: (() => void | Promise<void>) | null;
  started: boolean;
  finished: boolean;
}

const DEFAULT_CONNECTION_KEY = "__sidebar__";
const MAX_ACTIVE_PER_CONNECTION = 1;

let nextRequestId = 0;
let latestSupersedingRequestId = 0;
const queuedByConnection = new Map<string, QueuedOpen[]>();
const activeCountByConnection = new Map<string, number>();
const requests = new Map<number, QueuedOpen>();

function runCancellation(cancel: (() => void | Promise<void>) | null) {
  if (!cancel) return;
  void Promise.resolve(cancel()).catch(() => undefined);
}

function isCurrent(request: QueuedOpen): boolean {
  if (request.finished || request.controller.signal.aborted) return false;
  return !request.superseding || request.id === latestSupersedingRequestId;
}

function removeQueuedRequest(request: QueuedOpen) {
  const queue = queuedByConnection.get(request.connectionKey);
  if (!queue) return;
  const index = queue.indexOf(request);
  if (index >= 0) queue.splice(index, 1);
  if (queue.length === 0) queuedByConnection.delete(request.connectionKey);
}

function cancelRequest(request: QueuedOpen) {
  if (request.finished) return;
  request.controller.abort();
  runCancellation(request.cancel);
  request.cancel = null;
  if (!request.started) {
    request.finished = true;
    removeQueuedRequest(request);
    requests.delete(request.id);
  }
}

function supersedeCurrentRequest() {
  const current = requests.get(latestSupersedingRequestId);
  if (current) cancelRequest(current);
}

function finishRequest(request: QueuedOpen) {
  if (request.finished) return;
  request.finished = true;
  request.cancel = null;
  requests.delete(request.id);
  const activeCount = activeCountByConnection.get(request.connectionKey) ?? 0;
  if (activeCount <= 1) activeCountByConnection.delete(request.connectionKey);
  else activeCountByConnection.set(request.connectionKey, activeCount - 1);
  drainConnection(request.connectionKey);
}

function executeRequest(request: QueuedOpen) {
  if (!isCurrent(request)) {
    cancelRequest(request);
    return;
  }

  request.started = true;
  activeCountByConnection.set(request.connectionKey, (activeCountByConnection.get(request.connectionKey) ?? 0) + 1);
  const openRequest: SidebarDataOpenRequest = {
    isCurrent: () => isCurrent(request),
    signal: request.controller.signal,
    registerCancel: (cancel) => {
      if (!isCurrent(request)) {
        runCancellation(cancel);
        return;
      }
      request.cancel = cancel;
    },
  };

  let result: void | Promise<void>;
  try {
    result = request.runner(openRequest);
  } catch {
    result = undefined;
  }
  void Promise.resolve(result)
    .catch(() => undefined)
    .finally(() => finishRequest(request));
}

function drainConnection(connectionKey: string) {
  if ((activeCountByConnection.get(connectionKey) ?? 0) >= MAX_ACTIVE_PER_CONNECTION) return;
  const queue = queuedByConnection.get(connectionKey);
  const request = queue?.shift();
  if (!request) {
    queuedByConnection.delete(connectionKey);
    return;
  }
  if (queue?.length === 0) queuedByConnection.delete(connectionKey);
  executeRequest(request);
}

function enqueueRequest(options: SidebarDataOpenOptions, runner: OpenDataRunner) {
  const superseding = options.supersede !== false;
  if (superseding) supersedeCurrentRequest();

  const request: QueuedOpen = {
    id: ++nextRequestId,
    connectionKey: options.connectionKey || DEFAULT_CONNECTION_KEY,
    superseding,
    controller: new AbortController(),
    runner,
    cancel: null,
    started: false,
    finished: false,
  };
  if (superseding) latestSupersedingRequestId = request.id;
  requests.set(request.id, request);
  const queue = queuedByConnection.get(request.connectionKey) ?? [];
  queue.push(request);
  queuedByConnection.set(request.connectionKey, queue);
  drainConnection(request.connectionKey);
}

export function runSidebarDataOpenImmediately(runner: OpenDataRunner): void;
export function runSidebarDataOpenImmediately(options: SidebarDataOpenOptions, runner: OpenDataRunner): void;
export function runSidebarDataOpenImmediately(optionsOrRunner: SidebarDataOpenOptions | OpenDataRunner, maybeRunner?: OpenDataRunner) {
  if (typeof optionsOrRunner === "function") {
    enqueueRequest({ connectionKey: DEFAULT_CONNECTION_KEY }, optionsOrRunner);
    return;
  }
  if (maybeRunner) enqueueRequest(optionsOrRunner, maybeRunner);
}

export function cancelPendingSidebarDataOpen() {
  for (const request of Array.from(requests.values())) cancelRequest(request);
  latestSupersedingRequestId = 0;
}

export function sidebarDataOpenDiagnostics() {
  return {
    activeTasks: [...activeCountByConnection.values()].reduce((total, count) => total + count, 0),
    queuedTasks: [...queuedByConnection.values()].reduce((total, queue) => total + queue.length, 0),
    trackedRequests: requests.size,
  };
}