@drax/identity-back 0.36.0 → 0.37.2

package/dist/repository/sqlite/UserSessionSqliteRepository.js

@@ -0,0 +1,31 @@
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class UserSessionSqliteRepository extends AbstractSqliteRepository {
+    constructor() {
+        super(...arguments);
+        this.tableName = 'user_sessions';
+        this.searchFields = [];
+        this.booleanFields = [];
+        this.identifier = '_id';
+        this.populateFields = [{ field: 'user', table: 'users', identifier: '_id' }];
+        this.tableFields = [
+            { name: "uuid", type: "TEXT", unique: false, primary: false },
+            { name: "user", type: "TEXT", unique: false, primary: false },
+            { name: "agent", type: "TEXT", unique: false, primary: false },
+            { name: "ip", type: "TEXT", unique: false, primary: false },
+            { name: "createdAt", type: "TEXT", unique: false, primary: false },
+            { name: "updatedAt", type: "TEXT", unique: false, primary: false },
+        ];
+    }
+    async prepareData(data) {
+        // Transform data before saving to database if needed
+    }
+    async prepareItem(item) {
+        if (item.createdAt && typeof item.createdAt === 'string') {
+            item.createdAt = new Date(item.createdAt);
+        }
+        if (item.updatedAt && typeof item.updatedAt === 'string') {
+            item.updatedAt = new Date(item.updatedAt);
+        }
+    }
+}
+export default UserSessionSqliteRepository;

package/dist/routes/UserLoginFailRoutes.js

@@ -0,0 +1,12 @@
+import UserLoginFailController from "../controllers/UserLoginFailController.js";
+import { CrudSchemaBuilder } from "@drax/crud-back";
+import { UserLoginFailSchema, UserLoginFailBaseSchema } from '../schemas/UserLoginFailSchema.js';
+async function UserLoginFailRoutes(fastify, options) {
+    const controller = new UserLoginFailController();
+    const schemas = new CrudSchemaBuilder(UserLoginFailSchema, UserLoginFailBaseSchema, UserLoginFailBaseSchema, 'UserLoginFail', 'openApi3', ['Identity']);
+    fastify.get('/api/user-login-fails', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.get('/api/user-login-fails/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
+    fastify.get('/api/user-login-fails/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));
+}
+export default UserLoginFailRoutes;
+export { UserLoginFailRoutes };

package/dist/routes/UserRoutes.js

@@ -10,6 +10,7 @@ async function UserRoutes(fastify, options) {
     const controller = new UserController();
     const schemas = new CrudSchemaBuilder(UserSchema, UserCreateSchema, UserUpdateSchema, 'tenant', 'openApi3', ['Identity']);
     fastify.get('/api/users/search', { schema: schemas.searchSchema }, async (req, rep) => await controller.search(req, rep));
+    fastify.get('/api/users/group-by', { schema: schemas.groupBySchema }, async (req, rep) => await controller.groupBy(req, rep));
     fastify.get('/api/users/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));
     fastify.get('/api/users', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
     fastify.post('/api/users', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));

package/dist/routes/UserSessionRoutes.js

@@ -0,0 +1,12 @@
+import UserSessionController from "../controllers/UserSessionController.js";
+import { CrudSchemaBuilder } from "@drax/crud-back";
+import { UserSessionSchema, UserSessionBaseSchema } from '../schemas/UserSessionSchema.js';
+async function UserSessionRoutes(fastify, options) {
+    const controller = new UserSessionController();
+    const schemas = new CrudSchemaBuilder(UserSessionSchema, UserSessionBaseSchema, UserSessionBaseSchema, 'UserSession', 'openApi3', ['Identity']);
+    fastify.get('/api/user-sessions', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.get('/api/user-sessions/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
+    fastify.get('/api/user-sessions/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));
+}
+export default UserSessionRoutes;
+export { UserSessionRoutes };

package/dist/schemas/RoleSchema.js

@@ -4,12 +4,16 @@ const RoleBaseSchema = object({
         .min(1, "validation.required")
         .regex(/^[A-Z]/, "validation.startWithUpperCase"),
     permissions: array(string()).optional(),
+    icon: string().optional(),
+    color: string().optional(),
     childRoles: array(string()).optional(),
 });
 const RoleSchema = RoleBaseSchema.extend({
     _id: string(),
     id: string().optional(),
     permissions: array(string()).optional(),
+    icon: string().optional(),
+    color: string().optional(),
     readonly: boolean(),
     childRoles: array(object({
         _id: string(),

package/dist/schemas/UserLoginFailSchema.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+const UserLoginFailBaseSchema = z.object({
+    username: z.string().min(1, 'validation.required'),
+    userAgent: z.string().optional(),
+    ip: z.string().optional(),
+});
+const UserLoginFailSchema = UserLoginFailBaseSchema
+    .extend({
+    _id: z.string(),
+    createdAt: z.coerce.date().nullable().optional()
+});
+export default UserLoginFailSchema;
+export { UserLoginFailSchema, UserLoginFailBaseSchema };

package/dist/schemas/UserSchema.js

@@ -26,6 +26,8 @@ const UserSchema = UserBaseSchema
         _id: string(),
         id: string().optional(),
         name: string(),
+        icon: string().optional(),
+        color: string().optional(),
         permissions: array(string()),
         childRoles: array(object({ _id: string(), name: string() })).optional()
     }).optional(),

package/dist/schemas/UserSessionSchema.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+const UserSessionBaseSchema = z.object({
+    uuid: z.string().min(1, 'validation.required'),
+    user: z.string().min(1, 'validation.required'),
+    userAgent: z.string().optional(),
+    ip: z.string().optional(),
+});
+const UserSessionSchema = UserSessionBaseSchema
+    .extend({
+    _id: z.string(),
+    user: z.object({ _id: z.string(), username: z.string() }),
+    createdAt: z.coerce.date().nullable().optional()
+});
+export default UserSessionSchema;
+export { UserSessionSchema, UserSessionBaseSchema };

package/dist/services/UserLoginFailService.js

@@ -0,0 +1,8 @@
+import { AbstractService } from "@drax/crud-back";
+class UserLoginFailService extends AbstractService {
+    constructor(UserLoginFailRepository, schema) {
+        super(UserLoginFailRepository, schema);
+    }
+}
+export default UserLoginFailService;
+export { UserLoginFailService };

package/dist/services/UserService.js

@@ -5,23 +5,38 @@ import { UserCreateSchema, UserUpdateSchema, UserBaseSchema } from "../schemas/U
 import BadCredentialsError from "../errors/BadCredentialsError.js";
 import { AbstractService } from "@drax/crud-back";
 import { randomUUID } from "crypto";
+import UserLoginFailServiceFactory from "../factory/UserLoginFailServiceFactory.js";
+import UserSessionServiceFactory from "../factory/UserSessionServiceFactory.js";
 class UserService extends AbstractService {
     constructor(userRepository) {
         super(userRepository, UserBaseSchema);
         this._repository = userRepository;
         console.log("UserService constructor");
     }
-    async auth(username, password) {
+    async auth(username, password, { userAgent, ip }) {
         let user = null;
         console.log("auth username", username);
         user = await this.findByUsernameWithPassword(username);
         if (user && user.active && AuthUtils.checkPassword(password, user.password)) {
             //TODO: Generar session
-            const session = randomUUID();
-            const accessToken = AuthUtils.generateToken(user._id.toString(), user.username, user.role._id, user.tenant?._id, session);
+            const sessionUUID = randomUUID();
+            const sessionService = UserSessionServiceFactory();
+            await sessionService.create({
+                user: user._id.toString(),
+                uuid: sessionUUID,
+                userAgent: userAgent,
+                ip: ip
+            });
+            const accessToken = AuthUtils.generateToken(user._id.toString(), user.username, user.role._id, user.tenant?._id, sessionUUID);
             return { accessToken: accessToken };
         }
         else {
+            const userLoginFailService = UserLoginFailServiceFactory();
+            await userLoginFailService.create({
+                username: username,
+                userAgent: userAgent,
+                ip: ip
+            });
             throw new BadCredentialsError();
         }
     }

package/dist/services/UserSessionService.js

@@ -0,0 +1,8 @@
+import { AbstractService } from "@drax/crud-back";
+class UserSessionService extends AbstractService {
+    constructor(UserSessionRepository, schema) {
+        super(UserSessionRepository, schema);
+    }
+}
+export default UserSessionService;
+export { UserSessionService };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.36.0",
+  "version": "0.37.2",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -28,11 +28,11 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^0.36.0",
-    "@drax/crud-back": "^0.36.0",
-    "@drax/crud-share": "^0.36.0",
-    "@drax/email-back": "^0.36.0",
-    "@drax/identity-share": "^0.36.0",
+    "@drax/common-back": "^0.37.2",
+    "@drax/crud-back": "^0.37.2",
+    "@drax/crud-share": "^0.37.0",
+    "@drax/email-back": "^0.37.0",
+    "@drax/identity-share": "^0.37.0",
     "bcryptjs": "^2.4.3",
     "graphql": "^16.8.2",
     "jsonwebtoken": "^9.0.2"
@@ -63,5 +63,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "096f17a9a7f6e6969b8367a978137e090916f16d"
+  "gitHead": "85833fa79a0d1df3899c13a3a47ed3e7e3fe0448"
 }

package/src/controllers/UserController.ts

@@ -31,14 +31,19 @@ class UserController extends AbstractFastifyController<IUser, IUserCreate, IUser
 
     constructor() {
         super(UserServiceFactory(), UserPermissions)
+        this.tenantField = "tenant";
+        this.tenantFilter = true;
     }
 
     async auth(request, reply) {
         try {
             const username = request.body.username
             const password = request.body.password
+            const userAgent = request.headers['user-agent'];
+            const ip = request.ip;
             const userService = UserServiceFactory()
-            return await userService.auth(username, password)
+
+            return await userService.auth(username, password,{userAgent, ip})
         } catch (e) {
             console.error('/api/auth error', e)
             if (e instanceof BadCredentialsError) {

package/src/controllers/UserLoginFailController.ts

@@ -0,0 +1,64 @@
+
+import UserLoginFailServiceFactory from "../factory/UserLoginFailServiceFactory.js";
+import {AbstractFastifyController} from "@drax/crud-back";
+import UserLoginFailPermissions from "../permissions/UserLoginFailPermissions.js";
+import type {IUserLoginFail, IUserLoginFailBase} from "@drax/identity-share";
+import type {FastifyReply, FastifyRequest} from "fastify";
+import {MethodNotAllowedError} from "@drax/common-back";
+
+class UserLoginFailController extends AbstractFastifyController<IUserLoginFail, IUserLoginFailBase, IUserLoginFailBase>   {
+
+    constructor() {
+        super(UserLoginFailServiceFactory(), UserLoginFailPermissions)
+        this.tenantField = "tenant";
+        this.userField = "user";
+        this.tenantFilter = false;
+        this.userFilter = true;
+        this.tenantSetter = false;
+        this.userSetter = true;
+        this.tenantAssert = false;
+        this.userAssert = true;
+    }
+
+    async create(request: FastifyRequest, reply: FastifyReply): Promise<IUserLoginFail> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async update(request: FastifyRequest, reply: FastifyReply): Promise<IUserLoginFail> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async updatePartial(request: FastifyRequest, reply: FastifyReply): Promise<IUserLoginFail> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async delete(request: FastifyRequest, reply: FastifyReply) {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+    }
+
+}
+
+export default UserLoginFailController;
+export {
+    UserLoginFailController
+}
+

package/src/controllers/UserSessionController.ts

@@ -0,0 +1,64 @@
+
+import UserSessionServiceFactory from "../factory/UserSessionServiceFactory.js";
+import {AbstractFastifyController} from "@drax/crud-back";
+import UserSessionPermissions from "../permissions/UserSessionPermissions.js";
+import type {IUserSession, IUserSessionBase} from "@drax/identity-share";
+import type {FastifyReply, FastifyRequest} from "fastify";
+import {MethodNotAllowedError} from "@drax/common-back";
+
+class UserSessionController extends AbstractFastifyController<IUserSession, IUserSessionBase, IUserSessionBase>   {
+
+    constructor() {
+        super(UserSessionServiceFactory(), UserSessionPermissions)
+        this.tenantField = "tenant";
+        this.userField = "user";
+        this.tenantFilter = false;
+        this.userFilter = true;
+        this.tenantSetter = false;
+        this.userSetter = true;
+        this.tenantAssert = false;
+        this.userAssert = true;
+    }
+
+    async create(request: FastifyRequest, reply: FastifyReply): Promise<IUserSession> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async update(request: FastifyRequest, reply: FastifyReply): Promise<IUserSession> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async updatePartial(request: FastifyRequest, reply: FastifyReply): Promise<IUserSession> {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+        return null;
+    }
+
+    async delete(request: FastifyRequest, reply: FastifyReply) {
+        try {
+            throw new MethodNotAllowedError()
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+    }
+
+}
+
+export default UserSessionController;
+export {
+    UserSessionController
+}
+

package/src/factory/UserLoginFailServiceFactory.ts

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

package/src/factory/UserSessionServiceFactory.ts

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

package/src/graphql/resolvers/role.resolvers.ts

@@ -1,5 +1,5 @@
 import RoleServiceFactory from "../../factory/RoleServiceFactory.js";
-import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
+import {RolePermissions} from "../../permissions/RolePermissions.js";
 import {ValidationError, ValidationErrorToGraphQLError, UnauthorizedError} from "@drax/common-back";
 import {GraphQLError} from "graphql";
 import {PermissionService} from "../../services/PermissionService.js";
@@ -10,7 +10,7 @@ export default {
     Query: {
         findRoleById: async (_, {id}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewRole)
+                rbac.assertPermission(RolePermissions.View)
                 const roleService = RoleServiceFactory()
                 return await roleService.findById(id)
             } catch (e) {
@@ -22,7 +22,7 @@ export default {
         },
         findRoleByName: async (_, {name}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewRole)
+                rbac.assertPermission(RolePermissions.View)
                 const roleService = RoleServiceFactory()
                 return await roleService.findByName(name)
             } catch (e) {
@@ -34,7 +34,7 @@ export default {
         },
         fetchRole: async (_, {}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewRole)
+                rbac.assertPermission(RolePermissions.View)
                 const roleService = RoleServiceFactory()
                 const roles = await roleService.fetchAll()
                 if(rbac.getRole?.childRoles?.length > 0) {
@@ -53,7 +53,7 @@ export default {
         },
         fetchPermissions: async (_, {}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.PermissionsRole)
+                rbac.assertPermission(RolePermissions.Permissions)
                 return PermissionService.getPermissions()
             } catch (e) {
                 if (e instanceof UnauthorizedError) {
@@ -64,7 +64,7 @@ export default {
         },
         paginateRole: async (_, {options= {page:1, limit:5, orderBy:"", order:"asc", search:"", filters: []} as IDraxPaginateOptions }, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewRole)
+                rbac.assertPermission(RolePermissions.View)
                 const roleService = RoleServiceFactory()
                 return await roleService.paginate(options)
             } catch (e) {
@@ -79,7 +79,7 @@ export default {
     Mutation: {
         createRole: async (_, {input}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.CreateRole)
+                rbac.assertPermission(RolePermissions.Create)
                 const roleService = RoleServiceFactory()
                 return await roleService.create(input)
             } catch (e) {
@@ -96,7 +96,7 @@ export default {
         },
         updateRole: async (_, {id, input}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.UpdateRole)
+                rbac.assertPermission(RolePermissions.Update)
                 const roleService = RoleServiceFactory()
                 const currentRole = await roleService.findById(id)
                 if(currentRole.readonly){
@@ -117,7 +117,7 @@ export default {
         },
         deleteRole: async (_, {id}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.DeleteRole)
+                rbac.assertPermission(RolePermissions.Delete)
                 const roleService = RoleServiceFactory()
                 const currentRole = await roleService.findById(id)
                 if(currentRole.readonly){

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

@@ -1,5 +1,5 @@
 import TenantServiceFactory from "../../factory/TenantServiceFactory.js";
-import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
+import {TenantPermissions} from "../../permissions/TenantPermissions.js";
 import {ValidationError, ValidationErrorToGraphQLError, UnauthorizedError} from "@drax/common-back";
 import {GraphQLError} from "graphql";
 import {IDraxPaginateOptions} from "@drax/crud-share";
@@ -9,7 +9,7 @@ export default {
     Query: {
         findTenantById: async (_, {id}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewTenant)
+                rbac.assertPermission(TenantPermissions.View)
                 const tenantService = TenantServiceFactory()
                 return await tenantService.findById(id)
             } catch (e) {
@@ -21,7 +21,7 @@ export default {
         },
         findTenantByName: async (_, {name}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewTenant)
+                rbac.assertPermission(TenantPermissions.View)
                 const tenantService = TenantServiceFactory()
                 return await tenantService.findByName(name)
             } catch (e) {
@@ -33,7 +33,7 @@ export default {
         },
         fetchTenant: async (_, {}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewTenant)
+                rbac.assertPermission(TenantPermissions.View)
                 const tenantService = TenantServiceFactory()
                 const tenants =  await tenantService.fetchAll()
                 if(rbac.getAuthUser.tenantId){
@@ -51,7 +51,7 @@ export default {
         },
         paginateTenant: async (_, {options= {page:1, limit:5, orderBy:"", order:"asc", search:"", filters: []} as IDraxPaginateOptions }, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewTenant)
+                rbac.assertPermission(TenantPermissions.View)
                 const tenantService = TenantServiceFactory()
                 return await tenantService.paginate(options)
             } catch (e) {
@@ -66,7 +66,7 @@ export default {
     Mutation: {
         createTenant: async (_, {input}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.CreateTenant)
+                rbac.assertPermission(TenantPermissions.Create)
                 const tenantService = TenantServiceFactory()
                 return await tenantService.create(input)
             } catch (e) {
@@ -83,7 +83,7 @@ export default {
         },
         updateTenant: async (_, {id, input}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.UpdateTenant)
+                rbac.assertPermission(TenantPermissions.Update)
                 const tenantService = TenantServiceFactory()
                 return await tenantService.update(id, input)
             } catch (e) {
@@ -99,7 +99,7 @@ export default {
         },
         deleteTenant: async (_, {id}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.DeleteTenant)
+                rbac.assertPermission(TenantPermissions.Delete)
                 const tenantService = TenantServiceFactory()
                 return await tenantService.delete(id)
             } catch (e) {

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

@@ -1,5 +1,5 @@
 import UserApiKeyServiceFactory from "../../factory/UserApiKeyServiceFactory.js";
-import {IdentityPermissions} from "../../permissions/IdentityPermissions.js";
+import {UserApiKeyPermissions} from "../../permissions/UserApiKeyPermissions.js";
 import {ValidationError, ValidationErrorToGraphQLError, UnauthorizedError} from "@drax/common-back";
 import {GraphQLError} from "graphql";
 import * as crypto from "node:crypto";
@@ -14,15 +14,15 @@ export default {
 
 
                 rbac.assertOrPermissions([
-                    IdentityPermissions.ViewUserApiKey,
-                    IdentityPermissions.ViewMyUserApiKey
+                    UserApiKeyPermissions.View,
+                    UserApiKeyPermissions.ViewMy
                 ])
 
                 if(!Array.isArray(options.filters)){
                     options.filters = []
                 }
 
-                if(!rbac.hasPermission(IdentityPermissions.ViewUserApiKey)){
+                if(!rbac.hasPermission(UserApiKeyPermissions.View)){
                     options.filters.push({field: "user", operator: "eq", value: rbac.userId})
                 }
 
@@ -40,7 +40,7 @@ export default {
     Mutation: {
         createUserApiKey: async (_, {input}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.CreateUserApiKey)
+                rbac.assertPermission(UserApiKeyPermissions.Create)
                 input.user = rbac.authUser.id
                 input.secret = crypto.randomUUID()
                 const userApiKeyService = UserApiKeyServiceFactory(true)
@@ -59,7 +59,7 @@ export default {
         },
         updateUserApiKey: async (_, {id, input}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.UpdateUserApiKey)
+                rbac.assertPermission(UserApiKeyPermissions.Update)
                 const userApiKeyService = UserApiKeyServiceFactory()
                 return await userApiKeyService.update(id, input)
             } catch (e) {
@@ -75,7 +75,7 @@ export default {
         },
         deleteUserApiKey: async (_, {id}, {rbac}) => {
             try {
-                rbac.assertPermission(IdentityPermissions.DeleteUserApiKey)
+                rbac.assertPermission(UserApiKeyPermissions.Delete)
                 const userApiKeyService = UserApiKeyServiceFactory()
                 return await userApiKeyService.delete(id)
             } catch (e) {

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

@@ -71,7 +71,9 @@ export default {
         auth: async (_, {input}) => {
             try {
                 let userService = UserServiceFactory()
-                return await userService.auth(input.username, input.password)
+                const userAgent = ''
+                const ip = ''
+                return await userService.auth(input.username, input.password,{userAgent, ip})
             } catch (e) {
                 console.error("auth", e)
                 if (e instanceof BadCredentialsError) {