web-dc-api 0.1.5 → 0.1.6

package/lib/implements/threaddb/common/idbstore-adapter.ts

@@ -1,260 +0,0 @@
-import { Key, Query, Batch, Pair, KeyQuery } from 'interface-datastore'  
-import { IDBDatastore } from "datastore-idb";
-import {  QueryExt, QueryResult, Transaction,TxnDatastoreExtended } from '../core/db'  
-import { AbortOptions } from '@libp2p/interface';
-type AwaitIterable<T> = AsyncIterable<T> | Iterable<T>;  
-
-
-class IDBDatastoreAdapter implements TxnDatastoreExtended {  
-    private store: IDBDatastore;  
-    private txn: any; 
-  
-    constructor(store: IDBDatastore) {  
-      this.store = store;  
-      this.txn = null; 
-    }  
-  
-    // 修改 queryKeys 的实现  
-    async *queryKeys(  
-      query: KeyQuery,  
-      options?: AbortOptions  
-    ): AsyncIterable<Key> {  
-      const { filters = [], prefix } = query;  
-      const q = { prefix } as Query;
-      for await (const { key } of this.store.query(q)) {  
-        let match = true;  
-        
-        // 应用所有过滤器  
-        for (const filter of filters) {  
-          if (!filter(key)) {  
-            match = false;  
-            break;  
-          }  
-        }  
-  
-        if (match) {  
-          yield key;  
-        }  
-      }  
-    }  
-  
-    async *query(
-      query: Query,
-      options?: AbortOptions
-    ): AsyncIterable<Pair> {
-      try {
-        
-        // 获取迭代器
-        const storeQuery = this.store.query(query);
-        
-        // 检查异步迭代器协议
-        if (!storeQuery || typeof storeQuery[Symbol.asyncIterator] !== 'function') {
-          return;
-        }
-        
-        let count = 0;
-        // 手动迭代，而不是使用 yield*
-        for await (const entry of storeQuery) {
-          count++;
-          
-          // 验证返回值格式
-          if (!entry || !entry.key) {
-            continue;
-          }
-          
-          yield entry;
-        }
-        
-
-      } catch (err) {
-        throw err; // 重新抛出以便上层处理
-      }
-    }
-  
-    // 扩展查询方法  
-    
-  // 修改 queryExtended 的实现  
-  async *queryExtended(  
-    q: QueryExt  
-  ): AsyncIterable<QueryResult> {  
-    const { prefix, filters = [] } = q;  
-
-    const queryOptions: Query = {};
-    if (prefix !== undefined) {
-      queryOptions.prefix = prefix;
-    }
-    for await (const entry of this.store.query(queryOptions)) {  
-      let match = true;  
-      
-      // 应用所有过滤器  
-      for (const filter of filters) {  
-        if (!filter(entry)) {  
-          match = false;  
-          break;  
-        }  
-      }  
-
-      if (match) {  
-        yield {  
-          key: entry.key.toString(),  
-          value: entry.value,  
-          size: entry.value.length  
-        };  
-      }  
-    }  
-  }  
-  
-    // 其他批量操作方法  
-    async *putMany(  
-      source: AwaitIterable<Pair>,  
-      options?: AbortOptions  
-    ): AsyncIterable<Key> {  
-      const batch = this.batch();  
-      
-      for await (const entry of source) {  
-        const key = entry.key;  
-        batch.put(key, entry.value);  
-        yield key;  
-      }  
-      
-      await batch.commit();  
-    }  
-  
-    async *getMany(  
-      source: AwaitIterable<Key>,  
-      options?: AbortOptions  
-    ): AsyncIterable<Pair> {  
-      for await (const key of source) {  
-        try {  
-          const value = await this.get(key);  
-          yield {  
-            key: key,  
-            value  
-          };  
-        } catch (err) {  
-          console.error(`Error getting key ${key}:`, err);  
-        }  
-      }  
-    }  
-  
-    async *deleteMany(  
-      source: AwaitIterable<Key>,  
-      options?: AbortOptions  
-    ): AsyncIterable<Key> {  
-      const batch = this.batch();  
-      
-      for await (const key of source) {  
-        batch.delete(key);  
-        yield key;  
-      }  
-      
-      await batch.commit();  
-    }  
-  
-    // 基本操作方法  
-    async put(key: Key, value: Uint8Array): Promise<Key> {  
-      return this.store.put(key, value);  
-    }  
-  
-    async get(key: Key): Promise<Uint8Array> {  
-      return this.store.get(key);  
-    }  
-  
-    async has(key: Key): Promise<boolean> {  
-      return this.store.has(key);  
-    }  
-  
-    async delete(key: Key): Promise<void> {  
-      return this.store.delete(key);  
-    }  
-  
-    batch(): Batch {  
-      return this.store.batch();  
-    }  
-  
-
-  // 实现 TxnDatastoreExtended 接口的方法  
-  async newTransactionExtended(  
-    
-    readOnly: boolean  
-  ): Promise<Transaction> {  
-    // 保存当前实例的引用
-    const store = this.store;
-    // 由于 LevelDatastore 不支持原生事务，我们创建一个简单的包装器  
-    const txn: Transaction = {  
-      put: async ( key: Key, value: Uint8Array): Promise<Key> => {  
-        if (readOnly) throw new Error('Transaction is read-only');  
-        await this.store.put(key, value);  
-        return key;  
-      },  
-
-      get: async ( key: Key): Promise<Uint8Array> => {  
-        return this.store.get(key);  
-      },  
-
-      has: async ( key: Key): Promise<boolean> => {  
-        return this.store.has(key);  
-      },  
-
-      delete: async ( key: Key): Promise<void> => {  
-        if (readOnly) throw new Error('Transaction is read-only');  
-        await this.store.delete(key);  
-        return  ;
-      },  
-
-      query: async function*( q: Query): AsyncIterable<QueryResult> {  
-        for await (const entry of store.query(q)) {  
-          yield {  
-            key: entry.key.toString(),  
-            value: entry.value,  
-            size: entry.value.length  
-          };  
-        }  
-      }.bind(this),  
-
-      queryExtended: async function*( q: QueryExt): AsyncIterable<QueryResult> {  
-        const { prefix, filters = [] } = q;  
-        const queryOptions: Query = {};
-        if (prefix !== undefined) {
-          queryOptions.prefix = prefix;
-        }
-        for await (const entry of store.query(queryOptions)) {  
-          let match = true;  
-          for (const filter of filters) {  
-            if (!filter(entry)) {  
-              match = false;  
-              break;  
-            }  
-          }  
-          if (match) {  
-            yield {  
-              key: entry.key.toString(),  
-              value: entry.value,  
-              size: entry.value.length  
-            };  
-          }  
-        }  
-      }.bind(this),  
-
-      commit: async (): Promise<void> => {  
-        // 由于没有实际的事务支持，这里是一个空操作  
-        return Promise.resolve();  
-      } , 
-      discard: async (): Promise<void> => {  
-        // 由于没有实际的事务支持，这里是一个空操作  
-        return Promise.resolve();  
-      } 
-    };  
-
-    return txn; 
-  }  
-}  
-
-// 工厂函数  
-export async function createTxnDatastore(location: string): Promise<TxnDatastoreExtended> {  
-  const levelStore = new IDBDatastore(location);  
-  await levelStore.open();
-  const adapter = new IDBDatastoreAdapter(levelStore);  
-  return adapter;
-
-}  

package/lib/implements/threaddb/common/json-patcher.ts

@@ -1,204 +0,0 @@
-// json-patcher.ts - 完整实现  
-import { name,code, encode, decode } from '@ipld/dag-cbor';  
-import { sha256 } from 'multiformats/hashes/sha2';  
-import * as Block from 'multiformats/block';  
-import { Key } from 'interface-datastore';
-import * as dagCBOR from '@ipld/dag-cbor';
-import * as cbornode from '../cbor/node';
-import {       
-  IndexFunc,    
-  Transaction,  
-  TxnDatastoreExtended
-} from '../core/db'; 
-import {   
-  EventCodec,  
-  Action,  
-  Event,  
-  ReduceAction,  
-  InstanceID,     
-  CoreActionType
-} from '../core/db';  
-import { IPLDNode } from '../core/core';
-
-// ==================== 核心数据结构 ====================  
-interface Operation {  //当前命名方式,大小写与golang一致
-  type: CoreActionType; 
-  instanceID: InstanceID;  
-  jSONPatch: Uint8Array ; 
-}  
-
-interface PatchEvent {  //当前命名方式大小写与golang一致
-  timestamp: BigInt;  
-  iD: InstanceID;  
-  collectionName?: string; 
-  patch: Operation;  
-}  
-
-interface RecordEvents {  
-  patches: PatchEvent[];  
-}  
-
-// ==================== JSON PATCHER 实现 ====================  
-// 定义codec对象，确保包含name字段  
-const DAG_CBOR_CODEC = {  
-    name, 
-    code,  
-    encode,  
-    decode  
-  };
-export class JsonPatcher implements EventCodec {  
-  private static readonly ENCODER_SETTINGS = {  
-    codec: DAG_CBOR_CODEC,  
-    hasher: sha256,  
-    cidVersion: 1 as const  
-  };  
-
-  async create(actions: Action[]): Promise<[Event[], IPLDNode ]> {  
-    const events = this.convertActions(actions);  
-    const recordEvents = { patches: events };
-    const obj = await cbornode.wrapObject(recordEvents);
-    // const block = await Block.encode({  
-    //   value: objValue,  
-    //   ...JsonPatcher.ENCODER_SETTINGS  
-    // });  
-    return [this.wrapEvents(events), obj];  
-  }  
-
-  async reduce(  
-    events: Event[],  
-    store: TxnDatastoreExtended,  
-    baseKey: Key,  
-    indexFunc: IndexFunc  
-  ): Promise<ReduceAction[]> {  
-    const txn = await store.newTransactionExtended(false);  
-    try {  
-      const actions: ReduceAction[] = [];  
-      for (const rawEvent of this.sortEvents(events)) {  
-        const event = await this.parseEvent(rawEvent);  
-        await this.processEvent(event, baseKey, txn, indexFunc);  
-        actions.push({  
-          type: event.patch.type,  
-          collection: event.collectionName|| 'default',  
-          instanceID: event.iD  
-        });  
-      }  
-      await txn.commit();  
-      return actions;  
-    } catch (err) {  
-       txn.discard();  
-      throw this.wrapError(err as Error);  
-    }  
-  }  
-
-  async eventsFromBytes(data: Uint8Array): Promise<Event[]> {  
-    let block = await dagCBOR.decode(data);
-    if (block &&  typeof block === 'object'  &&'patches' in block && Array.isArray(block.patches)) {
-      return this.wrapEvents(block.patches);  
-    }
-    throw new Error('Invalid block format: expected RecordEvents with patches array'); 
-  }  
-
-  // ==================== 私有方法 ====================  
-  private convertActions(actions: Action[]): PatchEvent[] {  
-   const timestamp = BigInt(Date.now() * 1000000 + Math.floor(Math.random() * 1000000));
-    return actions.map(action => ({  
-      timestamp: timestamp,
-      iD: action.instanceID,  
-      collectionName: action.collectionName || 'default',  
-      patch: action.current ?{  
-        type: action.type,  
-        instanceID: action.instanceID,  
-        jSONPatch: action.current  
-      }  : {  
-        type: action.type,  
-        instanceID: action.instanceID,
-        jSONPatch: new Uint8Array()
-      }
-    }));  
-  }  
-
-  private wrapEvents(patches: PatchEvent[]): Event[] {  
-    if (!patches || patches.length === 0) {
-      return [];  
-    }
-    return patches.map(p => ({  
-      collection:  p.collectionName || 'default',  
-      instanceID: p.iD || p.patch.instanceID,  
-      timestamp: p.timestamp,  
-      payload:  p.patch.jSONPatch ? p.patch.jSONPatch : new Uint8Array(),  
-      marshal: async () => this.marshalPatchEvent(p)  
-    }));  
-  }  
-
-  private async marshalPatchEvent(event: PatchEvent): Promise<Uint8Array> {  
-   
-    return encode({  
-      t: event.timestamp,  
-      i: event.iD || event.iD,  
-      c: event.collectionName,  
-      op: {  
-        type: event.patch.type,  
-        id: event.patch.instanceID,  
-        patch:  event.patch.jSONPatch ? event.patch.jSONPatch : new Uint8Array() 
-      }
-    });  
-  }  
-
-  private sortEvents(events: Event[]): Event[] {  
-    return [...events].sort((a, b) => {
-      if (a.timestamp < b.timestamp) return -1;
-      if (a.timestamp > b.timestamp) return 1;
-      return 0;
-    });  
-  } 
-
-  private async parseEvent(event: Event): Promise<PatchEvent> {  
-    const data = decode(await event.marshal()) as any;  
-    return {  
-      timestamp: data.t,  
-      iD: data.i,  
-      collectionName: data.c,  
-      patch: {  
-        type: data.op.type,  
-        instanceID: data.op.id,  
-        jSONPatch: data.op.patch ? encode(data.op.patch) : new Uint8Array()  
-      }  
-    };  
-  }  
-
-  private async processEvent(  
-    event: PatchEvent,  
-    baseKey: Key,  
-    txn: Transaction,  
-    indexFunc: IndexFunc  
-  ): Promise<void> {  
-    const recordKey = baseKey.child(new Key(event.collectionName || 'default')).child(new Key(event.iD));  
-
-    const oldData = await txn.get(recordKey).catch(() => undefined);  
-    const newData = event.patch.type === CoreActionType.Delete  
-      ? undefined   
-      : event.patch.jSONPatch;  
-
-    await indexFunc(  
-      event.collectionName|| 'default',  
-      recordKey,  
-      txn ,  
-      oldData,  
-      newData
-    );  
-
-    if (event.patch.type === CoreActionType.Delete) {  
-      await txn.delete(recordKey);  
-    } else if (newData) {  
-      const decoded = dagCBOR.decode<Uint8Array>(newData);
-      if (!decoded) {  
-        throw new Error('Failed to decode JSON patch');  
-      }
-      await txn.put(recordKey, decoded);  
-    }  
-  }  
-
-  private wrapError(err: Error): Error {  
-    return new Error(`JSONPATCHER_ERROR: ${err.message}`);  
-  }  
-}