@drax/identity-back 0.0.13 → 0.0.14

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