s3db.js 7.3.5 → 7.3.8

package/dist/s3db.es.js

@@ -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;
@@ -8950,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;
     }
@@ -9019,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;
                 }
@@ -9080,6 +9098,9 @@ class BigqueryReplicator extends base_replicator_class_default {
         }
       }
       const success = errors.length === 0;
+      if (errors.length > 0) {
+        console.warn(`[BigqueryReplicator] Replication completed with errors for ${resourceName}:`, errors);
+      }
       this.emit("replicated", {
         replicator: this.name,
         resourceName,
@@ -9098,6 +9119,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,
@@ -9118,8 +9142,17 @@ 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 });
+      }
+    }
+    if (errors.length > 0) {
+      console.warn(`[BigqueryReplicator] Batch replication completed with ${errors.length} error(s) for ${resourceName}:`, errors);
     }
     return {
       success: errors.length === 0,
@@ -9135,6 +9168,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;
   }
@@ -9222,6 +9258,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
@@ -9345,6 +9384,9 @@ class PostgresReplicator extends base_replicator_class_default {
         }
       }
       const success = errors.length === 0;
+      if (errors.length > 0) {
+        console.warn(`[PostgresReplicator] Replication completed with errors for ${resourceName}:`, errors);
+      }
       this.emit("replicated", {
         replicator: this.name,
         resourceName,
@@ -9363,6 +9405,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,
@@ -9383,8 +9428,17 @@ 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 });
+      }
+    }
+    if (errors.length > 0) {
+      console.warn(`[PostgresReplicator] Batch replication completed with ${errors.length} error(s) for ${resourceName}:`, errors);
     }
     return {
       success: errors.length === 0,
@@ -9399,6 +9453,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;
   }
@@ -13133,7 +13190,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.7" : "latest");
       return ok ? version : "latest";
     })();
     this.resources = {};
@@ -13637,9 +13694,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;
@@ -13652,15 +13708,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;
@@ -13668,10 +13723,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() {
@@ -13685,8 +13736,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) {
@@ -13705,7 +13756,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;
     }
   }
@@ -13724,18 +13779,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;
   }
@@ -13744,13 +13858,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;
     }
@@ -13763,9 +13889,11 @@ 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 (typeof entry === "function") return resource;
@@ -13773,8 +13901,7 @@ class S3dbReplicator extends base_replicator_class_default {
     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) {
@@ -13796,8 +13923,17 @@ 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 });
+      }
+    }
+    if (errors.length > 0) {
+      console.warn(`[S3dbReplicator] Batch replication completed with ${errors.length} error(s) for ${resourceName}:`, errors);
     }
     this.emit("batch_replicated", {
       replicator: this.name,
@@ -13815,18 +13951,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();
@@ -13858,7 +13996,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;
         }
       }
@@ -13985,6 +14123,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
@@ -14036,6 +14177,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,
@@ -14088,6 +14232,9 @@ class SqsReplicator extends base_replicator_class_default {
           }
         }
       }
+      if (errors.length > 0) {
+        console.warn(`[SqsReplicator] Batch replication completed with ${errors.length} error(s) for ${resource}:`, errors);
+      }
       this.emit("batch_replicated", {
         replicator: this.name,
         resource,
@@ -14108,6 +14255,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,
@@ -14129,6 +14279,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
@@ -14225,25 +14378,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 });
       }
     });
@@ -14259,13 +14424,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,
@@ -14282,7 +14451,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);
@@ -14325,21 +14502,28 @@ class ReplicatorPlugin extends plugin_class_default {
   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];
@@ -14354,7 +14538,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) {
@@ -14367,8 +14563,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
         );
@@ -14377,11 +14573,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,
@@ -14406,11 +14608,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,
@@ -14432,18 +14637,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);
@@ -14465,9 +14676,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 });
     }
   }
@@ -14573,14 +14788,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);
@@ -14589,7 +14813,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
+      });
     }
   }
 }