web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/implements/threaddb/lsstoreds/headbook.js

@@ -0,0 +1,264 @@
+'use strict';
+
+var key = require('../../../node_modules/interface-datastore/dist/src/key.js');
+var head = require('../core/head.js');
+var global = require('./global.js');
+var index = require('../../../_virtual/index.js');
+
+const {
+  Buffer
+} = index;
+const hbBase = new key.Key('/thread/heads');
+const hbEdge = new key.Key('/thread/heads:edge');
+function newHeadBook(ds) {
+  return new DsHeadBook(ds);
+}
+class DsHeadBook {
+  constructor(datastore) {
+    Object.defineProperty(this, "ds", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.ds = datastore;
+  }
+  async addHead(tid, pid, head) {
+    return this.addHeads(tid, pid, [head]);
+  }
+  async addHeads(tid, pid, heads) {
+    return this.withTransaction(async txn => {
+      const key = global.dsLogKey(tid, pid, hbBase);
+      let existing = await this.getHeadsRecord(txn, key);
+      if (!existing) {
+        existing = {
+          heads: []
+        };
+      }
+      const newHeads = this.mergeHeads(existing, heads);
+      const record = {
+        heads: newHeads
+      };
+      await this.saveRecord(txn, key, record);
+      await this.invalidateEdge(txn, tid);
+    });
+  }
+  async setHead(tid, pid, head) {
+    return this.setHeads(tid, pid, [head]);
+  }
+  async setHeads(tid, pid, heads) {
+    const txn = await this.ds.newTransactionExtended(false);
+    try {
+      const key = global.dsLogKey(tid, pid, hbBase);
+      const hr = {
+        heads: []
+      };
+      for (const head of heads) {
+        if (!head.id) {
+          console.warn(`Ignoring head ${head} is undefined for ${key}`);
+          continue;
+        }
+        hr.heads.push({
+          id: head.id,
+          counter: head.counter
+        });
+      }
+      const serializedRecord = head.serializeHeadBookRecord(hr);
+      const recordBytes = new TextEncoder().encode(serializedRecord);
+      await txn.put(key, recordBytes);
+      await this.invalidateEdge(txn, tid);
+      await txn.commit();
+    } catch (err) {
+      txn.discard();
+      throw new Error(`Error when setting heads: ${err.message}`);
+    }
+  }
+  async heads(tid, pid) {
+    const key = global.dsLogKey(tid, pid, hbBase);
+    try {
+      const data = await this.ds.get(key);
+      if (!data) return [];
+      const hr = head.deserializeHeadBookRecord(new TextDecoder().decode(data));
+      return hr.heads.map(h => ({
+        ...(h.id ? {
+          id: h.id
+        } : {}),
+        counter: h.counter
+      }));
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') return [];
+      throw new Error(`Error when getting current heads from log ${key}: ${err.message}`);
+    }
+  }
+  async clearHeads(tid, pid) {
+    const txn = await this.ds.newTransactionExtended(false);
+    try {
+      const key = global.dsLogKey(tid, pid, hbBase);
+      await txn.delete(key);
+      await this.invalidateEdge(txn, tid);
+      await txn.commit();
+    } catch (err) {
+      txn.discard();
+      throw new Error(`Error when clearing heads: ${err.message}`);
+    }
+  }
+  async withTransaction(fn) {
+    const txn = await this.ds.newTransactionExtended(false);
+    try {
+      const result = await fn(txn);
+      await txn.commit();
+      return result;
+    } catch (err) {
+      txn.discard();
+      throw err;
+    }
+  }
+  async getHeadsRecord(txn, key) {
+    try {
+      const data = await txn.get(key);
+      if (!data) return null;
+      return head.deserializeHeadBookRecord(new TextDecoder().decode(data));
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') return null;
+      throw err;
+    }
+  }
+  mergeHeads(existing, newHeads) {
+    const seen = new Set(existing.heads.map(h => h.id?.toString()));
+    return [...existing.heads, ...newHeads.filter(h => !seen.has(h.id?.toString()))];
+  }
+  async saveRecord(txn, key, record) {
+    const serializedRecord = head.serializeHeadBookRecord(record);
+    const recordBytes = new TextEncoder().encode(serializedRecord);
+    await txn.put(key, recordBytes);
+  }
+  async headsEdge(tid) {
+    let retries = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
+    const key = global.dsThreadKey(tid, hbEdge);
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      try {
+        return await this.calculateEdge(tid, key);
+      } catch (err) {
+        if (err.code !== 'TX_CONFLICT') throw err;
+        await this.randomDelay(attempt);
+      }
+    }
+    throw new Error('Edge computation failed');
+  }
+  async calculateEdge(tid, key) {
+    return this.withTransaction(async txn => {
+      try {
+        let data = await txn.get(key);
+        if (!data) {
+          data = Buffer.alloc(8);
+        }
+        return Buffer.from(data).readUInt32BE(0);
+      } catch (err) {
+        if (err.code !== 'ERR_NOT_FOUND') throw err;
+      }
+      const heads = await this.collectHeads(txn, tid);
+      if (heads.length === 0) throw new Error('Thread not found');
+      const edge = this.computeEdgeValue(heads);
+      const buffer = Buffer.alloc(8);
+      buffer.writeBigUInt64BE(edge, 0);
+      await txn.put(key, buffer);
+      return edge;
+    });
+  }
+  async collectHeads(txn, tid) {
+    const query = {
+      prefix: global.dsThreadKey(tid, hbBase).toString()
+    };
+    const results = txn.query(query);
+    const heads = [];
+    for await (const entry of results) {
+      const record = head.deserializeHeadBookRecord(new TextDecoder().decode(entry.value));
+      heads.push(...record.heads.map(h => ({
+        ...(h.id ? {
+          id: h.id
+        } : {}),
+        counter: h.counter
+      })));
+    }
+    return heads.filter(h => h.counter !== 0);
+  }
+  computeEdgeValue(heads) {
+    return heads.reduce((acc, h) => acc + h.counter, 0);
+  }
+  async invalidateEdge(txn, tid) {
+    const key = global.dsThreadKey(tid, hbEdge);
+    await txn.delete(key);
+  }
+  randomDelay(attempt) {
+    const delay = 50 * attempt + Math.random() * 30;
+    return new Promise(resolve => setTimeout(resolve, delay));
+  }
+  async dumpHeads() {
+    const data = await this.traverse(true);
+    return {
+      data: data
+    };
+  }
+  async restoreHeads(dump) {
+    if (Object.keys(dump.data).length === 0) {
+      throw new Error('Empty dump');
+    }
+    const stored = await this.traverse(false);
+    for (const tid in stored) {
+      for (const lid in stored[tid]) {
+        await this.clearHeads(tid, lid);
+      }
+    }
+    for (const tid in dump.data) {
+      for (const lid in dump.data[tid]) {
+        await this.setHeads(tid, lid, dump.data[tid][lid]);
+      }
+    }
+  }
+  async traverse(withHeads) {
+    const data = {};
+    const result = this.ds.query({
+      prefix: hbBase.toString()
+    });
+    for await (const entry of result) {
+      const {
+        tid,
+        lid,
+        heads
+      } = await this.decodeHeadEntry(entry, withHeads);
+      if (!data[tid]) {
+        data[tid] = {};
+      }
+      data[tid][lid] = heads;
+    }
+    return data;
+  }
+  async decodeHeadEntry(entry, withHeads) {
+    const kns = entry.key.namespaces();
+    if (kns.length < 3) {
+      throw new Error(`bad headbook key detected: ${entry.key}`);
+    }
+    const ts = kns[kns.length - 2];
+    const ls = kns[kns.length - 1];
+    const tid = ts;
+    const lid = ls;
+    let heads = [];
+    if (withHeads) {
+      const hr = head.deserializeHeadBookRecord(new TextDecoder().decode(entry.value));
+      heads = hr.heads.map(h => ({
+        ...(h.id ? {
+          id: h.id
+        } : {}),
+        counter: h.counter
+      }));
+    }
+    return {
+      tid,
+      lid,
+      heads
+    };
+  }
+}
+
+exports.DsHeadBook = DsHeadBook;
+exports.newHeadBook = newHeadBook;

package/dist/cjs/implements/threaddb/lsstoreds/keybook.js

@@ -0,0 +1,241 @@
+'use strict';
+
+var key = require('../../../node_modules/interface-datastore/dist/src/key.js');
+var peerId = require('@libp2p/peer-id');
+var crypto = require('@libp2p/crypto');
+var ThreadID = require('@textile/threads-id');
+var global = require('./global.js');
+var keyManager = require('../../../common/dc-key/keyManager.js');
+var index = require('../../../node_modules/@libp2p/crypto/dist/src/keys/index.js');
+
+// 键路径构建工具  
+const KB_BASE = new key.Key('/thread/keys');
+const PUB_SUFFIX = new key.Key('/pub');
+const PRIV_SUFFIX = new key.Key('/priv');
+const READ_SUFFIX = new key.Key('/read');
+const SERVICE_SUFFIX = new key.Key('/service');
+class DsKeyBook {
+  constructor(store) {
+    Object.defineProperty(this, "ds", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.ds = store;
+  }
+  async pubKey(t, p) {
+    const key = global.dsLogKey(t, p, KB_BASE).child(PUB_SUFFIX);
+    try {
+      const value = await this.ds.get(key);
+      return crypto.keys.publicKeyFromRaw(value);
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') return;
+      throw new Error(`Error getting public key: ${err.message}`);
+    }
+  }
+  async addPubKey(t, p, pk) {
+    if (!pk) throw new Error('Public key is null');
+    const peerId$1 = peerId.peerIdFromPublicKey(pk);
+    if (!peerId$1.equals(p)) {
+      throw new Error("Log ID doesn't match provided public key");
+    }
+    const value = pk.raw;
+    const key = global.dsLogKey(t, p, KB_BASE).child(PUB_SUFFIX);
+    await this.ds.put(key, value);
+  }
+  async privKey(t, p) {
+    const key = global.dsLogKey(t, p, KB_BASE).child(PRIV_SUFFIX);
+    try {
+      const value = await this.ds.get(key);
+      return crypto.keys.privateKeyFromRaw(value);
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') return null;
+      throw new Error(`Error getting private key: ${err.message}`);
+    }
+  }
+  async addPrivKey(t, p, sk) {
+    if (!sk) throw new Error('Private key is null');
+    const peerId$1 = await peerId.peerIdFromPrivateKey(sk);
+    if (!peerId$1.equals(p)) {
+      throw new Error("Peer ID doesn't match private key");
+    }
+    const value = sk.raw;
+    const key = global.dsLogKey(t, p, KB_BASE).child(PRIV_SUFFIX);
+    await this.ds.put(key, value);
+  }
+  async readKey(t) {
+    const key = global.dsThreadKey(t, KB_BASE).child(READ_SUFFIX);
+    try {
+      const value = await this.ds.get(key);
+      let symkey = await keyManager.symKeyFromBytes(value);
+      return symkey;
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') return;
+      throw new Error(`Error getting read key: ${err.message}`);
+    }
+  }
+  async addReadKey(t, rk) {
+    if (!rk) throw new Error('Read key is null');
+    const value = rk.raw;
+    const key = global.dsThreadKey(t, KB_BASE).child(READ_SUFFIX);
+    await this.ds.put(key, value);
+  }
+  async serviceKey(t) {
+    const key = global.dsThreadKey(t, KB_BASE).child(SERVICE_SUFFIX);
+    try {
+      const value = await this.ds.get(key);
+      const symkey = await keyManager.symKeyFromBytes(value);
+      return symkey;
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') return;
+      throw new Error(`Error getting service key: ${err.message}`);
+    }
+  }
+  async addServiceKey(t, fk) {
+    if (!fk) throw new Error('Service key is null');
+    const key = global.dsThreadKey(t, KB_BASE).child(SERVICE_SUFFIX);
+    await this.ds.put(key, fk.raw);
+  }
+  async clearKeys(t) {
+    return this.clearKeysInternal(global.dsThreadKey(t, KB_BASE));
+  }
+  async clearLogKeys(t, p) {
+    const baseKey = global.dsLogKey(t, p, KB_BASE);
+    await this.ds.delete(baseKey.child(PRIV_SUFFIX));
+    await this.ds.delete(baseKey.child(PUB_SUFFIX));
+  }
+  async clearKeysInternal(prefix) {
+    const q = {
+      prefix: prefix.toString()
+    };
+    for await (const result of this.ds.query(q)) {
+      await this.ds.delete(result.key);
+    }
+  }
+  async logsWithKeys(t) {
+    const threadKey = KB_BASE.child(new key.Key(t.toString()));
+    return global.uniqueLogIds(this.ds, threadKey, result => result.parent().name());
+  }
+  async threadsFromKeys() {
+    return global.uniqueThreadIds(this.ds, KB_BASE, result => result.parent().parent().name());
+  }
+  async dumpKeys() {
+    const dump = {
+      data: {
+        public: {},
+        private: {},
+        read: {},
+        service: {}
+      }
+    };
+    const q = {
+      prefix: KB_BASE.toString()
+    };
+    const results = this.ds.query(q);
+    for await (const entry of results) {
+      const key$1 = new key.Key(entry.key.toString());
+      const namespaces = key$1.list();
+      if (namespaces.length < 4) {
+        throw new Error(`Invalid keybook key: ${entry.key}`);
+      }
+      const suffix = `/${namespaces[namespaces.length - 1]}`;
+      switch (suffix) {
+        case PUB_SUFFIX.toString():
+          this.processPublicKeyEntry(namespaces, entry.value, dump);
+          break;
+        case PRIV_SUFFIX.toString():
+          this.processPrivateKeyEntry(namespaces, entry.value, dump);
+          break;
+        case READ_SUFFIX.toString():
+          this.processReadKeyEntry(namespaces, entry.value, dump);
+          break;
+        case SERVICE_SUFFIX.toString():
+          this.processServiceKeyEntry(namespaces, entry.value, dump);
+          break;
+        default:
+          throw new Error(`Invalid key suffix: ${suffix}`);
+      }
+    }
+    return dump;
+  }
+  processPublicKeyEntry(namespaces, value, dump) {
+    const [tid, lid] = namespaces.slice(2, 4);
+    if (!tid || !lid) {
+      throw new Error(`Invalid namespaces for public key: ${namespaces.join('/')}`);
+    }
+    const pk = index.publicKeyFromRaw(value);
+    if (!dump.data.public[tid]) {
+      dump.data.public[tid] = {};
+    }
+    dump.data.public[tid][lid] = pk;
+  }
+  processPrivateKeyEntry(namespaces, value, dump) {
+    const [tid, lid] = namespaces.slice(2, 4);
+    if (!tid || !lid) {
+      throw new Error(`Invalid namespaces for private key: ${namespaces.join('/')}`);
+    }
+    const privk = index.privateKeyFromRaw(value);
+    if (!dump.data.private[tid]) {
+      dump.data.private[tid] = {};
+    }
+    dump.data.private[tid][lid] = privk;
+  }
+  processReadKeyEntry(namespaces, value, dump) {
+    const [tid] = namespaces.slice(2, 3);
+    dump.data.read[tid] = Buffer.from(value);
+  }
+  processServiceKeyEntry(namespaces, value, dump) {
+    const [tid] = namespaces.slice(2, 3);
+    if (!tid) {
+      throw new Error(`Invalid namespaces for service key: ${namespaces.join('/')}`);
+    }
+    dump.data.service[tid] = Buffer.from(value);
+  }
+  async restoreKeys(dump) {
+    if (Object.keys(dump.data.public).length === 0 && Object.keys(dump.data.private).length === 0 && Object.keys(dump.data.read).length === 0 && Object.keys(dump.data.service).length === 0) {
+      throw new Error('Empty dump data');
+    }
+    // clear all local keys
+    await this.clearKeysInternal(KB_BASE);
+    for (const tid in dump.data.public) {
+      for (const lid in dump.data.public[tid]) {
+        const pubKey = dump.data.public[tid][lid];
+        if (!pubKey) {
+          continue;
+        }
+        await this.addPubKey(ThreadID.ThreadID.fromString(tid), peerId.peerIdFromPublicKey(pubKey), pubKey);
+      }
+    }
+    for (const tid in dump.data.private) {
+      for (const lid in dump.data.private[tid]) {
+        const privKey = dump.data.private[tid][lid];
+        if (!privKey) {
+          continue;
+        }
+        await this.addPrivKey(ThreadID.ThreadID.fromString(tid), peerId.peerIdFromPrivateKey(privKey), privKey);
+      }
+    }
+    for (const tid in dump.data.read) {
+      const rk = dump.data.read[tid];
+      if (!rk) {
+        continue;
+      }
+      const key = await keyManager.symKeyFromBytes(rk);
+      await this.addReadKey(ThreadID.ThreadID.fromString(tid), key);
+    }
+    for (const tid in dump.data.service) {
+      const sk = dump.data.service[tid];
+      if (!sk) {
+        continue;
+      }
+      const key = await keyManager.symKeyFromBytes(sk);
+      await this.addServiceKey(ThreadID.ThreadID.fromString(tid), key);
+    }
+  }
+}
+async function newKeyBook(store) {
+  return new DsKeyBook(store);
+}
+
+exports.newKeyBook = newKeyBook;

package/dist/cjs/implements/threaddb/lsstoreds/metadata.js

@@ -0,0 +1,199 @@
+'use strict';
+
+var key = require('../../../node_modules/interface-datastore/dist/src/key.js');
+var ThreadID = require('@textile/threads-id');
+require('../../../_virtual/index.js');
+
+// 元数据键前缀  
+const tmetaBase = new key.Key('/thread/meta');
+function newThreadMetadata(ds) {
+  return new DsThreadMetadata(ds);
+}
+class DsThreadMetadata {
+  constructor(ds) {
+    Object.defineProperty(this, "ds", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: ds
+    });
+  }
+  async getInt64(t, key) {
+    return this.getValue(t, key);
+  }
+  async putInt64(t, key, val) {
+    return this.setValue(t, key, val);
+  }
+  async getString(t, key) {
+    return this.getValue(t, key);
+  }
+  async putString(t, key, val) {
+    return this.setValue(t, key, val);
+  }
+  async getBool(t, key) {
+    return this.getValue(t, key);
+  }
+  async putBool(t, key, val) {
+    return this.setValue(t, key, val);
+  }
+  async getBytes(t, key) {
+    const k = this.keyMeta(t, key);
+    try {
+      const value = await this.ds.get(k);
+      return value;
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') return null;
+      throw new Error(`Error getting metadata: ${err.message}`);
+    }
+  }
+  async putBytes(t, key, val) {
+    const k = this.keyMeta(t, key);
+    try {
+      await this.ds.put(k, val);
+    } catch (err) {
+      throw new Error(`Error setting metadata: ${err.message}`);
+    }
+  }
+  keyMeta(t, k) {
+    const tKey = t.toString();
+    return tmetaBase.child(new key.Key(tKey)).child(new key.Key(k));
+  }
+  async getValue(t, key) {
+    const k = this.keyMeta(t, key);
+    try {
+      const value = await this.ds.get(k);
+      // For Uint8Array we'll handle it in getBytes method
+      return this.decodeValue(value);
+    } catch (err) {
+      if (err.code === 'ERR_NOT_FOUND') return null;
+      throw new Error(`Error getting metadata: ${err.message}`);
+    }
+  }
+  async setValue(t, key, val) {
+    const k = this.keyMeta(t, key);
+    const value = this.encodeValue(val);
+    try {
+      await this.ds.put(k, value);
+    } catch (err) {
+      throw new Error(`Error setting metadata: ${err.message}`);
+    }
+  }
+  async clearMetadata(t) {
+    const prefix = tmetaBase.child(new key.Key(t.toString())).toString();
+    return this.clearKeys(prefix);
+  }
+  async dumpMeta() {
+    const dump = {
+      data: {
+        bool: {},
+        int64: {},
+        string: {},
+        bytes: {}
+      }
+    };
+    const results = this.ds.query({
+      prefix: tmetaBase.toString()
+    });
+    try {
+      for await (const entry of results) {
+        const kns = new key.Key(entry.key.toString()).list();
+        if (kns.length < 4) {
+          throw new Error(`Bad metabook key: ${entry.key}`);
+        }
+        const [,, ts, key$1] = kns;
+        const tid = this.parseThreadID(ts);
+        const mk = {
+          t: tid,
+          k: key$1
+        };
+        const value = await this.decodeAnyValue(entry.value);
+        this.storeDecodedValue(dump, mk, value);
+      }
+    } catch (err) {
+      throw new Error(`Error dumping metadata: ${err.message}`);
+    }
+    return dump;
+  }
+  async restoreMeta(dump) {
+    const dataLen = Object.keys(dump.data.bool).length + Object.keys(dump.data.int64).length + Object.keys(dump.data.string).length + Object.keys(dump.data.bytes).length;
+    if (dataLen === 0) {
+      throw new Error('Empty metadata dump');
+    }
+    await this.clearKeys(tmetaBase.toString());
+    const entries = [...Object.entries(dump.data.bool), ...Object.entries(dump.data.int64), ...Object.entries(dump.data.string), ...Object.entries(dump.data.bytes)];
+    for (const [mkStr, value] of entries) {
+      const mk = JSON.parse(mkStr);
+      await this.setValue(mk.t, mk.k, value);
+    }
+  }
+  async clearKeys(prefix) {
+    const results = this.ds.queryKeys({
+      prefix
+    });
+    try {
+      for await (const key of results) {
+        await this.ds.delete(key);
+      }
+    } catch (err) {
+      throw new Error(`Error clearing keys: ${err.message}`);
+    }
+  }
+  decodeValue(buf) {
+    try {
+      const decoder = new TextDecoder();
+      return JSON.parse(decoder.decode(buf));
+    } catch (err) {
+      throw new Error(`Value decoding failed: ${err.message}`);
+    }
+  }
+  encodeValue(val) {
+    try {
+      const encoder = new TextEncoder();
+      return encoder.encode(JSON.stringify(val));
+    } catch (err) {
+      throw new Error(`Value encoding failed: ${err.message}`);
+    }
+  }
+  parseThreadID(ts) {
+    try {
+      return ThreadID.ThreadID.fromString(ts);
+    } catch (err) {
+      throw new Error(`Invalid thread ID: ${ts}`);
+    }
+  }
+  storeDecodedValue(dump, mk, value) {
+    switch (typeof value) {
+      case 'boolean':
+        dump.data.bool[mk.t.toString()] = dump.data.bool[mk.t.toString()] || {};
+        dump.data.bool[mk.t.toString()][mk.k] = value;
+        break;
+      case 'number':
+        dump.data.int64[mk.t.toString()] = dump.data.int64[mk.t.toString()] || {};
+        dump.data.int64[mk.t.toString()][mk.k] = value;
+        break;
+      case 'string':
+        dump.data.string[mk.t.toString()] = dump.data.string[mk.t.toString()] || {};
+        dump.data.string[mk.t.toString()][mk.k] = value;
+        break;
+      default:
+        if (value instanceof Uint8Array) {
+          // dump.data.bytes[mk.t.toString()] = dump.data.bytes[mk.t.toString()] || '';
+          dump.data.bytes[mk.t.toString()] = dump.data.bytes[mk.t.toString()] || {};
+          dump.data.bytes[mk.t.toString()][mk.k] = value;
+        } else {
+          throw new Error(`Unsupported value type for key: ${mk.k}`);
+        }
+    }
+  }
+  async decodeAnyValue(buf) {
+    try {
+      return this.decodeValue(buf);
+    } catch {
+      // 原始字节回退  
+      return buf;
+    }
+  }
+}
+
+exports.DsThreadMetadata = DsThreadMetadata;
+exports.newThreadMetadata = newThreadMetadata;