s3db.js 7.3.1 → 7.3.3

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,186 +6872,1026 @@ ${JSON.stringify(validation, null, 2)}`,
   }
   var memory_cache_class_default = MemoryCache;
 
-  class CachePlugin extends plugin_class_default {
-    constructor(options = {}) {
-      super(options);
-      this.driver = options.driver;
-      this.config = {
-        includePartitions: options.includePartitions !== false,
-        ...options
+  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
       };
-    }
-    async setup(database) {
-      await super.setup(database);
-    }
-    async onSetup() {
-      if (this.config.driver) {
-        this.driver = this.config.driver;
-      } else if (this.config.driverType === "memory") {
-        this.driver = new memory_cache_class_default(this.config.memoryOptions || {});
-      } else {
-        this.driver = new s3_cache_class_default({ client: this.database.client, ...this.config.s3Options || {} });
+      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);
       }
-      this.installDatabaseProxy();
-      this.installResourceHooks();
     }
-    async onStart() {
+    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}`);
+      }
     }
-    async onStop() {
+    _getFilePath(key) {
+      const sanitizedKey = key.replace(/[<>:"/\\|?*]/g, "_");
+      const filename = `${this.prefix}_${sanitizedKey}${this.fileExtension}`;
+      return path.join(this.directory, filename);
     }
-    installDatabaseProxy() {
-      if (this.database._cacheProxyInstalled) {
-        return;
-      }
-      const installResourceHooks = this.installResourceHooks.bind(this);
-      this.database._originalCreateResourceForCache = this.database.createResource;
-      this.database.createResource = async function(...args) {
-        const resource = await this._originalCreateResourceForCache(...args);
-        installResourceHooks(resource);
-        return resource;
-      };
-      this.database._cacheProxyInstalled = true;
+    _getMetadataPath(filePath) {
+      return filePath + ".meta";
     }
-    installResourceHooks() {
-      for (const resource of Object.values(this.database.resources)) {
-        this.installResourceHooksForResource(resource);
+    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}`);
       }
     }
-    installResourceHooksForResource(resource) {
-      if (!this.driver) return;
-      Object.defineProperty(resource, "cache", {
-        value: this.driver,
-        writable: true,
-        configurable: true,
-        enumerable: false
-      });
-      resource.cacheKeyFor = async (options = {}) => {
-        const { action, params = {}, partition, partitionValues } = options;
-        return this.generateCacheKey(resource, action, params, partition, partitionValues);
-      };
-      const cacheMethods = [
-        "count",
-        "listIds",
-        "getMany",
-        "getAll",
-        "page",
-        "list",
-        "get"
-      ];
-      for (const method of cacheMethods) {
-        resource.useMiddleware(method, async (ctx, next) => {
-          let key;
-          if (method === "getMany") {
-            key = await resource.cacheKeyFor({ action: method, params: { ids: ctx.args[0] } });
-          } else if (method === "page") {
-            const { offset, size, partition, partitionValues } = ctx.args[0] || {};
-            key = await resource.cacheKeyFor({ action: method, params: { offset, size }, partition, partitionValues });
-          } else if (method === "list" || method === "listIds" || method === "count") {
-            const { partition, partitionValues } = ctx.args[0] || {};
-            key = await resource.cacheKeyFor({ action: method, partition, partitionValues });
-          } else if (method === "getAll") {
-            key = await resource.cacheKeyFor({ action: method });
-          } else if (method === "get") {
-            key = await resource.cacheKeyFor({ action: method, params: { id: ctx.args[0] } });
+    async _get(key) {
+      const filePath = this._getFilePath(key);
+      try {
+        if (!await this._fileExists(filePath)) {
+          if (this.enableStats) {
+            this.stats.misses++;
           }
-          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;
-        });
-      }
-      const writeMethods = ["insert", "update", "delete", "deleteMany"];
-      for (const method of writeMethods) {
-        resource.useMiddleware(method, async (ctx, next) => {
-          const result = await next();
-          if (method === "insert") {
-            await this.clearCacheForResource(resource, ctx.args[0]);
-          } else if (method === "update") {
-            await this.clearCacheForResource(resource, { id: ctx.args[0], ...ctx.args[1] });
-          } else if (method === "delete") {
-            let data = { id: ctx.args[0] };
-            if (typeof resource.get === "function") {
-              const [ok, err, full] = await try_fn_default(() => resource.get(ctx.args[0]));
-              if (ok && full) data = full;
+          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;
             }
-            await this.clearCacheForResource(resource, data);
-          } else if (method === "deleteMany") {
-            await this.clearCacheForResource(resource);
           }
-          return result;
-        });
-      }
-    }
-    async clearCacheForResource(resource, data) {
-      if (!resource.cache) return;
-      const keyPrefix = `resource=${resource.name}`;
-      await resource.cache.clear(keyPrefix);
-      if (this.config.includePartitions === true && resource.config?.partitions && Object.keys(resource.config.partitions).length > 0) {
-        if (!data) {
-          for (const partitionName of Object.keys(resource.config.partitions)) {
-            const partitionKeyPrefix = join(keyPrefix, `partition=${partitionName}`);
-            await resource.cache.clear(partitionKeyPrefix);
+        } 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++;
           }
-        } else {
-          const partitionValues = this.getPartitionValues(data, resource);
-          for (const [partitionName, values] of Object.entries(partitionValues)) {
-            if (values && Object.keys(values).length > 0 && Object.values(values).some((v) => v !== null && v !== void 0)) {
-              const partitionKeyPrefix = join(keyPrefix, `partition=${partitionName}`);
-              await resource.cache.clear(partitionKeyPrefix);
+          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 generateCacheKey(resource, action, params = {}, partition = null, partitionValues = null) {
-      const keyParts = [
-        `resource=${resource.name}`,
-        `action=${action}`
-      ];
-      if (partition && partitionValues && Object.keys(partitionValues).length > 0) {
-        keyParts.push(`partition:${partition}`);
-        for (const [field, value] of Object.entries(partitionValues)) {
-          if (value !== null && value !== void 0) {
-            keyParts.push(`${field}:${value}`);
+    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}`);
       }
-      if (Object.keys(params).length > 0) {
-        const paramsHash = await this.hashParams(params);
-        keyParts.push(paramsHash);
-      }
-      return join(...keyParts) + ".json.gz";
-    }
-    async hashParams(params) {
-      const sortedParams = Object.keys(params).sort().map((key) => `${key}:${params[key]}`).join("|") || "empty";
-      return await sha256(sortedParams);
-    }
-    // Utility methods
-    async getCacheStats() {
-      if (!this.driver) return null;
-      return {
-        size: await this.driver.size(),
-        keys: await this.driver.keys(),
-        driver: this.driver.constructor.name
-      };
     }
-    async clearAllCache() {
-      if (!this.driver) return;
-      for (const resource of Object.values(this.database.resources)) {
-        if (resource.cache) {
-          const keyPrefix = `resource=${resource.name}`;
-          await resource.cache.clear(keyPrefix);
+    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 warmCache(resourceName, options = {}) {
-      const resource = this.database.resources[resourceName];
-      if (!resource) {
-        throw new Error(`Resource '${resourceName}' not found`);
-      }
-      const { includePartitions = true } = options;
+    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.rm);
+  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
+      };
+    }
+    async setup(database) {
+      await super.setup(database);
+    }
+    async onSetup() {
+      if (this.config.driver) {
+        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 || {} });
+      }
+      this.installDatabaseProxy();
+      this.installResourceHooks();
+    }
+    async onStart() {
+    }
+    async onStop() {
+    }
+    installDatabaseProxy() {
+      if (this.database._cacheProxyInstalled) {
+        return;
+      }
+      const installResourceHooks = this.installResourceHooks.bind(this);
+      this.database._originalCreateResourceForCache = this.database.createResource;
+      this.database.createResource = async function(...args) {
+        const resource = await this._originalCreateResourceForCache(...args);
+        installResourceHooks(resource);
+        return resource;
+      };
+      this.database._cacheProxyInstalled = true;
+    }
+    installResourceHooks() {
+      for (const resource of Object.values(this.database.resources)) {
+        this.installResourceHooksForResource(resource);
+      }
+    }
+    installResourceHooksForResource(resource) {
+      if (!this.driver) return;
+      Object.defineProperty(resource, "cache", {
+        value: this.driver,
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+      resource.cacheKeyFor = async (options = {}) => {
+        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",
+        "getMany",
+        "getAll",
+        "page",
+        "list",
+        "get"
+      ];
+      for (const method of cacheMethods) {
+        resource.useMiddleware(method, async (ctx, next) => {
+          let key;
+          if (method === "getMany") {
+            key = await resource.cacheKeyFor({ action: method, params: { ids: ctx.args[0] } });
+          } else if (method === "page") {
+            const { offset, size, partition, partitionValues } = ctx.args[0] || {};
+            key = await resource.cacheKeyFor({ action: method, params: { offset, size }, partition, partitionValues });
+          } else if (method === "list" || method === "listIds" || method === "count") {
+            const { partition, partitionValues } = ctx.args[0] || {};
+            key = await resource.cacheKeyFor({ action: method, partition, partitionValues });
+          } else if (method === "getAll") {
+            key = await resource.cacheKeyFor({ action: method });
+          } else if (method === "get") {
+            key = await resource.cacheKeyFor({ action: method, params: { id: ctx.args[0] } });
+          }
+          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"];
+      for (const method of writeMethods) {
+        resource.useMiddleware(method, async (ctx, next) => {
+          const result = await next();
+          if (method === "insert") {
+            await this.clearCacheForResource(resource, ctx.args[0]);
+          } else if (method === "update") {
+            await this.clearCacheForResource(resource, { id: ctx.args[0], ...ctx.args[1] });
+          } else if (method === "delete") {
+            let data = { id: ctx.args[0] };
+            if (typeof resource.get === "function") {
+              const [ok, err, full] = await try_fn_default(() => resource.get(ctx.args[0]));
+              if (ok && full) data = full;
+            }
+            await this.clearCacheForResource(resource, data);
+          } else if (method === "deleteMany") {
+            await this.clearCacheForResource(resource);
+          }
+          return result;
+        });
+      }
+    }
+    async clearCacheForResource(resource, data) {
+      if (!resource.cache) return;
+      const keyPrefix = `resource=${resource.name}`;
+      await resource.cache.clear(keyPrefix);
+      if (this.config.includePartitions === true && resource.config?.partitions && Object.keys(resource.config.partitions).length > 0) {
+        if (!data) {
+          for (const partitionName of Object.keys(resource.config.partitions)) {
+            const partitionKeyPrefix = join(keyPrefix, `partition=${partitionName}`);
+            await resource.cache.clear(partitionKeyPrefix);
+          }
+        } else {
+          const partitionValues = this.getPartitionValues(data, resource);
+          for (const [partitionName, values] of Object.entries(partitionValues)) {
+            if (values && Object.keys(values).length > 0 && Object.values(values).some((v) => v !== null && v !== void 0)) {
+              const partitionKeyPrefix = join(keyPrefix, `partition=${partitionName}`);
+              await resource.cache.clear(partitionKeyPrefix);
+            }
+          }
+        }
+      }
+    }
+    async generateCacheKey(resource, action, params = {}, partition = null, partitionValues = null) {
+      const keyParts = [
+        `resource=${resource.name}`,
+        `action=${action}`
+      ];
+      if (partition && partitionValues && Object.keys(partitionValues).length > 0) {
+        keyParts.push(`partition:${partition}`);
+        for (const [field, value] of Object.entries(partitionValues)) {
+          if (value !== null && value !== void 0) {
+            keyParts.push(`${field}:${value}`);
+          }
+        }
+      }
+      if (Object.keys(params).length > 0) {
+        const paramsHash = await this.hashParams(params);
+        keyParts.push(paramsHash);
+      }
+      return join(...keyParts) + ".json.gz";
+    }
+    async hashParams(params) {
+      const sortedParams = Object.keys(params).sort().map((key) => `${key}:${params[key]}`).join("|") || "empty";
+      return await sha256(sortedParams);
+    }
+    // Utility methods
+    async getCacheStats() {
+      if (!this.driver) return null;
+      return {
+        size: await this.driver.size(),
+        keys: await this.driver.keys(),
+        driver: this.driver.constructor.name
+      };
+    }
+    async clearAllCache() {
+      if (!this.driver) return;
+      for (const resource of Object.values(this.database.resources)) {
+        if (resource.cache) {
+          const keyPrefix = `resource=${resource.name}`;
+          await resource.cache.clear(keyPrefix);
+        }
+      }
+    }
+    async warmCache(resourceName, options = {}) {
+      const resource = this.database.resources[resourceName];
+      if (!resource) {
+        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)) {
@@ -7890,20 +8856,628 @@ ${JSON.stringify(validation, null, 2)}`,
           await this.metricsResource.delete(metric.id);
         }
       }
-      if (this.errorsResource) {
-        const oldErrors = await this.getErrorLogs({ endDate: cutoffDate.toISOString() });
-        for (const error of oldErrors) {
-          await this.errorsResource.delete(error.id);
-        }
+      if (this.errorsResource) {
+        const oldErrors = await this.getErrorLogs({ endDate: cutoffDate.toISOString() });
+        for (const error of oldErrors) {
+          await this.errorsResource.delete(error.id);
+        }
+      }
+      if (this.performanceResource) {
+        const oldPerformance = await this.getPerformanceLogs({ endDate: cutoffDate.toISOString() });
+        for (const perf of oldPerformance) {
+          await this.performanceResource.delete(perf.id);
+        }
+      }
+    }
+  }
+
+  class BaseReplicator extends EventEmitter {
+    constructor(config = {}) {
+      super();
+      this.config = config;
+      this.name = this.constructor.name;
+      this.enabled = config.enabled !== false;
+    }
+    /**
+     * Initialize the replicator
+     * @param {Object} database - The s3db database instance
+     * @returns {Promise<void>}
+     */
+    async initialize(database) {
+      this.database = database;
+      this.emit("initialized", { replicator: this.name });
+    }
+    /**
+     * Replicate data to the target
+     * @param {string} resourceName - Name of the resource being replicated
+     * @param {string} operation - Operation type (insert, update, delete)
+     * @param {Object} data - The data to replicate
+     * @param {string} id - Record ID
+     * @returns {Promise<Object>} replicator result
+     */
+    async replicate(resourceName, operation, data, id) {
+      throw new Error(`replicate() method must be implemented by ${this.name}`);
+    }
+    /**
+     * Replicate multiple records in batch
+     * @param {string} resourceName - Name of the resource being replicated
+     * @param {Array} records - Array of records to replicate
+     * @returns {Promise<Object>} Batch replicator result
+     */
+    async replicateBatch(resourceName, records) {
+      throw new Error(`replicateBatch() method must be implemented by ${this.name}`);
+    }
+    /**
+     * Test the connection to the target
+     * @returns {Promise<boolean>} True if connection is successful
+     */
+    async testConnection() {
+      throw new Error(`testConnection() method must be implemented by ${this.name}`);
+    }
+    /**
+     * Get replicator status and statistics
+     * @returns {Promise<Object>} Status information
+     */
+    async getStatus() {
+      return {
+        name: this.name,
+        // Removed: enabled: this.enabled,
+        config: this.config,
+        connected: false
+      };
+    }
+    /**
+     * Cleanup resources
+     * @returns {Promise<void>}
+     */
+    async cleanup() {
+      this.emit("cleanup", { replicator: this.name });
+    }
+    /**
+     * Validate replicator configuration
+     * @returns {Object} Validation result
+     */
+    validateConfig() {
+      return { isValid: true, errors: [] };
+    }
+  }
+  var base_replicator_class_default = BaseReplicator;
+
+  class BigqueryReplicator extends base_replicator_class_default {
+    constructor(config = {}, resources = {}) {
+      super(config);
+      this.projectId = config.projectId;
+      this.datasetId = config.datasetId;
+      this.bigqueryClient = null;
+      this.credentials = config.credentials;
+      this.location = config.location || "US";
+      this.logTable = config.logTable;
+      this.resources = this.parseResourcesConfig(resources);
+    }
+    parseResourcesConfig(resources) {
+      const parsed = {};
+      for (const [resourceName, config] of Object.entries(resources)) {
+        if (typeof config === "string") {
+          parsed[resourceName] = [{
+            table: config,
+            actions: ["insert"],
+            transform: null
+          }];
+        } else if (Array.isArray(config)) {
+          parsed[resourceName] = config.map((item) => {
+            if (typeof item === "string") {
+              return { table: item, actions: ["insert"], transform: null };
+            }
+            return {
+              table: item.table,
+              actions: item.actions || ["insert"],
+              transform: item.transform || null
+            };
+          });
+        } else if (typeof config === "object") {
+          parsed[resourceName] = [{
+            table: config.table,
+            actions: config.actions || ["insert"],
+            transform: config.transform || null
+          }];
+        }
+      }
+      return parsed;
+    }
+    validateConfig() {
+      const errors = [];
+      if (!this.projectId) errors.push("projectId is required");
+      if (!this.datasetId) errors.push("datasetId is required");
+      if (Object.keys(this.resources).length === 0) errors.push("At least one resource must be configured");
+      for (const [resourceName, tables] of Object.entries(this.resources)) {
+        for (const tableConfig of tables) {
+          if (!tableConfig.table) {
+            errors.push(`Table name is required for resource '${resourceName}'`);
+          }
+          if (!Array.isArray(tableConfig.actions) || tableConfig.actions.length === 0) {
+            errors.push(`Actions array is required for resource '${resourceName}'`);
+          }
+          const validActions = ["insert", "update", "delete"];
+          const invalidActions = tableConfig.actions.filter((action) => !validActions.includes(action));
+          if (invalidActions.length > 0) {
+            errors.push(`Invalid actions for resource '${resourceName}': ${invalidActions.join(", ")}. Valid actions: ${validActions.join(", ")}`);
+          }
+          if (tableConfig.transform && typeof tableConfig.transform !== "function") {
+            errors.push(`Transform must be a function for resource '${resourceName}'`);
+          }
+        }
+      }
+      return { isValid: errors.length === 0, errors };
+    }
+    async initialize(database) {
+      await super.initialize(database);
+      const [ok, err, sdk] = await try_fn_default(() => import('@google-cloud/bigquery'));
+      if (!ok) {
+        this.emit("initialization_error", { replicator: this.name, error: err.message });
+        throw err;
+      }
+      const { BigQuery } = sdk;
+      this.bigqueryClient = new BigQuery({
+        projectId: this.projectId,
+        credentials: this.credentials,
+        location: this.location
+      });
+      this.emit("initialized", {
+        replicator: this.name,
+        projectId: this.projectId,
+        datasetId: this.datasetId,
+        resources: Object.keys(this.resources)
+      });
+    }
+    shouldReplicateResource(resourceName) {
+      return this.resources.hasOwnProperty(resourceName);
+    }
+    shouldReplicateAction(resourceName, operation) {
+      if (!this.resources[resourceName]) return false;
+      return this.resources[resourceName].some(
+        (tableConfig) => tableConfig.actions.includes(operation)
+      );
+    }
+    getTablesForResource(resourceName, operation) {
+      if (!this.resources[resourceName]) return [];
+      return this.resources[resourceName].filter((tableConfig) => tableConfig.actions.includes(operation)).map((tableConfig) => ({
+        table: tableConfig.table,
+        transform: tableConfig.transform
+      }));
+    }
+    applyTransform(data, transformFn) {
+      if (!transformFn) return data;
+      let transformedData = JSON.parse(JSON.stringify(data));
+      if (transformedData._length) delete transformedData._length;
+      return transformFn(transformedData);
+    }
+    async replicate(resourceName, operation, data, id, beforeData = null) {
+      if (!this.enabled || !this.shouldReplicateResource(resourceName)) {
+        return { skipped: true, reason: "resource_not_included" };
+      }
+      if (!this.shouldReplicateAction(resourceName, operation)) {
+        return { skipped: true, reason: "action_not_included" };
+      }
+      const tableConfigs = this.getTablesForResource(resourceName, operation);
+      if (tableConfigs.length === 0) {
+        return { skipped: true, reason: "no_tables_for_action" };
+      }
+      const results = [];
+      const errors = [];
+      const [ok, err, result] = await try_fn_default(async () => {
+        const dataset = this.bigqueryClient.dataset(this.datasetId);
+        for (const tableConfig of tableConfigs) {
+          const [okTable, errTable] = await try_fn_default(async () => {
+            const table = dataset.table(tableConfig.table);
+            let job;
+            if (operation === "insert") {
+              const transformedData = this.applyTransform(data, tableConfig.transform);
+              job = await table.insert([transformedData]);
+            } else if (operation === "update") {
+              const transformedData = this.applyTransform(data, tableConfig.transform);
+              const keys = Object.keys(transformedData).filter((k) => k !== "id");
+              const setClause = keys.map((k) => `${k} = @${k}`).join(", ");
+              const params = { id, ...transformedData };
+              const query = `UPDATE \`${this.projectId}.${this.datasetId}.${tableConfig.table}\` SET ${setClause} WHERE id = @id`;
+              const maxRetries = 2;
+              let lastError = null;
+              for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                try {
+                  const [updateJob] = await this.bigqueryClient.createQueryJob({
+                    query,
+                    params,
+                    location: this.location
+                  });
+                  await updateJob.getQueryResults();
+                  job = [updateJob];
+                  break;
+                } catch (error) {
+                  lastError = error;
+                  if (error?.message?.includes("streaming buffer") && attempt < maxRetries) {
+                    const delaySeconds = 30;
+                    await new Promise((resolve) => setTimeout(resolve, delaySeconds * 1e3));
+                    continue;
+                  }
+                  throw error;
+                }
+              }
+              if (!job) throw lastError;
+            } else if (operation === "delete") {
+              const query = `DELETE FROM \`${this.projectId}.${this.datasetId}.${tableConfig.table}\` WHERE id = @id`;
+              const [deleteJob] = await this.bigqueryClient.createQueryJob({
+                query,
+                params: { id },
+                location: this.location
+              });
+              await deleteJob.getQueryResults();
+              job = [deleteJob];
+            } else {
+              throw new Error(`Unsupported operation: ${operation}`);
+            }
+            results.push({
+              table: tableConfig.table,
+              success: true,
+              jobId: job[0]?.id
+            });
+          });
+          if (!okTable) {
+            errors.push({
+              table: tableConfig.table,
+              error: errTable.message
+            });
+          }
+        }
+        if (this.logTable) {
+          const [okLog, errLog] = await try_fn_default(async () => {
+            const logTable = dataset.table(this.logTable);
+            await logTable.insert([{
+              resource_name: resourceName,
+              operation,
+              record_id: id,
+              data: JSON.stringify(data),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              source: "s3db-replicator"
+            }]);
+          });
+          if (!okLog) {
+          }
+        }
+        const success = errors.length === 0;
+        this.emit("replicated", {
+          replicator: this.name,
+          resourceName,
+          operation,
+          id,
+          tables: tableConfigs.map((t) => t.table),
+          results,
+          errors,
+          success
+        });
+        return {
+          success,
+          results,
+          errors,
+          tables: tableConfigs.map((t) => t.table)
+        };
+      });
+      if (ok) return result;
+      this.emit("replicator_error", {
+        replicator: this.name,
+        resourceName,
+        operation,
+        id,
+        error: err.message
+      });
+      return { success: false, error: err.message };
+    }
+    async replicateBatch(resourceName, records) {
+      const results = [];
+      const errors = [];
+      for (const record of records) {
+        const [ok, err, res] = await try_fn_default(() => this.replicate(
+          resourceName,
+          record.operation,
+          record.data,
+          record.id,
+          record.beforeData
+        ));
+        if (ok) results.push(res);
+        else errors.push({ id: record.id, error: err.message });
+      }
+      return {
+        success: errors.length === 0,
+        results,
+        errors
+      };
+    }
+    async testConnection() {
+      const [ok, err] = await try_fn_default(async () => {
+        if (!this.bigqueryClient) await this.initialize();
+        const dataset = this.bigqueryClient.dataset(this.datasetId);
+        await dataset.getMetadata();
+        return true;
+      });
+      if (ok) return true;
+      this.emit("connection_error", { replicator: this.name, error: err.message });
+      return false;
+    }
+    async cleanup() {
+    }
+    getStatus() {
+      return {
+        ...super.getStatus(),
+        projectId: this.projectId,
+        datasetId: this.datasetId,
+        resources: this.resources,
+        logTable: this.logTable
+      };
+    }
+  }
+  var bigquery_replicator_class_default = BigqueryReplicator;
+
+  class PostgresReplicator extends base_replicator_class_default {
+    constructor(config = {}, resources = {}) {
+      super(config);
+      this.connectionString = config.connectionString;
+      this.host = config.host;
+      this.port = config.port || 5432;
+      this.database = config.database;
+      this.user = config.user;
+      this.password = config.password;
+      this.client = null;
+      this.ssl = config.ssl;
+      this.logTable = config.logTable;
+      this.resources = this.parseResourcesConfig(resources);
+    }
+    parseResourcesConfig(resources) {
+      const parsed = {};
+      for (const [resourceName, config] of Object.entries(resources)) {
+        if (typeof config === "string") {
+          parsed[resourceName] = [{
+            table: config,
+            actions: ["insert"]
+          }];
+        } else if (Array.isArray(config)) {
+          parsed[resourceName] = config.map((item) => {
+            if (typeof item === "string") {
+              return { table: item, actions: ["insert"] };
+            }
+            return {
+              table: item.table,
+              actions: item.actions || ["insert"]
+            };
+          });
+        } else if (typeof config === "object") {
+          parsed[resourceName] = [{
+            table: config.table,
+            actions: config.actions || ["insert"]
+          }];
+        }
+      }
+      return parsed;
+    }
+    validateConfig() {
+      const errors = [];
+      if (!this.connectionString && (!this.host || !this.database)) {
+        errors.push("Either connectionString or host+database must be provided");
+      }
+      if (Object.keys(this.resources).length === 0) {
+        errors.push("At least one resource must be configured");
+      }
+      for (const [resourceName, tables] of Object.entries(this.resources)) {
+        for (const tableConfig of tables) {
+          if (!tableConfig.table) {
+            errors.push(`Table name is required for resource '${resourceName}'`);
+          }
+          if (!Array.isArray(tableConfig.actions) || tableConfig.actions.length === 0) {
+            errors.push(`Actions array is required for resource '${resourceName}'`);
+          }
+          const validActions = ["insert", "update", "delete"];
+          const invalidActions = tableConfig.actions.filter((action) => !validActions.includes(action));
+          if (invalidActions.length > 0) {
+            errors.push(`Invalid actions for resource '${resourceName}': ${invalidActions.join(", ")}. Valid actions: ${validActions.join(", ")}`);
+          }
+        }
+      }
+      return { isValid: errors.length === 0, errors };
+    }
+    async initialize(database) {
+      await super.initialize(database);
+      const [ok, err, sdk] = await try_fn_default(() => import('pg'));
+      if (!ok) {
+        this.emit("initialization_error", {
+          replicator: this.name,
+          error: err.message
+        });
+        throw err;
+      }
+      const { Client } = sdk;
+      const config = this.connectionString ? {
+        connectionString: this.connectionString,
+        ssl: this.ssl
+      } : {
+        host: this.host,
+        port: this.port,
+        database: this.database,
+        user: this.user,
+        password: this.password,
+        ssl: this.ssl
+      };
+      this.client = new Client(config);
+      await this.client.connect();
+      if (this.logTable) {
+        await this.createLogTableIfNotExists();
+      }
+      this.emit("initialized", {
+        replicator: this.name,
+        database: this.database || "postgres",
+        resources: Object.keys(this.resources)
+      });
+    }
+    async createLogTableIfNotExists() {
+      const createTableQuery = `
+      CREATE TABLE IF NOT EXISTS ${this.logTable} (
+        id SERIAL PRIMARY KEY,
+        resource_name VARCHAR(255) NOT NULL,
+        operation VARCHAR(50) NOT NULL,
+        record_id VARCHAR(255) NOT NULL,
+        data JSONB,
+        timestamp TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        source VARCHAR(100) DEFAULT 's3db-replicator',
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+      CREATE INDEX IF NOT EXISTS idx_${this.logTable}_resource_name ON ${this.logTable}(resource_name);
+      CREATE INDEX IF NOT EXISTS idx_${this.logTable}_operation ON ${this.logTable}(operation);
+      CREATE INDEX IF NOT EXISTS idx_${this.logTable}_record_id ON ${this.logTable}(record_id);
+      CREATE INDEX IF NOT EXISTS idx_${this.logTable}_timestamp ON ${this.logTable}(timestamp);
+    `;
+      await this.client.query(createTableQuery);
+    }
+    shouldReplicateResource(resourceName) {
+      return this.resources.hasOwnProperty(resourceName);
+    }
+    shouldReplicateAction(resourceName, operation) {
+      if (!this.resources[resourceName]) return false;
+      return this.resources[resourceName].some(
+        (tableConfig) => tableConfig.actions.includes(operation)
+      );
+    }
+    getTablesForResource(resourceName, operation) {
+      if (!this.resources[resourceName]) return [];
+      return this.resources[resourceName].filter((tableConfig) => tableConfig.actions.includes(operation)).map((tableConfig) => tableConfig.table);
+    }
+    async replicate(resourceName, operation, data, id, beforeData = null) {
+      if (!this.enabled || !this.shouldReplicateResource(resourceName)) {
+        return { skipped: true, reason: "resource_not_included" };
+      }
+      if (!this.shouldReplicateAction(resourceName, operation)) {
+        return { skipped: true, reason: "action_not_included" };
       }
-      if (this.performanceResource) {
-        const oldPerformance = await this.getPerformanceLogs({ endDate: cutoffDate.toISOString() });
-        for (const perf of oldPerformance) {
-          await this.performanceResource.delete(perf.id);
+      const tables = this.getTablesForResource(resourceName, operation);
+      if (tables.length === 0) {
+        return { skipped: true, reason: "no_tables_for_action" };
+      }
+      const results = [];
+      const errors = [];
+      const [ok, err, result] = await try_fn_default(async () => {
+        for (const table of tables) {
+          const [okTable, errTable] = await try_fn_default(async () => {
+            let result2;
+            if (operation === "insert") {
+              const keys = Object.keys(data);
+              const values = keys.map((k) => data[k]);
+              const columns = keys.map((k) => `"${k}"`).join(", ");
+              const params = keys.map((_, i) => `$${i + 1}`).join(", ");
+              const sql = `INSERT INTO ${table} (${columns}) VALUES (${params}) ON CONFLICT (id) DO NOTHING RETURNING *`;
+              result2 = await this.client.query(sql, values);
+            } else if (operation === "update") {
+              const keys = Object.keys(data).filter((k) => k !== "id");
+              const setClause = keys.map((k, i) => `"${k}"=$${i + 1}`).join(", ");
+              const values = keys.map((k) => data[k]);
+              values.push(id);
+              const sql = `UPDATE ${table} SET ${setClause} WHERE id=$${keys.length + 1} RETURNING *`;
+              result2 = await this.client.query(sql, values);
+            } else if (operation === "delete") {
+              const sql = `DELETE FROM ${table} WHERE id=$1 RETURNING *`;
+              result2 = await this.client.query(sql, [id]);
+            } else {
+              throw new Error(`Unsupported operation: ${operation}`);
+            }
+            results.push({
+              table,
+              success: true,
+              rows: result2.rows,
+              rowCount: result2.rowCount
+            });
+          });
+          if (!okTable) {
+            errors.push({
+              table,
+              error: errTable.message
+            });
+          }
+        }
+        if (this.logTable) {
+          const [okLog, errLog] = await try_fn_default(async () => {
+            await this.client.query(
+              `INSERT INTO ${this.logTable} (resource_name, operation, record_id, data, timestamp, source) VALUES ($1, $2, $3, $4, $5, $6)`,
+              [resourceName, operation, id, JSON.stringify(data), (/* @__PURE__ */ new Date()).toISOString(), "s3db-replicator"]
+            );
+          });
+          if (!okLog) {
+          }
         }
+        const success = errors.length === 0;
+        this.emit("replicated", {
+          replicator: this.name,
+          resourceName,
+          operation,
+          id,
+          tables,
+          results,
+          errors,
+          success
+        });
+        return {
+          success,
+          results,
+          errors,
+          tables
+        };
+      });
+      if (ok) return result;
+      this.emit("replicator_error", {
+        replicator: this.name,
+        resourceName,
+        operation,
+        id,
+        error: err.message
+      });
+      return { success: false, error: err.message };
+    }
+    async replicateBatch(resourceName, records) {
+      const results = [];
+      const errors = [];
+      for (const record of records) {
+        const [ok, err, res] = await try_fn_default(() => this.replicate(
+          resourceName,
+          record.operation,
+          record.data,
+          record.id,
+          record.beforeData
+        ));
+        if (ok) results.push(res);
+        else errors.push({ id: record.id, error: err.message });
       }
+      return {
+        success: errors.length === 0,
+        results,
+        errors
+      };
+    }
+    async testConnection() {
+      const [ok, err] = await try_fn_default(async () => {
+        if (!this.client) await this.initialize();
+        await this.client.query("SELECT 1");
+        return true;
+      });
+      if (ok) return true;
+      this.emit("connection_error", { replicator: this.name, error: err.message });
+      return false;
+    }
+    async cleanup() {
+      if (this.client) await this.client.end();
+    }
+    getStatus() {
+      return {
+        ...super.getStatus(),
+        database: this.database || "postgres",
+        resources: this.resources,
+        logTable: this.logTable
+      };
     }
   }
+  var postgres_replicator_class_default = PostgresReplicator;
 
   const S3_DEFAULT_REGION = "us-east-1";
   const S3_DEFAULT_ENDPOINT = "https://s3.us-east-1.amazonaws.com";
@@ -9987,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,
@@ -11334,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 = {};
@@ -11490,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)) {
@@ -11622,7 +13196,7 @@ ${JSON.stringify(validation, null, 2)}`,
       super();
       this.version = "1";
       this.s3dbVersion = (() => {
-        const [ok, err, version] = try_fn_default(() => true ? "7.2.1" : "latest");
+        const [ok, err, version] = try_fn_default(() => true ? "7.3.3" : "latest");
         return ok ? version : "latest";
       })();
       this.resources = {};
@@ -11695,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",
@@ -12097,6 +13671,570 @@ ${JSON.stringify(validation, null, 2)}`,
   class S3db extends Database {
   }
 
+  function normalizeResourceName$1(name) {
+    return typeof name === "string" ? name.trim().toLowerCase() : name;
+  }
+  class S3dbReplicator extends base_replicator_class_default {
+    constructor(config = {}, resources = [], client = null) {
+      super(config);
+      this.instanceId = Math.random().toString(36).slice(2, 10);
+      this.client = client;
+      this.connectionString = config.connectionString;
+      let normalizedResources = resources;
+      if (!resources) normalizedResources = {};
+      else if (Array.isArray(resources)) {
+        normalizedResources = {};
+        for (const res of resources) {
+          if (typeof res === "string") normalizedResources[normalizeResourceName$1(res)] = res;
+        }
+      } else if (typeof resources === "string") {
+        normalizedResources[normalizeResourceName$1(resources)] = resources;
+      }
+      this.resourcesMap = this._normalizeResources(normalizedResources);
+    }
+    _normalizeResources(resources) {
+      if (!resources) return {};
+      if (Array.isArray(resources)) {
+        const map = {};
+        for (const res of resources) {
+          if (typeof res === "string") map[normalizeResourceName$1(res)] = res;
+          else if (Array.isArray(res) && typeof res[0] === "string") map[normalizeResourceName$1(res[0])] = res;
+          else if (typeof res === "object" && res.resource) {
+            map[normalizeResourceName$1(res.resource)] = { ...res };
+          }
+        }
+        return map;
+      }
+      if (typeof resources === "object") {
+        const map = {};
+        for (const [src, dest] of Object.entries(resources)) {
+          const normSrc = normalizeResourceName$1(src);
+          if (typeof dest === "string") map[normSrc] = dest;
+          else if (Array.isArray(dest)) {
+            map[normSrc] = dest.map((item) => {
+              if (typeof item === "string") return item;
+              if (typeof item === "function") return item;
+              if (typeof item === "object" && item.resource) {
+                return { ...item };
+              }
+              return item;
+            });
+          } else if (typeof dest === "function") map[normSrc] = dest;
+          else if (typeof dest === "object" && dest.resource) {
+            map[normSrc] = { ...dest };
+          }
+        }
+        return map;
+      }
+      if (typeof resources === "function") {
+        return resources;
+      }
+      if (typeof resources === "string") {
+        const map = { [normalizeResourceName$1(resources)]: resources };
+        return map;
+      }
+      return {};
+    }
+    validateConfig() {
+      const errors = [];
+      if (!this.client && !this.connectionString) {
+        errors.push("You must provide a client or a connectionString");
+      }
+      if (!this.resourcesMap || typeof this.resourcesMap === "object" && Object.keys(this.resourcesMap).length === 0) {
+        errors.push("You must provide a resources map or array");
+      }
+      return { isValid: errors.length === 0, errors };
+    }
+    async initialize(database) {
+      try {
+        await super.initialize(database);
+        if (this.client) {
+          this.targetDatabase = this.client;
+        } else if (this.connectionString) {
+          const targetConfig = {
+            connectionString: this.connectionString,
+            region: this.region,
+            keyPrefix: this.keyPrefix,
+            verbose: this.config.verbose || false
+          };
+          this.targetDatabase = new S3db(targetConfig);
+          await this.targetDatabase.connect();
+        } else {
+          throw new Error("S3dbReplicator: No client or connectionString provided");
+        }
+        this.emit("connected", {
+          replicator: this.name,
+          target: this.connectionString || "client-provided"
+        });
+      } catch (err) {
+        throw err;
+      }
+    }
+    // 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, payload);
+      const destResourceObj = this._getDestResourceObj(destResource);
+      const transformedData = this._applyTransformer(normResource, payload);
+      let result;
+      if (op === "insert") {
+        result = await destResourceObj.insert(transformedData);
+      } else if (op === "update") {
+        result = await destResourceObj.update(id, transformedData);
+      } else if (op === "delete") {
+        result = await destResourceObj.delete(id);
+      } else {
+        throw new Error(`Invalid operation: ${op}. Supported operations are: insert, update, delete`);
+      }
+      return result;
+    }
+    _applyTransformer(resource, data) {
+      const normResource = normalizeResourceName$1(resource);
+      const entry = this.resourcesMap[normResource];
+      let result;
+      if (!entry) return data;
+      if (Array.isArray(entry) && typeof entry[1] === "function") {
+        result = entry[1](data);
+      } else if (typeof entry === "function") {
+        result = entry(data);
+      } else if (typeof entry === "object") {
+        if (typeof entry.transform === "function") result = entry.transform(data);
+        else if (typeof entry.transformer === "function") result = entry.transformer(data);
+      } else {
+        result = data;
+      }
+      if (result && data && data.id && !result.id) result.id = data.id;
+      if (!result && data) result = data;
+      return result;
+    }
+    _resolveDestResource(resource, data) {
+      const normResource = normalizeResourceName$1(resource);
+      const entry = this.resourcesMap[normResource];
+      if (!entry) return resource;
+      if (Array.isArray(entry)) {
+        if (typeof entry[0] === "string") return entry[0];
+        if (typeof entry[0] === "object" && entry[0].resource) return entry[0].resource;
+        if (typeof entry[0] === "function") return resource;
+      }
+      if (typeof entry === "string") return entry;
+      if (resource && !targetResourceName) targetResourceName = resource;
+      if (typeof entry === "object" && entry.resource) return entry.resource;
+      return resource;
+    }
+    _getDestResourceObj(resource) {
+      if (!this.client || !this.client.resources) return null;
+      const available = Object.keys(this.client.resources);
+      const norm = normalizeResourceName$1(resource);
+      const found = available.find((r) => normalizeResourceName$1(r) === norm);
+      if (!found) {
+        throw new Error(`[S3dbReplicator] Destination resource not found: ${resource}. Available: ${available.join(", ")}`);
+      }
+      return this.client.resources[found];
+    }
+    async replicateBatch(resourceName, records) {
+      if (!this.enabled || !this.shouldReplicateResource(resourceName)) {
+        return { skipped: true, reason: "resource_not_included" };
+      }
+      const results = [];
+      const errors = [];
+      for (const record of records) {
+        const [ok, err, result] = await try_fn_default(() => this.replicate({
+          resource: resourceName,
+          operation: record.operation,
+          id: record.id,
+          data: record.data,
+          beforeData: record.beforeData
+        }));
+        if (ok) results.push(result);
+        else errors.push({ id: record.id, error: err.message });
+      }
+      this.emit("batch_replicated", {
+        replicator: this.name,
+        resourceName,
+        total: records.length,
+        successful: results.length,
+        errors: errors.length
+      });
+      return {
+        success: errors.length === 0,
+        results,
+        errors,
+        total: records.length
+      };
+    }
+    async testConnection() {
+      const [ok, err] = await try_fn_default(async () => {
+        if (!this.targetDatabase) {
+          await this.initialize(this.database);
+        }
+        await this.targetDatabase.listResources();
+        return true;
+      });
+      if (ok) return true;
+      this.emit("connection_error", {
+        replicator: this.name,
+        error: err.message
+      });
+      return false;
+    }
+    async getStatus() {
+      const baseStatus = await super.getStatus();
+      return {
+        ...baseStatus,
+        connected: !!this.targetDatabase,
+        targetDatabase: this.connectionString || "client-provided",
+        resources: Object.keys(this.resourcesMap || {}),
+        totalreplicators: this.listenerCount("replicated"),
+        totalErrors: this.listenerCount("replicator_error")
+      };
+    }
+    async cleanup() {
+      if (this.targetDatabase) {
+        this.targetDatabase.removeAllListeners();
+      }
+      await super.cleanup();
+    }
+    shouldReplicateResource(resource, action) {
+      const normResource = normalizeResourceName$1(resource);
+      const entry = this.resourcesMap[normResource];
+      if (!entry) return false;
+      if (!action) return true;
+      if (Array.isArray(entry)) {
+        for (const item of entry) {
+          if (typeof item === "object" && item.resource) {
+            if (item.actions && Array.isArray(item.actions)) {
+              if (item.actions.includes(action)) return true;
+            } else {
+              return true;
+            }
+          } else if (typeof item === "string" || typeof item === "function") {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (typeof entry === "object" && entry.resource) {
+        if (entry.actions && Array.isArray(entry.actions)) {
+          return entry.actions.includes(action);
+        }
+        return true;
+      }
+      if (typeof entry === "string" || typeof entry === "function") {
+        return true;
+      }
+      return false;
+    }
+  }
+  var s3db_replicator_class_default = S3dbReplicator;
+
+  class SqsReplicator extends base_replicator_class_default {
+    constructor(config = {}, resources = [], client = null) {
+      super(config);
+      this.client = client;
+      this.queueUrl = config.queueUrl;
+      this.queues = config.queues || {};
+      this.defaultQueue = config.defaultQueue || config.defaultQueueUrl || config.queueUrlDefault;
+      this.region = config.region || "us-east-1";
+      this.sqsClient = client || null;
+      this.messageGroupId = config.messageGroupId;
+      this.deduplicationId = config.deduplicationId;
+      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 && resourceConfig.queueUrl) {
+            this.queues[resourceName] = resourceConfig.queueUrl;
+          }
+        }
+      } else {
+        this.resources = {};
+      }
+    }
+    validateConfig() {
+      const errors = [];
+      if (!this.queueUrl && Object.keys(this.queues).length === 0 && !this.defaultQueue && !this.resourceQueueMap) {
+        errors.push("Either queueUrl, queues object, defaultQueue, or resourceQueueMap must be provided");
+      }
+      return {
+        isValid: errors.length === 0,
+        errors
+      };
+    }
+    getQueueUrlsForResource(resource) {
+      if (this.resourceQueueMap && this.resourceQueueMap[resource]) {
+        return this.resourceQueueMap[resource];
+      }
+      if (this.queues[resource]) {
+        return [this.queues[resource]];
+      }
+      if (this.queueUrl) {
+        return [this.queueUrl];
+      }
+      if (this.defaultQueue) {
+        return [this.defaultQueue];
+      }
+      throw new Error(`No queue URL found for resource '${resource}'`);
+    }
+    _applyTransformer(resource, data) {
+      const entry = this.resources[resource];
+      let result = data;
+      if (!entry) return data;
+      if (typeof entry.transform === "function") {
+        result = entry.transform(data);
+      } else if (typeof entry.transformer === "function") {
+        result = entry.transformer(data);
+      }
+      return result || data;
+    }
+    /**
+     * Create standardized message structure
+     */
+    createMessage(resource, operation, data, id, beforeData = null) {
+      const baseMessage = {
+        resource,
+        // padronizado para 'resource'
+        action: operation,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "s3db-replicator"
+      };
+      switch (operation) {
+        case "insert":
+          return {
+            ...baseMessage,
+            data
+          };
+        case "update":
+          return {
+            ...baseMessage,
+            before: beforeData,
+            data
+          };
+        case "delete":
+          return {
+            ...baseMessage,
+            data
+          };
+        default:
+          return {
+            ...baseMessage,
+            data
+          };
+      }
+    }
+    async initialize(database, client) {
+      await super.initialize(database);
+      if (!this.sqsClient) {
+        const [ok, err, sdk] = await try_fn_default(() => import('@aws-sdk/client-sqs'));
+        if (!ok) {
+          this.emit("initialization_error", {
+            replicator: this.name,
+            error: err.message
+          });
+          throw err;
+        }
+        const { SQSClient } = sdk;
+        this.sqsClient = client || new SQSClient({
+          region: this.region,
+          credentials: this.config.credentials
+        });
+        this.emit("initialized", {
+          replicator: this.name,
+          queueUrl: this.queueUrl,
+          queues: this.queues,
+          defaultQueue: this.defaultQueue
+        });
+      }
+    }
+    async replicate(resource, operation, data, id, beforeData = null) {
+      if (!this.enabled || !this.shouldReplicateResource(resource)) {
+        return { skipped: true, reason: "resource_not_included" };
+      }
+      const [ok, err, result] = await try_fn_default(async () => {
+        const { SendMessageCommand } = await import('@aws-sdk/client-sqs');
+        const queueUrls = this.getQueueUrlsForResource(resource);
+        const transformedData = this._applyTransformer(resource, data);
+        const message = this.createMessage(resource, operation, transformedData, id, beforeData);
+        const results = [];
+        for (const queueUrl of queueUrls) {
+          const command = new SendMessageCommand({
+            QueueUrl: queueUrl,
+            MessageBody: JSON.stringify(message),
+            MessageGroupId: this.messageGroupId,
+            MessageDeduplicationId: this.deduplicationId ? `${resource}:${operation}:${id}` : void 0
+          });
+          const result2 = await this.sqsClient.send(command);
+          results.push({ queueUrl, messageId: result2.MessageId });
+          this.emit("replicated", {
+            replicator: this.name,
+            resource,
+            operation,
+            id,
+            queueUrl,
+            messageId: result2.MessageId,
+            success: true
+          });
+        }
+        return { success: true, results };
+      });
+      if (ok) return result;
+      this.emit("replicator_error", {
+        replicator: this.name,
+        resource,
+        operation,
+        id,
+        error: err.message
+      });
+      return { success: false, error: err.message };
+    }
+    async replicateBatch(resource, records) {
+      if (!this.enabled || !this.shouldReplicateResource(resource)) {
+        return { skipped: true, reason: "resource_not_included" };
+      }
+      const [ok, err, result] = await try_fn_default(async () => {
+        const { SendMessageBatchCommand } = await import('@aws-sdk/client-sqs');
+        const queueUrls = this.getQueueUrlsForResource(resource);
+        const batchSize = 10;
+        const batches = [];
+        for (let i = 0; i < records.length; i += batchSize) {
+          batches.push(records.slice(i, i + batchSize));
+        }
+        const results = [];
+        const errors = [];
+        for (const batch of batches) {
+          const [okBatch, errBatch] = await try_fn_default(async () => {
+            const entries = batch.map((record, index) => ({
+              Id: `${record.id}-${index}`,
+              MessageBody: JSON.stringify(this.createMessage(
+                resource,
+                record.operation,
+                record.data,
+                record.id,
+                record.beforeData
+              )),
+              MessageGroupId: this.messageGroupId,
+              MessageDeduplicationId: this.deduplicationId ? `${resource}:${record.operation}:${record.id}` : void 0
+            }));
+            const command = new SendMessageBatchCommand({
+              QueueUrl: queueUrls[0],
+              // Assuming all queueUrls in a batch are the same for batching
+              Entries: entries
+            });
+            const result2 = await this.sqsClient.send(command);
+            results.push(result2);
+          });
+          if (!okBatch) {
+            errors.push({ batch: batch.length, error: errBatch.message });
+            if (errBatch.message && (errBatch.message.includes("Batch error") || errBatch.message.includes("Connection") || errBatch.message.includes("Network"))) {
+              throw errBatch;
+            }
+          }
+        }
+        this.emit("batch_replicated", {
+          replicator: this.name,
+          resource,
+          queueUrl: queueUrls[0],
+          // Assuming all queueUrls in a batch are the same for batching
+          total: records.length,
+          successful: results.length,
+          errors: errors.length
+        });
+        return {
+          success: errors.length === 0,
+          results,
+          errors,
+          total: records.length,
+          queueUrl: queueUrls[0]
+          // Assuming all queueUrls in a batch are the same for batching
+        };
+      });
+      if (ok) return result;
+      const errorMessage = err?.message || err || "Unknown error";
+      this.emit("batch_replicator_error", {
+        replicator: this.name,
+        resource,
+        error: errorMessage
+      });
+      return { success: false, error: errorMessage };
+    }
+    async testConnection() {
+      const [ok, err] = await try_fn_default(async () => {
+        if (!this.sqsClient) {
+          await this.initialize(this.database);
+        }
+        const { GetQueueAttributesCommand } = await import('@aws-sdk/client-sqs');
+        const command = new GetQueueAttributesCommand({
+          QueueUrl: this.queueUrl,
+          AttributeNames: ["QueueArn"]
+        });
+        await this.sqsClient.send(command);
+        return true;
+      });
+      if (ok) return true;
+      this.emit("connection_error", {
+        replicator: this.name,
+        error: err.message
+      });
+      return false;
+    }
+    async getStatus() {
+      const baseStatus = await super.getStatus();
+      return {
+        ...baseStatus,
+        connected: !!this.sqsClient,
+        queueUrl: this.queueUrl,
+        region: this.region,
+        resources: Object.keys(this.resources || {}),
+        totalreplicators: this.listenerCount("replicated"),
+        totalErrors: this.listenerCount("replicator_error")
+      };
+    }
+    async cleanup() {
+      if (this.sqsClient) {
+        this.sqsClient.destroy();
+      }
+      await super.cleanup();
+    }
+    shouldReplicateResource(resource) {
+      const result = this.resourceQueueMap && Object.keys(this.resourceQueueMap).includes(resource) || this.queues && Object.keys(this.queues).includes(resource) || !!(this.defaultQueue || this.queueUrl) || this.resources && Object.keys(this.resources).includes(resource) || false;
+      return result;
+    }
+  }
+  var sqs_replicator_class_default = SqsReplicator;
+
+  const REPLICATOR_DRIVERS = {
+    s3db: s3db_replicator_class_default,
+    sqs: sqs_replicator_class_default,
+    bigquery: bigquery_replicator_class_default,
+    postgres: postgres_replicator_class_default
+  };
+  function createReplicator(driver, config = {}, resources = [], client = null) {
+    const ReplicatorClass = REPLICATOR_DRIVERS[driver];
+    if (!ReplicatorClass) {
+      throw new Error(`Unknown replicator driver: ${driver}. Available drivers: ${Object.keys(REPLICATOR_DRIVERS).join(", ")}`);
+    }
+    return new ReplicatorClass(config, resources, client);
+  }
+
   function normalizeResourceName(name) {
     return typeof name === "string" ? name.trim().toLowerCase() : name;
   }
@@ -12144,7 +14282,7 @@ ${JSON.stringify(validation, null, 2)}`,
       return filtered;
     }
     installEventListeners(resource, database, plugin) {
-      if (!resource || this.eventListenersInstalled.has(resource.name)) {
+      if (!resource || this.eventListenersInstalled.has(resource.name) || resource.name === this.config.replicatorLogResource) {
         return;
       }
       resource.on("insert", async (data) => {
@@ -12221,10 +14359,15 @@ ${JSON.stringify(validation, null, 2)}`,
         this.installEventListeners(resource, database, this);
       }
     }
+    createReplicator(driver, config, resources, client) {
+      return createReplicator(driver, config, resources, client);
+    }
     async initializeReplicators(database) {
       for (const replicatorConfig of this.config.replicators) {
-        const { driver, config, resources } = replicatorConfig;
-        const replicator = this.createReplicator(driver, config, resources);
+        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);
@@ -12235,6 +14378,66 @@ ${JSON.stringify(validation, null, 2)}`,
     }
     async stop() {
     }
+    filterInternalFields(data) {
+      if (!data || typeof data !== "object") return data;
+      const filtered = {};
+      for (const [key, value] of Object.entries(data)) {
+        if (!key.startsWith("_") && !key.startsWith("$")) {
+          filtered[key] = value;
+        }
+      }
+      return filtered;
+    }
+    async uploadMetadataFile(database) {
+      if (typeof database.uploadMetadataFile === "function") {
+        await database.uploadMetadataFile();
+      }
+    }
+    async getCompleteData(resource, data) {
+      try {
+        const [ok, err, record] = await try_fn_default(() => resource.get(data.id));
+        if (ok && record) {
+          return record;
+        }
+      } catch (error) {
+      }
+      return data;
+    }
+    async retryWithBackoff(operation, maxRetries = 3) {
+      let lastError;
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          return await operation();
+        } catch (error) {
+          lastError = error;
+          if (attempt === maxRetries) {
+            throw error;
+          }
+          const delay = Math.pow(2, attempt - 1) * 1e3;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+      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) => {
@@ -12365,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,
@@ -12439,12 +14642,12 @@ ${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);
           }
         }
       }