@nocobase/cache 1.6.0-beta.3 → 1.6.0-beta.5

package/lib/bloom-filter/redis-bloom-filter.d.ts

@@ -6,7 +6,6 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { RedisStore } from 'cache-manager-redis-yet';
 import { BloomFilter } from '.';
 import { Cache } from '../cache';
 /**
@@ -15,7 +14,7 @@ import { Cache } from '../cache';
 export declare class RedisBloomFilter implements BloomFilter {
     cache: Cache;
     constructor(cache: Cache);
-    getStore(): RedisStore<import("redis").RedisClientType>;
+    private get store();
     reserve(key: string, errorRate: number, capacity: number): Promise<void>;
     add(key: string, value: string): Promise<void>;
     mAdd(key: string, values: string[]): Promise<void>;

package/lib/bloom-filter/redis-bloom-filter.js

@@ -36,24 +36,27 @@ const _RedisBloomFilter = class _RedisBloomFilter {
   constructor(cache) {
     this.cache = cache;
   }
-  getStore() {
+  get store() {
     return this.cache.store.store;
   }
   async reserve(key, errorRate, capacity) {
-    const store = this.getStore();
-    await store.client.bf.reserve(key, errorRate, capacity);
+    try {
+      await this.store.client.bf.reserve(key, errorRate, capacity);
+    } catch (error) {
+      if (error.message.includes("ERR item exists")) {
+        return;
+      }
+      throw error;
+    }
   }
   async add(key, value) {
-    const store = this.getStore();
-    await store.client.bf.add(key, value);
+    await this.store.client.bf.add(key, value);
   }
   async mAdd(key, values) {
-    const store = this.getStore();
-    await store.client.bf.mAdd(key, values);
+    await this.store.client.bf.mAdd(key, values);
   }
   async exists(key, value) {
-    const store = this.getStore();
-    return await store.client.bf.exists(key, value);
+    return this.store.client.bf.exists(key, value);
   }
 };
 __name(_RedisBloomFilter, "RedisBloomFilter");

package/lib/cache-manager.d.ts

@@ -9,6 +9,8 @@
 import { FactoryStore, Store } from 'cache-manager';
 import { Cache } from './cache';
 import { BloomFilter } from './bloom-filter';
+import { Counter } from './counter';
+import { LockManager } from '@nocobase/lock-manager';
 type StoreOptions = {
     store?: 'memory' | FactoryStore<Store, any>;
     close?: (store: Store) => Promise<void>;
@@ -19,9 +21,11 @@ export type CacheManagerOptions = Partial<{
     stores: {
         [storeType: string]: StoreOptions;
     };
+    prefix: string;
 }>;
 export declare class CacheManager {
     defaultStore: string;
+    prefix?: string;
     private stores;
     /**
      * @internal
@@ -52,5 +56,13 @@ export declare class CacheManager {
     createBloomFilter(options?: {
         store?: string;
     }): Promise<BloomFilter>;
+    /**
+     * @experimental
+     */
+    createCounter(options: {
+        name: string;
+        prefix?: string;
+        store?: string;
+    }, lockManager?: LockManager): Promise<Counter>;
 }
 export {};

package/lib/cache-manager.js

@@ -47,8 +47,10 @@ var import_cache_manager_redis_yet = require("cache-manager-redis-yet");
 var import_deepmerge = __toESM(require("deepmerge"));
 var import_memory_bloom_filter = require("./bloom-filter/memory-bloom-filter");
 var import_redis_bloom_filter = require("./bloom-filter/redis-bloom-filter");
+var import_counter = require("./counter");
 const _CacheManager = class _CacheManager {
   defaultStore;
+  prefix;
   stores = /* @__PURE__ */ new Map();
   /**
    * @internal
@@ -80,8 +82,9 @@ const _CacheManager = class _CacheManager {
       }
     };
     const cacheOptions = (0, import_deepmerge.default)(defaultOptions, options || {});
-    const { defaultStore = "memory", stores } = cacheOptions;
+    const { defaultStore = "memory", stores, prefix } = cacheOptions;
     this.defaultStore = defaultStore;
+    this.prefix = prefix;
     for (const [name, store] of Object.entries(stores)) {
       const { store: s, ...globalConfig } = store;
       this.registerStore({ name, store: s, ...globalConfig });
@@ -109,7 +112,9 @@ const _CacheManager = class _CacheManager {
     return cache;
   }
   async createCache(options) {
-    const { name, prefix, store = this.defaultStore, ...config } = options;
+    const { name, store = this.defaultStore, ...config } = options;
+    let { prefix } = options;
+    prefix = this.prefix ? prefix ? `${this.prefix}:${prefix}` : this.prefix : prefix;
     if (!import_lodash.default.isEmpty(config) || store === "memory") {
       const newStore = await this.createStore({ name, storeType: store, ...config });
       return this.newCache({ name, prefix, store: newStore });
@@ -164,6 +169,31 @@ const _CacheManager = class _CacheManager {
         throw new Error(`BloomFilter store [${store}] is not supported`);
     }
   }
+  /**
+   * @experimental
+   */
+  async createCounter(options, lockManager) {
+    const { store = this.defaultStore, name, prefix } = options || {};
+    let cache;
+    if (store !== "memory") {
+      try {
+        cache = this.getCache(name);
+      } catch (error) {
+        cache = await this.createCache({ name, store, prefix });
+      }
+    }
+    switch (store) {
+      case "memory":
+        return new import_counter.MemoryCounter();
+      case "redis":
+        return new import_counter.RedisCounter(cache);
+      default:
+        if (!lockManager) {
+          throw new Error(`Counter store [${store}] is not supported`);
+        }
+        return new import_counter.LockCounter(cache, lockManager);
+    }
+  }
 };
 __name(_CacheManager, "CacheManager");
 let CacheManager = _CacheManager;

package/lib/counter/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/**
+ * @experimental
+ * atomic counter
+ */
+export interface Counter {
+    get(key: string): Promise<number>;
+    incr(key: string): Promise<number>;
+    incr(key: string, ttl: number): Promise<number>;
+    incrby(key: string, val: number): Promise<number>;
+    incrby(key: string, val: number, ttl: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}
+export { MemoryCounter } from './memory-counter';
+export { RedisCounter } from './redis-counter';
+export { LockCounter } from './lock-counter';

package/lib/counter/index.js

@@ -0,0 +1,42 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var counter_exports = {};
+__export(counter_exports, {
+  LockCounter: () => import_lock_counter.LockCounter,
+  MemoryCounter: () => import_memory_counter.MemoryCounter,
+  RedisCounter: () => import_redis_counter.RedisCounter
+});
+module.exports = __toCommonJS(counter_exports);
+var import_memory_counter = require("./memory-counter");
+var import_redis_counter = require("./redis-counter");
+var import_lock_counter = require("./lock-counter");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LockCounter,
+  MemoryCounter,
+  RedisCounter
+});

package/lib/counter/lock-counter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { LockManager } from '@nocobase/lock-manager';
+import { Counter as ICounter } from '.';
+import { Cache } from '../cache';
+/**
+ * @experimental
+ */
+export declare class LockCounter implements ICounter {
+    cache: Cache;
+    lockManager: LockManager;
+    constructor(cache: Cache, lockManager: LockManager);
+    get(key: string): Promise<number>;
+    incr(key: string, ttl?: number): Promise<number>;
+    incrby(key: string, value: number, ttl?: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}

package/lib/counter/lock-counter.js

@@ -0,0 +1,70 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lock_counter_exports = {};
+__export(lock_counter_exports, {
+  LockCounter: () => LockCounter
+});
+module.exports = __toCommonJS(lock_counter_exports);
+const _LockCounter = class _LockCounter {
+  cache;
+  lockManager;
+  constructor(cache, lockManager) {
+    this.cache = cache;
+    this.lockManager = lockManager;
+  }
+  async get(key) {
+    return await this.cache.get(key) || 0;
+  }
+  async incr(key, ttl) {
+    return this.incrby(key, 1, ttl);
+  }
+  async incrby(key, value, ttl) {
+    const lockKey = `lock:${key}`;
+    const release = await this.lockManager.acquire(lockKey, 3e3);
+    try {
+      const v = await this.cache.get(key);
+      const n = v || 0;
+      const newValue = n + value;
+      await this.cache.set(key, newValue, ttl);
+      return newValue;
+    } catch (error) {
+      throw error;
+    } finally {
+      await release();
+    }
+  }
+  async reset(key) {
+    return this.cache.del(key);
+  }
+};
+__name(_LockCounter, "LockCounter");
+let LockCounter = _LockCounter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LockCounter
+});

package/lib/counter/memory-counter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Counter as ICounter } from '.';
+declare class Cache {
+    data: Map<any, any>;
+    timers: Map<any, any>;
+    set(k: string, v: any, ttl?: number): void;
+    get(k: string): any;
+    del(k: string): boolean;
+}
+/**
+ * @experimental
+ */
+export declare class MemoryCounter implements ICounter {
+    cache: Cache;
+    get(key: string): Promise<any>;
+    incr(key: string, ttl?: number): Promise<any>;
+    incrby(key: string, value: number, ttl?: number): Promise<any>;
+    reset(key: string): Promise<void>;
+}
+export {};

package/lib/counter/memory-counter.js

@@ -0,0 +1,89 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var memory_counter_exports = {};
+__export(memory_counter_exports, {
+  MemoryCounter: () => MemoryCounter
+});
+module.exports = __toCommonJS(memory_counter_exports);
+const _Cache = class _Cache {
+  data = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  set(k, v, ttl) {
+    if (ttl) {
+      if (this.timers.has(k)) {
+        clearTimeout(this.timers.get(k));
+      }
+      this.timers.set(
+        k,
+        setTimeout(() => this.del(k), ttl)
+      );
+    }
+    this.data.set(k, v);
+  }
+  get(k) {
+    return this.data.get(k);
+  }
+  del(k) {
+    if (this.timers.has(k)) {
+      clearTimeout(this.timers.get(k));
+    }
+    this.timers.delete(k);
+    return this.data.delete(k);
+  }
+};
+__name(_Cache, "Cache");
+let Cache = _Cache;
+const _MemoryCounter = class _MemoryCounter {
+  cache = new Cache();
+  async get(key) {
+    return this.cache.get(key) || 0;
+  }
+  async incr(key, ttl) {
+    return this.incrby(key, 1, ttl);
+  }
+  async incrby(key, value, ttl) {
+    const v = this.cache.get(key);
+    const n = v || 0;
+    const newValue = n + value;
+    if (!v) {
+      this.cache.set(key, newValue, ttl);
+    } else {
+      this.cache.set(key, newValue);
+    }
+    return newValue;
+  }
+  async reset(key) {
+    this.cache.del(key);
+  }
+};
+__name(_MemoryCounter, "MemoryCounter");
+let MemoryCounter = _MemoryCounter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryCounter
+});

package/lib/counter/redis-counter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Counter as ICounter } from '.';
+import { Cache } from '../cache';
+/**
+ * @experimental
+ */
+export declare class RedisCounter implements ICounter {
+    cache: Cache;
+    scriptSha: string;
+    constructor(cache: Cache);
+    private get store();
+    get(key: string): Promise<number>;
+    incr(key: string, ttl?: number): Promise<number>;
+    incrby(key: string, value: number, ttl?: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}

package/lib/counter/redis-counter.js

@@ -0,0 +1,77 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var redis_counter_exports = {};
+__export(redis_counter_exports, {
+  RedisCounter: () => RedisCounter
+});
+module.exports = __toCommonJS(redis_counter_exports);
+const script = `
+local key = KEYS[1]
+local value = tonumber(ARGV[1]) or 1
+local ttl = tonumber(ARGV[2])
+local current = redis.call('INCRBY', key, value)
+if tonumber(current) == value and ttl then
+  redis.call('PEXPIRE', key, ttl)
+end
+return current
+`;
+const _RedisCounter = class _RedisCounter {
+  cache;
+  scriptSha;
+  constructor(cache) {
+    this.cache = cache;
+  }
+  get store() {
+    return this.cache.store.store;
+  }
+  async get(key) {
+    return await this.cache.get(key) || 0;
+  }
+  async incr(key, ttl) {
+    return this.incrby(key, 1, ttl);
+  }
+  async incrby(key, value, ttl) {
+    if (!this.scriptSha) {
+      this.scriptSha = await this.store.client.scriptLoad(script);
+    }
+    const result = await this.store.client.evalSha(this.scriptSha, {
+      keys: [this.cache.key(key)],
+      arguments: [value, ttl].map((v) => v ? v.toString() : "")
+    });
+    return Number(result);
+  }
+  async reset(key) {
+    return this.cache.del(key);
+  }
+};
+__name(_RedisCounter, "RedisCounter");
+let RedisCounter = _RedisCounter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisCounter
+});

package/lib/index.d.ts

@@ -9,3 +9,4 @@
 export * from './cache-manager';
 export * from './cache';
 export * from './bloom-filter';
+export * from './counter';

package/lib/index.js

@@ -26,9 +26,11 @@ module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("./cache-manager"), module.exports);
 __reExport(src_exports, require("./cache"), module.exports);
 __reExport(src_exports, require("./bloom-filter"), module.exports);
+__reExport(src_exports, require("./counter"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./cache-manager"),
   ...require("./cache"),
-  ...require("./bloom-filter")
+  ...require("./bloom-filter"),
+  ...require("./counter")
 });

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@nocobase/cache",
-  "version": "1.6.0-beta.3",
+  "version": "1.6.0-beta.5",
   "description": "",
   "license": "AGPL-3.0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "dependencies": {
+    "@nocobase/lock-manager": "1.6.0-alpha.6",
     "bloom-filters": "^3.0.1",
     "cache-manager": "^5.2.4",
     "cache-manager-redis-yet": "^4.1.2"
@@ -18,5 +19,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/cache"
   },
-  "gitHead": "19a659c49d7eedd3d57e46f9df2e8540f55c99b7"
+  "gitHead": "66e7c7239b29361bc60543886d107ba0e00085d9"
 }