@drax/identity-back 0.0.12 → 0.0.14

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(", "));
         }
     }