@nocobase/cache 0.15.0-alpha.4 → 0.16.0-alpha.1

package/lib/cache-manager.d.ts

@@ -0,0 +1,35 @@
+import { FactoryStore, Store } from 'cache-manager';
+import { Cache } from './cache';
+type StoreOptions = {
+    store?: 'memory' | FactoryStore<Store, any>;
+    close?: (store: Store) => Promise<void>;
+    [key: string]: any;
+};
+export type CacheManagerOptions = Partial<{
+    defaultStore: string;
+    stores: {
+        [storeType: string]: StoreOptions;
+    };
+}>;
+export declare class CacheManager {
+    defaultStore: string;
+    private stores;
+    storeTypes: Map<string, StoreOptions>;
+    caches: Map<string, Cache>;
+    constructor(options?: CacheManagerOptions);
+    private createStore;
+    registerStore(options: {
+        name: string;
+    } & StoreOptions): void;
+    private newCache;
+    createCache(options: {
+        name: string;
+        prefix?: string;
+        store?: string;
+        [key: string]: any;
+    }): Promise<Cache>;
+    getCache(name: string): Cache;
+    flushAll(): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

package/lib/cache-manager.js

@@ -0,0 +1,131 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_manager_exports = {};
+__export(cache_manager_exports, {
+  CacheManager: () => CacheManager
+});
+module.exports = __toCommonJS(cache_manager_exports);
+var import_cache_manager = require("cache-manager");
+var import_cache = require("./cache");
+var import_lodash = __toESM(require("lodash"));
+var import_cache_manager_redis_yet = require("cache-manager-redis-yet");
+var import_deepmerge = __toESM(require("deepmerge"));
+const _CacheManager = class _CacheManager {
+  defaultStore;
+  stores = /* @__PURE__ */ new Map();
+  storeTypes = /* @__PURE__ */ new Map();
+  caches = /* @__PURE__ */ new Map();
+  constructor(options) {
+    const defaultOptions = {
+      defaultStore: "memory",
+      stores: {
+        memory: {
+          store: "memory",
+          // global config
+          max: 2e3
+        },
+        redis: {
+          store: import_cache_manager_redis_yet.redisStore,
+          close: async (redis) => {
+            await redis.client.quit();
+          }
+        }
+      }
+    };
+    const cacheOptions = (0, import_deepmerge.default)(defaultOptions, options || {});
+    const { defaultStore = "memory", stores } = cacheOptions;
+    this.defaultStore = defaultStore;
+    for (const [name, store] of Object.entries(stores)) {
+      const { store: s, ...globalConfig } = store;
+      this.registerStore({ name, store: s, ...globalConfig });
+    }
+  }
+  async createStore(options) {
+    const { name, storeType: type, ...config } = options;
+    const storeType = this.storeTypes.get(type);
+    if (!storeType) {
+      throw new Error(`Create cache failed, store type [${type}] is unavailable or not registered`);
+    }
+    const { store: s, close, ...globalConfig } = storeType;
+    const store = await (0, import_cache_manager.caching)(s, { ...globalConfig, ...config });
+    this.stores.set(name, { close, store });
+    return store;
+  }
+  registerStore(options) {
+    const { name, ...rest } = options;
+    this.storeTypes.set(name, rest);
+  }
+  newCache(options) {
+    const { name, prefix, store } = options;
+    const cache = new import_cache.Cache({ name, prefix, store });
+    this.caches.set(name, cache);
+    return cache;
+  }
+  async createCache(options) {
+    const { name, prefix, store = this.defaultStore, ...config } = options;
+    if (!import_lodash.default.isEmpty(config)) {
+      const newStore = await this.createStore({ name, storeType: store, ...config });
+      return this.newCache({ name, prefix, store: newStore });
+    }
+    const s = this.stores.get(store);
+    if (!s) {
+      const defaultStore = await this.createStore({ name: store, storeType: store });
+      return this.newCache({ name, prefix, store: defaultStore });
+    }
+    return this.newCache({ name, prefix, store: s.store });
+  }
+  getCache(name) {
+    const cache = this.caches.get(name);
+    if (!cache) {
+      throw new Error(`Get cache failed, ${name} is not found`);
+    }
+    return cache;
+  }
+  async flushAll() {
+    const promises = [];
+    for (const cache of this.caches.values()) {
+      promises.push(cache.reset());
+    }
+    await Promise.all(promises);
+  }
+  async close() {
+    const promises = [];
+    for (const s of this.stores.values()) {
+      const { close, store } = s;
+      close && promises.push(close(store.store));
+    }
+    await Promise.all(promises);
+  }
+};
+__name(_CacheManager, "CacheManager");
+let CacheManager = _CacheManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheManager
+});

package/lib/cache.d.ts

@@ -0,0 +1,29 @@
+import { Cache as BasicCache, Milliseconds } from 'cache-manager';
+export declare class Cache {
+    name: string;
+    prefix?: string;
+    store: BasicCache;
+    constructor({ name, prefix, store }: {
+        name: string;
+        store: BasicCache;
+        prefix?: string;
+    });
+    key(key: string): string;
+    set(key: string, value: unknown, ttl?: Milliseconds): Promise<void>;
+    get<T>(key: string): Promise<T>;
+    del(key: string): Promise<void>;
+    reset(): Promise<void>;
+    wrap<T>(key: string, fn: () => Promise<T>, ttl?: Milliseconds): Promise<T>;
+    wrapWithCondition<T>(key: string, fn: () => T | Promise<T>, options?: {
+        useCache?: boolean;
+        isCacheable?: (val: unknown) => boolean | Promise<boolean>;
+        ttl?: Milliseconds;
+    }): Promise<T>;
+    mset(args: [string, unknown][], ttl?: Milliseconds): Promise<void>;
+    mget(...args: string[]): Promise<unknown[]>;
+    mdel(...args: string[]): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+    ttl(key: string): Promise<number>;
+    setValueInObject(key: string, objectKey: string, value: unknown): Promise<void>;
+    getValueInObject(key: string, objectKey: string): Promise<any>;
+}

package/lib/cache.js

@@ -0,0 +1,104 @@
+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 cache_exports = {};
+__export(cache_exports, {
+  Cache: () => Cache
+});
+module.exports = __toCommonJS(cache_exports);
+const _Cache = class _Cache {
+  name;
+  prefix;
+  store;
+  constructor({ name, prefix, store }) {
+    this.name = name;
+    this.prefix = prefix;
+    this.store = store;
+  }
+  key(key) {
+    return this.prefix ? `${this.prefix}:${key}` : key;
+  }
+  async set(key, value, ttl) {
+    await this.store.set(this.key(key), value, ttl);
+  }
+  async get(key) {
+    return await this.store.get(this.key(key));
+  }
+  async del(key) {
+    await this.store.del(this.key(key));
+  }
+  async reset() {
+    await this.store.reset();
+  }
+  async wrap(key, fn, ttl) {
+    return await this.store.wrap(this.key(key), fn, ttl);
+  }
+  async wrapWithCondition(key, fn, options) {
+    const { useCache, isCacheable, ttl } = options || {};
+    if (useCache === false) {
+      return await fn();
+    }
+    const value = await this.get(key);
+    if (value) {
+      return value;
+    }
+    const result = await fn();
+    const cacheable = isCacheable ? await isCacheable(result) : result;
+    if (!cacheable) {
+      return result;
+    }
+    await this.set(key, result, ttl);
+    return result;
+  }
+  async mset(args, ttl) {
+    await this.store.store.mset(
+      args.map(([key, value]) => [this.key(key), value]),
+      ttl
+    );
+  }
+  async mget(...args) {
+    args = args.map((key) => this.key(key));
+    return await this.store.store.mget(...args);
+  }
+  async mdel(...args) {
+    args = args.map((key) => this.key(key));
+    await this.store.store.mdel(...args);
+  }
+  async keys(pattern) {
+    const keys = await this.store.store.keys(pattern);
+    return keys.map((key) => key.replace(`${this.name}:`, ""));
+  }
+  async ttl(key) {
+    return await this.store.store.ttl(this.key(key));
+  }
+  async setValueInObject(key, objectKey, value) {
+    const object = await this.get(key) || {};
+    object[objectKey] = value;
+    await this.set(key, object);
+  }
+  async getValueInObject(key, objectKey) {
+    const object = await this.get(key) || {};
+    return object[objectKey];
+  }
+};
+__name(_Cache, "Cache");
+let Cache = _Cache;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache
+});

package/lib/index.d.ts

@@ -1,30 +1,2 @@
-import { CacheOptions, CachingConfig, StoreConfig, WrapArgsType } from 'cache-manager';
-/**
- * be used for create cache {@link createCache}
- */
-export type ICacheConfig = StoreConfig & CacheOptions & {
-    storePackage?: string;
-};
-/**
- * create a default cache config object
- * @returns {ICacheConfig}
- */
-export declare function createDefaultCacheConfig(): ICacheConfig;
-/**
- * cache and multi cache common method and only keep promise method
- */
-export interface Cache {
-    set<T>(key: string, value: T, options?: CachingConfig): Promise<T>;
-    set<T>(key: string, value: T, ttl: number): Promise<T>;
-    wrap<T>(...args: WrapArgsType<T>[]): Promise<T>;
-    get<T>(key: string): Promise<T | undefined>;
-    del(key: string): Promise<any>;
-    reset(): Promise<void>;
-}
-/**
- * create cache
- * <br/> if cacheConfig is array and length gt 1 then will be return multi cache, else will be return cache
- * @param {ICacheConfig | ICacheConfig[]} cacheConfig
- * @returns {Cache}
- */
-export declare function createCache(cacheConfig?: ICacheConfig | ICacheConfig[]): Cache;
+export * from './cache-manager';
+export * from './cache';

package/lib/index.js

@@ -2,11 +2,6 @@ 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))
@@ -15,48 +10,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
-__export(src_exports, {
-  createCache: () => createCache,
-  createDefaultCacheConfig: () => createDefaultCacheConfig
-});
 module.exports = __toCommonJS(src_exports);
-var import_cache_manager = require("cache-manager");
-function createDefaultCacheConfig() {
-  return {
-    ttl: 86400,
-    // seconds
-    max: 1e3,
-    store: "memory"
-  };
-}
-__name(createDefaultCacheConfig, "createDefaultCacheConfig");
-function createCache(cacheConfig = createDefaultCacheConfig()) {
-  if (Array.isArray(cacheConfig)) {
-    if (cacheConfig.length === 1) {
-      return createCacheByICacheConfig(cacheConfig[0]);
-    } else {
-      const caches = [];
-      for (const cacheConfigEle of cacheConfig) {
-        caches.push(createCacheByICacheConfig(cacheConfigEle));
-      }
-      return (0, import_cache_manager.multiCaching)(caches);
-    }
-  } else {
-    return createCacheByICacheConfig(cacheConfig);
-  }
-}
-__name(createCache, "createCache");
-function createCacheByICacheConfig(cacheConfig) {
-  if (cacheConfig.storePackage) {
-    cacheConfig.store = require(cacheConfig.storePackage);
-  }
-  return (0, import_cache_manager.caching)(cacheConfig);
-}
-__name(createCacheByICacheConfig, "createCacheByICacheConfig");
+__reExport(src_exports, require("./cache-manager"), module.exports);
+__reExport(src_exports, require("./cache"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createCache,
-  createDefaultCacheConfig
+  ...require("./cache-manager"),
+  ...require("./cache")
 });

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@nocobase/cache",
-  "version": "0.15.0-alpha.4",
+  "version": "0.16.0-alpha.1",
   "description": "",
   "license": "Apache-2.0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "dependencies": {
-    "cache-manager": "^4.1.0"
+    "cache-manager": "^5.2.4",
+    "cache-manager-redis-yet": "^4.1.2"
   },
   "devDependencies": {
-    "@types/cache-manager": "^4.0.2",
-    "cache-manager-fs-hash": "^1.0.0"
+    "redis": "^4.6.10"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/cache"
   },
-  "gitHead": "380045c660ea0432f3e8fd7cf01c3cfe7275db34"
+  "gitHead": "e8aaf48d169448376a06d87f090786cd7649255e"
 }