s3db.js 7.2.1 → 7.3.2

package/dist/s3db.iife.js

@@ -1333,7 +1333,8 @@ ${JSON.stringify(validation, null, 2)}`,
             version: "2.0"
           })
         };
-        this.logAudit(auditRecord).catch(console.error);
+        this.logAudit(auditRecord).catch(() => {
+        });
       });
       resource.on("update", async (data) => {
         const recordId = data.id;
@@ -1359,7 +1360,8 @@ ${JSON.stringify(validation, null, 2)}`,
             version: "2.0"
           })
         };
-        this.logAudit(auditRecord).catch(console.error);
+        this.logAudit(auditRecord).catch(() => {
+        });
       });
       resource.on("delete", async (data) => {
         const recordId = data.id;
@@ -1385,7 +1387,8 @@ ${JSON.stringify(validation, null, 2)}`,
             version: "2.0"
           })
         };
-        this.logAudit(auditRecord).catch(console.error);
+        this.logAudit(auditRecord).catch(() => {
+        });
       });
       resource.useMiddleware("deleteMany", async (ctx, next) => {
         const ids = ctx.args[0];
@@ -1418,7 +1421,8 @@ ${JSON.stringify(validation, null, 2)}`,
                 batchOperation: true
               })
             };
-            this.logAudit(auditRecord).catch(console.error);
+            this.logAudit(auditRecord).catch(() => {
+            });
           }
         }
         return result;
@@ -2065,6 +2069,16 @@ ${JSON.stringify(validation, null, 2)}`,
   // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
   // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+  var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
+    function getOwnPropertyDescriptors(obj) {
+      var keys = Object.keys(obj);
+      var descriptors = {};
+      for (var i = 0; i < keys.length; i++) {
+        descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
+      }
+      return descriptors;
+    };
+
   var formatRegExp = /%[sdj%]/g;
   function format(f) {
     if (!isString(f)) {
@@ -2550,6 +2564,64 @@ ${JSON.stringify(validation, null, 2)}`,
     return Object.prototype.hasOwnProperty.call(obj, prop);
   }
 
+  var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
+
+  function promisify(original) {
+    if (typeof original !== 'function')
+      throw new TypeError('The "original" argument must be of type Function');
+
+    if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+      var fn = original[kCustomPromisifiedSymbol];
+      if (typeof fn !== 'function') {
+        throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+      }
+      Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+        value: fn, enumerable: false, writable: false, configurable: true
+      });
+      return fn;
+    }
+
+    function fn() {
+      var promiseResolve, promiseReject;
+      var promise = new Promise(function (resolve, reject) {
+        promiseResolve = resolve;
+        promiseReject = reject;
+      });
+
+      var args = [];
+      for (var i = 0; i < arguments.length; i++) {
+        args.push(arguments[i]);
+      }
+      args.push(function (err, value) {
+        if (err) {
+          promiseReject(err);
+        } else {
+          promiseResolve(value);
+        }
+      });
+
+      try {
+        original.apply(this, args);
+      } catch (err) {
+        promiseReject(err);
+      }
+
+      return promise;
+    }
+
+    Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+
+    if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+      value: fn, enumerable: false, writable: false, configurable: true
+    });
+    return Object.defineProperties(
+      fn,
+      getOwnPropertyDescriptors(original)
+    );
+  }
+
+  promisify.custom = kCustomPromisifiedSymbol;
+
   var lookup = [];
   var revLookup = [];
   var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
@@ -6800,12 +6872,798 @@ ${JSON.stringify(validation, null, 2)}`,
   }
   var memory_cache_class_default = MemoryCache;
 
+  var fs = {};
+
+  const readFile$1 = promisify(fs.readFile);
+  const writeFile$1 = promisify(fs.writeFile);
+  const unlink = promisify(fs.unlink);
+  const readdir$1 = promisify(fs.readdir);
+  const stat$1 = promisify(fs.stat);
+  const mkdir = promisify(fs.mkdir);
+  class FilesystemCache extends Cache {
+    constructor({
+      directory,
+      prefix = "cache",
+      ttl = 36e5,
+      enableCompression = true,
+      compressionThreshold = 1024,
+      createDirectory = true,
+      fileExtension = ".cache",
+      enableMetadata = true,
+      maxFileSize = 10485760,
+      // 10MB
+      enableStats = false,
+      enableCleanup = true,
+      cleanupInterval = 3e5,
+      // 5 minutes
+      encoding = "utf8",
+      fileMode = 420,
+      enableBackup = false,
+      backupSuffix = ".bak",
+      enableLocking = false,
+      lockTimeout = 5e3,
+      enableJournal = false,
+      journalFile = "cache.journal",
+      ...config
+    }) {
+      super(config);
+      if (!directory) {
+        throw new Error("FilesystemCache: directory parameter is required");
+      }
+      this.directory = path.resolve(directory);
+      this.prefix = prefix;
+      this.ttl = ttl;
+      this.enableCompression = enableCompression;
+      this.compressionThreshold = compressionThreshold;
+      this.createDirectory = createDirectory;
+      this.fileExtension = fileExtension;
+      this.enableMetadata = enableMetadata;
+      this.maxFileSize = maxFileSize;
+      this.enableStats = enableStats;
+      this.enableCleanup = enableCleanup;
+      this.cleanupInterval = cleanupInterval;
+      this.encoding = encoding;
+      this.fileMode = fileMode;
+      this.enableBackup = enableBackup;
+      this.backupSuffix = backupSuffix;
+      this.enableLocking = enableLocking;
+      this.lockTimeout = lockTimeout;
+      this.enableJournal = enableJournal;
+      this.journalFile = path.join(this.directory, journalFile);
+      this.stats = {
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        clears: 0,
+        errors: 0
+      };
+      this.locks = /* @__PURE__ */ new Map();
+      this.cleanupTimer = null;
+      this._init();
+    }
+    async _init() {
+      if (this.createDirectory) {
+        await this._ensureDirectory(this.directory);
+      }
+      if (this.enableCleanup && this.cleanupInterval > 0) {
+        this.cleanupTimer = setInterval(() => {
+          this._cleanup().catch((err) => {
+            console.warn("FilesystemCache cleanup error:", err.message);
+          });
+        }, this.cleanupInterval);
+      }
+    }
+    async _ensureDirectory(dir) {
+      const [ok, err] = await try_fn_default(async () => {
+        await mkdir(dir, { recursive: true });
+      });
+      if (!ok && err.code !== "EEXIST") {
+        throw new Error(`Failed to create cache directory: ${err.message}`);
+      }
+    }
+    _getFilePath(key) {
+      const sanitizedKey = key.replace(/[<>:"/\\|?*]/g, "_");
+      const filename = `${this.prefix}_${sanitizedKey}${this.fileExtension}`;
+      return path.join(this.directory, filename);
+    }
+    _getMetadataPath(filePath) {
+      return filePath + ".meta";
+    }
+    async _set(key, data) {
+      const filePath = this._getFilePath(key);
+      try {
+        let serialized = JSON.stringify(data);
+        const originalSize = Buffer.byteLength(serialized, this.encoding);
+        if (originalSize > this.maxFileSize) {
+          throw new Error(`Cache data exceeds maximum file size: ${originalSize} > ${this.maxFileSize}`);
+        }
+        let compressed = false;
+        let finalData = serialized;
+        if (this.enableCompression && originalSize >= this.compressionThreshold) {
+          const compressedBuffer = zlib.gzipSync(Buffer.from(serialized, this.encoding));
+          finalData = compressedBuffer.toString("base64");
+          compressed = true;
+        }
+        if (this.enableBackup && await this._fileExists(filePath)) {
+          const backupPath = filePath + this.backupSuffix;
+          await this._copyFile(filePath, backupPath);
+        }
+        if (this.enableLocking) {
+          await this._acquireLock(filePath);
+        }
+        try {
+          await writeFile$1(filePath, finalData, {
+            encoding: compressed ? "utf8" : this.encoding,
+            mode: this.fileMode
+          });
+          if (this.enableMetadata) {
+            const metadata = {
+              key,
+              timestamp: Date.now(),
+              ttl: this.ttl,
+              compressed,
+              originalSize,
+              compressedSize: compressed ? Buffer.byteLength(finalData, "utf8") : originalSize,
+              compressionRatio: compressed ? (Buffer.byteLength(finalData, "utf8") / originalSize).toFixed(2) : 1
+            };
+            await writeFile$1(this._getMetadataPath(filePath), JSON.stringify(metadata), {
+              encoding: this.encoding,
+              mode: this.fileMode
+            });
+          }
+          if (this.enableStats) {
+            this.stats.sets++;
+          }
+          if (this.enableJournal) {
+            await this._journalOperation("set", key, { size: originalSize, compressed });
+          }
+        } finally {
+          if (this.enableLocking) {
+            this._releaseLock(filePath);
+          }
+        }
+        return data;
+      } catch (error) {
+        if (this.enableStats) {
+          this.stats.errors++;
+        }
+        throw new Error(`Failed to set cache key '${key}': ${error.message}`);
+      }
+    }
+    async _get(key) {
+      const filePath = this._getFilePath(key);
+      try {
+        if (!await this._fileExists(filePath)) {
+          if (this.enableStats) {
+            this.stats.misses++;
+          }
+          return null;
+        }
+        let isExpired = false;
+        if (this.enableMetadata) {
+          const metadataPath = this._getMetadataPath(filePath);
+          if (await this._fileExists(metadataPath)) {
+            const [ok, err, metadata] = await try_fn_default(async () => {
+              const metaContent = await readFile$1(metadataPath, this.encoding);
+              return JSON.parse(metaContent);
+            });
+            if (ok && metadata.ttl > 0) {
+              const age = Date.now() - metadata.timestamp;
+              isExpired = age > metadata.ttl;
+            }
+          }
+        } else if (this.ttl > 0) {
+          const stats = await stat$1(filePath);
+          const age = Date.now() - stats.mtime.getTime();
+          isExpired = age > this.ttl;
+        }
+        if (isExpired) {
+          await this._del(key);
+          if (this.enableStats) {
+            this.stats.misses++;
+          }
+          return null;
+        }
+        if (this.enableLocking) {
+          await this._acquireLock(filePath);
+        }
+        try {
+          const content = await readFile$1(filePath, this.encoding);
+          let isCompressed = false;
+          if (this.enableMetadata) {
+            const metadataPath = this._getMetadataPath(filePath);
+            if (await this._fileExists(metadataPath)) {
+              const [ok, err, metadata] = await try_fn_default(async () => {
+                const metaContent = await readFile$1(metadataPath, this.encoding);
+                return JSON.parse(metaContent);
+              });
+              if (ok) {
+                isCompressed = metadata.compressed;
+              }
+            }
+          }
+          let finalContent = content;
+          if (isCompressed || this.enableCompression && content.match(/^[A-Za-z0-9+/=]+$/)) {
+            try {
+              const compressedBuffer = Buffer.from(content, "base64");
+              finalContent = zlib.gunzipSync(compressedBuffer).toString(this.encoding);
+            } catch (decompressError) {
+              finalContent = content;
+            }
+          }
+          const data = JSON.parse(finalContent);
+          if (this.enableStats) {
+            this.stats.hits++;
+          }
+          return data;
+        } finally {
+          if (this.enableLocking) {
+            this._releaseLock(filePath);
+          }
+        }
+      } catch (error) {
+        if (this.enableStats) {
+          this.stats.errors++;
+        }
+        await this._del(key);
+        return null;
+      }
+    }
+    async _del(key) {
+      const filePath = this._getFilePath(key);
+      try {
+        if (await this._fileExists(filePath)) {
+          await unlink(filePath);
+        }
+        if (this.enableMetadata) {
+          const metadataPath = this._getMetadataPath(filePath);
+          if (await this._fileExists(metadataPath)) {
+            await unlink(metadataPath);
+          }
+        }
+        if (this.enableBackup) {
+          const backupPath = filePath + this.backupSuffix;
+          if (await this._fileExists(backupPath)) {
+            await unlink(backupPath);
+          }
+        }
+        if (this.enableStats) {
+          this.stats.deletes++;
+        }
+        if (this.enableJournal) {
+          await this._journalOperation("delete", key);
+        }
+        return true;
+      } catch (error) {
+        if (this.enableStats) {
+          this.stats.errors++;
+        }
+        throw new Error(`Failed to delete cache key '${key}': ${error.message}`);
+      }
+    }
+    async _clear(prefix) {
+      try {
+        const files = await readdir$1(this.directory);
+        const cacheFiles = files.filter((file) => {
+          if (!file.startsWith(this.prefix)) return false;
+          if (!file.endsWith(this.fileExtension)) return false;
+          if (prefix) {
+            const keyPart = file.slice(this.prefix.length + 1, -this.fileExtension.length);
+            return keyPart.startsWith(prefix);
+          }
+          return true;
+        });
+        for (const file of cacheFiles) {
+          const filePath = path.join(this.directory, file);
+          if (await this._fileExists(filePath)) {
+            await unlink(filePath);
+          }
+          if (this.enableMetadata) {
+            const metadataPath = this._getMetadataPath(filePath);
+            if (await this._fileExists(metadataPath)) {
+              await unlink(metadataPath);
+            }
+          }
+          if (this.enableBackup) {
+            const backupPath = filePath + this.backupSuffix;
+            if (await this._fileExists(backupPath)) {
+              await unlink(backupPath);
+            }
+          }
+        }
+        if (this.enableStats) {
+          this.stats.clears++;
+        }
+        if (this.enableJournal) {
+          await this._journalOperation("clear", prefix || "all", { count: cacheFiles.length });
+        }
+        return true;
+      } catch (error) {
+        if (this.enableStats) {
+          this.stats.errors++;
+        }
+        throw new Error(`Failed to clear cache: ${error.message}`);
+      }
+    }
+    async size() {
+      const keys = await this.keys();
+      return keys.length;
+    }
+    async keys() {
+      try {
+        const files = await readdir$1(this.directory);
+        const cacheFiles = files.filter(
+          (file) => file.startsWith(this.prefix) && file.endsWith(this.fileExtension)
+        );
+        const keys = cacheFiles.map((file) => {
+          const keyPart = file.slice(this.prefix.length + 1, -this.fileExtension.length);
+          return keyPart;
+        });
+        return keys;
+      } catch (error) {
+        console.warn("FilesystemCache: Failed to list keys:", error.message);
+        return [];
+      }
+    }
+    // Helper methods
+    async _fileExists(filePath) {
+      const [ok] = await try_fn_default(async () => {
+        await stat$1(filePath);
+      });
+      return ok;
+    }
+    async _copyFile(src, dest) {
+      const [ok, err] = await try_fn_default(async () => {
+        const content = await readFile$1(src);
+        await writeFile$1(dest, content);
+      });
+      if (!ok) {
+        console.warn("FilesystemCache: Failed to create backup:", err.message);
+      }
+    }
+    async _cleanup() {
+      if (!this.ttl || this.ttl <= 0) return;
+      try {
+        const files = await readdir$1(this.directory);
+        const now = Date.now();
+        for (const file of files) {
+          if (!file.startsWith(this.prefix) || !file.endsWith(this.fileExtension)) {
+            continue;
+          }
+          const filePath = path.join(this.directory, file);
+          let shouldDelete = false;
+          if (this.enableMetadata) {
+            const metadataPath = this._getMetadataPath(filePath);
+            if (await this._fileExists(metadataPath)) {
+              const [ok, err, metadata] = await try_fn_default(async () => {
+                const metaContent = await readFile$1(metadataPath, this.encoding);
+                return JSON.parse(metaContent);
+              });
+              if (ok && metadata.ttl > 0) {
+                const age = now - metadata.timestamp;
+                shouldDelete = age > metadata.ttl;
+              }
+            }
+          } else {
+            const [ok, err, stats] = await try_fn_default(async () => {
+              return await stat$1(filePath);
+            });
+            if (ok) {
+              const age = now - stats.mtime.getTime();
+              shouldDelete = age > this.ttl;
+            }
+          }
+          if (shouldDelete) {
+            const keyPart = file.slice(this.prefix.length + 1, -this.fileExtension.length);
+            await this._del(keyPart);
+          }
+        }
+      } catch (error) {
+        console.warn("FilesystemCache cleanup error:", error.message);
+      }
+    }
+    async _acquireLock(filePath) {
+      if (!this.enableLocking) return;
+      const lockKey = filePath;
+      const startTime = Date.now();
+      while (this.locks.has(lockKey)) {
+        if (Date.now() - startTime > this.lockTimeout) {
+          throw new Error(`Lock timeout for file: ${filePath}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      this.locks.set(lockKey, Date.now());
+    }
+    _releaseLock(filePath) {
+      if (!this.enableLocking) return;
+      this.locks.delete(filePath);
+    }
+    async _journalOperation(operation, key, metadata = {}) {
+      if (!this.enableJournal) return;
+      const entry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        operation,
+        key,
+        metadata
+      };
+      const [ok, err] = await try_fn_default(async () => {
+        const line = JSON.stringify(entry) + "\n";
+        await fs.promises.appendFile(this.journalFile, line, this.encoding);
+      });
+      if (!ok) {
+        console.warn("FilesystemCache journal error:", err.message);
+      }
+    }
+    // Cleanup on process exit
+    destroy() {
+      if (this.cleanupTimer) {
+        clearInterval(this.cleanupTimer);
+        this.cleanupTimer = null;
+      }
+    }
+    // Get cache statistics
+    getStats() {
+      return {
+        ...this.stats,
+        directory: this.directory,
+        ttl: this.ttl,
+        compression: this.enableCompression,
+        metadata: this.enableMetadata,
+        cleanup: this.enableCleanup,
+        locking: this.enableLocking,
+        journal: this.enableJournal
+      };
+    }
+  }
+
+  promisify(fs.mkdir);
+  const rmdir = promisify(fs.rmdir);
+  const readdir = promisify(fs.readdir);
+  const stat = promisify(fs.stat);
+  const writeFile = promisify(fs.writeFile);
+  const readFile = promisify(fs.readFile);
+  class PartitionAwareFilesystemCache extends FilesystemCache {
+    constructor({
+      partitionStrategy = "hierarchical",
+      // 'hierarchical', 'flat', 'temporal'
+      trackUsage = true,
+      preloadRelated = false,
+      preloadThreshold = 10,
+      maxCacheSize = null,
+      usageStatsFile = "partition-usage.json",
+      ...config
+    }) {
+      super(config);
+      this.partitionStrategy = partitionStrategy;
+      this.trackUsage = trackUsage;
+      this.preloadRelated = preloadRelated;
+      this.preloadThreshold = preloadThreshold;
+      this.maxCacheSize = maxCacheSize;
+      this.usageStatsFile = path.join(this.directory, usageStatsFile);
+      this.partitionUsage = /* @__PURE__ */ new Map();
+      this.loadUsageStats();
+    }
+    /**
+     * Generate partition-aware cache key
+     */
+    _getPartitionCacheKey(resource, action, partition, partitionValues = {}, params = {}) {
+      const keyParts = [`resource=${resource}`, `action=${action}`];
+      if (partition && Object.keys(partitionValues).length > 0) {
+        keyParts.push(`partition=${partition}`);
+        const sortedFields = Object.entries(partitionValues).sort(([a], [b]) => a.localeCompare(b));
+        for (const [field, value] of sortedFields) {
+          if (value !== null && value !== void 0) {
+            keyParts.push(`${field}=${value}`);
+          }
+        }
+      }
+      if (Object.keys(params).length > 0) {
+        const paramsStr = Object.entries(params).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join("|");
+        keyParts.push(`params=${Buffer.from(paramsStr).toString("base64")}`);
+      }
+      return keyParts.join("/") + this.fileExtension;
+    }
+    /**
+     * Get directory path for partition cache
+     */
+    _getPartitionDirectory(resource, partition, partitionValues = {}) {
+      const basePath = path.join(this.directory, `resource=${resource}`);
+      if (!partition) {
+        return basePath;
+      }
+      if (this.partitionStrategy === "flat") {
+        return path.join(basePath, "partitions");
+      }
+      if (this.partitionStrategy === "temporal" && this._isTemporalPartition(partition, partitionValues)) {
+        return this._getTemporalDirectory(basePath, partition, partitionValues);
+      }
+      const pathParts = [basePath, `partition=${partition}`];
+      const sortedFields = Object.entries(partitionValues).sort(([a], [b]) => a.localeCompare(b));
+      for (const [field, value] of sortedFields) {
+        if (value !== null && value !== void 0) {
+          pathParts.push(`${field}=${this._sanitizePathValue(value)}`);
+        }
+      }
+      return path.join(...pathParts);
+    }
+    /**
+     * Enhanced set method with partition awareness
+     */
+    async _set(key, data, options = {}) {
+      const { resource, action, partition, partitionValues, params } = options;
+      if (resource && partition) {
+        const partitionKey = this._getPartitionCacheKey(resource, action, partition, partitionValues, params);
+        const partitionDir = this._getPartitionDirectory(resource, partition, partitionValues);
+        await this._ensureDirectory(partitionDir);
+        const filePath = path.join(partitionDir, this._sanitizeFileName(partitionKey));
+        if (this.trackUsage) {
+          await this._trackPartitionUsage(resource, partition, partitionValues);
+        }
+        const partitionData = {
+          data,
+          metadata: {
+            resource,
+            partition,
+            partitionValues,
+            timestamp: Date.now(),
+            ttl: this.ttl
+          }
+        };
+        return this._writeFileWithMetadata(filePath, partitionData);
+      }
+      return super._set(key, data);
+    }
+    /**
+     * Enhanced get method with partition awareness
+     */
+    async _get(key, options = {}) {
+      const { resource, action, partition, partitionValues, params } = options;
+      if (resource && partition) {
+        const partitionKey = this._getPartitionCacheKey(resource, action, partition, partitionValues, params);
+        const partitionDir = this._getPartitionDirectory(resource, partition, partitionValues);
+        const filePath = path.join(partitionDir, this._sanitizeFileName(partitionKey));
+        if (!await this._fileExists(filePath)) {
+          if (this.preloadRelated) {
+            await this._preloadRelatedPartitions(resource, partition, partitionValues);
+          }
+          return null;
+        }
+        const result = await this._readFileWithMetadata(filePath);
+        if (result && this.trackUsage) {
+          await this._trackPartitionUsage(resource, partition, partitionValues);
+        }
+        return result?.data || null;
+      }
+      return super._get(key);
+    }
+    /**
+     * Clear cache for specific partition
+     */
+    async clearPartition(resource, partition, partitionValues = {}) {
+      const partitionDir = this._getPartitionDirectory(resource, partition, partitionValues);
+      const [ok, err] = await try_fn_default(async () => {
+        if (await this._fileExists(partitionDir)) {
+          await rmdir(partitionDir, { recursive: true });
+        }
+      });
+      if (!ok) {
+        console.warn(`Failed to clear partition cache: ${err.message}`);
+      }
+      const usageKey = this._getUsageKey(resource, partition, partitionValues);
+      this.partitionUsage.delete(usageKey);
+      await this._saveUsageStats();
+      return ok;
+    }
+    /**
+     * Clear all partitions for a resource
+     */
+    async clearResourcePartitions(resource) {
+      const resourceDir = path.join(this.directory, `resource=${resource}`);
+      const [ok, err] = await try_fn_default(async () => {
+        if (await this._fileExists(resourceDir)) {
+          await rmdir(resourceDir, { recursive: true });
+        }
+      });
+      for (const [key] of this.partitionUsage.entries()) {
+        if (key.startsWith(`${resource}/`)) {
+          this.partitionUsage.delete(key);
+        }
+      }
+      await this._saveUsageStats();
+      return ok;
+    }
+    /**
+     * Get partition cache statistics
+     */
+    async getPartitionStats(resource, partition = null) {
+      const stats = {
+        totalFiles: 0,
+        totalSize: 0,
+        partitions: {},
+        usage: {}
+      };
+      const resourceDir = path.join(this.directory, `resource=${resource}`);
+      if (!await this._fileExists(resourceDir)) {
+        return stats;
+      }
+      await this._calculateDirectoryStats(resourceDir, stats);
+      for (const [key, usage] of this.partitionUsage.entries()) {
+        if (key.startsWith(`${resource}/`)) {
+          const partitionName = key.split("/")[1];
+          if (!partition || partitionName === partition) {
+            stats.usage[partitionName] = usage;
+          }
+        }
+      }
+      return stats;
+    }
+    /**
+     * Get cache recommendations based on usage patterns
+     */
+    async getCacheRecommendations(resource) {
+      const recommendations = [];
+      const now = Date.now();
+      const dayMs = 24 * 60 * 60 * 1e3;
+      for (const [key, usage] of this.partitionUsage.entries()) {
+        if (key.startsWith(`${resource}/`)) {
+          const [, partition] = key.split("/");
+          const daysSinceLastAccess = (now - usage.lastAccess) / dayMs;
+          const accessesPerDay = usage.count / Math.max(1, daysSinceLastAccess);
+          let recommendation = "keep";
+          let priority = usage.count;
+          if (daysSinceLastAccess > 30) {
+            recommendation = "archive";
+            priority = 0;
+          } else if (accessesPerDay < 0.1) {
+            recommendation = "reduce_ttl";
+            priority = 1;
+          } else if (accessesPerDay > 10) {
+            recommendation = "preload";
+            priority = 100;
+          }
+          recommendations.push({
+            partition,
+            recommendation,
+            priority,
+            usage: accessesPerDay,
+            lastAccess: new Date(usage.lastAccess).toISOString()
+          });
+        }
+      }
+      return recommendations.sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Preload frequently accessed partitions
+     */
+    async warmPartitionCache(resource, options = {}) {
+      const { partitions = [], maxFiles = 1e3 } = options;
+      let warmedCount = 0;
+      for (const partition of partitions) {
+        const usageKey = `${resource}/${partition}`;
+        const usage = this.partitionUsage.get(usageKey);
+        if (usage && usage.count >= this.preloadThreshold) {
+          console.log(`\u{1F525} Warming cache for ${resource}/${partition} (${usage.count} accesses)`);
+          warmedCount++;
+        }
+        if (warmedCount >= maxFiles) break;
+      }
+      return warmedCount;
+    }
+    // Private helper methods
+    async _trackPartitionUsage(resource, partition, partitionValues) {
+      const usageKey = this._getUsageKey(resource, partition, partitionValues);
+      const current = this.partitionUsage.get(usageKey) || {
+        count: 0,
+        firstAccess: Date.now(),
+        lastAccess: Date.now()
+      };
+      current.count++;
+      current.lastAccess = Date.now();
+      this.partitionUsage.set(usageKey, current);
+      if (current.count % 10 === 0) {
+        await this._saveUsageStats();
+      }
+    }
+    _getUsageKey(resource, partition, partitionValues) {
+      const valuePart = Object.entries(partitionValues).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join("|");
+      return `${resource}/${partition}/${valuePart}`;
+    }
+    async _preloadRelatedPartitions(resource, partition, partitionValues) {
+      console.log(`\u{1F3AF} Preloading related partitions for ${resource}/${partition}`);
+      if (partitionValues.timestamp || partitionValues.date) ;
+    }
+    _isTemporalPartition(partition, partitionValues) {
+      const temporalFields = ["date", "timestamp", "createdAt", "updatedAt"];
+      return Object.keys(partitionValues).some(
+        (field) => temporalFields.some((tf) => field.toLowerCase().includes(tf))
+      );
+    }
+    _getTemporalDirectory(basePath, partition, partitionValues) {
+      const dateValue = Object.values(partitionValues)[0];
+      if (typeof dateValue === "string" && dateValue.match(/^\d{4}-\d{2}-\d{2}/)) {
+        const [year, month, day] = dateValue.split("-");
+        return path.join(basePath, "temporal", year, month, day);
+      }
+      return path.join(basePath, `partition=${partition}`);
+    }
+    _sanitizePathValue(value) {
+      return String(value).replace(/[<>:"/\\|?*]/g, "_");
+    }
+    _sanitizeFileName(filename) {
+      return filename.replace(/[<>:"/\\|?*]/g, "_");
+    }
+    async _calculateDirectoryStats(dir, stats) {
+      const [ok, err, files] = await try_fn_default(() => readdir(dir));
+      if (!ok) return;
+      for (const file of files) {
+        const filePath = path.join(dir, file);
+        const [statOk, statErr, fileStat] = await try_fn_default(() => stat(filePath));
+        if (statOk) {
+          if (fileStat.isDirectory()) {
+            await this._calculateDirectoryStats(filePath, stats);
+          } else {
+            stats.totalFiles++;
+            stats.totalSize += fileStat.size;
+          }
+        }
+      }
+    }
+    async loadUsageStats() {
+      const [ok, err, content] = await try_fn_default(async () => {
+        const data = await readFile(this.usageStatsFile, "utf8");
+        return JSON.parse(data);
+      });
+      if (ok && content) {
+        this.partitionUsage = new Map(Object.entries(content));
+      }
+    }
+    async _saveUsageStats() {
+      const statsObject = Object.fromEntries(this.partitionUsage);
+      await try_fn_default(async () => {
+        await writeFile(
+          this.usageStatsFile,
+          JSON.stringify(statsObject, null, 2),
+          "utf8"
+        );
+      });
+    }
+    async _writeFileWithMetadata(filePath, data) {
+      const content = JSON.stringify(data);
+      const [ok, err] = await try_fn_default(async () => {
+        await writeFile(filePath, content, {
+          encoding: this.encoding,
+          mode: this.fileMode
+        });
+      });
+      if (!ok) {
+        throw new Error(`Failed to write cache file: ${err.message}`);
+      }
+      return true;
+    }
+    async _readFileWithMetadata(filePath) {
+      const [ok, err, content] = await try_fn_default(async () => {
+        return await readFile(filePath, this.encoding);
+      });
+      if (!ok || !content) return null;
+      try {
+        return JSON.parse(content);
+      } catch (error) {
+        return { data: content };
+      }
+    }
+  }
+
   class CachePlugin extends plugin_class_default {
     constructor(options = {}) {
       super(options);
       this.driver = options.driver;
       this.config = {
         includePartitions: options.includePartitions !== false,
+        partitionStrategy: options.partitionStrategy || "hierarchical",
+        partitionAware: options.partitionAware !== false,
+        trackUsage: options.trackUsage !== false,
+        preloadRelated: options.preloadRelated !== false,
         ...options
       };
     }
@@ -6817,6 +7675,17 @@ ${JSON.stringify(validation, null, 2)}`,
         this.driver = this.config.driver;
       } else if (this.config.driverType === "memory") {
         this.driver = new memory_cache_class_default(this.config.memoryOptions || {});
+      } else if (this.config.driverType === "filesystem") {
+        if (this.config.partitionAware) {
+          this.driver = new PartitionAwareFilesystemCache({
+            partitionStrategy: this.config.partitionStrategy,
+            trackUsage: this.config.trackUsage,
+            preloadRelated: this.config.preloadRelated,
+            ...this.config.filesystemOptions
+          });
+        } else {
+          this.driver = new FilesystemCache(this.config.filesystemOptions || {});
+        }
       } else {
         this.driver = new s3_cache_class_default({ client: this.database.client, ...this.config.s3Options || {} });
       }
@@ -6857,6 +7726,20 @@ ${JSON.stringify(validation, null, 2)}`,
         const { action, params = {}, partition, partitionValues } = options;
         return this.generateCacheKey(resource, action, params, partition, partitionValues);
       };
+      if (this.driver instanceof PartitionAwareFilesystemCache) {
+        resource.clearPartitionCache = async (partition, partitionValues = {}) => {
+          return await this.driver.clearPartition(resource.name, partition, partitionValues);
+        };
+        resource.getPartitionCacheStats = async (partition = null) => {
+          return await this.driver.getPartitionStats(resource.name, partition);
+        };
+        resource.getCacheRecommendations = async () => {
+          return await this.driver.getCacheRecommendations(resource.name);
+        };
+        resource.warmPartitionCache = async (partitions = [], options = {}) => {
+          return await this.driver.warmPartitionCache(resource.name, { partitions, ...options });
+        };
+      }
       const cacheMethods = [
         "count",
         "listIds",
@@ -6882,12 +7765,37 @@ ${JSON.stringify(validation, null, 2)}`,
           } else if (method === "get") {
             key = await resource.cacheKeyFor({ action: method, params: { id: ctx.args[0] } });
           }
-          const [ok, err, cached] = await try_fn_default(() => resource.cache.get(key));
-          if (ok && cached !== null && cached !== void 0) return cached;
-          if (!ok && err.name !== "NoSuchKey") throw err;
-          const result = await next();
-          await resource.cache.set(key, result);
-          return result;
+          if (this.driver instanceof PartitionAwareFilesystemCache) {
+            let partition, partitionValues;
+            if (method === "list" || method === "listIds" || method === "count" || method === "page") {
+              const args = ctx.args[0] || {};
+              partition = args.partition;
+              partitionValues = args.partitionValues;
+            }
+            const [ok, err, result] = await try_fn_default(() => resource.cache._get(key, {
+              resource: resource.name,
+              action: method,
+              partition,
+              partitionValues
+            }));
+            if (ok && result !== null && result !== void 0) return result;
+            if (!ok && err.name !== "NoSuchKey") throw err;
+            const freshResult = await next();
+            await resource.cache._set(key, freshResult, {
+              resource: resource.name,
+              action: method,
+              partition,
+              partitionValues
+            });
+            return freshResult;
+          } else {
+            const [ok, err, result] = await try_fn_default(() => resource.cache.get(key));
+            if (ok && result !== null && result !== void 0) return result;
+            if (!ok && err.name !== "NoSuchKey") throw err;
+            const freshResult = await next();
+            await resource.cache.set(key, freshResult);
+            return freshResult;
+          }
         });
       }
       const writeMethods = ["insert", "update", "delete", "deleteMany"];
@@ -6980,6 +7888,10 @@ ${JSON.stringify(validation, null, 2)}`,
         throw new Error(`Resource '${resourceName}' not found`);
       }
       const { includePartitions = true } = options;
+      if (this.driver instanceof PartitionAwareFilesystemCache && resource.warmPartitionCache) {
+        const partitionNames = resource.config.partitions ? Object.keys(resource.config.partitions) : [];
+        return await resource.warmPartitionCache(partitionNames, options);
+      }
       await resource.getAll();
       if (includePartitions && resource.config.partitions) {
         for (const [partitionName, partitionDef] of Object.entries(resource.config.partitions)) {
@@ -7001,6 +7913,57 @@ ${JSON.stringify(validation, null, 2)}`,
         }
       }
     }
+    // Partition-specific methods
+    async getPartitionCacheStats(resourceName, partition = null) {
+      if (!(this.driver instanceof PartitionAwareFilesystemCache)) {
+        throw new Error("Partition cache statistics are only available with PartitionAwareFilesystemCache");
+      }
+      return await this.driver.getPartitionStats(resourceName, partition);
+    }
+    async getCacheRecommendations(resourceName) {
+      if (!(this.driver instanceof PartitionAwareFilesystemCache)) {
+        throw new Error("Cache recommendations are only available with PartitionAwareFilesystemCache");
+      }
+      return await this.driver.getCacheRecommendations(resourceName);
+    }
+    async clearPartitionCache(resourceName, partition, partitionValues = {}) {
+      if (!(this.driver instanceof PartitionAwareFilesystemCache)) {
+        throw new Error("Partition cache clearing is only available with PartitionAwareFilesystemCache");
+      }
+      return await this.driver.clearPartition(resourceName, partition, partitionValues);
+    }
+    async analyzeCacheUsage() {
+      if (!(this.driver instanceof PartitionAwareFilesystemCache)) {
+        return { message: "Cache usage analysis is only available with PartitionAwareFilesystemCache" };
+      }
+      const analysis = {
+        totalResources: Object.keys(this.database.resources).length,
+        resourceStats: {},
+        recommendations: {},
+        summary: {
+          mostUsedPartitions: [],
+          leastUsedPartitions: [],
+          suggestedOptimizations: []
+        }
+      };
+      for (const [resourceName, resource] of Object.entries(this.database.resources)) {
+        try {
+          analysis.resourceStats[resourceName] = await this.driver.getPartitionStats(resourceName);
+          analysis.recommendations[resourceName] = await this.driver.getCacheRecommendations(resourceName);
+        } catch (error) {
+          analysis.resourceStats[resourceName] = { error: error.message };
+        }
+      }
+      const allRecommendations = Object.values(analysis.recommendations).flat();
+      analysis.summary.mostUsedPartitions = allRecommendations.filter((r) => r.recommendation === "preload").sort((a, b) => b.priority - a.priority).slice(0, 5);
+      analysis.summary.leastUsedPartitions = allRecommendations.filter((r) => r.recommendation === "archive").slice(0, 5);
+      analysis.summary.suggestedOptimizations = [
+        `Consider preloading ${analysis.summary.mostUsedPartitions.length} high-usage partitions`,
+        `Archive ${analysis.summary.leastUsedPartitions.length} unused partitions`,
+        `Monitor cache hit rates for partition efficiency`
+      ];
+      return analysis;
+    }
   }
 
   const CostsPlugin = {
@@ -7177,24 +8140,29 @@ ${JSON.stringify(validation, null, 2)}`,
       resource._deleteMany = resource.deleteMany;
       this.wrapResourceMethod(resource, "insert", async (result, args, methodName) => {
         const [data] = args;
-        this.indexRecord(resource.name, result.id, data).catch(console.error);
+        this.indexRecord(resource.name, result.id, data).catch(() => {
+        });
         return result;
       });
       this.wrapResourceMethod(resource, "update", async (result, args, methodName) => {
         const [id, data] = args;
-        this.removeRecordFromIndex(resource.name, id).catch(console.error);
-        this.indexRecord(resource.name, id, result).catch(console.error);
+        this.removeRecordFromIndex(resource.name, id).catch(() => {
+        });
+        this.indexRecord(resource.name, id, result).catch(() => {
+        });
         return result;
       });
       this.wrapResourceMethod(resource, "delete", async (result, args, methodName) => {
         const [id] = args;
-        this.removeRecordFromIndex(resource.name, id).catch(console.error);
+        this.removeRecordFromIndex(resource.name, id).catch(() => {
+        });
         return result;
       });
       this.wrapResourceMethod(resource, "deleteMany", async (result, args, methodName) => {
         const [ids] = args;
         for (const id of ids) {
-          this.removeRecordFromIndex(resource.name, id).catch(console.error);
+          this.removeRecordFromIndex(resource.name, id).catch(() => {
+          });
         }
         return result;
       });
@@ -7684,7 +8652,8 @@ ${JSON.stringify(validation, null, 2)}`,
       }
       if (this.config.flushInterval > 0) {
         this.flushTimer = setInterval(() => {
-          this.flushMetrics().catch(console.error);
+          this.flushMetrics().catch(() => {
+          });
         }, this.config.flushInterval);
       }
     }
@@ -7756,9 +8725,6 @@ ${JSON.stringify(validation, null, 2)}`,
         }
         this.resetMetrics();
       });
-      if (!ok) {
-        console.error("Failed to flush metrics:", err);
-      }
     }
     resetMetrics() {
       for (const operation of Object.keys(this.metrics.operations)) {
@@ -10595,7 +11561,7 @@ ${JSON.stringify(validation, null, 2)}`,
         if (okParse) contentType = "application/json";
       }
       if (this.behavior === "body-only" && (!body || body === "")) {
-        throw new Error(`[Resource.insert] Tentativa de gravar objeto sem body! Dados: id=${finalId}, resource=${this.name}`);
+        throw new Error(`[Resource.insert] Attempt to save object without body! Data: id=${finalId}, resource=${this.name}`);
       }
       const [okPut, errPut, putResult] = await try_fn_default(() => this.client.putObject({
         key,
@@ -11942,8 +12908,8 @@ ${JSON.stringify(validation, null, 2)}`,
       return mappedData;
     }
     /**
-     * Compose the full object (metadata + body) as retornado por .get(),
-     * usando os dados em memória após insert/update, de acordo com o behavior
+     * Compose the full object (metadata + body) as returned by .get(),
+     * using in-memory data after insert/update, according to behavior
      */
     async composeFullObjectFromWrite({ id, metadata, body, behavior }) {
       const behaviorFlags = {};
@@ -12098,7 +13064,7 @@ ${JSON.stringify(validation, null, 2)}`,
       if (!this._middlewares.has(method)) throw new ResourceError(`No such method for middleware: ${method}`, { operation: "useMiddleware", method });
       this._middlewares.get(method).push(fn);
     }
-    // Utilitário para aplicar valores default do schema
+    // Utility to apply schema default values
     applyDefaults(data) {
       const out = { ...data };
       for (const [key, def] of Object.entries(this.attributes)) {
@@ -12230,7 +13196,7 @@ ${JSON.stringify(validation, null, 2)}`,
       super();
       this.version = "1";
       this.s3dbVersion = (() => {
-        const [ok, err, version] = try_fn_default(() => true ? "7.2.0" : "latest");
+        const [ok, err, version] = try_fn_default(() => true ? "7.3.2" : "latest");
         return ok ? version : "latest";
       })();
       this.resources = {};
@@ -12303,7 +13269,7 @@ ${JSON.stringify(validation, null, 2)}`,
             name,
             client: this.client,
             database: this,
-            // garantir referência
+            // ensure reference
             version: currentVersion,
             attributes: versionData.attributes,
             behavior: versionData.behavior || "user-managed",
@@ -12804,21 +13770,33 @@ ${JSON.stringify(validation, null, 2)}`,
         throw err;
       }
     }
-    // Change signature to accept id
-    async replicate({ resource, operation, data, id: explicitId }) {
+    // Support both object and parameter signatures for flexibility
+    async replicate(resourceOrObj, operation, data, recordId, beforeData) {
+      let resource, op, payload, id;
+      if (typeof resourceOrObj === "object" && resourceOrObj.resource) {
+        resource = resourceOrObj.resource;
+        op = resourceOrObj.operation;
+        payload = resourceOrObj.data;
+        id = resourceOrObj.id;
+      } else {
+        resource = resourceOrObj;
+        op = operation;
+        payload = data;
+        id = recordId;
+      }
       const normResource = normalizeResourceName$1(resource);
-      const destResource = this._resolveDestResource(normResource, data);
+      const destResource = this._resolveDestResource(normResource, payload);
       const destResourceObj = this._getDestResourceObj(destResource);
-      const transformedData = this._applyTransformer(normResource, data);
+      const transformedData = this._applyTransformer(normResource, payload);
       let result;
-      if (operation === "insert") {
+      if (op === "insert") {
         result = await destResourceObj.insert(transformedData);
-      } else if (operation === "update") {
-        result = await destResourceObj.update(explicitId, transformedData);
-      } else if (operation === "delete") {
-        result = await destResourceObj.delete(explicitId);
+      } else if (op === "update") {
+        result = await destResourceObj.update(id, transformedData);
+      } else if (op === "delete") {
+        result = await destResourceObj.delete(id);
       } else {
-        throw new Error(`Invalid operation: ${operation}. Supported operations are: insert, update, delete`);
+        throw new Error(`Invalid operation: ${op}. Supported operations are: insert, update, delete`);
       }
       return result;
     }
@@ -12851,7 +13829,7 @@ ${JSON.stringify(validation, null, 2)}`,
         if (typeof entry[0] === "function") return resource;
       }
       if (typeof entry === "string") return entry;
-      if (typeof entry === "function") return resource;
+      if (resource && !targetResourceName) targetResourceName = resource;
       if (typeof entry === "object" && entry.resource) return entry.resource;
       return resource;
     }
@@ -12964,7 +13942,6 @@ ${JSON.stringify(validation, null, 2)}`,
   class SqsReplicator extends base_replicator_class_default {
     constructor(config = {}, resources = [], client = null) {
       super(config);
-      this.resources = resources;
       this.client = client;
       this.queueUrl = config.queueUrl;
       this.queues = config.queues || {};
@@ -12973,12 +13950,24 @@ ${JSON.stringify(validation, null, 2)}`,
       this.sqsClient = client || null;
       this.messageGroupId = config.messageGroupId;
       this.deduplicationId = config.deduplicationId;
-      if (resources && typeof resources === "object") {
+      if (Array.isArray(resources)) {
+        this.resources = {};
+        for (const resource of resources) {
+          if (typeof resource === "string") {
+            this.resources[resource] = true;
+          } else if (typeof resource === "object" && resource.name) {
+            this.resources[resource.name] = resource;
+          }
+        }
+      } else if (typeof resources === "object") {
+        this.resources = resources;
         for (const [resourceName, resourceConfig] of Object.entries(resources)) {
-          if (resourceConfig.queueUrl) {
+          if (resourceConfig && resourceConfig.queueUrl) {
             this.queues[resourceName] = resourceConfig.queueUrl;
           }
         }
+      } else {
+        this.resources = {};
       }
     }
     validateConfig() {
@@ -13214,7 +14203,7 @@ ${JSON.stringify(validation, null, 2)}`,
         connected: !!this.sqsClient,
         queueUrl: this.queueUrl,
         region: this.region,
-        resources: this.resources,
+        resources: Object.keys(this.resources || {}),
         totalreplicators: this.listenerCount("replicated"),
         totalErrors: this.listenerCount("replicator_error")
       };
@@ -13252,33 +14241,28 @@ ${JSON.stringify(validation, null, 2)}`,
   class ReplicatorPlugin extends plugin_class_default {
     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);
-      }
       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");
       }
       this.config = {
-        verbose: options.verbose ?? false,
-        persistReplicatorLog: options.persistReplicatorLog ?? false,
-        replicatorLogResource: options.replicatorLogResource ?? "replicator_logs",
-        replicators: options.replicators || []
+        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 || 3e4,
+        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 = /* @__PURE__ */ new Set();
     }
     /**
      * Decompress data if it was compressed
@@ -13297,79 +14281,34 @@ ${JSON.stringify(validation, null, 2)}`,
       }
       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])
-        });
-      }
-      if (!resource || resource.name === plugin.config.replicatorLogResource || !resource.database || resource.database !== plugin.database) return;
-      if (resource._replicatorListenersInstalled) return;
-      resource._replicatorListenersInstalled = true;
-      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;
       }
       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: (/* @__PURE__ */ 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 });
         }
       });
-      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 {
-          let completeData;
-          const [ok, err, record] = await try_fn_default(() => 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: (/* @__PURE__ */ 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 });
         }
       });
-      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);
     }
     /**
      * Get complete data by always fetching the full record from the resource
@@ -13380,112 +14319,58 @@ ${JSON.stringify(validation, null, 2)}`,
       return ok ? completeRecord : data;
     }
     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;
-      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;
-        if (this.config.verbose) {
-          console.log("[PLUGIN] Log resource created and registered:", this.config.replicatorLogResource, !!database.resources[normalizeResourceName(this.config.replicatorLogResource)]);
-        }
-        if (typeof database.uploadMetadataFile === "function") {
-          await database.uploadMetadataFile();
-          if (this.config.verbose) {
-            console.log("[PLUGIN] uploadMetadataFile called. database.resources keys:", Object.keys(database.resources));
-          }
-        }
-      }
-      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 })));
-        }
-      }
-      for (const resourceName in database.resources) {
-        if (normalizeResourceName(resourceName) !== normalizeResourceName(this.config.replicatorLogResource)) {
-          this.installEventListeners(database.resources[resourceName]);
         }
+      } catch (error) {
       }
-      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) {
-            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;
+        const replicatorResources = resources || config.resources || {};
+        const mergedConfig = { ...config, ...otherConfig };
+        const replicator = this.createReplicator(driver, mergedConfig, replicatorResources, client);
+        if (replicator) {
+          await replicator.initialize(database);
+          this.replicators.push(replicator);
         }
       }
     }
@@ -13493,160 +14378,162 @@ ${JSON.stringify(validation, null, 2)}`,
     }
     async stop() {
     }
-    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)) {
+        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 try_fn_default(() => resource.get(data.id));
+        if (ok && record) {
+          return record;
+        }
+      } catch (error) {
       }
-      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;
+          }
+          const delay = Math.pow(2, attempt - 1) * 1e3;
+          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: (/* @__PURE__ */ new Date()).toISOString(),
+            status: "error"
+          });
         }
+      } catch (logError) {
+      }
+    }
+    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;
       }
-      const filteredData = this.filterInternalFields(lodashEs.isPlainObject(data) ? data : { raw: data });
-      const filteredBeforeData = beforeData ? this.filterInternalFields(lodashEs.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: (/* @__PURE__ */ new Date()).toISOString(),
-        attempts: 0
-      };
-      const logId = await this.logreplicator(item);
-      const [ok, err, result] = await try_fn_default(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 try_fn_default(
+            () => 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
           });
+          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
+          });
+          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 };
         }
-        if (replicator.instance && replicator.instance.constructor && replicator.instance.constructor.name === "S3dbReplicator") {
-          [ok, err, result] = await try_fn_default(
-            () => replicator.instance.replicate({
-              resource: item.resourceName,
-              operation: item.operation,
-              data: item.data,
-              id: item.recordId,
-              beforeData: item.beforeData
-            })
-          );
-        } else {
-          [ok, err, result] = await try_fn_default(
-            () => replicator.instance.replicate(
-              item.resourceName,
-              item.operation,
-              item.data,
-              item.recordId,
-              item.beforeData
-            )
-          );
-        }
-        results.push({
-          replicatorId: replicator.id,
-          driver: replicator.driver,
-          success: result && result.success,
-          error: result && result.error,
-          skipped: result && result.skipped
-        });
-      }
-      return {
-        success: results.every((r) => r.success || r.skipped),
-        results
-      };
+      });
+      return Promise.allSettled(promises);
     }
     async logreplicator(item) {
       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);
-            }
-          }
+          if (this.database.options && this.database.options.connectionString) ;
         }
         this.emit("replicator.log.failed", { error: "replicator log resource not found", item });
         return;
@@ -13662,9 +14549,6 @@ ${JSON.stringify(validation, null, 2)}`,
       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 });
       }
     }
@@ -13684,7 +14568,7 @@ ${JSON.stringify(validation, null, 2)}`,
     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,
@@ -13746,10 +14630,6 @@ ${JSON.stringify(validation, null, 2)}`,
         });
         if (ok) {
           retried++;
-        } else {
-          if (this.config.verbose) {
-            console.error("Failed to retry replicator:", err);
-          }
         }
       }
       return { retried };
@@ -13762,52 +14642,35 @@ ${JSON.stringify(validation, null, 2)}`,
       this.stats.lastSync = (/* @__PURE__ */ new Date()).toISOString();
       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);
           }
         }
       }
       this.emit("replicator.sync.completed", { replicatorId, stats: this.stats });
     }
     async cleanup() {
-      if (this.config.verbose) {
-        console.log("[PLUGIN][CLEANUP] Cleaning up ReplicatorPlugin");
-      }
-      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 = [];
-      }
-      if (this.database && typeof this.database.removeAllListeners === "function") {
-        this.database.removeAllListeners();
-      }
-      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) {
+            }
+          });
+          await Promise.allSettled(cleanupPromises);
         }
         this.replicators = [];
-      }
-      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) {
       }
     }
   }