@abtnode/db-cache 1.16.45-beta-20250609-025419-7fd1f86c

package/dist/index.mjs

@@ -0,0 +1,811 @@
+import { createClient } from 'redis';
+import sqlite3 from 'sqlite3';
+import * as path from 'path';
+import * as fs from 'fs';
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _RedisAdapter = class _RedisAdapter {
+  constructor() {
+    __publicField$4(this, "opts", null);
+    __publicField$4(this, "defaultTtl", 1e3 * 60 * 60);
+    __publicField$4(this, "url", "");
+    __publicField$4(this, "prefix", "");
+    __publicField$4(this, "prefixKey", (key) => `${this.prefix}:${key}`);
+    __publicField$4(this, "prefixKeyGroup", (key) => `${this.prefix}:group:${key}`);
+  }
+  clearAll() {
+    throw new Error("Method not implemented.");
+  }
+  async ensure() {
+    if (!this.url) {
+      this.url = this.opts.redisUrl || "";
+      this.prefix = this.opts.prefix;
+      this.defaultTtl = this.opts.ttl;
+    }
+    if (_RedisAdapter.clients.has(this.url)) {
+      return;
+    }
+    if (!_RedisAdapter.initPromises.has(this.url)) {
+      _RedisAdapter.initPromises.set(
+        this.url,
+        (async () => {
+          const cli = createClient({ url: this.url });
+          cli.on("error", console.error);
+          await cli.connect();
+          _RedisAdapter.clients.set(this.url, cli);
+        })()
+      );
+    }
+    await _RedisAdapter.initPromises.get(this.url);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  getClient() {
+    if (!this.url || !_RedisAdapter.clients.has(this.url)) {
+      throw new Error("Redis not initialized");
+    }
+    return _RedisAdapter.clients.get(this.url);
+  }
+  serialize(value) {
+    return JSON.stringify({ v: value });
+  }
+  deserialize(raw) {
+    if (raw === null || raw === void 0)
+      return null;
+    try {
+      const obj = JSON.parse(raw);
+      return obj.v;
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value, { ttl, nx }) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    if (ttl && ttl > 0) {
+      await client.set(storageKey, this.serialize(value), { PX: ttl, NX: nx });
+    } else {
+      await client.set(storageKey, this.serialize(value), { NX: nx });
+    }
+    return true;
+  }
+  async get(key) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const raw = await client.get(storageKey);
+    return this.deserialize(raw);
+  }
+  async del(key) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const storageKeyGroup = this.prefixKeyGroup(key);
+    await client.del(storageKey);
+    await client.del(storageKeyGroup);
+  }
+  async has(key) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const exists = await client.exists(storageKey);
+    if (exists === 0)
+      return false;
+    const raw = await client.get(storageKey);
+    if (!raw)
+      return false;
+    const data = JSON.parse(raw);
+    if (data.e && Date.now() > data.e) {
+      await this.del(key);
+      return false;
+    }
+    return true;
+  }
+  async groupSet(key, subKey, value, { ttl }) {
+    const client = this.getClient();
+    const storageKey = this.prefixKeyGroup(key);
+    await client.hSet(storageKey, subKey, this.serialize(value));
+    const effectiveTtl = ttl !== void 0 ? ttl : this.defaultTtl;
+    if (effectiveTtl > 0) {
+      await client.expire(storageKey, Math.ceil(effectiveTtl / 1e3));
+    }
+  }
+  async groupGet(key, subKey) {
+    const client = this.getClient();
+    const storageKey = this.prefixKeyGroup(key);
+    const raw = await client.hGet(storageKey, subKey);
+    return this.deserialize(raw);
+  }
+  async groupHas(key, subKey) {
+    const client = this.getClient();
+    const storageKey = this.prefixKeyGroup(key);
+    return await client.hExists(storageKey, subKey) === 1;
+  }
+  async groupDel(key, subKey) {
+    const client = this.getClient();
+    const storageKey = this.prefixKeyGroup(key);
+    await client.hDel(storageKey, subKey);
+  }
+  async close() {
+    if (this.url && _RedisAdapter.clients.has(this.url)) {
+      const client = _RedisAdapter.clients.get(this.url);
+      await client.quit();
+      _RedisAdapter.clients.delete(this.url);
+      _RedisAdapter.initPromises.delete(this.url);
+    }
+  }
+  async flushAll() {
+    const client = this.getClient();
+    await client.flushAll();
+  }
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+__publicField$4(_RedisAdapter, "clients", /* @__PURE__ */ new Map());
+__publicField$4(_RedisAdapter, "initPromises", /* @__PURE__ */ new Map());
+let RedisAdapter = _RedisAdapter;
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _SqliteAdapter = class _SqliteAdapter {
+  constructor() {
+    __publicField$3(this, "opts", null);
+    __publicField$3(this, "prefix", "");
+    __publicField$3(this, "defaultTtl", 1e3 * 60 * 60);
+    __publicField$3(this, "cleanupInterval", 5 * 60 * 1e3);
+    __publicField$3(this, "dbPath", "");
+  }
+  async ensure() {
+    if (!this.dbPath) {
+      this.dbPath = path.resolve(this.opts.sqlitePath);
+      this.prefix = this.opts.prefix;
+      this.defaultTtl = this.opts.ttl;
+      this.cleanupInterval = this.opts.cleanupInterval ?? 30 * 60 * 1e3;
+    }
+    if (_SqliteAdapter.clients.has(this.dbPath))
+      return;
+    if (!_SqliteAdapter.initPromises.has(this.dbPath)) {
+      const dir = path.dirname(this.dbPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      _SqliteAdapter.initPromises.set(
+        this.dbPath,
+        (async () => {
+          const dbDir = path.dirname(this.dbPath);
+          if (!fs.existsSync(dbDir)) {
+            fs.mkdirSync(dbDir, { recursive: true });
+          }
+          const db = new sqlite3.Database(this.dbPath);
+          await new Promise(
+            (res) => db.exec(
+              `
+              PRAGMA journal_mode = WAL;
+              PRAGMA synchronous = OFF;
+              PRAGMA busy_timeout = 20000;
+              PRAGMA wal_autocheckpoint = 2000;
+              `,
+              (err) => {
+                if (err)
+                  console.error("SQLite init error:", err);
+                res();
+              }
+            )
+          );
+          await new Promise(
+            (res, rej) => db.run(
+              `
+              CREATE TABLE IF NOT EXISTS kvcache (
+                key TEXT NOT NULL,
+                subKey TEXT NOT NULL,
+                value TEXT NOT NULL,
+                expiresAt INTEGER,
+                PRIMARY KEY (key, subKey)
+              )
+              `,
+              (err) => err ? rej(err) : res()
+            )
+          );
+          await new Promise(
+            (res, rej) => db.run(
+              `
+              PRAGMA shrink_memory;
+              `,
+              (err) => err ? rej(err) : res()
+            )
+          );
+          _SqliteAdapter.clients.set(this.dbPath, db);
+          _SqliteAdapter.cleanupTimers.set(
+            this.dbPath,
+            setInterval(
+              () => {
+                this.cleanup().catch(console.error);
+              },
+              this.cleanupInterval + Math.random() * 3e4
+            )
+          );
+        })()
+      );
+    }
+    await _SqliteAdapter.initPromises.get(this.dbPath);
+  }
+  getClient() {
+    if (!this.dbPath || !_SqliteAdapter.clients.has(this.dbPath)) {
+      throw new Error("SQLite not initialized");
+    }
+    return _SqliteAdapter.clients.get(this.dbPath);
+  }
+  async cleanup() {
+    const client = this.getClient();
+    await new Promise((res, rej) => {
+      client.run(
+        "DELETE FROM kvcache WHERE expiresAt IS NOT NULL AND expiresAt <= ?",
+        [Date.now()],
+        (err) => err ? rej(err) : res()
+      );
+    });
+  }
+  prefixKey(key) {
+    return `${this.prefix}:${key}`;
+  }
+  serialize(value) {
+    return JSON.stringify({ v: value });
+  }
+  deserialize(raw) {
+    if (raw === null || raw === void 0)
+      return null;
+    try {
+      const obj = JSON.parse(raw);
+      return obj.v;
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value, opts) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const effectiveTtl = opts.ttl !== void 0 ? opts.ttl : this.defaultTtl;
+    const expiresAt = effectiveTtl > 0 ? Date.now() + effectiveTtl : null;
+    const subKey = "";
+    if (opts.nx) {
+      const exists = await this.has(key);
+      if (exists)
+        return false;
+    }
+    await new Promise((res, rej) => {
+      client.run(
+        `
+        INSERT INTO kvcache (key, subKey, value, expiresAt)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(key, subKey) DO UPDATE SET
+          value = excluded.value,
+          expiresAt = excluded.expiresAt
+        `,
+        [storageKey, subKey, this.serialize(value), expiresAt],
+        (err) => err ? rej(err) : res()
+      );
+    });
+    return true;
+  }
+  async get(key) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const subKey = "";
+    const row = await new Promise(
+      (res, rej) => {
+        client.get(
+          "SELECT value, expiresAt FROM kvcache WHERE key = ? AND subKey = ?",
+          [storageKey, subKey],
+          (err, result) => {
+            if (err)
+              return rej(err);
+            return res(result);
+          }
+        );
+      }
+    );
+    if (!row)
+      return null;
+    if (row.expiresAt !== null && Date.now() > row.expiresAt) {
+      await this.del(key);
+      return null;
+    }
+    return this.deserialize(row.value);
+  }
+  async del(key) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    await new Promise((res, rej) => {
+      client.run(
+        "DELETE FROM kvcache WHERE key = ?",
+        [storageKey],
+        (err) => err ? rej(err) : res()
+      );
+    });
+  }
+  async has(key) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const subKey = "";
+    const row = await new Promise((res, rej) => {
+      client.get(
+        "SELECT expiresAt FROM kvcache WHERE key = ? AND subKey = ?",
+        [storageKey, subKey],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (err, result) => err ? rej(err) : res(result)
+      );
+    });
+    if (!row)
+      return false;
+    if (row.expiresAt !== null && Date.now() > row.expiresAt) {
+      await this.del(key);
+      return false;
+    }
+    return true;
+  }
+  async groupSet(key, subKey, value, opts) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const effectiveTtl = opts.ttl !== void 0 ? opts.ttl : this.defaultTtl;
+    const expiresAt = effectiveTtl > 0 ? Date.now() + effectiveTtl : null;
+    if (opts.nx) {
+      const exists = await this.groupHas(key, subKey);
+      if (exists)
+        return;
+    }
+    await new Promise((res, rej) => {
+      client.run(
+        `
+        INSERT INTO kvcache (key, subKey, value, expiresAt)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(key, subKey) DO UPDATE SET
+          value = excluded.value,
+          expiresAt = excluded.expiresAt
+        `,
+        [storageKey, subKey, this.serialize(value), expiresAt],
+        (err) => err ? rej(err) : res()
+      );
+    });
+  }
+  async groupGet(key, subKey) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const row = await new Promise(
+      (res, rej) => {
+        client.get(
+          "SELECT value, expiresAt FROM kvcache WHERE key = ? AND subKey = ?",
+          [storageKey, subKey],
+          (err, result) => {
+            if (err)
+              return rej(err);
+            return res(result);
+          }
+        );
+      }
+    );
+    if (!row)
+      return null;
+    if (row.expiresAt !== null && Date.now() > row.expiresAt) {
+      await this.groupDel(key, subKey);
+      return null;
+    }
+    return this.deserialize(row.value);
+  }
+  async groupHas(key, subKey) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    const row = await new Promise((res, rej) => {
+      client.get(
+        "SELECT expiresAt FROM kvcache WHERE key = ? AND subKey = ?",
+        [storageKey, subKey],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (err, result) => err ? rej(err) : res(result)
+      );
+    });
+    if (!row)
+      return false;
+    if (row.expiresAt !== null && Date.now() > row.expiresAt) {
+      await this.groupDel(key, subKey);
+      return false;
+    }
+    return true;
+  }
+  async groupDel(key, subKey) {
+    const client = this.getClient();
+    const storageKey = this.prefixKey(key);
+    await new Promise((res, rej) => {
+      client.run(
+        "DELETE FROM kvcache WHERE key = ? AND subKey = ?",
+        [storageKey, subKey],
+        (err) => err ? rej(err) : res()
+      );
+    });
+  }
+  async close() {
+    if (this.dbPath) {
+      const timer = _SqliteAdapter.cleanupTimers.get(this.dbPath);
+      if (timer) {
+        clearInterval(timer);
+        _SqliteAdapter.cleanupTimers.delete(this.dbPath);
+      }
+      const client = _SqliteAdapter.clients.get(this.dbPath);
+      if (client) {
+        client.close();
+        _SqliteAdapter.clients.delete(this.dbPath);
+        _SqliteAdapter.initPromises.delete(this.dbPath);
+      }
+    }
+  }
+  async flushAll() {
+    const client = this.getClient();
+    await client.run("DELETE FROM kvcache");
+  }
+};
+__publicField$3(_SqliteAdapter, "clients", /* @__PURE__ */ new Map());
+__publicField$3(_SqliteAdapter, "initPromises", /* @__PURE__ */ new Map());
+__publicField$3(_SqliteAdapter, "cleanupTimers", /* @__PURE__ */ new Map());
+let SqliteAdapter = _SqliteAdapter;
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class BaseDBCache {
+  constructor(opts) {
+    __publicField$2(this, "adapter", null);
+    __publicField$2(this, "prefix", "");
+    __publicField$2(this, "type", "");
+    __publicField$2(this, "defaultTtl", 0);
+    __publicField$2(this, "getOpts");
+    __publicField$2(this, "_initdAdapter", false);
+    this.getOpts = opts;
+  }
+  initAdapter() {
+    if (this._initdAdapter) {
+      return;
+    }
+    if (typeof this.getOpts !== "function") {
+      throw new Error("getOpts must be a function");
+    }
+    const opts = this.getOpts();
+    if (!opts.prefix || typeof opts.prefix !== "string" || opts.prefix.trim() === "") {
+      throw new Error("prefix is required");
+    }
+    if (!opts.sqlitePath || typeof opts.sqlitePath !== "string") {
+      throw new Error("sqlitePath is required");
+    }
+    if (typeof opts.ttl !== "number" || opts.ttl < 0) {
+      throw new Error("ttl must be a non-negative number");
+    }
+    if (opts.cleanupInterval && opts.cleanupInterval < 1e3 * 60 * 5) {
+      console.error("cleanupInterval must be at least 5 minutes");
+      throw new Error("cleanupInterval must be at least 5 minutes");
+    }
+    this.type = opts.forceType || (opts.redisUrl ? "redis" : "sqlite");
+    this.prefix = opts.prefix;
+    this.defaultTtl = opts.ttl;
+    switch (this.type) {
+      case "redis":
+        this.adapter = new RedisAdapter();
+        this.adapter.opts = opts;
+        break;
+      case "sqlite":
+        this.adapter = new SqliteAdapter();
+        this.adapter.opts = opts;
+        break;
+      default:
+        throw new Error(`Unsupported backend: ${this.type}`);
+    }
+    this._initdAdapter = true;
+  }
+  static randomKey() {
+    return Math.random().toString(36).substring(2, 15);
+  }
+  async set(key, value, opts = {}) {
+    this.initAdapter();
+    if (typeof key !== "string") {
+      console.error("key must be a string");
+      return Promise.resolve(false);
+    }
+    const effectiveTtl = opts.ttl !== void 0 ? opts.ttl : this.defaultTtl;
+    if (typeof effectiveTtl !== "number" || effectiveTtl < 0) {
+      console.error("ttl must be a non-negative number");
+      throw new Error("ttl must be a non-negative number");
+    }
+    await this.adapter.ensure();
+    return this.adapter.set(key, value, { ttl: effectiveTtl, nx: opts.nx });
+  }
+  async get(key) {
+    this.initAdapter();
+    if (typeof key !== "string") {
+      console.error("key must be a string");
+      return Promise.resolve();
+    }
+    await this.adapter.ensure();
+    return this.adapter.get(key);
+  }
+  async del(key) {
+    this.initAdapter();
+    if (typeof key !== "string") {
+      console.error("key must be a string");
+      return Promise.resolve();
+    }
+    await this.adapter.ensure();
+    return this.adapter.del(key);
+  }
+  async has(key) {
+    this.initAdapter();
+    if (typeof key !== "string") {
+      console.error("key must be a string");
+      return Promise.resolve(false);
+    }
+    await this.adapter.ensure();
+    return this.adapter.has(key);
+  }
+  async groupSet(key, subKey, value, opts = {}) {
+    this.initAdapter();
+    if (typeof key !== "string" || typeof subKey !== "string") {
+      return Promise.resolve();
+    }
+    const effectiveTtl = opts.ttl !== void 0 ? opts.ttl : this.defaultTtl;
+    if (typeof effectiveTtl !== "number" || effectiveTtl < 0) {
+      console.error("ttl must be a non-negative number");
+      throw new Error("ttl must be a non-negative number");
+    }
+    await this.adapter.ensure();
+    return this.adapter.groupSet(key, subKey, value, { ttl: effectiveTtl, nx: opts.nx });
+  }
+  async groupGet(key, subKey) {
+    this.initAdapter();
+    if (typeof key !== "string" || typeof subKey !== "string") {
+      console.error("key must be a string");
+      return null;
+    }
+    await this.adapter.ensure();
+    return this.adapter.groupGet(key, subKey);
+  }
+  async groupHas(key, subKey) {
+    this.initAdapter();
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    if (typeof subKey !== "string") {
+      throw new Error("subKey must be a string");
+    }
+    await this.adapter.ensure();
+    return this.adapter.groupHas(key, subKey);
+  }
+  async groupDel(key, subKey) {
+    this.initAdapter();
+    if (!key || !subKey) {
+      return Promise.resolve();
+    }
+    await this.adapter.ensure();
+    return this.adapter.groupDel(key, subKey);
+  }
+  async close() {
+    this.initAdapter();
+    await this.adapter.ensure();
+    return this.adapter.close();
+  }
+  async flushAll() {
+    this.initAdapter();
+    await this.adapter.ensure();
+    return this.adapter.flushAll();
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class SingleFlightDBCache extends BaseDBCache {
+  constructor(opts) {
+    super(opts);
+    __publicField$1(this, "_pending");
+    this._pending = /* @__PURE__ */ new Map();
+  }
+  /**
+   * If a request for the same key is already in flight, reuse it.
+   * Otherwise, fetch, cache, and return the value.
+   */
+  autoCache(key, fn, { ttl } = {}) {
+    this.initAdapter();
+    if (!key) {
+      return fn();
+    }
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    if (this._pending.has(key)) {
+      return this._pending.get(key);
+    }
+    const task = (async () => {
+      try {
+        const hit = await super.get(key);
+        if (hit !== null) {
+          return hit;
+        }
+        const result = await fn();
+        await super.set(key, result, { ttl });
+        return result;
+      } finally {
+        this._pending.delete(key);
+      }
+    })();
+    this._pending.set(key, task);
+    return task;
+  }
+  /**
+   * Same logic as autoCache, but for group fields (hash).
+   */
+  autoCacheGroup(key, subKey, fn, { ttl } = {}) {
+    this.initAdapter();
+    if (!key || !subKey) {
+      return fn();
+    }
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    if (typeof subKey !== "string") {
+      throw new Error("subKey must be a string");
+    }
+    const pendingKey = `${key}-${subKey}`;
+    if (this._pending.has(pendingKey)) {
+      return this._pending.get(pendingKey);
+    }
+    const task = (async () => {
+      try {
+        const hit = await super.groupGet(key, subKey);
+        if (hit !== null) {
+          return hit;
+        }
+        const result = await fn();
+        await super.groupSet(key, subKey, result, { ttl });
+        return result;
+      } finally {
+        this._pending.delete(pendingKey);
+      }
+    })();
+    this._pending.set(pendingKey, task);
+    return task;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class LockDBCache extends SingleFlightDBCache {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_inFlight", /* @__PURE__ */ new Map());
+  }
+  async createLock(lockName) {
+    this.initAdapter();
+    if (!lockName) {
+      return false;
+    }
+    const key = this._formatLockKey(lockName);
+    const lastLockTime = this._inFlight.get(key);
+    if (lastLockTime && Date.now() - lastLockTime < this.defaultTtl) {
+      return false;
+    }
+    this._inFlight.set(key, Date.now());
+    try {
+      const exists = await this.has(key);
+      if (!exists) {
+        const result = await this.set(key, Date.now(), { ttl: this.defaultTtl, nx: true });
+        return result;
+      }
+      return false;
+    } finally {
+      this._inFlight.delete(key);
+      for (const [key2, value] of this._inFlight.entries()) {
+        if (Date.now() - value > this.defaultTtl) {
+          this._inFlight.delete(key2);
+        }
+      }
+    }
+  }
+  /**
+   * 检查锁是否已经过期：只要缓存层面已经没有该 key，就代表已过期或从未创建。
+   *
+   * @param lockName    锁的名称
+   * @returns           如果锁不存在或已过期，返回 true；否则返回 false
+   */
+  async isExpired(lockName) {
+    this.initAdapter();
+    if (!lockName) {
+      return true;
+    }
+    const key = this._formatLockKey(lockName);
+    const exists = await this.has(key);
+    return !exists;
+  }
+  /**
+   * 主动释放锁：删除对应的缓存 key
+   *
+   * @param lockName    锁的名称
+   */
+  async releaseLock(lockName) {
+    this.initAdapter();
+    if (!lockName) {
+      return;
+    }
+    const key = this._formatLockKey(lockName);
+    await this.del(key);
+  }
+  /**
+   * 等待锁释放或超时。每隔 100ms 检查一次缓存层面是否仍存在该锁 key。
+   * 如果在 timeoutMs 毫秒内 key 不再存在，则 resolve(true)。否则 resolve(false)。
+   *
+   * @param lockName     锁的名称
+   * @param timeoutMs    等待超时时间（毫秒），默认使用构造时传入的 this._timeout
+   * @returns            如果锁被释放或过期，resolve(true)；等待到超时还没释放，则 resolve(false)
+   */
+  // eslint-disable-next-line require-await
+  async waitUnLock(lockName, timeoutMs = this.defaultTtl) {
+    this.initAdapter();
+    if (!lockName) {
+      return true;
+    }
+    const key = this._formatLockKey(lockName);
+    const start = Date.now();
+    return new Promise((resolve) => {
+      const interval = setInterval(async () => {
+        const exists = await this.has(key);
+        if (!exists) {
+          clearInterval(interval);
+          resolve(true);
+        } else if (Date.now() - start >= timeoutMs) {
+          clearInterval(interval);
+          resolve(false);
+        }
+      }, 100);
+    });
+  }
+  /**
+   * 获取锁的流程：
+   *  1. 先尝试 createLock(lockName)：
+   *     - 如果立刻拿到（createLock 返回 true），直接返回；
+   *     - 如果没拿到，就等待 waitUnLock(lockName)。
+   *  2. 等待到释放/过期后，再次尝试 createLock(lockName)。
+   *
+   * @param lockName    锁的名称
+   */
+  async acquire(lockName) {
+    while (true) {
+      const acquired = await this.createLock(lockName);
+      if (acquired) {
+        return;
+      }
+      await this.waitUnLock(lockName);
+    }
+  }
+  _formatLockKey(lockName) {
+    return `lock:${this.prefix}:${lockName}`;
+  }
+}
+
+const isJestTest = () => {
+  return process.env.NODE_ENV === "test" || process.env.BABEL_ENV === "test" || typeof jest !== "undefined";
+};
+const getAbtNodeRedisAndSQLiteUrl = () => {
+  return {
+    redisUrl: process.env.ABT_NODE_CACHE_REDIS_URL,
+    sqlitePath: isJestTest() ? "test.db" : process.env.ABT_NODE_CACHE_SQLITE_PATH
+  };
+};
+
+export { LockDBCache as DBCache, getAbtNodeRedisAndSQLiteUrl };