@drax/identity-back 0.36.0 → 0.37.0

package/dist/controllers/UserController.js

@@ -15,13 +15,17 @@ const BASE_URL = DraxConfig.getOrLoad(CommonConfig.BaseUrl) ? DraxConfig.get(Com
 class UserController extends AbstractFastifyController {
     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);

package/dist/controllers/UserLoginFailController.js

@@ -0,0 +1,54 @@
+import UserLoginFailServiceFactory from "../factory/UserLoginFailServiceFactory.js";
+import { AbstractFastifyController } from "@drax/crud-back";
+import UserLoginFailPermissions from "../permissions/UserLoginFailPermissions.js";
+import { MethodNotAllowedError } from "@drax/common-back";
+class UserLoginFailController extends AbstractFastifyController {
+    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, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async update(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async updatePartial(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async delete(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+    }
+}
+export default UserLoginFailController;
+export { UserLoginFailController };

package/dist/controllers/UserSessionController.js

@@ -0,0 +1,54 @@
+import UserSessionServiceFactory from "../factory/UserSessionServiceFactory.js";
+import { AbstractFastifyController } from "@drax/crud-back";
+import UserSessionPermissions from "../permissions/UserSessionPermissions.js";
+import { MethodNotAllowedError } from "@drax/common-back";
+class UserSessionController extends AbstractFastifyController {
+    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, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async update(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async updatePartial(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+        return null;
+    }
+    async delete(request, reply) {
+        try {
+            throw new MethodNotAllowedError();
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+    }
+}
+export default UserSessionController;
+export { UserSessionController };

package/dist/factory/UserLoginFailServiceFactory.js

@@ -0,0 +1,25 @@
+import UserLoginFailMongoRepository from "../repository/mongo/UserLoginFailMongoRepository.js";
+import UserLoginFailService from "../services/UserLoginFailService.js";
+import UserLoginFailSqliteRepository from "../repository/sqlite/UserLoginFailSqliteRepository.js";
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
+let userService;
+const UserLoginFailServiceFactory = (verbose = false) => {
+    if (!userService) {
+        let userRepository;
+        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/dist/factory/UserSessionServiceFactory.js

@@ -0,0 +1,25 @@
+import UserSessionMongoRepository from "../repository/mongo/UserSessionMongoRepository.js";
+import UserSessionService from "../services/UserSessionService.js";
+import UserSessionSqliteRepository from "../repository/sqlite/UserSessionSqliteRepository.js";
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
+let userService;
+const UserSessionServiceFactory = (verbose = false) => {
+    if (!userService) {
+        let userRepository;
+        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/dist/factory/services/UserLoginFailServiceFactory.js

@@ -0,0 +1,15 @@
+import UserLoginFailRepository from '../../repository/mongo/UserLoginFailMongoRepository';
+import { UserLoginFailService } from '../../services/UserLoginFailService.js';
+import { UserLoginFailBaseSchema } from "../../schemas/UserLoginFailSchema.js";
+class UserLoginFailServiceFactory {
+    static get instance() {
+        if (!UserLoginFailServiceFactory.service) {
+            const repository = new UserLoginFailRepository();
+            const schema = UserLoginFailBaseSchema;
+            UserLoginFailServiceFactory.service = new UserLoginFailService(repository, schema);
+        }
+        return UserLoginFailServiceFactory.service;
+    }
+}
+export default UserLoginFailServiceFactory;
+export { UserLoginFailServiceFactory };

package/dist/factory/services/UserSessionServiceFactory.js

@@ -0,0 +1,15 @@
+import UserSessionRepository from '../../repository/mongo/UserSessionMongoRepository';
+import { UserSessionService } from '../../services/UserSessionService.js';
+import { UserSessionBaseSchema } from "../../schemas/UserSessionSchema.js";
+class UserSessionServiceFactory {
+    static get instance() {
+        if (!UserSessionServiceFactory.service) {
+            const repository = new UserSessionRepository();
+            const schema = UserSessionBaseSchema;
+            UserSessionServiceFactory.service = new UserSessionService(repository, schema);
+        }
+        return UserSessionServiceFactory.service;
+    }
+}
+export default UserSessionServiceFactory;
+export { UserSessionServiceFactory };

package/dist/graphql/resolvers/role.resolvers.js

@@ -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";
@@ -7,7 +7,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);
             }
@@ -20,7 +20,7 @@ export default {
         },
         findRoleByName: async (_, { name }, { rbac }) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewRole);
+                rbac.assertPermission(RolePermissions.View);
                 const roleService = RoleServiceFactory();
                 return await roleService.findByName(name);
             }
@@ -33,7 +33,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) {
@@ -65,7 +65,7 @@ export default {
         },
         paginateRole: async (_, { options = { page: 1, limit: 5, orderBy: "", order: "asc", search: "", filters: [] } }, { rbac }) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewRole);
+                rbac.assertPermission(RolePermissions.View);
                 const roleService = RoleServiceFactory();
                 return await roleService.paginate(options);
             }
@@ -81,7 +81,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);
             }
@@ -98,7 +98,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) {
@@ -119,7 +119,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/dist/graphql/resolvers/tenant.resolvers.js

@@ -1,12 +1,12 @@
 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";
 export default {
     Query: {
         findTenantById: async (_, { id }, { rbac }) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewTenant);
+                rbac.assertPermission(TenantPermissions.View);
                 const tenantService = TenantServiceFactory();
                 return await tenantService.findById(id);
             }
@@ -19,7 +19,7 @@ export default {
         },
         findTenantByName: async (_, { name }, { rbac }) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewTenant);
+                rbac.assertPermission(TenantPermissions.View);
                 const tenantService = TenantServiceFactory();
                 return await tenantService.findByName(name);
             }
@@ -32,7 +32,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: [] } }, { rbac }) => {
             try {
-                rbac.assertPermission(IdentityPermissions.ViewTenant);
+                rbac.assertPermission(TenantPermissions.View);
                 const tenantService = TenantServiceFactory();
                 return await tenantService.paginate(options);
             }
@@ -67,7 +67,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);
             }
@@ -84,7 +84,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);
             }
@@ -101,7 +101,7 @@ export default {
         },
         deleteTenant: async (_, { id }, { rbac }) => {
             try {
-                rbac.assertPermission(IdentityPermissions.DeleteTenant);
+                rbac.assertPermission(TenantPermissions.Delete);
                 const tenantService = TenantServiceFactory();
                 return await tenantService.delete(id);
             }

package/dist/graphql/resolvers/user-api-key.resolvers.js

@@ -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";
@@ -9,13 +9,13 @@ export default {
             try {
                 rbac.assertAuthenticated();
                 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 });
                 }
                 const userApiKeyService = UserApiKeyServiceFactory();
@@ -33,7 +33,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);
@@ -52,7 +52,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);
             }
@@ -69,7 +69,7 @@ export default {
         },
         deleteUserApiKey: async (_, { id }, { rbac }) => {
             try {
-                rbac.assertPermission(IdentityPermissions.DeleteUserApiKey);
+                rbac.assertPermission(UserApiKeyPermissions.Delete);
                 const userApiKeyService = UserApiKeyServiceFactory();
                 return await userApiKeyService.delete(id);
             }

package/dist/graphql/resolvers/user.resolvers.js

@@ -62,7 +62,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);

package/dist/index.js

@@ -11,6 +11,8 @@ import { UserRoutes } from "./routes/UserRoutes.js";
 import { RoleRoutes } from "./routes/RoleRoutes.js";
 import { TenantRoutes } from "./routes/TenantRoutes.js";
 import { UserApiKeyRoutes } from "./routes/UserApiKeyRoutes.js";
+import { UserSessionRoutes } from "./routes/UserSessionRoutes.js";
+import { UserLoginFailRoutes } from "./routes/UserLoginFailRoutes.js";
 import AuthUtils from "./utils/AuthUtils.js";
 import { jwtMiddleware } from "./middleware/jwtMiddleware.js";
 import { rbacMiddleware } from "./middleware/rbacMiddleware.js";
@@ -22,11 +24,12 @@ import CreateOrUpdateRole from "./setup/CreateOrUpdateRole.js";
 import LoadPermissions from "./setup/LoadPermissions.js";
 import LoadIdentityConfigFromEnv from "./setup/LoadIdentityConfigFromEnv.js";
 import RecoveryUserPassword from "./setup/RecoveryUserPassword.js";
-import IdentityPermissions from "./permissions/IdentityPermissions.js";
 import { RolePermissions } from "./permissions/RolePermissions.js";
 import { TenantPermissions } from "./permissions/TenantPermissions.js";
 import { UserPermissions } from "./permissions/UserPermissions.js";
 import { UserApiKeyPermissions } from "./permissions/UserApiKeyPermissions.js";
+import { UserLoginFailPermissions } from "./permissions/UserLoginFailPermissions.js";
+import { UserSessionPermissions } from "./permissions/UserSessionPermissions.js";
 import { UserSchema, UserBaseSchema } from "./schemas/UserSchema.js";
 import { TenantSchema, TenantBaseSchema } from "./schemas/TenantSchema.js";
 import { RoleSchema, RoleBaseSchema } from "./schemas/RoleSchema.js";
@@ -44,11 +47,11 @@ UserServiceFactory, RoleServiceFactory, TenantServiceFactory,
 //GQL
 identityTypeDefs, identityResolvers, 
 //API REST
-UserRoutes, RoleRoutes, TenantRoutes, UserApiKeyRoutes, AuthUtils, 
+UserRoutes, RoleRoutes, TenantRoutes, UserApiKeyRoutes, UserSessionRoutes, UserLoginFailRoutes, AuthUtils, 
 //API MIDDLEWARE
 jwtMiddleware, rbacMiddleware, apiKeyMiddleware, 
 //Permissions
-IdentityPermissions, RolePermissions, TenantPermissions, UserPermissions, UserApiKeyPermissions, 
+RolePermissions, TenantPermissions, UserPermissions, UserApiKeyPermissions, UserSessionPermissions, UserLoginFailPermissions, 
 //Config
 IdentityConfig, 
 //Errors

package/dist/interfaces/IUserLoginFail.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IUserLoginFailRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IUserSession.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IUserSessionRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/models/RoleModel.js

@@ -7,6 +7,8 @@ const RoleMongoSchema = new Schema({
         type: String, unique: true, required: true, index: true,
     },
     permissions: [{ type: String, required: true }],
+    icon: { type: String, required: false },
+    color: { type: String, required: false },
     childRoles: [{
             type: mongoose.Schema.Types.ObjectId,
             ref: 'Role',

package/dist/models/UserLoginFailModel.js

@@ -0,0 +1,20 @@
+import { mongoose } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+const UserLoginFailSchema = new mongoose.Schema({
+    username: { type: String, required: false, index: false, unique: false },
+    userAgent: { type: String, required: false, index: false, unique: false },
+    ip: { type: String, required: false, index: false, unique: false },
+}, { timestamps: true });
+UserLoginFailSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+UserLoginFailSchema.plugin(mongoosePaginate);
+UserLoginFailSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+UserLoginFailSchema.set('toJSON', { getters: true, virtuals: true });
+UserLoginFailSchema.set('toObject', { getters: true, virtuals: true });
+const MODEL_NAME = 'UserLoginFail';
+const COLLECTION_NAME = 'UserLoginFail';
+const UserLoginFailModel = mongoose.model(MODEL_NAME, UserLoginFailSchema, COLLECTION_NAME);
+export { UserLoginFailSchema, UserLoginFailModel };
+export default UserLoginFailModel;

package/dist/models/UserSessionModel.js

@@ -0,0 +1,21 @@
+import { mongoose } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+const UserSessionSchema = new mongoose.Schema({
+    uuid: { type: String, required: true, index: true, unique: false },
+    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, index: true, unique: false },
+    userAgent: { type: String, required: false, index: false, unique: false },
+    ip: { type: String, required: false, index: false, unique: false },
+}, { timestamps: true });
+UserSessionSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+UserSessionSchema.plugin(mongoosePaginate);
+UserSessionSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+UserSessionSchema.set('toJSON', { getters: true, virtuals: true });
+UserSessionSchema.set('toObject', { getters: true, virtuals: true });
+const MODEL_NAME = 'UserSession';
+const COLLECTION_NAME = 'UserSession';
+const UserSessionModel = mongoose.model(MODEL_NAME, UserSessionSchema, COLLECTION_NAME);
+export { UserSessionSchema, UserSessionModel };
+export default UserSessionModel;

package/dist/permissions/UserLoginFailPermissions.js

@@ -0,0 +1,8 @@
+var UserLoginFailPermissions;
+(function (UserLoginFailPermissions) {
+    UserLoginFailPermissions["View"] = "userloginfail:view";
+    UserLoginFailPermissions["ViewAll"] = "userloginfail:viewAll";
+    UserLoginFailPermissions["Manage"] = "userloginfail:manage";
+})(UserLoginFailPermissions || (UserLoginFailPermissions = {}));
+export { UserLoginFailPermissions };
+export default UserLoginFailPermissions;

package/dist/permissions/UserSessionPermissions.js

@@ -0,0 +1,8 @@
+var UserSessionPermissions;
+(function (UserSessionPermissions) {
+    UserSessionPermissions["View"] = "usersession:view";
+    UserSessionPermissions["ViewAll"] = "usersession:viewAll";
+    UserSessionPermissions["Manage"] = "usersession:manage";
+})(UserSessionPermissions || (UserSessionPermissions = {}));
+export { UserSessionPermissions };
+export default UserSessionPermissions;

package/dist/permissions/index.js

@@ -1,12 +1,16 @@
-import TenantPermissions from './TenantPermissions';
-import UserPermissions from './UserPermissions';
-import RolePermissions from './RolePermissions';
-import UserApiKeyPermissions from './UserApiKeyPermissions';
+import TenantPermissions from './TenantPermissions.js';
+import UserPermissions from './UserPermissions.js';
+import RolePermissions from './RolePermissions.js';
+import UserApiKeyPermissions from './UserApiKeyPermissions.js';
+import UserLoginFailPermissions from './UserLoginFailPermissions.js';
+import UserSessionPermissions from './UserSessionPermissions.js';
 const permissions = {
     ...TenantPermissions,
     ...UserPermissions,
     ...RolePermissions,
-    ...UserApiKeyPermissions
+    ...UserApiKeyPermissions,
+    ...UserLoginFailPermissions,
+    ...UserSessionPermissions
 };
 export default permissions;
 export { permissions };

package/dist/rbac/Rbac.js

@@ -46,7 +46,7 @@ class Rbac {
     }
     assertPermission(requiredPermission) {
         this.assertAuthenticated();
-        if (!this.hasPermission(requiredPermission)) {
+        if (requiredPermission === undefined || !this.hasPermission(requiredPermission)) {
             throw new ForbiddenError();
         }
     }

package/dist/repository/mongo/UserLoginFailMongoRepository.js

@@ -0,0 +1,12 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { UserLoginFailModel } from "../../models/UserLoginFailModel.js";
+class UserLoginFailMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        this._model = UserLoginFailModel;
+        this._searchFields = ['agent', 'ip'];
+        this._populateFields = [];
+    }
+}
+export default UserLoginFailMongoRepository;
+export { UserLoginFailMongoRepository };

package/dist/repository/mongo/UserSessionMongoRepository.js

@@ -0,0 +1,12 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { UserSessionModel } from "../../models/UserSessionModel.js";
+class UserSessionMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        this._model = UserSessionModel;
+        this._searchFields = ['uuid', 'agent', 'ip'];
+        this._populateFields = ['user'];
+    }
+}
+export default UserSessionMongoRepository;
+export { UserSessionMongoRepository };

package/dist/repository/sqlite/UserLoginFailSqliteRepository.js

@@ -0,0 +1,31 @@
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class UserLoginFailSqliteRepository 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 UserLoginFailSqliteRepository;