@koalarx/nest 1.14.3 → 1.15.0

package/core/backgroud-services/cron-service/cron-job.handler.base.d.ts

@@ -2,13 +2,15 @@ import { ILoggingService } from '../../../services/logging/ilogging.service';
 import { IRedLockService } from '../../../services/redlock/ired-lock.service';
 import { RequestResult } from '../../request-overflow/request-result';
 export type CronJobResponse = RequestResult<Error, null>;
+export interface CronJobSettings {
+    isActive: boolean;
+    timeInMinutes: number;
+}
 export declare abstract class CronJobHandlerBase {
     private readonly redlockService;
     private readonly loggingService;
-    private readonly _timeout;
     constructor(redlockService: IRedLockService, loggingService: ILoggingService);
     protected abstract run(): Promise<CronJobResponse>;
-    protected abstract isActive(): Promise<boolean>;
-    protected abstract defineTimeInMinutes(): number;
+    protected abstract settings(): Promise<CronJobSettings>;
     start(): Promise<void>;
 }

package/core/backgroud-services/cron-service/cron-job.handler.base.js

@@ -6,17 +6,17 @@ const koala_global_vars_1 = require("../../koala-global-vars");
 class CronJobHandlerBase {
     redlockService;
     loggingService;
-    _timeout;
     constructor(redlockService, loggingService) {
         this.redlockService = redlockService;
         this.loggingService = loggingService;
-        this._timeout = this.defineTimeInMinutes() * 60 * 1000;
     }
     async start() {
         const name = this.constructor.name;
         while (true) {
-            if (await this.isActive()) {
-                const ttlSecondsLock = this._timeout / 1000;
+            const settings = await this.settings();
+            const timeout = settings.timeInMinutes * 60 * 1000;
+            if (settings.isActive) {
+                const ttlSecondsLock = timeout / 1000;
                 const acquiredLock = await this.redlockService.acquiredLock(name, ttlSecondsLock);
                 if (acquiredLock) {
                     const error = await this.run()
@@ -41,7 +41,7 @@ class CronJobHandlerBase {
                     }
                 }
             }
-            await (0, KlDelay_1.delay)(this._timeout);
+            await (0, KlDelay_1.delay)(timeout);
             await this.redlockService.releaseLock(name);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "1.14.3",
+  "version": "1.15.0",
   "description": "",
   "repository": {
     "type": "git",
@@ -14,7 +14,7 @@
   "homepage": "https://github.com/igordrangel/koala-nest#readme",
   "types": "./koala-nest.d.ts",
   "peerDependencies": {
-    "@koalarx/utils": "^4.2.0",
+    "@koalarx/utils": "^4.2.1",
     "@nestjs/common": "^11.0.12",
     "@nestjs/config": "^4.0.1",
     "@nestjs/core": "^11.0.12",

package/services/redis/iredis.service.d.ts

@@ -1,4 +1,5 @@
 export declare abstract class IRedisService {
+    abstract isConnected: boolean;
     abstract getCache(key: string): Promise<string | null>;
     abstract setCache(key: string, ttlSecondsCache: number, payload: any): Promise<void>;
     abstract deleteCache(key: string): Promise<void>;

package/services/redis/redis.service.d.ts

@@ -4,6 +4,7 @@ import { IRedisService } from './iredis.service';
 export declare class RedisService implements IRedisService, OnModuleDestroy {
     private readonly redisClient;
     private readonly environment;
+    get isConnected(): boolean;
     constructor(env: EnvService);
     onModuleDestroy(): void;
     getCache(key: string): Promise<string | null>;

package/services/redis/redis.service.js

@@ -17,6 +17,9 @@ const env_service_1 = require("../../env/env.service");
 let RedisService = class RedisService {
     redisClient;
     environment;
+    get isConnected() {
+        return !!this.redisClient;
+    }
     constructor(env) {
         if (!env_config_1.EnvConfig.isEnvTest) {
             const redisUrl = env.get('REDIS_CONNECTION_STRING');

package/services/redlock/red-lock.service.js

@@ -19,7 +19,7 @@ let RedLockService = class RedLockService {
         this.redisService = redisService;
     }
     async acquiredLock(key, ttlSecondsLock) {
-        if (env_config_1.EnvConfig.isEnvTest) {
+        if (env_config_1.EnvConfig.isEnvTest || !this.redisService.isConnected) {
             return true;
         }
         const lockKey = this.getLockKey(key);
@@ -31,7 +31,7 @@ let RedLockService = class RedLockService {
         return true;
     }
     async releaseLock(key) {
-        if (!env_config_1.EnvConfig.isEnvTest) {
+        if (!env_config_1.EnvConfig.isEnvTest && this.redisService.isConnected) {
             await this.redisService.deleteCache(this.getLockKey(key));
         }
     }