@fireproof/core 0.19.11-dev-dryrun6 → 0.19.99-dev-100

package/deno.json

@@ -15,6 +15,8 @@
     "ipfs-unixfs-exporter": "npm:ipfs-unixfs-exporter@^13.6.1",
     "memfs": "npm:memfs@^4.12.0",
     "p-limit": "npm:p-limit@^6.1.0",
-    "react": "npm:react@^18.3.1"
+    "react": "npm:react@^18.3.1",
+    "p-map": "npm:p-map@^7.0.2",
+    "p-retry": "npm:p-retry@^6.2.0"
   }
 }

package/index.cjs

@@ -1149,7 +1149,6 @@ var UnixFSFileBuilder = class {
 };
 
 // src/blockstore/store.ts
-var import_p_limit2 = __toESM(require("p-limit"), 1);
 var import_dag_json2 = require("@ipld/dag-json");
 var import_cement10 = require("@adviser/cement");
 
@@ -2564,6 +2563,8 @@ async function encodeEventsWithParents(sthis, events, parents) {
 }
 
 // src/blockstore/store.ts
+var import_p_retry = __toESM(require("p-retry"), 1);
+var import_p_map = __toESM(require("p-map"), 1);
 function guardVersion(url) {
   if (!url.hasParam("version")) {
     return import_cement10.Result.Err(`missing version: ${url.toString()}`);
@@ -2823,72 +2824,82 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
   async _doProcess() {
     if (!this.loader.remoteCarStore) return;
-    const rmlp = (async () => {
-      const operations = [...this.walState.operations];
-      const fileOperations = [...this.walState.fileOperations];
-      const uploads = [];
-      const noLoaderOps = [...this.walState.noLoaderOps];
-      const limit = (0, import_p_limit2.default)(3);
-      if (operations.length + fileOperations.length + noLoaderOps.length === 0) return;
-      for (const dbMeta of noLoaderOps) {
-        const uploadP = limit(async () => {
-          for (const cid of dbMeta.cars) {
-            const car = await (await this.loader.carStore()).load(cid);
-            if (!car) {
-              if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars))
-                throw this.logger.Error().Ref("cid", cid).Msg("missing local car").AsError();
-            } else {
-              await throwFalsy(this.loader.remoteCarStore).save(car);
+    const operations = [...this.walState.operations];
+    const noLoaderOps = [...this.walState.noLoaderOps];
+    const fileOperations = [...this.walState.fileOperations];
+    if (operations.length + noLoaderOps.length + fileOperations.length === 0) return;
+    const concurrencyLimit = 3;
+    const retryableUpload = (fn, description) => (0, import_p_retry.default)(fn, {
+      retries: 5,
+      onFailedAttempt: (error) => {
+        this.logger.Warn().Msg(`Attempt ${error.attemptNumber} failed for ${description}. There are ${error.retriesLeft} retries left.`);
+      }
+    });
+    try {
+      await (0, import_p_map.default)(
+        noLoaderOps,
+        async (dbMeta) => {
+          await retryableUpload(async () => {
+            for (const cid of dbMeta.cars) {
+              const car = await (await this.loader.carStore()).load(cid);
+              if (!car) {
+                if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars)) {
+                  throw this.logger.Error().Ref("cid", cid).Msg("missing local car").AsError();
+                }
+              } else {
+                await throwFalsy(this.loader.remoteCarStore).save(car);
+              }
             }
             this.walState.noLoaderOps = this.walState.noLoaderOps.filter((op) => op !== dbMeta);
-          }
-        });
-        uploads.push(uploadP);
-      }
-      for (const dbMeta of operations) {
-        const uploadP = limit(async () => {
-          for (const cid of dbMeta.cars) {
-            const car = await (await this.loader.carStore()).load(cid).catch(() => null);
-            if (!car) {
-              if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars))
-                throw this.logger.Error().Ref("cid", cid).Msg(`missing local car`).AsError();
-            } else {
-              await throwFalsy(this.loader.remoteCarStore).save(car);
+          }, `noLoaderOp with dbMeta.cars=${dbMeta.cars.toString()}`);
+        },
+        { concurrency: concurrencyLimit }
+      );
+      await (0, import_p_map.default)(
+        operations,
+        async (dbMeta) => {
+          await retryableUpload(async () => {
+            for (const cid of dbMeta.cars) {
+              const car = await (await this.loader.carStore()).load(cid);
+              if (!car) {
+                if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars)) {
+                  throw this.logger.Error().Ref("cid", cid).Msg(`missing local car`).AsError();
+                }
+              } else {
+                await throwFalsy(this.loader.remoteCarStore).save(car);
+              }
             }
-          }
-          this.walState.operations = this.walState.operations.filter((op) => op !== dbMeta);
-        });
-        uploads.push(uploadP);
-      }
-      if (fileOperations.length) {
-        const dbLoader = this.loader;
-        for (const { cid: fileCid, public: publicFile } of fileOperations) {
-          const uploadP = limit(async () => {
-            const fileBlock = await (await dbLoader.fileStore()).load(fileCid);
-            await dbLoader.remoteFileStore?.save(fileBlock, { public: publicFile });
+            this.walState.operations = this.walState.operations.filter((op) => op !== dbMeta);
+          }, `operation with dbMeta.cars=${dbMeta.cars.toString()}`);
+        },
+        { concurrency: concurrencyLimit }
+      );
+      await (0, import_p_map.default)(
+        fileOperations,
+        async ({ cid: fileCid, public: publicFile }) => {
+          await retryableUpload(async () => {
+            const fileBlock = await (await this.loader.fileStore()).load(fileCid);
+            if (!fileBlock) {
+              throw this.logger.Error().Ref("cid", fileCid).Msg("missing file block").AsError();
+            }
+            await this.loader.remoteFileStore?.save(fileBlock, { public: publicFile });
             this.walState.fileOperations = this.walState.fileOperations.filter((op) => op.cid !== fileCid);
-          });
-          uploads.push(uploadP);
-        }
-      }
-      try {
-        const res = await Promise.allSettled(uploads);
-        const errors = res.filter((r) => r.status === "rejected");
-        if (errors.length) {
-          throw this.logger.Error().Any("errors", errors).Msg("error uploading").AsError();
-        }
-        if (operations.length) {
-          const lastOp = operations[operations.length - 1];
-          await this.loader.remoteMetaStore?.save(lastOp).catch((e) => {
-            this.walState.operations.push(lastOp);
-            throw this.logger.Error().Any("error", e).Msg("error saving remote meta").AsError();
-          });
-        }
-      } finally {
-        await this.save(this.walState);
+          }, `fileOperation with cid=${fileCid.toString()}`);
+        },
+        { concurrency: concurrencyLimit }
+      );
+      if (operations.length) {
+        const lastOp = operations[operations.length - 1];
+        await retryableUpload(async () => {
+          await this.loader.remoteMetaStore?.save(lastOp);
+        }, `remoteMetaStore save with dbMeta.cars=${lastOp.cars.toString()}`);
       }
-    })();
-    await rmlp;
+    } catch (error) {
+      this.logger.Error().Any("error", error).Msg("Processing failed");
+      return;
+    } finally {
+      await this.save(this.walState);
+    }
   }
   async load() {
     this.logger.Debug().Msg("loading");
@@ -4324,6 +4335,6 @@ init_utils();
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.11-dev-dryrun6": "xxxx"
+  "0.19.99-dev-100": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map