@fireproof/core 0.4.1 → 0.5.0

package/dist/src/fireproof.mjs

@@ -37116,6 +37116,7 @@ const blocksToCarBlock = async (lastCid, blocks) => {
     blocks = Array.from(blocks.entries());
   }
   for (const { cid, bytes } of blocks) {
+    // console.log(cid, bytes)
     size += blockLength({ cid, bytes });
   }
   const buffer = new Uint8Array(size);
@@ -37695,7 +37696,8 @@ async function root (inBlocks, head) {
  */
 async function eventsSince (blocks, head, since) {
   if (!head.length) {
-    throw new Error('no head')
+    // throw new Error('no head')
+    return { clockCIDs: [], result: [] }
   }
   // @ts-ignore
   const sinceHead = [...since, ...head]; // ?
@@ -38133,7 +38135,7 @@ class Database {
       // console.log('change rows', this.instanceId, rows)
     } else {
       const allResp = await getAll(this.blocks, this.clock);
-      rows = allResp.result.map(({ key, value }) => (decodeEvent({ key, value })));
+      rows = allResp.result.map(({ key, value }) => decodeEvent({ key, value }));
       dataCIDs = allResp.cids;
       // console.log('dbdoc rows', this.instanceId, rows)
     }
@@ -38146,7 +38148,9 @@ class Database {
 
   async allDocuments () {
     const allResp = await getAll(this.blocks, this.clock);
-    const rows = allResp.result.map(({ key, value }) => (decodeEvent({ key, value }))).map(({ key, value }) => ({ key, value: { _id: key, ...value } }));
+    const rows = allResp.result
+      .map(({ key, value }) => decodeEvent({ key, value }))
+      .map(({ key, value }) => ({ key, value: { _id: key, ...value } }));
     return {
       rows,
       clock: this.clockToJSON(),
@@ -38154,6 +38158,15 @@ class Database {
     }
   }
 
+  async allCIDs () {
+    const allResp = await getAll(this.blocks, this.clock);
+    const cids = await cidsToProof(allResp.cids);
+    const clockCids = await cidsToProof(allResp.clockCIDs);
+    // console.log('allcids', cids, clockCids)
+    // todo we need to put the clock head as the last block in the encrypted car
+    return [...cids, ...clockCids] // need a single block version of clock head, maybe an encoded block for it
+  }
+
   /**
    * Runs validation on the specified document using the Fireproof instance's configuration. Throws an error if the document is invalid.
    *
@@ -38166,7 +38179,7 @@ class Database {
   async runValidation (doc) {
     if (this.config && this.config.validateChange) {
       const oldDoc = await this.get(doc._id)
-        .then((doc) => doc)
+        .then(doc => doc)
         .catch(() => ({}));
       this.config.validateChange(doc, oldDoc, this.authCtx);
     }
@@ -38201,13 +38214,13 @@ class Database {
     return doc
   }
   /**
- * @typedef {Object} Document
- * @property {string} _id - The ID of the document (required)
- * @property {string} [_proof] - The proof of the document (optional)
- * @property {string} [_clock] - The clock of the document (optional)
- * @property {any} [key: string] - Index signature notation to allow any other unknown fields
- *  * @property {Object.<string, any>} [otherProperties] - Any other unknown properties (optional)
- */
+   * @typedef {Object} Document
+   * @property {string} _id - The ID of the document (required)
+   * @property {string} [_proof] - The proof of the document (optional)
+   * @property {string} [_clock] - The clock of the document (optional)
+   * @property {any} [key: string] - Index signature notation to allow any other unknown fields
+   *  * @property {Object.<string, any>} [otherProperties] - Any other unknown properties (optional)
+   */
 
   /**
    * Adds a new document to the database, or updates an existing document. Returns the ID of the document and the new clock head.
@@ -38262,17 +38275,17 @@ class Database {
         throw new Error('MVCC conflict, document is changed, please reload the document and try again.')
       }
     }
+    const prevClock = [...this.clock];
     const result = await doTransaction(
       'putToProllyTree',
       this.blocks,
-      async (blocks) => await put(blocks, this.clock, event)
+      async blocks => await put(blocks, this.clock, event)
     );
     if (!result) {
       console.error('failed', event);
       throw new Error('failed to put at storage layer')
     }
-    // console.log('new clock head', this.instanceId, result.head.toString())
-    this.clock = result.head; // do we want to do this as a finally block
+    this.applyClock(prevClock, result.head);
     await this.notifyListeners([decodedEvent]); // this type is odd
     return {
       id: decodedEvent.key,
@@ -38282,6 +38295,12 @@ class Database {
     // todo should include additions (or split clock)
   }
 
+  applyClock (prevClock, newClock) {
+    // console.log('applyClock', prevClock, newClock, this.clock)
+    const removedprevCIDs = this.clock.filter(cid => prevClock.indexOf(cid) === -1);
+    this.clock = removedprevCIDs.concat(newClock);
+  }
+
   //   /**
   //    * Advances the clock to the specified event and updates the root CID
   //    *   Will be used by replication
@@ -38340,7 +38359,7 @@ class Database {
 async function cidsToProof (cids) {
   if (!cids || !cids.all) return []
   const all = await cids.all();
-  return [...all].map((cid) => cid.toString())
+  return [...all].map(cid => cid.toString())
 }
 
 function decodeEvent (event) {
@@ -38650,10 +38669,10 @@ const indexEntriesForChanges = (changes, mapFn) => {
   changes.forEach(({ key, value, del }) => {
     if (del || !value) return
     mapFn(makeDoc({ key, value }), (k, v) => {
-      if (typeof v === 'undefined' || typeof k === 'undefined') return
+      if (typeof k === 'undefined') return
       indexEntries.push({
         key: [charwise.encode(k), key],
-        value: v
+        value: v || null
       });
     });
   });
@@ -38671,7 +38690,7 @@ const indexEntriesForChanges = (changes, mapFn) => {
  *
  */
 class DbIndex {
-  constructor (database, mapFn, clock, opts = {}) {
+  constructor (database, name, mapFn, clock = null, opts = {}) {
     this.database = database;
     if (!database.indexBlocks) {
       database.indexBlocks = new TransactionBlockstore(database?.name + '.indexes', database.blocks.valet?.getKeyMaterial());
@@ -38687,7 +38706,7 @@ class DbIndex {
       this.mapFn = mapFn;
       this.mapFnString = mapFn.toString();
     }
-    this.name = opts.name || this.makeName();
+    this.name = name || this.makeName();
     this.indexById = { root: null, cid: null };
     this.indexByKey = { root: null, cid: null };
     this.dbHead = null;
@@ -38737,7 +38756,7 @@ class DbIndex {
 
   static fromJSON (database, { code, clock, name }) {
     // console.log('DbIndex.fromJSON', database.constructor.name, code, clock)
-    return new DbIndex(database, code, clock, { name })
+    return new DbIndex(database, name, code, clock)
   }
 
   /**
@@ -38754,7 +38773,7 @@ class DbIndex {
    * @memberof DbIndex
    * @instance
    */
-  async query (query, update = true) {
+  async query (query = {}, update = true) {
     // const callId = Math.random().toString(36).substring(2, 7)
     // todo pass a root to query a snapshot
     // console.time(callId + '.updateIndex')
@@ -38781,7 +38800,12 @@ class DbIndex {
   async updateIndex (blocks) {
     // todo this could enqueue the request and give fresh ones to all second comers -- right now it gives out stale promises while working
     // what would it do in a world where all indexes provide a database snapshot to query?
-    if (this.updateIndexPromise) return this.updateIndexPromise
+    if (this.updateIndexPromise) {
+      return this.updateIndexPromise.then(() => {
+        this.updateIndexPromise = null;
+        return this.updateIndex(blocks)
+      })
+    }
     this.updateIndexPromise = this.innerUpdateIndex(blocks);
     this.updateIndexPromise.finally(() => { this.updateIndexPromise = null; });
     return this.updateIndexPromise
@@ -38802,7 +38826,7 @@ class DbIndex {
       this.dbHead = result.clock;
       return
     }
-    await doTransaction('updateIndex', inBlocks, async (blocks) => {
+    const didT = await doTransaction('updateIndex', inBlocks, async (blocks) => {
       let oldIndexEntries = [];
       let removeByIdIndexEntries = [];
       await loadIndex(blocks, this.indexById, idIndexOpts);
@@ -38824,6 +38848,7 @@ class DbIndex {
     this.database.notifyExternal('dbIndex');
     // console.timeEnd(callTag + '.doTransactionupdateIndex')
     // console.log(`updateIndex ${callTag} <`, this.instanceId, this.dbHead?.toString(), this.indexByKey.cid?.toString(), this.indexById.cid?.toString())
+    return didT
   }
 }
 
@@ -38866,7 +38891,11 @@ async function bulkIndex (blocks, inIndex, indexEntries, opts) {
 async function loadIndex (blocks, index, indexOpts) {
   if (!index.root) {
     const cid = index.cid;
-    if (!cid) return
+    if (!cid) {
+      // console.log('no cid', index)
+      // throw new Error('cannot load index')
+      return null
+    }
     const { getBlock } = makeGetBlock(blocks);
     index.root = await load({ cid, get: getBlock, ...indexOpts });
   }
@@ -38893,7 +38922,7 @@ async function doIndexQuery (blocks, indexByKey, query = {}) {
   }
 }
 
-const parseCID = cid => typeof cid === 'string' ? CID$1.parse(cid) : cid;
+const parseCID = cid => (typeof cid === 'string' ? CID$1.parse(cid) : cid);
 
 class Fireproof {
   /**
@@ -38924,7 +38953,11 @@ class Fireproof {
   static fromJSON (json, database) {
     database.hydrate({ clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key });
     if (json.indexes) {
-      for (const { name, code, clock: { byId, byKey, db } } of json.indexes) {
+      for (const {
+        name,
+        code,
+        clock: { byId, byKey, db }
+      } of json.indexes) {
         DbIndex.fromJSON(database, {
           clock: {
             byId: byId ? parseCID(byId) : null,
@@ -38951,14 +38984,14 @@ class Fireproof {
       });
     }
     const snappedDb = this.fromJSON(definition, withBlocks)
-    ;([...database.indexes.values()]).forEach(index => {
+    ;[...database.indexes.values()].forEach(index => {
       snappedDb.indexes.get(index.mapFnString).mapFn = index.mapFn;
     });
     return snappedDb
   }
 
   static async zoom (database, clock) {
-([...database.indexes.values()]).forEach(index => {
+[...database.indexes.values()].forEach(index => {
       index.indexById = { root: null, cid: null };
       index.indexByKey = { root: null, cid: null };
       index.dbHead = null;
@@ -38967,7 +39000,42 @@ class Fireproof {
     await database.notifyReset(); // hmm... indexes should listen to this? might be more complex than worth it. so far this is the only caller
     return database
   }
+
+  // get all the cids
+  // tell valet to make a file
+  static async makeCar (database, key) {
+    const allCIDs = await database.allCIDs();
+    const blocks = database.blocks;
+
+    const rootCid = CID$1.parse(allCIDs[allCIDs.length - 1]);
+    if (typeof key === 'undefined') {
+      key = blocks.valet?.getKeyMaterial();
+    }
+    if (key) {
+      return blocksToEncryptedCarBlock(
+        rootCid,
+        {
+          entries: () => allCIDs.map(cid => ({ cid })),
+          get: async cid => await blocks.get(cid)
+        },
+        key
+      )
+    } else {
+      const carBlocks = await Promise.all(
+        allCIDs.map(async c => {
+          const b = await blocks.get(c);
+          // console.log('block', b)
+          if (typeof b.cid === 'string') { b.cid = CID$1.parse(b.cid); }
+          // if (b.bytes.constructor.name === 'Buffer') console.log('conver vbuff')
+          return b
+        })
+      );
+      return blocksToCarBlock(rootCid, {
+        entries: () => carBlocks
+      })
+    }
+  }
 }
 
-export { Fireproof, DbIndex as Index, Listener };
+export { Database, Fireproof, DbIndex as Index, Listener };
 //# sourceMappingURL=fireproof.mjs.map