@x5e/gink
Version:
an eventually consistent database
77 lines (76 loc) • 4.19 kB
TypeScript
import { IDBPTransaction } from "idb";
import { AsOf, BroadcastFunc, BundleInfo, Bytes, ChainStart, ClaimedChain, Entry, IndexedDbStoreSchema, ScalarKey, Medallion, Muid, MuidTuple, Removal, Timestamp, BundleView, KeyPair, Value, Placement } from "./typedefs";
import { HasMap } from "./HasMap";
import { Store } from "./Store";
type Transaction = IDBPTransaction<IndexedDbStoreSchema, ("trxns" | "chainInfos" | "activeChains" | "containers" | "removals" | "clearances" | "entries" | "identities" | "verifyKeys" | "secretKeys" | "symmetricKeys" | "accumulatorTotals")[], "readwrite" | "readonly">;
/**
* Uses an indexedDb to implement the Store interface. On the server side, this will
* be done using a shim that is only an in-memory implementation of the IndexedDb API,
* so the LogBackedStore should be used on the server for persistence. Most of the time
* uses of Gink should not need to call methods on the store directly, instead just
* pass it into the Database (or SimpleServer, etc.).
*/
export declare class IndexedDbStore implements Store {
private keepingHistory;
ready: Promise<void>;
private wrapped;
private transaction;
private countTrxns;
private trxnId;
private initialized;
private processingLock;
private lastCaller;
private foundBundleCallBacks;
private pending;
private static readonly YEAR_2020;
constructor(indexedDbName: string, reset?: boolean, keepingHistory?: boolean);
getBillionths(muid: Muid, asOf?: AsOf): Promise<bigint>;
acquireChain(identity: string): Promise<BundleInfo | null>;
private initialize;
getVerifyKey(chainInfo: [Medallion, ChainStart]): Promise<Bytes>;
saveKeyPair(keyPair: KeyPair): Promise<void>;
pullKeyPair(publicKey: Bytes): Promise<KeyPair>;
saveSymmetricKey(symmetricKey: Bytes): Promise<number>;
getSymmetricKey(keyId: number, trxn?: Transaction): Promise<Bytes>;
private clearTransaction;
private getTransaction;
getTransactionCount(): number;
dropHistory(container?: Muid, before?: AsOf): Promise<void>;
stopHistory(): Promise<void>;
startHistory(): void;
close(): Promise<void>;
getLocation(entry: Muid, asOf?: AsOf): Promise<Placement | undefined>;
private asOfToTimestamp;
getClaimedChains(): Promise<Map<Medallion, ClaimedChain>>;
getChainIdentity(chainInfo: [Medallion, ChainStart]): Promise<string>;
private claimChain;
getChainTracker(): Promise<HasMap>;
private getChainInfos;
addBundle(bundleView: BundleView, claimChain?: boolean): Promise<boolean>;
private addBundleHelper;
getContainerBytes(address: Muid): Promise<Bytes | undefined>;
getEntryByKey(container?: Muid, key?: ScalarKey | Muid | [Muid, Muid], asOf?: AsOf): Promise<Entry | undefined>;
getClearanceTime(trxn: Transaction, muidTuple: MuidTuple, asOfTs: Timestamp): Promise<Timestamp>;
getKeyedEntries(container: Muid, asOf?: AsOf): Promise<Map<string, Entry>>;
getEntriesBySourceOrTarget(vertex: Muid, source: boolean, asOf?: AsOf): Promise<Entry[]>;
/**
* Returns entry data for a List. Does it in a single pass rather than using an async generator
* because if a user tried to await on something else between entries it would cause the IndexedDb
* transaction to auto-close.
* @param container to get entries for
* @param through number to get, negative for starting from end
* @param asOf show results as of a time in the past
* @returns a promise of a list of ChangePairs
*/
getOrderedEntries(container: Muid, through?: number, asOf?: AsOf): Promise<Map<string, Entry>>;
getEntryById(entryMuid: Muid, asOf?: AsOf): Promise<Entry | undefined>;
getContainersByName(name: string, asOf?: AsOf): Promise<Muid[]>;
getContainerProperties(containerMuid: Muid, asOf?: AsOf): Promise<Map<string, Value>>;
getAllContainerTuples(): Promise<MuidTuple[]>;
getAllEntryKeys(): Promise<MuidTuple[]>;
getAllEntries(): Promise<Entry[]>;
getAllRemovals(): Promise<Removal[]>;
getBundles(callBack: (bundle: BundleView) => void): Promise<void>;
addFoundBundleCallBack(callback: BroadcastFunc): void;
}
export {};