@drax/identity-back 0.0.31 → 0.1.2

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/TenantService.js

@@ -14,6 +14,7 @@ class TenantService {
             return tenant;
         }
         catch (e) {
+            console.error("Error creating tenant", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, tenantData);
             }
@@ -28,6 +29,7 @@ class TenantService {
             return tenant;
         }
         catch (e) {
+            console.error("Error updating tenant", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, tenantData);
             }
@@ -35,25 +37,54 @@ class TenantService {
         }
     }
     async delete(id) {
-        const currentTenant = await this.findById(id);
-        const deletedTenant = await this._repository.delete(id);
-        return deletedTenant;
+        try {
+            const deletedTenant = await this._repository.delete(id);
+            return deletedTenant;
+        }
+        catch (e) {
+            console.error("Error deleting tenant", e);
+            throw e;
+        }
     }
     async findById(id) {
-        const tenant = await this._repository.findById(id);
-        return tenant;
+        try {
+            const tenant = await this._repository.findById(id);
+            return tenant;
+        }
+        catch (e) {
+            console.error("Error finding tenant by id", e);
+            throw e;
+        }
     }
     async findByName(name) {
-        const tenant = await this._repository.findByName(name);
-        return tenant;
+        try {
+            const tenant = await this._repository.findByName(name);
+            return tenant;
+        }
+        catch (e) {
+            console.error("Error finding tenant by name", e);
+            throw e;
+        }
     }
     async fetchAll() {
-        const tenants = await this._repository.fetchAll();
-        return tenants;
+        try {
+            const tenants = await this._repository.fetchAll();
+            return tenants;
+        }
+        catch (e) {
+            console.error("Error fetching all tenants", e);
+            throw e;
+        }
     }
     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;
+        try {
+            const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
+            return pagination;
+        }
+        catch (e) {
+            console.error("Error paginating tenants", e);
+            throw e;
+        }
     }
 }
 export default TenantService;

package/dist/services/UserApiKeyService.js

@@ -0,0 +1,90 @@
+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) {
+            console.error("Error creating userApiKey", 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) {
+            console.error("Error updating userApiKey", e);
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, userApiKeyData);
+            }
+            throw e;
+        }
+    }
+    async delete(id) {
+        try {
+            const deletedUserApiKey = await this._repository.delete(id);
+            return deletedUserApiKey;
+        }
+        catch (e) {
+            console.error("Error deleting userApiKey", e);
+            throw e;
+        }
+    }
+    async findById(id) {
+        try {
+            const userApiKey = await this._repository.findById(id);
+            return userApiKey;
+        }
+        catch (e) {
+            console.error("Error finding userApiKey by id", e);
+            throw e;
+        }
+    }
+    async findBySecret(secret) {
+        try {
+            const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret);
+            const hashedSecret = AuthUtils.generateHMAC(APIKEY_SECRET, secret);
+            const userApiKey = await this._repository.findBySecret(hashedSecret);
+            return userApiKey;
+        }
+        catch (e) {
+            console.error("Error finding userApiKey by secret", e);
+            throw e;
+        }
+    }
+    async paginate({ page = 1, limit = 5, orderBy = '', orderDesc = false, search = '', filters = [] }) {
+        try {
+            const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
+            return pagination;
+        }
+        catch (e) {
+            console.error("Error paginating userApiKeys", e);
+            throw e;
+        }
+    }
+}
+export default UserApiKeyService;

package/dist/services/UserService.js

@@ -74,6 +74,7 @@ class UserService {
             return user;
         }
         catch (e) {
+            console.error("Error creating user", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, userData);
             }
@@ -91,6 +92,7 @@ class UserService {
             return user;
         }
         catch (e) {
+            console.error("Error updating user", e);
             if (e instanceof ZodError) {
                 throw ZodErrorToValidationError(e, userData);
             }
@@ -98,20 +100,44 @@ class UserService {
         }
     }
     async delete(id) {
-        const deletedRole = await this._repository.delete(id);
-        return deletedRole;
+        try {
+            const deletedRole = await this._repository.delete(id);
+            return deletedRole;
+        }
+        catch (e) {
+            console.error("Error deleting user", e);
+            throw e;
+        }
     }
     async findById(id) {
-        const user = await this._repository.findById(id);
-        return user;
+        try {
+            const user = await this._repository.findById(id);
+            return user;
+        }
+        catch (e) {
+            console.error("Error finding user by id", e);
+            throw e;
+        }
     }
     async findByUsername(username) {
-        const user = await this._repository.findByUsername(username);
-        return user;
+        try {
+            const user = await this._repository.findByUsername(username);
+            return user;
+        }
+        catch (e) {
+            console.error("Error finding user by username", e);
+            throw e;
+        }
     }
     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;
+        try {
+            const pagination = await this._repository.paginate({ page, limit, orderBy, orderDesc, search, filters });
+            return pagination;
+        }
+        catch (e) {
+            console.error("Error paginating users", e);
+            throw e;
+        }
     }
 }
 export default UserService;

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 };