s3db.js 7.3.4 → 7.3.6

package/dist/s3db.es.js

@@ -3,8 +3,8 @@ import zlib from 'node:zlib';
 import { PromisePool } from '@supercharge/promise-pool';
 import { ReadableStream } from 'node:stream/web';
 import { mkdir, writeFile, readFile, stat, unlink, readdir, rm } from 'fs/promises';
-import { chunk, merge, isString as isString$1, isEmpty, invert, uniq, cloneDeep, get, set, isObject as isObject$1, isFunction as isFunction$1 } from 'lodash-es';
 import { createHash } from 'crypto';
+import { chunk, merge, isString as isString$1, isEmpty, invert, uniq, cloneDeep, get, set, isObject as isObject$1, isFunction as isFunction$1 } from 'lodash-es';
 import jsonStableStringify from 'json-stable-stringify';
 import { S3Client, PutObjectCommand, GetObjectCommand, HeadObjectCommand, CopyObjectCommand, DeleteObjectCommand, DeleteObjectsCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
 import { flatten, unflatten } from 'flat';
@@ -7079,6 +7079,12 @@ class FilesystemCache extends Cache {
   }
   async _clear(prefix) {
     try {
+      if (!await this._fileExists(this.directory)) {
+        if (this.enableStats) {
+          this.stats.clears++;
+        }
+        return true;
+      }
       const files = await readdir(this.directory);
       const cacheFiles = files.filter((file) => {
         if (!file.startsWith(this.prefix)) return false;
@@ -8349,7 +8355,7 @@ class MetricsPlugin extends plugin_class_default {
   }
   async setup(database) {
     this.database = database;
-    if (process.env.NODE_ENV === "test") return;
+    if (typeof process !== "undefined" && process.env.NODE_ENV === "test") return;
     const [ok, err] = await try_fn_default(async () => {
       const [ok1, err1, metricsResource] = await try_fn_default(() => database.createResource({
         name: "metrics",
@@ -8399,7 +8405,7 @@ class MetricsPlugin extends plugin_class_default {
       this.performanceResource = database.resources.performance_logs;
     }
     this.installMetricsHooks();
-    if (process.env.NODE_ENV !== "test") {
+    if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
       this.startFlushTimer();
     }
   }
@@ -8410,7 +8416,7 @@ class MetricsPlugin extends plugin_class_default {
       clearInterval(this.flushTimer);
       this.flushTimer = null;
     }
-    if (process.env.NODE_ENV !== "test") {
+    if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
       await this.flushMetrics();
     }
   }
@@ -8589,10 +8595,18 @@ class MetricsPlugin extends plugin_class_default {
   async flushMetrics() {
     if (!this.metricsResource) return;
     const [ok, err] = await try_fn_default(async () => {
-      const metadata = process.env.NODE_ENV === "test" ? {} : { global: "true" };
-      const perfMetadata = process.env.NODE_ENV === "test" ? {} : { perf: "true" };
-      const errorMetadata = process.env.NODE_ENV === "test" ? {} : { error: "true" };
-      const resourceMetadata = process.env.NODE_ENV === "test" ? {} : { resource: "true" };
+      let metadata, perfMetadata, errorMetadata, resourceMetadata;
+      if (typeof process !== "undefined" && process.env.NODE_ENV === "test") {
+        metadata = {};
+        perfMetadata = {};
+        errorMetadata = {};
+        resourceMetadata = {};
+      } else {
+        metadata = { global: "true" };
+        perfMetadata = { perf: "true" };
+        errorMetadata = { error: "true" };
+        resourceMetadata = { resource: "true" };
+      }
       for (const [operation, data] of Object.entries(this.metrics.operations)) {
         if (data.count > 0) {
           await this.metricsResource.insert({
@@ -8942,6 +8956,9 @@ class BigqueryReplicator extends base_replicator_class_default {
     await super.initialize(database);
     const [ok, err, sdk] = await try_fn_default(() => import('@google-cloud/bigquery'));
     if (!ok) {
+      if (this.config.verbose) {
+        console.warn(`[BigqueryReplicator] Failed to import BigQuery SDK: ${err.message}`);
+      }
       this.emit("initialization_error", { replicator: this.name, error: err.message });
       throw err;
     }
@@ -9011,19 +9028,28 @@ class BigqueryReplicator extends base_replicator_class_default {
             const maxRetries = 2;
             let lastError = null;
             for (let attempt = 1; attempt <= maxRetries; attempt++) {
-              try {
+              const [ok2, error] = await try_fn_default(async () => {
                 const [updateJob] = await this.bigqueryClient.createQueryJob({
                   query,
                   params,
                   location: this.location
                 });
                 await updateJob.getQueryResults();
-                job = [updateJob];
+                return [updateJob];
+              });
+              if (ok2) {
+                job = ok2;
                 break;
-              } catch (error) {
+              } else {
                 lastError = error;
+                if (this.config.verbose) {
+                  console.warn(`[BigqueryReplicator] Update attempt ${attempt} failed: ${error.message}`);
+                }
                 if (error?.message?.includes("streaming buffer") && attempt < maxRetries) {
                   const delaySeconds = 30;
+                  if (this.config.verbose) {
+                    console.warn(`[BigqueryReplicator] Retrying in ${delaySeconds} seconds due to streaming buffer issue`);
+                  }
                   await new Promise((resolve) => setTimeout(resolve, delaySeconds * 1e3));
                   continue;
                 }
@@ -9090,6 +9116,9 @@ class BigqueryReplicator extends base_replicator_class_default {
       };
     });
     if (ok) return result;
+    if (this.config.verbose) {
+      console.warn(`[BigqueryReplicator] Replication failed for ${resourceName}: ${err.message}`);
+    }
     this.emit("replicator_error", {
       replicator: this.name,
       resourceName,
@@ -9110,8 +9139,14 @@ class BigqueryReplicator extends base_replicator_class_default {
         record.id,
         record.beforeData
       ));
-      if (ok) results.push(res);
-      else errors.push({ id: record.id, error: err.message });
+      if (ok) {
+        results.push(res);
+      } else {
+        if (this.config.verbose) {
+          console.warn(`[BigqueryReplicator] Batch replication failed for record ${record.id}: ${err.message}`);
+        }
+        errors.push({ id: record.id, error: err.message });
+      }
     }
     return {
       success: errors.length === 0,
@@ -9127,6 +9162,9 @@ class BigqueryReplicator extends base_replicator_class_default {
       return true;
     });
     if (ok) return true;
+    if (this.config.verbose) {
+      console.warn(`[BigqueryReplicator] Connection test failed: ${err.message}`);
+    }
     this.emit("connection_error", { replicator: this.name, error: err.message });
     return false;
   }
@@ -9214,6 +9252,9 @@ class PostgresReplicator extends base_replicator_class_default {
     await super.initialize(database);
     const [ok, err, sdk] = await try_fn_default(() => import('pg'));
     if (!ok) {
+      if (this.config.verbose) {
+        console.warn(`[PostgresReplicator] Failed to import pg SDK: ${err.message}`);
+      }
       this.emit("initialization_error", {
         replicator: this.name,
         error: err.message
@@ -9355,6 +9396,9 @@ class PostgresReplicator extends base_replicator_class_default {
       };
     });
     if (ok) return result;
+    if (this.config.verbose) {
+      console.warn(`[PostgresReplicator] Replication failed for ${resourceName}: ${err.message}`);
+    }
     this.emit("replicator_error", {
       replicator: this.name,
       resourceName,
@@ -9375,8 +9419,14 @@ class PostgresReplicator extends base_replicator_class_default {
         record.id,
         record.beforeData
       ));
-      if (ok) results.push(res);
-      else errors.push({ id: record.id, error: err.message });
+      if (ok) {
+        results.push(res);
+      } else {
+        if (this.config.verbose) {
+          console.warn(`[PostgresReplicator] Batch replication failed for record ${record.id}: ${err.message}`);
+        }
+        errors.push({ id: record.id, error: err.message });
+      }
     }
     return {
       success: errors.length === 0,
@@ -9391,6 +9441,9 @@ class PostgresReplicator extends base_replicator_class_default {
       return true;
     });
     if (ok) return true;
+    if (this.config.verbose) {
+      console.warn(`[PostgresReplicator] Connection test failed: ${err.message}`);
+    }
     this.emit("connection_error", { replicator: this.name, error: err.message });
     return false;
   }
@@ -13125,7 +13178,7 @@ class Database extends EventEmitter {
     super();
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = try_fn_default(() => true ? "7.3.4" : "latest");
+      const [ok, err, version] = try_fn_default(() => true ? "7.3.6" : "latest");
       return ok ? version : "latest";
     })();
     this.resources = {};
@@ -13168,14 +13221,16 @@ class Database extends EventEmitter {
     this.keyPrefix = this.client.keyPrefix;
     if (!this._exitListenerRegistered) {
       this._exitListenerRegistered = true;
-      process.on("exit", async () => {
-        if (this.isConnected()) {
-          try {
-            await this.disconnect();
-          } catch (err) {
+      if (typeof process !== "undefined") {
+        process.on("exit", async () => {
+          if (this.isConnected()) {
+            try {
+              await this.disconnect();
+            } catch (err) {
+            }
           }
-        }
-      });
+        });
+      }
     }
   }
   async connect() {
@@ -13627,9 +13682,8 @@ class S3dbReplicator extends base_replicator_class_default {
       const map = {};
       for (const res of resources) {
         if (typeof res === "string") map[normalizeResourceName$1(res)] = res;
-        else if (Array.isArray(res) && typeof res[0] === "string") map[normalizeResourceName$1(res[0])] = res;
         else if (typeof res === "object" && res.resource) {
-          map[normalizeResourceName$1(res.resource)] = { ...res };
+          map[normalizeResourceName$1(res.resource)] = res;
         }
       }
       return map;
@@ -13642,15 +13696,14 @@ class S3dbReplicator extends base_replicator_class_default {
         else if (Array.isArray(dest)) {
           map[normSrc] = dest.map((item) => {
             if (typeof item === "string") return item;
-            if (typeof item === "function") return item;
             if (typeof item === "object" && item.resource) {
-              return { ...item };
+              return item;
             }
             return item;
           });
         } else if (typeof dest === "function") map[normSrc] = dest;
         else if (typeof dest === "object" && dest.resource) {
-          map[normSrc] = { ...dest };
+          map[normSrc] = dest;
         }
       }
       return map;
@@ -13658,10 +13711,6 @@ class S3dbReplicator extends base_replicator_class_default {
     if (typeof resources === "function") {
       return resources;
     }
-    if (typeof resources === "string") {
-      const map = { [normalizeResourceName$1(resources)]: resources };
-      return map;
-    }
     return {};
   }
   validateConfig() {
@@ -13675,8 +13724,8 @@ class S3dbReplicator extends base_replicator_class_default {
     return { isValid: errors.length === 0, errors };
   }
   async initialize(database) {
-    try {
-      await super.initialize(database);
+    await super.initialize(database);
+    const [ok, err] = await try_fn_default(async () => {
       if (this.client) {
         this.targetDatabase = this.client;
       } else if (this.connectionString) {
@@ -13695,7 +13744,11 @@ class S3dbReplicator extends base_replicator_class_default {
         replicator: this.name,
         target: this.connectionString || "client-provided"
       });
-    } catch (err) {
+    });
+    if (!ok) {
+      if (this.config.verbose) {
+        console.warn(`[S3dbReplicator] Initialization failed: ${err.message}`);
+      }
       throw err;
     }
   }
@@ -13714,18 +13767,77 @@ class S3dbReplicator extends base_replicator_class_default {
       id = recordId;
     }
     const normResource = normalizeResourceName$1(resource);
-    const destResource = this._resolveDestResource(normResource, payload);
-    const destResourceObj = this._getDestResourceObj(destResource);
-    const transformedData = this._applyTransformer(normResource, payload);
+    const entry = this.resourcesMap[normResource];
+    if (!entry) {
+      throw new Error(`[S3dbReplicator] Resource not configured: ${resource}`);
+    }
+    if (Array.isArray(entry)) {
+      const results = [];
+      for (const destConfig of entry) {
+        const [ok, error, result] = await try_fn_default(async () => {
+          return await this._replicateToSingleDestination(destConfig, normResource, op, payload, id);
+        });
+        if (!ok) {
+          if (this.config && this.config.verbose) {
+            console.warn(`[S3dbReplicator] Failed to replicate to destination ${JSON.stringify(destConfig)}: ${error.message}`);
+          }
+          throw error;
+        }
+        results.push(result);
+      }
+      return results;
+    } else {
+      const [ok, error, result] = await try_fn_default(async () => {
+        return await this._replicateToSingleDestination(entry, normResource, op, payload, id);
+      });
+      if (!ok) {
+        if (this.config && this.config.verbose) {
+          console.warn(`[S3dbReplicator] Failed to replicate to destination ${JSON.stringify(entry)}: ${error.message}`);
+        }
+        throw error;
+      }
+      return result;
+    }
+  }
+  async _replicateToSingleDestination(destConfig, sourceResource, operation, data, recordId) {
+    let destResourceName;
+    if (typeof destConfig === "string") {
+      destResourceName = destConfig;
+    } else if (typeof destConfig === "object" && destConfig.resource) {
+      destResourceName = destConfig.resource;
+    } else {
+      destResourceName = sourceResource;
+    }
+    if (typeof destConfig === "object" && destConfig.actions && Array.isArray(destConfig.actions)) {
+      if (!destConfig.actions.includes(operation)) {
+        return { skipped: true, reason: "action_not_supported", action: operation, destination: destResourceName };
+      }
+    }
+    const destResourceObj = this._getDestResourceObj(destResourceName);
+    let transformedData;
+    if (typeof destConfig === "object" && destConfig.transform && typeof destConfig.transform === "function") {
+      transformedData = destConfig.transform(data);
+      if (transformedData && data && data.id && !transformedData.id) {
+        transformedData.id = data.id;
+      }
+    } else if (typeof destConfig === "object" && destConfig.transformer && typeof destConfig.transformer === "function") {
+      transformedData = destConfig.transformer(data);
+      if (transformedData && data && data.id && !transformedData.id) {
+        transformedData.id = data.id;
+      }
+    } else {
+      transformedData = data;
+    }
+    if (!transformedData && data) transformedData = data;
     let result;
-    if (op === "insert") {
+    if (operation === "insert") {
       result = await destResourceObj.insert(transformedData);
-    } else if (op === "update") {
-      result = await destResourceObj.update(id, transformedData);
-    } else if (op === "delete") {
-      result = await destResourceObj.delete(id);
+    } else if (operation === "update") {
+      result = await destResourceObj.update(recordId, transformedData);
+    } else if (operation === "delete") {
+      result = await destResourceObj.delete(recordId);
     } else {
-      throw new Error(`Invalid operation: ${op}. Supported operations are: insert, update, delete`);
+      throw new Error(`Invalid operation: ${operation}. Supported operations are: insert, update, delete`);
     }
     return result;
   }
@@ -13734,13 +13846,25 @@ class S3dbReplicator extends base_replicator_class_default {
     const entry = this.resourcesMap[normResource];
     let result;
     if (!entry) return data;
-    if (Array.isArray(entry) && typeof entry[1] === "function") {
-      result = entry[1](data);
+    if (Array.isArray(entry)) {
+      for (const item of entry) {
+        if (typeof item === "object" && item.transform && typeof item.transform === "function") {
+          result = item.transform(data);
+          break;
+        } else if (typeof item === "object" && item.transformer && typeof item.transformer === "function") {
+          result = item.transformer(data);
+          break;
+        }
+      }
+      if (!result) result = data;
+    } else if (typeof entry === "object") {
+      if (typeof entry.transform === "function") {
+        result = entry.transform(data);
+      } else if (typeof entry.transformer === "function") {
+        result = entry.transformer(data);
+      }
     } else if (typeof entry === "function") {
       result = entry(data);
-    } else if (typeof entry === "object") {
-      if (typeof entry.transform === "function") result = entry.transform(data);
-      else if (typeof entry.transformer === "function") result = entry.transformer(data);
     } else {
       result = data;
     }
@@ -13753,18 +13877,19 @@ class S3dbReplicator extends base_replicator_class_default {
     const entry = this.resourcesMap[normResource];
     if (!entry) return resource;
     if (Array.isArray(entry)) {
-      if (typeof entry[0] === "string") return entry[0];
-      if (typeof entry[0] === "object" && entry[0].resource) return entry[0].resource;
-      if (typeof entry[0] === "function") return resource;
+      for (const item of entry) {
+        if (typeof item === "string") return item;
+        if (typeof item === "object" && item.resource) return item.resource;
+      }
+      return resource;
     }
     if (typeof entry === "string") return entry;
-    if (resource && !targetResourceName) targetResourceName = resource;
+    if (typeof entry === "function") return resource;
     if (typeof entry === "object" && entry.resource) return entry.resource;
     return resource;
   }
   _getDestResourceObj(resource) {
-    if (!this.client || !this.client.resources) return null;
-    const available = Object.keys(this.client.resources);
+    const available = Object.keys(this.client.resources || {});
     const norm = normalizeResourceName$1(resource);
     const found = available.find((r) => normalizeResourceName$1(r) === norm);
     if (!found) {
@@ -13786,8 +13911,14 @@ class S3dbReplicator extends base_replicator_class_default {
         data: record.data,
         beforeData: record.beforeData
       }));
-      if (ok) results.push(result);
-      else errors.push({ id: record.id, error: err.message });
+      if (ok) {
+        results.push(result);
+      } else {
+        if (this.config.verbose) {
+          console.warn(`[S3dbReplicator] Batch replication failed for record ${record.id}: ${err.message}`);
+        }
+        errors.push({ id: record.id, error: err.message });
+      }
     }
     this.emit("batch_replicated", {
       replicator: this.name,
@@ -13805,18 +13936,20 @@ class S3dbReplicator extends base_replicator_class_default {
   }
   async testConnection() {
     const [ok, err] = await try_fn_default(async () => {
-      if (!this.targetDatabase) {
-        await this.initialize(this.database);
+      if (!this.targetDatabase) throw new Error("No target database configured");
+      if (typeof this.targetDatabase.connect === "function") {
+        await this.targetDatabase.connect();
       }
-      await this.targetDatabase.listResources();
       return true;
     });
-    if (ok) return true;
-    this.emit("connection_error", {
-      replicator: this.name,
-      error: err.message
-    });
-    return false;
+    if (!ok) {
+      if (this.config.verbose) {
+        console.warn(`[S3dbReplicator] Connection test failed: ${err.message}`);
+      }
+      this.emit("connection_error", { replicator: this.name, error: err.message });
+      return false;
+    }
+    return true;
   }
   async getStatus() {
     const baseStatus = await super.getStatus();
@@ -13848,7 +13981,7 @@ class S3dbReplicator extends base_replicator_class_default {
           } else {
             return true;
           }
-        } else if (typeof item === "string" || typeof item === "function") {
+        } else if (typeof item === "string") {
           return true;
         }
       }
@@ -13975,6 +14108,9 @@ class SqsReplicator extends base_replicator_class_default {
     if (!this.sqsClient) {
       const [ok, err, sdk] = await try_fn_default(() => import('@aws-sdk/client-sqs'));
       if (!ok) {
+        if (this.config.verbose) {
+          console.warn(`[SqsReplicator] Failed to import SQS SDK: ${err.message}`);
+        }
         this.emit("initialization_error", {
           replicator: this.name,
           error: err.message
@@ -14026,6 +14162,9 @@ class SqsReplicator extends base_replicator_class_default {
       return { success: true, results };
     });
     if (ok) return result;
+    if (this.config.verbose) {
+      console.warn(`[SqsReplicator] Replication failed for ${resource}: ${err.message}`);
+    }
     this.emit("replicator_error", {
       replicator: this.name,
       resource,
@@ -14098,6 +14237,9 @@ class SqsReplicator extends base_replicator_class_default {
     });
     if (ok) return result;
     const errorMessage = err?.message || err || "Unknown error";
+    if (this.config.verbose) {
+      console.warn(`[SqsReplicator] Batch replication failed for ${resource}: ${errorMessage}`);
+    }
     this.emit("batch_replicator_error", {
       replicator: this.name,
       resource,
@@ -14119,6 +14261,9 @@ class SqsReplicator extends base_replicator_class_default {
       return true;
     });
     if (ok) return true;
+    if (this.config.verbose) {
+      console.warn(`[SqsReplicator] Connection test failed: ${err.message}`);
+    }
     this.emit("connection_error", {
       replicator: this.name,
       error: err.message
@@ -14215,25 +14360,37 @@ class ReplicatorPlugin extends plugin_class_default {
       return;
     }
     resource.on("insert", async (data) => {
-      try {
+      const [ok, error] = await try_fn_default(async () => {
         const completeData = { ...data, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
         await plugin.processReplicatorEvent("insert", resource.name, completeData.id, completeData);
-      } catch (error) {
+      });
+      if (!ok) {
+        if (this.config.verbose) {
+          console.warn(`[ReplicatorPlugin] Insert event failed for resource ${resource.name}: ${error.message}`);
+        }
         this.emit("error", { operation: "insert", error: error.message, resource: resource.name });
       }
     });
     resource.on("update", async (data, beforeData) => {
-      try {
+      const [ok, error] = await try_fn_default(async () => {
         const completeData = { ...data, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
         await plugin.processReplicatorEvent("update", resource.name, completeData.id, completeData, beforeData);
-      } catch (error) {
+      });
+      if (!ok) {
+        if (this.config.verbose) {
+          console.warn(`[ReplicatorPlugin] Update event failed for resource ${resource.name}: ${error.message}`);
+        }
         this.emit("error", { operation: "update", error: error.message, resource: resource.name });
       }
     });
     resource.on("delete", async (data) => {
-      try {
+      const [ok, error] = await try_fn_default(async () => {
         await plugin.processReplicatorEvent("delete", resource.name, data.id, data);
-      } catch (error) {
+      });
+      if (!ok) {
+        if (this.config.verbose) {
+          console.warn(`[ReplicatorPlugin] Delete event failed for resource ${resource.name}: ${error.message}`);
+        }
         this.emit("error", { operation: "delete", error: error.message, resource: resource.name });
       }
     });
@@ -14249,13 +14406,17 @@ class ReplicatorPlugin extends plugin_class_default {
   }
   async setup(database) {
     this.database = database;
-    try {
+    const [initOk, initError] = await try_fn_default(async () => {
       await this.initializeReplicators(database);
-    } catch (error) {
-      this.emit("error", { operation: "setup", error: error.message });
-      throw error;
+    });
+    if (!initOk) {
+      if (this.config.verbose) {
+        console.warn(`[ReplicatorPlugin] Replicator initialization failed: ${initError.message}`);
+      }
+      this.emit("error", { operation: "setup", error: initError.message });
+      throw initError;
     }
-    try {
+    const [logOk, logError] = await try_fn_default(async () => {
       if (this.config.replicatorLogResource) {
         const logRes = await database.createResource({
           name: this.config.replicatorLogResource,
@@ -14272,7 +14433,15 @@ class ReplicatorPlugin extends plugin_class_default {
           }
         });
       }
-    } catch (error) {
+    });
+    if (!logOk) {
+      if (this.config.verbose) {
+        console.warn(`[ReplicatorPlugin] Failed to create log resource ${this.config.replicatorLogResource}: ${logError.message}`);
+      }
+      this.emit("replicator_log_resource_creation_error", {
+        resourceName: this.config.replicatorLogResource,
+        error: logError.message
+      });
     }
     await this.uploadMetadataFile(database);
     const originalCreateResource = database.createResource.bind(database);
@@ -14307,49 +14476,36 @@ class ReplicatorPlugin extends plugin_class_default {
   }
   async stop() {
   }
-  filterInternalFields(data) {
-    if (!data || typeof data !== "object") return data;
-    const filtered = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (!key.startsWith("_") && !key.startsWith("$")) {
-        filtered[key] = value;
-      }
-    }
-    return filtered;
-  }
   async uploadMetadataFile(database) {
     if (typeof database.uploadMetadataFile === "function") {
       await database.uploadMetadataFile();
     }
   }
-  async getCompleteData(resource, data) {
-    try {
-      const [ok, err, record] = await try_fn_default(() => resource.get(data.id));
-      if (ok && record) {
-        return record;
-      }
-    } catch (error) {
-    }
-    return data;
-  }
   async retryWithBackoff(operation, maxRetries = 3) {
     let lastError;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        return await operation();
-      } catch (error) {
+      const [ok, error] = await try_fn_default(operation);
+      if (ok) {
+        return ok;
+      } else {
         lastError = error;
+        if (this.config.verbose) {
+          console.warn(`[ReplicatorPlugin] Retry attempt ${attempt}/${maxRetries} failed: ${error.message}`);
+        }
         if (attempt === maxRetries) {
           throw error;
         }
         const delay = Math.pow(2, attempt - 1) * 1e3;
+        if (this.config.verbose) {
+          console.warn(`[ReplicatorPlugin] Waiting ${delay}ms before retry...`);
+        }
         await new Promise((resolve) => setTimeout(resolve, delay));
       }
     }
     throw lastError;
   }
   async logError(replicator, resourceName, operation, recordId, data, error) {
-    try {
+    const [ok, logError] = await try_fn_default(async () => {
       const logResourceName = this.config.replicatorLogResource;
       if (this.database && this.database.resources && this.database.resources[logResourceName]) {
         const logResource = this.database.resources[logResourceName];
@@ -14364,7 +14520,19 @@ class ReplicatorPlugin extends plugin_class_default {
           status: "error"
         });
       }
-    } catch (logError) {
+    });
+    if (!ok) {
+      if (this.config.verbose) {
+        console.warn(`[ReplicatorPlugin] Failed to log error for ${resourceName}: ${logError.message}`);
+      }
+      this.emit("replicator_log_error", {
+        replicator: replicator.name || replicator.id,
+        resourceName,
+        operation,
+        recordId,
+        originalError: error.message,
+        logError: logError.message
+      });
     }
   }
   async processReplicatorEvent(operation, resourceName, recordId, data, beforeData = null) {
@@ -14377,8 +14545,8 @@ class ReplicatorPlugin extends plugin_class_default {
       return;
     }
     const promises = applicableReplicators.map(async (replicator) => {
-      try {
-        const result = await this.retryWithBackoff(
+      const [ok, error, result] = await try_fn_default(async () => {
+        const result2 = await this.retryWithBackoff(
           () => replicator.replicate(resourceName, operation, data, recordId, beforeData),
           this.config.maxRetries
         );
@@ -14387,11 +14555,17 @@ class ReplicatorPlugin extends plugin_class_default {
           resourceName,
           operation,
           recordId,
-          result,
+          result: result2,
           success: true
         });
+        return result2;
+      });
+      if (ok) {
         return result;
-      } catch (error) {
+      } else {
+        if (this.config.verbose) {
+          console.warn(`[ReplicatorPlugin] Replication failed for ${replicator.name || replicator.id} on ${resourceName}: ${error.message}`);
+        }
         this.emit("replicator_error", {
           replicator: replicator.name || replicator.id,
           resourceName,
@@ -14416,11 +14590,14 @@ class ReplicatorPlugin extends plugin_class_default {
       return;
     }
     const promises = applicableReplicators.map(async (replicator) => {
-      try {
+      const [wrapperOk, wrapperError] = await try_fn_default(async () => {
         const [ok, err, result] = await try_fn_default(
           () => replicator.replicate(item.resourceName, item.operation, item.data, item.recordId, item.beforeData)
         );
         if (!ok) {
+          if (this.config.verbose) {
+            console.warn(`[ReplicatorPlugin] Replicator item processing failed for ${replicator.name || replicator.id} on ${item.resourceName}: ${err.message}`);
+          }
           this.emit("replicator_error", {
             replicator: replicator.name || replicator.id,
             resourceName: item.resourceName,
@@ -14442,18 +14619,24 @@ class ReplicatorPlugin extends plugin_class_default {
           success: true
         });
         return { success: true, result };
-      } catch (error) {
+      });
+      if (wrapperOk) {
+        return wrapperOk;
+      } else {
+        if (this.config.verbose) {
+          console.warn(`[ReplicatorPlugin] Wrapper processing failed for ${replicator.name || replicator.id} on ${item.resourceName}: ${wrapperError.message}`);
+        }
         this.emit("replicator_error", {
           replicator: replicator.name || replicator.id,
           resourceName: item.resourceName,
           operation: item.operation,
           recordId: item.recordId,
-          error: error.message
+          error: wrapperError.message
         });
         if (this.config.logErrors && this.database) {
-          await this.logError(replicator, item.resourceName, item.operation, item.recordId, item.data, error);
+          await this.logError(replicator, item.resourceName, item.operation, item.recordId, item.data, wrapperError);
         }
-        return { success: false, error: error.message };
+        return { success: false, error: wrapperError.message };
       }
     });
     return Promise.allSettled(promises);
@@ -14475,9 +14658,13 @@ class ReplicatorPlugin extends plugin_class_default {
       timestamp: typeof item.timestamp === "number" ? item.timestamp : Date.now(),
       createdAt: item.createdAt || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
     };
-    try {
+    const [ok, err] = await try_fn_default(async () => {
       await logRes.insert(logItem);
-    } catch (err) {
+    });
+    if (!ok) {
+      if (this.config.verbose) {
+        console.warn(`[ReplicatorPlugin] Failed to log replicator item: ${err.message}`);
+      }
       this.emit("replicator.log.failed", { error: err, item });
     }
   }
@@ -14583,14 +14770,23 @@ class ReplicatorPlugin extends plugin_class_default {
     this.emit("replicator.sync.completed", { replicatorId, stats: this.stats });
   }
   async cleanup() {
-    try {
+    const [ok, error] = await try_fn_default(async () => {
       if (this.replicators && this.replicators.length > 0) {
         const cleanupPromises = this.replicators.map(async (replicator) => {
-          try {
+          const [replicatorOk, replicatorError] = await try_fn_default(async () => {
             if (replicator && typeof replicator.cleanup === "function") {
               await replicator.cleanup();
             }
-          } catch (error) {
+          });
+          if (!replicatorOk) {
+            if (this.config.verbose) {
+              console.warn(`[ReplicatorPlugin] Failed to cleanup replicator ${replicator.name || replicator.id}: ${replicatorError.message}`);
+            }
+            this.emit("replicator_cleanup_error", {
+              replicator: replicator.name || replicator.id || "unknown",
+              driver: replicator.driver || "unknown",
+              error: replicatorError.message
+            });
           }
         });
         await Promise.allSettled(cleanupPromises);
@@ -14599,7 +14795,14 @@ class ReplicatorPlugin extends plugin_class_default {
       this.database = null;
       this.eventListenersInstalled.clear();
       this.removeAllListeners();
-    } catch (error) {
+    });
+    if (!ok) {
+      if (this.config.verbose) {
+        console.warn(`[ReplicatorPlugin] Failed to cleanup plugin: ${error.message}`);
+      }
+      this.emit("replicator_plugin_cleanup_error", {
+        error: error.message
+      });
     }
   }
 }