@huyooo/ai-chat-storage 0.1.0

package/dist/chunk-BRWTH4LQ.js

@@ -0,0 +1,642 @@
+// src/adapters/postgres/index.ts
+import postgres from "postgres";
+
+// src/adapters/postgres/base.ts
+async function initSchema(sql) {
+  try {
+    await sql`CREATE EXTENSION IF NOT EXISTS vector`;
+  } catch {
+    console.warn("pgvector \u6269\u5C55\u4E0D\u53EF\u7528\uFF0C\u5411\u91CF\u641C\u7D22\u529F\u80FD\u5C06\u964D\u7EA7");
+  }
+  await sql`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      app_id TEXT,
+      user_id TEXT,
+      title TEXT NOT NULL,
+      model TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `;
+  await sql`
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      app_id TEXT,
+      user_id TEXT,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      thinking TEXT,
+      tool_calls TEXT,
+      search_results TEXT,
+      operation_ids TEXT,
+      timestamp TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `;
+  await sql`
+    CREATE TABLE IF NOT EXISTS operations (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      message_id TEXT,
+      app_id TEXT,
+      user_id TEXT,
+      command TEXT NOT NULL,
+      operation_type TEXT NOT NULL,
+      affected_files TEXT NOT NULL,
+      backup_path TEXT,
+      status TEXT NOT NULL DEFAULT 'pending',
+      error_message TEXT,
+      timestamp TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `;
+  await sql`
+    CREATE TABLE IF NOT EXISTS backups (
+      id TEXT PRIMARY KEY,
+      operation_id TEXT NOT NULL,
+      original_path TEXT NOT NULL,
+      backup_path TEXT NOT NULL,
+      file_size INTEGER NOT NULL,
+      file_hash TEXT NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      expires_at TIMESTAMPTZ NOT NULL
+    )
+  `;
+  await sql`
+    CREATE TABLE IF NOT EXISTS trash (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      app_id TEXT,
+      user_id TEXT,
+      original_path TEXT NOT NULL,
+      trash_path TEXT NOT NULL,
+      deleted_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      auto_delete_at TIMESTAMPTZ NOT NULL
+    )
+  `;
+  try {
+    await sql`
+      CREATE TABLE IF NOT EXISTS embeddings (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        message_id TEXT,
+        app_id TEXT,
+        user_id TEXT,
+        content TEXT NOT NULL,
+        content_type TEXT NOT NULL,
+        embedding vector(1536),
+        metadata JSONB,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `;
+  } catch {
+    await sql`
+      CREATE TABLE IF NOT EXISTS embeddings (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        message_id TEXT,
+        app_id TEXT,
+        user_id TEXT,
+        content TEXT NOT NULL,
+        content_type TEXT NOT NULL,
+        embedding TEXT,
+        metadata JSONB,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `;
+  }
+  await sql`CREATE INDEX IF NOT EXISTS idx_sessions_tenant ON sessions(app_id, user_id)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_messages_tenant ON messages(app_id, user_id)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_operations_session ON operations(session_id)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_operations_message ON operations(message_id)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_backups_operation ON backups(operation_id)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_backups_expires ON backups(expires_at)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_trash_tenant ON trash(app_id, user_id)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_trash_auto_delete ON trash(auto_delete_at)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_embeddings_session ON embeddings(session_id)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_embeddings_tenant ON embeddings(app_id, user_id)`;
+  try {
+    await sql`CREATE INDEX IF NOT EXISTS idx_embeddings_vector ON embeddings USING hnsw (embedding vector_cosine_ops)`;
+  } catch {
+  }
+}
+function cosineSimilarity(a, b) {
+  if (!a || !b || a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+// src/adapters/postgres/sessions.ts
+function toSessionRecord(row) {
+  return {
+    id: row.id,
+    appId: row.app_id,
+    userId: row.user_id,
+    title: row.title,
+    model: row.model,
+    mode: row.mode,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+async function getSessions(sql, ctx) {
+  const rows = await sql`
+    SELECT id, app_id, user_id, title, model, mode, created_at, updated_at
+    FROM sessions
+    WHERE (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+      AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+    ORDER BY updated_at DESC
+  `;
+  return rows.map(toSessionRecord);
+}
+async function getSession(sql, id, ctx) {
+  const rows = await sql`
+    SELECT id, app_id, user_id, title, model, mode, created_at, updated_at
+    FROM sessions
+    WHERE id = ${id}
+      AND (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+      AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+  `;
+  return rows[0] ? toSessionRecord(rows[0]) : null;
+}
+async function createSession(sql, input, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  await sql`
+    INSERT INTO sessions (id, app_id, user_id, title, model, mode, created_at, updated_at)
+    VALUES (${input.id}, ${ctx.appId || null}, ${ctx.userId || null}, ${input.title}, ${input.model}, ${input.mode}, ${now}, ${now})
+  `;
+  return {
+    id: input.id,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    title: input.title,
+    model: input.model,
+    mode: input.mode,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function updateSession(sql, id, data, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  await sql`
+    UPDATE sessions
+    SET updated_at = ${now},
+        title = COALESCE(${data.title || null}, title),
+        model = COALESCE(${data.model || null}, model),
+        mode = COALESCE(${data.mode || null}, mode)
+    WHERE id = ${id}
+      AND (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+      AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+  `;
+}
+async function deleteSession(sql, id, ctx) {
+  await sql`
+    DELETE FROM sessions
+    WHERE id = ${id}
+      AND (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+      AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+  `;
+}
+
+// src/adapters/postgres/messages.ts
+function toMessageRecord(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    appId: row.app_id,
+    userId: row.user_id,
+    role: row.role,
+    content: row.content,
+    thinking: row.thinking,
+    toolCalls: row.tool_calls,
+    searchResults: row.search_results,
+    operationIds: row.operation_ids,
+    timestamp: new Date(row.timestamp)
+  };
+}
+async function getMessages(sql, sessionId) {
+  const rows = await sql`
+    SELECT id, session_id, app_id, user_id, role, content, thinking,
+           tool_calls, search_results, operation_ids, timestamp
+    FROM messages
+    WHERE session_id = ${sessionId}
+    ORDER BY timestamp
+  `;
+  return rows.map(toMessageRecord);
+}
+async function getMessage(sql, id, ctx) {
+  const rows = await sql`
+    SELECT id, session_id, app_id, user_id, role, content, thinking,
+           tool_calls, search_results, operation_ids, timestamp
+    FROM messages
+    WHERE id = ${id}
+      AND (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+      AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+  `;
+  return rows[0] ? toMessageRecord(rows[0]) : null;
+}
+async function saveMessage(sql, input, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  await sql`
+    INSERT INTO messages (id, session_id, app_id, user_id, role, content, thinking, tool_calls, search_results, operation_ids, timestamp)
+    VALUES (${input.id}, ${input.sessionId}, ${ctx.appId || null}, ${ctx.userId || null}, ${input.role}, ${input.content}, ${input.thinking}, ${input.toolCalls}, ${input.searchResults}, ${input.operationIds}, ${now})
+  `;
+  await sql`UPDATE sessions SET updated_at = ${now} WHERE id = ${input.sessionId}`;
+  return {
+    id: input.id,
+    sessionId: input.sessionId,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    role: input.role,
+    content: input.content,
+    thinking: input.thinking,
+    toolCalls: input.toolCalls,
+    searchResults: input.searchResults,
+    operationIds: input.operationIds,
+    timestamp: now
+  };
+}
+async function deleteMessagesAfter(sql, sessionId, timestamp) {
+  await sql`
+    DELETE FROM messages
+    WHERE session_id = ${sessionId}
+      AND timestamp > ${timestamp}
+  `;
+}
+async function deleteSessionMessages(sql, sessionId) {
+  await sql`DELETE FROM messages WHERE session_id = ${sessionId}`;
+}
+
+// src/adapters/postgres/operations.ts
+function toOperationRecord(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    messageId: row.message_id,
+    appId: row.app_id,
+    userId: row.user_id,
+    command: row.command,
+    operationType: row.operation_type,
+    affectedFiles: row.affected_files,
+    backupPath: row.backup_path,
+    status: row.status,
+    errorMessage: row.error_message,
+    timestamp: new Date(row.timestamp)
+  };
+}
+async function getOperations(sql, sessionId) {
+  const rows = await sql`
+    SELECT id, session_id, message_id, app_id, user_id, command, operation_type,
+           affected_files, backup_path, status, error_message, timestamp
+    FROM operations
+    WHERE session_id = ${sessionId}
+    ORDER BY timestamp
+  `;
+  return rows.map(toOperationRecord);
+}
+async function getOperationsByMessage(sql, messageId, ctx) {
+  const rows = await sql`
+    SELECT id, session_id, message_id, app_id, user_id, command, operation_type,
+           affected_files, backup_path, status, error_message, timestamp
+    FROM operations
+    WHERE message_id = ${messageId}
+      AND (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+      AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+  `;
+  return rows.map(toOperationRecord);
+}
+async function saveOperation(sql, input, ctx) {
+  const now = /* @__PURE__ */ new Date();
+  const status = input.status || "pending";
+  await sql`
+    INSERT INTO operations (id, session_id, message_id, app_id, user_id, command, operation_type, affected_files, backup_path, status, timestamp)
+    VALUES (${input.id}, ${input.sessionId}, ${input.messageId || null}, ${ctx.appId || null}, ${ctx.userId || null}, ${input.command}, ${input.operationType}, ${input.affectedFiles}, ${input.backupPath || null}, ${status}, ${now})
+  `;
+  return {
+    id: input.id,
+    sessionId: input.sessionId,
+    messageId: input.messageId,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    command: input.command,
+    operationType: input.operationType,
+    affectedFiles: input.affectedFiles,
+    backupPath: input.backupPath,
+    status,
+    errorMessage: null,
+    timestamp: now
+  };
+}
+async function updateOperationStatus(sql, id, status, errorMessage) {
+  await sql`
+    UPDATE operations
+    SET status = ${status}, error_message = ${errorMessage || null}
+    WHERE id = ${id}
+  `;
+}
+async function deleteSessionOperations(sql, sessionId) {
+  await sql`DELETE FROM operations WHERE session_id = ${sessionId}`;
+}
+
+// src/adapters/postgres/backups.ts
+function toBackupRecord(row) {
+  return {
+    id: row.id,
+    operationId: row.operation_id,
+    originalPath: row.original_path,
+    backupPath: row.backup_path,
+    fileSize: row.file_size,
+    fileHash: row.file_hash,
+    createdAt: new Date(row.created_at),
+    expiresAt: new Date(row.expires_at)
+  };
+}
+async function getBackups(sql, operationId) {
+  const rows = await sql`
+    SELECT id, operation_id, original_path, backup_path, file_size, file_hash, created_at, expires_at
+    FROM backups
+    WHERE operation_id = ${operationId}
+  `;
+  return rows.map(toBackupRecord);
+}
+async function saveBackup(sql, input) {
+  const now = /* @__PURE__ */ new Date();
+  await sql`
+    INSERT INTO backups (id, operation_id, original_path, backup_path, file_size, file_hash, created_at, expires_at)
+    VALUES (${input.id}, ${input.operationId}, ${input.originalPath}, ${input.backupPath}, ${input.fileSize}, ${input.fileHash}, ${now}, ${input.expiresAt})
+  `;
+  return { ...input, createdAt: now };
+}
+async function deleteExpiredBackups(sql) {
+  const result = await sql`DELETE FROM backups WHERE expires_at < NOW()`;
+  return result.count;
+}
+
+// src/adapters/postgres/trash.ts
+function toTrashRecord(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    appId: row.app_id,
+    userId: row.user_id,
+    originalPath: row.original_path,
+    trashPath: row.trash_path,
+    deletedAt: new Date(row.deleted_at),
+    autoDeleteAt: new Date(row.auto_delete_at)
+  };
+}
+async function getTrashItems(sql, ctx) {
+  const rows = await sql`
+    SELECT id, session_id, app_id, user_id, original_path, trash_path, deleted_at, auto_delete_at
+    FROM trash
+    WHERE (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+      AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+    ORDER BY deleted_at DESC
+  `;
+  return rows.map(toTrashRecord);
+}
+async function moveToTrash(sql, input, ctx, config) {
+  const now = /* @__PURE__ */ new Date();
+  const retentionDays = config.trashRetentionDays || 30;
+  const autoDeleteAt = new Date(now.getTime() + retentionDays * 24 * 60 * 60 * 1e3);
+  await sql`
+    INSERT INTO trash (id, session_id, app_id, user_id, original_path, trash_path, deleted_at, auto_delete_at)
+    VALUES (${input.id}, ${input.sessionId}, ${ctx.appId || null}, ${ctx.userId || null}, ${input.originalPath}, ${input.trashPath}, ${now}, ${autoDeleteAt})
+  `;
+  return {
+    ...input,
+    appId: ctx.appId || null,
+    userId: ctx.userId || null,
+    deletedAt: now,
+    autoDeleteAt
+  };
+}
+async function restoreFromTrash(sql, id, ctx) {
+  const rows = await sql`
+    SELECT id, session_id, app_id, user_id, original_path, trash_path, deleted_at, auto_delete_at
+    FROM trash
+    WHERE id = ${id}
+      AND (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+      AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+  `;
+  if (!rows[0]) {
+    throw new Error("\u56DE\u6536\u7AD9\u8BB0\u5F55\u4E0D\u5B58\u5728");
+  }
+  await sql`DELETE FROM trash WHERE id = ${id}`;
+  return toTrashRecord(rows[0]);
+}
+async function emptyExpiredTrash(sql) {
+  const result = await sql`DELETE FROM trash WHERE auto_delete_at < NOW()`;
+  return result.count;
+}
+
+// src/adapters/postgres/embeddings.ts
+async function saveEmbedding(sql, id, content, embedding, metadata, ctx) {
+  const embeddingStr = `[${embedding.join(",")}]`;
+  try {
+    await sql`
+      INSERT INTO embeddings (id, session_id, message_id, app_id, user_id, content, content_type, embedding, metadata, created_at)
+      VALUES (${id}, ${metadata.sessionId}, ${metadata.messageId || null}, ${ctx.appId || null}, ${ctx.userId || null}, ${content}, ${metadata.contentType}, ${embeddingStr}::vector, ${JSON.stringify(metadata)}, NOW())
+    `;
+  } catch {
+    await sql`
+      INSERT INTO embeddings (id, session_id, message_id, app_id, user_id, content, content_type, embedding, metadata, created_at)
+      VALUES (${id}, ${metadata.sessionId}, ${metadata.messageId || null}, ${ctx.appId || null}, ${ctx.userId || null}, ${content}, ${metadata.contentType}, ${embeddingStr}, ${JSON.stringify(metadata)}, NOW())
+    `;
+  }
+}
+async function searchSimilar(sql, queryEmbedding, options, ctx) {
+  const { limit = 10, threshold = 0.7, sessionId } = options;
+  const embeddingStr = `[${queryEmbedding.join(",")}]`;
+  try {
+    const rows = await sql`
+      SELECT id, content, content_type, metadata,
+             1 - (embedding <=> ${embeddingStr}::vector) as similarity
+      FROM embeddings
+      WHERE (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+        AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+        AND (${sessionId || null}::TEXT IS NULL OR session_id = ${sessionId || null})
+        AND 1 - (embedding <=> ${embeddingStr}::vector) > ${threshold}
+      ORDER BY embedding <=> ${embeddingStr}::vector
+      LIMIT ${limit}
+    `;
+    return rows.map((row) => ({
+      id: row.id,
+      content: row.content,
+      contentType: row.content_type,
+      similarity: row.similarity || 0,
+      metadata: row.metadata
+    }));
+  } catch {
+    console.warn("pgvector \u4E0D\u53EF\u7528\uFF0C\u4F7F\u7528\u5185\u5B58\u8BA1\u7B97\u76F8\u4F3C\u5EA6");
+    const rows = await sql`
+      SELECT id, content, content_type, embedding, metadata
+      FROM embeddings
+      WHERE (${ctx.appId || null}::TEXT IS NULL OR app_id = ${ctx.appId || null})
+        AND (${ctx.userId || null}::TEXT IS NULL OR user_id = ${ctx.userId || null})
+        AND (${sessionId || null}::TEXT IS NULL OR session_id = ${sessionId || null})
+    `;
+    return rows.map((row) => {
+      let stored = [];
+      if (typeof row.embedding === "string") {
+        try {
+          stored = JSON.parse(row.embedding.replace(/^\[|\]$/g, "").split(",").map(Number).join(","));
+        } catch {
+          stored = row.embedding.slice(1, -1).split(",").map(Number);
+        }
+      } else if (Array.isArray(row.embedding)) {
+        stored = row.embedding;
+      }
+      const similarity = cosineSimilarity(queryEmbedding, stored);
+      return {
+        id: row.id,
+        content: row.content,
+        contentType: row.content_type,
+        similarity,
+        metadata: row.metadata
+      };
+    }).filter((r) => r.similarity >= threshold).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+  }
+}
+async function deleteSessionEmbeddings(sql, sessionId) {
+  await sql`DELETE FROM embeddings WHERE session_id = ${sessionId}`;
+}
+
+// src/adapters/postgres/index.ts
+var PostgresAdapter = class {
+  sql;
+  config;
+  initialized = false;
+  constructor(connectionString, config = { type: "postgres" }) {
+    this.sql = postgres(connectionString);
+    this.config = config;
+  }
+  /** 确保表结构已初始化 */
+  async ensureInitialized() {
+    if (this.initialized) return;
+    await initSchema(this.sql);
+    this.initialized = true;
+  }
+  // ============ 会话 ============
+  async getSessions(ctx) {
+    await this.ensureInitialized();
+    return getSessions(this.sql, ctx);
+  }
+  async getSession(id, ctx) {
+    await this.ensureInitialized();
+    return getSession(this.sql, id, ctx);
+  }
+  async createSession(input, ctx) {
+    await this.ensureInitialized();
+    return createSession(this.sql, input, ctx);
+  }
+  async updateSession(id, data, ctx) {
+    await this.ensureInitialized();
+    await updateSession(this.sql, id, data, ctx);
+  }
+  async deleteSession(id, ctx) {
+    await this.ensureInitialized();
+    await deleteSessionMessages(this.sql, id);
+    await deleteSessionOperations(this.sql, id);
+    await deleteSessionEmbeddings(this.sql, id);
+    await deleteSession(this.sql, id, ctx);
+  }
+  // ============ 消息 ============
+  async getMessages(sessionId, ctx) {
+    await this.ensureInitialized();
+    const session = await this.getSession(sessionId, ctx);
+    if (!session) return [];
+    return getMessages(this.sql, sessionId);
+  }
+  async getMessage(id, ctx) {
+    await this.ensureInitialized();
+    return getMessage(this.sql, id, ctx);
+  }
+  async saveMessage(input, ctx) {
+    await this.ensureInitialized();
+    return saveMessage(this.sql, input, ctx);
+  }
+  async deleteMessagesAfter(sessionId, timestamp, ctx) {
+    await this.ensureInitialized();
+    const session = await this.getSession(sessionId, ctx);
+    if (!session) return;
+    await deleteMessagesAfter(this.sql, sessionId, timestamp);
+  }
+  // ============ 操作日志 ============
+  async getOperations(sessionId, ctx) {
+    await this.ensureInitialized();
+    const session = await this.getSession(sessionId, ctx);
+    if (!session) return [];
+    return getOperations(this.sql, sessionId);
+  }
+  async getOperationsByMessage(messageId, ctx) {
+    await this.ensureInitialized();
+    return getOperationsByMessage(this.sql, messageId, ctx);
+  }
+  async saveOperation(input, ctx) {
+    await this.ensureInitialized();
+    return saveOperation(this.sql, input, ctx);
+  }
+  async updateOperationStatus(id, status, errorMessage) {
+    await this.ensureInitialized();
+    await updateOperationStatus(this.sql, id, status, errorMessage);
+  }
+  // ============ 备份 ============
+  async getBackups(operationId) {
+    await this.ensureInitialized();
+    return getBackups(this.sql, operationId);
+  }
+  async saveBackup(input) {
+    await this.ensureInitialized();
+    return saveBackup(this.sql, input);
+  }
+  async deleteExpiredBackups() {
+    await this.ensureInitialized();
+    return deleteExpiredBackups(this.sql);
+  }
+  // ============ 回收站 ============
+  async getTrashItems(ctx) {
+    await this.ensureInitialized();
+    return getTrashItems(this.sql, ctx);
+  }
+  async moveToTrash(input, ctx) {
+    await this.ensureInitialized();
+    return moveToTrash(this.sql, input, ctx, this.config);
+  }
+  async restoreFromTrash(id, ctx) {
+    await this.ensureInitialized();
+    return restoreFromTrash(this.sql, id, ctx);
+  }
+  async emptyExpiredTrash() {
+    await this.ensureInitialized();
+    return emptyExpiredTrash(this.sql);
+  }
+  // ============ 向量搜索 ============
+  async saveEmbedding(id, content, embedding, metadata, ctx) {
+    await this.ensureInitialized();
+    await saveEmbedding(this.sql, id, content, embedding, metadata, ctx);
+  }
+  async searchSimilar(queryEmbedding, options, ctx) {
+    await this.ensureInitialized();
+    return searchSimilar(this.sql, queryEmbedding, options, ctx);
+  }
+  // ============ 生命周期 ============
+  async close() {
+    await this.sql.end();
+  }
+};
+
+export {
+  PostgresAdapter
+};