@drax/identity-back 0.0.31 → 0.1.0

package/src/factory/UserApiKeyServiceFactory.ts

@@ -0,0 +1,30 @@
+import UserApiKeyMongoRepository from "../repository/mongo/UserApiKeyMongoRepository.js";
+import UserApiKeyService from "../services/UserApiKeyService.js";
+import UserApiKeySqliteRepository from "../repository/sqlite/UserApiKeySqliteRepository.js";
+import {IUserApiKeyRepository} from "../interfaces/IUserApiKeyRepository";
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back";
+
+let userService: UserApiKeyService
+
+const UserApiKeyServiceFactory = (verbose: boolean = false): UserApiKeyService => {
+    if (!userService) {
+        let userRepository: IUserApiKeyRepository
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
+                userRepository = new UserApiKeyMongoRepository()
+                break;
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                userRepository = new UserApiKeySqliteRepository(dbFile, verbose)
+                break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+        }
+
+        userService = new UserApiKeyService(userRepository)
+    }
+
+    return userService
+}
+
+export default UserApiKeyServiceFactory

package/src/factory/UserServiceFactory.ts

@@ -1,23 +1,24 @@
 import UserMongoRepository from "../repository/mongo/UserMongoRepository.js";
 import UserService from "../services/UserService.js";
 import UserSqliteRepository from "../repository/sqlite/UserSqliteRepository.js";
-import {DbEngine, DbSetupUtils} from "../utils/DbSetupUtils.js";
 import {IUserRepository} from "../interfaces/IUserRepository";
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back";
 
 let userService: UserService
 
 const UserServiceFactory = (verbose:boolean = false) : UserService => {
     if(!userService){
         let userRepository: IUserRepository
-        switch (DbSetupUtils.getDbEngine()) {
-            case DbEngine.Mongo:
-                console.log("UserServiceFactory DB ENGINE MONGODB")
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
                 userRepository = new UserMongoRepository()
                 break;
-            case DbEngine.Sqlite:
-                console.log("UserServiceFactory DB ENGINE SQLITE")
-                userRepository = new UserSqliteRepository(DbSetupUtils.getDbConfig(),verbose)
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                userRepository = new UserSqliteRepository(dbFile,verbose)
                 break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
         }
 
         userService = new UserService(userRepository)

package/src/graphql/resolvers/tenant.resolvers.ts

@@ -2,7 +2,6 @@ import TenantServiceFactory from "../../factory/TenantServiceFactory.js";
 import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
 import {ValidationError, ValidationErrorToGraphQLError} from "@drax/common-back";
 import {GraphQLError} from "graphql";
-import {PermissionService} from "../../services/PermissionService.js";
 import UnauthorizedError from "../../errors/UnauthorizedError.js";
 
 

package/src/graphql/resolvers/user-api-key.resolvers.ts

@@ -0,0 +1,94 @@
+import UserApiKeyServiceFactory from "../../factory/UserApiKeyServiceFactory.js";
+import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
+import {ValidationError, ValidationErrorToGraphQLError} from "@drax/common-back";
+import {GraphQLError} from "graphql";
+import UnauthorizedError from "../../errors/UnauthorizedError.js";
+import * as crypto from "node:crypto";
+
+
+export default {
+    Query: {
+        paginateUserApiKey: async (_, {options= {page:1, limit:5, orderBy:"", orderDesc:false, search:"", filters: []} }, {rbac, authUser}) => {
+            try {
+                rbac.assertAuthenticated()
+
+
+                rbac.assertOrPermissions([
+                    IdentityPermissions.ViewUserApiKey,
+                    IdentityPermissions.ViewMyUserApiKey
+                ])
+
+                if(!Array.isArray(options.filters)){
+                    options.filters = []
+                }
+
+                if(!rbac.hasPermission(IdentityPermissions.ViewUserApiKey)){
+                    options.filters.push({field: "user", operator: "eq", value: rbac.authUser.id})
+                }
+
+                const userApiKeyService = UserApiKeyServiceFactory()
+                return await userApiKeyService.paginate(options)
+            } catch (e) {
+                console.error("paginateUserApiKey",e)
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+        }
+    },
+    Mutation: {
+        createUserApiKey: async (_, {input}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.CreateUserApiKey)
+                input.user = rbac.authUser.id
+                input.secret = crypto.randomUUID()
+                const userApiKeyService = UserApiKeyServiceFactory(true)
+                return await userApiKeyService.create(input)
+            } catch (e) {
+                console.error("createUserApiKey",e)
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+
+        },
+        updateUserApiKey: async (_, {id, input}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.UpdateUserApiKey)
+                const userApiKeyService = UserApiKeyServiceFactory()
+                return await userApiKeyService.update(id, input)
+            } catch (e) {
+                console.error("updateUserApiKey",e)
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+        },
+        deleteUserApiKey: async (_, {id}, {rbac}) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.DeleteUserApiKey)
+                const userApiKeyService = UserApiKeyServiceFactory()
+                return await userApiKeyService.delete(id)
+            } catch (e) {
+                console.error("deleteUserApiKey",e)
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e)
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message)
+                }
+                throw new GraphQLError('error.server')
+            }
+
+        }
+    }
+}

package/src/graphql/resolvers/user.resolvers.ts

@@ -20,7 +20,7 @@ export default {
                 if (authUser) {
                     let userService = UserServiceFactory()
                     let user = await userService.findById(authUser.id)
-                    delete user.password
+                    user.password = undefined
                     return user
                 }
                 throw new UnauthorizedError()
@@ -34,7 +34,9 @@ export default {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewUser)
                 let userService = UserServiceFactory()
-                return await userService.findById(id)
+                let user =  await userService.findById(id)
+                user.password = undefined
+                return user
             } catch (e) {
                 if (e instanceof UnauthorizedError) {
                     throw new GraphQLError(e.message)
@@ -47,6 +49,11 @@ export default {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewUser)
                 let userService = UserServiceFactory()
+
+                if(!options.filters){
+                    options.filters = []
+                }
+
                 if (rbac.getAuthUser.tenantId) {
                     options.filters.push({field: 'tenant', operator: '$eq', value: rbac.getAuthUser.tenantId})
                 }

package/src/graphql/types/userApiKey.graphql

@@ -0,0 +1,33 @@
+type UserApiKey {
+    id: ID!
+    name: String
+    secret: String
+    ipv4: [String]
+    ipv6: [String]
+    user: User
+    createdAt: Date
+    updatedAt: Date
+}
+
+type UserApiKeyPaginated{
+    total: Int
+    page: Int
+    limit: Int
+    items: [UserApiKey]
+}
+
+type Query{
+    paginateUserApiKey(options: PaginateOptions): UserApiKeyPaginated
+}
+
+input UserApiKeyInput{
+    name: String
+    ipv4: [String]
+    ipv6: [String]
+}
+
+type Mutation{
+    createUserApiKey(input: UserApiKeyInput): UserApiKey
+    updateUserApiKey(id: ID!, input: UserApiKeyInput): UserApiKey
+    deleteUserApiKey(id: ID!): Boolean
+}

package/src/index.ts

@@ -2,18 +2,24 @@ import GraphqlMerge from "./graphql/index.js"
 import UserServiceFactory from "./factory/UserServiceFactory.js";
 import RoleServiceFactory from "./factory/RoleServiceFactory.js";
 import TenantServiceFactory from "./factory/TenantServiceFactory.js";
+
 import RoleService from "./services/RoleService.js";
 import UserService from "./services/UserService.js";
 import TenantService from "./services/TenantService.js";
 import PermissionService from "./services/PermissionService.js";
+
 import Rbac from "./rbac/Rbac.js";
+
 import {UserRoutes} from "./routes/UserRoutes.js";
 import {UserAvatarRoutes} from "./routes/UserAvatarRoutes.js";
 import {RoleRoutes} from "./routes/RoleRoutes.js";
 import {TenantRoutes} from "./routes/TenantRoutes.js";
+import {UserApiKeyRoutes} from "./routes/UserApiKeyRoutes.js";
+
 import AuthUtils from "./utils/AuthUtils.js";
 import {jwtMiddleware} from "./middleware/jwtMiddleware.js";
 import {rbacMiddleware} from "./middleware/rbacMiddleware.js";
+import {apiKeyMiddleware} from "./middleware/apiKeyMiddleware.js";
 
 import IdentityPermissions from "./permissions/IdentityPermissions.js";
 import IdentityConfig from "./config/IdentityConfig.js";
@@ -29,6 +35,7 @@ import RecoveryUserPassword from "./setup/RecoveryUserPassword.js";
 import type {IRoleRepository} from "./interfaces/IRoleRepository";
 import type {ITenantRepository} from "./interfaces/ITenantRepository";
 import type {IUserRepository} from "./interfaces/IUserRepository";
+import type {IUserApiKeyRepository} from "./interfaces/IUserApiKeyRepository";
 
 
 const graphqlMergeResult = await GraphqlMerge()
@@ -40,6 +47,7 @@ export type {
     IRoleRepository,
     ITenantRepository,
     IUserRepository,
+    IUserApiKeyRepository
 }
 
 export {
@@ -64,12 +72,14 @@ export {
     RoleRoutes,
     TenantRoutes,
     UserAvatarRoutes,
+    UserApiKeyRoutes,
 
     AuthUtils,
 
     //API MIDDLEWARE
     jwtMiddleware,
     rbacMiddleware,
+    apiKeyMiddleware,
 
     //Permissions
     IdentityPermissions,

package/src/interfaces/IUserApiKeyRepository.ts

@@ -0,0 +1,8 @@
+import {IUserApiKey, IUserApiKeyBase} from '@drax/identity-share'
+import {IDraxCrud} from "@drax/common-share";
+
+interface IUserApiKeyRepository extends IDraxCrud<IUserApiKey, IUserApiKeyBase, IUserApiKeyBase>{
+    findBySecret(username: string): Promise<IUserApiKey | null>;
+}
+
+export {IUserApiKeyRepository}

package/src/middleware/apiKeyMiddleware.ts

@@ -0,0 +1,35 @@
+import {IUserApiKey} from "@drax/identity-share";
+import {DraxCache, DraxConfig} from "@drax/common-back";
+import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
+import IdentityConfig from "../config/IdentityConfig.js";
+
+const cacheTTL = DraxConfig.getOrLoad(IdentityConfig.ApiKeyCacheTTL) ? parseInt(DraxConfig.getOrLoad(IdentityConfig.ApiKeyCacheTTL)) : 10000;
+const draxCache = new DraxCache<IUserApiKey>(cacheTTL);
+
+
+async function userApiKeyLoader(k):Promise<IUserApiKey | null> {
+    const userApiKeyService = UserApiKeyServiceFactory()
+    const userApiKey: IUserApiKey = await userApiKeyService.findBySecret(k)
+    return userApiKey
+}
+
+async function apiKeyMiddleware (request, reply) {
+        try{
+            const apiKey = request.headers['x-api-key']
+            if(apiKey){
+                const userApiKey = await draxCache.getOrLoad(apiKey, userApiKeyLoader)
+                if(userApiKey && userApiKey.user){
+                    request.authUser = userApiKey.user
+                    request.authUser.roleId = userApiKey.user.role.id
+                    request.authUser.tenantId = userApiKey.user.tenant.id
+                }
+            }
+            return
+        }catch (e) {
+            console.error(e)
+            reply.code(500).send({ error: 'APIKEY ERROR' });
+        }
+}
+
+export default apiKeyMiddleware;
+export {apiKeyMiddleware}

package/src/middleware/rbacMiddleware.ts

@@ -16,10 +16,9 @@ async function roleLoader(k):Promise<IRole | null> {
 
 async function rbacMiddleware (request, reply) {
         try{
-            //console.log("rbacMiddleware authUser",request.authUser)
             if(request.authUser as IJwtUser){
                 const authUser = request.authUser
-                const cacheKey= authUser.roleId
+                const cacheKey = authUser.roleId
                 const role = await draxCache.getOrLoad(cacheKey, roleLoader)
                 const rbac = new Rbac(authUser,role)
                 request.rbac = rbac

package/src/models/UserApiKeyModel.ts

@@ -0,0 +1,59 @@
+import {mongoose, MongooseSoftDelete} from '@drax/common-back';
+import {IUserApiKey} from "@drax/identity-share";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import {PaginateModel} from "mongoose";
+
+// Defining user Mongoose Schema
+const UserApiKeySchema = new mongoose.Schema<IUserApiKey>({
+    name: {
+        type: String,
+        unique: false,
+        required: true,
+        index: false,
+    },
+    secret: {
+        type: String,
+        unique: false,
+        required: true,
+        index: true,
+    },
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+    },
+    ipv4: [{
+        type: String,
+        unique: false,
+        required: false,
+        index: false,
+    }],
+    ipv6: [{
+        type: String,
+        unique: false,
+        required: false,
+        index: false,
+    }],
+}, {timestamps: true});
+
+UserApiKeySchema.set('toJSON', {getters: true});
+
+UserApiKeySchema.plugin(uniqueValidator, {message: 'validation.unique'});
+
+UserApiKeySchema.plugin(MongooseSoftDelete);
+UserApiKeySchema.plugin(mongoosePaginate);
+
+const MODEL_NAME = 'UserApiKey';
+const COLLECTION_NAME = 'userApiKeys';
+
+const UserApiKeyModel = mongoose.model<IUserApiKey,PaginateModel<IUserApiKey>>(MODEL_NAME, UserApiKeySchema,COLLECTION_NAME);
+
+
+export {
+    UserApiKeySchema,
+    UserApiKeyModel
+}
+
+export default UserApiKeyModel
+

package/src/permissions/IdentityPermissions.ts

@@ -7,6 +7,13 @@ enum IdentityPermissions {
     ViewUser = "user:view",
     ManageUser = "user:manage",
 
+    CreateUserApiKey = "userApiKey:create",
+    UpdateUserApiKey = "userApiKey:update",
+    DeleteUserApiKey = "userApiKey:delete",
+    ViewUserApiKey = "userApiKey:view",
+    ViewMyUserApiKey = "userApiKey:myView",
+    ManageUserApiKey = "userApiKey:manage",
+
     CreateRole = "role:create",
     UpdateRole = "role:update",
     DeleteRole = "role:delete",

package/src/rbac/Rbac.ts

@@ -1,7 +1,7 @@
 import {IJwtUser, IRole} from "@drax/identity-share";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
 
-class Rbac{
+class Rbac {
     private role: IRole;
     private authUser: IJwtUser;
 
@@ -27,11 +27,22 @@ class Rbac{
     }
 
     assertPermission(requiredPermission: string) {
-        if(!this.hasPermission(requiredPermission)){
+        if (!this.hasPermission(requiredPermission)) {
             throw new UnauthorizedError()
         }
     }
 
+    assertOrPermissions(requiredPermissions: string[]) {
+
+        for(let requiredPermission of requiredPermissions){
+            if (this.hasPermission(requiredPermission)) {
+                return true
+            }
+        }
+
+        throw new UnauthorizedError()
+    }
+
     assertAuthenticated() {
         if (!this.authUser) {
             throw new UnauthorizedError()

package/src/repository/mongo/UserApiKeyMongoRepository.ts

@@ -0,0 +1,114 @@
+import {UserApiKeyModel} from "../../models/UserApiKeyModel.js";
+import {
+    mongoose,
+    MongooseErrorToValidationError,
+    MongoServerErrorToValidationError,
+    ValidationError
+} from "@drax/common-back"
+import type {IUserApiKey, IUserApiKeyBase, IUserApiKeySoftDelete} from "@drax/identity-share";
+import {DeleteResult, MongoServerError} from "mongodb";
+import {PaginateResult} from "mongoose";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IUserApiKeyRepository} from "../../interfaces/IUserApiKeyRepository";
+
+class UserMongoRepository implements IUserApiKeyRepository {
+
+
+    constructor() {
+    }
+
+    async create(data: IUserApiKeyBase): Promise<IUserApiKey> {
+        try {
+
+            const userApiKey: mongoose.HydratedDocument<IUserApiKey> = new UserApiKeyModel(data)
+            await userApiKey.save()
+            await userApiKey.populate({path: 'user', populate: {path: 'tenant role'} })
+            return userApiKey
+        } catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e)
+            }
+            throw e
+        }
+
+    }
+
+    async update(id: string, data: IUserApiKeyBase): Promise<IUserApiKey> {
+        try {
+            delete data.secret
+            const userApiKey: mongoose.HydratedDocument<IUserApiKey> = await UserApiKeyModel.findOneAndUpdate({_id: id}, data, {new: true}).populate({path: 'user', populate: {path: 'tenant role'} }).exec()
+            return userApiKey
+        } catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e)
+            }
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
+                throw MongoServerErrorToValidationError(e)
+            }
+            throw e
+        }
+    }
+
+    async delete(id: string): Promise<boolean> {
+        const userApiKey: mongoose.HydratedDocument<IUserApiKeySoftDelete> = await UserApiKeyModel.findById(id)
+        userApiKey.softDelete()
+        return true
+    }
+
+    async findById(id: string): Promise<IUserApiKey> {
+        const userApiKey: mongoose.HydratedDocument<IUserApiKey> = await UserApiKeyModel.findById(id).populate({path: 'user', populate: {path: 'tenant role'} }).exec()
+        return userApiKey
+    }
+
+    async findBySecret(secret: string): Promise<IUserApiKey> {
+        const userApiKey: mongoose.HydratedDocument<IUserApiKey> = await UserApiKeyModel.findOne({secret: secret}).populate({path: 'user', populate: {path: 'tenant role'}}).exec()
+        return userApiKey
+    }
+
+    async paginate({
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       orderDesc = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
+
+        const query = {
+            deleted: false
+        }
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        if(filters){
+            for(const filter of filters){
+                if(['eq','$eq'].includes(filter.operator)){
+                    query[filter.field] = {$eq: filter.value}
+                }
+                if(['ne','$ne'].includes(filter.operator)){
+                    query[filter.field] = {$ne: filter.value}
+                }
+                if(['in','$in'].includes(filter.operator)){
+                    query[filter.field] = {$in: filter.value}
+                }
+            }
+        }
+
+        const options = {populate: ['user', 'user.tenant', 'user.role'], page: page, limit: limit}
+
+        const userApiKeyPaginated: PaginateResult<IUserApiKey> = await UserApiKeyModel.paginate(query, options)
+        return {
+            page: page,
+            limit: limit,
+            total: userApiKeyPaginated.totalDocs,
+            items: userApiKeyPaginated.docs
+        }
+    }
+
+}
+
+export default UserMongoRepository

package/src/repository/mongo/UserMongoRepository.ts

@@ -86,13 +86,13 @@ class UserMongoRepository implements IUserRepository {
 
         if(filters){
             for(const filter of filters){
-                if(filter.operator === '$eq'){
+                if(['eq','$eq'].includes(filter.operator)){
                     query[filter.field] = {$eq: filter.value}
                 }
-                if(filter.operator === '$ne'){
+                if(['ne','$ne'].includes(filter.operator)){
                     query[filter.field] = {$ne: filter.value}
                 }
-                if(filter.operator === '$in'){
+                if(['in','$in'].includes(filter.operator)){
                     query[filter.field] = {$in: filter.value}
                 }
             }

package/src/repository/sqlite/RoleSqliteRepository.ts

@@ -4,31 +4,36 @@ import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
 import {IRole, IRoleBase} from "@drax/identity-share";
-import {SqliteErrorToValidationError} from "@drax/common-back";
-
-const roleTableSQL: string = `
-    CREATE TABLE IF NOT EXISTS roles
-    (
-        id TEXT PRIMARY KEY,
-        name TEXT,
-        permissions TEXT,
-        readonly INTEGER,
-        childRoles TEXT
-        
-    );
-`;
+import {SqliteErrorToValidationError, SqliteTableBuilder, SqliteTableField} from "@drax/common-back";
+
+const tableFields: SqliteTableField[] = [
+    {name: "name", type: "TEXT", unique: true, primary: false},
+    {name: "permissions", type: "TEXT", unique: false, primary: false},
+    {name: "childRoles", type: "TEXT", unique: false, primary: false},
+    {name: "readonly", type: "INTEGER", unique: false, primary: false},
+    {name: "createdAt", type: "TEXT", unique: false, primary: false},
+    {name: "updatedAt", type: "TEXT", unique: false, primary: false},
+]
+
 
 class RoleSqliteRepository implements IRoleRepository{
 
     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(dataBaseFile, {verbose: verbose ? console.log : null});
         this.table()
     }
 
     table() {
-        this.db.exec(roleTableSQL);
+        const builder = new SqliteTableBuilder(
+            this.dataBaseFile,
+            'roles',
+            tableFields,
+            false);
+        builder.build('id')
     }
 
     normalizeData(roleData: IRoleBase){
@@ -52,7 +57,7 @@ class RoleSqliteRepository implements IRoleRepository{
             }
 
             this.normalizeData(roleData)
-
+            roleData.createdAt = (new Date().toISOString())
 
             const fields = Object.keys(roleData)
                 .map(field => `${field}`)
@@ -62,9 +67,6 @@ class RoleSqliteRepository implements IRoleRepository{
                 .map(field => `@${field}`)
                 .join(', ');
 
-           /* console.log("fields", fields)
-            console.log("values",values)
-            console.log("userData",roleData)*/
 
         const stmt = this.db.prepare(`INSERT INTO roles (${fields}) VALUES (${values})`);
         stmt.run(roleData)
@@ -80,12 +82,18 @@ class RoleSqliteRepository implements IRoleRepository{
     async update(id: string, roleData: IRoleBase): Promise<IRole> {
         try{
             this.normalizeData(roleData)
+            roleData.updatedAt = (new Date().toISOString())
+
             const setClauses = Object.keys(roleData)
                 .map(field => `${field} = @${field}`)
                 .join(', ');
+
             roleData.id = id
+
             const stmt = this.db.prepare( `UPDATE roles SET ${setClauses} WHERE id = @id `);
+
             stmt.run(roleData);
+
             return this.findById(id)
         }catch (e){
             console.log(e)