vona-module-a-redis 5.0.8 → 5.0.10

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/index.js

@@ -0,0 +1,32 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/** main: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+/** bean: begin */
+import 'vona';
+/** service: end */
+/** service: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from "../bean/bean.redis.js";
+/** service: end */
+/** main: begin */
+export * from "../main.js";
+/** bean: end */
+/** service: begin */
+export * from "../service/redisClient.js";
+let ScopeModuleARedis = class ScopeModuleARedis extends BeanScopeBase {
+};
+ScopeModuleARedis = __decorate([
+    Scope()
+], ScopeModuleARedis);
+export { 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/.metadata/this.js

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

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/bean/bean.redis.js

@@ -0,0 +1,22 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BeanBase } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+import { ServiceRedisClient } from "../service/redisClient.js";
+let BeanRedis = class BeanRedis extends BeanBase {
+    getClient(clientName) {
+        return this.app.bean._getBeanSelector(ServiceRedisClient, clientName);
+    }
+    get(clientName) {
+        const client = this.getClient(clientName);
+        return client.instance;
+    }
+};
+BeanRedis = __decorate([
+    Bean()
+], BeanRedis);
+export { BeanRedis };

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,2 @@
+export * from "./.metadata/index.js";
+export * from "./types/index.js";

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/main.js

@@ -0,0 +1,32 @@
+import { BeanSimple, combineConfigDefault, deepExtend } from 'vona';
+export 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) { }
+}
+export 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}:` },
+        },
+    };
+}

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/service/redisClient.js

@@ -0,0 +1,78 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Redis } from 'ioredis';
+import { BeanBase, cast, deepExtend } from 'vona';
+import { Service } from 'vona-module-a-web';
+let ServiceRedisClient = class ServiceRedisClient extends BeanBase {
+    _redisInstance;
+    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);
+        }
+    }
+};
+ServiceRedisClient = __decorate([
+    Service()
+], ServiceRedisClient);
+export { ServiceRedisClient };

package/dist/types/index.d.ts

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

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from "./redis.js";

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/dist/types/redis.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-redis",
   "type": "module",
-  "version": "5.0.8",
+  "version": "5.0.10",
   "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 && tsc -p tsconfig.build.json"
   }
 }