@drax/identity-back 0.0.13 → 0.0.15

package/dist/config/IdentityConfig.js

@@ -0,0 +1,12 @@
+var IdentityConfig;
+(function (IdentityConfig) {
+    IdentityConfig["DbEngine"] = "DB_ENGINE";
+    IdentityConfig["SqliteDbFile"] = "SQLITE_FILE";
+    IdentityConfig["MongoDbUri"] = "MONGO_URI";
+    IdentityConfig["JwtSecret"] = "JWT_SECRET";
+    IdentityConfig["JwtExpiration"] = "JWT_EXPIRATION";
+    IdentityConfig["JwtIssuer"] = "JWT_ISSUER";
+    IdentityConfig["RbacCacheTTL"] = "RBAC_CACHE_TTL";
+})(IdentityConfig || (IdentityConfig = {}));
+export default IdentityConfig;
+export { IdentityConfig };

package/dist/factory/RoleServiceFactory.js

@@ -2,20 +2,23 @@ import RoleService from "../services/RoleService.js";
 import RoleMongoRepository from "../repository/mongo/RoleMongoRepository.js";
 import RoleSqliteRepository from "../repository/sqlite/RoleSqliteRepository.js";
 import { DbSetupUtils, DbEngine } from "../utils/DbSetupUtils.js";
+let roleService;
 const RoleServiceFactory = () => {
-    let roleRepository;
-    switch (DbSetupUtils.getDbEngine()) {
-        case DbEngine.Mongo:
-            console.log("RoleServiceFactory DB ENGINE MONGODB");
-            roleRepository = new RoleMongoRepository();
-            break;
-        case DbEngine.Sqlite:
-            console.log("RoleServiceFactory DB ENGINE SQLITE");
-            roleRepository = new RoleSqliteRepository(process.env.SQLITE_DATABASE, false);
-            roleRepository.table();
-            break;
+    if (!roleService) {
+        let roleRepository;
+        switch (DbSetupUtils.getDbEngine()) {
+            case DbEngine.Mongo:
+                console.log("RoleServiceFactory DB ENGINE MONGODB");
+                roleRepository = new RoleMongoRepository();
+                break;
+            case DbEngine.Sqlite:
+                console.log("RoleServiceFactory DB ENGINE SQLITE");
+                roleRepository = new RoleSqliteRepository(DbSetupUtils.getDbConfig(), false);
+                roleRepository.table();
+                break;
+        }
+        roleService = new RoleService(roleRepository);
     }
-    const roleService = new RoleService(roleRepository);
     return roleService;
 };
-export default RoleServiceFactory();
+export default RoleServiceFactory;

package/dist/factory/UserServiceFactory.js

@@ -1,22 +1,24 @@
 import UserMongoRepository from "../repository/mongo/UserMongoRepository.js";
 import UserService from "../services/UserService.js";
 import UserSqliteRepository from "../repository/sqlite/UserSqliteRepository.js";
-import process from "node:process";
 import { DbEngine, DbSetupUtils } from "../utils/DbSetupUtils.js";
+let userService;
 const UserServiceFactory = () => {
-    let userRepository;
-    switch (DbSetupUtils.getDbEngine()) {
-        case DbEngine.Mongo:
-            console.log("UserServiceFactory DB ENGINE MONGODB");
-            userRepository = new UserMongoRepository();
-            break;
-        case DbEngine.Sqlite:
-            console.log("UserServiceFactory DB ENGINE SQLITE");
-            userRepository = new UserSqliteRepository(process.env.SQLITE_DATABASE, false);
-            userRepository.table();
-            break;
+    if (!userService) {
+        let userRepository;
+        switch (DbSetupUtils.getDbEngine()) {
+            case DbEngine.Mongo:
+                console.log("UserServiceFactory DB ENGINE MONGODB");
+                userRepository = new UserMongoRepository();
+                break;
+            case DbEngine.Sqlite:
+                console.log("UserServiceFactory DB ENGINE SQLITE");
+                userRepository = new UserSqliteRepository(DbSetupUtils.getDbConfig(), false);
+                userRepository.table();
+                break;
+        }
+        userService = new UserService(userRepository);
     }
-    const userService = new UserService(userRepository);
     return userService;
 };
-export default UserServiceFactory();
+export default UserServiceFactory;

package/dist/graphql/resolvers/role.resolvers.js

@@ -4,12 +4,12 @@ import { ValidationError, ValidationErrorToGraphQLError } from "@drax/common-bac
 import { GraphQLError } from "graphql";
 import { PermissionService } from "../../services/PermissionService.js";
 import UnauthorizedError from "../../errors/UnauthorizedError.js";
-const roleService = RoleServiceFactory;
 export default {
     Query: {
         findRoleById: async (_, { id }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewRole);
+                const roleService = RoleServiceFactory();
                 return await roleService.findById(id);
             }
             catch (e) {
@@ -22,6 +22,7 @@ export default {
         findRoleByName: async (_, { name }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewRole);
+                const roleService = RoleServiceFactory();
                 return await roleService.findByName(name);
             }
             catch (e) {
@@ -34,6 +35,7 @@ export default {
         fetchRole: async (_, {}, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewRole);
+                const roleService = RoleServiceFactory();
                 return await roleService.fetchAll();
             }
             catch (e) {
@@ -58,6 +60,7 @@ export default {
         paginateRole: async (_, { page, limit, seach }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewRole);
+                const roleService = RoleServiceFactory();
                 return await roleService.paginate(page, limit, seach);
             }
             catch (e) {
@@ -73,6 +76,7 @@ export default {
         createRole: async (_, { input }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.CreateRole);
+                const roleService = RoleServiceFactory();
                 return await roleService.create(input);
             }
             catch (e) {
@@ -89,6 +93,7 @@ export default {
         updateRole: async (_, { id, input }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.UpdateRole);
+                const roleService = RoleServiceFactory();
                 const currentRole = await roleService.findById(id);
                 if (currentRole.readonly) {
                     throw new ValidationError([{ field: 'name', reason: "role.readonly", value: input.name }]);
@@ -109,6 +114,7 @@ export default {
         deleteRole: async (_, { id }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.DeleteRole);
+                const roleService = RoleServiceFactory();
                 return await roleService.delete(id);
             }
             catch (e) {

package/dist/graphql/resolvers/user.resolvers.js

@@ -4,12 +4,12 @@ import { ValidationErrorToGraphQLError, ValidationError } from "@drax/common-bac
 import { IdentityPermissions } from "../../permissions/IdentityPermissions.js";
 import UnauthorizedError from "../../errors/UnauthorizedError.js";
 import BadCredentialsError from "../../errors/BadCredentialsError.js";
-const userService = UserServiceFactory;
 export default {
     Query: {
         me: async (_, {}, { authUser }) => {
             try {
                 if (authUser) {
+                    let userService = UserServiceFactory();
                     let user = await userService.findById(authUser.id);
                     delete user.password;
                     return user;
@@ -24,6 +24,7 @@ export default {
         findUserById: async (_, { id }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewUser);
+                let userService = UserServiceFactory();
                 return await userService.findById(id);
             }
             catch (e) {
@@ -36,6 +37,7 @@ export default {
         paginateUser: async (_, { page, limit, search }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewUser);
+                let userService = UserServiceFactory();
                 return await userService.paginate(page, limit, search);
             }
             catch (e) {
@@ -49,6 +51,7 @@ export default {
     Mutation: {
         auth: async (_, { input }) => {
             try {
+                let userService = UserServiceFactory();
                 return await userService.auth(input.username, input.password);
             }
             catch (e) {
@@ -62,6 +65,7 @@ export default {
         createUser: async (_, { input }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.CreateUser);
+                let userService = UserServiceFactory();
                 const user = await userService.create(input);
                 return user;
             }
@@ -79,6 +83,7 @@ export default {
         updateUser: async (_, { id, input }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.UpdateUser);
+                let userService = UserServiceFactory();
                 const user = await userService.update(id, input);
                 return user;
             }
@@ -95,6 +100,7 @@ export default {
         deleteUser: async (_, { id }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.DeleteUser);
+                let userService = UserServiceFactory();
                 return await userService.delete(id);
             }
             catch (e) {
@@ -114,6 +120,7 @@ export default {
                     throw new UnauthorizedError();
                 }
                 let userId = authUser.id;
+                let userService = UserServiceFactory();
                 return await userService.changeOwnPassword(userId, currentPassword, newPassword);
             }
             catch (e) {
@@ -129,6 +136,7 @@ export default {
         changeUserPassword: async (_, { userId, newPassword }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.UpdateUser);
+                let userService = UserServiceFactory();
                 return await userService.changeUserPassword(userId, newPassword);
             }
             catch (e) {

package/dist/index.js

@@ -11,8 +11,14 @@ import AuthUtils from "./utils/AuthUtils.js";
 import { jwtMiddleware } from "./middleware/jwtMiddleware.js";
 import { rbacMiddleware } from "./middleware/rbacMiddleware.js";
 import IdentityPermissions from "./permissions/IdentityPermissions.js";
+import IdentityConfig from "./config/IdentityConfig.js";
 import UnauthorizedError from "./errors/UnauthorizedError.js";
 import BadCredentialsError from "./errors/BadCredentialsError.js";
+import CreateUserIfNotExist from "./setup/CreateUserIfNotExist.js";
+import CreateOrUpdateRole from "./setup/CreateOrUpdateRole.js";
+import LoadPermissions from "./setup/LoadPermissions.js";
+import LoadConfigFromEnv from "./setup/LoadConfigFromEnv.js";
+import RecoveryUserPassword from "./setup/RecoveryUserPassword.js";
 const graphqlMergeResult = await GraphqlMerge();
 const identityTypeDefs = await graphqlMergeResult.typeDefs;
 const identityResolvers = await graphqlMergeResult.resolvers;
@@ -29,6 +35,10 @@ UserRoutes, RoleRoutes, AuthUtils,
 jwtMiddleware, rbacMiddleware, 
 //Permissions
 IdentityPermissions, 
+//Config
+IdentityConfig, 
 //Errors
-UnauthorizedError, BadCredentialsError };
+UnauthorizedError, BadCredentialsError, 
+//Setup
+LoadConfigFromEnv, LoadPermissions, CreateOrUpdateRole, CreateUserIfNotExist, RecoveryUserPassword };
 /// <reference types="index.d.ts" />

package/dist/middleware/rbacMiddleware.js

@@ -1,10 +1,11 @@
-import { DraxCache } from "@drax/common-back";
+import { DraxCache, DraxConfig } from "@drax/common-back";
 import RoleServiceFactory from "../factory/RoleServiceFactory.js";
 import Rbac from "../rbac/Rbac.js";
-const cacheTTL = process.env.RBAC_CACHE_TTL ? parseInt(process.env.RBAC_CACHE_TTL) : 10000;
+import IdentityConfig from "../config/IdentityConfig.js";
+const cacheTTL = DraxConfig.getOrLoad(IdentityConfig.RbacCacheTTL) ? parseInt(DraxConfig.getOrLoad(IdentityConfig.RbacCacheTTL)) : 10000;
 const draxCache = new DraxCache(cacheTTL);
-const roleService = RoleServiceFactory;
 async function roleLoader(k) {
+    const roleService = RoleServiceFactory();
     const role = await roleService.findById(k);
     if (role) {
         return { id: role.id, name: role.name, permissions: role.permissions };

package/dist/routes/RoleRoutes.js

@@ -3,7 +3,6 @@ import RoleServiceFactory from "../factory/RoleServiceFactory.js";
 import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
 import { PermissionService } from "../services/PermissionService.js";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
-const roleService = RoleServiceFactory;
 async function RoleRoutes(fastify, options) {
     fastify.get('/api/permissions', async (request, reply) => {
         try {
@@ -27,6 +26,7 @@ async function RoleRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewRole);
             const id = request.params.id;
+            const roleService = RoleServiceFactory();
             let role = await roleService.findById(id);
             return role;
         }
@@ -50,6 +50,7 @@ async function RoleRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewRole);
             const name = request.params.name;
+            const roleService = RoleServiceFactory();
             let role = await roleService.findByName(name);
             return role;
         }
@@ -72,6 +73,7 @@ async function RoleRoutes(fastify, options) {
     fastify.get('/api/roles/all', async (request, reply) => {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewRole);
+            const roleService = RoleServiceFactory();
             let roles = await roleService.fetchAll();
             return roles;
         }
@@ -97,6 +99,7 @@ async function RoleRoutes(fastify, options) {
             const page = request.query.page;
             const limit = request.query.limit;
             const search = request.query.search;
+            const roleService = RoleServiceFactory();
             let paginateResult = await roleService.paginate(page, limit, search);
             return paginateResult;
         }
@@ -120,6 +123,7 @@ async function RoleRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.CreateRole);
             const payload = request.body;
+            const roleService = RoleServiceFactory();
             let role = await roleService.create(payload);
             return role;
         }
@@ -144,6 +148,7 @@ async function RoleRoutes(fastify, options) {
             request.rbac.assertPermission(IdentityPermissions.UpdateRole);
             const id = request.params.id;
             const payload = request.body;
+            const roleService = RoleServiceFactory();
             const currentRole = await roleService.findById(id);
             if (currentRole.readonly) {
                 throw new ValidationError([{ field: 'name', reason: "role.readonly", value: payload.name }]);
@@ -171,6 +176,7 @@ async function RoleRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.DeleteRole);
             const id = request.params.id;
+            const roleService = RoleServiceFactory();
             let r = await roleService.delete(id);
             return r;
         }

package/dist/routes/UserRoutes.js

@@ -3,12 +3,12 @@ import { ValidationError } from "@drax/common-back";
 import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
 import BadCredentialsError from "../errors/BadCredentialsError.js";
-const userService = UserServiceFactory;
 async function UserRoutes(fastify, options) {
     fastify.post('/api/auth', async (request, reply) => {
         try {
             const username = request.body.username;
             const password = request.body.password;
+            const userService = UserServiceFactory();
             return await userService.auth(username, password);
         }
         catch (e) {
@@ -24,6 +24,7 @@ async function UserRoutes(fastify, options) {
     fastify.get('/api/me', async (request, reply) => {
         try {
             if (request.authUser) {
+                const userService = UserServiceFactory();
                 let user = await userService.findById(request.authUser.id);
                 delete user.password;
                 return user;
@@ -53,6 +54,7 @@ async function UserRoutes(fastify, options) {
             const page = request.query.page;
             const limit = request.query.limit;
             const search = request.query.search;
+            const userService = UserServiceFactory();
             let paginateResult = await userService.paginate(page, limit, search);
             return paginateResult;
         }
@@ -75,6 +77,7 @@ async function UserRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.CreateUser);
             const payload = request.body;
+            const userService = UserServiceFactory();
             let user = await userService.create(payload);
             return user;
         }
@@ -98,6 +101,7 @@ async function UserRoutes(fastify, options) {
             request.rbac.assertPermission(IdentityPermissions.UpdateUser);
             const id = request.params.id;
             const payload = request.body;
+            const userService = UserServiceFactory();
             let user = await userService.update(id, payload);
             return user;
         }
@@ -124,6 +128,7 @@ async function UserRoutes(fastify, options) {
         try {
             request.rbac.assertPermission(IdentityPermissions.DeleteUser);
             const id = request.params.id;
+            const userService = UserServiceFactory();
             let r = await userService.delete(id);
             return r;
         }
@@ -150,6 +155,7 @@ async function UserRoutes(fastify, options) {
             const userId = request.authUser.id;
             const currentPassword = request.body.currentPassword;
             const newPassword = request.body.newPassword;
+            const userService = UserServiceFactory();
             return await userService.changeOwnPassword(userId, currentPassword, newPassword);
         }
         catch (e) {
@@ -176,6 +182,7 @@ async function UserRoutes(fastify, options) {
                 throw new UnauthorizedError();
             }
             const newPassword = request.body.newPassword;
+            const userService = UserServiceFactory();
             return await userService.changeUserPassword(userId, newPassword);
         }
         catch (e) {

package/dist/setup/CreateOrUpdateRole.js

@@ -0,0 +1,15 @@
+import RoleServiceFactory from "../factory/RoleServiceFactory.js";
+async function CreateOrUpdateRole(roleData) {
+    const roleService = RoleServiceFactory();
+    const role = await roleService.findByName(roleData.name);
+    if (role) {
+        const r = await roleService.update(role.id, roleData);
+        console.log("Role Updated. Name: " + roleData.name);
+    }
+    else {
+        const r = await roleService.create(roleData);
+        console.log("Role Created. Name: " + roleData.name);
+    }
+}
+export default CreateOrUpdateRole;
+export { CreateOrUpdateRole };

package/dist/setup/CreateUserIfNotExist.js

@@ -0,0 +1,17 @@
+import RoleServiceFactory from "../factory/RoleServiceFactory.js";
+import UserServiceFactory from "../factory/UserServiceFactory.js";
+async function CreateUserIfNotExist(userData) {
+    const userService = UserServiceFactory();
+    const roleService = RoleServiceFactory();
+    const user = await userService.findByUsername(userData.username);
+    if (user) {
+    }
+    else {
+        const role = await roleService.findByName(userData.role);
+        userData.role = role.id;
+        const r = await userService.create(userData);
+        console.log("User Created. Username: " + userData.username);
+    }
+}
+export default CreateUserIfNotExist;
+export { CreateUserIfNotExist };

package/dist/setup/LoadConfigFromEnv.js

@@ -0,0 +1,12 @@
+import { DraxConfig } from "@drax/common-back";
+import IdentityConfig from "../config/IdentityConfig.js";
+function LoadConfigFromEnv() {
+    DraxConfig.set(IdentityConfig.DbEngine, process.env[IdentityConfig.DbEngine]);
+    DraxConfig.set(IdentityConfig.SqliteDbFile, process.env[IdentityConfig.SqliteDbFile]);
+    DraxConfig.set(IdentityConfig.MongoDbUri, process.env[IdentityConfig.MongoDbUri]);
+    DraxConfig.set(IdentityConfig.JwtSecret, process.env[IdentityConfig.JwtSecret]);
+    DraxConfig.set(IdentityConfig.JwtExpiration, process.env[IdentityConfig.JwtExpiration]);
+    DraxConfig.set(IdentityConfig.JwtIssuer, process.env[IdentityConfig.JwtIssuer]);
+}
+export default LoadConfigFromEnv;
+export { LoadConfigFromEnv };

package/dist/setup/LoadPermissions.js

@@ -0,0 +1,8 @@
+import { PermissionService } from "../services/PermissionService.js";
+function LoadPermissions(permissions) {
+    for (const permission of permissions) {
+        PermissionService.addPermission(permission);
+    }
+}
+export default LoadPermissions;
+export { LoadPermissions };

package/dist/setup/RecoveryUserPassword.js

@@ -0,0 +1,9 @@
+import UserServiceFactory from "../factory/UserServiceFactory.js";
+async function RecoveryUserPassword(username, password) {
+    const userService = UserServiceFactory();
+    const user = await userService.findByUsername(username);
+    const r = await userService.changeUserPassword(user.id, password);
+    console.log("User password recovered. Username: " + username);
+}
+export default RecoveryUserPassword;
+export { RecoveryUserPassword };

package/dist/utils/AuthUtils.js

@@ -1,10 +1,12 @@
 import bcryptjs from "bcryptjs";
 import jsonwebtoken from "jsonwebtoken";
+import { DraxConfig } from "@drax/common-back";
+import IdentityConfig from "../config/IdentityConfig.js";
 class AuthUtils {
     static verifyToken(token) {
-        const JWT_SECRET = process.env.JWT_SECRET;
+        const JWT_SECRET = DraxConfig.getOrLoad(IdentityConfig.JwtSecret);
         if (!JWT_SECRET) {
-            throw new Error("JWT_SECRET ENV must be provided");
+            throw new Error("DraxConfig.JWT_SECRET must be provided");
         }
         const options = {
             algorithms: ['HS256'],
@@ -32,16 +34,18 @@ class AuthUtils {
     }
     static generateToken(userId, username, roleId, session) {
         const payload = AuthUtils.tokenSignPayload(userId, username, roleId, session);
-        const JWT_SECRET = process.env.JWT_SECRET;
+        const JWT_SECRET = DraxConfig.getOrLoad(IdentityConfig.JwtSecret);
         if (!JWT_SECRET) {
             throw new Error("JWT_SECRET ENV must be provided");
         }
+        const JWT_EXPIRATION = DraxConfig.getOrLoad(IdentityConfig.JwtExpiration) || '1h';
+        const JWT_ISSUER = DraxConfig.getOrLoad(IdentityConfig.JwtIssuer) || 'DRAX';
         const options = {
-            expiresIn: process.env.JWT_EXPIRATION || '1h',
+            expiresIn: JWT_EXPIRATION,
             jwtid: userId,
             algorithm: 'HS256',
             audience: username,
-            issuer: process.env.JWT_ISSUER ? process.env.JWT_ISSUER : 'drax'
+            issuer: JWT_ISSUER
         };
         let token = jsonwebtoken.sign(payload, JWT_SECRET, options);
         return token;

package/dist/utils/DbSetupUtils.js

@@ -1,3 +1,5 @@
+import IdentityConfig from "../config/IdentityConfig.js";
+import { DraxConfig } from "@drax/common-back";
 var DbEngine;
 (function (DbEngine) {
     DbEngine["Sqlite"] = "sqlite";
@@ -5,23 +7,23 @@ var DbEngine;
 })(DbEngine || (DbEngine = {}));
 class DbSetupUtils {
     static getDbEngine() {
-        if (!process.env.DB_ENGINE) {
-            throw new Error("process.env.DB_ENGINE is not defined");
+        if (!DraxConfig.getOrLoad(IdentityConfig.DbEngine)) {
+            throw new Error("DraxConfig.DB_ENGINE is not defined");
         }
-        const dbEngine = process.env.DB_ENGINE;
+        const dbEngine = DraxConfig.getOrLoad(IdentityConfig.DbEngine);
         if (!Object.values(DbEngine).includes(dbEngine)) {
-            throw new Error("process.env.DB_ENGINE must be one of " + Object.values(DbEngine).join(", "));
+            throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(DbEngine).join(", "));
         }
         return dbEngine;
     }
-    static getDbUri() {
+    static getDbConfig() {
         switch (DbSetupUtils.getDbEngine()) {
             case DbEngine.Mongo:
-                return process.env.MONGO_URI;
+                return DraxConfig.getOrLoad(IdentityConfig.MongoDbUri);
             case DbEngine.Sqlite:
-                return process.env.SQLITE_DATABASE;
+                return DraxConfig.getOrLoad(IdentityConfig.SqliteDbFile);
             default:
-                throw new Error("process.env.DB_ENGINE must be one of " + Object.values(DbEngine).join(", "));
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(DbEngine).join(", "));
         }
     }
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -56,5 +56,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "ef1c27d0173392ba03038b2a588e657061b9f9eb"
+  "gitHead": "141cd8b418596b7a16d4baf7f5f0b8b7587ec546"
 }

package/src/config/IdentityConfig.ts

@@ -0,0 +1,17 @@
+enum IdentityConfig {
+
+    DbEngine = "DB_ENGINE",
+    SqliteDbFile = "SQLITE_FILE",
+    MongoDbUri = "MONGO_URI",
+
+    JwtSecret = "JWT_SECRET",
+    JwtExpiration = "JWT_EXPIRATION",
+    JwtIssuer = "JWT_ISSUER",
+
+    RbacCacheTTL = "RBAC_CACHE_TTL",
+
+
+}
+
+export default IdentityConfig;
+export {IdentityConfig};

package/src/factory/RoleServiceFactory.ts

@@ -1,27 +1,33 @@
+import {DraxConfig} from "@drax/common-back"
 import RoleService from "../services/RoleService.js";
 import RoleMongoRepository from "../repository/mongo/RoleMongoRepository.js";
 import RoleSqliteRepository from "../repository/sqlite/RoleSqliteRepository.js";
 import {DbSetupUtils, DbEngine} from "../utils/DbSetupUtils.js";
 import type {IRoleRepository} from "../interfaces/IRoleRepository";
 
+let roleService: RoleService
+
 const RoleServiceFactory = () : RoleService => {
 
-    let roleRepository: IRoleRepository
+    if(!roleService){
+        let roleRepository: IRoleRepository
+
+        switch (DbSetupUtils.getDbEngine()) {
+            case DbEngine.Mongo:
+                console.log("RoleServiceFactory DB ENGINE MONGODB")
+                roleRepository = new RoleMongoRepository()
+                break;
+            case DbEngine.Sqlite:
+                console.log("RoleServiceFactory DB ENGINE SQLITE")
+                roleRepository = new RoleSqliteRepository(DbSetupUtils.getDbConfig(), false)
+                roleRepository.table()
+                break;
+        }
 
-    switch (DbSetupUtils.getDbEngine()) {
-        case DbEngine.Mongo:
-            console.log("RoleServiceFactory DB ENGINE MONGODB")
-            roleRepository = new RoleMongoRepository()
-            break;
-        case DbEngine.Sqlite:
-            console.log("RoleServiceFactory DB ENGINE SQLITE")
-            roleRepository = new RoleSqliteRepository(process.env.SQLITE_DATABASE, false)
-            roleRepository.table()
-            break;
+        roleService = new RoleService(roleRepository)
     }
 
-    const roleService = new RoleService(roleRepository)
     return roleService
 }
 
- export default RoleServiceFactory()
+ export default RoleServiceFactory