@drax/identity-back 0.0.31 → 0.1.0

package/dist/repository/sqlite/UserApiKeySqliteRepository.js

@@ -0,0 +1,147 @@
+import sqlite from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { SqliteErrorToValidationError, SqliteTableBuilder } from "@drax/common-back";
+import UserSqliteRepository from "./UserSqliteRepository.js";
+const tableFields = [
+    { name: "secret", type: "TEXT", unique: true, primary: false },
+    { name: "name", type: "TEXT", unique: false, primary: false },
+    { name: "user", type: "TEXT", unique: false, primary: false },
+    { name: "ipv4", type: "TEXT", unique: false, primary: false },
+    { name: "ipv6", type: "TEXT", unique: false, primary: false },
+    { name: "createdAt", type: "TEXT", unique: false, primary: false }
+];
+class UserApiKeySqliteRepository {
+    constructor(dataBaseFile, verbose = false) {
+        this.dataBaseFile = dataBaseFile;
+        this.userRepository = new UserSqliteRepository(dataBaseFile, verbose);
+        this.db = new sqlite(dataBaseFile, { verbose: verbose ? console.log : null });
+        this.table();
+    }
+    async findUserById(id) {
+        return await this.userRepository.findById(id);
+    }
+    table() {
+        const builder = new SqliteTableBuilder(this.dataBaseFile, 'user_api_keys', tableFields, false);
+        builder.build('id');
+    }
+    async create(userApiKeyData) {
+        try {
+            if (!userApiKeyData.id) {
+                userApiKeyData.id = randomUUID();
+            }
+            if (userApiKeyData.ipv4 && Array.isArray(userApiKeyData.ipv4) && userApiKeyData.ipv4.length > 0) {
+                userApiKeyData.ipv4 = userApiKeyData.ipv4.join(',');
+            }
+            else {
+                userApiKeyData.ipv4 = "";
+            }
+            if (userApiKeyData.ipv6 && Array.isArray(userApiKeyData.ipv6) && userApiKeyData.ipv6.length > 0) {
+                userApiKeyData.ipv6 = userApiKeyData.ipv6.join(',');
+            }
+            else {
+                userApiKeyData.ipv6 = "";
+            }
+            userApiKeyData.createdAt = (new Date().toISOString());
+            const fields = Object.keys(userApiKeyData)
+                .map(field => `${field}`)
+                .join(', ');
+            const values = Object.keys(userApiKeyData)
+                .map(field => `@${field}`)
+                .join(', ');
+            const stmt = this.db.prepare(`INSERT INTO user_api_keys (${fields})
+                                          VALUES (${values})`);
+            stmt.run(userApiKeyData);
+            return this.findById(userApiKeyData.id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, userApiKeyData);
+        }
+    }
+    async findById(id) {
+        const userApiKey = this.db.prepare('SELECT * FROM user_api_keys WHERE id = ?').get(id);
+        userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : [];
+        userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : [];
+        userApiKey.user = await this.findUserById(userApiKey.user);
+        return userApiKey;
+    }
+    async findBySecret(secret) {
+        const userApiKey = this.db.prepare('SELECT * FROM user_api_keys WHERE secret = ?').get(secret);
+        userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : [];
+        userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : [];
+        userApiKey.user = await this.findUserById(userApiKey.user);
+        return userApiKey;
+    }
+    async update(id, userApiKeyData) {
+        try {
+            if (userApiKeyData.ipv4 && Array.isArray(userApiKeyData.ipv4) && userApiKeyData.ipv4.length > 0) {
+                userApiKeyData.ipv4 = userApiKeyData.ipv4.join(',');
+            }
+            else {
+                userApiKeyData.ipv4 = "";
+            }
+            if (userApiKeyData.ipv6 && Array.isArray(userApiKeyData.ipv6) && userApiKeyData.ipv6.length > 0) {
+                userApiKeyData.ipv6 = userApiKeyData.ipv6.join(',');
+            }
+            else {
+                userApiKeyData.ipv6 = "";
+            }
+            delete userApiKeyData.secret;
+            const setClauses = Object.keys(userApiKeyData)
+                .map(field => `${field} = @${field}`)
+                .join(', ');
+            userApiKeyData.id = id;
+            const stmt = this.db.prepare(`UPDATE user_api_keys
+                                          SET ${setClauses}
+                                          WHERE id = @id `);
+            stmt.run(userApiKeyData);
+            return this.findById(id);
+        }
+        catch (e) {
+            console.log(e);
+            throw SqliteErrorToValidationError(e, userApiKeyData);
+        }
+    }
+    async delete(id) {
+        const stmt = this.db.prepare('DELETE FROM user_api_keys WHERE id = ?');
+        stmt.run(id);
+        return true;
+    }
+    async paginate({ page = 1, limit = 5, orderBy = '', orderDesc = false, search = '', filters = [] }) {
+        const offset = page > 1 ? (page - 1) * limit : 0;
+        let where = "";
+        if (search) {
+            where = ` WHERE name LIKE '%${search}%'`;
+        }
+        let whereFilters = [];
+        if (filters && filters.length > 0) {
+            where = where ? ` AND ` : ` WHERE `;
+            for (const filter of filters) {
+                if (['eq', '$eq'].includes(filter.operator)) {
+                    whereFilters.push(` ${filter.field} = '${filter.value}' `);
+                }
+                if (['ne', '$ne'].includes(filter.operator)) {
+                    whereFilters.push(` ${filter.field} != '${filter.value}' `);
+                }
+                if (['in', '$in'].includes(filter.operator)) {
+                    whereFilters.push(` ${filter.field} LIKE '%${filter.value}%' `);
+                }
+            }
+            where += whereFilters.join(" AND ");
+        }
+        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM user_api_keys' + where).get();
+        const userApiKeys = this.db.prepare('SELECT * FROM user_api_keys ' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
+        for (const userApiKey of userApiKeys) {
+            userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : [];
+            userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : [];
+            userApiKey.user = await this.findUserById(userApiKey.user);
+        }
+        return {
+            page: page,
+            limit: limit,
+            total: rCount.count,
+            items: userApiKeys
+        };
+    }
+}
+export default UserApiKeySqliteRepository;

package/dist/repository/sqlite/UserSqliteRepository.js

@@ -1,33 +1,34 @@
 import sqlite from "better-sqlite3";
 import { randomUUID } from "node:crypto";
-import { SqliteErrorToValidationError, ValidationError } from "@drax/common-back";
+import { SqliteErrorToValidationError, SqliteTableBuilder, ValidationError } from "@drax/common-back";
 import RoleSqliteRepository from "./RoleSqliteRepository.js";
 import TenantSqliteRepository from "./TenantSqliteRepository.js";
-const userTableSQL = `
-    CREATE TABLE IF NOT EXISTS users
-    (
-        id TEXT PRIMARY KEY,
-        name TEXT,
-        username TEXT UNIQUE,
-        active INTEGER,
-        password TEXT,
-        email TEXT UNIQUE,
-        phone TEXT,
-        role TEXT,
-        tenant TEXT,
-        groups TEXT,
-        avatar TEXT
-    );
-`;
+const tableFields = [
+    { name: "name", type: "TEXT", unique: false, primary: false },
+    { name: "username", type: "TEXT", unique: true, primary: false },
+    { name: "active", type: "INTEGER", unique: false, primary: false },
+    { name: "active", type: "INTEGER", unique: false, primary: false },
+    { name: "password", type: "TEXT", unique: false, primary: false },
+    { name: "email", type: "TEXT", unique: true, primary: false },
+    { name: "phone", type: "TEXT", unique: false, primary: false },
+    { name: "role", type: "TEXT", unique: false, primary: false },
+    { name: "tenant", type: "TEXT", unique: false, primary: false },
+    { name: "groups", type: "TEXT", unique: false, primary: false },
+    { name: "avatar", type: "TEXT", unique: false, primary: false },
+    { name: "createdAt", type: "TEXT", unique: false, primary: false },
+    { name: "updatedAt", type: "TEXT", unique: false, primary: false }
+];
 class UserSqliteRepository {
-    constructor(DATABASE, verbose = false) {
-        this.db = new sqlite(DATABASE, { verbose: verbose ? console.log : null });
-        this.roleRepository = new RoleSqliteRepository(DATABASE, verbose);
-        this.tenantRepository = new TenantSqliteRepository(DATABASE, verbose);
+    constructor(dataBaseFile, verbose = false) {
+        this.dataBaseFile = dataBaseFile;
+        this.db = new sqlite(dataBaseFile, { verbose: verbose ? console.log : null });
+        this.roleRepository = new RoleSqliteRepository(dataBaseFile, verbose);
+        this.tenantRepository = new TenantSqliteRepository(dataBaseFile, verbose);
         this.table();
     }
     table() {
-        this.db.exec(userTableSQL);
+        const builder = new SqliteTableBuilder(this.dataBaseFile, 'users', tableFields, false);
+        builder.build('id');
     }
     normalizeData(userData) {
         if (userData.groups && Array.isArray(userData.groups)) {
@@ -42,6 +43,7 @@ class UserSqliteRepository {
         if (!await this.findRoleById(userData.role)) {
             throw new ValidationError([{ field: 'role', reason: 'validation.notfound', value: userData.role }]);
         }
+        userData.createdAt = (new Date().toISOString());
         this.normalizeData(userData);
         try {
             const fields = Object.keys(userData)
@@ -64,6 +66,7 @@ class UserSqliteRepository {
             if (!await this.findRoleById(userData.role)) {
                 throw new ValidationError([{ field: 'role', reason: 'validation.notfound', value: userData.role }]);
             }
+            userData.updatedAt = (new Date().toISOString());
             this.normalizeData(userData);
             const setClauses = Object.keys(userData)
                 .map(field => `${field} = @${field}`)
@@ -117,19 +120,19 @@ class UserSqliteRepository {
         if (filters && filters.length > 0) {
             where = where ? ` AND ` : ` WHERE `;
             for (const filter of filters) {
-                if (filter.operator === '$eq') {
+                if (['eq', '$eq'].includes(filter.operator)) {
                     whereFilters.push(` ${filter.field} = '${filter.value}' `);
                 }
-                if (filter.operator === '$ne') {
+                if (['ne', '$ne'].includes(filter.operator)) {
                     whereFilters.push(` ${filter.field} != '${filter.value}' `);
                 }
-                if (filter.operator === '$in') {
+                if (['in', '$in'].includes(filter.operator)) {
                     whereFilters.push(` ${filter.field} LIKE '%${filter.value}%' `);
                 }
             }
             where += whereFilters.join(" AND ");
         }
-        // console.log("paginate where ", where, "search", search, "filters", filters, "whereFilters", whereFilters)
+        console.log("paginate where ", where, "search", search, "filters", filters, "whereFilters", whereFilters);
         const rCount = this.db.prepare('SELECT COUNT(*) as count FROM users' + where).get();
         const users = this.db.prepare('SELECT * FROM users' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
         for (const user of users) {

package/dist/routes/UserApiKeyRoutes.js

@@ -0,0 +1,119 @@
+import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
+import { ValidationError } from "@drax/common-back";
+import { IdentityPermissions } from "../permissions/IdentityPermissions.js";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+async function UserApiKeyRoutes(fastify, options) {
+    fastify.get('/api/user-api-keys', async (request, reply) => {
+        try {
+            request.rbac.assertAuthenticated();
+            request.rbac.assertOrPermissions([
+                IdentityPermissions.ViewUserApiKey,
+                IdentityPermissions.ViewMyUserApiKey
+            ]);
+            const filters = [];
+            if (!request.rbac.hasPermission(IdentityPermissions.ViewUserApiKey)) {
+                filters.push({ field: "user", operator: "eq", value: request.rbac.authUser.id });
+            }
+            const page = request.query.page;
+            const limit = request.query.limit;
+            const orderBy = request.query.orderBy;
+            const orderDesc = request.query.orderDesc;
+            const search = request.query.search;
+            const userApiKeyService = UserApiKeyServiceFactory();
+            let paginateResult = await userApiKeyService.paginate({ page, limit, orderBy, orderDesc, search, filters });
+            return paginateResult;
+        }
+        catch (e) {
+            console.log("/api/user-api-keys", e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.post('/api/user-api-keys', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.CreateUser);
+            const payload = request.body;
+            payload.user = request.rbac.authUser.id;
+            const userApiKeyService = UserApiKeyServiceFactory();
+            let userApiKey = await userApiKeyService.create(payload);
+            return userApiKey;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.put('/api/user-api-keys/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.UpdateUser);
+            const id = request.params.id;
+            const payload = request.body;
+            const userApiKeyService = UserApiKeyServiceFactory();
+            let userApiKey = await userApiKeyService.update(id, payload);
+            return userApiKey;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+    fastify.delete('/api/user-api-keys/:id', async (request, reply) => {
+        try {
+            request.rbac.assertPermission(IdentityPermissions.DeleteUser);
+            const id = request.params.id;
+            const userApiKeyService = UserApiKeyServiceFactory();
+            let r = await userApiKeyService.delete(id);
+            return r;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    });
+}
+export default UserApiKeyRoutes;
+export { UserApiKeyRoutes };

package/dist/routes/UserRoutes.js

@@ -26,6 +26,7 @@ async function UserRoutes(fastify, options) {
             if (request.authUser) {
                 const userService = UserServiceFactory();
                 let user = await userService.findById(request.authUser.id);
+                user.password = undefined;
                 delete user.password;
                 return user;
             }
@@ -62,10 +63,13 @@ async function UserRoutes(fastify, options) {
                 filters.push({ field: 'tenant', operator: '$eq', value: request.rbac.getAuthUser.tenantId });
             }
             let paginateResult = await userService.paginate({ page, limit, orderBy, orderDesc, search, filters });
+            for (let item of paginateResult.items) {
+                item.password = undefined;
+                delete item.password;
+            }
             return paginateResult;
         }
         catch (e) {
-            console.log("/api/users", e);
             if (e instanceof ValidationError) {
                 reply.statusCode = e.statusCode;
                 reply.send({ error: e.message, inputErrors: e.errors });

package/dist/services/UserApiKeyService.js

@@ -0,0 +1,65 @@
+import { DraxConfig, ZodErrorToValidationError } from "@drax/common-back";
+import { userApiKeySchema } from "../zod/UserApiKeyZod.js";
+import { ZodError } from "zod";
+import crypto from "node:crypto";
+import AuthUtils from "../utils/AuthUtils.js";
+import IdentityConfig from "../config/IdentityConfig.js";
+class UserApiKeyService {
+    constructor(userApiKeyRepostitory) {
+        this._repository = userApiKeyRepostitory;
+        console.log("UserApiKeyService constructor");
+    }
+    async create(userApiKeyData) {
+        try {
+            userApiKeyData.name = userApiKeyData?.name?.trim();
+            const secret = crypto.randomUUID();
+            const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret);
+            userApiKeyData.secret = AuthUtils.generateHMAC(APIKEY_SECRET, secret);
+            await userApiKeySchema.parseAsync(userApiKeyData);
+            const userApiKey = await this._repository.create(userApiKeyData);
+            userApiKey.secret = secret;
+            return userApiKey;
+        }
+        catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, userApiKeyData);
+            }
+            throw e;
+        }
+    }
+    async update(id, userApiKeyData) {
+        try {
+            userApiKeyData.name = userApiKeyData?.name?.trim();
+            delete userApiKeyData.secret;
+            await userApiKeySchema.parseAsync(userApiKeyData);
+            const userApiKey = await this._repository.update(id, userApiKeyData);
+            return userApiKey;
+        }
+        catch (e) {
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, userApiKeyData);
+            }
+            throw e;
+        }
+    }
+    async delete(id) {
+        const currentUserApiKey = await this.findById(id);
+        const deletedUserApiKey = await this._repository.delete(id);
+        return deletedUserApiKey;
+    }
+    async findById(id) {
+        const userApiKey = await this._repository.findById(id);
+        return userApiKey;
+    }
+    async findBySecret(secret) {
+        const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret);
+        const hashedSecret = AuthUtils.generateHMAC(APIKEY_SECRET, secret);
+        const userApiKey = await this._repository.findBySecret(hashedSecret);
+        return userApiKey;
+    }
+    async paginate({ page = 1, limit = 5, orderBy = '', orderDesc = false, search = '', filters = [] }) {
+        const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
+        return pagination;
+    }
+}
+export default UserApiKeyService;

package/dist/setup/LoadIdentityConfigFromEnv.js

@@ -1,12 +1,12 @@
 import { DraxConfig } from "@drax/common-back";
 import IdentityConfig from "../config/IdentityConfig.js";
 function LoadIdentityConfigFromEnv() {
-    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]);
+    DraxConfig.set(IdentityConfig.ApiKeySecret, process.env[IdentityConfig.ApiKeySecret]);
+    DraxConfig.set(IdentityConfig.RbacCacheTTL, process.env[IdentityConfig.RbacCacheTTL]);
+    DraxConfig.set(IdentityConfig.AvatarDir, process.env[IdentityConfig.AvatarDir]);
 }
 export default LoadIdentityConfigFromEnv;
 export { LoadIdentityConfigFromEnv };

package/dist/utils/AuthUtils.js

@@ -2,6 +2,7 @@ import bcryptjs from "bcryptjs";
 import jsonwebtoken from "jsonwebtoken";
 import { DraxConfig } from "@drax/common-back";
 import IdentityConfig from "../config/IdentityConfig.js";
+import crypto from "crypto";
 class AuthUtils {
     static verifyToken(token) {
         const JWT_SECRET = DraxConfig.getOrLoad(IdentityConfig.JwtSecret);
@@ -51,5 +52,14 @@ class AuthUtils {
         let token = jsonwebtoken.sign(payload, JWT_SECRET, options);
         return token;
     }
+    static generateHMAC(secret, apikey) {
+        // Crear un objeto HMAC utilizando el algoritmo SHA-256 y el secreto
+        const hmac = crypto.createHmac('sha256', secret);
+        // Actualizar el HMAC con la apikey
+        hmac.update(apikey);
+        // Generar el hash en formato hexadecimal
+        return hmac.digest('hex');
+    }
 }
 export default AuthUtils;
+export { AuthUtils };

package/dist/zod/UserApiKeyZod.js

@@ -0,0 +1,9 @@
+import { array, object, string } from "zod";
+const userApiKeySchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    ipv4: array(string().ip({ version: "v4", message: 'validation.invalidIpv4' })),
+    ipv6: array(string().ip({ version: "v6", message: 'validation.invalidIpv6' })),
+});
+export default userApiKeySchema;
+export { userApiKeySchema };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.31",
+  "version": "0.1.0",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -16,7 +16,8 @@
     "tsc": "tsc -b tsconfig.json",
     "test": "node --import tsx --test test/**/*",
     "testMongoRepositoryRole": "node --import tsx --test test/repository/mongo/role*",
-    "testMongoRepositoryUser": "node --import tsx --test test/repository/mongo/user*",
+    "testMongoRepositoryUser": "node --import tsx --test test/repository/mongo/user-mongo*",
+    "testMongoRepositoryUserApiKey": "node --import tsx --test test/repository/mongo/user-apikey-mongo*",
     "testSqliteRepositoryUser": "node --import tsx --test test/repository/sqlite/user*",
     "testSqliteRepositoryRole": "node --import tsx --test test/repository/sqlite/role*",
     "testServiceRole": "node --import tsx --test test/service/role*",
@@ -26,9 +27,9 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^0.0.31",
-    "@drax/common-share": "^0.0.31",
-    "@drax/identity-share": "^0.0.31",
+    "@drax/common-back": "^0.1.0",
+    "@drax/common-share": "^0.1.0",
+    "@drax/identity-share": "^0.1.0",
     "bcryptjs": "^2.4.3",
     "express-jwt": "^8.4.1",
     "graphql": "^16.8.2",
@@ -59,5 +60,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "14a8c465526ef0edc3179be38fb0aaa081a4ebc4"
+  "gitHead": "bec2a22554155ef5deab5a55245878a4449932ad"
 }

package/src/config/IdentityConfig.ts

@@ -1,13 +1,14 @@
 enum IdentityConfig {
 
-    DbEngine = "DRAX_DB_ENGINE",
-    SqliteDbFile = "DRAX_SQLITE_FILE",
-    MongoDbUri = "DRAX_MONGO_URI",
+
 
     JwtSecret = "DRAX_JWT_SECRET",
     JwtExpiration = "DRAX_JWT_EXPIRATION",
     JwtIssuer = "DRAX_JWT_ISSUER",
 
+    ApiKeySecret = "DRAX_APIKEY_SECRET",
+    ApiKeyCacheTTL = "DRAX_APIKEY_CACHE_TTL",
+
     RbacCacheTTL = "DRAX_RBAC_CACHE_TTL",
 
     AvatarDir = "DRAX_AVATAR_DIR",

package/src/factory/RoleServiceFactory.ts

@@ -1,26 +1,26 @@
-import {DraxConfig} from "@drax/common-back"
+import {DraxConfig, CommonConfig, COMMON} 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 = (verbose: boolean = false) : RoleService => {
+const RoleServiceFactory = (verbose: boolean = false): RoleService => {
 
-    if(!roleService){
+    if (!roleService) {
         let roleRepository: IRoleRepository
 
-        switch (DbSetupUtils.getDbEngine()) {
-            case DbEngine.Mongo:
-                console.log("RoleServiceFactory DB ENGINE MONGODB")
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
                 roleRepository = new RoleMongoRepository()
                 break;
-            case DbEngine.Sqlite:
-                console.log("RoleServiceFactory DB ENGINE SQLITE")
-                roleRepository = new RoleSqliteRepository(DbSetupUtils.getDbConfig(), verbose)
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                roleRepository = new RoleSqliteRepository(dbFile, verbose)
                 break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
         }
 
         roleService = new RoleService(roleRepository)
@@ -29,4 +29,4 @@ const RoleServiceFactory = (verbose: boolean = false) : RoleService => {
     return roleService
 }
 
- export default RoleServiceFactory
+export default RoleServiceFactory

package/src/factory/TenantServiceFactory.ts

@@ -1,26 +1,26 @@
-import {DraxConfig} from "@drax/common-back"
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back"
 import TenantService from "../services/TenantService.js";
 import TenantMongoRepository from "../repository/mongo/TenantMongoRepository.js";
 import TenantSqliteRepository from "../repository/sqlite/TenantSqliteRepository.js";
-import {DbSetupUtils, DbEngine} from "../utils/DbSetupUtils.js";
 import type {ITenantRepository} from "../interfaces/ITenantRepository";
 
 let tenantService: TenantService
 
-const TenantServiceFactory = (verbose: boolean = false) : TenantService => {
+const TenantServiceFactory = (verbose: boolean = false): TenantService => {
 
-    if(!tenantService){
+    if (!tenantService) {
         let tenantRepository: ITenantRepository
 
-        switch (DbSetupUtils.getDbEngine()) {
-            case DbEngine.Mongo:
-                console.log("TenantServiceFactory DB ENGINE MONGODB")
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
                 tenantRepository = new TenantMongoRepository()
                 break;
-            case DbEngine.Sqlite:
-                console.log("TenantServiceFactory DB ENGINE SQLITE")
-                tenantRepository = new TenantSqliteRepository(DbSetupUtils.getDbConfig(), verbose)
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                tenantRepository = new TenantSqliteRepository(dbFile, verbose)
                 break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
         }
 
         tenantService = new TenantService(tenantRepository)
@@ -29,4 +29,4 @@ const TenantServiceFactory = (verbose: boolean = false) : TenantService => {
     return tenantService
 }
 
- export default TenantServiceFactory
+export default TenantServiceFactory