@drax/identity-back 0.0.12 → 0.0.14

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,7 +4,7 @@ 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;
+const roleService = RoleServiceFactory();
 export default {
     Query: {
         findRoleById: async (_, { id }, { rbac }) => {
@@ -89,6 +89,10 @@ export default {
         updateRole: async (_, { id, input }, { rbac }) => {
             try {
                 rbac.assertPermission(IdentityPermissions.UpdateRole);
+                const currentRole = await roleService.findById(id);
+                if (currentRole.readonly) {
+                    throw new ValidationError([{ field: 'name', reason: "role.readonly", value: input.name }]);
+                }
                 return await roleService.update(id, input);
             }
             catch (e) {

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

@@ -4,7 +4,7 @@ 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;
+const userService = UserServiceFactory();
 export default {
     Query: {
         me: async (_, {}, { authUser }) => {

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,9 +1,10 @@
-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;
+const roleService = RoleServiceFactory();
 async function roleLoader(k) {
     const role = await roleService.findById(k);
     if (role) {

package/dist/routes/RoleRoutes.js

@@ -3,7 +3,7 @@ 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;
+const roleService = RoleServiceFactory();
 async function RoleRoutes(fastify, options) {
     fastify.get('/api/permissions', async (request, reply) => {
         try {
@@ -144,6 +144,10 @@ async function RoleRoutes(fastify, options) {
             request.rbac.assertPermission(IdentityPermissions.UpdateRole);
             const id = request.params.id;
             const payload = request.body;
+            const currentRole = await roleService.findById(id);
+            if (currentRole.readonly) {
+                throw new ValidationError([{ field: 'name', reason: "role.readonly", value: payload.name }]);
+            }
             let role = await roleService.update(id, payload);
             return role;
         }

package/dist/routes/UserRoutes.js

@@ -3,7 +3,7 @@ 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;
+const userService = UserServiceFactory();
 async function UserRoutes(fastify, options) {
     fastify.post('/api/auth', async (request, reply) => {
         try {

package/dist/services/RoleService.js

@@ -1,4 +1,4 @@
-import { ValidationError, ZodErrorToValidationError } from "@drax/common-back";
+import { ZodErrorToValidationError } from "@drax/common-back";
 import { roleSchema } from "../zod/RoleZod.js";
 import { ZodError } from "zod";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
@@ -25,10 +25,6 @@ class RoleService {
         try {
             roleData.name = roleData?.name?.trim();
             await roleSchema.parseAsync(roleData);
-            const currentRole = await this.findById(id);
-            if (currentRole.readonly) {
-                throw new ValidationError([{ field: 'name', reason: "role.readonly", value: roleData.name }]);
-            }
             const role = await this._repository.update(id, roleData);
             return role;
         }

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.12",
+  "version": "0.0.14",
   "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": "8ce067f9804a5af6ed630206387331ec1248fb13"
+  "gitHead": "ef0b07b3396f6eeb1f045ef430b4ec3856896f7e"
 }

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

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,7 +5,7 @@ import {GraphQLError} from "graphql";
 import {PermissionService} from "../../services/PermissionService.js";
 import UnauthorizedError from "../../errors/UnauthorizedError.js";
 
-const roleService = RoleServiceFactory
+const roleService = RoleServiceFactory()
 export default {
     Query: {
         findRoleById: async (_, {id}, {rbac}) => {
@@ -85,6 +85,12 @@ export default {
         updateRole: async (_, {id, input}, {rbac}) => {
             try {
                 rbac.assertPermission(IdentityPermissions.UpdateRole)
+
+                const currentRole = await roleService.findById(id)
+                if(currentRole.readonly){
+                    throw new ValidationError([{field:'name', reason:"role.readonly", value:input.name}])
+                }
+
                 return await roleService.update(id, input)
             } catch (e) {
                 console.error("updateRole",e)

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

@@ -5,7 +5,7 @@ import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
 import UnauthorizedError from "../../errors/UnauthorizedError.js";
 import BadCredentialsError from "../../errors/BadCredentialsError.js";
 
-const userService = UserServiceFactory
+const userService = UserServiceFactory()
 
 export default {
     Query: {

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,12 +1,13 @@
 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
+const roleService = RoleServiceFactory()
 
 async function roleLoader(k):Promise<IRoleBase | null> {
     const role: IRole = await roleService.findById(k)

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
+const roleService = RoleServiceFactory()
 
 async function RoleRoutes(fastify, options) {
 
@@ -138,6 +138,12 @@ async function RoleRoutes(fastify, options) {
             request.rbac.assertPermission(IdentityPermissions.UpdateRole)
             const id = request.params.id
             const payload = request.body
+
+            const currentRole = await roleService.findById(id)
+            if(currentRole.readonly){
+                throw new ValidationError([{field:'name', reason:"role.readonly", value:payload.name}])
+            }
+
             let role = await roleService.update(id, payload)
             return role
         } catch (e) {

package/src/routes/UserRoutes.ts

@@ -5,7 +5,7 @@ import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
 import BadCredentialsError from "../errors/BadCredentialsError.js";
 
-const userService = UserServiceFactory
+const userService = UserServiceFactory()
 
 async function UserRoutes(fastify, options) {
     fastify.post('/api/auth', async (request, reply) => {

package/src/services/RoleService.ts

@@ -32,10 +32,6 @@ class RoleService {
         try {
             roleData.name = roleData?.name?.trim()
             await roleSchema.parseAsync(roleData)
-            const currentRole = await this.findById(id)
-            if(currentRole.readonly){
-                throw new ValidationError([{field:'name', reason:"role.readonly", value:roleData.name}])
-            }
             const role = await this._repository.update(id, roleData)
             return role
         } catch (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
+}