@abtnode/util 1.16.44 → 1.16.45-beta-20250609-025419-7fd1f86c

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.44",
+  "version": "1.16.45-beta-20250609-025419-7fd1f86c",
   "description": "ArcBlock's JavaScript utility",
   "main": "lib/index.js",
   "files": [
@@ -18,17 +18,18 @@
   "author": "polunzh <polunzh@gmail.com> (http://github.com/polunzh)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/constant": "1.16.44",
-    "@arcblock/did": "1.20.13",
+    "@abtnode/constant": "1.16.45-beta-20250609-025419-7fd1f86c",
+    "@abtnode/db-cache": "1.16.45-beta-20250609-025419-7fd1f86c",
+    "@arcblock/did": "1.20.14",
     "@arcblock/pm2": "^5.4.0",
-    "@blocklet/constant": "1.16.44",
+    "@blocklet/constant": "1.16.45-beta-20250609-025419-7fd1f86c",
     "@blocklet/error": "^0.2.5",
-    "@blocklet/meta": "1.16.44",
+    "@blocklet/meta": "1.16.45-beta-20250609-025419-7fd1f86c",
     "@blocklet/xss": "^0.1.36",
-    "@ocap/client": "1.20.13",
-    "@ocap/mcrypto": "1.20.13",
-    "@ocap/util": "1.20.13",
-    "@ocap/wallet": "1.20.13",
+    "@ocap/client": "1.20.14",
+    "@ocap/mcrypto": "1.20.14",
+    "@ocap/util": "1.20.14",
+    "@ocap/wallet": "1.20.14",
     "archiver": "^7.0.1",
     "axios": "^1.7.9",
     "axios-mock-adapter": "^2.1.0",
@@ -55,7 +56,6 @@
     "is-url": "^1.2.4",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.21",
-    "lru-cache": "^11.0.2",
     "minimatch": "^10.0.1",
     "multiformats": "9.9.0",
     "npm-packlist": "^7.0.4",
@@ -88,5 +88,5 @@
     "fs-extra": "^11.2.0",
     "jest": "^29.7.0"
   },
-  "gitHead": "a177f040e3e8da94311cec1395c8e8defae2da9e"
+  "gitHead": "0457b82da528653a1b903149ea1fb1966c31bee3"
 }

package/lib/lock-with-file.js

@@ -1,142 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const debug = require('debug')('@abtnode/util:lock-with-file');
-
-class LockFile {
-  constructor(lockDir, timeout = 1000 * 60 * 2) {
-    this.lockDir = lockDir;
-    this.timeout = timeout;
-    if (lockDir && !fs.existsSync(lockDir)) {
-      try {
-        fs.mkdirSync(lockDir, { recursive: true });
-      } catch (err) {
-        debug('create lock dir failed', { lockDir, err });
-      }
-    }
-  }
-
-  /**
-   * 创建锁文件（原子操作）
-   * @param {string} lockName 锁文件名称
-   * @returns {boolean} 是否成功创建锁
-   */
-  createLock(lockName) {
-    if (!this.lockDir) {
-      return false;
-    }
-    const lockFile = path.join(this.lockDir, `${lockName}.lock`);
-    try {
-      debug('create lock file', { lockFile });
-      if (this.lockDir && !fs.existsSync(this.lockDir)) {
-        fs.mkdirSync(this.lockDir, { recursive: true });
-      }
-      const fd = fs.openSync(lockFile, 'wx'); // 原子操作创建文件, 如果文件已存在则失败
-      fs.writeSync(fd, Date.now().toString());
-      fs.closeSync(fd);
-      return true;
-    } catch (err) {
-      debug('create lock file failed', { lockName, err });
-      if (err.code === 'EEXIST') {
-        return false;
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * 检查锁文件是否过期
-   * @param {string} lockName 锁文件名称
-   * @returns {boolean} 是否已过期
-   */
-  isExpired(lockName) {
-    if (!this.lockDir) {
-      return true;
-    }
-    const lockFile = path.join(this.lockDir, `${lockName}.lock`);
-    if (!fs.existsSync(lockFile)) {
-      return true;
-    }
-    try {
-      const lockTime = parseInt(fs.readFileSync(lockFile, 'utf8'), 10);
-      debug('check lock file expired', { lockName, lockTime });
-      return Date.now() - lockTime > this.timeout;
-    } catch (err) {
-      debug('check lock file expired failed', { lockName, err });
-      return true;
-    }
-  }
-
-  /**
-   * 释放锁文件
-   * @param {string} lockName 锁文件名称
-   */
-  releaseLock(lockName) {
-    if (!this.lockDir) {
-      return;
-    }
-    const lockFile = path.join(this.lockDir, `${lockName}.lock`);
-    try {
-      if (fs.existsSync(lockFile)) {
-        debug('release lock file', { lockName });
-        fs.rmSync(lockFile, { force: true });
-      }
-    } catch (err) {
-      debug('release lock file failed', { lockName, err });
-    }
-  }
-
-  /**
-   * 尝试获取锁文件（自动处理过期锁）
-   * @param {string} lockName 锁文件名称
-   * @returns {boolean} 是否成功获取锁
-   */
-  tryLock(lockName) {
-    if (!this.lockDir) {
-      return false;
-    }
-    if (this.createLock(lockName)) {
-      return true;
-    }
-    if (this.isExpired(lockName)) {
-      this.releaseLock(lockName);
-      return this.createLock(lockName);
-    }
-    return false;
-  }
-
-  waitUnLock(lockName, timeout = 1000 * 60 * 2) {
-    if (!this.lockDir) {
-      return false;
-    }
-    const start = Date.now();
-    const lockFile = path.join(this.lockDir, `${lockName}.lock`);
-    debug('wait unlock', { lockName });
-
-    return new Promise((resolve) => {
-      const interval = setInterval(() => {
-        debug('check unlock', { lockName });
-        if (!fs.existsSync(lockFile) || this.isExpired(lockName)) {
-          clearInterval(interval);
-          resolve(true);
-        } else if (Date.now() - start >= timeout) {
-          clearInterval(interval);
-          resolve(false);
-        }
-      }, 200);
-    });
-  }
-
-  async acquire(lockName) {
-    if (!this.tryLock(lockName)) {
-      await this.waitUnLock(lockName);
-    }
-
-    this.tryLock(lockName);
-  }
-
-  release(lockName) {
-    this.releaseLock(lockName);
-  }
-}
-
-module.exports = LockFile;

package/lib/single-flight-lru-cache.js

@@ -1,80 +0,0 @@
-const { LRUCache } = require('lru-cache');
-const pWaitFor = require('p-wait-for');
-
-const PADDING_VALUE = '__padding__';
-
-// Single flight lru cache
-// ref: https://www.codingexplorations.com/blog/understanding-singleflight-in-golang-a-solution-for-eliminating-redundant-work
-class SingleFlightLRUCache extends LRUCache {
-  paddingInterval = 100;
-
-  paddingTimeout = 10 * 1000;
-
-  setPadding(key) {
-    this.set(key, PADDING_VALUE);
-  }
-
-  isPadding(key) {
-    return this.get(key) === PADDING_VALUE;
-  }
-
-  async waitPending(key) {
-    if (this.get(key) === PADDING_VALUE) {
-      try {
-        await pWaitFor(() => this.get(key) !== PADDING_VALUE, {
-          interval: this.paddingInterval,
-          timeout: this.paddingTimeout,
-        });
-      } catch (_) {
-        if (this.get(key) === PADDING_VALUE) {
-          this.delete(key);
-        }
-      }
-    }
-    return this.get(key);
-  }
-
-  async wrapPending(key, fn) {
-    if (!key) {
-      return Promise.resolve(fn());
-    }
-    const old = this.get(key);
-    if (old) {
-      if (old === PADDING_VALUE) {
-        const result = await this.waitPending(key);
-        if (result && result !== PADDING_VALUE) {
-          return result;
-        }
-      } else {
-        return old;
-      }
-    }
-    this.setPadding(key);
-    try {
-      const result = await Promise.resolve(fn());
-      return result;
-    } finally {
-      if (this.get(key) === PADDING_VALUE) {
-        this.delete(key);
-      }
-    }
-  }
-
-  /**
-   * autoCache will set the result to the cache if the key is not null
-   * if the key is null, it will return the result of the function
-   * if the key is not null, it will return the cached result
-   * if padding, it will wait for the padding to finish
-   * if the key is not in the cache, it will set the result to the cache
-   * if the key is in the cache, it will return the cached result
-   */
-  async autoCache(key, fn) {
-    const result = await this.wrapPending(key, fn);
-    if (key) {
-      this.set(key, result);
-    }
-    return result;
-  }
-}
-
-module.exports = SingleFlightLRUCache;