web-dc-api 0.0.58 → 0.0.59

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

@@ -0,0 +1,518 @@
+'use strict';
+
+var key = require('../../../node_modules/interface-datastore/dist/src/key.js');
+var db = require('../core/db.js');
+var collection = require('./collection.js');
+var core = require('../core/core.js');
+var jsonPatcher = require('../common/json-patcher.js');
+var dispatcher = require('../common/dispatcher.js');
+var app = require('../core/app.js');
+var event = require('../cbor/event.js');
+require('../../../node_modules/multiformats/dist/src/bases/base32.js');
+require('../../../node_modules/jscrypto/es6/lib/random.js');
+require('../../../node_modules/jscrypto/es6/lib/browser.js');
+require('../../../node_modules/jscrypto/es6/lib/encoder/Base64.js');
+require('../../../node_modules/jscrypto/es6/SHA256.js');
+require('../../../node_modules/jscrypto/es6/MD5.js');
+require('../../../node_modules/jscrypto/es6/SHA512.js');
+require('../../../node_modules/jscrypto/es6/AES.js');
+require('../../../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/GCM.js');
+require('../../../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/CCM.js');
+require('../../../node_modules/jscrypto/es6/SHA3.js');
+require('../../../node_modules/jscrypto/es6/DES.js');
+require('../../../node_modules/jscrypto/es6/DES3.js');
+require('../../../node_modules/jscrypto/es6/RIPEMD160.js');
+require('../../../node_modules/jscrypto/es6/Rabbit.js');
+require('../../../node_modules/jscrypto/es6/RC4.js');
+require('../../../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/CBC.js');
+require('../../../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/CFB.js');
+require('../../../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/CTR.js');
+require('../../../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/ECB.js');
+require('../../../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/OFB.js');
+require('@multiformats/multiaddr');
+require('@libp2p/peer-id');
+require('@libp2p/crypto');
+require('../../../_virtual/index.js');
+
+const baseKey = db.DBPrefix.dsPrefix.child(new key.Key("collection"));
+const getBlockInitialTimeout = 500;
+const getBlockRetries = 3;
+class CollectionExistsError extends Error {
+  constructor(name) {
+    super(`Collection ${name} already exists`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.name = "CollectionExistsError";
+  }
+}
+class DB {
+  constructor(datastore, net, id, opts) {
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "connector", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    }); //
+    Object.defineProperty(this, "datastore", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dispatcher", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "eventcodec", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "collections", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: new Map()
+    });
+    Object.defineProperty(this, "localEventsBus", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "webLock", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    // 使用队列确保写入操作按顺序执行
+    Object.defineProperty(this, "writeQueue", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: Promise.resolve()
+    });
+    this.datastore = datastore;
+    this.name = opts.name || "unnamed";
+    this.eventcodec = opts.eventCodec || new jsonPatcher.JsonPatcher();
+    this.webLock = "webLock_db_" + id;
+  }
+  // 新建 DB 实例
+  static async newDB(store, n, id, opts) {
+    const args = opts || new core.NewOptions();
+    if (!args.eventCodec) {
+      args.eventCodec = new jsonPatcher.JsonPatcher(); //DefaultEventCodec()
+    }
+    const dbInstance = new DB(store, n, id.toString(), args);
+    dbInstance.name = "";
+    dbInstance.dispatcher = new dispatcher.Dispatcher(store);
+    dbInstance.localEventsBus = new app.LocalEventsBus();
+    try {
+      await dbInstance.loadName();
+    } catch (error) {
+      throw new Error("Failed to load DB name");
+    }
+    const prevName = dbInstance.name;
+    if (args.name) {
+      dbInstance.name = args.name;
+    } else if (prevName === "") {
+      dbInstance.name = "unnamed";
+    }
+    await dbInstance.saveName(prevName);
+    await dbInstance.reCreateCollections();
+    dbInstance.dispatcher.register(dbInstance);
+    try {
+      const connector = await n.connectApp(dbInstance, id);
+      dbInstance.connector = connector;
+    } catch (err) {
+      throw new Error(`Failed to connect app: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // 处理集合配置
+    if (args.collections && args.collections.length > 0) {
+      for (const collectionConfig of args.collections) {
+        try {
+          await dbInstance.newCollection(collectionConfig);
+        } catch (err) {
+          throw new Error(`Failed to create collection: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    return dbInstance;
+  }
+  /**
+   * GetDBInfo returns the addresses and key that can be used to join the DB thread.
+   * @param options Optional settings for the operation
+   * @returns Promise resolving to thread info
+   */
+  async getDBInfo(options) {
+    console.debug(`getting db info in ${this.name}`);
+    try {
+      const threadInfo = await this.connector?.net.getThread(this.connector?.threadId, {
+        token: options?.token
+      });
+      const dbInfo = {
+        id: this.connector ? this.connector.threadId.toString() : "",
+        name: this.name,
+        addrs: threadInfo ? threadInfo.addrs.map(addr => addr.toString()) : [],
+        key: threadInfo ? threadInfo.key?.toString() : ""
+      };
+      return dbInfo;
+    } catch (err) {
+      throw new Error(`Failed to get DB info: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async saveName(prevName) {
+    if (this.name === prevName) return;
+    if (!this.name.match(/^[a-zA-Z0-9_-]+$/)) {
+      // 根据需求定义规则
+      throw new Error("Invalid name");
+    }
+    await this.datastore.put(db.DBPrefix.dsName, new TextEncoder().encode(this.name));
+  }
+  async loadName() {
+    try {
+      const nameBuffer = await this.datastore.get(db.DBPrefix.dsName);
+      if (nameBuffer) {
+        this.name = new TextDecoder().decode(nameBuffer);
+      }
+    } catch (error) {}
+  }
+  async saveVerno(verno) {
+    await this.datastore.put(db.DBPrefix.dsVerno, new TextEncoder().encode(verno.toString()));
+  }
+  async loadVerno() {
+    try {
+      const vernoBuffer = await this.datastore.get(db.DBPrefix.dsVerno);
+      if (vernoBuffer) {
+        return parseInt(new TextDecoder().decode(vernoBuffer));
+      }
+    } catch (error) {}
+    return 0;
+  }
+  async initCollections(configs) {
+    for (const config of configs) {
+      await this.newCollection(config);
+    }
+  }
+  async upgradeCollections(configs) {
+    for (const config of configs) {
+      await this.newCollection(config, true);
+    }
+  }
+  async newCollection(config) {
+    let forceUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (this.collections.has(config.name) && !forceUpdate) {
+      throw new CollectionExistsError(config.name);
+    }
+    const collection$1 = new collection.Collection(config.name, config.schema, this);
+    // Add default _id index
+    await collection$1.addIndex({
+      path: "_id",
+      unique: true
+    });
+    // Add custom indexes
+    for (const index of config.indexes || []) {
+      await collection$1.addIndex(index);
+    }
+    //保存集合配置到数据存储
+    this.saveCollection(collection$1);
+    return collection$1;
+  }
+  async saveCollection(c) {
+    console.debug(`saving collection ${c.name} in ${this.name}`);
+    try {
+      // Save schema
+      await this.datastore.put(db.DBPrefix.dsSchemas.child(new key.Key(c.name)), c.getSchema());
+      // Save write validator if exists
+      if (c.rawWriteValidator) {
+        await this.datastore.put(db.DBPrefix.dsValidators.child(new key.Key(c.name)), new TextEncoder().encode(c.rawWriteValidator));
+      }
+      // Save read filter if exists
+      if (c.rawReadFilter) {
+        await this.datastore.put(db.DBPrefix.dsFilters.child(new key.Key(c.name)), new TextEncoder().encode(c.rawReadFilter));
+      }
+      // Add collection to local map
+      this.collections.set(c.name, c);
+    } catch (err) {
+      throw new Error(`Failed to save collection ${c.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async reCreateCollections() {
+    try {
+      const results = this.datastore.query({
+        prefix: db.DBPrefix.dsSchemas.toString()
+      });
+      try {
+        for await (const res of results) {
+          const name = res.key.name();
+          const schema = JSON.parse(new TextDecoder().decode(res.value));
+          let wv;
+          try {
+            const wvBuffer = await this.datastore.get(db.DBPrefix.dsValidators.child(new key.Key(name)));
+            wv = new TextDecoder().decode(wvBuffer);
+          } catch (err) {
+            if (err.code !== "ERR_NOT_FOUND") throw err;
+          }
+          let rf;
+          try {
+            const rfBuffer = await this.datastore.get(db.DBPrefix.dsFilters.child(new key.Key(name)));
+            rf = new TextDecoder().decode(rfBuffer);
+          } catch (err) {
+            if (err.code !== "ERR_NOT_FOUND") throw err;
+          }
+          const c = new collection.Collection(name, schema, this);
+          // 修复索引对象
+          try {
+            const indexBuffer = await this.datastore.get(db.DBPrefix.dsIndexes.child(new key.Key(name)));
+            const indexData = JSON.parse(new TextDecoder().decode(indexBuffer));
+            // 修复索引映射 - 使用 Map 而不是对象
+            for (const [path, index] of Object.entries(indexData)) {
+              if (path) {
+                c.indexes.set(path, index);
+              }
+            }
+          } catch (err) {
+            if (err.code !== "ERR_NOT_FOUND") throw err;
+          }
+          // 添加到集合映射
+          this.collections.set(c.name, c);
+        }
+      } catch (err) {
+        throw new Error(`Error re-creating collections: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    } catch (err) {
+      throw new Error(`Error re-creating collections: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  getCollection(name) {
+    const collection = this.collections.get(name);
+    if (!collection) throw new Error(`Collection ${name} not found`);
+    return collection;
+  }
+  async close() {}
+  async reduce(events) {
+    try {
+      // 调用事件编解码器的 reduce 方法获取处理结果
+      const codecActions = await this.eventcodec.reduce(events, this.datastore, baseKey, this.defaultIndexFunc());
+      // 创建 actions 数组并映射处理结果
+      const actions = codecActions.map(ca => {
+        // 返回转换后的 Action 对象
+        return {
+          collectionName: ca.collection,
+          type: ca.type,
+          instanceID: ca.instanceID
+        };
+      });
+      // 通知状态变更
+      this.notifyStateChanged(actions);
+    } catch (err) {
+      throw new Error(`Error reducing events: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  /**
+   * 默认索引函数
+   * 创建一个处理集合索引更新的函数
+   */
+  defaultIndexFunc() {
+    return async (collection, key, txn, oldData, newData) => {
+      const c = this.collections.get(collection);
+      if (!c) {
+        throw new Error(`collection (${collection}) not found`);
+      }
+      if (oldData) {
+        await c.indexDelete(txn, key, oldData);
+      }
+      if (!newData) {
+        return;
+      }
+      await c.indexAdd(txn, key, newData);
+    };
+  }
+  // 添加通知状态变更的方法
+  notifyStateChanged(actions) {
+    // 发送状态变更事件
+    if (this.localEventsBus) ;
+  }
+  /**
+   * 通知事务事件
+   * 将事务相关的节点和令牌发送到本地事件总线
+   */
+  async notifyTxnEvents(node, token) {
+    try {
+      await this.localEventsBus?.send({
+        node: node,
+        token: token
+      });
+    } catch (err) {
+      throw new Error(`Failed to notify transaction events: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async dispatch(events) {
+    // 实现事件分发逻辑
+    for (const event of events) {
+      await this.reduce([event]);
+    }
+  }
+  async validateNetRecordBody(body, identity) {
+    try {
+      const events = await this.eventcodec.eventsFromBytes(body.data());
+      if (events.length === 0) {
+        return;
+      }
+      for (const e of events) {
+        const collection = this.collections.get(e.collection);
+        if (!collection) {
+          return db.Errors.ErrCollectionNotFound;
+        }
+      }
+      return;
+    } catch (error) {
+      return error;
+    }
+  }
+  async handleNetRecord(rec, key) {
+    let event$1;
+    try {
+      if (!this.connector) {
+        return new Error("no connector");
+      }
+      // 从记录中解码事件
+      event$1 = await event.EventFromRecord(this.connector?.net.bstore, rec.value());
+    } catch (err) {
+      // 如果解码失败，尝试从块中获取事件
+      try {
+        const block = await this.getBlockWithRetry(rec.value());
+        event$1 = await event.EventFromNode(block);
+      } catch (blockErr) {
+        return blockErr;
+      }
+    }
+    try {
+      // 获取事件的主体
+      const body = await event$1.getBody(this.connector?.net, key.read());
+      // 从字节数据中解码事件
+      const events = await this.eventcodec.eventsFromBytes(body.rawData());
+      // 分发事件
+      await this.dispatch(events);
+    } catch (err) {
+      return new Error(`error when processing event: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return;
+  }
+  async getNetRecordCreateTime(rec, key) {
+    let event$1;
+    if (!this.connector) {
+      throw new Error("no connector");
+    }
+    try {
+      // 从记录中解码事件
+      event$1 = await event.EventFromRecord(this.connector?.net.bstore, rec.value());
+    } catch (err) {
+      // 如果解码失败，尝试从块中获取事件
+      try {
+        const block = await this.getBlockWithRetry(rec.value());
+        event$1 = await event.EventFromNode(block);
+      } catch (decodeErr) {
+        throw new Error(`Error when decoding block to event: ${decodeErr instanceof Error ? decodeErr.message : String(decodeErr)}`);
+      }
+    }
+    let body;
+    try {
+      // 获取事件的主体
+      body = await event$1.getBody(this.connector?.net.bstore, key.read());
+    } catch (err) {
+      throw new Error(`Error when getting body of event on thread ${this.connector?.threadId}/${rec.logID()}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let events;
+    try {
+      // 从字节数据中解码事件
+      events = await this.eventcodec.eventsFromBytes(body.data());
+    } catch (err) {
+      throw new Error(`Error when unmarshaling event from bytes: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (events.length === 0) {
+      throw new Error("No events found in record");
+    }
+    return events[0].timestamp;
+  }
+  async getBlockWithRetry(rec) {
+    let backoff = getBlockInitialTimeout;
+    if (!this.connector) {
+      throw new Error("no connector");
+    }
+    // 重试循环
+    for (let i = 1; i <= getBlockRetries; i++) {
+      try {
+        // 尝试获取块
+        const block = await rec.getBlock(this.connector?.net.bstore);
+        return block; // 成功则立即返回
+      } catch (err) {
+        console.warn(`错误: 在第 ${i} 次重试中获取块 ${rec.cid()} 失败`);
+        await new Promise(resolve => setTimeout(resolve, backoff));
+        backoff *= 2;
+      }
+    }
+  }
+  async readTxn(collection$1, fn, token) {
+    // 创建只读事务
+    const txn = new collection.Txn(collection$1, token, true);
+    try {
+      // 执行事务函数
+      await fn(txn);
+    } finally {
+      // 确保事务被丢弃
+      txn.discard();
+    }
+  }
+  async writeTxn(collection$1, fn, token) {
+    // Save the current promise chain
+    const previousOperation = this.writeQueue;
+    // Create a new promise for this operation
+    const currentOperation = new Promise((resolve, reject) => {
+      // Wait for previous operations to complete (or fail)
+      previousOperation.catch(() => {
+        // Ignore previous errors - just ensure we wait for previous operations
+      }).finally(async () => {
+        // After previous operations are done (success or failure), run this operation
+        const txn = new collection.Txn(collection$1, token, false);
+        try {
+          // Execute transaction function
+          await fn(txn);
+          // Commit transaction
+          await txn.commit();
+          resolve();
+        } catch (err) {
+          // Properly propagate the error
+          reject(err);
+        } finally {
+          // Always discard the transaction
+          txn.discard();
+        }
+      });
+    });
+    // Update the queue with our operation
+    this.writeQueue = currentOperation.catch(() => {
+      // Swallow errors in the queue chain but log them
+      // This ensures future operations will still execute
+      return Promise.resolve();
+    });
+    // Return the current operation, allowing errors to propagate to the caller
+    return currentOperation;
+  }
+}
+
+exports.DB = DB;

package/dist/cjs/implements/threaddb/db/json2Query.js

@@ -0,0 +1,162 @@
+'use strict';
+
+var query = require('./query.js');
+
+// 错误定义
+const ErrInvalidQueryConditionFormat = new Error("无效的查询条件格式");
+/**
+ * 解析JSON字符串为查询对象
+ * @param jsonQuery JSON查询字符串
+ * @returns 数据库查询对象
+ */
+function parseJsonToQuery(jsonQuery) {
+  const queryObject = {
+    condition: '',
+    ors: [],
+    sort: {},
+    seek: '',
+    limit: 0,
+    skip: 0,
+    index: ''
+  };
+  if (jsonQuery === '') {
+    jsonQuery = '{}';
+  }
+  try {
+    Object.assign(queryObject, JSON.parse(jsonQuery));
+    return dcQueryToDbQuery(queryObject);
+  } catch (err) {
+    throw new Error(`解析查询JSON失败: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+/**
+ * 将自定义查询对象转换为数据库查询对象
+ * @param dcQuery 自定义查询对象
+ * @returns 数据库查询对象
+ */
+function dcQueryToDbQuery(dcQuery) {
+  try {
+    const ands = parseCondition(dcQuery.condition);
+    const dbQuery = new query.Query();
+    dbQuery.ands = ands;
+    dbQuery.sort = dcQuery.sort;
+    dbQuery.seek = dcQuery.seek;
+    dbQuery.limit = dcQuery.limit;
+    dbQuery.skip = dcQuery.skip;
+    dbQuery.index = dcQuery.index;
+    dbQuery.ors = [];
+    // 处理子查询
+    dbQuery.ors = dcQuery.ors?.map(query => dcQueryToDbQuery(query)) || [];
+    // 设置默认限制
+    if (dbQuery.limit === 0) {
+      dbQuery.limit = -1;
+    }
+    return dbQuery;
+  } catch (err) {
+    throw new Error(`转换查询对象失败: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+/**
+ * 解析条件字符串为条件对象数组
+ * @param condition 条件字符串
+ * @returns 条件对象数组
+ */
+function parseCondition(condition) {
+  // 根据 and 进行分解
+  if (!condition) return [];
+  const criterions = condition.split(' and ');
+  const ands = [];
+  for (const criterion of criterions) {
+    // 解析出key，操作符以及值
+    try {
+      const parsed = parseSingleCondition(criterion);
+      if (!parsed || parsed.length !== 3) {
+        continue;
+      }
+      const value = parseValue(parsed[2]);
+      const queryCriterion = new query.Criterion(parsed[0], getDbQueryOperation(parsed[1]), value);
+      ands.push(queryCriterion);
+    } catch (err) {
+      // 忽略解析错误的条件
+      continue;
+    }
+  }
+  return ands;
+}
+/**
+ * 解析值字符串为类型化的值对象
+ * @param strValue 值字符串
+ * @returns 类型化的值对象
+ */
+function parseValue(strValue) {
+  const value = new query.Value();
+  if (strValue[0] === "'" || strValue[0] === '"') {
+    const sValue = strValue.substring(1, strValue.length - 1);
+    value.string = sValue;
+  } else if (strValue === "true" || strValue === "false") {
+    const bValue = strValue === "true";
+    value.bool = bValue;
+  } else {
+    const fValue = parseFloat(strValue);
+    if (isNaN(fValue)) {
+      throw new Error(`无效的数字格式: ${strValue}`);
+    }
+    value.float = fValue;
+  }
+  return value;
+}
+// 支持的操作符
+const splitOp = ["!=", ">=", "<=", "=", "<>", ">", "<"];
+/**
+ * 解析单个条件字符串为操作数组
+ * @param condition 条件字符串
+ * @returns [字段路径, 操作符, 值] 数组
+ */
+function parseSingleCondition(condition) {
+  for (const op of splitOp) {
+    const index = condition.indexOf(op);
+    if (index > 0) {
+      // 判断操作符是否出现在值的字符串中
+      const qStartIndex = condition.indexOf("'");
+      const dqStartIndex = condition.indexOf('"');
+      if (qStartIndex > 0 && index > qStartIndex || dqStartIndex > 0 && index > dqStartIndex) {
+        // 操作符出现在字符串中，不做处理，判断下一个操作符
+        continue;
+      }
+      const parsedCondition = new Array(3);
+      parsedCondition[0] = condition.substring(0, index).trim();
+      parsedCondition[1] = op.trim();
+      parsedCondition[2] = condition.substring(index + op.length).trim();
+      return parsedCondition;
+    }
+  }
+  throw ErrInvalidQueryConditionFormat;
+}
+/**
+ * 获取数据库查询操作类型
+ * @param op 操作符字符串
+ * @returns 操作类型枚举值
+ */
+function getDbQueryOperation(op) {
+  const top = op.trim();
+  switch (top) {
+    case "=":
+      return query.Operation.eq;
+    case "!=":
+    case "<>":
+      return query.Operation.ne;
+    case ">":
+      return query.Operation.gt;
+    case "<":
+      return query.Operation.lt;
+    case ">=":
+      return query.Operation.ge;
+    case "<=":
+      return query.Operation.le;
+    default:
+      return query.Operation.eq;
+    // 默认等于
+  }
+}
+
+exports.parseJsonToQuery = parseJsonToQuery;