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 { ConnectionConfig, ConnectionTestResult, DatabaseConnectionInfo, IdentifierCase } from "@/types/database";

export type DatabaseInfoField = Exclude<keyof DatabaseConnectionInfo, "compatibilityMode">;

export interface DatabaseInfoRow {
  key: DatabaseInfoField;
  value: string;
}

// These connections have no real database metadata. VictoriaMetrics exposes a
// configured label as a synthetic database node, not a server database.
const DATABASE_INFO_UNSUPPORTED_TYPES = new Set<ConnectionConfig["db_type"]>(["dynamodb", "elasticsearch", "easysearch", "meilisearch", "solr", "qdrant", "weaviate", "chromadb", "etcd", "zookeeper", "nacos", "consul", "mq", "mqtt", "victoriametrics"]);

export function supportsConnectionDatabaseInfo(dbType: ConnectionConfig["db_type"]): boolean {
  return !DATABASE_INFO_UNSUPPORTED_TYPES.has(dbType);
}

const DATABASE_INFO_FIELDS: readonly DatabaseInfoField[] = ["productName", "productVersion", "currentDatabase", "serverComment", "serverCharset", "serverCollation", "unquotedIdentifierCase", "quotedIdentifierCase", "driverName", "driverVersion", "jdbcVersion"];
const IDENTIFIER_CASES = new Set<IdentifierCase>(["lower", "upper", "mixed"]);

function isRecord(value: unknown): value is Record<string, unknown> {
  return !!value && typeof value === "object" && !Array.isArray(value);
}

function nonBlankString(value: unknown): string | undefined {
  if (typeof value !== "string") return undefined;
  const trimmed = value.trim();
  return trimmed || undefined;
}

function identifierCase(value: unknown): IdentifierCase | undefined {
  const normalized = nonBlankString(value)?.toLowerCase() as IdentifierCase | undefined;
  return normalized && IDENTIFIER_CASES.has(normalized) ? normalized : undefined;
}

export function configuredDatabaseProductName(config: Pick<ConnectionConfig, "db_type" | "driver_label">): string {
  return config.driver_label?.trim() || config.db_type;
}

export function normalizeDatabaseConnectionInfo(value: unknown, fallbackProductName?: string, fallbackCurrentDatabase?: string): DatabaseConnectionInfo | undefined {
  const source = isRecord(value) ? value : {};
  const result: DatabaseConnectionInfo = {
    compatibilityMode: nonBlankString(source.compatibilityMode),
    productName: nonBlankString(source.productName) ?? nonBlankString(fallbackProductName),
    productVersion: nonBlankString(source.productVersion),
    currentDatabase: nonBlankString(source.currentDatabase) ?? nonBlankString(fallbackCurrentDatabase),
    serverComment: nonBlankString(source.serverComment),
    serverCharset: nonBlankString(source.serverCharset),
    serverCollation: nonBlankString(source.serverCollation),
    unquotedIdentifierCase: identifierCase(source.unquotedIdentifierCase),
    quotedIdentifierCase: identifierCase(source.quotedIdentifierCase),
    driverName: nonBlankString(source.driverName),
    driverVersion: nonBlankString(source.driverVersion),
    jdbcVersion: nonBlankString(source.jdbcVersion),
  };
  return result.compatibilityMode || DATABASE_INFO_FIELDS.some((key) => result[key] !== undefined) ? result : undefined;
}

export function normalizeConnectionTestResult(value: unknown, config: ConnectionConfig): ConnectionTestResult {
  const fallbackProductName = configuredDatabaseProductName(config);
  const fallbackCurrentDatabase = config.database;
  if (typeof value === "string") {
    return {
      message: value,
      databaseInfo: normalizeDatabaseConnectionInfo(undefined, fallbackProductName, fallbackCurrentDatabase),
    };
  }
  if (!isRecord(value) || typeof value.message !== "string") {
    throw new Error("Invalid connection test response");
  }
  return {
    message: value.message,
    databaseInfo: normalizeDatabaseConnectionInfo(value.databaseInfo, fallbackProductName, fallbackCurrentDatabase),
  };
}

function stableValue(value: unknown): unknown {
  if (Array.isArray(value)) return value.map(stableValue);
  if (!isRecord(value)) return value;
  const result: Record<string, unknown> = {};
  for (const key of Object.keys(value).sort()) {
    const child = value[key];
    if (child !== undefined) result[key] = stableValue(child);
  }
  return result;
}

function fnv1a(value: string, seed: number): number {
  let hash = seed >>> 0;
  for (let index = 0; index < value.length; index += 1) {
    hash ^= value.charCodeAt(index);
    hash = Math.imul(hash, 0x01000193);
  }
  return hash >>> 0;
}

export function connectionConfigFingerprint(config: ConnectionConfig, sourceName = config.name): string {
  const {
    database_info: _databaseInfo,
    default_schema: _defaultSchema,
    note: _note,
    show_database_links: _showDatabaseLinks,
    show_native_jobs: _showNativeJobs,
    show_user_admin: _showUserAdmin,
    sidebar_auto_load_all_tables: _sidebarAutoLoadAllTables,
    redis_key_filter: _redisKeyFilter,
    jdbc_dialect: _jdbcDialect,
    ...submittedConfig
  } = config;
  const serialized = JSON.stringify(stableValue({ config: submittedConfig, sourceName }));
  const first = fnv1a(serialized, 0x811c9dc5).toString(16).padStart(8, "0");
  const second = fnv1a(serialized, 0x9e3779b9).toString(16).padStart(8, "0");
  return `${first}${second}`;
}

export function databaseInfoRows(info: DatabaseConnectionInfo): DatabaseInfoRow[] {
  return DATABASE_INFO_FIELDS.flatMap((key) => {
    const value = info[key];
    return value ? [{ key, value }] : [];
  });
}

export function databaseInfoSummary(info: DatabaseConnectionInfo): string {
  return [info.productName, info.productVersion].filter(Boolean).join(" ");
}

export function databaseInfoCopyText(info: DatabaseConnectionInfo, fieldLabel: (field: DatabaseInfoField) => string, caseLabel: (value: IdentifierCase) => string): string {
  return databaseInfoRows(info)
    .map((row) => {
      const value = row.key === "unquotedIdentifierCase" || row.key === "quotedIdentifierCase" ? caseLabel(row.value as IdentifierCase) : row.value;
      return `${fieldLabel(row.key)}: ${value}`;
    })
    .join("\n");
}

export function isTauriCommandUnavailable(error: unknown, command: string): boolean {
  const message = error instanceof Error ? error.message : String(error);
  const escapedCommand = command.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  return new RegExp(`unknown command\\s*[:=]?\\s*['"]?${escapedCommand}['"]?`, "i").test(message) || new RegExp(`command\\s+['"]?${escapedCommand}['"]?\\s+(?:was\\s+)?not found`, "i").test(message);
}