s3db.js 7.2.1 → 7.3.1

package/src/plugins/replicator.plugin.js

@@ -126,35 +126,31 @@ function normalizeResourceName(name) {
 export class ReplicatorPlugin extends Plugin {
   constructor(options = {}) {
     super();
-    if (options.verbose) {
-      console.log('[PLUGIN][CONSTRUCTOR] ReplicatorPlugin constructor called');
-    }
-    if (options.verbose) {
-      console.log('[PLUGIN][constructor] New ReplicatorPlugin instance created with config:', options);
-    }
     // Validation for config tests
     if (!options.replicators || !Array.isArray(options.replicators)) {
       throw new Error('ReplicatorPlugin: replicators array is required');
     }
     for (const rep of options.replicators) {
       if (!rep.driver) throw new Error('ReplicatorPlugin: each replicator must have a driver');
+      if (!rep.resources || typeof rep.resources !== 'object') throw new Error('ReplicatorPlugin: each replicator must have resources config');
+      if (Object.keys(rep.resources).length === 0) throw new Error('ReplicatorPlugin: each replicator must have at least one resource configured');
     }
-    // Aceita apenas os parâmetros válidos
+    
     this.config = {
-      verbose: options.verbose ?? false,
-      persistReplicatorLog: options.persistReplicatorLog ?? false,
-      replicatorLogResource: options.replicatorLogResource ?? 'replicator_logs',
       replicators: options.replicators || [],
+      logErrors: options.logErrors !== false,
+      replicatorLogResource: options.replicatorLogResource || 'replicator_log',
+      enabled: options.enabled !== false,
+      batchSize: options.batchSize || 100,
+      maxRetries: options.maxRetries || 3,
+      timeout: options.timeout || 30000,
+      verbose: options.verbose || false,
+      ...options
     };
+    
     this.replicators = [];
-    this.queue = [];
-    this.isProcessing = false;
-    this.stats = {
-      totalOperations: 0,
-      totalErrors: 0,
-      lastError: null,
-    };
-    this._installedListeners = [];
+    this.database = null;
+    this.eventListenersInstalled = new Set();
   }
 
   /**
@@ -176,87 +172,39 @@ export class ReplicatorPlugin extends Plugin {
     return filtered;
   }
 
-  installEventListeners(resource) {
-    const plugin = this;
-    if (plugin.config.verbose) {
-      console.log('[PLUGIN] installEventListeners called for:', resource && resource.name, {
-        hasDatabase: !!resource.database,
-        sameDatabase: resource.database === plugin.database,
-        alreadyInstalled: resource._replicatorListenersInstalled,
-        resourceObj: resource,
-        resourceObjId: resource && resource.id,
-        resourceObjType: typeof resource,
-        resourceObjIs: resource && Object.is(resource, plugin.database.resources && plugin.database.resources[resource.name]),
-        resourceObjEq: resource === (plugin.database.resources && plugin.database.resources[resource.name])
-      });
-    }
-    // Only install listeners on resources belonging to the source database
-    if (!resource || resource.name === plugin.config.replicatorLogResource || !resource.database || resource.database !== plugin.database) return;
-    if (resource._replicatorListenersInstalled) return;
-    resource._replicatorListenersInstalled = true;
-    // Track listeners for cleanup
-    this._installedListeners.push(resource);
-    if (plugin.config.verbose) {
-      console.log(`[PLUGIN] installEventListeners INSTALLED for resource: ${resource && resource.name}`);
+  installEventListeners(resource, database, plugin) {
+    if (!resource || this.eventListenersInstalled.has(resource.name) || 
+        resource.name === this.config.replicatorLogResource) {
+      return;
     }
-    // Insert event
+
     resource.on('insert', async (data) => {
-      if (plugin.config.verbose) {
-        console.log('[PLUGIN] Listener INSERT on', resource.name, 'plugin.replicators.length:', plugin.replicators.length, plugin.replicators.map(r => ({id: r.id, driver: r.driver})));
-      }
       try {
-        const completeData = await plugin.getCompleteData(resource, data);
-        if (plugin.config.verbose) {
-          console.log(`[PLUGIN] Listener INSERT completeData for ${resource.name} id=${data && data.id}:`, completeData);
-        }
-        await plugin.processReplicatorEvent(resource.name, 'insert', data.id, completeData, null);
-      } catch (err) {
-        if (plugin.config.verbose) {
-          console.error(`[PLUGIN] Listener INSERT error on ${resource.name} id=${data && data.id}:`, err);
-        }
+        const completeData = { ...data, createdAt: new Date().toISOString() };
+        await plugin.processReplicatorEvent('insert', resource.name, completeData.id, completeData);
+      } catch (error) {
+        this.emit('error', { operation: 'insert', error: error.message, resource: resource.name });
       }
     });
 
-    // Update event
-    resource.on('update', async (data) => {
-      console.log('[PLUGIN][Listener][UPDATE][START] triggered for resource:', resource.name, 'data:', data);
-      const beforeData = data && data.$before;
-      if (plugin.config.verbose) {
-        console.log('[PLUGIN] Listener UPDATE on', resource.name, 'plugin.replicators.length:', plugin.replicators.length, plugin.replicators.map(r => ({id: r.id, driver: r.driver})), 'data:', data, 'beforeData:', beforeData);
-      }
+    resource.on('update', async (data, beforeData) => {
       try {
-        // Always fetch the full, current object for update replication
-        let completeData;
-        const [ok, err, record] = await tryFn(() => resource.get(data.id));
-        if (ok && record) {
-          completeData = record;
-        } else {
-          completeData = data;
-        }
-        await plugin.processReplicatorEvent(resource.name, 'update', data.id, completeData, beforeData);
-      } catch (err) {
-        if (plugin.config.verbose) {
-        console.error(`[PLUGIN] Listener UPDATE erro em ${resource.name} id=${data && data.id}:`, err);
-        }
+        const completeData = { ...data, updatedAt: new Date().toISOString() };
+        await plugin.processReplicatorEvent('update', resource.name, completeData.id, completeData, beforeData);
+      } catch (error) {
+        this.emit('error', { operation: 'update', error: error.message, resource: resource.name });
       }
     });
 
-    // Delete event
-    resource.on('delete', async (data, beforeData) => {
-      if (plugin.config.verbose) {
-        console.log('[PLUGIN] Listener DELETE on', resource.name, 'plugin.replicators.length:', plugin.replicators.length, plugin.replicators.map(r => ({id: r.id, driver: r.driver})));
-      }
+    resource.on('delete', async (data) => {
       try {
-        await plugin.processReplicatorEvent(resource.name, 'delete', data.id, null, beforeData);
-      } catch (err) {
-        if (plugin.config.verbose) {
-        console.error(`[PLUGIN] Listener DELETE erro em ${resource.name} id=${data && data.id}:`, err);
-        }
+        await plugin.processReplicatorEvent('delete', resource.name, data.id, data);
+      } catch (error) {
+        this.emit('error', { operation: 'delete', error: error.message, resource: resource.name });
       }
     });
-    if (plugin.config.verbose) {
-    console.log(`[PLUGIN] Listeners instalados para resource: ${resource && resource.name} (insert: ${resource.listenerCount('insert')}, update: ${resource.listenerCount('update')}, delete: ${resource.listenerCount('delete')})`);
-    }
+
+    this.eventListenersInstalled.add(resource.name);
   }
 
   /**
@@ -271,120 +219,72 @@ export class ReplicatorPlugin extends Plugin {
   }
 
   async setup(database) {
-    console.log('[PLUGIN][SETUP] setup called');
-    if (this.config.verbose) {
-      console.log('[PLUGIN][setup] called with database:', database && database.name);
-    }
     this.database = database;
-    // 1. Sempre crie a resource de log antes de qualquer outra coisa
-    if (this.config.persistReplicatorLog) {
-      let logRes = database.resources[normalizeResourceName(this.config.replicatorLogResource)];
-      if (!logRes) {
-        logRes = await database.createResource({
+
+    try {
+      await this.initializeReplicators(database);
+    } catch (error) {
+      this.emit('error', { operation: 'setup', error: error.message });
+      throw error;
+    }
+
+    try {
+      if (this.config.replicatorLogResource) {
+        const logRes = await database.createResource({
           name: this.config.replicatorLogResource,
-          behavior: 'truncate-data',
+          behavior: 'body-overflow',
           attributes: {
-            id: 'string|required',
-            resource: 'string|required',
-            action: 'string|required',
-            data: 'object',
-            timestamp: 'number|required',
-            createdAt: 'string|required',
-          },
-          partitions: {
-            byDate: { fields: { 'createdAt': 'string|maxlength:10' } }
+            operation: 'string',
+            resourceName: 'string', 
+            recordId: 'string',
+            data: 'string',
+            error: 'string|optional',
+            replicator: 'string',
+            timestamp: 'string',
+            status: 'string'
           }
         });
-        if (this.config.verbose) {
-          console.log('[PLUGIN] Log resource created:', this.config.replicatorLogResource, !!logRes);
-        }
-      }
-      database.resources[normalizeResourceName(this.config.replicatorLogResource)] = logRes;
-      this.replicatorLog = logRes; // Salva referência para uso futuro
-      if (this.config.verbose) {
-        console.log('[PLUGIN] Log resource created and registered:', this.config.replicatorLogResource, !!database.resources[normalizeResourceName(this.config.replicatorLogResource)]);
-      }
-      // Persist the log resource to metadata
-      if (typeof database.uploadMetadataFile === 'function') {
-        await database.uploadMetadataFile();
-        if (this.config.verbose) {
-          console.log('[PLUGIN] uploadMetadataFile called. database.resources keys:', Object.keys(database.resources));
-        }
-      }
-    }
-    // 2. Só depois inicialize replicators e listeners
-    if (this.config.replicators && this.config.replicators.length > 0 && this.replicators.length === 0) {
-      await this.initializeReplicators();
-      console.log('[PLUGIN][SETUP] after initializeReplicators, replicators.length:', this.replicators.length);
-      if (this.config.verbose) {
-        console.log('[PLUGIN][setup] After initializeReplicators, replicators.length:', this.replicators.length, this.replicators.map(r => ({id: r.id, driver: r.driver})));
       }
+    } catch (error) {
+      // Log resource creation failed, continue without it
     }
-    // Only install event listeners after replicators are initialized
-    for (const resourceName in database.resources) {
-      if (normalizeResourceName(resourceName) !== normalizeResourceName(this.config.replicatorLogResource)) {
-        this.installEventListeners(database.resources[resourceName]);
-      }
-    }
-    database.on('connected', () => {
-      for (const resourceName in database.resources) {
-        if (normalizeResourceName(resourceName) !== normalizeResourceName(this.config.replicatorLogResource)) {
-          this.installEventListeners(database.resources[resourceName]);
-        }
-      }
-    });
+
+    await this.uploadMetadataFile(database);
+
     const originalCreateResource = database.createResource.bind(database);
     database.createResource = async (config) => {
-      if (this.config.verbose) {
-        console.log('[PLUGIN] createResource proxy called for:', config && config.name);
-      }
       const resource = await originalCreateResource(config);
-      if (resource && resource.name !== this.config.replicatorLogResource) {
-        this.installEventListeners(resource);
+      if (resource) {
+        this.installEventListeners(resource, database, this);
       }
       return resource;
     };
-    database.on('s3db.resourceCreated', (resourceName) => {
-      const resource = database.resources[resourceName];
-      if (resource && resource.name !== this.config.replicatorLogResource) {
-        this.installEventListeners(resource);
-      }
-    });
-    
-    database.on('s3db.resourceUpdated', (resourceName) => {
+
+    for (const resourceName in database.resources) {
       const resource = database.resources[resourceName];
-      if (resource && resource.name !== this.config.replicatorLogResource) {
-        this.installEventListeners(resource);
-      }
-    });
+      this.installEventListeners(resource, database, this);
+    }
+  }
+
+  createReplicator(driver, config, resources, client) {
+    return createReplicator(driver, config, resources, client);
   }
 
-  async initializeReplicators() {
-    console.log('[PLUGIN][INIT] initializeReplicators called');
+  async initializeReplicators(database) {
     for (const replicatorConfig of this.config.replicators) {
-      try {
-        console.log('[PLUGIN][INIT] processing replicatorConfig:', replicatorConfig);
-        const driver = replicatorConfig.driver;
-        const resources = replicatorConfig.resources;
-        const client = replicatorConfig.client;
-        const replicator = createReplicator(driver, replicatorConfig, resources, client);
-        if (replicator) {
-          // Initialize the replicator with the database
-          await replicator.initialize(this.database);
-          
-          this.replicators.push({
-            id: Math.random().toString(36).slice(2),
-            driver,
-            config: replicatorConfig,
-            resources,
-            instance: replicator
-          });
-          console.log('[PLUGIN][INIT] pushed replicator:', driver, resources);
-        } else {
-          console.log('[PLUGIN][INIT] createReplicator returned null/undefined for driver:', driver);
-        }
-      } catch (err) {
-        console.error('[PLUGIN][INIT] Error creating replicator:', err);
+      const { driver, config = {}, resources, client, ...otherConfig } = replicatorConfig;
+      
+      // Extract resources from replicatorConfig or config
+      const replicatorResources = resources || config.resources || {};
+      
+      // Merge config with other top-level config options (like queueUrlDefault)
+      const mergedConfig = { ...config, ...otherConfig };
+      
+      // Pass config, resources, and client in correct order
+      const replicator = this.createReplicator(driver, mergedConfig, replicatorResources, client);
+      if (replicator) {
+        await replicator.initialize(database);
+        this.replicators.push(replicator);
       }
     }
   }
@@ -400,180 +300,198 @@ export class ReplicatorPlugin extends Plugin {
     // await this.processQueue(); // Removed as per edit hint
   }
 
-  async processReplicatorEvent(resourceName, operation, recordId, data, beforeData = null) {
-    if (this.config.verbose) {
-      console.log('[PLUGIN][processReplicatorEvent] replicators.length:', this.replicators.length, this.replicators.map(r => ({id: r.id, driver: r.driver})));
-      console.log(`[PLUGIN][processReplicatorEvent] operation: ${operation}, resource: ${resourceName}, recordId: ${recordId}, data:`, data, 'beforeData:', beforeData);
+  filterInternalFields(data) {
+    if (!data || typeof data !== 'object') return data;
+    const filtered = {};
+    for (const [key, value] of Object.entries(data)) {
+      // Filter out internal fields that start with _ or $
+      if (!key.startsWith('_') && !key.startsWith('$')) {
+        filtered[key] = value;
+      }
     }
-    if (this.config.verbose) {
-      console.log(`[PLUGIN] processReplicatorEvent: resource=${resourceName} op=${operation} id=${recordId} data=`, data);
+    return filtered;
+  }
+
+  async uploadMetadataFile(database) {
+    if (typeof database.uploadMetadataFile === 'function') {
+      await database.uploadMetadataFile();
     }
-    if (this.config.verbose) {
-    console.log(`[PLUGIN] processReplicatorEvent: resource=${resourceName} op=${operation} replicators=${this.replicators.length}`);
+  }
+
+  async getCompleteData(resource, data) {
+    try {
+      const [ok, err, record] = await tryFn(() => resource.get(data.id));
+      if (ok && record) {
+        return record;
+      }
+    } catch (error) {
+      // Fallback to provided data
     }
-    if (this.replicators.length === 0) {
-      if (this.config.verbose) {
-        console.log('[PLUGIN] No replicators registered');
+    return data;
+  }
+
+  async retryWithBackoff(operation, maxRetries = 3) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (attempt === maxRetries) {
+          throw error;
+        }
+        // Simple backoff: wait 1s, 2s, 4s...
+        const delay = Math.pow(2, attempt - 1) * 1000;
+        await new Promise(resolve => setTimeout(resolve, delay));
       }
-      return;
     }
-    const applicableReplicators = this.replicators.filter(replicator => {
-      const should = replicator.instance.shouldReplicateResource(resourceName, operation);
-      if (this.config.verbose) {
-        console.log(`[PLUGIN] Replicator ${replicator.driver} shouldReplicateResource(${resourceName}, ${operation}):`, should);
+    throw lastError;
+  }
+
+  async logError(replicator, resourceName, operation, recordId, data, error) {
+    try {
+      const logResourceName = this.config.replicatorLogResource;
+      if (this.database && this.database.resources && this.database.resources[logResourceName]) {
+        const logResource = this.database.resources[logResourceName];
+        await logResource.insert({
+          replicator: replicator.name || replicator.id,
+          resourceName,
+          operation,
+          recordId,
+          data: JSON.stringify(data),
+          error: error.message,
+          timestamp: new Date().toISOString(),
+          status: 'error'
+        });
       }
+    } catch (logError) {
+      // Silent log errors
+    }
+  }
+
+  async processReplicatorEvent(operation, resourceName, recordId, data, beforeData = null) {
+    if (!this.config.enabled) return;
+
+    const applicableReplicators = this.replicators.filter(replicator => {
+      const should = replicator.shouldReplicateResource && replicator.shouldReplicateResource(resourceName, operation);
       return should;
     });
-    if (this.config.verbose) {
-      console.log(`[PLUGIN] processReplicatorEvent: applicableReplicators for resource=${resourceName}:`, applicableReplicators.map(r => r.driver));
-    }
+
     if (applicableReplicators.length === 0) {
-      if (this.config.verbose) {
-        console.log('[PLUGIN] No applicable replicators for resource', resourceName);
-      }
       return;
     }
 
-    // Filtrar campos internos antes de replicar
-    const filteredData = this.filterInternalFields(isPlainObject(data) ? data : { raw: data });
-    const filteredBeforeData = beforeData ? this.filterInternalFields(isPlainObject(beforeData) ? beforeData : { raw: beforeData }) : null;
-
-    const item = {
-      id: `repl-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      resourceName,
-      operation,
-      recordId,
-      data: filteredData,
-      beforeData: filteredBeforeData,
-      timestamp: new Date().toISOString(),
-      attempts: 0
-    };
-
-    // Log replicator attempt
-    const logId = await this.logreplicator(item);
-
-    // Sempre processa imediatamente (sincrono)
-    const [ok, err, result] = await tryFn(async () => this.processreplicatorItem(item));
-    if (ok) {
-      if (logId) {
-        await this.updatereplicatorLog(logId, {
-          status: result.success ? 'success' : 'failed',
-          attempts: 1,
-          error: result.success ? '' : JSON.stringify(result.results)
+    const promises = applicableReplicators.map(async (replicator) => {
+      try {
+        const result = await this.retryWithBackoff(
+          () => replicator.replicate(resourceName, operation, data, recordId, beforeData),
+          this.config.maxRetries
+        );
+        
+        this.emit('replicated', {
+          replicator: replicator.name || replicator.id,
+          resourceName,
+          operation,
+          recordId,
+          result,
+          success: true
         });
-      }
-      this.stats.totalOperations++;
-      if (result.success) {
-        this.stats.successfulOperations++;
-      } else {
-        this.stats.failedOperations++;
-      }
-    } else {
-      if (logId) {
-        await this.updatereplicatorLog(logId, {
-          status: 'failed',
-          attempts: 1,
-          error: err.message
+
+        return result;
+      } catch (error) {
+        this.emit('replicator_error', {
+          replicator: replicator.name || replicator.id,
+          resourceName,
+          operation,
+          recordId,
+          error: error.message
         });
+
+        if (this.config.logErrors && this.database) {
+          await this.logError(replicator, resourceName, operation, recordId, data, error);
+        }
+
+        throw error;
       }
-      this.stats.failedOperations++;
-    }
+    });
+
+    return Promise.allSettled(promises);
   }
 
   async processreplicatorItem(item) {
-    if (this.config.verbose) {
-      console.log('[PLUGIN][processreplicatorItem] called with item:', item);
-    }
     const applicableReplicators = this.replicators.filter(replicator => {
-      const should = replicator.instance.shouldReplicateResource(item.resourceName, item.operation);
-      if (this.config.verbose) {
-        console.log(`[PLUGIN] processreplicatorItem: Replicator ${replicator.driver} shouldReplicateResource(${item.resourceName}, ${item.operation}):`, should);
-      }
+      const should = replicator.shouldReplicateResource && replicator.shouldReplicateResource(item.resourceName, item.operation);
       return should;
     });
-    if (this.config.verbose) {
-      console.log(`[PLUGIN] processreplicatorItem: applicableReplicators for resource=${item.resourceName}:`, applicableReplicators.map(r => r.driver));
-    }
+
     if (applicableReplicators.length === 0) {
-      if (this.config.verbose) {
-        console.log('[PLUGIN] processreplicatorItem: No applicable replicators for resource', item.resourceName);
-      }
-      return { success: true, skipped: true, reason: 'no_applicable_replicators' };
+      return;
     }
 
-    const results = [];
-    
-    for (const replicator of applicableReplicators) {
-      let result;
-      let ok, err;
-      if (this.config.verbose) {
-        console.log('[PLUGIN] processReplicatorItem', {
-          resource: item.resourceName,
+    const promises = applicableReplicators.map(async (replicator) => {
+      try {
+        const [ok, err, result] = await tryFn(() => 
+          replicator.replicate(item.resourceName, item.operation, item.data, item.recordId, item.beforeData)
+        );
+
+        if (!ok) {
+          this.emit('replicator_error', {
+            replicator: replicator.name || replicator.id,
+            resourceName: item.resourceName,
+            operation: item.operation,
+            recordId: item.recordId,
+            error: err.message
+          });
+
+          if (this.config.logErrors && this.database) {
+            await this.logError(replicator, item.resourceName, item.operation, item.recordId, item.data, err);
+          }
+
+          return { success: false, error: err.message };
+        }
+
+        this.emit('replicated', {
+          replicator: replicator.name || replicator.id,
+          resourceName: item.resourceName,
           operation: item.operation,
-          data: item.data,
-          beforeData: item.beforeData,
-          replicator: replicator.instance?.constructor?.name
+          recordId: item.recordId,
+          result,
+          success: true
         });
-      }
-      if (replicator.instance && replicator.instance.constructor && replicator.instance.constructor.name === 'S3dbReplicator') {
-        [ok, err, result] = await tryFn(() => 
-          replicator.instance.replicate({
-            resource: item.resourceName,
-            operation: item.operation,
-            data: item.data,
-            id: item.recordId,
-            beforeData: item.beforeData
-          })
-        );
-      } else {
-        [ok, err, result] = await tryFn(() =>
-        replicator.instance.replicate(
-          item.resourceName,
-          item.operation,
-          item.data,
-          item.recordId,
-          item.beforeData
-        )
-      );
-      }
-      // Remove or comment out this line:
-      // console.log('[PLUGIN] replicate result', { ok, err, result });
-      results.push({
-          replicatorId: replicator.id,
-          driver: replicator.driver,
-          success: result && result.success,
-          error: result && result.error,
-          skipped: result && result.skipped
+
+        return { success: true, result };
+      } catch (error) {
+        this.emit('replicator_error', {
+          replicator: replicator.name || replicator.id,
+          resourceName: item.resourceName,
+          operation: item.operation,
+          recordId: item.recordId,
+          error: error.message
         });
-    }
 
-    return {
-      success: results.every(r => r.success || r.skipped),
-      results
-    };
+        if (this.config.logErrors && this.database) {
+          await this.logError(replicator, item.resourceName, item.operation, item.recordId, item.data, error);
+        }
+
+        return { success: false, error: error.message };
+      }
+    });
+
+    return Promise.allSettled(promises);
   }
 
   async logreplicator(item) {
-    // Use sempre a referência salva
+            // Always use the saved reference
     const logRes = this.replicatorLog || this.database.resources[normalizeResourceName(this.config.replicatorLogResource)];
     if (!logRes) {
-      if (this.config.verbose) {
-      console.error('[PLUGIN] replicator log resource not found!');
-      }
       if (this.database) {
-        if (this.config.verbose) {
-        console.warn('[PLUGIN] database.resources keys:', Object.keys(this.database.resources));
-        }
         if (this.database.options && this.database.options.connectionString) {
-          if (this.config.verbose) {
-          console.warn('[PLUGIN] database connectionString:', this.database.options.connectionString);
-          }
         }
       }
       this.emit('replicator.log.failed', { error: 'replicator log resource not found', item });
       return;
     }
-    // Corrigir campos obrigatórios do log resource
+            // Fix required fields of log resource
     const logItem = {
       id: item.id || `repl-${Date.now()}-${Math.random().toString(36).slice(2)}`,
       resource: item.resource || item.resourceName || '',
@@ -585,9 +503,6 @@ export class ReplicatorPlugin extends Plugin {
     try {
       await logRes.insert(logItem);
     } catch (err) {
-      if (this.config.verbose) {
-        console.error('[PLUGIN] Error writing to replicator log:', err);
-      }
       this.emit('replicator.log.failed', { error: err, item });
     }
   }
@@ -610,7 +525,7 @@ export class ReplicatorPlugin extends Plugin {
   async getreplicatorStats() {
     const replicatorStats = await Promise.all(
       this.replicators.map(async (replicator) => {
-        const status = await replicator.instance.getStatus();
+        const status = await replicator.getStatus();
         return {
           id: replicator.id,
           driver: replicator.driver,
@@ -688,9 +603,7 @@ export class ReplicatorPlugin extends Plugin {
       if (ok) {
         retried++;
       } else {
-        if (this.config.verbose) {
-        console.error('Failed to retry replicator:', err);
-        }
+        // Retry failed, continue
       }
     }
 
@@ -708,14 +621,14 @@ export class ReplicatorPlugin extends Plugin {
     for (const resourceName in this.database.resources) {
       if (normalizeResourceName(resourceName) === normalizeResourceName('replicator_logs')) continue;
 
-      if (replicator.instance.shouldReplicateResource(resourceName)) {
+      if (replicator.shouldReplicateResource(resourceName)) {
         this.emit('replicator.sync.resource', { resourceName, replicatorId });
         
         const resource = this.database.resources[resourceName];
       const allRecords = await resource.getAll();
       
       for (const record of allRecords) {
-          await replicator.instance.replicate(resourceName, 'insert', record, record.id);
+          await replicator.replicate(resourceName, 'insert', record, record.id);
         }
       }
     }
@@ -724,44 +637,28 @@ export class ReplicatorPlugin extends Plugin {
   }
 
   async cleanup() {
-    if (this.config.verbose) {
-      console.log('[PLUGIN][CLEANUP] Cleaning up ReplicatorPlugin');
-    }
-    // Remove all event listeners installed on resources
-    if (this._installedListeners && Array.isArray(this._installedListeners)) {
-      for (const resource of this._installedListeners) {
-        if (resource && typeof resource.removeAllListeners === 'function') {
-          resource.removeAllListeners('insert');
-          resource.removeAllListeners('update');
-          resource.removeAllListeners('delete');
-        }
-        resource._replicatorListenersInstalled = false;
-      }
-      this._installedListeners = [];
-    }
-    // Remove all event listeners from the database
-    if (this.database && typeof this.database.removeAllListeners === 'function') {
-      this.database.removeAllListeners();
-    }
-    // Cleanup all replicator instances
-    if (this.replicators && Array.isArray(this.replicators)) {
-      for (const rep of this.replicators) {
-        if (rep.instance && typeof rep.instance.cleanup === 'function') {
-          await rep.instance.cleanup();
-        }
+    try {
+      if (this.replicators && this.replicators.length > 0) {
+        const cleanupPromises = this.replicators.map(async (replicator) => {
+          try {
+            if (replicator && typeof replicator.cleanup === 'function') {
+              await replicator.cleanup();
+            }
+          } catch (error) {
+            // Silent cleanup errors
+          }
+        });
+        
+        await Promise.allSettled(cleanupPromises);
       }
+      
       this.replicators = [];
-    }
-    // Clear other internal state
-    this.queue = [];
-    this.isProcessing = false;
-    this.stats = {
-      totalOperations: 0,
-      totalErrors: 0,
-      lastError: null,
-    };
-    if (this.config.verbose) {
-      console.log('[PLUGIN][CLEANUP] ReplicatorPlugin cleanup complete');
+      this.database = null;
+      this.eventListenersInstalled.clear();
+      
+      this.removeAllListeners();
+    } catch (error) {
+      // Silent cleanup errors
     }
   }
 }