rez_core 0.0.1

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "rez_core",
+  "version": "0.0.1",
+  "description": "",
+  "author": "",
+  "private": false,
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/config": "^4.0.1",
+    "@nestjs/core": "^11.0.1",
+    "@nestjs/jwt": "^11.0.0",
+    "@nestjs/passport": "^11.0.5",
+    "@nestjs/platform-express": "^11.0.1",
+    "@nestjs/swagger": "^11.0.3",
+    "@nestjs/typeorm": "^11.0.0",
+    "250218_nodejs_core": "file:",
+    "bcrypt": "^5.1.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "crypto": "^1.0.1",
+    "crypto-js": "^4.2.0",
+    "dotenv": "^16.4.7",
+    "exceljs": "^4.4.0",
+    "moment": "^2.30.1",
+    "mysql2": "^3.12.0",
+    "passport": "^0.7.0",
+    "passport-google-oauth20": "^2.0.0",
+    "passport-jwt": "^4.0.1",
+    "passport-local": "^1.0.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.20",
+    "winston": "^3.17.0",
+    "xlsx": "^0.18.5"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.18.0",
+    "@nestjs/cli": "^11.0.0",
+    "@nestjs/schematics": "^11.0.0",
+    "@nestjs/testing": "^11.0.1",
+    "@swc/cli": "^0.6.0",
+    "@swc/core": "^1.10.7",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.7",
+    "@types/supertest": "^6.0.2",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.2.2",
+    "globals": "^15.14.0",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "prettier": "^3.4.2",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.2.5",
+    "ts-loader": "^9.5.2",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.20.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/src/app.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}

package/src/app.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

package/src/config/config.module.ts

@@ -0,0 +1,18 @@
+import { Global, Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+// import { MySqlConfiguration } from './database.config';
+import {ConfigModule} from "@nestjs/config";
+import { MySqlConfiguration } from './database.config';
+
+@Global()
+@Module({
+  imports: [
+    TypeOrmModule.forRootAsync({
+      useClass: MySqlConfiguration,
+    }),
+    ConfigModule.forRoot({isGlobal: true})
+  ],
+//   providers: [MySqlConfiguration],
+  exports: [TypeOrmModule],
+})
+export class DatabaseModule {}

package/src/config/database.config.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { TypeOrmModuleOptions, TypeOrmOptionsFactory } from '@nestjs/typeorm';
+
+@Injectable()
+export class MySqlConfiguration implements TypeOrmOptionsFactory {
+
+  createTypeOrmOptions(): TypeOrmModuleOptions {
+    return {
+      type: 'mysql',
+      host: process.env.DB_HOST || 'localhost',
+      port: parseInt(process.env.DB_PORT || '3306', 10),
+      username: process.env.DB_USER || 'root',
+      password: process.env.DB_PASS || 'root',
+      database: process.env.DB_NAME || 'core',
+      entities: [__dirname + '/../module/**/*.entity.{ts,js}'],
+      synchronize: true,
+      autoLoadEntities: true,
+    };
+  }
+}

package/src/constant/global.constant.ts

@@ -0,0 +1,10 @@
+// Entity Types
+export const ENTITYTYPE_USER = 'USR';
+export const ENTITYTYPE_ENTITYMASTER = 'EMS';
+export const ENTITYTYPE_ROLE = 'ROL';
+export const ENTITYTYPE_ENTITYTABLE = 'ETB';
+export const ENTITYTYPE_ENTITYTABLECOLUMN = 'ETM';
+export const ENTITYTYPE_PREFERENCEMASTER = 'PRM'
+export const masterKey: string = process.env.master_key || '';
+export const masterIv: string = process.env.master_iv || '';
+export const secretKey: string = process.env.secret_key || '';

package/src/constant/status.constant.ts

@@ -0,0 +1,3 @@
+export enum StatusType{
+    ACTIVE, INACTIVE
+}

package/src/core.module.ts

@@ -0,0 +1,40 @@
+import { Module, DynamicModule, Global } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config'; // Import ConfigModule
+import { EnterpriseModule } from './module/enterprise/enterprise.module';
+import { UtilsModule } from './utils/utils.module';
+import { UserModule } from './module/user/user.module';
+import { EntityModule } from './module/meta/entity.module';
+import { ModuleModule } from './module/module/module.module';
+
+@Global()
+@Module({})
+export class CoreModule {
+  static forRootAsync(dbModule: DynamicModule): DynamicModule {
+    if (!dbModule) {
+      throw new Error('Database module must be provided.');
+    }
+  
+    return {
+      module: CoreModule,
+      imports: [
+        ConfigModule.forRoot({ isGlobal: true }),
+        dbModule, // ✅ Make sure it's resolved
+        EntityModule,
+        EnterpriseModule,
+        UtilsModule,
+        UserModule,
+        ModuleModule,
+      ],
+      exports: [
+        ConfigModule,
+        dbModule,
+        EntityModule,
+        EnterpriseModule,
+        UtilsModule,
+        UserModule,
+        ModuleModule,
+      ],
+    };
+  }
+  
+}

package/src/decorators/roles.decorator.ts

@@ -0,0 +1,4 @@
+import {applyDecorators, SetMetadata} from "@nestjs/common";
+
+export const Roles = (moduleCode: string, actions: string) =>
+    applyDecorators(SetMetadata('moduleCode', moduleCode), SetMetadata('actions', actions));

package/src/index.ts

@@ -0,0 +1 @@
+export * from './core.module'

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

@@ -0,0 +1,36 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { JwtModule } from '@nestjs/jwt';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { JwtStrategy } from './strategies/jwt.strategy';
+import { JwtAuthService } from './services/jwt.service';
+import { JwtAuthGuard } from './guards/jwt.guard';
+import { PassportModule } from '@nestjs/passport';
+import { UserSession } from '../user/entity/user-session.entity';
+import { GoogleStrategy } from './strategies/google.strategy';
+import { RolesGuard } from './guards/role.guard';
+
+@Module({
+  imports: [
+    ConfigModule, // ✅ Ensure ConfigModule is imported
+    PassportModule.register({ defaultStrategy: 'jwt' }),
+    JwtModule.registerAsync({
+      imports: [ConfigModule], // ✅ Ensure ConfigModule is available
+      inject: [ConfigService],
+      useFactory: async (configService: ConfigService) => ({
+        secret: configService.get<string>('secret_key', 'defaultSecret'), // ✅ Use ConfigService
+        signOptions: { expiresIn: '1800s' },
+      }),
+    }),
+    TypeOrmModule.forFeature([UserSession]),
+  ],
+  providers: [
+    JwtAuthService,
+    JwtStrategy,
+    JwtAuthGuard,
+    GoogleStrategy,
+    RolesGuard,
+  ],
+  exports: [JwtAuthService, JwtAuthGuard, RolesGuard],
+})
+export class AuthModule {}

package/src/module/auth/guards/google-auth.guard.ts

@@ -0,0 +1,9 @@
+import { Injectable, ExecutionContext } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class GoogleAuthGuard extends AuthGuard('google') {
+  canActivate(context: ExecutionContext) {
+    return super.canActivate(context);
+  }
+}

package/src/module/auth/guards/jwt.guard.ts

@@ -0,0 +1,22 @@
+import { ExecutionContext, Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {
+  constructor(private reflector: Reflector) {
+    super();
+  }
+
+  canActivate(
+    context: ExecutionContext,
+  ): Promise<boolean> | boolean | Observable<boolean> {
+    const isPublic = this.reflector.getAllAndOverride('isPublic', [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    if (isPublic) return true;
+    return super.canActivate(context);
+  }
+}

package/src/module/auth/guards/role.guard.ts

@@ -0,0 +1,68 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  ForbiddenException,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { UserData } from '../../user/entity/user.entity';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(
+    private reflector: Reflector,
+    @InjectEntityManager() private entityManager: EntityManager,
+  ) {}
+
+  async canActivate(context: ExecutionContext) {
+    const request = context
+      .switchToHttp()
+      .getRequest<Request & { user: any }>();
+    const object = request.user;
+
+    const users: UserData = await this.entityManager.query(
+      `SELECT * FROM cr_user WHERE id = ${object.userId} LIMIT 1`,
+    );
+
+    const user = users[0];
+    if (!user || !user['role_id']) {
+      throw new UnauthorizedException('User not authorized');
+    }
+
+    const requiredModule = this.reflector.get<string>(
+      'moduleCode',
+      context.getHandler(),
+    );
+    const requiredActions = this.reflector.get<string>(
+      'actions',
+      context.getHandler(),
+    );
+
+    const roleAccess = await this.entityManager.query(
+      `SELECT *
+             FROM cr_module_access
+             WHERE role_id = ${user['role_id']}
+               AND module_code = '${requiredModule}'`,
+    );
+
+    if (!roleAccess || roleAccess.length === 0) {
+      throw new ForbiddenException(
+        'Access denied: No permissions found for this module',
+      );
+    }
+
+    const hasAccess = roleAccess.some(
+      (access) =>
+        requiredActions.includes(access.action_type) &&
+        access.access_flag === 1,
+    );
+
+    if (!hasAccess) {
+      throw new ForbiddenException('Access denied: Insufficient permissions.');
+    }
+    return true;
+  }
+}

package/src/module/auth/services/auth.service.ts

@@ -0,0 +1,29 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { UserService } from '../../user/service/user.service';
+import { JwtService } from '@nestjs/jwt';
+import { UserData } from '../../user/entity/user.entity';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private userService: UserService,
+    private jwtService: JwtService,
+  ) {}
+
+  async validateUser(email: string, password: string): Promise<UserData> {
+    const user = await this.userService.findByEmailId(email);
+    if (!user) {
+      throw new BadRequestException('User not found');
+    }
+    const isMatch: boolean = password === user.password;
+    if (!isMatch) {
+      throw new BadRequestException('Password does not match');
+    }
+    return user;
+  }
+
+  async login(user: UserData) {
+    const payload = { email: user.email_id, id: user.id };
+    return { access_token: this.jwtService.sign(payload) };
+  }
+}

package/src/module/auth/services/jwt.service.ts

@@ -0,0 +1,11 @@
+import { Injectable } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+@Injectable()
+export class JwtAuthService {
+  constructor(private readonly jwtService: JwtService) {}
+
+  generateJwt(payload: any): string {
+    return this.jwtService.sign(payload);
+  }
+}

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

@@ -0,0 +1,29 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { Strategy, VerifyCallback } from 'passport-google-oauth20';
+
+@Injectable()
+export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
+  constructor() {
+    super({
+      clientID: process.env.clientID,
+      clientSecret: process.env.clientSecret,
+      callbackURL: process.env.callbackURL,
+      scope: ['email', 'profile'],
+    });
+  }
+
+  async validate(
+    accessToken: string,
+    refreshToken: string,
+    profile: any,
+    done: VerifyCallback,
+  ) {
+    // console.log(profile)
+    const { emails, name } = profile;
+    const email = emails?.[0]?.value;
+
+    // Pass extracted user data to the controller (No dependencies here)
+    return done(null, { email, name });
+  }
+}

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

@@ -0,0 +1,43 @@
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { PassportStrategy } from '@nestjs/passport';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ConfigService } from '@nestjs/config'; // ✅ Import ConfigService
+import { UserSession } from '../../../module/user/entity/user-session.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(
+    private readonly configService: ConfigService, // ✅ Inject ConfigService
+    @InjectRepository(UserSession)
+    private userSessionRepository: Repository<UserSession>,
+  ) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get<string>('secret_key'), // ✅ Use ConfigService
+    });
+
+    console.log('Loaded JWT Secret:', configService.get<string>('secret_key')); // Debugging
+  }
+
+  async validate(payload) {
+    const { userId, sessionToken } = payload;
+
+    // Check if session exists and is valid
+    const userSession = await this.userSessionRepository.findOne({
+      where: { session_key: sessionToken },
+    });
+
+    if (
+      !userSession ||
+      userSession.is_session_loggedout ||
+      new Date(userSession.expiry_date) < new Date()
+    ) {
+      throw new UnauthorizedException('Invalid or expired session');
+    }
+
+    return { userId, sessionToken };
+  }
+}

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

@@ -0,0 +1,13 @@
+import { PassportStrategy } from '@nestjs/passport';
+import { AuthService } from '../services/auth.service';
+import { Injectable } from '@nestjs/common';
+import { Strategy } from 'passport-jwt';
+
+@Injectable()
+export class LocalStrategy extends PassportStrategy(Strategy) {
+  constructor(private authService: AuthService) {
+    super({
+      usernameField: 'email',
+    });
+  }
+}

package/src/module/dev/dev.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { EntityModule } from '../meta/entity.module';
+import { UserModule } from '../user/user.module';
+import { ModuleModule } from '../module/module.module';
+import { DevService } from './service/dev.service';
+
+@Module({
+  imports: [EntityModule, UserModule, ModuleModule],
+  controllers: [],
+  providers: [DevService],
+})
+export class DevModule {}

package/src/module/dev/service/dev.service.ts

@@ -0,0 +1,7 @@
+import { Injectable } from '@nestjs/common';
+import { UserService } from '../../user/service/user.service';
+
+@Injectable()
+export class DevService {
+  constructor(private readonly userService: UserService) {}
+}

package/src/module/enterprise/enterprise.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserData } from '../user/entity/user.entity';
+
+@Module({
+  imports: [],
+})
+export class EnterpriseModule {}

package/src/module/enterprise/entity/enterprise.entity.ts

@@ -0,0 +1,37 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_enterprise' })
+export class EnterpriseData {
+  @PrimaryGeneratedColumn({ name: 'id', type: 'bigint' })
+  id: number;
+
+  @Column({ name: 'entity_type', type: 'varchar', nullable: true, length: 50 })
+  entityType: string;
+
+  @Column({ name: 'code', type: 'varchar', nullable: true, length: 50 })
+  code: string;
+
+  @Column({ name: 'name', type: 'varchar', nullable: true, length: 50 })
+  name: string;
+
+  @Column({ name: 'status', type: 'varchar', nullable: true, length: 50 })
+  status: string;
+
+  @Column({ name: 'created_by', type: 'int', nullable: true })
+  createdBy: number;
+
+  @Column({ name: 'modified_by', type: 'int', nullable: true })
+  modifiedBy: number;
+
+  @Column({ name: 'created_date', type: 'datetime', nullable: true })
+  createdDate: Date;
+
+  @Column({ name: 'modified_date', type: 'datetime', nullable: true })
+  modifiedDate: Date;
+
+  @Column({ name: 'app_code', type: 'varchar', nullable: true, length: 50 })
+  appCode: string;
+
+  @Column({ name: 'app_url_name', type: 'varchar', nullable: true, length: 50 })
+  appUrlName: string;
+}

package/src/module/enterprise/entity/organization.entity.ts

@@ -0,0 +1,80 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_organization' })
+export class OrganizationData {
+  @PrimaryGeneratedColumn({ name: 'id', type: 'int' })
+  id: number;
+
+  @Column({ name: 'enterprise_id', type: 'int' })
+  enterprise_id: number;
+
+  @Column({ name: 'code', nullable: true })
+  code: string;
+
+  @Column({ name: 'app_code', nullable: true })
+  appCode: string;
+
+  @Column({ name: 'name', nullable: true })
+  name: string;
+
+  @Column({ name: 'status', type: 'varchar', nullable: true })
+  status: string;
+
+  @Column({ name: 'seq_no', nullable: true })
+  seq_no: number;
+
+  @Column({ name: 'created_by', nullable: true })
+  created_by: number;
+
+  @Column({ name: 'modified_by', nullable: true })
+  modified_by: number;
+
+  @Column({ name: 'created_date', nullable: true })
+  created_date: Date;
+
+  @Column({ name: 'parent_id', nullable: true })
+  parent_id: number;
+
+  @Column({ name: 'modified_date', nullable: true })
+  modified_date: Date;
+
+  @Column({ name: 'contact_number', nullable: true })
+  contact_number: string;
+
+  @Column({ name: 'email', nullable: true })
+  emailId: string;
+
+  @Column({ name: 'entity_type', nullable: true })
+  entity_type: string;
+
+  @Column({ name: 'primary_contact_name', nullable: true })
+  primary_contact_name: string;
+
+  @Column({ name: 'address', nullable: true })
+  address: string;
+
+  @Column({ name: 'gstin', nullable: true })
+  gstin: string;
+
+  @Column({ name: 'company_pan_number', nullable: true })
+  company_pan_number: string;
+
+  @Column({ name: 'bankacc_benef_name', nullable: true })
+  bankacc_benef_name: string;
+
+  @Column({ name: 'bankacc_bank_name', nullable: true })
+  bankacc_bank_name: string;
+
+  @Column({ name: 'bankacc_account_number', nullable: true })
+  bankaccAccountNumber: string;
+
+  @Column({ name: 'bankacc_branch_IFSC', nullable: true })
+  bankacc_account_number: string;
+
+  @Column({
+    name: 'organization_type',
+    type: 'varchar',
+    nullable: true,
+  })
+  organization_type: string;
+}

package/src/module/master/controller/master.controller.ts

@@ -0,0 +1,22 @@
+import {
+  Controller,
+  Post,
+  UploadedFile,
+  UseInterceptors,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { MasterService } from '../service/master.service';
+
+@Controller('master')
+export class MasterController {
+  constructor(private readonly masterService: MasterService) {}
+
+  @Post('upload')
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadFile(@UploadedFile() file) {
+    if (!file) {
+      throw new Error('File is required');
+    }
+    return this.masterService.processExcel(file);
+  }
+}