s3db.js 7.3.3 → 7.3.5

package/dist/s3db.cjs.js

@@ -6,8 +6,9 @@ var nanoid = require('nanoid');
 var zlib = require('node:zlib');
 var promisePool = require('@supercharge/promise-pool');
 var web = require('node:stream/web');
-var lodashEs = require('lodash-es');
+var promises = require('fs/promises');
 var crypto = require('crypto');
+var lodashEs = require('lodash-es');
 var jsonStableStringify = require('json-stable-stringify');
 var clientS3 = require('@aws-sdk/client-s3');
 var flat = require('flat');
@@ -2081,16 +2082,6 @@ if (typeof Object.create === 'function'){
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
-  function getOwnPropertyDescriptors(obj) {
-    var keys = Object.keys(obj);
-    var descriptors = {};
-    for (var i = 0; i < keys.length; i++) {
-      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
-    }
-    return descriptors;
-  };
-
 var formatRegExp = /%[sdj%]/g;
 function format(f) {
   if (!isString(f)) {
@@ -2576,64 +2567,6 @@ function hasOwnProperty(obj, prop) {
   return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 
-var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
-
-function promisify(original) {
-  if (typeof original !== 'function')
-    throw new TypeError('The "original" argument must be of type Function');
-
-  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
-    var fn = original[kCustomPromisifiedSymbol];
-    if (typeof fn !== 'function') {
-      throw new TypeError('The "util.promisify.custom" argument must be of type Function');
-    }
-    Object.defineProperty(fn, kCustomPromisifiedSymbol, {
-      value: fn, enumerable: false, writable: false, configurable: true
-    });
-    return fn;
-  }
-
-  function fn() {
-    var promiseResolve, promiseReject;
-    var promise = new Promise(function (resolve, reject) {
-      promiseResolve = resolve;
-      promiseReject = reject;
-    });
-
-    var args = [];
-    for (var i = 0; i < arguments.length; i++) {
-      args.push(arguments[i]);
-    }
-    args.push(function (err, value) {
-      if (err) {
-        promiseReject(err);
-      } else {
-        promiseResolve(value);
-      }
-    });
-
-    try {
-      original.apply(this, args);
-    } catch (err) {
-      promiseReject(err);
-    }
-
-    return promise;
-  }
-
-  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
-
-  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
-    value: fn, enumerable: false, writable: false, configurable: true
-  });
-  return Object.defineProperties(
-    fn,
-    getOwnPropertyDescriptors(original)
-  );
-}
-
-promisify.custom = kCustomPromisifiedSymbol;
-
 var lookup = [];
 var revLookup = [];
 var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
@@ -6886,12 +6819,6 @@ var memory_cache_class_default = MemoryCache;
 
 var fs = {};
 
-const readFile$1 = promisify(fs.readFile);
-const writeFile$1 = promisify(fs.writeFile);
-const unlink = promisify(fs.unlink);
-const readdir$1 = promisify(fs.readdir);
-const stat$1 = promisify(fs.stat);
-const mkdir = promisify(fs.mkdir);
 class FilesystemCache extends Cache {
   constructor({
     directory,
@@ -6968,7 +6895,7 @@ class FilesystemCache extends Cache {
   }
   async _ensureDirectory(dir) {
     const [ok, err] = await try_fn_default(async () => {
-      await mkdir(dir, { recursive: true });
+      await promises.mkdir(dir, { recursive: true });
     });
     if (!ok && err.code !== "EEXIST") {
       throw new Error(`Failed to create cache directory: ${err.message}`);
@@ -7005,7 +6932,7 @@ class FilesystemCache extends Cache {
         await this._acquireLock(filePath);
       }
       try {
-        await writeFile$1(filePath, finalData, {
+        await promises.writeFile(filePath, finalData, {
           encoding: compressed ? "utf8" : this.encoding,
           mode: this.fileMode
         });
@@ -7019,7 +6946,7 @@ class FilesystemCache extends Cache {
             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), {
+          await promises.writeFile(this._getMetadataPath(filePath), JSON.stringify(metadata), {
             encoding: this.encoding,
             mode: this.fileMode
           });
@@ -7057,7 +6984,7 @@ class FilesystemCache extends Cache {
         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);
+            const metaContent = await promises.readFile(metadataPath, this.encoding);
             return JSON.parse(metaContent);
           });
           if (ok && metadata.ttl > 0) {
@@ -7066,7 +6993,7 @@ class FilesystemCache extends Cache {
           }
         }
       } else if (this.ttl > 0) {
-        const stats = await stat$1(filePath);
+        const stats = await promises.stat(filePath);
         const age = Date.now() - stats.mtime.getTime();
         isExpired = age > this.ttl;
       }
@@ -7081,13 +7008,13 @@ class FilesystemCache extends Cache {
         await this._acquireLock(filePath);
       }
       try {
-        const content = await readFile$1(filePath, this.encoding);
+        const content = await promises.readFile(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);
+              const metaContent = await promises.readFile(metadataPath, this.encoding);
               return JSON.parse(metaContent);
             });
             if (ok) {
@@ -7126,18 +7053,18 @@ class FilesystemCache extends Cache {
     const filePath = this._getFilePath(key);
     try {
       if (await this._fileExists(filePath)) {
-        await unlink(filePath);
+        await promises.unlink(filePath);
       }
       if (this.enableMetadata) {
         const metadataPath = this._getMetadataPath(filePath);
         if (await this._fileExists(metadataPath)) {
-          await unlink(metadataPath);
+          await promises.unlink(metadataPath);
         }
       }
       if (this.enableBackup) {
         const backupPath = filePath + this.backupSuffix;
         if (await this._fileExists(backupPath)) {
-          await unlink(backupPath);
+          await promises.unlink(backupPath);
         }
       }
       if (this.enableStats) {
@@ -7156,7 +7083,7 @@ class FilesystemCache extends Cache {
   }
   async _clear(prefix) {
     try {
-      const files = await readdir$1(this.directory);
+      const files = await promises.readdir(this.directory);
       const cacheFiles = files.filter((file) => {
         if (!file.startsWith(this.prefix)) return false;
         if (!file.endsWith(this.fileExtension)) return false;
@@ -7169,18 +7096,18 @@ class FilesystemCache extends Cache {
       for (const file of cacheFiles) {
         const filePath = path.join(this.directory, file);
         if (await this._fileExists(filePath)) {
-          await unlink(filePath);
+          await promises.unlink(filePath);
         }
         if (this.enableMetadata) {
           const metadataPath = this._getMetadataPath(filePath);
           if (await this._fileExists(metadataPath)) {
-            await unlink(metadataPath);
+            await promises.unlink(metadataPath);
           }
         }
         if (this.enableBackup) {
           const backupPath = filePath + this.backupSuffix;
           if (await this._fileExists(backupPath)) {
-            await unlink(backupPath);
+            await promises.unlink(backupPath);
           }
         }
       }
@@ -7204,7 +7131,7 @@ class FilesystemCache extends Cache {
   }
   async keys() {
     try {
-      const files = await readdir$1(this.directory);
+      const files = await promises.readdir(this.directory);
       const cacheFiles = files.filter(
         (file) => file.startsWith(this.prefix) && file.endsWith(this.fileExtension)
       );
@@ -7221,14 +7148,14 @@ class FilesystemCache extends Cache {
   // Helper methods
   async _fileExists(filePath) {
     const [ok] = await try_fn_default(async () => {
-      await stat$1(filePath);
+      await promises.stat(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);
+      const content = await promises.readFile(src);
+      await promises.writeFile(dest, content);
     });
     if (!ok) {
       console.warn("FilesystemCache: Failed to create backup:", err.message);
@@ -7237,7 +7164,7 @@ class FilesystemCache extends Cache {
   async _cleanup() {
     if (!this.ttl || this.ttl <= 0) return;
     try {
-      const files = await readdir$1(this.directory);
+      const files = await promises.readdir(this.directory);
       const now = Date.now();
       for (const file of files) {
         if (!file.startsWith(this.prefix) || !file.endsWith(this.fileExtension)) {
@@ -7249,7 +7176,7 @@ class FilesystemCache extends Cache {
           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);
+              const metaContent = await promises.readFile(metadataPath, this.encoding);
               return JSON.parse(metaContent);
             });
             if (ok && metadata.ttl > 0) {
@@ -7259,7 +7186,7 @@ class FilesystemCache extends Cache {
           }
         } else {
           const [ok, err, stats] = await try_fn_default(async () => {
-            return await stat$1(filePath);
+            return await promises.stat(filePath);
           });
           if (ok) {
             const age = now - stats.mtime.getTime();
@@ -7329,12 +7256,6 @@ class FilesystemCache extends Cache {
   }
 }
 
-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",
@@ -7456,7 +7377,7 @@ class PartitionAwareFilesystemCache extends FilesystemCache {
     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 });
+        await promises.rm(partitionDir, { recursive: true });
       }
     });
     if (!ok) {
@@ -7474,7 +7395,7 @@ class PartitionAwareFilesystemCache extends FilesystemCache {
     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 });
+        await promises.rm(resourceDir, { recursive: true });
       }
     });
     for (const [key] of this.partitionUsage.entries()) {
@@ -7606,11 +7527,11 @@ class PartitionAwareFilesystemCache extends FilesystemCache {
     return filename.replace(/[<>:"/\\|?*]/g, "_");
   }
   async _calculateDirectoryStats(dir, stats) {
-    const [ok, err, files] = await try_fn_default(() => readdir(dir));
+    const [ok, err, files] = await try_fn_default(() => promises.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));
+      const [statOk, statErr, fileStat] = await try_fn_default(() => promises.stat(filePath));
       if (statOk) {
         if (fileStat.isDirectory()) {
           await this._calculateDirectoryStats(filePath, stats);
@@ -7623,7 +7544,7 @@ class PartitionAwareFilesystemCache extends FilesystemCache {
   }
   async loadUsageStats() {
     const [ok, err, content] = await try_fn_default(async () => {
-      const data = await readFile(this.usageStatsFile, "utf8");
+      const data = await promises.readFile(this.usageStatsFile, "utf8");
       return JSON.parse(data);
     });
     if (ok && content) {
@@ -7633,7 +7554,7 @@ class PartitionAwareFilesystemCache extends FilesystemCache {
   async _saveUsageStats() {
     const statsObject = Object.fromEntries(this.partitionUsage);
     await try_fn_default(async () => {
-      await writeFile(
+      await promises.writeFile(
         this.usageStatsFile,
         JSON.stringify(statsObject, null, 2),
         "utf8"
@@ -7643,7 +7564,7 @@ class PartitionAwareFilesystemCache extends FilesystemCache {
   async _writeFileWithMetadata(filePath, data) {
     const content = JSON.stringify(data);
     const [ok, err] = await try_fn_default(async () => {
-      await writeFile(filePath, content, {
+      await promises.writeFile(filePath, content, {
         encoding: this.encoding,
         mode: this.fileMode
       });
@@ -7655,7 +7576,7 @@ class PartitionAwareFilesystemCache extends FilesystemCache {
   }
   async _readFileWithMetadata(filePath) {
     const [ok, err, content] = await try_fn_default(async () => {
-      return await readFile(filePath, this.encoding);
+      return await promises.readFile(filePath, this.encoding);
     });
     if (!ok || !content) return null;
     try {
@@ -8432,7 +8353,7 @@ class MetricsPlugin extends plugin_class_default {
   }
   async setup(database) {
     this.database = database;
-    if (process.env.NODE_ENV === "test") return;
+    if (typeof process !== "undefined" && process.env.NODE_ENV === "test") return;
     const [ok, err] = await try_fn_default(async () => {
       const [ok1, err1, metricsResource] = await try_fn_default(() => database.createResource({
         name: "metrics",
@@ -8482,7 +8403,7 @@ class MetricsPlugin extends plugin_class_default {
       this.performanceResource = database.resources.performance_logs;
     }
     this.installMetricsHooks();
-    if (process.env.NODE_ENV !== "test") {
+    if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
       this.startFlushTimer();
     }
   }
@@ -8493,7 +8414,7 @@ class MetricsPlugin extends plugin_class_default {
       clearInterval(this.flushTimer);
       this.flushTimer = null;
     }
-    if (process.env.NODE_ENV !== "test") {
+    if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
       await this.flushMetrics();
     }
   }
@@ -8672,10 +8593,18 @@ class MetricsPlugin extends plugin_class_default {
   async flushMetrics() {
     if (!this.metricsResource) return;
     const [ok, err] = await try_fn_default(async () => {
-      const metadata = process.env.NODE_ENV === "test" ? {} : { global: "true" };
-      const perfMetadata = process.env.NODE_ENV === "test" ? {} : { perf: "true" };
-      const errorMetadata = process.env.NODE_ENV === "test" ? {} : { error: "true" };
-      const resourceMetadata = process.env.NODE_ENV === "test" ? {} : { resource: "true" };
+      let metadata, perfMetadata, errorMetadata, resourceMetadata;
+      if (typeof process !== "undefined" && process.env.NODE_ENV === "test") {
+        metadata = {};
+        perfMetadata = {};
+        errorMetadata = {};
+        resourceMetadata = {};
+      } else {
+        metadata = { global: "true" };
+        perfMetadata = { perf: "true" };
+        errorMetadata = { error: "true" };
+        resourceMetadata = { resource: "true" };
+      }
       for (const [operation, data] of Object.entries(this.metrics.operations)) {
         if (data.count > 0) {
           await this.metricsResource.insert({
@@ -13208,7 +13137,7 @@ class Database extends EventEmitter {
     super();
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = try_fn_default(() => true ? "7.3.3" : "latest");
+      const [ok, err, version] = try_fn_default(() => true ? "7.3.4" : "latest");
       return ok ? version : "latest";
     })();
     this.resources = {};
@@ -13251,14 +13180,16 @@ class Database extends EventEmitter {
     this.keyPrefix = this.client.keyPrefix;
     if (!this._exitListenerRegistered) {
       this._exitListenerRegistered = true;
-      process.on("exit", async () => {
-        if (this.isConnected()) {
-          try {
-            await this.disconnect();
-          } catch (err) {
+      if (typeof process !== "undefined") {
+        process.on("exit", async () => {
+          if (this.isConnected()) {
+            try {
+              await this.disconnect();
+            } catch (err) {
+            }
           }
-        }
-      });
+        });
+      }
     }
   }
   async connect() {
@@ -13841,7 +13772,7 @@ class S3dbReplicator extends base_replicator_class_default {
       if (typeof entry[0] === "function") return resource;
     }
     if (typeof entry === "string") return entry;
-    if (resource && !targetResourceName) targetResourceName = resource;
+    if (typeof entry === "function") return resource;
     if (typeof entry === "object" && entry.resource) return entry.resource;
     return resource;
   }
@@ -14390,31 +14321,11 @@ class ReplicatorPlugin extends plugin_class_default {
   }
   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++) {