s3db.js 7.2.1 → 7.3.2

package/dist/s3db.cjs.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var nanoid = require('nanoid');
-var zlib = require('zlib');
+var zlib = require('node:zlib');
 var promisePool = require('@supercharge/promise-pool');
 var web = require('node:stream/web');
 var lodashEs = require('lodash-es');
@@ -1345,7 +1345,8 @@ class AuditPlugin extends plugin_class_default {
           version: "2.0"
         })
       };
-      this.logAudit(auditRecord).catch(console.error);
+      this.logAudit(auditRecord).catch(() => {
+      });
     });
     resource.on("update", async (data) => {
       const recordId = data.id;
@@ -1371,7 +1372,8 @@ class AuditPlugin extends plugin_class_default {
           version: "2.0"
         })
       };
-      this.logAudit(auditRecord).catch(console.error);
+      this.logAudit(auditRecord).catch(() => {
+      });
     });
     resource.on("delete", async (data) => {
       const recordId = data.id;
@@ -1397,7 +1399,8 @@ class AuditPlugin extends plugin_class_default {
           version: "2.0"
         })
       };
-      this.logAudit(auditRecord).catch(console.error);
+      this.logAudit(auditRecord).catch(() => {
+      });
     });
     resource.useMiddleware("deleteMany", async (ctx, next) => {
       const ids = ctx.args[0];
@@ -1430,7 +1433,8 @@ class AuditPlugin extends plugin_class_default {
               batchOperation: true
             })
           };
-          this.logAudit(auditRecord).catch(console.error);
+          this.logAudit(auditRecord).catch(() => {
+          });
         }
       }
       return result;
@@ -2077,6 +2081,16 @@ if (typeof Object.create === 'function'){
 // 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)) {
@@ -2562,6 +2576,64 @@ function hasOwnProperty(obj, prop) {
   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;
@@ -6812,12 +6884,798 @@ class MemoryCache extends Cache {
 }
 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
     };
   }
@@ -6829,6 +7687,17 @@ class CachePlugin extends plugin_class_default {
       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 || {} });
     }
@@ -6869,6 +7738,20 @@ class CachePlugin extends plugin_class_default {
       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",
@@ -6894,12 +7777,37 @@ class CachePlugin extends plugin_class_default {
         } 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"];
@@ -6992,6 +7900,10 @@ class CachePlugin extends plugin_class_default {
       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)) {
@@ -7013,6 +7925,57 @@ class CachePlugin extends plugin_class_default {
       }
     }
   }
+  // 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 = {
@@ -7189,24 +8152,29 @@ class FullTextPlugin extends plugin_class_default {
     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;
     });
@@ -7696,7 +8664,8 @@ class MetricsPlugin extends plugin_class_default {
     }
     if (this.config.flushInterval > 0) {
       this.flushTimer = setInterval(() => {
-        this.flushMetrics().catch(console.error);
+        this.flushMetrics().catch(() => {
+        });
       }, this.config.flushInterval);
     }
   }
@@ -7768,9 +8737,6 @@ class MetricsPlugin extends plugin_class_default {
       }
       this.resetMetrics();
     });
-    if (!ok) {
-      console.error("Failed to flush metrics:", err);
-    }
   }
   resetMetrics() {
     for (const operation of Object.keys(this.metrics.operations)) {
@@ -10607,7 +11573,7 @@ class Resource extends EventEmitter {
       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,
@@ -11954,8 +12920,8 @@ class Resource extends EventEmitter {
     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 = {};
@@ -12110,7 +13076,7 @@ class Resource extends EventEmitter {
     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)) {
@@ -12242,7 +13208,7 @@ class Database extends EventEmitter {
     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 = {};
@@ -12315,7 +13281,7 @@ class Database extends EventEmitter {
           name,
           client: this.client,
           database: this,
-          // garantir referência
+          // ensure reference
           version: currentVersion,
           attributes: versionData.attributes,
           behavior: versionData.behavior || "user-managed",
@@ -12816,21 +13782,33 @@ class S3dbReplicator extends base_replicator_class_default {
       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;
   }
@@ -12863,7 +13841,7 @@ class S3dbReplicator extends base_replicator_class_default {
       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;
   }
@@ -12976,7 +13954,6 @@ var s3db_replicator_class_default = S3dbReplicator;
 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 || {};
@@ -12985,12 +13962,24 @@ class SqsReplicator extends base_replicator_class_default {
     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() {
@@ -13226,7 +14215,7 @@ class SqsReplicator extends base_replicator_class_default {
       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")
     };
@@ -13264,33 +14253,28 @@ function normalizeResourceName(name) {
 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
@@ -13309,79 +14293,34 @@ class ReplicatorPlugin extends plugin_class_default {
     }
     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
@@ -13392,112 +14331,58 @@ class ReplicatorPlugin extends plugin_class_default {
     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);
       }
     }
   }
@@ -13505,160 +14390,162 @@ class ReplicatorPlugin extends plugin_class_default {
   }
   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;
@@ -13674,9 +14561,6 @@ class ReplicatorPlugin extends plugin_class_default {
     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 });
     }
   }
@@ -13696,7 +14580,7 @@ class ReplicatorPlugin extends plugin_class_default {
   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,
@@ -13758,10 +14642,6 @@ class ReplicatorPlugin extends plugin_class_default {
       });
       if (ok) {
         retried++;
-      } else {
-        if (this.config.verbose) {
-          console.error("Failed to retry replicator:", err);
-        }
       }
     }
     return { retried };
@@ -13774,52 +14654,35 @@ class ReplicatorPlugin extends plugin_class_default {
     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) {
     }
   }
 }