web-dc-api 0.1.5 → 0.1.6

package/lib/implements/threaddb/common/logstore.ts

@@ -1,215 +0,0 @@
-// Package logstore provides local store for thread logs. The subpackages provide creators for different types of store implementations.
-
-import { Mutex } from 'async-mutex';
-import { KeyBook, AddrBook, IThreadMetadata, HeadBook, ILogstore } from '../core/logstore';
-import {IThreadInfo,IThreadLogInfo} from '../core/core';
-import {SymmetricKey} from './key';
-import { ThreadID } from '@textile/threads-id'; 
-import type { PeerId } from "@libp2p/interface";
-import { compareByteArrays } from '../../../util/utils';
-import {Key as ThreadKey} from './key';
-import {ThreadInfo} from '../core/core';
-import {Errors} from '../core/db';
-
-export const PermanentAddrTTL = 2**53-1; 
-
-
-const managedSuffix = "/managed";
-
-
-// NewLogstore creates a new log store from the given books.
- export function newLogstore(kb: KeyBook, ab: AddrBook, hb: HeadBook, md: IThreadMetadata): ILogstore {
-    return new Logstore(kb, ab, hb, md);
-}
-
-// logstore is a collection of books for storing thread logs.
-class Logstore implements ILogstore {
-    private mutex = new Mutex();
-
-    constructor(
-        public keyBook: KeyBook,
-        public addrBook: AddrBook,
-        public headBook: HeadBook,
-        public metadata: IThreadMetadata
-    ) {}
-  
-
-    // Close the logstore.
-    async close(): Promise<void> {
-        const errs: Error[] = [];
-        const weakClose = async (name: string, c: any) => {
-            if (c && typeof c.close === 'function') {
-                try {
-                    await c.close();
-                } catch (err) {
-                    errs.push(new Error(`${name} error: ${err}`));
-                }
-            }
-        };
-
-        await weakClose("keybook", this.keyBook);
-        await weakClose("addressbook", this.addrBook);
-        await weakClose("headbook", this.headBook);
-        await weakClose("threadmetadata", this.metadata);
-
-        if (errs.length > 0) {
-            throw new Error(`failed while closing logstore; err(s): ${errs.map(e => e.message).join(', ')}`);
-        }
-    }
-
-    // Threads returns a list of the thread IDs in the store.
-    async threads(): Promise<ThreadID[]> {
-        return this.mutex.runExclusive(async () => {
-            const set: Set<ThreadID> = new Set();
-            const threadsFromKeys = await this.keyBook.threadsFromKeys();
-            threadsFromKeys.forEach(t => set.add(t));
-            const threadsFromAddrs = await this.addrBook.threadsFromAddrs();
-            threadsFromAddrs.forEach(t => set.add(t));
-            return Array.from(set);
-        });
-    }
-
-    // AddThread adds a thread with keys.
-    async addThread(info: IThreadInfo): Promise<void> {
-            if (!info.key?.service()) {
-                throw new Error("a service-key is required to add a thread");
-            }
-            const sk = await this.keyBook.serviceKey(info.id);
-            const symKey =  await info.key.service()?.toSymKey();
-            if (!sk) {
-                if (!symKey) {
-                    throw new Error("service-key is required");
-                }
-                await this.keyBook.addServiceKey(info.id, symKey);
-            } else if (!symKey || !compareByteArrays(symKey.raw, sk.raw)) {
-                throw new Error("service-key mismatch");
-            }
-            if (info.key.canRead()) {
-                const rk = await this.keyBook.readKey(info.id);
-                const readKey =  await info.key.read()?.toSymKey();
-                if (!rk) {
-                    if (!readKey) {
-                        throw new Error("read-key is required");
-                    }
-                    await this.keyBook.addReadKey(info.id, readKey);
-                } else if (!readKey  || !compareByteArrays(readKey.raw, rk.raw)) {
-                    throw new Error("read-key mismatch");
-                }
-            }
-        
-    }
-
-    // GetThread returns thread info of the given id.
-    async getThread(id: ThreadID):Promise<IThreadInfo> {
-            const sk = await this.keyBook.serviceKey(id);
-            if (!sk) {
-                throw Errors.ErrThreadNotFound
-            }
-            const rk = await this.keyBook.readKey(id);
-            const set = await this.getLogIDs(id);
-            const logs: IThreadLogInfo[] = [];
-            for (const l of set) {
-                const i = await this.getLog(id, l);
-                logs.push(i);
-            }
-            let threadKey = new ThreadKey(SymmetricKey.fromSymKey(sk));
-            if(rk) {
-                threadKey = new ThreadKey(SymmetricKey.fromSymKey(sk), SymmetricKey.fromSymKey(rk));
-            }
-            const threadInfo = new ThreadInfo(id, logs, [], threadKey );
-            return threadInfo;
-    
-    }
-
-    private async getLogIDs(id: ThreadID): Promise<Set<PeerId>> {
-        const set: Set<PeerId> = new Set();
-        const logsWithKeys = await this.keyBook.logsWithKeys(id);
-        logsWithKeys.forEach(l => set.add(l));
-        const logsWithAddrs = await this.addrBook.logsWithAddrs(id);
-        logsWithAddrs.forEach(l => set.add(l));
-        return set;
-    }
-
-    // DeleteThread deletes a thread.
-    async deleteThread(id: ThreadID): Promise<void> {
-            await this.keyBook.clearKeys(id);
-            await this.metadata.clearMetadata(id);
-            const set = await this.getLogIDs(id);
-            for (const l of set) {
-                await this.addrBook.clearAddrs(id, l);
-                await this.headBook.clearHeads(id, l);
-            }
-    }
-
-    // AddLog adds a log under the given thread.
-    async addLog(id: ThreadID, lg: IThreadLogInfo): Promise<void> {
-        if (lg.privKey) {
-            const pk = await this.keyBook.privKey(id, lg.id);
-            if (pk) {
-                throw Errors.ErrLogExists;
-            }
-            await this.keyBook.addPrivKey(id, lg.id, lg.privKey);
-        }
-        if (!lg.pubKey) {
-            throw new Error("public key is required");
-        }
-        await this.keyBook.addPubKey(id, lg.id, lg.pubKey);
-        await this.addrBook.addAddrs(id, lg.id, lg.addrs, PermanentAddrTTL);
-        if (lg.head ) {
-            await this.headBook.setHead(id, lg.id, lg.head);
-        }
-        if (lg.managed || lg.privKey) {
-            await this.metadata.putBool(id, lg.id.toString() + managedSuffix, true);
-        }
-        return;
-    }
-
-    // GetLog returns info about the given thread.
-    async getLog(id: ThreadID, lid: PeerId): Promise<IThreadLogInfo> {
-        return this.getLogInternal(id, lid);
-    }
-
-    private async getLogInternal(id: ThreadID, lid: PeerId): Promise<IThreadLogInfo> {
-        const pk = await this.keyBook.pubKey(id, lid);
-        if (!pk) {
-            throw Errors.ErrLogNotFound;
-        }
-        const sk = await this.keyBook.privKey(id, lid);
-        const addrs = await this.addrBook.addrs(id, lid);
-        const heads = await this.headBook.heads(id, lid);
-        const managed = await this.metadata.getBool(id, lid.toString() + managedSuffix);
-        return {
-            id: lid,
-            pubKey: pk,
-            ...(sk ? { privKey: sk } : {}),
-            addrs,
-            ...(heads.length > 0 ? { head: heads[0] } : {}),
-            managed: managed || false
-        };
-    }
-
-    // GetManagedLogs returns the logs the host is 'managing' under the given thread.
-    async getManagedLogs(id: ThreadID): Promise<IThreadLogInfo[]> {
-        const logs = await this.keyBook.logsWithKeys(id);
-        const managed: IThreadLogInfo[] = [];
-        for (const lid of logs) {
-            const lg = await this.getLog(id, lid);
-            if (lg.managed || lg.privKey) {
-                managed.push(lg);
-            }
-        }
-        return managed;
-    }
-
-    // DeleteLog deletes a log.
-    async deleteLog(id: ThreadID, lid: PeerId): Promise<void> {
-        return this.mutex.runExclusive(async () => {
-            await this.keyBook.clearLogKeys(id, lid);
-            await this.addrBook.clearAddrs(id, lid);
-            await this.headBook.clearHeads(id, lid);
-        });
-    }
-
-}
-
-export default Logstore;

package/lib/implements/threaddb/common/transformed-datastore.ts

@@ -1,308 +0,0 @@
-
-import { Key, Query, QueryFilter,Batch, Pair,Datastore } from 'interface-datastore';  
-import { BaseDatastore } from 'datastore-core';  
-import {  
-  Transaction,
-  QueryExt,
-  QueryResult ,
-  TxnDatastoreExtended
-} from '../core/db';
-
-import { 
-  AbortOptions, 
-} from '../core/core';
-
-
-// ======== 类型扩展声明 ========  
-declare module 'interface-datastore' {  
-  interface Pair {  
-    size?: number; // 添加扩展属性声明  
-  } 
-  interface QueryFilter {  
-    /** 类型标识字段 */  
-    $type?: 'key' | 'prefix';  
-  }  
-
-  // 明确导出子类型  
-  interface KeyFilter extends QueryFilter {  
-    $type: 'key';  
-    key: string;  
-  }  
-
-  interface PrefixFilter extends QueryFilter {  
-    $type: 'prefix';  
-    prefix: string;  
-  }  
-
-  interface Datastore {  
-    newTransactionExtended?: ( readOnly: boolean) => Promise<Transaction>;  
-  }  
-}
-// ======== 类型守卫优化 ========  
-
-function isKeyFilter(filter: QueryFilter): filter is KeyFilter {  
-  return (filter as KeyFilter).$type === 'key' &&   
-         typeof (filter as KeyFilter).key === 'string';  
-}  
-
-function isPrefixFilter(filter: QueryFilter): filter is PrefixFilter {  
-  return (filter as PrefixFilter).$type === 'prefix' &&   
-         typeof (filter as PrefixFilter).prefix === 'string';  
-}  
-
-
-
-
-export interface KeyTransform {  
-  convert(key: Key): Key;  
-  invert(key: Key): Key | null;  
-}  
-
-
-  // 数据存储扩展接口  
-  
-  
-  // 组合接口  
-export function createTransformedDatastore(
-  child: TxnDatastoreExtended,
-  transform: KeyTransform
-): TransformedDatastore {
-  return new TransformedDatastore(child, transform);
-}
-
-
-class TransformedDatastore extends BaseDatastore {  
-  constructor(  
-    private readonly child: TxnDatastoreExtended,  
-    private readonly transform: KeyTransform  
-  ) {  
-    super();  
-  }  
-
-  // === 基础操作 ===  
-  async put(key: Key, value: Uint8Array, options?: AbortOptions): Promise<Key> {  
-    return this.child.put(this.transform.convert(key), value, options);  
-  }  
-
-  async get(key: Key, options?: AbortOptions): Promise<Uint8Array> {  
-    return this.child.get(this.transform.convert(key));  
-  }  
-
-  async has(key: Key, options?: AbortOptions): Promise<boolean> {  
-      return this.child.has(this.transform.convert(key), options)  
-    }  
-  
-    // 使用 Await<void> 作为返回类型  
-  async delete(key: Key, options?: AbortOptions): Promise<void> {  
-      return this.child.delete(this.transform.convert(key), options)  
-  }
-
-  // === 事务管理 ===  
-  async beginTransaction(): Promise<Transaction> {  
-    const childTxn = await this.getTransaction();  
-    return new TransformedTransaction(childTxn, this.transform);  
-  }  
-
-  async  newTransactionExtended( readOnly: boolean): Promise<Transaction> {  
-    const childTxn =  await this.getTransaction(); 
-    return new TransformedTransaction(childTxn, this.transform);  
-  }
-
-  private async getTransaction(): Promise<Transaction> {  
-    if (typeof (this.child as any).newTransactionExtended === 'function') {  
-      return (this.child as any).newTransactionExtended(false);  
-    }  
-    throw new Error('Transactions not supported by underlying datastore');  
-  }  
-
-  // === 查询处理 ===  
-  // async *query(query: Query): AsyncIterable<QueryResult> {  
-  //   yield* this.queryExtended({ ...query });  
-  // }  
-
-  async *query( q: Query): AsyncIterable<Pair> {  
-      const results = this.queryExtended(q as QueryExt)  
-      for await (const result of results) {  
-        yield {key: new Key(result.key), value: result.value}
-      }  
-    }  
-  
-
-  async *queryExtended(q: QueryExt): AsyncIterable<QueryResult> {  
-    const transformedQuery = this.transformQuery(q);  
-    
-    for await (const result of this.child.query(transformedQuery)) {  
-      const originalKey = this.transform.invert(new Key(result.key.toString()));  
-      if (!originalKey) continue;  
-
-      yield {  
-        ...result,  
-        key: originalKey.toString()  
-      };  
-    }  
-  }  
-
-  private transformQuery(query: QueryExt): QueryExt {  
-    return FilterProcessor.process(query, this.transform);  
-  }  
-}  
-
-// ======== 事务实现 ========  
-class TransformedTransaction implements Transaction {  
-  constructor(  
-    private readonly txn: Transaction,  
-    private readonly transform: KeyTransform  
-  ) {}  
-
-  // === 核心操作 ===  
-  async put( key: Key, value: Uint8Array): Promise<Key> {  
-    return this.txn.put(this.transform.convert(key), value);  
-  }  
-
-  async delete( key: Key): Promise<void> {  
-    return this.txn.delete(this.transform.convert(key));  
-  }  
-
-  async get( key: Key): Promise<Uint8Array|undefined > {  
-    return this.txn.get(this.transform.convert(key));  
-  }  
-
-  async has( key: Key): Promise<boolean> {  
-    return this.txn.has(this.transform.convert(key));  
-  }  
-
-  async commit(): Promise<void> {  
-    return this.txn.commit();  
-  }  
-
-  discard(): void {  
-    this.txn.discard();  
-  }  
-
-  // === 查询操作 ===  
-  async *query( q: Query): AsyncIterable<QueryResult> {  
-    yield* this.queryExtended(q as QueryExt);  
-  }  
-
-  async *queryExtended( q: QueryExt): AsyncIterable<QueryResult> {  
-    const processedQuery = FilterProcessor.process(q, this.transform);  
-    
-    for await (const result of this.txn.queryExtended(processedQuery)) {  
-      const originalKey = this.transform.invert(new Key(result.key));  
-      if (!originalKey) continue;  
-
-      yield {  
-        ...result,  
-        key: originalKey.toString()  
-      };  
-    }  
-  }  
-}  
-
-// ======== 过滤器处理器 ========  
-class FilterProcessor {  
-  static process(input: QueryExt, transform: KeyTransform): QueryExt {  
-    const query = structuredClone(input);  
-    
-    // 前缀转换  
-    if (query.prefix) {  
-      query.prefix = transform.convert(new Key(query.prefix)).toString();  
-    }  
-
-    // 过滤器转换  
-    if (query.filters) {  
-      query.filters = query.filters.map(filter =>   
-        this.transformFilter(filter, transform)  
-      );  
-    }  
-
-    return query;  
-  }  
-  
-  // 改进后的转换方法  
-  private static transformFilter(filter: QueryFilter, transform: KeyTransform): QueryFilter {  
-    if (isKeyFilter(filter)) {  
-      const transformedKey = transform.convert(new Key(filter.key)).toString();  
-      
-      // 创建一个函数对象  
-      const keyFilter = function(item: Pair): boolean {  
-        return item.key.toString() === transformedKey;  
-      };  
-      
-      // 添加属性到函数对象  
-      Object.assign(keyFilter, {  
-        key: transformedKey,  
-        $type: 'key' as const  
-      });  
-      return keyFilter ;  
-    }  
-  
-    if (isPrefixFilter(filter)) {  
-      const transformedPrefix = transform.convert(new Key(filter.prefix)).toString();  
-      
-      // 创建一个函数对象  
-      const prefixFilter = function(item: Pair): boolean {  
-        return item.key.toString().startsWith(transformedPrefix);  
-      };  
-      
-      // 添加属性到函数对象  
-      Object.assign(prefixFilter, {  
-        prefix: transformedPrefix,  
-        $type: 'prefix' as const  
-      });  
-      return prefixFilter;  
-    }  
-
-    throw new Error('Unsupported filter type');  
-  }
-
-  private static createKeyFilter(originalKey: string): (entry: Pair) => boolean {  
-    return (entry) => entry.key.toString() === originalKey;  
-  }  
-
-  private static createPrefixFilter(originalPrefix: string): (entry: Pair) => boolean {  
-    return (entry) => entry.key.toString().startsWith(originalPrefix);  
-  }  
-}  
-
-
-
-// ======== 辅助类型定义 ========  
-interface KeyFilter extends QueryFilter {  
-  key: string;  
-}  
-
-interface PrefixFilter extends QueryFilter {  
-  prefix: string;  
-}
-
-// 前缀转换实现  
-class PrefixTransform implements KeyTransform {  
-  private prefix: Key  
-
-  constructor(prefix: string) {  
-    this.prefix = new Key(prefix)  
-  }  
-
-  convert(key: Key): Key {  
-    return new Key(this.prefix.toString() + key.toString())  
-  }  
-
-  invert(key: Key): Key {  
-    const keyStr = key.toString()  
-    const prefixStr = this.prefix.toString()  
-    if (!keyStr.startsWith(prefixStr)) {  
-      throw new Error('Invalid prefix')  
-    }  
-    return new Key(keyStr.slice(prefixStr.length))  
-  }  
-}  
-
-// 导出  
-export {  
-  TransformedDatastore,  
-  PrefixTransform,  
-}
-
-// Add a default export
-export default TransformedDatastore;