dsh-lh-data 0.1.0

package/src/datasource/importer.ts

@@ -0,0 +1,262 @@
+/**
+ * 远端表 → 本地数据集的导入。
+ *
+ * 落库完全复用文件导入的那一套（`createDatasetTable` / `insertRows` / `DatasetStore`），
+ * 因此导进来的数据集与 Excel 导入的**结构完全一致**，八个 `dataset_*` 工具零改动可用。
+ * 远端表名只出现在发往远端的 SQL 里，本地表名仍走 `generateTableName` 白名单。
+ */
+
+import { shortHash, type Database } from '../db'
+import { fillSamples, buildColumns, mapRowKeys } from './columns'
+import { connectSource } from './connection'
+import type { DatabaseConnector } from './connector/base'
+import { DataSourceError } from './errors'
+import type { ColumnInfo } from '../parse'
+import {
+  assertPhysicalTableName,
+  generateTableName,
+  makeDatasetId,
+  type DataServices,
+  type DatasetRecord,
+} from '../store'
+import { countRows, createDatasetTable, dropDatasetTable, insertRows } from '../table'
+import { PLUGIN_NAME, type ToolExec } from '../tooling'
+import type { DataSourceRecord } from './types'
+
+export const REMOTE_IMPORT_JOB_KIND = 'datasource-import'
+
+/** 采样式预览：只为了给设置页与 `dataset_schema` 填样例值。 */
+const SAMPLE_ROWS = 5
+
+export interface RemoteImportParams {
+  scopeKey: string
+  source: DataSourceRecord
+  tableName: string
+  schemaName?: string | null
+  /** 数据集登记名；缺省取远端表名。 */
+  name?: string | null
+  /** 只导入前 N 行；配合 `datasourceMaxImportRows` 双重夹紧。 */
+  limit?: number | null
+}
+
+export interface RemoteImportContext {
+  signal: AbortSignal
+  /** 有 agent 才能回注后台任务的完成通知；设置页导入时传 undefined。 */
+  exec?: ToolExec
+  background?: boolean
+}
+
+export interface RemoteImportResult {
+  datasetId: string
+  name: string
+  rowCount: number
+  columnCount: number
+  columns: ColumnInfo[]
+  status: 'ready' | 'running'
+  jobId?: string
+}
+
+interface PreparedImport {
+  scopeKey: string
+  record: DatasetRecord
+  db: Database
+  columns: ColumnInfo[]
+  connector: DatabaseConnector
+  remoteTable: string
+  remoteSchema: string | null
+  /** 0 表示不限。 */
+  maxRows: number
+  estimate: number
+}
+
+function resolveMaxRows(services: DataServices, limit?: number | null): number {
+  const ceiling = services.cfg.datasourceMaxImportRows
+  const requested = limit !== undefined && limit !== null && limit > 0 ? Math.trunc(limit) : 0
+  if (requested === 0) return ceiling > 0 ? ceiling : 0
+  return ceiling > 0 ? Math.min(requested, ceiling) : requested
+}
+
+/** 远端的脱敏定位串：`<schema>.<table>`（MySQL 无 schema 时为 `<table>`）。 */
+function sourceRefOf(params: RemoteImportParams): string {
+  const schema = params.schemaName?.trim() ?? ''
+  return schema.length > 0 ? `${schema}.${params.tableName}` : params.tableName
+}
+
+async function prepareImport(services: DataServices, params: RemoteImportParams): Promise<PreparedImport> {
+  const connector = await connectSource(services.cfg, params.source)
+  const schema = params.schemaName?.trim() || undefined
+  const tables = await connector.getTables(schema)
+  const remote = tables.find(table => table.tableName === params.tableName)
+  if (remote === undefined) {
+    throw new DataSourceError('NOT_FOUND', `数据源「${params.source.name}」里没有表 ${params.tableName}`)
+  }
+  if (remote.columns.length === 0) {
+    throw new DataSourceError('BAD_REQUEST', `表 ${params.tableName} 没有可导入的列`)
+  }
+
+  const columns = buildColumns(remote.columns)
+  const preview = await connector.getTableData(params.tableName, remote.schemaName ?? undefined, { limit: SAMPLE_ROWS })
+  fillSamples(columns, preview)
+
+  const base = params.name?.trim() || params.tableName
+  const now = Date.now()
+  const record: DatasetRecord = {
+    id: makeDatasetId(),
+    scopeKey: params.scopeKey,
+    name: await services.store.uniqueName(params.scopeKey, base),
+    tableName: generateTableName(base, shortHash(params.scopeKey)),
+    sourcePath: `db:${params.source.name}`,
+    sourceId: params.source.id,
+    sourceRef: sourceRefOf(params),
+    description: null,
+    rowCount: 0,
+    columns,
+    status: 'importing',
+    error: null,
+    createdAt: now,
+    updatedAt: now,
+  }
+  assertPhysicalTableName(record.tableName)
+  await services.store.create(record)
+  const db = await services.store.database(params.scopeKey)
+  await createDatasetTable(db, record.tableName, columns)
+  return {
+    scopeKey: params.scopeKey,
+    record,
+    db,
+    columns,
+    connector,
+    remoteTable: params.tableName,
+    remoteSchema: remote.schemaName,
+    maxRows: resolveMaxRows(services, params.limit),
+    estimate: remote.rowCount,
+  }
+}
+
+/** 分块拉取 → 键改写 → 批量插入，直到拉空或达到上限。 */
+async function pullAndInsert(services: DataServices, prepared: PreparedImport, signal: AbortSignal): Promise<number> {
+  const fetchSize = Math.max(1, services.cfg.datasourceFetchBatchSize)
+  let inserted = 0
+  let offset = 0
+  for (;;) {
+    signal.throwIfAborted()
+    const remaining = prepared.maxRows > 0 ? prepared.maxRows - inserted : fetchSize
+    const limit = Math.min(fetchSize, remaining > 0 ? remaining : 0)
+    if (limit <= 0) break
+    const rows = await prepared.connector.getTableData(prepared.remoteTable, prepared.remoteSchema ?? undefined, { limit, offset })
+    if (rows.length === 0) break
+    await insertRows(prepared.db, prepared.record.tableName, prepared.columns, mapRowKeys(rows, prepared.columns), {
+      batchSize: services.cfg.batchSize,
+      signal,
+    })
+    inserted += rows.length
+    offset += rows.length
+    if (rows.length < limit) break
+  }
+  return inserted
+}
+
+async function finalize(services: DataServices, prepared: PreparedImport, inserted: number): Promise<number> {
+  const rowCount = await countRows(prepared.db, prepared.record.tableName)
+  const total = Number.isFinite(rowCount) ? rowCount : inserted
+  await services.store.update(prepared.scopeKey, prepared.record.id, { rowCount: total, status: 'ready' })
+  return total
+}
+
+async function cleanupFailedImport(services: DataServices, prepared: PreparedImport, message: string): Promise<void> {
+  try {
+    await dropDatasetTable(prepared.db, prepared.record.tableName)
+  } catch {
+    // 清理失败不应掩盖原始错误。
+  }
+  try {
+    await services.store.update(prepared.scopeKey, prepared.record.id, {
+      status: 'failed',
+      error: message.slice(0, 500),
+      rowCount: 0,
+    })
+  } catch {
+    // 同上。
+  }
+}
+
+function startBackgroundImport(services: DataServices, exec: ToolExec, prepared: PreparedImport): string | undefined {
+  const jobs = services.jobs
+  if (jobs === undefined) return undefined
+  const controller = new AbortController()
+  const notify = (text: string): void => {
+    try {
+      exec.agent?.inject?.({ role: 'user', content: [{ type: 'text', text }], source: { kind: 'plugin', plugin: PLUGIN_NAME } })
+    } catch {
+      // agent 已 dispose 时静默跳过。
+    }
+  }
+  try {
+    return jobs.start({
+      kind: REMOTE_IMPORT_JOB_KIND,
+      label: `导入远端表 ${prepared.remoteTable} → ${prepared.record.name}`,
+      owner: exec.agent,
+      run: () => {
+        const done = (async (): Promise<{ status: string; detail: string; output: string }> => {
+          try {
+            const inserted = await pullAndInsert(services, prepared, controller.signal)
+            const total = await finalize(services, prepared, inserted)
+            const text = `远端表导入完成：${prepared.record.name}（${total} 行，datasetId: ${prepared.record.id}）`
+            notify(text)
+            return { status: 'completed', detail: `${total} rows`, output: text }
+          } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : String(error)
+            await cleanupFailedImport(services, prepared, message)
+            const aborted = controller.signal.aborted
+            const text = `远端表导入${aborted ? '已取消' : '失败'}：${prepared.record.name} — ${message}`
+            notify(text)
+            return { status: aborted ? 'killed' : 'failed', detail: message.slice(0, 500), output: text }
+          }
+        })()
+        return { cancel: (reason?: string) => controller.abort(reason), done }
+      },
+    })
+  } catch {
+    return undefined
+  }
+}
+
+export async function importRemoteTable(
+  services: DataServices,
+  params: RemoteImportParams,
+  context: RemoteImportContext,
+): Promise<RemoteImportResult> {
+  const prepared = await prepareImport(services, params)
+  try {
+    const wantsBackground = context.background === true
+      || (context.exec !== undefined && prepared.estimate >= services.cfg.backgroundThresholdRows)
+    if (wantsBackground && context.exec !== undefined) {
+      const jobId = startBackgroundImport(services, context.exec, prepared)
+      if (jobId !== undefined) {
+        return {
+          datasetId: prepared.record.id,
+          name: prepared.record.name,
+          rowCount: 0,
+          columnCount: prepared.columns.length,
+          columns: prepared.columns,
+          status: 'running',
+          jobId,
+        }
+      }
+    }
+    const inserted = await pullAndInsert(services, prepared, context.signal)
+    const total = await finalize(services, prepared, inserted)
+    return {
+      datasetId: prepared.record.id,
+      name: prepared.record.name,
+      rowCount: total,
+      columnCount: prepared.columns.length,
+      columns: prepared.columns,
+      status: 'ready',
+    }
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error)
+    await cleanupFailedImport(services, prepared, message)
+    throw error
+  }
+}

package/src/datasource/index.ts

@@ -0,0 +1,62 @@
+/**
+ * 数据源模块对外入口。
+ *
+ * 主机侧（工具 / 管理接口）只从这里导入；连接器与驱动加载属于内部实现，不直接暴露。
+ */
+
+// 错误
+export { DataSourceError, dataSourceErrorStatus, isDataSourceError, type DataSourceErrorCode } from './errors'
+
+// 类型
+export type {
+  ConnectionConfig,
+  ConnectionTestResult,
+  DataSourceConfig,
+  DataSourceInput,
+  DataSourcePatch,
+  DataSourceRecord,
+  DataSourceStatus,
+  DataSourceType,
+  FetchRange,
+  ImportRequest,
+  RemoteColumn,
+  RemoteTable,
+  SchemaSummary,
+} from './types'
+
+// 加解密
+export { decryptPassword, encryptPassword, isValidEncryptedFormat, resolveEncryptKey, usingDefaultEncryptKey } from './crypto'
+
+// 驱动
+export { DRIVER_INSTALL_HINTS } from './driver'
+
+// 连接
+export {
+  closeAllConnectors,
+  closeConnector,
+  connectSource,
+  createConnector,
+  DEFAULT_PORTS,
+  testDraft,
+  testSource,
+  type ConnectionDraft,
+} from './connection'
+
+// 连接器基类
+export { DatabaseConnector } from './connector/base'
+
+// 持久化
+export { createSourceStore, DataSourceStore } from './source-store'
+export { makeSourceId, SOURCE_SCHEMA_SQL } from './source-sql'
+
+// 列映射
+export { buildColumns, fillSamples, mapRowKeys } from './columns'
+
+// 导入
+export {
+  importRemoteTable,
+  REMOTE_IMPORT_JOB_KIND,
+  type RemoteImportContext,
+  type RemoteImportParams,
+  type RemoteImportResult,
+} from './importer'

package/src/datasource/source-sql.ts

@@ -0,0 +1,64 @@
+/**
+ * `lh_data_sources` 的 DDL 与行映射。
+ *
+ * 数据源是**全局**的（catalog 库，跨工作区共享），与 `dataset_scopes` 同库。
+ * DDL 与行映射单独放这里，`source-store.ts` 只留 CRUD，避免类膨胀。
+ */
+
+import type { Row } from '../db'
+import type { DataSourceRecord, DataSourceStatus, DataSourceType } from './types'
+
+export const SOURCE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS lh_data_sources (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  type TEXT NOT NULL,
+  host TEXT NOT NULL,
+  port INTEGER NOT NULL,
+  database_name TEXT NOT NULL,
+  username TEXT NOT NULL,
+  password_enc TEXT NOT NULL,
+  ssl_mode TEXT,
+  pool_max INTEGER,
+  description TEXT,
+  status TEXT NOT NULL DEFAULT 'unknown',
+  last_error TEXT,
+  last_checked_at INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lh_data_sources_name ON lh_data_sources(name);
+`
+
+export function makeSourceId(): string {
+  return `dsrc_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`
+}
+
+function nullableString(value: unknown): string | null {
+  return value === null || value === undefined ? null : String(value)
+}
+
+function nullableNumber(value: unknown): number | null {
+  return value === null || value === undefined ? null : Number(value)
+}
+
+export function rowToSource(row: Row): DataSourceRecord {
+  return {
+    id: String(row.id),
+    name: String(row.name),
+    type: String(row.type ?? 'mysql') as DataSourceType,
+    host: String(row.host ?? ''),
+    port: Number(row.port ?? 0),
+    database: String(row.database_name ?? ''),
+    username: String(row.username ?? ''),
+    passwordEnc: String(row.password_enc ?? ''),
+    sslMode: nullableString(row.ssl_mode),
+    poolMax: nullableNumber(row.pool_max),
+    description: nullableString(row.description),
+    status: String(row.status ?? 'unknown') as DataSourceStatus,
+    lastError: nullableString(row.last_error),
+    lastCheckedAt: nullableNumber(row.last_checked_at),
+    createdAt: Number(row.created_at ?? 0),
+    updatedAt: Number(row.updated_at ?? 0),
+  }
+}

package/src/datasource/source-store.ts

@@ -0,0 +1,152 @@
+/**
+ * 数据源的持久化：catalog 库 `lh_data_sources` 的 CRUD。
+ *
+ * 密码在这一层加密落库；改 / 删数据源会顺带关掉对应的连接池，避免缓存里残留
+ * 旧凭据。`list()` / `find()` 返回的是含密文的完整记录——**绝不能直接序列化
+ * 给前端或模型**，边界处必须过 `toView()` / 工具侧的脱敏。
+ */
+
+import { resolveCatalogDatabase, type Database, type DbConfig } from '../db'
+import { closeConnector } from './connection'
+import { encryptPassword, resolveEncryptKey } from './crypto'
+import { DataSourceError } from './errors'
+import { makeSourceId, rowToSource, SOURCE_SCHEMA_SQL } from './source-sql'
+import type { DataSourceConfig, DataSourceInput, DataSourcePatch, DataSourceRecord } from './types'
+
+export class DataSourceStore {
+  private initialized = false
+
+  constructor(private readonly cfg: DataSourceConfig & DbConfig) {}
+
+  private async db(): Promise<Database> {
+    const database = resolveCatalogDatabase(this.cfg)
+    if (!this.initialized) {
+      await database.exec(SOURCE_SCHEMA_SQL)
+      this.initialized = true
+    }
+    return database
+  }
+
+  async list(): Promise<DataSourceRecord[]> {
+    const rows = await (await this.db()).prepare('SELECT * FROM lh_data_sources ORDER BY name ASC').all()
+    return rows.map(rowToSource)
+  }
+
+  /** 按 id 或登记名查找；找不到返回 undefined（不抛错）。 */
+  async find(reference: string): Promise<DataSourceRecord | undefined> {
+    const key = reference.trim()
+    if (key.length === 0) return undefined
+    const row = await (await this.db())
+      .prepare('SELECT * FROM lh_data_sources WHERE id = ? OR name = ? LIMIT 1')
+      .get(key, key)
+    return row === undefined ? undefined : rowToSource(row)
+  }
+
+  async require(reference: string): Promise<DataSourceRecord> {
+    const record = await this.find(reference)
+    if (record === undefined) {
+      throw new DataSourceError('NOT_FOUND', `未找到数据源：${reference}（先用 datasource_list 查看可用数据源）`)
+    }
+    return record
+  }
+
+  /** 全局唯一的名字：已存在则追加 `_2` / `_3`。 */
+  async uniqueName(name: string): Promise<string> {
+    const base = name.trim().length > 0 ? name.trim() : 'source'
+    const taken = new Set((await this.list()).map(record => record.name))
+    if (!taken.has(base)) return base
+    for (let index = 2; index < 1000; index += 1) {
+      if (!taken.has(`${base}_${index}`)) return `${base}_${index}`
+    }
+    throw new DataSourceError('BAD_REQUEST', `无法为数据源生成唯一名称：${base}`)
+  }
+
+  async create(input: DataSourceInput): Promise<DataSourceRecord> {
+    const key = resolveEncryptKey(this.cfg.datasourceEncryptKey)
+    const now = Date.now()
+    const record: DataSourceRecord = {
+      id: makeSourceId(),
+      name: await this.uniqueName(input.name),
+      type: input.type,
+      host: input.host,
+      port: input.port,
+      database: input.database,
+      username: input.username,
+      passwordEnc: encryptPassword(input.password, key),
+      sslMode: input.sslMode ?? null,
+      poolMax: input.poolMax ?? null,
+      description: input.description ?? null,
+      status: 'unknown',
+      lastError: null,
+      lastCheckedAt: null,
+      createdAt: now,
+      updatedAt: now,
+    }
+    await this.insert(record)
+    return record
+  }
+
+  async update(id: string, patch: DataSourcePatch): Promise<DataSourceRecord> {
+    const current = await this.require(id)
+    const assignments: string[] = ['updated_at = ?']
+    const params: unknown[] = [Date.now()]
+    const assign = (column: string, value: unknown): void => {
+      assignments.push(`${column} = ?`)
+      params.push(value)
+    }
+    if (patch.name !== undefined) assign('name', patch.name)
+    if (patch.type !== undefined) assign('type', patch.type)
+    if (patch.host !== undefined) assign('host', patch.host)
+    if (patch.port !== undefined) assign('port', patch.port)
+    if (patch.database !== undefined) assign('database_name', patch.database)
+    if (patch.username !== undefined) assign('username', patch.username)
+    if (typeof patch.password === 'string') {
+      assign('password_enc', encryptPassword(patch.password, resolveEncryptKey(this.cfg.datasourceEncryptKey)))
+    }
+    if (patch.sslMode !== undefined) assign('ssl_mode', patch.sslMode)
+    if (patch.poolMax !== undefined) assign('pool_max', patch.poolMax)
+    if (patch.description !== undefined) assign('description', patch.description)
+    if (patch.status !== undefined) assign('status', patch.status)
+    if (patch.lastError !== undefined) assign('last_error', patch.lastError)
+    if (patch.lastCheckedAt !== undefined) assign('last_checked_at', patch.lastCheckedAt)
+    params.push(current.id)
+    await (await this.db()).prepare(`UPDATE lh_data_sources SET ${assignments.join(', ')} WHERE id = ?`).run(...params)
+    // 连接参数可能已变，缓存里的旧连接池必须作废。
+    await closeConnector(current.id)
+    return await this.require(current.id)
+  }
+
+  /** 记录一次连通性检测的结果。 */
+  async recordCheck(id: string, success: boolean, error: string | null): Promise<void> {
+    await this.update(id, {
+      status: success ? 'connected' : 'error',
+      lastError: success ? null : error,
+      lastCheckedAt: Date.now(),
+    })
+  }
+
+  async remove(id: string): Promise<void> {
+    const current = await this.require(id)
+    await closeConnector(current.id)
+    await (await this.db()).prepare('DELETE FROM lh_data_sources WHERE id = ?').run(current.id)
+  }
+
+  private async insert(record: DataSourceRecord): Promise<void> {
+    await (await this.db())
+      .prepare(
+        `INSERT INTO lh_data_sources
+         (id, name, type, host, port, database_name, username, password_enc, ssl_mode, pool_max,
+          description, status, last_error, last_checked_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        record.id, record.name, record.type, record.host, record.port, record.database, record.username,
+        record.passwordEnc, record.sslMode, record.poolMax, record.description, record.status,
+        record.lastError, record.lastCheckedAt, record.createdAt, record.updatedAt,
+      )
+  }
+}
+
+export function createSourceStore(cfg: DataSourceConfig & DbConfig): DataSourceStore {
+  return new DataSourceStore(cfg)
+}

package/src/datasource/types.ts

@@ -0,0 +1,133 @@
+/**
+ * 数据源（DataSource）的类型定义。
+ *
+ * 数据源 = 一条远程关系型数据库的连接配置，全局登记在 catalog 库，跨工作区共享；
+ * 导入产出的数据集仍落在**当前工作区**的 scope 库里。
+ */
+
+import type { ColumnType } from '../parse'
+
+/** 支持的关系型数据库类型。 */
+export type DataSourceType = 'mysql' | 'postgresql'
+
+/** 连通状态：从未检测 / 最近一次成功 / 最近一次失败。 */
+export type DataSourceStatus = 'unknown' | 'connected' | 'error'
+
+/**
+ * 与 `DataConfig` 结构同源的最小视图。
+ * 只声明本模块真正读取的键，避免 `datasource/*` → `store.ts` 的循环依赖。
+ */
+export interface DataSourceConfig {
+  datasourceEnabled: boolean
+  datasourceFetchBatchSize: number
+  datasourceConnectTimeoutMs: number
+  datasourceMaxImportRows: number
+  datasourceEncryptKey: string
+}
+
+/** catalog 库 `lh_data_sources` 的一行。`passwordEnc` 恒为密文。 */
+export interface DataSourceRecord {
+  id: string
+  name: string
+  type: DataSourceType
+  host: string
+  port: number
+  database: string
+  username: string
+  passwordEnc: string
+  sslMode: string | null
+  poolMax: number | null
+  description: string | null
+  status: DataSourceStatus
+  lastError: string | null
+  lastCheckedAt: number | null
+  createdAt: number
+  updatedAt: number
+}
+
+/** 新建一条数据源需要的字段（密码为明文，落库前加密）。 */
+export interface DataSourceInput {
+  name: string
+  type: DataSourceType
+  host: string
+  port: number
+  database: string
+  username: string
+  password: string
+  sslMode?: string | null
+  poolMax?: number | null
+  description?: string | null
+}
+
+/** 改一条数据源：字段缺省表示不改；`password` 给空串表示清空。 */
+export interface DataSourcePatch {
+  name?: string
+  type?: DataSourceType
+  host?: string
+  port?: number
+  database?: string
+  username?: string
+  password?: string | null
+  sslMode?: string | null
+  poolMax?: number | null
+  description?: string | null
+  status?: DataSourceStatus
+  lastError?: string | null
+  lastCheckedAt?: number | null
+}
+
+/** 明文连接参数：只在内存里流转，绝不落库、绝不回显给前端或模型。 */
+export interface ConnectionConfig {
+  host: string
+  port: number
+  database: string
+  username: string
+  password: string
+  sslMode: string | null
+  poolMax: number | null
+  connectTimeoutMs: number
+}
+
+/** 连接器返回的列元数据（方言无关，已把远端类型映射成本项目的列类型）。 */
+export interface RemoteColumn {
+  name: string
+  nativeType: ColumnType
+  nullable: boolean
+  comment: string | null
+}
+
+export interface RemoteTable {
+  tableName: string
+  schemaName: string | null
+  /** 远端的估计行数（MySQL `TABLE_ROWS` / PG `reltuples`），可能为 -1（未知）。 */
+  rowCount: number
+  primaryKey: string | null
+  columns: RemoteColumn[]
+}
+
+export interface SchemaSummary {
+  schemaName: string
+  tableCount: number
+}
+
+export interface ConnectionTestResult {
+  success: boolean
+  latency: number
+  version: string | null
+  error: string | null
+}
+
+/** 分块拉取的区间。 */
+export interface FetchRange {
+  limit?: number
+  offset?: number
+}
+
+/** 导入一张远端表的请求（`datasource_import` 与设置页共用）。 */
+export interface ImportRequest {
+  scopeKey: string
+  tableName: string
+  schemaName?: string | null
+  name?: string | null
+  limit?: number | null
+}