web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/implements/threaddb/dbmanager.js

@@ -0,0 +1,1604 @@
+'use strict';
+
+var multiaddr = require('@multiformats/multiaddr');
+var ThreadID = require('@textile/threads-id');
+var peerId = require('@libp2p/peer-id');
+var key = require('../../node_modules/interface-datastore/dist/src/key.js');
+var db = require('./db/db.js');
+var db$1 = require('./core/db.js');
+var ed25519 = require('../../common/dc-key/ed25519.js');
+var crypto = require('@libp2p/crypto');
+var key$1 = require('./common/key.js');
+var keyManager = require('../../common/dc-key/keyManager.js');
+var core = require('./core/core.js');
+var transformedDatastore = require('./common/transformed-datastore.js');
+var utils = require('../../util/utils.js');
+var constants = require('../../common/constants.js');
+var identity = require('./core/identity.js');
+var grpcClient = require('./net/grpcClient.js');
+var define = require('./net/define.js');
+var json2Query = require('./db/json2Query.js');
+var index = require('../../_virtual/index.js');
+var define$1 = require('../../common/define.js');
+var index$1 = require('../../_virtual/index2.js');
+var net_pb = require('./pb/net_pb.js');
+var lineReader = require('./common/lineReader.js');
+var manager = require('../file/manager.js');
+var collection = require('./db/collection.js');
+var query = require('./db/query.js');
+
+const {
+  Buffer
+} = index;
+"/dc/" + define.Protocol.name + "/" + define.Protocol.version;
+const dsManagerBaseKey = new key.Key('/manager');
+function newGrpcClient(client, net) {
+  if (client.p2pNode == null || client.p2pNode.peerId == null) {
+    throw new Error("p2pNode is null or node privateKey is null");
+  }
+  const grpcClient$1 = new grpcClient.DBGrpcClient(client.p2pNode, client.peerAddr, client.token, net, client.protocol);
+  return grpcClient$1;
+}
+// 管理器类  
+class DBManager {
+  constructor(store,
+  //实际上是一个LevelDatastore实例,用levelDatastoreAdapter包装
+  network, dc, connectedDc) {
+    let opts = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let chainUtil = arguments.length > 5 ? arguments[5] : undefined;
+    let storagePrefix = arguments.length > 6 ? arguments[6] : undefined;
+    let context = arguments.length > 7 ? arguments[7] : undefined;
+    Object.defineProperty(this, "store", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "network", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "connectedDc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "opts", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dbs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "lock", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "chainUtil", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "storagePrefix", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.store = store;
+    this.network = network;
+    this.dc = dc;
+    this.storagePrefix = storagePrefix;
+    this.opts = opts;
+    this.dbs = new Map();
+    this.lock = new AsyncLock();
+    this.chainUtil = chainUtil;
+    this.connectedDc = connectedDc;
+    this.context = context;
+  }
+  async loadDbs() {
+    // Query for existing databases
+    console.log("manager: loading dbs");
+    try {
+      const q = {
+        prefix: dsManagerBaseKey.toString(),
+        keysOnly: true
+      };
+      const results = this.store.query(q);
+      // Create a map to track loaded databases and prevent duplicates
+      const loaded = new Map();
+      // Process each result
+      for await (const result of results) {
+        try {
+          // Parse the key to extract thread ID
+          const parts = result.key.toString().split('/');
+          if (parts.length < 3) {
+            continue;
+          }
+          const id = ThreadID.ThreadID.fromString(parts[2] || "");
+          // Check if already loaded
+          if (loaded.has(id.toString())) {
+            continue;
+          }
+          // Mark as loaded
+          loaded.set(id.toString(), true);
+          // Wrap and create database
+          const [store, opts, err] = await this.wrapDB(this.store, id, this.opts, "", []);
+          if (err) {
+            continue;
+          }
+          const db$1 = await db.DB.newDB(store, this.network, id, opts);
+          // Add to map of databases
+          this.dbs.set(id.toString(), db$1);
+        } catch (err) {
+          console.error(`Error loading database: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    } catch (err) {
+      console.error(`Failed to load databases: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+  /**
+  * Gets the log key for a thread. If it doesn't exist, creates a new one.
+  * @param tid Thread ID
+  * @returns Promise resolving to the private key
+  * @throws Error if key operations fail
+  */
+  async getLogKey(tid) {
+    const storageKey = `${this.storagePrefix}_${tid.toString()}_logkey`;
+    try {
+      // Try to get existing key from localStorage  
+      const storedBytes = await this.store.get(new key.Key(storageKey));
+      if (storedBytes) {
+        const key = ed25519.Ed25519PrivKey.fromString(Buffer.from(storedBytes).toString('hex'));
+        return key;
+      } else {
+        // Create new key if none exists  
+        const key$1 = await this.newLogKey();
+        this.store.put(new key.Key(storageKey), Buffer.from(key$1.raw));
+        return key$1;
+      }
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') {
+        // Create new key if none exists  
+        const key$1 = await this.newLogKey();
+        this.store.put(new key.Key(storageKey), Buffer.from(key$1.raw));
+        return key$1;
+      }
+      throw new Error(`Failed to get/create log key: ${err}`);
+    }
+  }
+  /**
+  * Creates a new log key
+  * @private
+  */
+  async newLogKey() {
+    try {
+      //生成临时ed25519公私钥对
+      const keyPair = await crypto.keys.generateKeyPair("Ed25519");
+      // 获取私钥
+      const privateKey = new ed25519.Ed25519PrivKey(keyPair.raw);
+      return privateKey;
+    } catch (err) {
+      throw new Error(`Failed to generate log key: ${err}`);
+    }
+  }
+  // 新增静态方法  
+  /**
+   * FromAddr returns ID from a multiaddress if present.
+   * @param addr Multiaddr instance
+   * @returns ID instance
+   */
+  static fromAddr(addr) {
+    try {
+      // 获取协议值  
+      const parts = addr.toString().split('/');
+      const index = parts.indexOf(define.Protocol.name);
+      if (index === -1 || index === parts.length - 1) {
+        throw new Error('thread protocol not found in multiaddr');
+      }
+      const idstr = parts[index + 1] || "";
+      return ThreadID.ThreadID.fromString(idstr);
+    } catch (err) {
+      throw new Error(`Failed to extract ID from multiaddr: ${err.message}`);
+    }
+  }
+  /**
+   * ToAddr returns ID wrapped as a multiaddress.
+   * @returns Multiaddr instance
+   */
+  toAddr() {
+    try {
+      const addr = multiaddr.multiaddr(`/${define.Protocol.name}/${this.toString()}`);
+      return addr;
+    } catch (err) {
+      // This should not happen with valid IDs  
+      throw new Error(`Failed to create multiaddr: ${err.message}`);
+    }
+  }
+  async newDBFromAddr(addr, key) {
+    let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const id = addr.id;
+    return await this.lock.acquire('dbs', async () => {
+      if (this.dbs.has(id.toString())) {
+        throw db$1.Errors.ErrDBExists;
+      }
+      if (opts.name && !isValidName(opts.name)) {
+        throw db$1.Errors.ErrInvalidName;
+      }
+      if (key.defined() && !key.canRead()) {
+        throw db$1.Errors.ErrThreadReadKeyRequired;
+      }
+      await this.network.addThread(addr, {
+        token: opts.token,
+        logKey: opts.logKey,
+        threadKey: key
+      });
+      const collections = opts.collections || [];
+      const name = opts.name || '';
+      const [store, dbOpts, err] = await this.wrapDB(this.store, id, this.opts, name, collections);
+      if (err) {
+        throw new Error(`wrapping db: ${err.message}`);
+      }
+      const db$2 = await db.DB.newDB(store, this.network, id, dbOpts);
+      this.dbs.set(id.toString(), db$2);
+      if (opts.block) {
+        await this.network.pullThread(id, db$1.pullThreadBackgroundTimeout, {
+          token: opts.token
+        });
+      } else {
+        // Background pull  
+        this.pullThreadBackground(id, opts.token);
+      }
+      return db$2;
+    });
+  }
+  async pullThreadBackground(id, token) {
+    try {
+      await this.network.pullThread(id, db$1.pullThreadBackgroundTimeout, {
+        token: token
+      });
+    } catch (err) {
+      console.error(`Error pulling thread ${id}:`, err);
+    }
+  }
+  /**
+   * Preloads a database from DC network to local
+   * Generally happens when a new device first logs in to sync previously created databases
+   *
+   * @param threadid Thread ID string
+   * @param fid Content ID string of the file to preload
+   * @param dbname Database name
+   * @param dbAddr Database address string
+   * @param b32Rk Base32-encoded read key
+   * @param b32Sk Base32-encoded secret key
+   * @param block Whether to block until syncing is complete
+   * @param jsonCollections JSON string of collection configurations
+   * @returns Promise that resolves when preloading is complete
+   */
+  async preloadDBFromDC(threadid, fid, dbname, dbAddr, b32Rk, b32Sk, block, jsonCollections) {
+    console.debug(`manager: preloading DB from DC ${threadid}`);
+    // Check if DBManager exists
+    if (!this) {
+      throw db$1.Errors.ErrNoDbManager;
+    }
+    // Decode thread ID
+    let tID;
+    try {
+      tID = await this.decodeThreadId(threadid);
+    } catch (err) {
+      throw err;
+    }
+    // Get log key
+    let logKey;
+    try {
+      logKey = await this.getLogKey(tID);
+    } catch (err) {
+      throw err;
+    }
+    // Create peer ID from log key
+    let lid;
+    try {
+      lid = peerId.peerIdFromPrivateKey(logKey);
+    } catch (err) {
+      throw err;
+    }
+    // Begin connection in background
+    await this.dc._connectToObjNodes(tID.toString()).catch(err => console.error(`Error connecting to object nodes: ${err.message}`));
+    const ctx = createContext(30000);
+    try {
+      await this.addLogToThreadStart(ctx, tID, lid);
+    } catch (err) {
+      console.warn(`Warning: could not add log to thread: ${err.message}`);
+    }
+    // Generate thread key
+    let threadKey;
+    try {
+      const sk = key$1.SymmetricKey.fromString(b32Sk);
+      const rk = key$1.SymmetricKey.fromString(b32Rk);
+      threadKey = new key$1.Key(sk, rk);
+    } catch (err) {
+      throw err;
+    }
+    let connectedPeerId;
+    let multiAddr;
+    // Try to connect using provided dbAddr
+    let connectedFlag = false;
+    if (dbAddr.length > 10) {
+      try {
+        // Try to parse address info and connect
+        const peerAddrInfo = multiaddr.multiaddr(dbAddr);
+        try {
+          const conn = await this.dc.dcNodeClient?.libp2p.dial(peerAddrInfo, {
+            signal: AbortSignal.timeout(3000)
+          });
+          if (conn) {
+            connectedFlag = true;
+            multiAddr = multiaddr.multiaddr(dbAddr);
+          }
+        } catch (err) {
+          // Connection failed
+        }
+      } catch (err) {
+        // Invalid address
+      }
+    }
+    // If direct connection failed, connect through object nodes
+    if (!connectedFlag) {
+      try {
+        const [connectedAddr, peers] = await this.dc?._connectToObjNodes(tID.toString());
+        if (!connectedAddr && peers) {
+          // 有peers但是没有connectedAddr
+          throw db$1.Errors.ErrNoThreadOnDc;
+        }
+        const conns = this.dc.dcNodeClient?.libp2p.getConnections(connectedPeerId);
+        if (!conns || conns.length == 0) {
+          throw db$1.Errors.ErrNoThreadOnDc;
+        }
+      } catch (err) {
+        throw err;
+      }
+    } else {
+      // Start connection in background
+      this.dc._connectToObjNodes(tID.toString()).catch(err => console.error(`Error connecting to object nodes: ${err.message}`));
+    }
+    // Parse collection info
+    let collectionInfos = [];
+    try {
+      collectionInfos = JSON.parse(jsonCollections);
+    } catch (err) {
+      throw err;
+    }
+    // Create collection configurations
+    const collections = collectionInfos.map(info => ({
+      name: info.name,
+      schema: info.schema,
+      indexes: info.indexes || []
+    }));
+    // Create options for new database
+    const dbOpts = {
+      name: dbname,
+      collections: collections,
+      key: threadKey,
+      logKey: logKey,
+      block: block
+    };
+    // Delete existing database if it exists
+    try {
+      await this.deleteDB(tID, true);
+    } catch (err) {
+      // Ignore specific errors
+      if (err !== db$1.Errors.ErrDBNotFound && err !== db$1.Errors.ErrThreadNotFound) {
+        throw err;
+      }
+    }
+    if (this.dc.dcNodeClient == null) {
+      throw db$1.Errors.ErrNoDcNodeClient;
+    }
+    // Create context with extended timeout for file download
+    const tctx = createContext(db$1.PullTimeout * 30);
+    const fileManager = new manager.FileManager(this.dc, this.connectedDc, this.chainUtil, this.dc.dcNodeClient, this.context);
+    const fileStream = await fileManager.createSeekableFileStream(fid, "");
+    if (fileStream == null) {
+      throw db$1.Errors.ErrFileNotFound;
+    }
+    // Preload database from reader
+    const threadMultiaddr = new core.ThreadMuliaddr(multiAddr, tID);
+    await this.preloadDBFromReader(tctx, fileStream.createReadableStream(), threadMultiaddr, threadKey, dbOpts);
+  }
+  /**
+   * 从读取器预加载数据库
+   * @param ctx 上下文
+   * @param ioReader 数据流读取器
+   * @param addr 线程地址
+   * @param key 线程密钥
+   * @param opts 管理选项
+   */
+  async preloadDBFromReader(ctx, ioReader, addr, key) {
+    let opts = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    console.debug("manager: preloading db from reader");
+    let id;
+    try {
+      id = DBManager.fromAddr(addr.addr);
+    } catch (err) {
+      throw err;
+    }
+    // 检查数据库是否已存在
+    await this.lock.acquire('dbs', async () => {
+      if (this.dbs.has(id.toString())) {
+        throw db$1.Errors.ErrDBExists;
+      }
+    });
+    if (opts.name && !isValidName(opts.name)) {
+      throw db$1.Errors.ErrInvalidName;
+    }
+    // 验证密钥
+    if (key.defined() && !key.canRead()) {
+      throw db$1.Errors.ErrThreadReadKeyRequired;
+    }
+    // 添加线程到网络
+    console.debug(`manager: adding thread to net ${id}`);
+    try {
+      await this.network.addThread(addr, {
+        threadKey: key,
+        logKey: opts.logKey,
+        token: opts.token
+      });
+    } catch (err) {
+      throw err;
+    }
+    console.debug(`manager: added thread to net ${id}`);
+    // 包装数据库
+    let store;
+    let dbOpts;
+    try {
+      const collections = opts.collections || [];
+      const name = opts.name || '';
+      [store, dbOpts] = await this.wrapDB(this.store, id, this.opts, name, collections);
+    } catch (err) {
+      throw err;
+    }
+    // 创建新数据库
+    let db$2;
+    try {
+      db$2 = await db.DB.newDB(store, this.network, id, dbOpts);
+    } catch (err) {
+      throw err;
+    }
+    // 添加数据库到管理器
+    await this.lock.acquire('dbs', async () => {
+      this.dbs.set(id.toString(), db$2);
+    });
+    // 导入数据库状态
+    const readKey = key.read();
+    if (!readKey) {
+      throw new Error(`read key not found for thread ${id}`);
+    }
+    // 创建行读取器
+    const lineReader$1 = new lineReader.LineReader(ioReader);
+    new TextDecoder();
+    // 读取第一行并更新线程信息的日志头
+    let stateValue = "";
+    try {
+      const value = await lineReader$1.readLine();
+      if (value) {
+        stateValue = value;
+      }
+    } catch (err) {
+      throw err;
+    }
+    if (stateValue == "") {
+      throw new Error(`empty state value for thread ${id}`);
+    }
+    // 移除头部32位hash
+    stateValue = stateValue.slice(32);
+    // 更新线程信息的日志头
+    const logs = stateValue.split(';');
+    const pbLogs = [];
+    for (const log of logs) {
+      try {
+        // 解码 multibase 格式
+        const data = index$1.srcExports.decode(log);
+        // 解析 protobuf
+        const pbLog = net_pb.net.pb.Log.decode(data);
+        pbLogs.push(pbLog);
+      } catch (err) {
+        // 忽略错误，继续处理
+        continue;
+      }
+    }
+    // 预加载日志
+    try {
+      await this.network.preLoadLogs(id, pbLogs);
+    } catch (err) {
+      await this.deleteDB(id, false);
+      throw err;
+    }
+    // 导入数据库状态
+    try {
+      await this.importDBStateFromReader(id, lineReader$1, readKey);
+    } catch (err) {
+      await this.deleteDB(id, false);
+      throw err;
+    }
+  }
+  /**
+   * Browser-compatible version to export DB to file
+   * @param ctx Context
+   * @param id ThreadID
+   * @param fileName Suggested file name for download
+   * @param readKey Optional encryption key
+   * @returns Promise resolving to ThreadInfo
+   */
+  async exportDBToFile(ctx, id, fileName, readKey) {
+    console.debug(`manager: exporting db ${id.toString()} to file download`);
+    // Get thread logs similar to original function
+    let logState = "";
+    let logs;
+    let threadInfo;
+    [logs, threadInfo] = await this.network.getPbLogs(id);
+    // Build log state string
+    for (let i = 0; logs && i < logs.length; i++) {
+      if (!logs[i]) {
+        continue; // Skip undefined logs
+      }
+      const log = logs[i];
+      const logBytes = net_pb.net.pb.Log.encode(log).finish();
+      const mbaseLog = index$1.default.encode('base64', logBytes);
+      if (i === 0) {
+        logState = mbaseLog.toString();
+      } else {
+        logState = `${logState};${mbaseLog.toString()}`;
+      }
+    }
+    // Create content in memory instead of writing to file
+    let content = logState + "\n";
+    // Get database
+    const db = this.dbs.get(id.toString());
+    if (!db) {
+      throw db$1.Errors.ErrDBNotFound;
+    }
+    // Create transaction
+    const txn = await db.datastore.newTransactionExtended(true);
+    try {
+      // Similar query logic, but accumulating in memory
+      const q = new query.Query();
+      const baseKey = new key.Key('/');
+      const i = await collection.newIterator(txn, baseKey, q);
+      for await (const res of i.iter.next()) {
+        if (res.error) {
+          throw res.error;
+        }
+        let line;
+        if (readKey) {
+          const encBytes = await readKey.encrypt(res.entry.value);
+          const mValue = index$1.default.encode('base64', encBytes);
+          line = `${res.entry.key}|${mValue.toString()}`;
+        } else {
+          const mValue = index$1.default.encode('base64', res.entry.value);
+          line = `${res.entry.key}|${mValue.toString()}`;
+        }
+        content += line + "\n";
+      }
+      i.close();
+      txn.discard();
+      // Create blob and trigger download
+      const blob = new Blob([content], {
+        type: 'text/plain'
+      });
+      const url = URL.createObjectURL(blob);
+      // Create download link
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = fileName || `db-export-${id.toString().substring(0, 8)}.txt`;
+      // Append to body, click and remove
+      document.body.appendChild(a);
+      a.click();
+      // Cleanup
+      setTimeout(() => {
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+      }, 100);
+      return threadInfo;
+    } catch (err) {
+      txn.discard();
+      throw err;
+    }
+  }
+  /**
+   * 从读取器导入数据库状态
+   * @param id 线程ID
+   * @param reader 可读流读取器
+   * @param readKey 用于解密的对称密钥
+   */
+  async importDBStateFromReader(id, lineReader, readKey) {
+    console.debug("manager: importing db state from reader");
+    // 检查数据库是否存在
+    let db;
+    await this.lock.acquire('dbs', async () => {
+      db = this.dbs.get(id.toString());
+    });
+    if (!db) {
+      throw db$1.Errors.ErrDBNotFound;
+    }
+    // 获取索引函数
+    const indexFunc = db.defaultIndexFunc();
+    // 设置行读取
+    new TextDecoder();
+    let line = "";
+    while (true) {
+      line = await lineReader.readLine();
+      if (!line) {
+        break;
+      }
+      // 创建事务
+      let txn;
+      try {
+        txn = await db.datastore.newTransactionExtended(false);
+      } catch (err) {
+        throw new Error(`创建事务错误: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        // 解析键值对
+        const kv = line.split('|');
+        if (kv.length !== 2) {
+          txn.discard();
+          throw new Error('无效的记录格式');
+        }
+        const key$1 = kv[0];
+        const mValue = kv[1] || '';
+        // 使用multibase解码值
+        let encValue;
+        try {
+          const decoded = index$1.srcExports.decode(mValue);
+          encValue = decoded;
+        } catch (err) {
+          await txn.discard();
+          throw new Error(`multibase解码失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // 如有需要解密记录
+        let decValue = encValue;
+        if (readKey) {
+          try {
+            decValue = await readKey.decrypt(encValue);
+          } catch (err) {
+            await txn.discard();
+            throw new Error(`解密值失败: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        // 创建数据存储键
+        const setKey = new key.Key(key$1 || "");
+        // 检查键是否已存在
+        try {
+          const exists = await txn.has(setKey);
+          if (exists) {
+            txn.discard();
+            continue; // 跳过此记录
+          }
+        } catch (err) {
+          txn.discard();
+          throw new Error(`检查键存在性失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // 存储值
+        try {
+          await txn.put(setKey, decValue);
+        } catch (err) {
+          txn.discard();
+          throw new Error(`存储值失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // 从键中提取集合名称（倒数第二个部分）
+        const parts = key$1?.split('/');
+        if (!parts || parts.length < 2) {
+          txn.discard();
+          throw new Error('无效的键格式: 未找到集合名称');
+        }
+        const collection = parts[parts.length - 2] || "";
+        // 应用索引
+        try {
+          await indexFunc(collection, setKey, txn, decValue);
+        } catch (err) {
+          txn.discard();
+          throw new Error(`应用索引失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // 提交事务
+        try {
+          await txn.commit();
+        } catch (err) {
+          txn.discard();
+          throw new Error(`提交事务失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      } catch (err) {
+        // 确保在任何失败时丢弃事务
+        try {
+          txn.discard();
+        } catch {
+          // 忽略丢弃时的错误
+        }
+        throw err;
+      }
+    }
+  }
+  /**
+   * wrapDB 复制管理器的基本配置，
+   * 使用 ID 前缀包装数据存储，
+   * 并将指定的集合配置与基本配置合并
+   */
+  async wrapDB(store, id, base, name, collections) {
+    const isValid = await this.validateThreadId(id.toString());
+    if (!isValid) {
+      return [null, null, new Error('Invalid Thread ID')];
+    }
+    // 创建前缀转换器并包装数据存储  
+    const prefix = dsManagerBaseKey.child(new key.Key(id.toString())).toString();
+    const transform = new transformedDatastore.PrefixTransform(prefix);
+    //const wrappedStore = new TransformedDatastore(store, transform); 
+    const wrappedStore = transformedDatastore.createTransformedDatastore(store, transform);
+    // 创建新的选项对象  
+    const opts = {
+      name: name,
+      collections: [...(base.collections || []), ...collections],
+      eventCodec: base.eventCodec,
+      debug: base.debug
+    };
+    return [wrappedStore, opts, null];
+  }
+  async listDBs() {
+    const dbs = new Map();
+    await this.lock.acquire('dbs', async () => {
+      for (const [idStr, db] of this.dbs) {
+        const id = ThreadID.ThreadID.fromString(idStr);
+        await this.network.getThread(id);
+        dbs.set(id, db);
+      }
+    });
+    return dbs;
+  }
+  async ifSyncDBToDCSuccess(tId) {
+    try {
+      const [storeUnit, err] = await this.chainUtil.objectState(tId);
+      if (!storeUnit || err) return false;
+      return new Promise(resolve => {
+        const timeout = setTimeout(() => resolve(false), db$1.PullTimeout);
+        const checkPeers = async () => {
+          for (const pid of Object.keys(storeUnit.peers)) {
+            try {
+              const peerId$1 = peerId.peerIdFromString(pid);
+              const threadId = ThreadID.ThreadID.fromString(tId);
+              const remoteInfo = await this.network.getThreadFromPeer(threadId, peerId$1, {});
+              const localInfo = await this.network.getThread(threadId);
+              if (this.compareThreadSync(localInfo, remoteInfo, storeUnit)) {
+                clearTimeout(timeout);
+                resolve(true);
+                return;
+              }
+            } catch {
+              continue;
+            }
+          }
+          resolve(false);
+        };
+        checkPeers();
+      });
+    } catch {
+      return false;
+    }
+  }
+  compareThreadSync(local, remote, storeUnit) {
+    for (const logInfo of local.logs) {
+      if (!storeUnit.logs.has(logInfo.id.toString())) {
+        continue;
+      }
+      if (!logInfo.head) {
+        continue;
+      }
+      const remoteLog = remote.logs.find(l => l.id === logInfo.id);
+      if (!remoteLog?.head) {
+        return false;
+      }
+      if (!remoteLog || logInfo.head.counter > remoteLog.head.counter) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async ifDbInitSuccess(tid) {
+    try {
+      const logKey = await this.getLogKey(tid);
+      const lid = peerId.peerIdFromPrivateKey(logKey);
+      const [threadInfo, err] = await this.chainUtil.objectState(tid.toString());
+      if (!threadInfo || err) {
+        return false;
+      }
+      const exist = threadInfo ? threadInfo?.logs.has(lid.toString()) : false;
+      return exist;
+    } catch {
+      return false;
+    }
+  }
+  async syncDBFromDC(ctx, threadid, dbname, dbAddr, b32Rk, b32Sk, block, collectionInfos) {
+    try {
+      const tID = await this.decodeThreadId(threadid);
+      const logKey = await this.getLogKey(tID);
+      const lid = peerId.peerIdFromPrivateKey(logKey);
+      await this.dc._connectToObjNodes(threadid);
+      await this.addLogToThreadStart(ctx, tID, lid);
+      const sk = key$1.SymmetricKey.fromString(b32Sk);
+      const rk = key$1.SymmetricKey.fromString(b32Rk);
+      const threadKey = new key$1.Key(sk, rk);
+      let connectedFlag = false;
+      let connectedConn;
+      let fullMultiAddr;
+      let threadAddr;
+      let connectedPeerId;
+      let dbMultiAddr;
+      if (dbAddr.length > 0) {
+        try {
+          //
+          connectedConn = await this.dc.dcNodeClient?.libp2p.dial(multiaddr.multiaddr(dbAddr), {
+            signal: AbortSignal.timeout(define$1.dial_timeout)
+          });
+        } catch (error) {
+          const errMsg = error.message;
+          console.log("connect to %s catch return, error:%s", dbAddr, errMsg);
+        }
+      }
+      if (connectedConn) {
+        //连接成功
+        connectedPeerId = connectedConn?.remotePeer;
+        dbMultiAddr = connectedConn.remoteAddr;
+      } else {
+        //从区块链中获取节点信息,再连接
+        const [connectedAddr, peers] = await this.dc._connectToObjNodes(threadid);
+        if (!connectedAddr) {
+          throw new Error("connect to obj nodes failed");
+        }
+        dbMultiAddr = connectedAddr;
+      }
+      const collections = collectionInfos.map(info => ({
+        name: info.name,
+        schema: info.schema,
+        indexes: info.indexes || []
+      }));
+      const dbOpts = {
+        name: dbname,
+        collections: collections,
+        key: threadKey,
+        logKey: logKey,
+        block: block
+      };
+      // Delete existing database if present  
+      try {
+        await this.deleteDB(tID, false);
+      } catch (error) {
+        const errMsg = error.message;
+        if (errMsg != db$1.Errors.ErrDBNotFound.message && errMsg != db$1.Errors.ErrThreadNotFound.message) {
+          throw error;
+        }
+      }
+      const threadMultiaddr = new core.ThreadMuliaddr(dbMultiAddr, tID);
+      await this.newDBFromAddr(threadMultiaddr, threadKey, dbOpts);
+      return null;
+    } catch (error) {
+      const errMsg = error.message;
+      if (errMsg == db$1.Errors.ErrorThreadIDValidation.message) {
+        return errMsg;
+      }
+      return error;
+    }
+  }
+  async getDBRecordsCount(threadid) {
+    let count = 0;
+    try {
+      const tid = await this.decodeThreadId(threadid);
+      const threadInfo = await this.network.getThread(tid);
+      if (!threadInfo) {
+        return count;
+      }
+      for (const logInfo of threadInfo.logs) {
+        if (!logInfo.head) {
+          continue;
+        }
+        if (count < logInfo.head.counter) {
+          count = logInfo.head.counter;
+        }
+      }
+    } catch (error) {
+      console.error(`Error getting records count for thread ${threadid}:`, error);
+    }
+    return count;
+  }
+  async addLogToThread(ctx, id, lid) {
+    let blockHeight;
+    try {
+      blockHeight = (await this.chainUtil.getBlockHeight()) || 0;
+    } catch (err) {
+      throw err;
+    }
+    // 生成用户签名   
+    const hValue = utils.uint32ToLittleEndianBytes(blockHeight ? blockHeight : 0);
+    const peerIdValue = new TextEncoder().encode(this.connectedDc.nodeAddr?.getPeerId() || "");
+    const preSign = new Uint8Array([...new TextEncoder().encode(id.toString()), ...new TextEncoder().encode(lid.toString()), ...hValue, ...peerIdValue]);
+    let signature;
+    try {
+      signature = await this.context.sign(preSign);
+    } catch (err) {
+      throw err;
+    }
+    if (!this.connectedDc?.client) {
+      throw db$1.Errors.ErrNoDcPeerConnected;
+    }
+    const opts = {
+      token: new identity.ThreadToken(this.connectedDc.client.token),
+      blockHeight: blockHeight,
+      signature: signature
+    };
+    const dbClient = newGrpcClient(this.connectedDc.client, this.network);
+    await dbClient.addLogToThread(id.toString(), lid.toString(), opts);
+  }
+  async addLogToThreadStart(ctx, id, lid) {
+    if (!ctx) {
+      ctx = createContext(30000);
+    }
+    const abortController = new AbortController();
+    const signal = ctx?.signal || abortController.signal;
+    const [storeUnit, err] = await this.chainUtil.objectState(id.toString());
+    if (storeUnit && !err) {
+      const userPubkey = this.context.getPublicKey();
+      let findFlag = false;
+      for (const user of storeUnit.users) {
+        //移除0x前缀
+        const noPrefixUser = user.replace("0x", "");
+        if (noPrefixUser === userPubkey.toString()) {
+          findFlag = true;
+          break;
+        }
+      }
+      if (!findFlag) {
+        throw new Error('user not in the thread');
+      }
+    }
+    // 处理超时  
+    let timeoutId = null;
+    if (ctx.deadline) {
+      const timeout = ctx.deadline.getTime() - Date.now();
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          abortController.abort();
+        }, timeout);
+      }
+    }
+    let count = 0;
+    const maxCount = 6;
+    let endFlag = false;
+    try {
+      await this.addLogToThread(ctx, id, lid);
+    } catch (error) {//允许报错
+    }
+    const ticker = setInterval(async () => {
+      // 检查是否已被取消  
+      if (signal.aborted) {
+        clearInterval(ticker);
+        if (timeoutId) clearTimeout(timeoutId);
+        return;
+      }
+      if (await this.ifDbInitSuccess(id)) {
+        clearInterval(ticker);
+        if (timeoutId) clearTimeout(timeoutId);
+        endFlag = true;
+        return;
+      }
+      if (count >= maxCount) {
+        //每6秒确认
+        await this.addLogToThread(ctx, id, lid);
+        count = 0;
+      } else {
+        count++;
+      }
+    }, 1000); // 每秒执行一次  
+    await new Promise(resolve => {
+      // Add a resolving condition to the interval
+      const checkFlag = setInterval(() => {
+        if (endFlag) {
+          clearInterval(checkFlag);
+          resolve();
+        }
+      }, 1000);
+      // Also make sure the abort signal resolves the promise
+      signal.addEventListener('abort', () => {
+        clearInterval(checkFlag);
+        resolve();
+      });
+    });
+  }
+  async newDB(dbname, b32Rk, b32Sk, collectionInfos) {
+    if (!this.connectedDc?.client) {
+      return ['', db$1.Errors.ErrNoDcPeerConnected];
+    }
+    try {
+      const dbClient = newGrpcClient(this.connectedDc.client, this.network);
+      const tidStr = await dbClient.requestThreadID();
+      const threadID = await this.decodeThreadId(tidStr);
+      const logKey = await this.getLogKey(threadID);
+      const lpk = logKey.publicKey;
+      const lid = peerId.peerIdFromPrivateKey(logKey);
+      const sk = key$1.SymmetricKey.fromString(b32Sk);
+      const rk = key$1.SymmetricKey.fromString(b32Rk);
+      const threadKey = new key$1.Key(sk, rk);
+      const blockHeight = (await this.chainUtil.getBlockHeight()) || 0;
+      const hValue = utils.uint32ToLittleEndianBytes(blockHeight ? blockHeight : 0);
+      if (!this.connectedDc?.nodeAddr) {
+        return ['', db$1.Errors.ErrNodeAddrIsNull];
+      }
+      const rPeerId = await keyManager.extractPeerIdFromMultiaddr(this.connectedDc.nodeAddr);
+      const peerIdValue = new TextEncoder().encode(rPeerId.toString());
+      const sizeValue = utils.uint64ToLittleEndianBytes(50 << 20); //数据库固定大小50M
+      const tidUnit8Array = new TextEncoder().encode(tidStr);
+      const typeValue = utils.uint32ToLittleEndianBytes(constants.Type.Threaddbtype);
+      const preSign = new Uint8Array([...tidUnit8Array, ...sizeValue, ...hValue, ...typeValue, ...peerIdValue]);
+      const signature = await this.context.sign(preSign);
+      // Create thread options  
+      const opts = {
+        threadKey: threadKey,
+        logKey: logKey,
+        token: new identity.ThreadToken(this.connectedDc.client.token),
+        blockHeight: blockHeight,
+        signature: signature
+      };
+      const threadInfo = await dbClient.createThread(threadID.toString(), opts);
+      const collections = collectionInfos.map(info => ({
+        name: info.name,
+        schema: info.schema,
+        indexes: info.indexes || []
+      }));
+      const dbOpts = {
+        name: dbname,
+        collections: collections,
+        key: threadKey,
+        logKey: logKey,
+        block: true
+      };
+      // Try creating database  
+      const errors = [];
+      for (const multiAddr of threadInfo.addrs) {
+        try {
+          await this.newDBFromAddr(multiAddr, threadKey, dbOpts);
+          break;
+        } catch (error) {
+          errors.push(error.message);
+        }
+      }
+      if (errors.length === threadInfo.addrs.length) {
+        throw new Error(`create db failed:${errors.join(',')}`);
+      }
+      const ctx = createContext(30000);
+      await this.addLogToThreadStart(ctx, threadID, lid);
+      return [threadID.toString(), null];
+    } catch (error) {
+      return ['', error];
+    }
+  }
+  async refreshDBFromDC(threadId) {
+    try {
+      const tId = await this.decodeThreadId(threadId);
+      await this.network.pullThread(tId, 600);
+      return null;
+    } catch (error) {
+      return error;
+    }
+  }
+  async syncDBToDC(threadId) {
+    if (!this.network) {
+      return db$1.Errors.ErrP2pNetworkNotInit;
+    }
+    try {
+      const tId = await this.decodeThreadId(threadId);
+      await this.network.exchange(tId);
+      return null;
+    } catch (error) {
+      return error;
+    }
+  }
+  async upgradeCollections(threadId, configs) {
+    try {
+      const tId = await this.decodeThreadId(threadId);
+      const db = this.dbs.get(tId.toString());
+      if (!db) {
+        return db$1.Errors.ErrDBNotFound;
+      }
+      await db.upgradeCollections(configs);
+      return null;
+    } catch (error) {
+      return error;
+    }
+  }
+  async decodeThreadId(threadid) {
+    if (!threadid) {
+      throw new Error('Thread ID is empty');
+    }
+    try {
+      // 基本格式验证  
+      if (!/^[a-zA-Z0-9]+$/.test(threadid)) {
+        throw db$1.Errors.ErrorThreadIDValidation;
+      }
+      // 尝试解码  
+      const threadID = ThreadID.ThreadID.fromString(threadid);
+      // 验证长度  
+      const bytes = threadID.toBytes();
+      if (bytes.length < 32) {
+        throw new Error('Thread ID too short');
+      }
+      return threadID;
+    } catch (error) {
+      const errMsg = error.message;
+      if (errMsg === db$1.Errors.ErrorThreadIDValidation.message) {
+        throw error;
+      }
+      throw new Error(`Failed to decode thread ID: $errMsg}`);
+    }
+  }
+  // 为了方便使用，可以添加一个验证方法  
+  async validateThreadId(threadid) {
+    try {
+      await this.decodeThreadId(threadid);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    await this.lock.acquire('dbs', async () => {
+      for (const db of this.dbs.values()) {
+        await db.close();
+      }
+      this.dbs.clear();
+    });
+  }
+  /**
+   * Gets a database by ID
+   * @param ctx The context for the operation
+   * @param id The thread ID of the database
+   * @param opts Optional managed options
+   * @returns Promise resolving to the database instance
+   * @throws Error if the database cannot be found
+   */
+  async getDB(id, opts) {
+    console.debug(`manager: getting db ${id}`);
+    console.debug(`manager: getting thread ${id} from net`);
+    try {
+      // Get thread from the network
+      await this.network.getThread(id, {
+        token: opts?.token
+      });
+      console.debug(`manager: got thread ${id} from net`);
+    } catch (err) {
+      throw err;
+    }
+    const db = this.dbs.get(id.toString());
+    if (!db) {
+      throw db$1.Errors.ErrDBNotFound;
+    }
+    return db;
+  }
+  async getDBInfo(id, opts) {
+    let dbInfo = null;
+    try {
+      const db = this.dbs.get(id.toString());
+      if (!db) {
+        throw db$1.Errors.ErrDBNotFound;
+      }
+      dbInfo = await db.getDBInfo(opts);
+      if (!dbInfo || dbInfo === null) {
+        throw new Error(`No info available for db ${id}`);
+      }
+    } catch (err) {
+      console.error(`Error getting DB info for ${id}:`, err);
+      return [null, err];
+    }
+    return [dbInfo, null];
+  }
+  // DeleteDB deletes a db by id.
+  async deleteDB(id, deleteThreadFlag, opts) {
+    console.debug(`manager: deleting db ${id}`);
+    console.debug(`manager: getting thread ${id} from net`);
+    try {
+      await this.network.getThread(id, {
+        token: opts?.token
+      });
+      console.debug(`manager: got thread ${id} from net`);
+    } catch (err) {
+      throw err;
+    }
+    const db = this.dbs.get(id.toString());
+    if (!db) {
+      throw db$1.Errors.ErrDBNotFound;
+    }
+    try {
+      await db.close();
+    } catch (err) {
+      throw err;
+    }
+    if (deleteThreadFlag) {
+      console.debug(`manager: deleting thread ${id} from net`);
+      try {
+        await this.network.deleteThread(id, {
+          token: opts?.token,
+          apiToken: db.connector?.token
+        });
+        console.debug(`manager: deleted thread ${id} from net`);
+      } catch (err) {
+        throw err;
+      }
+    }
+    try {
+      await this.deleteThreadNamespace(id);
+    } catch (err) {
+      throw err;
+    }
+    this.lock.acquire('dbs', async () => {
+      this.dbs.delete(id.toString());
+      console.debug(`manager: deleted db ${id}`);
+    });
+  }
+  async deleteThreadNamespace(id) {
+    const pre = dsManagerBaseKey.child(new key.Key(id.toString())).toString();
+    const q = {
+      prefix: pre,
+      keysOnly: true
+    };
+    const results = this.store.query(q);
+    for await (const result of results) {
+      await this.store.delete(result.key);
+    }
+  }
+  /**********************数据库数据操作相关**********************/
+  /**
+       * Create creates new instances of objects in a collection
+       * @param threadId Thread ID string
+       * @param collectionName Collection name
+       * @param jsonInstance JSON string representing the instance
+       * @returns Promise resolving to the created instance ID
+       * @throws Error if creation fails
+       */
+  async create(threadId, collectionName, jsonInstance) {
+    // // 检查实例大小
+    // if (jsonInstance.length > 100 * 1024) { // 100 KB
+    // throw new Error("instance too big");
+    // }
+    // 判断instance里面是否有_mod字段,存在则删除
+    try {
+      const instanceObj = JSON.parse(jsonInstance);
+      if (instanceObj && typeof instanceObj === 'object' && '_mod' in instanceObj) {
+        delete instanceObj._mod;
+        jsonInstance = JSON.stringify(instanceObj);
+      }
+    } catch (err) {
+      // JSON解析失败，保持原字符串不变
+      console.warn('Failed to parse instance JSON, keeping original:', err);
+      throw new Error("Invalid instance JSON format");
+    }
+    try {
+      // 解码threaddbID
+      const tID = ThreadID.ThreadID.fromString(threadId);
+      // 获取threaddb数据库
+      const threadDB = await this.getDB(tID);
+      // 获取集合
+      const collection = threadDB.getCollection(collectionName);
+      if (!collection) {
+        throw new Error("Collection does not exist");
+      }
+      // 创建实例
+      const instanceID = await collection.create(Buffer.from(jsonInstance));
+      // 返回实例ID
+      return instanceID ? instanceID.toString() : "";
+    } catch (err) {
+      console.error(`Failed to create instance: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+  /**
+       * Delete deletes an instance by ID
+       * @param threadId Thread ID string
+       * @param collectionName Collection name
+       * @param instanceID Instance ID to delete
+       * @throws Error if deletion fails
+       */
+  async delete(threadId, collectionName, instanceID) {
+    try {
+      // 解码线程ID
+      const tID = ThreadID.ThreadID.fromString(threadId);
+      // 获取线程数据库
+      const threadDB = await this.getDB(tID);
+      // 获取集合
+      const collection = threadDB.getCollection(collectionName);
+      if (!collection) {
+        throw new Error("Collection does not exist");
+      }
+      // 删除实例
+      await collection.delete(instanceID);
+    } catch (err) {
+      console.error(`Failed to delete instance: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+  /**
+   * Save updates an existing instance
+   * @param threadId Thread ID string
+   * @param collectionName Collection name
+   * @param instance JSON string representing the instance
+   * @throws Error if update fails
+   */
+  async save(threadId, collectionName, instance) {
+    // // 检查实例大小
+    // if (instance.length > 100 * 1024) { // 100 KB
+    //     throw new Error("instance too big");
+    // }
+    try {
+      // 解码线程ID
+      const tID = ThreadID.ThreadID.fromString(threadId);
+      // 判断instance里面是否有_mod字段,存在则删除
+      try {
+        const instanceObj = JSON.parse(instance);
+        if (instanceObj && typeof instanceObj === 'object' && '_mod' in instanceObj) {
+          delete instanceObj._mod;
+          instance = JSON.stringify(instanceObj);
+        }
+      } catch (err) {
+        // JSON解析失败，保持原字符串不变
+        console.warn('Failed to parse instance JSON, keeping original:', err);
+        throw new Error("Invalid instance JSON format");
+      }
+      // 获取线程数据库
+      const threadDB = await this.getDB(tID);
+      // 获取集合
+      const collection = threadDB.getCollection(collectionName);
+      if (!collection) {
+        throw new Error("Collection does not exist");
+      }
+      // 保存实例
+      await collection.save(Buffer.from(instance));
+    } catch (err) {
+      console.error(`Failed to save instance: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+  /**
+   * DeleteMany deletes multiple instances by their IDs
+   * @param threadId Thread ID string
+   * @param collectionName Collection name
+   * @param instanceIDs Comma-separated or JSON array of instance IDs
+   * @throws Error if deletion fails
+   */
+  async deleteMany(threadId, collectionName, instanceIDs) {
+    try {
+      // 解码线程ID
+      const tID = ThreadID.ThreadID.fromString(threadId);
+      // 获取线程数据库
+      const threadDB = await this.getDB(tID);
+      // 获取集合
+      const collection = threadDB.getCollection(collectionName);
+      if (!collection) {
+        throw new Error("Collection does not exist");
+      }
+      // 解析实例ID列表
+      let IDs = [];
+      instanceIDs = instanceIDs.trim();
+      if (instanceIDs === "") {
+        return;
+      }
+      if (instanceIDs[0] !== '[') {
+        // 逗号分隔的ID列表
+        IDs = instanceIDs.split(',');
+      } else {
+        // JSON数组
+        try {
+          IDs = JSON.parse(instanceIDs);
+        } catch (err) {
+          // 解析失败时，将整个字符串作为一个ID
+          IDs = [instanceIDs];
+        }
+      }
+      // 批量处理，每次最多100个（避免事务过大）
+      const idsLen = IDs.length;
+      for (let i = 0; i < idsLen; i += 100) {
+        const batchIds = IDs.slice(i, Math.min(i + 100, idsLen));
+        await collection.deleteMany(batchIds);
+      }
+    } catch (err) {
+      console.error(`Failed to delete instances: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+  /**
+   * Has checks if the specified instance exists
+   * @param threadId Thread ID string
+   * @param collectionName Collection name
+   * @param instanceID Instance ID to check
+   * @returns Promise resolving to a boolean indicating if instance exists
+   */
+  async has(threadId, collectionName, instanceID) {
+    try {
+      // 解码线程ID
+      const tID = ThreadID.ThreadID.fromString(threadId);
+      // 获取线程数据库
+      const threadDB = await this.getDB(tID);
+      // 获取集合
+      const collection = threadDB.getCollection(collectionName);
+      if (!collection) {
+        return false;
+      }
+      // 检查实例是否存在
+      return await collection.has(instanceID);
+    } catch (err) {
+      console.error(`Failed to check instance existence: ${err instanceof Error ? err.message : String(err)}`);
+      return false;
+    }
+  }
+  /**
+   * Find finds instances by query
+   * @param threadId Thread ID string
+   * @param collectionName Collection name
+   * @param queryString JSON string representing the query
+   * @returns Promise resolving to a JSON string with found instances
+   * @throws Error if query fails
+   */
+  async find(threadId, collectionName, queryString) {
+    try {
+      if (!queryString) {
+        queryString = "{}";
+      }
+      // 解析查询字符串
+      const query = json2Query.parseJsonToQuery(queryString);
+      // 解码线程ID
+      const tID = ThreadID.ThreadID.fromString(threadId);
+      // 获取线程数据库
+      const threadDB = await this.getDB(tID);
+      // 获取集合
+      const collection = threadDB.getCollection(collectionName);
+      if (!collection) {
+        throw new Error("Collection does not exist");
+      }
+      // 执行查询
+      const results = await collection.find(query);
+      // 合并结果并返回JSON字符串
+      if (Array.isArray(results)) {
+        return utils.jsonStringify(results);
+      } else {
+        // 如果结果是字节数组，则需要连接它们
+        const resultArray = results;
+        const joinedResult = Buffer.concat([Buffer.from('['), Buffer.concat(resultArray.map((buf, idx) => Buffer.concat([buf, idx < resultArray.length - 1 ? Buffer.from(',') : Buffer.from('')]))), Buffer.from(']')]);
+        return joinedResult.toString();
+      }
+    } catch (err) {
+      console.error(`Failed to find instances: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+  /**
+   * FindByID finds an instance by ID
+   * @param threadId Thread ID string
+   * @param collectionName Collection name
+   * @param instanceID Instance ID to find
+   * @returns Promise resolving to a JSON string with found instance
+   * @throws Error if query fails
+   */
+  async findByID(threadId, collectionName, instanceID) {
+    try {
+      // 解码线程ID
+      const tID = ThreadID.ThreadID.fromString(threadId);
+      // 获取线程数据库
+      const threadDB = await this.getDB(tID);
+      // 获取集合
+      const collection = threadDB.getCollection(collectionName);
+      if (!collection) {
+        throw new Error("Collection does not exist");
+      }
+      // 根据ID查找实例
+      const result = await collection.findByID(instanceID);
+      // 返回实例
+      return result instanceof Buffer ? result.toString() : utils.jsonStringify(result);
+    } catch (err) {
+      console.error(`Failed to find instance by ID: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+  /**
+   * ModifiedSince returns instance IDs modified since the given time
+   * @param threadId Thread ID string
+   * @param collectionName Collection name
+   * @param time Unix timestamp in milliseconds
+   * @returns Promise resolving to a JSON string with instance IDs
+   * @throws Error if query fails
+   */
+  async modifiedSince(threadId, collectionName, time) {
+    try {
+      // 解码线程ID
+      const tID = ThreadID.ThreadID.fromString(threadId);
+      // 获取线程数据库
+      const threadDB = await this.getDB(tID);
+      // 获取集合
+      const collection = threadDB.getCollection(collectionName);
+      if (!collection) {
+        throw new Error("Collection does not exist");
+      }
+      // 获取指定时间后修改的实例ID列表
+      const ids = await collection.modifiedSince(time);
+      // 序列化并返回ID列表
+      return JSON.stringify(ids);
+    } catch (err) {
+      console.error(`Failed to get modified instances: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+  }
+}
+class AsyncLock {
+  constructor() {
+    Object.defineProperty(this, "locks", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.locks = new Map();
+  }
+  async acquire(key, fn) {
+    while (this.locks.has(key)) {
+      await this.locks.get(key);
+    }
+    let resolve;
+    const promise = new Promise(r => resolve = r);
+    this.locks.set(key, promise);
+    try {
+      const result = await fn();
+      return result;
+    } catch (err) {
+      // 重新抛出错误以保持类型一致性
+      throw err;
+    } finally {
+      this.locks.delete(key);
+      resolve();
+    }
+  }
+}
+function isValidName(name) {
+  return /^[a-zA-Z0-9_-]+$/.test(name);
+}
+function createContext(timeout) {
+  const ctx = {
+    deadline: new Date(Date.now() + timeout)
+  };
+  if (timeout === 0) {
+    ctx.deadline = undefined;
+  }
+  if (typeof AbortController !== 'undefined') {
+    ctx.signal = new AbortController().signal;
+  }
+  return ctx;
+}
+
+exports.DBManager = DBManager;
+exports.createContext = createContext;
+exports.dsManagerBaseKey = dsManagerBaseKey;