@fireproof/core 0.13.3-dev → 0.13.5-dev

package/dist/types/apply-head-queue.d.ts

@@ -0,0 +1,18 @@
+import { Transaction } from "./transaction";
+import { ClockHead, DocUpdate } from "./types";
+type ApplyHeadWorkerFunction = (id: string, tblocks: Transaction | null, newHead: ClockHead, prevHead: ClockHead, updates: DocUpdate[] | null) => Promise<void>;
+type ApplyHeadTask = {
+    id: string;
+    tblocks: Transaction | null;
+    newHead: ClockHead;
+    prevHead: ClockHead;
+    updates: DocUpdate[] | null;
+};
+export type ApplyHeadQueue = {
+    push(task: ApplyHeadTask): AsyncGenerator<{
+        updates: DocUpdate[];
+        all: boolean;
+    }, void, unknown>;
+};
+export declare function applyHeadQueue(worker: ApplyHeadWorkerFunction): ApplyHeadQueue;
+export {};

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

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

package/dist/types/crdt-clock.d.ts

@@ -1,12 +1,19 @@
 import { TransactionBlockstore, Transaction } from './transaction';
 import type { DocUpdate, ClockHead } from './types';
+import { ApplyHeadQueue } from './apply-head-queue';
 export declare class CRDTClock {
     head: ClockHead;
     zoomers: Set<(() => void)>;
     watchers: Set<((updates: DocUpdate[]) => void)>;
+    emptyWatchers: Set<(() => void)>;
     blocks: TransactionBlockstore | null;
+    applyHeadQueue: ApplyHeadQueue;
+    constructor();
     setHead(head: ClockHead): void;
     applyHead(tblocks: Transaction | null, newHead: ClockHead, prevHead: ClockHead, updates?: DocUpdate[] | null): Promise<void>;
+    int_applyHead(taskId: string, tblocks: Transaction | null, newHead: ClockHead, prevHead: ClockHead, updates?: DocUpdate[] | null): Promise<void>;
+    notifyWatchers(updates: DocUpdate[]): void;
     onTick(fn: (updates: DocUpdate[]) => void): void;
+    onTock(fn: () => void): void;
     onZoom(fn: () => void): void;
 }

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

@@ -1,6 +1,6 @@
 import { LoggingFetcher, Transaction } from './transaction';
 import type { TransactionBlockstore } from './transaction';
-import type { DocUpdate, ClockHead, DocValue, BulkResult, ChangesOptions } from './types';
+import type { DocUpdate, ClockHead, AnyLink, DocValue, BulkResult, ChangesOptions } from './types';
 export declare function applyBulkUpdateToCrdt(tblocks: Transaction, head: ClockHead, updates: DocUpdate[], options?: object): Promise<BulkResult>;
 export declare function getValueFromCrdt(blocks: TransactionBlockstore, head: ClockHead, key: string): Promise<DocValue>;
 export declare function readFiles(blocks: TransactionBlockstore | LoggingFetcher, { doc }: DocValue): void;
@@ -10,4 +10,4 @@ export declare function clockChangesSince(blocks: TransactionBlockstore | Loggin
 }>;
 export declare function getAllEntries(blocks: TransactionBlockstore, head: ClockHead): AsyncGenerator<DocUpdate, void, unknown>;
 export declare function clockVis(blocks: TransactionBlockstore, head: ClockHead): AsyncGenerator<string, void, unknown>;
-export declare function doCompact(blocks: TransactionBlockstore, head: ClockHead): Promise<void>;
+export declare function doCompact(blocks: TransactionBlockstore, head: ClockHead): Promise<AnyLink | undefined>;

package/dist/types/database.d.ts

@@ -7,7 +7,9 @@ export declare class Database {
     static databases: Map<string, Database>;
     name: DbName;
     opts: FireproofOptions;
+    _listening: boolean;
     _listeners: Set<ListenerFn>;
+    _noupdate_listeners: Set<ListenerFn>;
     _crdt: CRDT;
     _writeQueue: WriteQueue;
     constructor(name?: string, opts?: FireproofOptions);
@@ -15,7 +17,14 @@ export declare class Database {
     put(doc: Doc): Promise<DbResponse>;
     del(id: string): Promise<DbResponse>;
     changes(since?: ClockHead, opts?: ChangesOptions): Promise<ChangesResponse>;
-    subscribe(listener: ListenerFn): () => void;
+    allDocs(): Promise<{
+        rows: {
+            key: string;
+            value: Doc;
+        }[];
+        clock: ClockHead;
+    }>;
+    subscribe(listener: ListenerFn | NoUpdateListenerFn, updates?: boolean): () => void;
     query(field: string | MapFn, opts?: QueryOpts): Promise<{
         rows: import("./types").IndexRow[];
     }>;
@@ -23,7 +32,10 @@ export declare class Database {
     getDashboardURL(compact?: boolean): Promise<URL>;
     openDashboard(): void;
     _notify(updates: DocUpdate[]): Promise<void>;
+    _no_update_notify(): Promise<void>;
 }
-type ListenerFn = (docs: Doc[]) => Promise<void> | void;
+type UpdateListenerFn = (docs: Doc[]) => Promise<void> | void;
+type NoUpdateListenerFn = () => Promise<void> | void;
+type ListenerFn = UpdateListenerFn | NoUpdateListenerFn;
 export declare function fireproof(name: string, opts?: FireproofOptions): Database;
 export {};

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

@@ -1,7 +1,8 @@
 import type { CarReader } from '@ipld/car';
-import type { AnyBlock, CarMakeable, AnyLink, BlockFetcher } from './types';
+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: BlockFetcher;
+    blocks: MemoryBlockstore;
     root: AnyLink;
 }>;

package/dist/types/loader.d.ts

@@ -1,16 +1,24 @@
 import { CarReader } from '@ipld/car';
 import { DataStore, MetaStore, RemoteWAL } from './store-browser';
-import type { DataStore as AbstractDataStore, MetaStore as AbstractMetaStore } from './store';
+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: AbstractMetaStore | undefined;
+    remoteMetaStore: AbstractRemoteMetaStore | undefined;
     remoteCarStore: AbstractDataStore | undefined;
     remoteWAL: RemoteWAL;
     metaStore: MetaStore;
@@ -20,20 +28,25 @@ export declare abstract class Loader {
     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>;
-    private committing;
     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>;
@@ -46,3 +59,4 @@ export interface Connection {
     loader: Loader;
     loaded: Promise<void>;
 }
+export {};

package/dist/types/loaders.d.ts

@@ -5,6 +5,7 @@ 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: {
@@ -34,9 +35,15 @@ export declare class DbLoader extends Loader {
         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;

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

@@ -1,5 +1,5 @@
 import { AnyLink, CommitOpts, DbMeta } from './types';
-import type { Loader } from './loader';
+import { type Loader } from './loader';
 export type WALState = {
     operations: DbMeta[];
     noLoaderOps: DbMeta[];
@@ -15,11 +15,12 @@ export declare abstract class RemoteWAL {
     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>;
-    _int_process(): Promise<void>;
+    _doProcess(): Promise<void>;
     abstract load(branch?: string): Promise<WALState | null>;
     abstract save(state: WALState, branch?: string): Promise<void>;
 }

package/dist/types/transaction.d.ts

@@ -4,8 +4,8 @@ import { DbLoader, IdxLoader } from './loaders';
 import { CRDT } from './crdt';
 import { CRDTClock } from './crdt-clock';
 export declare class Transaction extends MemoryBlockstore implements CarMakeable {
-    parent: BlockFetcher;
-    constructor(parent: BlockFetcher);
+    parent: FireproofBlockstore;
+    constructor(parent: FireproofBlockstore);
     get(cid: AnyLink): Promise<AnyBlock | undefined>;
     superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
 }
@@ -21,7 +21,7 @@ declare abstract class FireproofBlockstore implements BlockFetcher {
     }): Promise<BulkResultCar | IdxMetaCar>;
     put(): Promise<void>;
     get(cid: AnyLink): Promise<AnyBlock | undefined>;
-    commitCompaction(t: Transaction, head: ClockHead): Promise<AnyLink | 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;
@@ -43,7 +43,7 @@ type BulkResultCar = BulkResult & CarCommit;
 export declare class LoggingFetcher implements BlockFetcher {
     blocks: TransactionBlockstore;
     loader: DbLoader | IdxLoader | null;
-    cids: Set<AnyLink>;
+    loggedBlocks: Transaction;
     constructor(blocks: TransactionBlockstore);
     get(cid: AnyLink): Promise<AnyBlock | undefined>;
 }

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "0.13.3-dev";
+export declare const PACKAGE_VERSION = "0.13.5-dev";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireproof/core",
-  "version": "0.13.3-dev",
+  "version": "0.13.5-dev",
   "description": "Live database for the web",
   "main": "./dist/browser/fireproof.cjs",
   "module": "./dist/browser/fireproof.esm.js",
@@ -36,12 +36,12 @@
     "build:_types": "tsc --declaration --outDir dist/types && node ./scripts/types.js",
     "build:rollup": "rollup -c scripts/rollup.js",
     "build:tsc": "npm run clean && tsc && mkdir dist/tsc && mv dist/*.js dist/tsc/ && node ./scripts/types.js",
-    "build": "npm run build:tsc && npm run build:test && cp dist/browser/fireproof.iife.js test/www/",
     "test:watch:follow": "nodemon -w src -w test -e ts,js --exec \"sleep 2 && npm run test:node\"",
     "test:node": "node ./scripts/test.js",
     "test:browser": "node ./scripts/browser-test.js",
     "lint:fix": "eslint --fix '{src,test}/**/*.{js,ts}'",
     "lint:exports": "ts-unused-exports tsconfig.json",
+    "serve": "npx serve-http -p 8080 test/www",
     "lint": "eslint 'src/**/*.{js,ts}'",
     "analyze": "node ./scripts/analyze.js",
     "test:coverage": "c8 --reporter=html --include='dist/*' node ./scripts/test.js && open coverage/src/index.html",
@@ -50,7 +50,8 @@
     "test:watch": "nodemon -w src -w test -e ts,js --exec \"npm run build:test && npm run test:node\"",
     "test": "npm run build:test && npm run test:node && tsc",
     "build:test": "node ./scripts/build.js",
-    "build:all": " npm run build:version && npm run build && npm run test:browser"
+    "build": "npm run build:version && npm run build:tsc && npm run build:test && cp dist/browser/fireproof.iife.* test/www/",
+    "build:all": " npm run build && npm run test:browser"
   },
   "keywords": [
     "database",