ecrs-auth-core 1.0.16 → 1.0.17

package/dist/auth.module.js

@@ -29,9 +29,12 @@ let AuthCoreModule = AuthCoreModule_1 = class AuthCoreModule {
         return {
             module: AuthCoreModule_1,
             imports: [
-                jwt_1.JwtModule.register({
-                    secret: process.env.JWT_SECRET || "secret",
-                    signOptions: { expiresIn: "1d" },
+                jwt_1.JwtModule.registerAsync({
+                    useFactory: (options) => ({
+                        secret: options.jwtSecret,
+                        signOptions: { expiresIn: options.jwtExpiresIn },
+                    }),
+                    inject: [exports.AUTH_CORE_OPTIONS],
                 }),
             ],
             controllers: [auth_controller_1.AuthController],

package/dist/auth.service.d.ts

@@ -1,6 +1,6 @@
-import { JwtService } from "@nestjs/jwt";
-import { AuthCoreOptions } from "./interfaces/auth-core-options.interface";
-import { User } from "./entities/user.entity";
+import { JwtService } from '@nestjs/jwt';
+import { AuthCoreOptions } from './interfaces/auth-core-options.interface';
+import { User } from './entities/user.entity';
 export type RoutePermissionSet = {
     view?: boolean;
     create?: boolean;
@@ -10,12 +10,17 @@ export type RoutePermissionSet = {
     export?: boolean;
 };
 export declare class AuthService {
-    private jwtService;
+    private readonly jwtService;
     private readonly options;
-    private readonly config;
-    constructor(jwtService: JwtService, options: AuthCoreOptions, config: {
-        moduleId: number;
-    });
+    private readonly userRepo;
+    private readonly roleRepo;
+    private readonly moduleRepo;
+    private readonly featureRepo;
+    private readonly routeRepo;
+    private readonly featureAccessRepo;
+    private readonly moduleAccessRepo;
+    private readonly screenPermissionRepo;
+    constructor(jwtService: JwtService, options: AuthCoreOptions);
     validateUser(email: string, password: string): Promise<User | null>;
     login(user: User): Promise<{
         access_token: string;

package/dist/auth.service.js

@@ -49,15 +49,24 @@ exports.AuthService = void 0;
 const common_1 = require("@nestjs/common");
 const jwt_1 = require("@nestjs/jwt");
 const bcrypt = __importStar(require("bcrypt"));
+const auth_module_1 = require("./auth.module");
 let AuthService = class AuthService {
-    constructor(jwtService, options, config) {
+    constructor(jwtService, options) {
         this.jwtService = jwtService;
         this.options = options;
-        this.config = config;
+        const { userRepo, roleRepo, moduleRepo, featureRepo, routeRepo, featureAccessRepo, moduleAccessRepo, screenPermissionRepo, } = options.repositories;
+        this.userRepo = userRepo;
+        this.roleRepo = roleRepo;
+        this.moduleRepo = moduleRepo;
+        this.featureRepo = featureRepo;
+        this.routeRepo = routeRepo;
+        this.featureAccessRepo = featureAccessRepo;
+        this.moduleAccessRepo = moduleAccessRepo;
+        this.screenPermissionRepo = screenPermissionRepo;
     }
     async validateUser(email, password) {
-        const user = await this.options.userRepo.findOne({ where: { email } });
-        if (!user || user.moduleId !== this.config.moduleId)
+        const user = await this.userRepo.findOne({ where: { email } });
+        if (!user)
             return null;
         const isValid = await bcrypt.compare(password, user.password);
         return isValid ? user : null;
@@ -76,15 +85,15 @@ let AuthService = class AuthService {
         };
     }
     async findUserById(id) {
-        return this.options.userRepo.findOne({ where: { id } });
+        return this.userRepo.findOne({ where: { id } });
     }
     async loadPermissions(userId) {
-        // ---- Feature Permissions ----
-        const featureAccessList = await this.options.featureAccessRepo.find({
+        // Feature Permissions
+        const featureAccessList = await this.featureAccessRepo.find({
             where: { userId, isDeleted: 0 },
         });
         const featurePermissions = {};
-        const allFeatures = await this.options.featureRepo.find();
+        const allFeatures = await this.featureRepo.find();
         const featureMap = new Map(allFeatures.map((f) => [f.id, f]));
         for (const access of featureAccessList) {
             const feature = featureMap.get(access.featureId);
@@ -92,40 +101,40 @@ let AuthService = class AuthService {
                 continue;
             const perms = [];
             if (access.canView)
-                perms.push("view");
+                perms.push('view');
             if (access.canCreate)
-                perms.push("create");
+                perms.push('create');
             if (access.canModify)
-                perms.push("update");
+                perms.push('update');
             if (access.canDelete)
-                perms.push("delete");
+                perms.push('delete');
             if (access.canImport)
-                perms.push("import");
+                perms.push('import');
             if (access.canExport)
-                perms.push("export");
+                perms.push('export');
             if (perms.length) {
                 featurePermissions[feature.featureName] = perms;
             }
         }
-        // ---- Module Access ----
-        const moduleAccess = await this.options.moduleAccessRepo.find({
+        // Module Access
+        const moduleAccess = await this.moduleAccessRepo.find({
             where: { userId, isDeleted: 0 },
         });
         const moduleIds = moduleAccess.map((m) => m.moduleId);
-        // ---- Route Permissions ----
-        const screenPermissionsList = await this.options.screenPermissionRepo.find({
+        // Route Permissions
+        const screenPermissionsList = await this.screenPermissionRepo.find({
             where: { userId, isActive: true },
         });
         const routePermissions = {};
-        const allRoutes = await this.options.routeRepo.find();
+        const allRoutes = await this.routeRepo.find();
         const routeMap = new Map(allRoutes.map((r) => [r.id, r]));
         for (const screen of screenPermissionsList) {
             const route = routeMap.get(screen.moduleRouteId);
             if (!route)
                 continue;
             const perms = [];
-            const permissionKeys = ["view", "create", "update", "delete", "import", "export"];
-            for (const key of permissionKeys) {
+            const keys = ['view', 'create', 'update', 'delete', 'import', 'export'];
+            for (const key of keys) {
                 if (screen.permissions?.[key]) {
                     perms.push(key);
                 }
@@ -144,7 +153,6 @@ let AuthService = class AuthService {
 exports.AuthService = AuthService;
 exports.AuthService = AuthService = __decorate([
     (0, common_1.Injectable)(),
-    __param(1, (0, common_1.Inject)('AUTH_CORE_OPTIONS')),
-    __param(2, (0, common_1.Inject)('MODULE_CONFIG')),
-    __metadata("design:paramtypes", [jwt_1.JwtService, Object, Object])
+    __param(1, (0, common_1.Inject)(auth_module_1.AUTH_CORE_OPTIONS)),
+    __metadata("design:paramtypes", [jwt_1.JwtService, Object])
 ], AuthService);

package/dist/interfaces/auth-core-options.interface.d.ts

@@ -7,7 +7,7 @@ import { ModuleRoute } from '../entities/module-route.entity';
 import { UserFeatureAccess } from '../entities/user-feature-access.entity';
 import { UserModuleAccess } from '../entities/user-module-access.entity';
 import { ModuleScreenPermission } from '../entities/module-screen-permission.entity';
-export interface AuthCoreOptions {
+export interface Repositories {
     userRepo: Repository<User>;
     roleRepo: Repository<Role>;
     moduleRepo: Repository<Module>;
@@ -17,3 +17,14 @@ export interface AuthCoreOptions {
     routeRepo: Repository<ModuleRoute>;
     moduleAccessRepo: Repository<UserModuleAccess>;
 }
+export interface AuthModuleConfig {
+    enable2FA?: boolean;
+    tokenIssuer?: string;
+    [key: string]: any;
+}
+export interface AuthCoreOptions {
+    jwtSecret: string;
+    jwtExpiresIn: string;
+    repositories: Repositories;
+    moduleConfig?: AuthModuleConfig;
+}

package/dist/jwt/jwt.strategy.d.ts

@@ -1,8 +1,6 @@
 import { Strategy } from 'passport-jwt';
 import { AuthService } from '../auth.service';
-declare const JwtStrategy_base: new (...args: [opt: import("passport-jwt").StrategyOptionsWithRequest] | [opt: import("passport-jwt").StrategyOptionsWithoutRequest]) => Strategy & {
-    validate(...args: any[]): unknown;
-};
+declare const JwtStrategy_base: new (...args: any[]) => Strategy;
 export declare class JwtStrategy extends JwtStrategy_base {
     private readonly authService;
     constructor(authService: AuthService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ecrs-auth-core",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "Centralized authentication and authorization module for ECRS apps",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",