@drax/identity-back 0.0.31 → 0.1.0

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -4,27 +4,35 @@ import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
-import {SqliteErrorToValidationError} from "@drax/common-back";
+import {SqliteErrorToValidationError, SqliteTableBuilder} from "@drax/common-back";
+import type {SqliteTableField} from "@drax/common-back";
+
+
+const tableFields: SqliteTableField[] = [
+    {name: "name", type: "TEXT", unique: false, primary: false},
+    {name: "createdAt", type: "TEXT", unique: false, primary: false},
+    {name: "updatedAt", type: "TEXT", unique: false, primary: false},
+]
 
-const tenantTableSQL: string = `
-    CREATE TABLE IF NOT EXISTS tenants
-    (
-        id TEXT PRIMARY KEY,
-        name TEXT
-    );
-`;
 
 class TenantSqliteRepository implements ITenantRepository{
 
     private db: any;
+    private dataBaseFile: string;
 
-    constructor(DATABASE:string, verbose:boolean = false) {
-        this.db = new sqlite(DATABASE, {verbose: verbose ? console.log : null});
+    constructor(dataBaseFile:string, verbose:boolean = false) {
+        this.dataBaseFile = dataBaseFile;
+        this.db = new sqlite(this.dataBaseFile, {verbose: verbose ? console.log : null});
         this.table()
     }
 
     table() {
-        this.db.exec(tenantTableSQL);
+        const builder = new SqliteTableBuilder(
+            this.dataBaseFile,
+            'tenants',
+            tableFields,
+            false);
+        builder.build('id')
     }
 
 
@@ -36,6 +44,7 @@ class TenantSqliteRepository implements ITenantRepository{
                 tenantData.id = randomUUID()
             }
 
+            tenantData.createdAt = (new Date().toISOString())
 
             const fields = Object.keys(tenantData)
                 .map(field => `${field}`)
@@ -66,10 +75,15 @@ class TenantSqliteRepository implements ITenantRepository{
 
     async update(id: string, tenantData: ITenantBase): Promise<ITenant> {
         try{
+
+            tenantData.updatedAt = (new Date().toISOString())
+
             const setClauses = Object.keys(tenantData)
                 .map(field => `${field} = @${field}`)
                 .join(', ');
+
             tenantData.id = id
+
             const stmt = this.db.prepare( `UPDATE tenants SET ${setClauses} WHERE id = @id `);
             stmt.run(tenantData);
             return this.findById(id)

package/src/repository/sqlite/UserApiKeySqliteRepository.ts

@@ -0,0 +1,197 @@
+import {IUserApiKey, IUserApiKeyBase} from '@drax/identity-share'
+import {IUserApiKeyRepository} from '../../interfaces/IUserApiKeyRepository'
+import {UUID} from "crypto";
+import sqlite from "better-sqlite3";
+import {randomUUID} from "node:crypto";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
+import {SqliteErrorToValidationError, SqliteTableBuilder} from "@drax/common-back";
+import type {SqliteTableField} from "@drax/common-back";
+import UserSqliteRepository from "./UserSqliteRepository.js";
+
+
+const tableFields: SqliteTableField[] = [
+    {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 implements IUserApiKeyRepository {
+
+    private db: any;
+    private dataBaseFile: string;
+    private userRepository: UserSqliteRepository;
+
+    constructor(dataBaseFile: string, verbose: boolean = 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: string) {
+        return await this.userRepository.findById(id)
+    }
+
+    table() {
+        const builder = new SqliteTableBuilder(
+            this.dataBaseFile,
+            'user_api_keys',
+            tableFields,
+            false);
+        builder.build('id')
+    }
+
+
+    async create(userApiKeyData: IUserApiKeyBase): Promise<IUserApiKey> {
+        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 as UUID)
+        } catch (e) {
+            console.log(e)
+            throw SqliteErrorToValidationError(e, userApiKeyData)
+        }
+    }
+
+    async findById(id: string): Promise<IUserApiKey | null> {
+        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: string): Promise<IUserApiKey | null> {
+        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: string, userApiKeyData: IUserApiKeyBase): Promise<IUserApiKey> {
+        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: string): Promise<boolean> {
+        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 = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
+        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/src/repository/sqlite/UserSqliteRepository.ts

@@ -4,42 +4,48 @@ import {randomUUID} from "node:crypto";
 import {UUID} from "crypto";
 import {IUserRepository} from "../../interfaces/IUserRepository";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
-import { SqliteErrorToValidationError, ValidationError} from "@drax/common-back";
+import {SqliteErrorToValidationError, SqliteTableBuilder, ValidationError} from "@drax/common-back";
+import type {SqliteTableField} from "@drax/common-back";
 import RoleSqliteRepository from "./RoleSqliteRepository.js";
 import TenantSqliteRepository from "./TenantSqliteRepository.js";
 
-
-const userTableSQL: string = `
-    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: SqliteTableField[] = [
+    {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 implements IUserRepository {
     private db: any;
     private roleRepository: RoleSqliteRepository;
     private tenantRepository: TenantSqliteRepository;
+    private dataBaseFile: string;
 
-    constructor(DATABASE: string, verbose: boolean = 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: string, verbose: boolean = 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: IUserCreate | IUserUpdate): void {
@@ -58,6 +64,8 @@ class UserSqliteRepository implements IUserRepository {
             throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
         }
 
+        userData.createdAt = (new Date().toISOString())
+
         this.normalizeData(userData)
 
         try {
@@ -86,6 +94,8 @@ class UserSqliteRepository implements IUserRepository {
                 throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
             }
 
+            userData.updatedAt = (new Date().toISOString())
+
             this.normalizeData(userData)
 
             const setClauses = Object.keys(userData)
@@ -153,20 +163,20 @@ class UserSqliteRepository implements IUserRepository {
         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();
 

package/src/routes/UserApiKeyRoutes.ts

@@ -0,0 +1,128 @@
+import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
+import type {IUserApiKey} from "@drax/identity-share";
+import {ValidationError} from "@drax/common-back";
+import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
+import UnauthorizedError from "../errors/UnauthorizedError.js";
+import {IDraxPaginateResult} from "@drax/common-share";
+
+
+async function UserApiKeyRoutes(fastify, options) {
+
+    fastify.get('/api/user-api-keys', async (request, reply): Promise<IDraxPaginateResult<IUserApiKey>> => {
+
+        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): Promise<IUserApiKey> => {
+        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): Promise<IUserApiKey> => {
+        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): Promise<any> => {
+        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/src/routes/UserRoutes.ts

@@ -32,6 +32,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
             } else {
@@ -69,9 +70,12 @@ 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/src/services/UserApiKeyService.ts

@@ -0,0 +1,86 @@
+import {IUserApiKeyRepository} from "../interfaces/IUserApiKeyRepository";
+import {DraxConfig, ValidationError, ZodErrorToValidationError} from "@drax/common-back"
+import {userApiKeySchema} from "../zod/UserApiKeyZod.js";
+import {ZodError} from "zod";
+import {IUserApiKeyBase, IUserApiKey} from "@drax/identity-share";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import crypto from "node:crypto";
+import AuthUtils from "../utils/AuthUtils.js";
+import IdentityConfig from "../config/IdentityConfig.js";
+
+class UserApiKeyService {
+
+    _repository: IUserApiKeyRepository
+
+    constructor(userApiKeyRepostitory: IUserApiKeyRepository) {
+        this._repository = userApiKeyRepostitory
+        console.log("UserApiKeyService constructor")
+    }
+
+    async create(userApiKeyData: IUserApiKeyBase): Promise<IUserApiKey> {
+        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: string, userApiKeyData: IUserApiKeyBase) {
+        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: string): Promise<boolean> {
+        const currentUserApiKey = await this.findById(id)
+        const deletedUserApiKey = await this._repository.delete(id);
+        return deletedUserApiKey;
+    }
+
+    async findById(id: string): Promise<IUserApiKey | null> {
+        const userApiKey: IUserApiKey = await this._repository.findById(id);
+        return userApiKey
+    }
+
+    async findBySecret(secret: string): Promise<IUserApiKey | null> {
+        const APIKEY_SECRET = DraxConfig.getOrLoad(IdentityConfig.ApiKeySecret)
+        const hashedSecret = AuthUtils.generateHMAC(APIKEY_SECRET, secret)
+        const userApiKey: IUserApiKey = await this._repository.findBySecret(hashedSecret);
+        return userApiKey
+    }
+
+
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>>{
+        const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
+        return pagination;
+    }
+
+
+}
+
+export default UserApiKeyService

package/src/setup/LoadIdentityConfigFromEnv.ts

@@ -2,12 +2,14 @@ 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

package/src/utils/AuthUtils.ts

@@ -2,6 +2,7 @@ import bcryptjs from "bcryptjs";
 import jsonwebtoken, {SignOptions, VerifyOptions} from "jsonwebtoken";
 import {DraxConfig} from "@drax/common-back";
 import IdentityConfig from "../config/IdentityConfig.js";
+import crypto from "crypto";
 
 class AuthUtils{
 
@@ -67,6 +68,16 @@ class AuthUtils{
 
         return token
     }
+
+    static generateHMAC(secret: string, apikey: string) {
+        // 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/src/zod/UserApiKeyZod.ts

@@ -0,0 +1,15 @@
+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}