vona-module-a-redis 5.0.9 → 5.0.11

package/dist/.metadata/index.d.ts

@@ -0,0 +1,68 @@
+import type { BeanScopeUtil } from 'vona';
+/** bean: end */
+/** bean: begin */
+import type { BeanRedis } from '../bean/bean.redis.ts';
+/** service: end */
+/** service: begin */
+import type { ServiceRedisClient } from '../service/redisClient.ts';
+/** main: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+/** bean: begin */
+import 'vona';
+/** service: end */
+/** service: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from '../bean/bean.redis.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-a-redis' {
+    interface BeanRedis {
+    }
+}
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        redis: BeanRedis;
+    }
+}
+/** service: end */
+/** main: begin */
+export * from '../main.ts';
+declare module 'vona-module-a-web' {
+    interface IServiceRecord {
+        'a-redis:redisClient': never;
+    }
+}
+declare module 'vona-module-a-redis' {
+    interface ServiceRedisClient {
+    }
+}
+export interface IModuleService {
+    redisClient: ServiceRedisClient;
+}
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'a-redis.service.redisClient': ServiceRedisClient;
+    }
+}
+/** bean: end */
+/** service: begin */
+export * from '../service/redisClient.ts';
+export declare class ScopeModuleARedis extends BeanScopeBase {
+}
+export interface ScopeModuleARedis {
+    util: BeanScopeUtil;
+    service: IModuleService;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-redis': ScopeModuleARedis;
+    }
+    interface IBeanScopeContainer {
+        redis: ScopeModuleARedis;
+    }
+}
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-redis";
+export { ScopeModuleARedis as ScopeModule } from './index.ts';

package/dist/bean/bean.redis.d.ts

@@ -0,0 +1,7 @@
+import type { IRedisClientRecord } from '../types/redis.ts';
+import { BeanBase } from 'vona';
+import { ServiceRedisClient } from '../service/redisClient.ts';
+export declare class BeanRedis extends BeanBase {
+    getClient(clientName?: keyof IRedisClientRecord): ServiceRedisClient;
+    get(clientName?: keyof IRedisClientRecord): import("ioredis").default;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './.metadata/index.ts';
+export * from './types/index.ts';

package/dist/index.js

@@ -0,0 +1,136 @@
+import { BeanInfo, BeanBase, cast, deepExtend, BeanSimple, combineConfigDefault, BeanScopeBase } from 'vona';
+import { Bean, Scope } from 'vona-module-a-bean';
+import { Redis } from 'ioredis';
+import { Service } from 'vona-module-a-web';
+
+var _dec$2, _dec2$2, _class$2;
+let ServiceRedisClient = (_dec$2 = Service(), _dec2$2 = BeanInfo({
+  module: "a-redis"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = class ServiceRedisClient extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._redisInstance = void 0;
+  }
+  get instance() {
+    return this._redisInstance;
+  }
+  __init__(clientName) {
+    // instance
+    this._redisInstance = this._createClient(clientName);
+  }
+  async __dispose__() {
+    await this._redisInstance?.quit();
+  }
+  _createClient(clientName) {
+    clientName = clientName || 'default';
+    const configRedis = this.app.config.redis;
+    const configClient = configRedis.clients[clientName];
+    if (!configClient) throw new Error(`redis client not found: ${clientName}`);
+    if (cast(configClient).sentinels) {
+      // sentinels
+      return new Redis(configClient);
+    } else if (cast(configClient).nodes) {
+      return new Redis.Cluster(cast(configClient).nodes, cast(configClient));
+    } else {
+      const configNode = deepExtend({}, configRedis.default, configClient);
+      return new Redis(configNode);
+    }
+  }
+  async clearAllData() {
+    const app = this.app;
+    // clear keys
+    // await this._clearRedisKeys(app.bean.redis.get('limiter'), `b_${app.name}:*`);
+    await this._clearRedisKeys(app.bean.redis.get('queue'), `bull_${app.name}:*`);
+    // broadcast channel has subscribed
+    // await _clearRedisKeys(app.redis.get('broadcast'), `broadcast_${app.name}:*`);
+    // redlock
+    for (const clientName of this.$scope.redlock.config.redlock.clients) {
+      await this._clearRedisKeys(app.bean.redis.get(clientName), `redlock_${app.name}:*`);
+    }
+    for (const clientName in app.config.redis.clients) {
+      if (['redlock', 'limiter', 'queue', 'broadcast'].includes(clientName)) continue;
+      if (clientName.includes('redlock')) continue;
+      const client = app.config.redis.clients[clientName];
+      await this._clearRedisKeys(app.bean.redis.get(clientName), `${client.keyPrefix}*`);
+    }
+  }
+  async _clearRedisKeys(redis, pattern) {
+    if (!redis) return;
+    const keyPrefix = redis.options.keyPrefix;
+    const keys = await redis.keys(pattern);
+    const keysDel = [];
+    for (const fullKey of keys) {
+      const key = keyPrefix ? fullKey.substring(keyPrefix.length) : fullKey;
+      keysDel.push(key);
+    }
+    if (keysDel.length > 0) {
+      await redis.del(keysDel);
+    }
+  }
+}) || _class$2) || _class$2);
+
+var _dec$1, _dec2$1, _class$1;
+let BeanRedis = (_dec$1 = Bean(), _dec2$1 = BeanInfo({
+  module: "a-redis"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class BeanRedis extends BeanBase {
+  getClient(clientName) {
+    return this.app.bean._getBeanSelector(ServiceRedisClient, clientName);
+  }
+  get(clientName) {
+    const client = this.getClient(clientName);
+    return client.instance;
+  }
+}) || _class$1) || _class$1);
+
+class Main extends BeanSimple {
+  async moduleLoading() {
+    const _configDefault = await combineConfigDefault(this.app, configDefault);
+    this.app.config.redis = deepExtend({}, _configDefault, this.app.config.redis);
+  }
+  async moduleLoaded() {}
+  async configLoaded(_config) {}
+}
+async function configDefault(app) {
+  return {
+    default: {
+      host: app.meta.env.REDIS_DEFAULT_HOST,
+      port: Number.parseInt(app.meta.env.REDIS_DEFAULT_PORT),
+      password: app.meta.env.REDIS_DEFAULT_PASSWORD,
+      db: Number.parseInt(app.meta.env.REDIS_DEFAULT_DB),
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false
+    },
+    clients: {
+      default: {
+        keyPrefix: `default_${app.name}:`
+      },
+      redlock: {},
+      queue: {},
+      broadcast: {},
+      cache: {
+        keyPrefix: `cache_${app.name}:`
+      },
+      io: {
+        keyPrefix: `io_${app.name}:`
+      },
+      auth: {
+        keyPrefix: `auth_${app.name}:`
+      },
+      summer: {
+        keyPrefix: `summer_${app.name}:`
+      },
+      model: {
+        keyPrefix: `model_${app.name}:`
+      }
+    }
+  };
+}
+
+var _dec, _dec2, _class;
+let ScopeModuleARedis = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-redis"
+}), _dec(_class = _dec2(_class = class ScopeModuleARedis extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+export { BeanRedis, Main, ScopeModuleARedis, ServiceRedisClient, configDefault };

package/dist/main.d.ts

@@ -0,0 +1,9 @@
+import type { IModuleMain, PowerPartial, VonaApplication } from 'vona';
+import type { ConfigRedis } from './types/redis.ts';
+import { BeanSimple } from 'vona';
+export declare class Main extends BeanSimple implements IModuleMain {
+    moduleLoading(): Promise<void>;
+    moduleLoaded(): Promise<void>;
+    configLoaded(_config: any): Promise<void>;
+}
+export declare function configDefault(app: VonaApplication): Promise<PowerPartial<ConfigRedis>>;

package/dist/service/redisClient.d.ts

@@ -0,0 +1,11 @@
+import { Redis } from 'ioredis';
+import { BeanBase } from 'vona';
+export declare class ServiceRedisClient extends BeanBase {
+    private _redisInstance;
+    get instance(): Redis;
+    protected __init__(clientName?: string): void;
+    protected __dispose__(): Promise<void>;
+    private _createClient;
+    clearAllData(): Promise<void>;
+    private _clearRedisKeys;
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './redis.ts';

package/dist/types/redis.d.ts

@@ -0,0 +1,30 @@
+import type { ClusterOptions, RedisOptions } from 'ioredis';
+export interface IRedisClientRecord {
+    default: never;
+    redlock: never;
+    queue: never;
+    broadcast: never;
+    cache: never;
+    io: never;
+    auth: never;
+    summer: never;
+    model: never;
+}
+export interface ConfigRedisCluster extends ClusterOptions {
+    nodes: RedisOptions[];
+}
+export interface ConfigRedis {
+    default: RedisOptions;
+    clients: Record<keyof IRedisClientRecord, RedisOptions | ConfigRedisCluster>;
+}
+declare module 'vona' {
+    interface VonaConfig {
+        redis: ConfigRedis;
+    }
+    interface VonaConfigEnv {
+        REDIS_DEFAULT_HOST: string | undefined;
+        REDIS_DEFAULT_PORT: string | undefined;
+        REDIS_DEFAULT_PASSWORD: string | undefined;
+        REDIS_DEFAULT_DB: string | undefined;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-redis",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.11",
   "title": "a-redis",
   "vonaModule": {
     "dependencies": {},
@@ -31,8 +31,12 @@
   "dependencies": {
     "ioredis": "^5.4.1"
   },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
   "scripts": {
-    "clean": "rimraf dist tsconfig.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc"
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }