@fireproof/core 0.15.0-dev → 0.16.1

package/dist/types/commit-queue.d.ts

@@ -1,6 +0,0 @@
-export declare class CommitQueue<T = void> {
-    private queue;
-    private processing;
-    enqueue(fn: () => Promise<T>): Promise<T>;
-    private processNext;
-}

package/dist/types/crypto-ipld.d.ts

@@ -1,20 +0,0 @@
-import type { AnyBlock, AnyLink } from './types.js';
-import type { MultihashHasher } from 'multiformats';
-declare const encrypt: ({ get, cids, hasher, key, cache, chunker, root }: {
-    get: (cid: AnyLink) => Promise<AnyBlock | undefined>;
-    key: ArrayBuffer;
-    cids: AnyLink[];
-    hasher: MultihashHasher<number>;
-    chunker: (bytes: Uint8Array) => AsyncGenerator<Uint8Array>;
-    cache: (cid: AnyLink) => Promise<AnyBlock>;
-    root: AnyLink;
-}) => AsyncGenerator<any, void, unknown>;
-declare const decrypt: ({ root, get, key, cache, chunker, hasher }: {
-    root: AnyLink;
-    get: (cid: AnyLink) => Promise<AnyBlock | undefined>;
-    key: ArrayBuffer;
-    cache: (cid: AnyLink) => Promise<AnyBlock>;
-    chunker: (bytes: Uint8Array) => AsyncGenerator<Uint8Array>;
-    hasher: MultihashHasher<number>;
-}) => AsyncGenerator<AnyBlock, void, undefined>;
-export { encrypt, decrypt };

package/dist/types/crypto-node.d.ts

@@ -1,4 +0,0 @@
-import { Crypto } from '@peculiar/webcrypto';
-export declare function getCrypto(): Crypto | null;
-export declare const crypto: Crypto | null;
-export declare function randomBytes(size: number): Uint8Array;

package/dist/types/crypto-web.d.ts

@@ -1,4 +0,0 @@
-export declare function getCrypto(): Crypto | null;
-declare const gotCrypto: Crypto | null;
-export { gotCrypto as crypto };
-export declare function randomBytes(size: number): Uint8Array;

package/dist/types/encrypt-helpers.d.ts

@@ -1,8 +0,0 @@
-import type { CarReader } from '@ipld/car';
-import type { AnyBlock, CarMakeable, AnyLink } from './types';
-import { MemoryBlockstore } from '@alanshaw/pail/block';
-export declare function encryptedEncodeCarFile(key: string, rootCid: AnyLink, t: CarMakeable): Promise<AnyBlock>;
-export declare function decodeEncryptedCar(key: string, reader: CarReader): Promise<{
-    blocks: MemoryBlockstore;
-    root: AnyLink;
-}>;

package/dist/types/encrypted-block.d.ts

@@ -1,44 +0,0 @@
-import type { AnyLink } from './types';
-declare const encode: ({ iv, bytes }: {
-    iv: Uint8Array;
-    bytes: Uint8Array;
-}) => Uint8Array;
-declare const decode: (bytes: Uint8Array) => {
-    iv: Uint8Array;
-    bytes: Uint8Array;
-};
-declare const code: number;
-declare const decrypt: ({ key, value }: {
-    key: ArrayBuffer;
-    value: {
-        bytes: Uint8Array;
-        iv: Uint8Array;
-    };
-}) => Promise<{
-    cid: AnyLink;
-    bytes: Uint8Array;
-}>;
-declare const encrypt: ({ key, cid, bytes }: {
-    key: ArrayBuffer;
-    cid: AnyLink;
-    bytes: Uint8Array;
-}) => Promise<{
-    value: {
-        bytes: Uint8Array;
-        iv: Uint8Array;
-    };
-}>;
-declare const cryptoFn: (key: Uint8Array) => {
-    encrypt: (opts: any) => Promise<{
-        value: {
-            bytes: Uint8Array;
-            iv: Uint8Array;
-        };
-    }>;
-    decrypt: (opts: any) => Promise<{
-        cid: AnyLink;
-        bytes: Uint8Array;
-    }>;
-};
-declare const name = "jchris@encrypted-block:aes-gcm";
-export { encode, decode, code, name, encrypt, decrypt, cryptoFn as crypto };

package/dist/types/loader-helpers.d.ts

@@ -1,5 +0,0 @@
-import { CarReader } from '@ipld/car';
-import { AnyBlock, AnyCarHeader, AnyLink, CarMakeable } from './types';
-export declare function encodeCarFile(roots: AnyLink[], t: CarMakeable): Promise<AnyBlock>;
-export declare function encodeCarHeader(fp: AnyCarHeader): Promise<AnyBlock>;
-export declare function parseCarFile(reader: CarReader): Promise<AnyCarHeader>;

package/dist/types/loader.d.ts

@@ -1,62 +0,0 @@
-import { CarReader } from '@ipld/car';
-import { DataStore, MetaStore, RemoteWAL } from './store-browser';
-import { DataStore as AbstractDataStore, MetaStore as AbstractMetaStore } from './store';
-import type { Transaction } from './transaction';
-import type { AnyBlock, AnyCarHeader, AnyLink, BulkResult, CarLoaderHeader, CommitOpts, DbMeta, FileCarHeader, FileResult, FireproofOptions } from './types';
-import { type IndexerResult } from './loaders';
-import { CommitQueue } from './commit-queue';
-export declare function cidListIncludes(list: AnyLink[], cid: AnyLink): boolean;
-export declare function uniqueCids(list: AnyLink[], remove?: Set<string>): AnyLink[];
-export declare function toHexString(byteArray: Uint8Array): string;
-declare abstract class AbstractRemoteMetaStore extends AbstractMetaStore {
-    abstract handleByteHeads(byteHeads: Uint8Array[], branch?: string): Promise<DbMeta[]>;
-}
-export declare abstract class Loader {
-    name: string;
-    opts: FireproofOptions;
-    commitQueue: CommitQueue<AnyLink>;
-    isCompacting: boolean;
-    isWriting: boolean;
-    remoteMetaLoading: Promise<void> | undefined;
-    remoteMetaStore: AbstractRemoteMetaStore | undefined;
-    remoteCarStore: AbstractDataStore | undefined;
-    remoteWAL: RemoteWAL;
-    metaStore: MetaStore;
-    carStore: DataStore;
-    carLog: AnyLink[];
-    carReaders: Map<string, Promise<CarReader>>;
-    ready: Promise<void>;
-    key: string | undefined;
-    keyId: string | undefined;
-    seenCompacted: Set<string>;
-    private getBlockCache;
-    private seenMeta;
-    static defaultHeader: AnyCarHeader;
-    abstract defaultHeader: AnyCarHeader;
-    constructor(name: string, opts?: FireproofOptions);
-    snapToCar(carCid: AnyLink | string): Promise<void>;
-    _readyForMerge(): Promise<void>;
-    _setWaitForWrite(_writing: () => Promise<void>): Promise<void>;
-    handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
-    mergeDbMetaIntoClock(meta: DbMeta): Promise<void>;
-    protected ingestKeyFromMeta(meta: DbMeta): Promise<void>;
-    loadCarHeaderFromMeta({ car: cid }: DbMeta): Promise<CarLoaderHeader>;
-    protected abstract _applyCarHeader(_carHeader: CarLoaderHeader, snap?: boolean): Promise<void>;
-    _getKey(): Promise<string | undefined>;
-    commit(t: Transaction, done: IndexerResult | BulkResult | FileResult, opts?: CommitOpts): Promise<AnyLink>;
-    _commitInternal(t: Transaction, done: IndexerResult | BulkResult | FileResult, opts?: CommitOpts): Promise<AnyLink>;
-    flushCars(): Promise<void>;
-    entries(): AsyncIterableIterator<AnyBlock>;
-    getBlock(cid: AnyLink): Promise<AnyBlock | undefined>;
-    protected abstract makeCarHeader(_result: BulkResult | IndexerResult | FileResult, _cars: AnyLink[], _compact: boolean): AnyCarHeader | FileCarHeader;
-    protected loadCar(cid: AnyLink): Promise<CarReader>;
-    protected storesLoadCar(cid: AnyLink, local: AbstractDataStore, remote?: AbstractDataStore, publicFiles?: boolean): Promise<CarReader>;
-    protected ensureDecryptedReader(reader: CarReader): Promise<CarReader>;
-    protected setKey(key: string): Promise<void>;
-    protected getMoreReaders(cids: AnyLink[]): Promise<void>;
-}
-export interface Connection {
-    loader: Loader;
-    loaded: Promise<void>;
-}
-export {};

package/dist/types/loaders.d.ts

@@ -1,51 +0,0 @@
-import type { CarReader } from '@ipld/car';
-import type { AnyLink, BulkResult, CarCommit, DbCarHeader, FileCarHeader, FileResult, FireproofOptions, IdxCarHeader, IdxMeta, IdxMetaMap } from './types';
-import type { CRDT } from './crdt';
-import type { CRDTClock } from './crdt-clock';
-import { Loader } from './loader';
-import type { DataStore as AbstractDataStore } from './store';
-import { DataStore } from './store-browser';
-import { TransactionBlockstore } from './transaction';
-export declare class IdxLoader extends Loader {
-    crdt: CRDT;
-    static defaultHeader: {
-        cars: never[];
-        compact: never[];
-        indexes: Map<string, IdxMeta>;
-    };
-    defaultHeader: {
-        cars: never[];
-        compact: never[];
-        indexes: Map<string, IdxMeta>;
-    };
-    constructor(name: string, crdt: CRDT, opts?: FireproofOptions);
-    _applyCarHeader(header: IdxCarHeader): Promise<void>;
-    protected makeCarHeader({ indexes }: IndexerResult, cars: AnyLink[], compact?: boolean): IdxCarHeader;
-}
-export type IndexerResult = CarCommit & IdxMetaMap;
-export declare class DbLoader extends Loader {
-    static defaultHeader: {
-        cars: never[];
-        compact: never[];
-        head: never[];
-    };
-    defaultHeader: {
-        cars: never[];
-        compact: never[];
-        head: never[];
-    };
-    clock: CRDTClock;
-    awaitingCompact: boolean;
-    compacting: Promise<AnyLink | void>;
-    writing: Promise<BulkResult | void>;
-    remoteFileStore: AbstractDataStore | undefined;
-    fileStore: DataStore;
-    constructor(name: string, clock: CRDTClock, opts?: FireproofOptions);
-    _readyForMerge(): Promise<void>;
-    _setWaitForWrite(_writingFn: () => Promise<any>): Promise<void>;
-    compact(blocks: TransactionBlockstore): Promise<void>;
-    loadFileCar(cid: AnyLink, isPublic?: boolean): Promise<CarReader>;
-    protected _applyCarHeader(carHeader: DbCarHeader, snap?: boolean): Promise<void>;
-    protected makeCarHeader(result: BulkResult | FileResult, cars: AnyLink[], compact?: boolean): DbCarHeader | FileCarHeader;
-}
-export declare function isFileResult(result: IndexerResult | BulkResult | FileResult): result is FileResult;

package/dist/types/remote-wal.d.ts

@@ -1,26 +0,0 @@
-import { AnyLink, CommitOpts, DbMeta } from './types';
-import { type Loader } from './loader';
-export type WALState = {
-    operations: DbMeta[];
-    noLoaderOps: DbMeta[];
-    fileOperations: {
-        cid: AnyLink;
-        public: boolean;
-    }[];
-};
-export declare abstract class RemoteWAL {
-    tag: string;
-    STORAGE_VERSION: string;
-    loader: Loader;
-    ready: Promise<void>;
-    walState: WALState;
-    processing: Promise<void> | undefined;
-    private processQueue;
-    constructor(loader: Loader);
-    enqueue(dbMeta: DbMeta, opts: CommitOpts): Promise<void>;
-    enqueueFile(fileCid: AnyLink, publicFile?: boolean): Promise<void>;
-    _process(): Promise<void>;
-    _doProcess(): Promise<void>;
-    abstract load(branch?: string): Promise<WALState | null>;
-    abstract save(state: WALState, branch?: string): Promise<void>;
-}

package/dist/types/store-browser.d.ts

@@ -1,24 +0,0 @@
-import { IDBPDatabase } from 'idb';
-import { AnyBlock, AnyLink, DbMeta } from './types';
-import { DataStore as DataStoreBase, MetaStore as MetaStoreBase } from './store';
-import { RemoteWAL as RemoteWALBase, WALState } from './remote-wal';
-export declare class DataStore extends DataStoreBase {
-    tag: string;
-    idb: IDBPDatabase<unknown> | null;
-    _withDB(dbWorkFun: (arg0: any) => any): Promise<any>;
-    load(cid: AnyLink): Promise<AnyBlock>;
-    save(car: AnyBlock): Promise<void>;
-    remove(cid: AnyLink): Promise<void>;
-}
-export declare class RemoteWAL extends RemoteWALBase {
-    tag: string;
-    headerKey(branch: string): string;
-    load(branch?: string): Promise<WALState | null>;
-    save(state: WALState, branch?: string): Promise<void>;
-}
-export declare class MetaStore extends MetaStoreBase {
-    tag: string;
-    headerKey(branch: string): string;
-    load(branch?: string): Promise<DbMeta[] | null>;
-    save(meta: DbMeta, branch?: string): Promise<null>;
-}

package/dist/types/store-fs.d.ts

@@ -1,26 +0,0 @@
-import type { AnyBlock, AnyLink, DbMeta } from './types';
-import { MetaStore as MetaStoreBase, DataStore as DataStoreBase } from './store';
-import { RemoteWAL as RemoteWALBase, WALState } from './remote-wal';
-export declare class RemoteWAL extends RemoteWALBase {
-    filePathForBranch(branch: string): string;
-    load(branch?: string): Promise<WALState | null>;
-    save(state: WALState, branch?: string): Promise<void>;
-}
-export declare class MetaStore extends MetaStoreBase {
-    tag: string;
-    static dataDir: string;
-    filePathForBranch(branch: string): string;
-    load(branch?: string): Promise<DbMeta[] | null>;
-    save(meta: DbMeta, branch?: string): Promise<null>;
-}
-export declare const testConfig: {
-    dataDir: string;
-};
-export declare class DataStore extends DataStoreBase {
-    tag: string;
-    static dataDir: string;
-    save(car: AnyBlock): Promise<void>;
-    private cidPath;
-    load(cid: AnyLink): Promise<AnyBlock>;
-    remove(cid: AnyLink): Promise<void>;
-}

package/dist/types/store-memory.d.ts

@@ -1,24 +0,0 @@
-import { AnyBlock, AnyLink, DbMeta } from './types';
-import { DataStore as DataStoreBase, MetaStore as MetaStoreBase } from './store';
-import { RemoteWAL as RemoteWALBase, WALState } from './remote-wal';
-export declare class DataStore extends DataStoreBase {
-    tag: string;
-    store: Map<string, Uint8Array>;
-    load(cid: AnyLink): Promise<AnyBlock>;
-    save(car: AnyBlock): Promise<void>;
-    remove(cid: AnyLink): Promise<void>;
-}
-export declare class MetaStore extends MetaStoreBase {
-    tag: string;
-    store: Map<string, string>;
-    headerKey(branch: string): string;
-    load(branch?: string): Promise<DbMeta[] | null>;
-    save(meta: DbMeta, branch?: string): Promise<null>;
-}
-export declare class RemoteWAL extends RemoteWALBase {
-    tag: string;
-    store: Map<string, string>;
-    headerKey(branch: string): string;
-    load(branch?: string): Promise<WALState | null>;
-    save(state: WALState, branch?: string): Promise<void>;
-}

package/dist/types/store.d.ts

@@ -1,28 +0,0 @@
-import { ToString } from '@ipld/dag-json';
-import { AnyBlock, AnyLink, DbMeta } from './types';
-export declare const STORAGE_VERSION: string;
-declare abstract class VersionedStore {
-    STORAGE_VERSION: string;
-    name: string;
-    constructor(name: string);
-}
-export declare abstract class MetaStore extends VersionedStore {
-    tag: string;
-    makeHeader({ car, key }: DbMeta): ToString<DbMeta>;
-    parseHeader(headerData: ToString<DbMeta>): DbMeta;
-    abstract load(branch?: string): Promise<DbMeta[] | null>;
-    abstract save(dbMeta: DbMeta, branch?: string): Promise<DbMeta[] | null>;
-}
-type DataSaveOpts = {
-    public?: boolean;
-};
-export declare abstract class DataStore {
-    tag: string;
-    STORAGE_VERSION: string;
-    name: string;
-    constructor(name: string);
-    abstract load(cid: AnyLink): Promise<AnyBlock>;
-    abstract save(car: AnyBlock, opts?: DataSaveOpts): Promise<void | AnyLink>;
-    abstract remove(cid: AnyLink): Promise<void>;
-}
-export {};

package/dist/types/transaction.d.ts

@@ -1,50 +0,0 @@
-import { MemoryBlockstore } from '@alanshaw/pail/block';
-import { BlockFetcher, AnyBlock, AnyLink, BulkResult, ClockHead, IdxMeta, CarCommit, CarMakeable, FireproofOptions } from './types';
-import { DbLoader, IdxLoader } from './loaders';
-import { CRDT } from './crdt';
-import { CRDTClock } from './crdt-clock';
-export declare class Transaction extends MemoryBlockstore implements CarMakeable {
-    parent: FireproofBlockstore;
-    constructor(parent: FireproofBlockstore);
-    get(cid: AnyLink): Promise<AnyBlock | undefined>;
-    superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
-}
-declare abstract class FireproofBlockstore implements BlockFetcher {
-    ready: Promise<void>;
-    name: string | null;
-    loader: DbLoader | IdxLoader | null;
-    opts: FireproofOptions;
-    transactions: Set<Transaction>;
-    constructor(name: string | null, loader?: DbLoader | IdxLoader, opts?: FireproofOptions);
-    abstract transaction(fn: (t: Transaction) => Promise<IdxMeta | BulkResult>, indexes?: Map<string, IdxMeta>, opts?: {
-        noLoader: boolean;
-    }): Promise<BulkResultCar | IdxMetaCar>;
-    put(): Promise<void>;
-    get(cid: AnyLink): Promise<AnyBlock | undefined>;
-    commitCompaction(t: Transaction, head: ClockHead): Promise<AnyLink>;
-    entries(): AsyncIterableIterator<AnyBlock>;
-    protected executeTransaction<T, R>(fn: (t: Transaction) => Promise<T>, commitHandler: (t: Transaction, done: T) => Promise<{
-        car?: AnyLink;
-        done: R;
-    }>): Promise<R>;
-}
-export declare class IndexBlockstore extends FireproofBlockstore {
-    constructor(name: string | null, crdt: CRDT, opts?: FireproofOptions);
-    transaction(fn: (t: Transaction) => Promise<IdxMeta>, indexes: Map<string, IdxMeta>): Promise<IdxMetaCar>;
-}
-export declare class TransactionBlockstore extends FireproofBlockstore {
-    constructor(name: string | null, clock: CRDTClock, opts?: FireproofOptions);
-    transaction(fn: (t: Transaction) => Promise<BulkResult>, _indexes?: undefined, opts?: {
-        noLoader: boolean;
-    }): Promise<BulkResultCar>;
-}
-type IdxMetaCar = IdxMeta & CarCommit;
-type BulkResultCar = BulkResult & CarCommit;
-export declare class LoggingFetcher implements BlockFetcher {
-    blocks: TransactionBlockstore;
-    loader: DbLoader | IdxLoader | null;
-    loggedBlocks: Transaction;
-    constructor(blocks: TransactionBlockstore);
-    get(cid: AnyLink): Promise<AnyBlock | undefined>;
-}
-export {};