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

package/dist/src/fireproof.mjs

@@ -38937,10 +38937,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);
   }
 
@@ -38956,11 +38957,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 = [
       {
@@ -38982,7 +38983,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)
@@ -38991,6 +38992,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) {
@@ -39011,10 +39015,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
   }
 
@@ -39022,9 +39032,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)
     //  }
@@ -39086,8 +39101,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
     });
@@ -39099,9 +39119,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,
@@ -39138,12 +39170,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) {
@@ -39200,17 +39236,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,
@@ -39223,13 +39259,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
   }
@@ -39364,6 +39408,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());
       }
@@ -39374,7 +39419,7 @@ const blocksFromEncryptedCarBlock = async (cid, get, keyMaterial) => {
   }
 };
 
-const defaultConfig$2 = {
+const defaultConfig$1 = {
   headerKeyPrefix: 'fp.'
 };
 
@@ -39382,7 +39427,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 => {
@@ -40004,13 +40049,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)
   }
 
@@ -40062,49 +40107,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) {
@@ -40115,10 +40117,6 @@ const Loader = {
       return new Rest(name, config)
     }
 
-    if (config.type === 'ucan') {
-      return new UCAN(name, config)
-    }
-
     return new Browser(name, config)
   }
 };
@@ -40437,6 +40435,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
@@ -40452,6 +40453,7 @@ const doTransaction = async (label, blockstore, doFun, doSync = true) => {
 class InnerBlockstore {
   /** @type {Map<string, Uint8Array>} */
   blocks = new Map()
+  head = []
   lastCid = null
   label = ''
   parentBlockstore = null
@@ -40782,7 +40784,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
   )
@@ -41749,7 +41751,7 @@ class Database {
 
   toHeader () {
     return {
-      clock: this.clockToJSON(),
+      // clock: this.clockToJSON(),
       name: this.name,
       index: {
         key: this.indexBlocks.valet?.primary.keyMaterial,
@@ -41934,11 +41936,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)
   }
 
   /**
@@ -44282,6 +44286,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 => {