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

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/database.js

@@ -83,7 +83,7 @@ export class Database {
     }
     toHeader() {
         return {
-            clock: this.clockToJSON(),
+            // clock: this.clockToJSON(),
             name: this.name,
             index: {
                 key: this.indexBlocks.valet?.primary.keyMaterial,
@@ -257,11 +257,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,46 @@
+// 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 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;
@@ -174,7 +175,6 @@ declare class Database {
      */
     toJSON(): any;
     toHeader(): {
-        clock: string[];
         name: any;
         index: {
             key: any;
@@ -250,7 +250,7 @@ declare class Database {
      * @memberof Fireproof
      * @instance
      */
-    put({ _id, _proof, ...doc }: any): Promise<{
+    put({ _id, _proof, _clock, ...doc }: any): Promise<{
         id: string;
         clock: CID[];
     }>;

package/dist/src/fireproof.js

@@ -38939,10 +38939,11 @@ class Base {
     }
     cidMap.clear();
     const blocks = {
+      head: clock,
       lastCid: clock[0],
       get: cid => allBlocks.get(cid.toString())
     };
-    console.log('compact', this.instanceId, this.name, blocks.lastCid.toString(), dataCids.length);
+    // console.log('compact', this.instanceId, this.name, blocks.lastCid.toString(), dataCids.length)
     await this.parkCar(blocks, dataCids);
   }
 
@@ -38958,11 +38959,11 @@ class Base {
       newCar = await blocksToCarBlock(innerBlockstore.lastCid, innerBlockstore);
     }
     // console.log('new car', newCar.cid.toString())
-    return await this.saveCar(newCar.cid.toString(), newCar.bytes, cids)
+    return await this.saveCar(newCar.cid.toString(), newCar.bytes, cids, innerBlockstore.head)
   }
 
-  async saveCar (carCid, value, cids) {
-    const newValetCidCar = await this.updateCarCidMap(carCid, cids);
+  async saveCar (carCid, value, cids, head = null) {
+    const newValetCidCar = await this.updateCarCidMap(carCid, cids, head);
     // console.log('writeCars', carCid.toString(), newValetCidCar.cid.toString())
     const carList = [
       {
@@ -38984,7 +38985,7 @@ class Base {
     return newValetCidCar
   }
 
-  applyHeaders (headers) {
+  async applyHeaders (headers) {
     // console.log('applyHeaders', headers.index)
     this.headers = headers;
     // console.log('before applied', this.instanceId, this.name, this.keyMaterial, this.valetRootCarCid)
@@ -38993,6 +38994,9 @@ class Base {
         // console.log('applyHeaders', this.instanceId, this.name, header.key, header.car)
         header.key && this.setKeyMaterial(header.key);
         this.setCarCidMapCarCid(header.car);
+        const { clock } = await this.readHeaderCar(header.car);
+        // console.log('stored clock', this.name, branch, clock, header)
+        header.clock = clock.map(c => c.toString());
       }
     }
     if (!this.valetRootCarCid) {
@@ -39013,10 +39017,16 @@ class Base {
     const headers = {};
     for (const [branch] of Object.entries(this.config.branches)) {
       const got = await this.loadHeader(branch);
+      // const carCid = got.car
       // console.log('getHeaders', this.name, branch, got)
+      // if (got && got.car) {
+      // const { clock } = await this.readHeaderCar(got.car)
+      // console.log('stored clock', this.name, branch, clock)
+      // }
+
       headers[branch] = got;
     }
-    this.applyHeaders(headers);
+    await this.applyHeaders(headers);
     return headers
   }
 
@@ -39024,9 +39034,14 @@ class Base {
     throw new Error('not implemented')
   }
 
+  async getStoredClock (carCid) {
+
+  }
+
   async saveHeader (header) {
+    // this.clock = header.clock
     // for each branch, save the header
-    // console.log('saveHeader', this.config.branches, header)
+    // console.log('saveHeader', header.clock)
     //  for (const branch of this.branches) {
     //    await this.saveBranchHeader(branch)
     //  }
@@ -39088,8 +39103,13 @@ class Base {
   async mapForIPLDHashmapCarCid (carCid) {
     // console.log('mapForIPLDHashmapCarCid', carCid)
     // todo why is this writeable?
-    const carMapReader = await this.getWriteableCarReader(carCid);
-    const indexNode = await load$1(carMapReader, carMapReader.root.cid, {
+    const { cars, reader: carMapReader } = await this.readHeaderCar(carCid);
+
+    // this.clock = clock
+
+    // console.log('mapForIPLDHashmapCarCid', cars)
+
+    const indexNode = await load$1(carMapReader, cars, {
       blockHasher: blockOpts$1.hasher,
       blockCodec: blockOpts$1.codec
     });
@@ -39101,9 +39121,21 @@ class Base {
     return theCarMap
   }
 
+  async readHeaderCar (carCid) {
+    const carMapReader = await this.getWriteableCarReader(carCid);
+    // console.log('readHeaderCar', carCid, carMapReader)
+    // now when we load the root cid from the car, we get our new custom root node
+    const bytes = await carMapReader.get(carMapReader.root.cid);
+    const decoded = await decode$5({ bytes, hasher: blockOpts$1.hasher, codec: blockOpts$1.codec });
+    // @ts-ignore
+    const { fp: { cars, clock } } = decoded.value;
+    return { cars, clock, reader: carMapReader }
+  }
+
   async getWriteableCarReader (carCid) {
     // console.log('getWriteableCarReader', carCid)
     const carMapReader = await this.getCarReader(carCid);
+    // console.log('getWriteableCarReader', carCid, carMapReader)
     const theseWriteableBlocks = new VMemoryBlockstore();
     const combinedReader = {
       blocks: theseWriteableBlocks,
@@ -39140,12 +39172,16 @@ class Base {
 
   async getCarReaderImpl (carCid) {
     carCid = carCid.toString();
+    // console.log('getCarReaderImpl', carCid)
     const carBytes = await this.readCar(carCid);
     // console.log('getCarReader', this.constructor.name, carCid, carBytes.length)
     const reader = await CarReader.fromBytes(carBytes);
+    // console.log('getCarReader', carCid, reader._header)
     if (this.keyMaterial) {
       const roots = await reader.getRoots();
+      // let count = 0
       const readerGetWithCodec = async cid => {
+        // console.log('readerGetWithCodec', count++, cid)
         const got = await reader.get(cid);
         let useCodec = codec;
         if (cid.toString().indexOf('bafy') === 0) {
@@ -39202,17 +39238,17 @@ class Base {
 
   writeCars (cars) {}
 
-  async updateCarCidMap (carCid, cids) {
+  async updateCarCidMap (carCid, cids, head) {
     // this hydrates the map if it has not been hydrated
     const theCarMap = await this.getCidCarMap();
     for (const cid of cids) {
       theCarMap.set(cid, carCid);
     }
     // todo can we debounce this? -- maybe put it into a queue so we can batch it
-    return await this.persistCarMap(theCarMap)
+    return await this.persistCarMap(theCarMap, head)
   }
 
-  async persistCarMap (theCarMap) {
+  async persistCarMap (theCarMap, head) {
     const ipldLoader = await getEmptyLoader();
     const indexNode = await create$1(ipldLoader, {
       bitWidth: 4,
@@ -39225,13 +39261,21 @@ class Base {
       await indexNode.set(key, value);
     }
 
+    // console.log('persistCarMap', indexNode.cid, head)
+    const value = { fp: { cars: indexNode.cid, clock: head } };
+    const header = await encode$5({ value, hasher: blockOpts$1.hasher, codec: blockOpts$1.codec });
+    ipldLoader.blocks.put(header.cid, header.bytes);
+
     let newValetCidCar;
     if (this.keyMaterial) {
       const cids = [...ipldLoader.blocks.blocks.keys()];
       // console.log('persistCarMap', cids)
-      newValetCidCar = await blocksToEncryptedCarBlock(indexNode.cid, ipldLoader.blocks, this.keyMaterial, cids);
+      // store the clock head and a link to the indexNode.cid in a custom root?
+
+      newValetCidCar = await blocksToEncryptedCarBlock(header.cid, ipldLoader.blocks, this.keyMaterial, cids);
+      // then put this carcid into the header / w3clock
     } else {
-      newValetCidCar = await blocksToCarBlock(indexNode.cid, ipldLoader.blocks);
+      newValetCidCar = await blocksToCarBlock(header.cid, ipldLoader.blocks);
     }
     return newValetCidCar
   }
@@ -39366,6 +39410,7 @@ const blocksFromEncryptedCarBlock = async (cid, get, keyMaterial) => {
         cache: nocache
         // codec: dagcbor
       })) {
+        // console.log('decrypted', block.cid.toString())
         decryptedBlocks.push(block);
         cids.add(block.cid.toString());
       }
@@ -39376,7 +39421,7 @@ const blocksFromEncryptedCarBlock = async (cid, get, keyMaterial) => {
   }
 };
 
-const defaultConfig$2 = {
+const defaultConfig$1 = {
   headerKeyPrefix: 'fp.'
 };
 
@@ -39384,7 +39429,7 @@ const defaultConfig$2 = {
 
 class Browser extends Base {
   constructor (name, config = {}) {
-    super(name, Object.assign({}, defaultConfig$2, config));
+    super(name, Object.assign({}, defaultConfig$1, config));
   }
 
   withDB = async dbWorkFun => {
@@ -40006,13 +40051,13 @@ var browserPonyfill = {
 
 var fetch = /*@__PURE__*/getDefaultExportFromCjs(browserPonyfillExports);
 
-const defaultConfig$1 = {
+const defaultConfig = {
   url: 'http://localhost:4000'
 };
 
 class Rest extends Base {
   constructor (name, config = {}) {
-    super(name, Object.assign({}, defaultConfig$1, config));
+    super(name, Object.assign({}, defaultConfig, config));
     // console.log('Rest', name, config)
   }
 
@@ -40064,49 +40109,6 @@ class Rest extends Base {
   }
 }
 
-const defaultConfig = {
-  upload: () => {},
-  url: (cid) => `https://${cid}.ipfs.w3s.link/`
-};
-
-class UCAN extends Base {
-  constructor (name, config = {}) {
-    super(name, Object.assign({}, defaultConfig, config));
-  }
-
-  async writeCars (cars) {
-    if (this.config.readonly) return
-    for (const { cid, bytes } of cars) {
-      console.log(`write UCAN ${cid}, ${bytes.length} bytes`);
-      const upCid = await this.config.upload(bytes);
-      console.log(`wrote UCAN ${cid}, ${upCid}`);
-      // if (!response.ok) throw new Error(`An error occurred: ${response.statusText}`)
-    }
-  }
-
-  async readCar (carCid) {
-    const carURL = this.config.url(carCid);
-    const response = await fetch(carURL);
-    if (!response.ok) throw new Error(`An error occurred: ${response.statusText}`)
-    const got = await response.arrayBuffer();
-    return new Uint8Array(got)
-  }
-
-  async loadHeader (branch = 'main') {
-    return headerMock.get(branch)
-  }
-
-  async writeHeader (branch, header) {
-    if (this.config.readonly) return
-    const pHeader = this.prepareHeader(header);
-    // console.log('writeHeader rt', branch, pHeader)
-
-    headerMock.set(branch, pHeader);
-  }
-}
-
-const headerMock = new Map();
-
 const Loader = {
   appropriate: (name, config = {}) => {
     if (config.StorageClass) {
@@ -40117,10 +40119,6 @@ const Loader = {
       return new Rest(name, config)
     }
 
-    if (config.type === 'ucan') {
-      return new UCAN(name, config)
-    }
-
     return new Browser(name, config)
   }
 };
@@ -40439,6 +40437,9 @@ 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
@@ -40454,6 +40455,7 @@ const doTransaction = async (label, blockstore, doFun, doSync = true) => {
 class InnerBlockstore {
   /** @type {Map<string, Uint8Array>} */
   blocks = new Map()
+  head = []
   lastCid = null
   label = ''
   parentBlockstore = null
@@ -40784,7 +40786,7 @@ 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
   )
@@ -41751,7 +41753,7 @@ class Database {
 
   toHeader () {
     return {
-      clock: this.clockToJSON(),
+      // clock: this.clockToJSON(),
       name: this.name,
       index: {
         key: this.indexBlocks.valet?.primary.keyMaterial,
@@ -41936,11 +41938,13 @@ 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)
   }
 
   /**
@@ -44284,6 +44288,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 => {