rez_core 7.0.2 → 7.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "7.0.2",
+  "version": "7.0.4",
   "description": "",
   "author": "",
   "private": false,

package/src/config/bull.config.ts

@@ -5,18 +5,21 @@ import { ConfigService } from '@nestjs/config';
 /**
  * Bull Queue Configuration
  * Configures Redis connection and queue settings for Bull
+ *
+ * Uses Redis DB 0 for queue management
+ * Cache/sessions use DB 1 (configured in redis.config.ts)
  */
 @Injectable()
 export class BullConfigService implements SharedBullConfigurationFactory {
-  constructor(private configService: ConfigService) {}
+  constructor(private configService: ConfigService) { }
 
   createSharedConfiguration(): BullModuleOptions {
     return {
       redis: {
-        host: '43.205.35.45',
-        port: 6379,
-        password: 'Rezolut123',
-        db: 0,
+        host: this.configService.get('REDIS_HOST') || 'localhost',
+        port: Number(this.configService.get('REDIS_PORT')) || 6379,
+        password: this.configService.get('REDIS_PASSWORD') || 'Rezolut123',
+        db: 0, // Bull uses DB 0
         // Enable offline queue to handle Redis disconnections
         enableOfflineQueue: true,
         // Retry strategy for Redis connection

package/src/config/redis.config.ts

@@ -0,0 +1,56 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  RedisModuleOptions,
+  RedisOptionsFactory,
+} from '@liaoliaots/nestjs-redis';
+
+/**
+ * Centralized Redis Configuration
+ *
+ * Provides named Redis connections for different purposes:
+ * - 'cache': For session storage, JWT validation, and general caching (DB 1)
+ * - Bull uses DB 0 separately via bull.config.ts
+ *
+ * This separation ensures Bull queues don't interfere with cache data
+ */
+@Injectable()
+export class RedisConfigService implements RedisOptionsFactory {
+  constructor(private configService: ConfigService) {}
+
+  createRedisOptions(): RedisModuleOptions {
+    const host = this.configService.get('REDIS_HOST') || 'localhost';
+    const port = Number(this.configService.get('REDIS_PORT')) || 6379;
+    const password = this.configService.get('REDIS_PASSWORD') || 'Rezolut123';
+
+    return {
+      config: [
+        {
+          // Cache connection - for sessions, JWT validation, and general caching
+          namespace: 'cache',
+          host,
+          port,
+          password,
+          db: 1, // Use DB 1 for cache
+          enableOfflineQueue: true,
+          retryStrategy: (times: number) => {
+            const delay = Math.min(times * 50, 2000);
+            return delay;
+          },
+          connectTimeout: 10000,
+          keepAlive: 30000,
+          keyPrefix: 'cache:', // Optional: prefix all cache keys
+        },
+        // Bull uses its own connection to DB 0 (configured in bull.config.ts)
+        // This keeps queue data separate from application cache
+      ],
+    };
+  }
+}
+
+/**
+ * Factory function for RedisModule.forRootAsync()
+ */
+export const redisConfigFactory = {
+  useClass: RedisConfigService,
+};

package/src/module/auth/auth.module.ts

@@ -10,6 +10,7 @@ import { AuthService } from './services/auth.service';
 import { AuthController } from './controller/auth.controller';
 import { RedisModule, RedisService } from '@liaoliaots/nestjs-redis';
 import { Redis } from 'ioredis';
+import { redisConfigFactory } from '../../config/redis.config';
 
 @Module({
   imports: [
@@ -30,17 +31,8 @@ import { Redis } from 'ioredis';
         };
       },
     }),
-    RedisModule.forRootAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: async (configService: ConfigService) => ({
-        config: {
-          host: configService.get('REDIS_HOST') || 'localhost',
-          port: Number(configService.get('REDIS_PORT')) || 6379,
-          password: configService.get('REDIS_PASSWORD') || 'Rezolut123',
-        },
-      }),
-    }),
+    // Use centralized Redis configuration with named 'cache' connection
+    RedisModule.forRootAsync(redisConfigFactory),
   ],
   controllers: [AuthController],
   providers: [
@@ -56,17 +48,18 @@ export class AuthModule implements OnModuleInit {
   constructor(private readonly redisService: RedisService) {}
 
   async onModuleInit() {
-    const redis: Redis = this.redisService.getOrThrow();
+    // Get the named 'cache' connection (DB 1)
+    const redis: Redis = this.redisService.getOrThrow('cache');
 
     // TEST WRITE
     await redis.set('PING_TEST', 'PONG', 'EX', 10000);
 
     // TEST READ
     const value = await redis.get('PING_TEST');
-    console.log(`Redis Read: ${value}`);
+    console.log(`[Cache Redis DB 1] Read: ${value}`);
 
     // TEST PING
     const ping = await redis.ping();
-    console.log(`Redis PING reply: ${ping}`);
+    console.log(`[Cache Redis DB 1] PING reply: ${ping}`);
   }
 }

package/src/module/auth/strategies/jwt.strategy.ts

@@ -10,13 +10,14 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
   private redis: Redis;
 
   constructor(private readonly configService: ConfigService,
-              private readonly redisService: RedisService) {
+    private readonly redisService: RedisService) {
     super({
       jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
       ignoreExpiration: false,
       secretOrKey: configService.get('SECRET_KEY'),
     });
-    this.redis = this.redisService.getOrThrow();
+    // Use the named 'cache' connection for session validation
+    this.redis = this.redisService.getOrThrow('cache');
   }
 
   async validate(payload) {

package/src/module/listmaster/controller/list-master.controller.ts

@@ -126,11 +126,13 @@ export class ListMasterController {
   @HttpCode(HttpStatus.OK)
   async getAllListMasters(
     @Req() req: Request & { user: any },
+    @Query('app_code') app_code: string,
     @Query('search') search?: string,
   ) {
     const loggedInUser = req.user.userData;
     return await this.service.getAllListMasterByOrganization(
       loggedInUser.enterprise_id,
+      app_code,
       search,
     );
   }

package/src/module/listmaster/entity/list-master.entity.ts

@@ -1,23 +1,25 @@
-import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
+import { Column, Entity, Index } from 'typeorm';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
-import { ENTITYTYPE_LISTMASTER } from '../../../constant/global.constant';
 
 @Entity({ name: 'frm_list_master' })
 @Index('idx_list_master_type_org', ['type', 'enterprise_id'])
 export class ListMasterData extends BaseEntity {
 
-  @Column({nullable: true})
+  @Column({ nullable: true })
   type: string;
 
-  @Column({nullable: true})
+  @Column({ nullable: true })
   storage_type: string;
 
-  @Column({nullable: true})
+  @Column({ nullable: true })
   sort_by: string;
 
-  @Column({nullable: true})
+  @Column({ nullable: true })
   is_factory: number;
 
-  @Column({nullable: true})
+  @Column({ nullable: true })
   source: string;
+
+  @Column({ type: 'varchar', length: 25, nullable: true })
+  app_code: string;
 }

package/src/module/listmaster/repository/list-master.repository.ts

@@ -24,13 +24,17 @@ export class ListMasterRepository {
     return await this.repo.findOne({ where: condition });
   }
 
-  async findAllItems(enterprise_id: number, search?: string) {
+  async findAllItems(enterprise_id: number, app_code?: string, search?: string) {
     const qb = this.repo
       .createQueryBuilder('item')
       .where('item.source = :source', { source: 'master' })
       .andWhere('item.enterprise_id = :enterprise_id', { enterprise_id });
     // .andWhere('item.is_factory = :isFactory', { isFactory: false });
 
+    if (app_code) {
+      qb.andWhere('item.app_code = :appcode', { app_code: app_code });
+    }
+
     if (search?.trim()) {
       qb.andWhere(
         '(LOWER(item.name) LIKE :search OR LOWER(item.code) LIKE :search)',

package/src/module/listmaster/service/list-master.service.ts

@@ -288,9 +288,10 @@ export class ListMasterService extends EntityServiceImpl {
 
   async getAllListMasterByOrganization(
     enterprise_id: number,
+    app_code: string,
     search?: string,
   ): Promise<any[]> {
-    return await this.listMasterRepo.findAllItems(enterprise_id, search);
+    return await this.listMasterRepo.findAllItems(enterprise_id, app_code, search);
   }
 
   async getDropDownData(