@fireproof/core 0.7.3-dev.2 → 0.8.0-dev.2

package/dist/blockstore.js

@@ -207,6 +207,11 @@ export const doTransaction = async (label, blockstore, doFun, doSync = true) =>
     const innerBlockstore = blockstore.begin(label);
     try {
         const result = await doFun(innerBlockstore);
+        // console.log('doTransaction', label, 'result', result.head)
+        if (result && result.head) {
+            innerBlockstore.head = result.head;
+        }
+        // pass the latest clock head for writing to the valet
         // @ts-ignore
         await blockstore.commit(innerBlockstore, doSync);
         return result;
@@ -223,6 +228,7 @@ export const doTransaction = async (label, blockstore, doFun, doSync = true) =>
 export class InnerBlockstore {
     /** @type {Map<string, Uint8Array>} */
     blocks = new Map();
+    head = [];
     lastCid = null;
     label = '';
     parentBlockstore = null;

package/dist/crypto.js

@@ -11,7 +11,11 @@ const encrypt = async function* ({ get, cids, hasher, key, cache, chunker, root
     let eroot;
     for (const string of cids) {
         const cid = CID.parse(string);
-        const unencrypted = await get(cid);
+        let unencrypted = await get(cid);
+        if (!unencrypted.cid) {
+            unencrypted = { cid, bytes: unencrypted };
+        }
+        // console.log('unencrypted', unencrypted)
         const block = await encode({ ...await codec.encrypt({ ...unencrypted, key }), codec, hasher });
         // console.log(`encrypting ${string} as ${block.cid}`)
         yield block;

package/dist/database.js

@@ -4,6 +4,7 @@ import { doTransaction, TransactionBlockstore } from './blockstore.js';
 import charwise from 'charwise';
 import { CID } from 'multiformats';
 import { DbIndex as Index } from './db-index.js';
+import { Remote } from './remote.js';
 // TypeScript Types
 // eslint-disable-next-line no-unused-vars
 // import { CID } from 'multiformats/dist/types/src/cid.js'
@@ -27,12 +28,15 @@ export class Database {
     indexes = new Map();
     rootCache = null;
     eventsCache = new Map();
+    remote = null;
+    name = '';
     constructor(name, config = {}) {
         this.name = name;
         this.clock = [];
         this.instanceId = `fp.${this.name}.${Math.random().toString(36).substring(2, 7)}`;
         this.blocks = new TransactionBlockstore(name, config);
         this.indexBlocks = new TransactionBlockstore(name ? name + '.indexes' : null, { primary: config.index });
+        this.remote = new Remote(this, name, config);
         this.config = config;
         // todo we can wait for index blocks elsewhere
         this.ready = Promise.all([this.blocks.ready, this.indexBlocks.ready]).then(([blocksReady, indexReady]) => {
@@ -49,7 +53,7 @@ export class Database {
                         clock.add(cid);
                     }
                     if (header.index) {
-                        this.indexBlocks.valet.primary.setCarCidMapCarCid(header.index.car);
+                        this.indexBlocks.valet.primary.setLastCar(header.index.car);
                         this.indexBlocks.valet.primary.setKeyMaterial(header.index.key);
                     }
                     if (header.indexes) {
@@ -83,11 +87,11 @@ export class Database {
     }
     toHeader() {
         return {
-            clock: this.clockToJSON(),
+            // clock: this.clockToJSON(),
             name: this.name,
             index: {
                 key: this.indexBlocks.valet?.primary.keyMaterial,
-                car: this.indexBlocks.valet?.primary.valetRootCarCid?.toString()
+                car: this.indexBlocks.valet?.primary.lastCar?.toString()
             },
             indexes: [...this.indexes.values()].map(index => index.toJSON())
         };
@@ -101,9 +105,9 @@ export class Database {
     clockToJSON(clock = null) {
         return (clock || this.clock).map(cid => cid.toString());
     }
-    maybeSaveClock() {
+    async maybeSaveClock() {
         if (this.name && this.blocks.valet) {
-            this.blocks.valet.saveHeader(this.toHeader());
+            await this.blocks.valet.saveHeader(this.toHeader());
         }
     }
     index(name) {
@@ -257,11 +261,14 @@ export class Database {
      * @memberof Fireproof
      * @instance
      */
-    async put({ _id, _proof, ...doc }) {
+    async put({ _id, _proof, _clock, ...doc }) {
         await this.ready;
         const id = _id || 'f' + Math.random().toString(36).slice(2);
+        doc = JSON.parse(JSON.stringify(doc));
+        if (_clock)
+            doc._clock = _clock;
         await this.runValidation({ _id: id, ...doc });
-        return await this.putToProllyTree({ key: id, value: doc }, doc._clock);
+        return await this.putToProllyTree({ key: id, value: doc }, _clock);
     }
     /**
      * Deletes a document from the database

package/dist/fireproof.js

@@ -49,6 +49,7 @@ class Fireproof {
     }
     static snapshot(database, clock) {
         const definition = database.toJSON();
+        definition.clock = database.clockToJSON();
         if (clock) {
             definition.clock = clock.map(c => parseCID(c));
             definition.indexes.forEach(index => {

package/dist/loader.js

@@ -1,6 +1,5 @@
 import { Browser } from './storage/browser.js';
 import { Rest } from './storage/rest.js';
-import { UCAN } from './storage/ucan.js';
 export const Loader = {
     appropriate: (name, config = {}) => {
         if (config.StorageClass) {
@@ -9,9 +8,6 @@ export const Loader = {
         if (config.type === 'rest') {
             return new Rest(name, config);
         }
-        if (config.type === 'ucan') {
-            return new UCAN(name, config);
-        }
         return new Browser(name, config);
     }
 };

package/dist/prolly.js

@@ -280,7 +280,7 @@ export async function root(inBlocks, head, doFull = false) {
             bigPut(nb);
         }
         // console.log('root root', newProllyRootNode.constructor.name, newProllyRootNode)
-        return { clockCIDs, node: newProllyRootNode };
+        return { clockCIDs, node: newProllyRootNode, head };
     }, false);
     // return { clockCIDs, node: newProllyRootNode }
 }

package/dist/remote.js

@@ -0,0 +1,102 @@
+// when you call database.connect(email)
+// it will return a promise that resolves when the user is logged in
+// and sends you an email
+import { create } from '@web3-storage/w3up-client';
+import * as w3clock from '@web3-storage/clock/client';
+import { CID } from 'multiformats';
+export class Remote {
+    client = null;
+    name = 'unset';
+    config = {};
+    constructor(database, name, config) {
+        this.name = name;
+        this.config = config;
+        this.database = database;
+    }
+    async clock(cid) {
+        // const did = this.client.currentSpace()
+        const agent = this.client.agent();
+        const head = await w3clock.head({ issuer: agent, with: agent.did(), proofs: [] });
+        console.log('head', head, JSON.stringify(head.root.data.ocm.out));
+        const headCids = head.root.data.ocm.out.ok.head;
+        const blocks = await Promise.all([this.database.blocks.get(CID.parse(cid)),
+            ...headCids.map(c => this.database.blocks.get(c))]);
+        console.log('blocks', blocks);
+        const adv = await w3clock.advance({ issuer: agent, with: agent.did(), proofs: [] }, CID.parse(cid), { blocks });
+        console.log('adv', adv, JSON.stringify(adv.root.data.ocm.out));
+        return { head, adv };
+    }
+    async sync(cid) {
+        // fetch the remote clock headCids using w3clock.head
+        const agent = this.client.agent();
+        const head = await w3clock.head({ issuer: agent, with: agent.did(), proofs: [] });
+        console.log('head', head, JSON.stringify(head.root.data.ocm.out));
+        const headCids = head.root.data.ocm.out.ok.head;
+        const lastSyncHead = await this.database.blocks.valet.primary.getLastSynced();
+        console.log('lastSyncHead', lastSyncHead);
+        const headSet = new Set(headCids.map(c => c.toString()));
+        const lastSyncSet = new Set(lastSyncHead.map(c => c.toString()));
+        // are they the same?
+        const same = headSet.size === lastSyncSet.size && [...headSet].every(value => lastSyncSet.has(value));
+        // if the headCids and the lastSyncHead are the same, we are in sync and can push
+        if (same) {
+            const currentHead = this.database.clock;
+            const currentHeadSet = new Set(currentHead.map(c => c.toString()));
+            console.log('synced with cloud', headSet, lastSyncSet);
+            // are they the same?
+            const currentSame = headSet.size === currentHeadSet.size && [...headSet].every(value => currentHeadSet.has(value));
+            if (currentSame) {
+                // we are in sync, do nothing
+                return true;
+            }
+            else {
+                console.log('push to cloud', headSet, currentHeadSet);
+                // we are ahead of the remote, push our clock
+                // const lastCompact = this.database.blocks.valet.primary.getLastCompact()
+                // get a compact since the last sync
+                console.log('we are ahead of the remote, push our clock');
+                // const compact = this.database.blocks.valet.primary.getCompactSince(lastSyncHead)
+            }
+        }
+        else {
+            // we are behind, fetch the remote
+            console.log('we are behind, fetch the remote');
+        }
+        // if it is the same as the local (current metadata carcid? `newValetCidCar` / sync clock), do nothing, we are in sync
+        // if it is the same as our previously pushed clock event, but our local clock is ahead of it, we need to push our clock
+        //               - we can store the previous clock event cid in the metadata
+        // - sending our updates:
+        //   - get the _last_sync and _last_compact values from our metadata
+        //   - if last sync is after last compact
+        //     - make a merged car file for the syncs
+        //   - else
+        //     - upload the car file for the last compact
+        //     - make a merge car file for any uncompacted car files since the last compact, it should base its cidMap on the compact car file (as we go the sync stream will need to track it's own cidMap)
+        //        - if there is only one car file, it is the merge car file (already based on last compact)
+        //     - upload the merge car file
+        //     -  create a new clock block with the current w3clock.head as parent and the merge car file cid as the data
+        //     - update the remote clock with the new clock block (it doesn't need to fetch the car file, and we dont need to store the clock blocks locally, just the most recent one)
+        //
+        // else if the remote head is not contained by our clock, it is is ahead of the local sync clock.
+        // -  get the car file it points to from its data field
+        // - merge to the local clock (park that car so we have both carcid indexes)
+        // - calculate a new root from the merged head, and update the local clock
+    }
+    async connect(email) {
+        try {
+            const client = await create();
+            await client.authorize(email);
+            const claims = await client.capability.access.claim();
+            console.log('claims', claims);
+            const space = await client.createSpace('fp.' + this.name);
+            console.log('space', space);
+            await client.setCurrentSpace(space.did());
+            await client.registerSpace(email);
+            this.client = client;
+            console.log('client', client);
+        }
+        catch (err) {
+            console.error('registration failed: ', err);
+        }
+    }
+}

package/dist/src/fireproof.d.ts

@@ -113,6 +113,7 @@ declare class InnerBlockstore {
     constructor(label: any, parentBlockstore: any);
     /** @type {Map<string, Uint8Array>} */
     blocks: Map<string, Uint8Array>;
+    head: any[];
     lastCid: any;
     label: string;
     parentBlockstore: any;
@@ -159,7 +160,8 @@ declare class Database {
     indexes: Map<any, any>;
     rootCache: any;
     eventsCache: Map<any, any>;
-    name: any;
+    remote: any;
+    name: string;
     clock: any[];
     instanceId: string;
     blocks: TransactionBlockstore;
@@ -174,8 +176,7 @@ declare class Database {
      */
     toJSON(): any;
     toHeader(): {
-        clock: string[];
-        name: any;
+        name: string;
         index: {
             key: any;
             car: any;
@@ -189,7 +190,7 @@ declare class Database {
      * @instance
      */
     clockToJSON(clock?: any): string[];
-    maybeSaveClock(): void;
+    maybeSaveClock(): Promise<void>;
     index(name: any): any;
     /**
      * Triggers a notification to all listeners
@@ -250,7 +251,7 @@ declare class Database {
      * @memberof Fireproof
      * @instance
      */
-    put({ _id, _proof, ...doc }: any): Promise<{
+    put({ _id, _proof, _clock, ...doc }: any): Promise<{
         id: string;
         clock: CID[];
     }>;