dsh-lh-data 0.1.0

package/src/client/settings/styles.ts

@@ -0,0 +1,125 @@
+/**
+ * 设置页的内联样式常量。沿用插件既有风格：中性灰底、细边框、6px 圆角、12–13px 字号，
+ * 全部走 `var(--dsw-*)` 设计变量并带字面量兜底，自动跟随平台明暗主题。
+ * 不引入任何 CSS 管线（与浏览器半身既有卡片一致）。
+ */
+
+export const c = {
+  bg: 'var(--dsw-bg, #ffffff)',
+  subtle: 'var(--dsw-bg-subtle, #fafafa)',
+  fg: 'var(--dsw-fg, #1f2328)',
+  fg2: 'var(--dsw-fg-secondary, #656d76)',
+  border: 'var(--dsw-border, #e5e5e5)',
+  primary: 'var(--dsw-primary, #2f6feb)',
+  danger: 'var(--dsw-danger, #c0392b)',
+  ok: 'var(--dsw-ok, #1a7f37)',
+  warn: 'var(--dsw-warn, #9a6700)',
+} as const
+
+export const s = {
+  page: { fontSize: 12, color: c.fg, lineHeight: 1.6 },
+  toolbar: {
+    display: 'flex', alignItems: 'center', gap: 8, marginBottom: 10,
+    paddingBottom: 10, borderBottom: `1px solid ${c.border}`,
+  },
+  search: {
+    flex: 1, minWidth: 0, padding: '5px 8px', fontSize: 12,
+    border: `1px solid ${c.border}`, borderRadius: 6, background: c.bg, color: c.fg,
+    outline: 'none',
+  },
+  button: {
+    border: `1px solid ${c.border}`, background: c.bg, color: c.fg,
+    borderRadius: 6, padding: '5px 10px', cursor: 'pointer', fontSize: 12, whiteSpace: 'nowrap',
+  },
+  primaryButton: {
+    border: `1px solid ${c.primary}`, background: c.primary, color: '#fff',
+    borderRadius: 6, padding: '5px 12px', cursor: 'pointer', fontSize: 12, whiteSpace: 'nowrap',
+  },
+  dangerButton: {
+    border: `1px solid ${c.danger}`, background: 'transparent', color: c.danger,
+    borderRadius: 6, padding: '5px 10px', cursor: 'pointer', fontSize: 12,
+  },
+  disabledButton: { opacity: 0.5, cursor: 'not-allowed' },
+  banner: {
+    marginBottom: 10, padding: '6px 10px', borderRadius: 6,
+    border: `1px solid ${c.danger}`, color: c.danger, fontSize: 12,
+    display: 'flex', alignItems: 'center', gap: 8,
+  },
+  scroll: {
+    maxHeight: 360, overflow: 'auto', border: `1px solid ${c.border}`, borderRadius: 6,
+  },
+  table: { borderCollapse: 'collapse', width: '100%', fontSize: 12 },
+  th: {
+    position: 'sticky', top: 0, background: c.subtle, textAlign: 'left',
+    padding: '6px 8px', borderBottom: `1px solid ${c.border}`, color: c.fg2, fontWeight: 600,
+    whiteSpace: 'nowrap',
+  },
+  td: {
+    padding: '5px 8px', borderBottom: `1px solid ${c.border}`, maxWidth: 280,
+    overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+  },
+  row: { cursor: 'pointer' },
+  selectedRow: { boxShadow: `inset 2px 0 0 ${c.primary}` },
+  rowHover: { background: c.subtle },
+  dot: { display: 'inline-block', width: 7, height: 7, borderRadius: '50%', marginRight: 5 },
+  panel: {
+    marginTop: 12, padding: 12, border: `1px solid ${c.border}`, borderRadius: 6, background: c.subtle,
+  },
+  field: { marginBottom: 10 },
+  label: { display: 'block', fontSize: 12, color: c.fg2, marginBottom: 4 },
+  input: {
+    width: '100%', boxSizing: 'border-box', padding: '5px 8px', fontSize: 12,
+    border: `1px solid ${c.border}`, borderRadius: 6, background: c.bg, color: c.fg, outline: 'none',
+  },
+  select: {
+    padding: '4px 6px', fontSize: 12, border: `1px solid ${c.border}`, borderRadius: 6,
+    background: c.bg, color: c.fg, outline: 'none',
+  },
+  textarea: {
+    width: '100%', boxSizing: 'border-box', padding: '5px 8px', fontSize: 12,
+    border: `1px solid ${c.border}`, borderRadius: 6, background: c.bg, color: c.fg,
+    outline: 'none', resize: 'vertical', minHeight: 54, fontFamily: 'inherit',
+  },
+  grid2: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 10 },
+  grid3: { display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: 8, alignItems: 'end' },
+  head: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 10 },
+  bar: { display: 'flex', alignItems: 'center', gap: 8, marginTop: 8, flexWrap: 'wrap' },
+  muted: { color: c.fg2 },
+  link: { color: c.primary, cursor: 'pointer' },
+  status: { fontWeight: 600 },
+  tabs: {
+    display: 'flex', gap: 18, marginBottom: 12, borderBottom: `1px solid ${c.border}`,
+  },
+  tab: {
+    padding: '0 0 6px', fontSize: 13, fontWeight: 600, color: c.fg2,
+    background: 'none', border: 'none', borderBottom: '2px solid transparent',
+    cursor: 'pointer', transition: 'color 120ms ease, border-color 120ms ease',
+  },
+  activeTab: { color: c.fg, borderBottom: `2px solid ${c.primary}` },
+} as const
+
+/** 状态圆点配色（数据集）。 */
+export const STATUS_COLOR: Record<string, string> = {
+  ready: c.ok,
+  importing: c.warn,
+  failed: c.danger,
+}
+
+/** 数据源连通状态圆点配色。 */
+export const SOURCE_STATUS_COLOR: Record<string, string> = {
+  connected: c.ok,
+  error: c.danger,
+  unknown: c.fg2,
+}
+
+export const SOURCE_STATUS_TEXT: Record<string, string> = {
+  connected: '已连通',
+  error: '连接失败',
+  unknown: '未检测',
+}
+
+/** 类型徽标底色（低饱和，跟随主题的浅底细边框）。 */
+export const TYPE_BADGE: Record<string, string> = {
+  mysql: c.primary,
+  postgresql: c.ok,
+}

package/src/datasource/columns.ts

@@ -0,0 +1,56 @@
+/**
+ * 远端列 → 本地 `ColumnInfo` 的映射，以及行键改写。
+ *
+ * 与文件导入的区别：远端已有权威类型声明，所以**不做采样推断**（`parse.ts` 的
+ * `inferColumnType` 只在解析 Excel/CSV 时用），直接采用连接器映射出的类型。
+ */
+
+import { deduplicateColumnNames, sanitizeColumnName, type ColumnInfo } from '../parse'
+import type { RemoteColumn } from './types'
+
+/** 设置页展示用的样例值个数。 */
+const MAX_SAMPLE_VALUES = 5
+
+export function buildColumns(remote: readonly RemoteColumn[]): ColumnInfo[] {
+  const columns: ColumnInfo[] = remote.map(column => {
+    const info: ColumnInfo = {
+      name: column.name,
+      sanitizedName: sanitizeColumnName(column.name),
+      type: column.nativeType,
+      nullable: column.nullable,
+      sample: [],
+    }
+    if (column.comment !== null && column.comment.length > 0) info.description = column.comment
+    return info
+  })
+  deduplicateColumnNames(columns)
+  return columns
+}
+
+/** `insertRows` 按 `sanitizedName` 取值，远端行的原始列键必须改写一次。 */
+export function mapRowKeys(
+  rows: readonly Record<string, unknown>[],
+  columns: readonly ColumnInfo[],
+): Record<string, unknown>[] {
+  return rows.map(row => {
+    const mapped: Record<string, unknown> = {}
+    for (const column of columns) {
+      mapped[column.sanitizedName] = row[column.name] ?? null
+    }
+    return mapped
+  })
+}
+
+/** 从首批行里取几个非空值填进 `sample`（原地修改）。 */
+export function fillSamples(columns: readonly ColumnInfo[], rows: readonly Record<string, unknown>[]): void {
+  for (const column of columns) {
+    const sample: unknown[] = []
+    for (const row of rows) {
+      const value = row[column.name]
+      if (value === null || value === undefined) continue
+      sample.push(value)
+      if (sample.length >= MAX_SAMPLE_VALUES) break
+    }
+    if (sample.length > 0) column.sample = sample
+  }
+}

package/src/datasource/connection.ts

@@ -0,0 +1,124 @@
+/**
+ * 连接器的工厂与缓存。
+ *
+ * key 是 `sourceId`：同一数据源在一次插件生命周期内复用同一个连接池。
+ * 数据源被改 / 删时必须先 `closeConnector`，否则缓存里会残留旧凭据的连接。
+ */
+
+import { MySQLConnector } from './connector/mysql'
+import { PostgreSQLConnector } from './connector/postgresql'
+import type { DatabaseConnector } from './connector/base'
+import { decryptPassword, resolveEncryptKey } from './crypto'
+import { wrapConnectionError } from './errors'
+import type {
+  ConnectionConfig,
+  ConnectionTestResult,
+  DataSourceConfig,
+  DataSourceRecord,
+  DataSourceType,
+} from './types'
+
+export const DEFAULT_PORTS: Readonly<Record<DataSourceType, number>> = {
+  mysql: 3306,
+  postgresql: 5432,
+}
+
+/** 未保存的连接参数（设置页「先测试再保存」用）。 */
+export interface ConnectionDraft {
+  type: DataSourceType
+  host: string
+  port: number | null
+  database: string
+  username: string
+  password: string
+  sslMode?: string | null
+  poolMax?: number | null
+}
+
+const connectors = new Map<string, DatabaseConnector>()
+
+export function createConnector(type: DataSourceType, config: ConnectionConfig): DatabaseConnector {
+  if (type === 'mysql') return new MySQLConnector(config)
+  return new PostgreSQLConnector(config)
+}
+
+/** 已登记数据源 → 明文连接参数（解密只发生在这一刻，结果不出本模块）。 */
+export function connectionOf(cfg: DataSourceConfig, record: DataSourceRecord): ConnectionConfig {
+  return {
+    host: record.host,
+    port: record.port,
+    database: record.database,
+    username: record.username,
+    password: decryptPassword(record.passwordEnc, resolveEncryptKey(cfg.datasourceEncryptKey)),
+    sslMode: record.sslMode,
+    poolMax: record.poolMax,
+    connectTimeoutMs: cfg.datasourceConnectTimeoutMs,
+  }
+}
+
+/** 未保存草稿 → 明文连接参数。 */
+export function draftToConfig(cfg: DataSourceConfig, draft: ConnectionDraft): ConnectionConfig {
+  return {
+    host: draft.host,
+    port: draft.port ?? DEFAULT_PORTS[draft.type],
+    database: draft.database,
+    username: draft.username,
+    password: draft.password,
+    sslMode: draft.sslMode ?? null,
+    poolMax: draft.poolMax ?? null,
+    connectTimeoutMs: cfg.datasourceConnectTimeoutMs,
+  }
+}
+
+/** 取（或建）一个已连通的连接器；连接失败会抛出，并把失败状态留给调用方记录。 */
+export async function connectSource(cfg: DataSourceConfig, record: DataSourceRecord): Promise<DatabaseConnector> {
+  const cached = connectors.get(record.id)
+  if (cached !== undefined) return cached
+  const connector = createConnector(record.type, connectionOf(cfg, record))
+  try {
+    await connector.connect()
+  } catch (error: unknown) {
+    throw wrapConnectionError(error,record.host, record.port)
+  }
+  connectors.set(record.id, connector)
+  return connector
+}
+
+/** 用一次性连接器测连接：测完立刻关闭，不进缓存。 */
+export async function testDraft(cfg: DataSourceConfig, draft: ConnectionDraft): Promise<ConnectionTestResult> {
+  const connector = createConnector(draft.type, draftToConfig(cfg, draft))
+  try {
+    return await connector.testConnection()
+  } catch (error: unknown) {
+    throw wrapConnectionError(error,draft.host, draft.port ?? DEFAULT_PORTS[draft.type])
+  } finally {
+    await connector.disconnect()
+  }
+}
+
+/** 测一条已登记的数据源：命中缓存就复用，否则建一次性连接。 */
+export async function testSource(cfg: DataSourceConfig, record: DataSourceRecord): Promise<ConnectionTestResult> {
+  const cached = connectors.get(record.id)
+  if (cached !== undefined) return await cached.testConnection()
+  const connector = createConnector(record.type, connectionOf(cfg, record))
+  try {
+    return await connector.testConnection()
+  } catch (error: unknown) {
+    throw wrapConnectionError(error,record.host, record.port)
+  } finally {
+    await connector.disconnect()
+  }
+}
+
+export async function closeConnector(sourceId: string): Promise<void> {
+  const connector = connectors.get(sourceId)
+  if (connector === undefined) return
+  connectors.delete(sourceId)
+  await connector.disconnect().catch(() => undefined)
+}
+
+export async function closeAllConnectors(): Promise<void> {
+  const entries = [...connectors.entries()]
+  connectors.clear()
+  await Promise.all(entries.map(([, connector]) => connector.disconnect().catch(() => undefined)))
+}

package/src/datasource/connector/base.ts

@@ -0,0 +1,54 @@
+/**
+ * 数据库连接器抽象基类。
+ *
+ * 只定义方言无关的能力：连通性测试、schema / 表 / 列元数据、分块取数据。
+ * 标识符引号化与类型映射由各子类实现，基类不写任何方言分支。
+ */
+
+import type {
+  ConnectionConfig,
+  ConnectionTestResult,
+  FetchRange,
+  RemoteColumn,
+  RemoteTable,
+  SchemaSummary,
+} from '../types'
+
+export abstract class DatabaseConnector {
+  protected readonly config: ConnectionConfig
+
+  constructor(config: ConnectionConfig) {
+    this.config = config
+  }
+
+  // ── 连接 ───────────────────────────────────────────────────────────────────
+
+  abstract connect(): Promise<void>
+  abstract disconnect(): Promise<void>
+  abstract testConnection(): Promise<ConnectionTestResult>
+
+  // ── 元数据 ─────────────────────────────────────────────────────────────────
+
+  abstract getSchemas(): Promise<SchemaSummary[]>
+  abstract getTables(schemaName?: string): Promise<RemoteTable[]>
+  abstract getTableColumns(tableName: string, schemaName?: string): Promise<RemoteColumn[]>
+  abstract getTableData(tableName: string, schemaName?: string, range?: FetchRange): Promise<Record<string, unknown>[]>
+
+  // ── 方言相关的标识符引号化 ─────────────────────────────────────────────────
+
+  protected abstract quoteIdent(name: string): string
+
+  protected tableRef(tableName: string, schemaName?: string | null): string {
+    const schema = schemaName === undefined || schemaName === null ? '' : schemaName.trim()
+    return schema.length > 0
+      ? `${this.quoteIdent(schema)}.${this.quoteIdent(tableName)}`
+      : this.quoteIdent(tableName)
+  }
+
+  protected buildSelectQuery(tableName: string, schemaName?: string | null, range?: FetchRange): string {
+    let sql = `SELECT * FROM ${this.tableRef(tableName, schemaName)}`
+    if (range?.limit !== undefined) sql += ` LIMIT ${Math.max(0, Math.trunc(range.limit))}`
+    if (range?.offset !== undefined && range.offset > 0) sql += ` OFFSET ${Math.trunc(range.offset)}`
+    return sql
+  }
+}

package/src/datasource/connector/mysql.ts

@@ -0,0 +1,187 @@
+/**
+ * MySQL 连接器。
+ *
+ * 元数据一次查完（`tables` LEFT JOIN `columns`），避免逐表 N+1 查询。
+ * 类型映射依据 `information_schema.COLUMN_TYPE`：远端已有权威声明，不再采样推断。
+ */
+
+import { loadMysqlDriver, type MysqlPoolLike } from '../driver'
+import { DataSourceError, wrapConnectionError } from '../errors'
+import type { ColumnType } from '../../parse'
+import type {
+  ConnectionConfig,
+  ConnectionTestResult,
+  RemoteColumn,
+  RemoteTable,
+  SchemaSummary,
+} from '../types'
+import { DatabaseConnector } from './base'
+
+interface ColumnRow {
+  TABLE_NAME: string
+  TABLE_ROWS: number | string | null
+  COLUMN_NAME: string | null
+  COLUMN_TYPE: string | null
+  IS_NULLABLE: string | null
+  COLUMN_COMMENT: string | null
+  COLUMN_KEY: string | null
+}
+
+const TABLE_COLUMNS_SQL = `
+SELECT t.TABLE_NAME, t.TABLE_ROWS,
+       c.COLUMN_NAME, c.COLUMN_TYPE, c.IS_NULLABLE, c.COLUMN_COMMENT, c.COLUMN_KEY
+FROM information_schema.tables t
+LEFT JOIN information_schema.columns c
+  ON c.TABLE_SCHEMA = t.TABLE_SCHEMA AND c.TABLE_NAME = t.TABLE_NAME
+WHERE t.TABLE_SCHEMA = ? AND t.TABLE_TYPE = 'BASE TABLE'
+ORDER BY t.TABLE_NAME, c.ORDINAL_POSITION`
+
+const ONE_TABLE_COLUMNS_SQL = `
+SELECT c.COLUMN_NAME, c.COLUMN_TYPE, c.IS_NULLABLE, c.COLUMN_COMMENT, c.COLUMN_KEY
+FROM information_schema.columns c
+WHERE c.TABLE_SCHEMA = ? AND c.TABLE_NAME = ?
+ORDER BY c.ORDINAL_POSITION`
+
+function poolOptions(config: ConnectionConfig): Record<string, unknown> {
+  const options: Record<string, unknown> = {
+    host: config.host,
+    port: config.port,
+    database: config.database,
+    user: config.username,
+    password: config.password,
+    connectionLimit: config.poolMax ?? 5,
+    waitForConnections: true,
+    queueLimit: 0,
+    connectTimeout: config.connectTimeoutMs,
+    enableKeepAlive: true,
+    keepAliveInitialDelay: 30000,
+  }
+  if (config.sslMode !== null && config.sslMode !== 'disabled') {
+    options.ssl = { rejectUnauthorized: config.sslMode === 'verify_ca' || config.sslMode === 'verify_identity' }
+  }
+  return options
+}
+
+function mapMySQLType(columnType: string): ColumnType {
+  const type = columnType.toLowerCase()
+  if (type === 'tinyint(1)' || type === 'bool' || type === 'boolean') return 'boolean'
+  if (/^(tinyint|smallint|mediumint|int|integer|bigint|decimal|dec|numeric|float|double|real|fixed)/.test(type)) {
+    return 'numeric'
+  }
+  if (type.startsWith('date') || type.startsWith('time') || type.startsWith('year')) return 'date'
+  return 'text'
+}
+
+function toRemoteColumn(row: ColumnRow): RemoteColumn {
+  const comment = row.COLUMN_COMMENT === null ? null : String(row.COLUMN_COMMENT)
+  return {
+    name: String(row.COLUMN_NAME ?? ''),
+    nativeType: mapMySQLType(String(row.COLUMN_TYPE ?? '')),
+    nullable: row.IS_NULLABLE === 'YES',
+    comment: comment === null || comment.length === 0 ? null : comment,
+  }
+}
+
+function groupTables(rows: readonly ColumnRow[], schemaName: string): RemoteTable[] {
+  const byName = new Map<string, RemoteTable>()
+  for (const row of rows) {
+    const tableName = row.TABLE_NAME
+    let table = byName.get(tableName)
+    if (table === undefined) {
+      table = {
+        tableName,
+        schemaName,
+        rowCount: Number(row.TABLE_ROWS ?? -1),
+        primaryKey: null,
+        columns: [],
+      }
+      byName.set(tableName, table)
+    }
+    if (row.COLUMN_NAME !== null) {
+      const column = toRemoteColumn(row)
+      table.columns.push(column)
+      if (row.COLUMN_KEY === 'PRI' && table.primaryKey === null) table.primaryKey = column.name
+    }
+  }
+  return [...byName.values()]
+}
+
+export class MySQLConnector extends DatabaseConnector {
+  private pool: MysqlPoolLike | null = null
+
+  async connect(): Promise<void> {
+    if (this.pool !== null) return
+    const mysql = await loadMysqlDriver()
+    this.pool = mysql.createPool(poolOptions(this.config))
+  }
+
+  async disconnect(): Promise<void> {
+    const pool = this.pool
+    this.pool = null
+    if (pool !== null) await pool.end()
+  }
+
+  async testConnection(): Promise<ConnectionTestResult> {
+    const startedAt = Date.now()
+    try {
+      const mysql = await loadMysqlDriver()
+      const conn = await mysql.createConnection({
+        ...poolOptions(this.config),
+        connectionLimit: undefined,
+        connectTimeout: this.config.connectTimeoutMs,
+      })
+      const [rows] = await conn.execute('SELECT VERSION() AS version')
+      await conn.end()
+      const version = (rows as { version?: unknown }[])[0]?.version
+      return { success: true, latency: Date.now() - startedAt, version: version === undefined ? null : String(version), error: null }
+    } catch (error) {
+      return { success: false, latency: Date.now() - startedAt, version: null, error: describe(error) }
+    }
+  }
+
+  async getSchemas(): Promise<SchemaSummary[]> {
+    const rows = await this.query(
+      'SELECT COUNT(*) AS total FROM information_schema.tables WHERE table_schema = ? AND table_type = \'BASE TABLE\'',
+      [this.config.database],
+    )
+    const total = Number((rows[0] as { total?: unknown } | undefined)?.total ?? 0)
+    return [{ schemaName: this.config.database, tableCount: total }]
+  }
+
+  async getTables(schemaName?: string): Promise<RemoteTable[]> {
+    void schemaName
+    const rows = await this.query(TABLE_COLUMNS_SQL, [this.config.database])
+    return groupTables(rows as ColumnRow[], this.config.database)
+  }
+
+  async getTableColumns(tableName: string, schemaName?: string): Promise<RemoteColumn[]> {
+    void schemaName
+    const rows = await this.query(ONE_TABLE_COLUMNS_SQL, [this.config.database, tableName])
+    return (rows as ColumnRow[]).map(toRemoteColumn)
+  }
+
+  async getTableData(tableName: string, schemaName?: string, range?: { limit?: number; offset?: number }): Promise<Record<string, unknown>[]> {
+    return await this.query(this.buildSelectQuery(tableName, schemaName, range)) as Record<string, unknown>[]
+  }
+
+  protected quoteIdent(name: string): string {
+    return `\`${name.replace(/`/g, '``')}\``
+  }
+
+  private async query(sql: string, params: unknown[] = []): Promise<unknown[]> {
+    const pool = this.pool
+    if (pool === null) throw new DataSourceError('UNREACHABLE', 'MySQL 连接尚未建立，请先调用 connect()')
+    try {
+      const [rows] = await pool.execute(sql, params)
+      return (rows ?? []) as unknown[]
+    } catch (error: unknown) {
+      throw wrapConnectionError(error, this.config.host, this.config.port)
+    }
+  }
+}
+
+function describe(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error)
+  // 去掉驱动可能附带的连接串（含密码）。
+  return message.replace(/(mysql:\/\/)[^\s'"]*/gi, '$1***').slice(0, 300)
+}