@fireproof/core 0.13.2 → 0.13.3-dev

package/dist/types/database.d.ts

@@ -20,7 +20,6 @@ export declare class Database {
         rows: import("./types").IndexRow[];
     }>;
     compact(): Promise<void>;
-    connect(schemaName?: string): import("./connect-ipfs").ConnectIPFS;
     getDashboardURL(compact?: boolean): Promise<URL>;
     openDashboard(): void;
     _notify(updates: DocUpdate[]): Promise<void>;

package/dist/types/fireproof.d.ts

@@ -1,6 +1,7 @@
-import { connect } from './connect';
 export * from './database';
 export * from './index';
-export { connect };
+export * from './loader-helpers';
+export * from './store';
+export * from './loader';
 
 export * from './types';

package/dist/types/loader.d.ts

@@ -1,10 +1,8 @@
 import { CarReader } from '@ipld/car';
-import { RemoteDataStore, RemoteMetaStore } from './store-remote';
 import { DataStore, MetaStore, RemoteWAL } from './store-browser';
-import type { DataStore as AbstractDataStore } from './store';
+import type { 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 { Connection } from './connection';
 import { type IndexerResult } from './loaders';
 export declare function cidListIncludes(list: AnyLink[], cid: AnyLink): boolean;
 export declare function toHexString(byteArray: Uint8Array): string;
@@ -12,11 +10,11 @@ export declare abstract class Loader {
     name: string;
     opts: FireproofOptions;
     remoteMetaLoading: Promise<void> | undefined;
-    remoteMetaStore: RemoteMetaStore | undefined;
-    remoteCarStore: RemoteDataStore | undefined;
-    remoteWAL: RemoteWAL | undefined;
-    metaStore: MetaStore | undefined;
-    carStore: DataStore | undefined;
+    remoteMetaStore: AbstractMetaStore | undefined;
+    remoteCarStore: AbstractDataStore | undefined;
+    remoteWAL: RemoteWAL;
+    metaStore: MetaStore;
+    carStore: DataStore;
     carLog: AnyLink[];
     carReaders: Map<string, Promise<CarReader>>;
     ready: Promise<void>;
@@ -26,9 +24,6 @@ export declare abstract class Loader {
     static defaultHeader: AnyCarHeader;
     abstract defaultHeader: AnyCarHeader;
     constructor(name: string, opts?: FireproofOptions);
-    _connectRemoteMeta(connection: Connection): Connection;
-    _connectRemoteStorage(connection: Connection): Connection;
-    connectRemote(connection: Connection, storageConnection?: Connection): Connection;
     snapToCar(carCid: AnyLink | string): Promise<void>;
     handleDbMetasFromStore(metas: DbMeta[]): Promise<void>;
     mergeDbMetaIntoClock(meta: DbMeta): Promise<void>;
@@ -40,7 +35,6 @@ export declare abstract class Loader {
     commit(t: Transaction, done: IndexerResult | BulkResult | FileResult, opts?: CommitOpts): Promise<AnyLink>;
     _commitInternal(t: Transaction, done: IndexerResult | BulkResult | FileResult, opts?: CommitOpts): Promise<AnyLink>;
     getBlock(cid: AnyLink): Promise<AnyBlock | undefined>;
-    protected initializeStores(): Promise<void>;
     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>;
@@ -48,3 +42,7 @@ export declare abstract class Loader {
     protected setKey(key: string): Promise<void>;
     protected getMoreReaders(cids: AnyLink[]): Promise<void>;
 }
+export interface Connection {
+    loader: Loader;
+    loaded: Promise<void>;
+}

package/dist/types/loaders.d.ts

@@ -1,10 +1,9 @@
 import type { CarReader } from '@ipld/car';
 import type { AnyLink, BulkResult, CarCommit, DbCarHeader, FileCarHeader, FileResult, FireproofOptions, IdxCarHeader, IdxMeta, IdxMetaMap } from './types';
-import type { Connection } from './connection';
 import type { CRDT } from './crdt';
 import type { CRDTClock } from './crdt-clock';
 import { Loader } from './loader';
-import { RemoteDataStore } from './store-remote';
+import type { DataStore as AbstractDataStore } from './store';
 import { DataStore } from './store-browser';
 export declare class IdxLoader extends Loader {
     crdt: CRDT;
@@ -35,11 +34,9 @@ export declare class DbLoader extends Loader {
         head: never[];
     };
     clock: CRDTClock;
-    remoteFileStore: RemoteDataStore | undefined;
-    fileStore: DataStore | undefined;
+    remoteFileStore: AbstractDataStore | undefined;
+    fileStore: DataStore;
     constructor(name: string, clock: CRDTClock, opts?: FireproofOptions);
-    protected initializeStores(): Promise<void>;
-    _connectRemoteStorage(connection: Connection): Connection;
     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

@@ -0,0 +1,25 @@
+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;
+    constructor(loader: Loader);
+    enqueue(dbMeta: DbMeta, opts: CommitOpts): Promise<void>;
+    enqueueFile(fileCid: AnyLink, publicFile?: boolean): Promise<void>;
+    _process(): Promise<void>;
+    _int_process(): 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,6 +1,7 @@
 import { IDBPDatabase } from 'idb';
 import { AnyBlock, AnyLink, DbMeta } from './types';
-import { DataStore as DataStoreBase, MetaStore as MetaStoreBase, RemoteWAL as RemoteWALBase, WALState } from './store';
+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;

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

@@ -1,5 +1,6 @@
 import type { AnyBlock, AnyLink, DbMeta } from './types';
-import { MetaStore as MetaStoreBase, DataStore as DataStoreBase, RemoteWAL as RemoteWALBase, WALState } from './store';
+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>;

package/dist/types/store.d.ts

@@ -1,5 +1,5 @@
 import { ToString } from '@ipld/dag-json';
-import { AnyBlock, AnyLink, CommitOpts, DbMeta } from './types';
+import { AnyBlock, AnyLink, DbMeta } from './types';
 import type { Loader } from './loader';
 export declare const STORAGE_VERSION: string;
 declare abstract class VersionedStore {
@@ -14,29 +14,6 @@ export declare abstract class MetaStore extends VersionedStore {
     abstract load(branch?: string): Promise<DbMeta[] | null>;
     abstract save(dbMeta: DbMeta, branch?: string): Promise<DbMeta[] | null>;
 }
-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;
-    constructor(loader: Loader);
-    enqueue(dbMeta: DbMeta, opts: CommitOpts): Promise<void>;
-    enqueueFile(fileCid: AnyLink, publicFile?: boolean): Promise<void>;
-    _process(): Promise<void>;
-    _int_process(): Promise<void>;
-    abstract load(branch?: string): Promise<WALState | null>;
-    abstract save(state: WALState, branch?: string): Promise<void>;
-}
 type DataSaveOpts = {
     public?: boolean;
 };

package/dist/types/types.d.ts

@@ -151,32 +151,7 @@ export interface CarMakeable {
   get(cid: AnyLink): Promise<AnyBlock | undefined>
 }
 
-export type UploadMetaFnParams = {
-  name: string,
-  branch: string,
-}
-
-export type UploadDataFnParams = {
-  type: 'data' | 'file',
-  name: string,
-  car: string,
-  size: string
-}
-
-export type DownloadFnParamTypes = 'data' | 'file'
-
-export type DownloadDataFnParams = {
-  type: DownloadFnParamTypes,
-  name: string,
-  car: string,
-}
-
-export type DownloadMetaFnParams = {
-  name: string,
-  branch: string,
-}
 
-export type LoadHandler = (dbMetas: DbMeta[]) => Promise<void>
 
 export type ChangesOptions = {
   dirty?: boolean

package/dist/types/version.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireproof/core",
-  "version": "0.13.2",
+  "version": "0.13.3-dev",
   "description": "Live database for the web",
   "main": "./dist/browser/fireproof.cjs",
   "module": "./dist/browser/fireproof.esm.js",

package/dist/types/connect-ipfs-account.d.ts

@@ -1,48 +0,0 @@
-import type { Client } from '@web3-storage/w3up-client';
-import { Database } from './database';
-import { ConnectIPFSParams } from './connect-ipfs';
-import { DatabaseConnectIPFS } from './connect-ipfs-helpers';
-type ClockSpaceDoc = {
-    type: 'clock-space';
-    clockName: `_clock/${string}/${string}`;
-    with: `did:${string}:${string}`;
-    accountSpace: `did:${string}:${string}`;
-    issuer: `did:key:${string}`;
-    created: number;
-    name: string;
-    email: `${string}@${string}` | null;
-    ua: string;
-    schema: string;
-};
-type SpaceDelegationDoc = {
-    _id: `delegation/${string}/${string}`;
-    type: 'member-delegation';
-    audience: `did:key:${string}`;
-    with: `did:${string}:${string}`;
-    schema: string;
-    status: 'pending' | 'applied';
-    delegation?: Uint8Array;
-};
-export declare class AccountConnectIPFS extends DatabaseConnectIPFS {
-    accountDb: Database;
-    client: Client | null;
-    email: `${string}@${string}` | null;
-    constructor();
-    accountEmail(): Promise<`${string}@${string}` | undefined>;
-    authorize(email: `${string}@${string}`): Promise<void>;
-    initializeClient(): Promise<void>;
-    authorizedClient(): Promise<Client>;
-    clockSpaceDIDForDb(): `did:${string}:${string}`;
-    connectClient(): Promise<Client>;
-    bestSpace(client: Client): import("@web3-storage/w3up-client/dist/src/space").Space | undefined;
-    encodeSpaceName(params: ConnectIPFSParams): `_clock/${string}/${string}`;
-    authorizedClockSpace(params: ConnectIPFSParams): Promise<`did:${string}:${string}`>;
-    createNewSpace(params: ConnectIPFSParams): Promise<`did:${string}:${string}`>;
-    joinExistingSpace(doc: ClockSpaceDoc): Promise<`did:${string}:${string}`>;
-    joinSchema(schema: string, agentDID: `did:key:${string}`): Promise<void>;
-    waitForAccess(clockDoc: ClockSpaceDoc, agentDID: `did:key:${string}`): Promise<unknown>;
-    applyDelegation(doc: SpaceDelegationDoc): Promise<void>;
-    serviceAccessRequests(): Promise<() => void>;
-    delegateAccess(clockDoc: ClockSpaceDoc | SpaceDelegationDoc, memberDid: `did:key:${string}`): Promise<void>;
-}
-export {};

package/dist/types/connect-ipfs-helpers.d.ts

@@ -1,31 +0,0 @@
-import type { Client } from '@web3-storage/w3up-client';
-import type { DownloadDataFnParams, DownloadMetaFnParams, UploadDataFnParams, UploadMetaFnParams } from './types';
-import { Connection } from './connection';
-import { MemoryBlockstore } from '@alanshaw/pail/block';
-import { Proof } from '@ucanto/interface';
-import { CarClockHead } from './connect-ipfs';
-export declare abstract class AbstractConnectIPFS extends Connection {
-    eventBlocks: MemoryBlockstore;
-    parents: CarClockHead;
-    abstract authorizedClient(): Promise<Client>;
-    abstract clockProofsForDb(): Promise<Proof[]>;
-    abstract clockSpaceDIDForDb(): `did:${string}:${string}`;
-    issuer(client: Client): import("@ucanto/interface").Signer<`did:key:${string}`, import("@ucanto/interface").SigAlg>;
-    dataDownload(params: DownloadDataFnParams): Promise<Uint8Array>;
-    dataUpload(bytes: Uint8Array, params: UploadDataFnParams, opts: {
-        public?: boolean;
-    }): Promise<import("@web3-storage/w3up-client/dist/src/types").AnyLink>;
-    metaDownload(params: DownloadMetaFnParams): Promise<Uint8Array[]>;
-    metaUpload(bytes: Uint8Array, params: UploadMetaFnParams): Promise<Uint8Array[]>;
-    fetchAndUpdateHead(remoteHead: CarClockHead): Promise<Uint8Array[]>;
-}
-export declare abstract class DatabaseConnectIPFS extends AbstractConnectIPFS {
-    activated: boolean | null;
-    authorizing: Promise<void>;
-    authorizingComplete: () => void;
-    authorizingFailed: (reason: string) => void;
-    constructor();
-    startBackgroundSync(): Promise<void>;
-    abstract initializeClient(): Promise<void>;
-    clockProofsForDb(): Promise<any[]>;
-}

package/dist/types/connect-ipfs.d.ts

@@ -1,27 +0,0 @@
-import type { Link } from 'multiformats';
-import { EventView } from '@alanshaw/pail/clock';
-import { AccountConnectIPFS } from './connect-ipfs-account';
-import { DatabaseConnectIPFS } from './connect-ipfs-helpers';
-export type CarClockHead = Link<EventView<{
-    dbMeta: Uint8Array;
-}>, number, number, 1>[];
-export type ConnectIPFSParams = {
-    name: string;
-    schema: string;
-};
-export type ConnectIPFSCallbacks = {
-    resolve: (clockSpaceDID: `did:${string}:${string}`) => void;
-    reject: (reason: string) => void;
-};
-export declare class ConnectIPFS extends DatabaseConnectIPFS {
-    accountConnection: AccountConnectIPFS;
-    authorized: boolean | null;
-    params: ConnectIPFSParams;
-    clockSpaceDID: `did:${string}:${string}`;
-    constructor(params: ConnectIPFSParams);
-    authorize(email: `${string}@${string}`): Promise<void>;
-    accountEmail(): Promise<`${string}@${string}` | undefined>;
-    authorizedClient(): Promise<import("@web3-storage/w3up-client/dist/src").Client>;
-    clockSpaceDIDForDb(): `did:${string}:${string}`;
-    initializeClient(): Promise<void>;
-}

package/dist/types/connect-s3.d.ts

@@ -1,11 +0,0 @@
-import { DownloadMetaFnParams, DownloadDataFnParams, UploadMetaFnParams, UploadDataFnParams } from './types';
-import { Connection } from './connection';
-export declare class ConnectS3 extends Connection {
-    uploadUrl: URL;
-    downloadUrl: URL;
-    constructor(upload: string, download: string);
-    dataUpload(bytes: Uint8Array, params: UploadDataFnParams): Promise<void>;
-    metaUpload(bytes: Uint8Array, params: UploadMetaFnParams): Promise<null>;
-    dataDownload(params: DownloadDataFnParams): Promise<Uint8Array | null>;
-    metaDownload(params: DownloadMetaFnParams): Promise<Uint8Array[] | null>;
-}

package/dist/types/connect.d.ts

@@ -1,39 +0,0 @@
-import { ConnectS3 } from './connect-s3';
-import { ConnectIPFS } from './connect-ipfs';
-import { Connection } from './connection';
-import { Database } from './database';
-import type { DbLoader } from './loaders';
-import { UploadDataFnParams, UploadMetaFnParams, DownloadDataFnParams, DownloadMetaFnParams, AnyLink } from './types';
-type RawConnectionParams = {
-    metaUpload: (bytes: Uint8Array, params: UploadMetaFnParams) => Promise<Uint8Array[] | null>;
-    dataUpload: (bytes: Uint8Array, params: UploadDataFnParams) => Promise<void | AnyLink>;
-    metaDownload: (params: DownloadMetaFnParams) => Promise<Uint8Array[] | null>;
-    dataDownload: (params: DownloadDataFnParams) => Promise<Uint8Array | null>;
-};
-declare class ConnectRaw extends Connection {
-    constructor({ metaUpload, metaDownload, dataUpload, dataDownload }: RawConnectionParams);
-}
-export declare const connect: {
-    s3: ({ _crdt: { blocks: { loader } } }: {
-        _crdt: {
-            blocks: {
-                loader: DbLoader;
-            };
-        };
-    }, { upload, download }: {
-        upload: string;
-        download: string;
-    }) => ConnectS3;
-    raw: ({ _crdt: { blocks: { loader } } }: {
-        _crdt: {
-            blocks: {
-                loader: DbLoader;
-            };
-        };
-    }, params: RawConnectionParams) => ConnectRaw;
-    ipfs: (db: Database, schemaName?: string) => ConnectIPFS;
-    hybrid: (db: Database, schemaName?: string) => ConnectIPFS;
-};
-export declare function validateDataParams(params: DownloadDataFnParams | UploadDataFnParams): void;
-export declare function validateMetaParams(params: DownloadMetaFnParams | UploadMetaFnParams): void;
-export {};

package/dist/types/connection.d.ts

@@ -1,15 +0,0 @@
-import { Loader } from './loader';
-import { UploadMetaFnParams, UploadDataFnParams, AnyLink, DownloadMetaFnParams, DownloadDataFnParams } from './types';
-export declare abstract class Connection {
-    ready: Promise<any>;
-    loaded: Promise<any>;
-    abstract metaUpload(bytes: Uint8Array, params: UploadMetaFnParams): Promise<Uint8Array[] | null>;
-    abstract dataUpload(bytes: Uint8Array, params: UploadDataFnParams, opts?: {
-        public?: boolean;
-    }): Promise<void | AnyLink>;
-    abstract metaDownload(params: DownloadMetaFnParams): Promise<Uint8Array[] | null>;
-    abstract dataDownload(params: DownloadDataFnParams): Promise<Uint8Array | null>;
-    constructor();
-    loader?: Loader | null;
-    refresh(): Promise<void>;
-}

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

@@ -1,27 +0,0 @@
-import { AnyBlock, AnyLink, DbMeta, DownloadFnParamTypes, LoadHandler } from './types';
-import { Connection } from './connection';
-import { DataStore as DataStoreBase, MetaStore as MetaStoreBase } from './store';
-import type { Loader } from './loader';
-export declare class RemoteDataStore extends DataStoreBase {
-    tag: string;
-    connection: Connection;
-    type: DownloadFnParamTypes;
-    constructor(loader: Loader, connection: Connection, type?: DownloadFnParamTypes);
-    prefix(): string;
-    load(carCid: AnyLink): Promise<AnyBlock>;
-    save(car: AnyBlock, opts?: {
-        public?: boolean;
-    }): Promise<void | AnyLink>;
-    remove(_cid: AnyLink): Promise<void>;
-}
-export declare class RemoteMetaStore extends MetaStoreBase {
-    tag: string;
-    connection: Connection;
-    subscribers: Map<string, LoadHandler[]>;
-    constructor(name: string, connection: Connection);
-    onLoad(branch: string, loadHandler: LoadHandler): () => void;
-    prefix(): string;
-    load(branch?: string): Promise<DbMeta[] | null>;
-    save(meta: DbMeta, branch?: string): Promise<DbMeta[] | null>;
-    dbMetasForByteHeads(byteHeads: Uint8Array[]): DbMeta[];
-}