@drax/identity-back 0.0.13 → 0.0.15

package/src/factory/UserServiceFactory.ts

@@ -1,27 +1,31 @@
 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";
 import {IUserRepository} from "../interfaces/IUserRepository";
 
+let userService: UserService
+
 const UserServiceFactory = () : UserService => {
 
-    let userRepository: IUserRepository
-    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: IUserRepository
+        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/src/graphql/resolvers/role.resolvers.ts

@@ -5,12 +5,13 @@ 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) {
                 if (e instanceof UnauthorizedError) {
@@ -22,6 +23,7 @@ export default {
         findRoleByName: async (_, {name}, {rbac}) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewRole)
+                const roleService = RoleServiceFactory()
                 return await roleService.findByName(name)
             } catch (e) {
                 if (e instanceof UnauthorizedError) {
@@ -33,6 +35,7 @@ export default {
         fetchRole: async (_, {}, {rbac}) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewRole)
+                const roleService = RoleServiceFactory()
                 return await roleService.fetchAll()
             } catch (e) {
                 if (e instanceof UnauthorizedError) {
@@ -55,6 +58,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) {
                 console.error("paginateRole",e)
@@ -69,6 +73,7 @@ export default {
         createRole: async (_, {input}, {rbac}) => {
             try {
                 rbac.assertPermission(IdentityPermissions.CreateRole)
+                const roleService = RoleServiceFactory()
                 return await roleService.create(input)
             } catch (e) {
                 console.error("createRole",e)
@@ -85,7 +90,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}])
@@ -106,6 +111,7 @@ export default {
         deleteRole: async (_, {id}, {rbac}) => {
             try {
                 rbac.assertPermission(IdentityPermissions.DeleteRole)
+                const roleService = RoleServiceFactory()
                 return await roleService.delete(id)
             } catch (e) {
                 console.error("deleteRole",e)

package/src/graphql/resolvers/user.resolvers.ts

@@ -5,13 +5,12 @@ 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
@@ -26,6 +25,7 @@ export default {
         findUserById: async (_, {id}, {rbac}) => {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewUser)
+                let userService= UserServiceFactory()
                 return await userService.findById(id)
             } catch (e) {
                 if (e instanceof UnauthorizedError) {
@@ -38,6 +38,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) {
                 if (e instanceof UnauthorizedError) {
@@ -50,6 +51,7 @@ export default {
     Mutation: {
         auth: async (_, {input}) => {
             try {
+                let userService= UserServiceFactory()
                 return await userService.auth(input.username, input.password)
             } catch (e) {
                 console.error("auth", e)
@@ -63,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
             } catch (e) {
@@ -79,7 +82,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
             } catch (e) {
@@ -94,6 +97,7 @@ export default {
         deleteUser: async (_, {id}, {rbac}) => {
             try {
                 rbac.assertPermission(IdentityPermissions.DeleteUser)
+                let userService= UserServiceFactory()
                 return await userService.delete(id)
             } catch (e) {
                 console.error("deleteUser", e)
@@ -111,6 +115,7 @@ export default {
                     throw new UnauthorizedError()
                 }
                 let userId = authUser.id
+                let userService= UserServiceFactory()
                 return await userService.changeOwnPassword(userId, currentPassword, newPassword)
             } catch (e) {
                 if (e instanceof ValidationError) {
@@ -124,7 +129,7 @@ export default {
         changeUserPassword: async (_, {userId, newPassword}, {rbac}) => {
             try {
                 rbac.assertPermission(IdentityPermissions.UpdateUser)
-
+                let userService= UserServiceFactory()
                 return await userService.changeUserPassword(userId, newPassword)
             } catch (e) {
                 if (e instanceof ValidationError) {

package/src/index.ts

@@ -12,9 +12,16 @@ 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";
+
 import type {IJwtUser} from "./interfaces/IJwtUser";
 import type {IRole, IRoleBase} from "./interfaces/IRole";
 import type {IUser, IUserCreate, IUserUpdate} from "./interfaces/IUser";
@@ -62,9 +69,19 @@ export {
     //Permissions
     IdentityPermissions,
 
+    //Config
+    IdentityConfig,
+
     //Errors
     UnauthorizedError,
-    BadCredentialsError
+    BadCredentialsError,
+
+    //Setup
+    LoadConfigFromEnv,
+    LoadPermissions,
+    CreateOrUpdateRole,
+    CreateUserIfNotExist,
+    RecoveryUserPassword
 }
 
 

package/src/middleware/rbacMiddleware.ts

@@ -1,14 +1,16 @@
 import type {IJwtUser} from "../interfaces/IJwtUser";
 import type {IRole, IRoleBase} from "../interfaces/IRole";
-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";
+import IdentityConfig from "../config/IdentityConfig.js";
 
-const cacheTTL = process.env.RBAC_CACHE_TTL ? parseInt(process.env.RBAC_CACHE_TTL) : 10000;
+const cacheTTL = DraxConfig.getOrLoad(IdentityConfig.RbacCacheTTL) ? parseInt(DraxConfig.getOrLoad(IdentityConfig.RbacCacheTTL)) : 10000;
 const draxCache = new DraxCache<IRoleBase>(cacheTTL);
-const roleService = RoleServiceFactory
+
 
 async function roleLoader(k):Promise<IRoleBase | null> {
+    const roleService = RoleServiceFactory()
     const role: IRole = await roleService.findById(k)
     if(role){
         return {id: role.id, name: role.name, permissions: role.permissions} as IRoleBase

package/src/routes/RoleRoutes.ts

@@ -5,7 +5,7 @@ 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) {
 
@@ -30,6 +30,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
         } catch (e) {
@@ -51,6 +52,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
         } catch (e) {
@@ -71,6 +73,7 @@ async function RoleRoutes(fastify, options) {
     fastify.get('/api/roles/all', async (request, reply): Promise<IRole[]> => {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewRole)
+            const roleService = RoleServiceFactory()
             let roles = await roleService.fetchAll()
             return roles
         } catch (e) {
@@ -94,6 +97,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
         } catch (e) {
@@ -115,6 +119,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
         } catch (e) {
@@ -138,7 +143,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}])
@@ -166,6 +171,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
         } catch (e) {

package/src/routes/UserRoutes.ts

@@ -5,13 +5,12 @@ 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) {
             console.error('/api/auth error', e)
@@ -30,6 +29,7 @@ async function UserRoutes(fastify, options) {
     fastify.get('/api/me', async (request, reply): Promise<IUser | null> => {
         try {
             if (request.authUser) {
+                const userService = UserServiceFactory()
                 let user = await userService.findById(request.authUser.id)
                 delete user.password
                 return user
@@ -60,6 +60,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
         } catch (e) {
@@ -80,6 +81,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
         } catch (e) {
@@ -102,6 +104,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
         } catch (e) {
@@ -126,6 +129,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
         } catch (e) {
@@ -150,6 +154,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) {
             console.error('/api/password error', e)
@@ -175,7 +180,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) {
             console.error('/api/password error', e)

package/src/setup/CreateOrUpdateRole.ts

@@ -0,0 +1,19 @@
+import type {IRole} from "../interfaces/IRole"
+import RoleServiceFactory from "../factory/RoleServiceFactory.js"
+
+async function CreateOrUpdateRole(roleData: IRole) {
+    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/src/setup/CreateUserIfNotExist.ts

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

package/src/setup/LoadConfigFromEnv.ts

@@ -0,0 +1,16 @@
+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/src/setup/LoadPermissions.ts

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

package/src/setup/RecoveryUserPassword.ts

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

package/src/utils/AuthUtils.ts

@@ -1,12 +1,14 @@
 import bcryptjs from "bcryptjs";
 import jsonwebtoken, {SignOptions, VerifyOptions} from "jsonwebtoken";
+import {DraxConfig} from "@drax/common-back";
+import IdentityConfig from "../config/IdentityConfig.js";
 
 class AuthUtils{
 
     static verifyToken(token : string) {
-        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 : VerifyOptions = {
             algorithms: ['HS256'],
@@ -40,17 +42,20 @@ class AuthUtils{
     static generateToken(userId : string, username: string, roleId: string,  session : string) {
         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 : SignOptions = {
-            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(

package/src/utils/DbSetupUtils.ts

@@ -1,3 +1,5 @@
+import IdentityConfig from "../config/IdentityConfig.js";
+import {DraxConfig} from "@drax/common-back";
 
 enum DbEngine{
     Sqlite = "sqlite",
@@ -9,24 +11,24 @@ 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 as DbEngine;
+        const dbEngine = DraxConfig.getOrLoad(IdentityConfig.DbEngine) as 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(", "));
         }
     }