@drax/identity-back 0.36.0 → 0.37.2

package/src/index.ts

@@ -14,6 +14,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";
@@ -35,12 +37,12 @@ import type {IUserRepository} from "./interfaces/IUserRepository";
 import type {IUserApiKeyRepository} from "./interfaces/IUserApiKeyRepository";
 
 
-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";
@@ -93,6 +95,8 @@ export {
     RoleRoutes,
     TenantRoutes,
     UserApiKeyRoutes,
+    UserSessionRoutes,
+    UserLoginFailRoutes,
 
     AuthUtils,
 
@@ -102,11 +106,12 @@ export {
     apiKeyMiddleware,
 
     //Permissions
-    IdentityPermissions,
     RolePermissions,
     TenantPermissions,
     UserPermissions,
     UserApiKeyPermissions,
+    UserSessionPermissions,
+    UserLoginFailPermissions,
 
     //Config
     IdentityConfig,

package/src/interfaces/IUserLoginFailRepository.ts

@@ -0,0 +1,11 @@
+
+import {IUserLoginFail, IUserLoginFailBase} from '@drax/identity-share'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface IUserLoginFailRepository extends IDraxCrudRepository<IUserLoginFail, IUserLoginFailBase, IUserLoginFailBase>{
+
+}
+
+export {IUserLoginFailRepository}
+
+

package/src/interfaces/IUserSessionRepository.ts

@@ -0,0 +1,11 @@
+
+import {IUserSession, IUserSessionBase} from '@drax/identity-share'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface IUserSessionRepository extends IDraxCrudRepository<IUserSession, IUserSessionBase, IUserSessionBase>{
+
+}
+
+export {IUserSessionRepository}
+
+

package/src/models/RoleModel.ts

@@ -11,6 +11,8 @@ const RoleMongoSchema = new Schema<IRole>({
         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/src/models/UserLoginFailModel.ts

@@ -0,0 +1,34 @@
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {IUserLoginFail} from '@drax/identity-share'
+
+const UserLoginFailSchema = new mongoose.Schema<IUserLoginFail>({
+            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<IUserLoginFail, PaginateModel<IUserLoginFail>>(MODEL_NAME, UserLoginFailSchema,COLLECTION_NAME);
+
+export {
+    UserLoginFailSchema,
+    UserLoginFailModel
+}
+
+export default UserLoginFailModel

package/src/models/UserSessionModel.ts

@@ -0,0 +1,36 @@
+
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {IUserSession} from '@drax/identity-share'
+
+const UserSessionSchema = new mongoose.Schema<IUserSession>({
+            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<IUserSession, PaginateModel<IUserSession>>(MODEL_NAME, UserSessionSchema,COLLECTION_NAME);
+
+export {
+    UserSessionSchema,
+    UserSessionModel
+}
+
+export default UserSessionModel

package/src/permissions/UserLoginFailPermissions.ts

@@ -0,0 +1,12 @@
+
+enum UserLoginFailPermissions {
+
+    View = "userloginfail:view",
+    ViewAll = "userloginfail:viewAll",
+    Manage = "userloginfail:manage"
+
+}
+
+export { UserLoginFailPermissions };
+export default UserLoginFailPermissions;
+

package/src/permissions/UserSessionPermissions.ts

@@ -0,0 +1,12 @@
+
+enum UserSessionPermissions {
+
+    View = "usersession:view",
+    ViewAll = "usersession:viewAll",
+    Manage = "usersession:manage"
+
+}
+
+export { UserSessionPermissions };
+export default UserSessionPermissions;
+

package/src/permissions/index.ts

@@ -1,13 +1,17 @@
-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
 };
 
 

package/src/rbac/Rbac.ts

@@ -63,7 +63,7 @@ class Rbac implements IRbac{
 
     assertPermission(requiredPermission: string) {
         this.assertAuthenticated()
-        if (!this.hasPermission(requiredPermission)) {
+        if (requiredPermission === undefined || !this.hasPermission(requiredPermission)) {
             throw new ForbiddenError()
         }
     }

package/src/repository/mongo/UserLoginFailMongoRepository.ts

@@ -0,0 +1,21 @@
+
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {UserLoginFailModel} from "../../models/UserLoginFailModel.js";
+import type {IUserLoginFailRepository} from '../../interfaces/IUserLoginFailRepository'
+import type {IUserLoginFail, IUserLoginFailBase} from "@drax/identity-share";
+
+
+class UserLoginFailMongoRepository extends AbstractMongoRepository<IUserLoginFail, IUserLoginFailBase, IUserLoginFailBase> implements IUserLoginFailRepository {
+
+    constructor() {
+        super();
+        this._model = UserLoginFailModel;
+        this._searchFields = ['agent', 'ip'];
+         this._populateFields = [];
+    }
+
+}
+
+export default UserLoginFailMongoRepository
+export {UserLoginFailMongoRepository}
+

package/src/repository/mongo/UserSessionMongoRepository.ts

@@ -0,0 +1,21 @@
+
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {UserSessionModel} from "../../models/UserSessionModel.js";
+import type {IUserSessionRepository} from '../../interfaces/IUserSessionRepository'
+import type {IUserSession, IUserSessionBase} from "@drax/identity-share";
+
+
+class UserSessionMongoRepository extends AbstractMongoRepository<IUserSession, IUserSessionBase, IUserSessionBase> implements IUserSessionRepository {
+
+    constructor() {
+        super();
+        this._model = UserSessionModel;
+        this._searchFields = ['uuid', 'agent', 'ip'];
+         this._populateFields = ['user'];
+    }
+
+}
+
+export default UserSessionMongoRepository
+export {UserSessionMongoRepository}
+

package/src/repository/sqlite/RoleSqliteRepository.ts

@@ -1,15 +1,8 @@
 import {IRoleRepository} from '../../interfaces/IRoleRepository'
-import {UUID} from "crypto";
-import sqlite from "better-sqlite3";
-import {randomUUID} from "node:crypto";
-import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/crud-share";
 import {IRole, IRoleBase} from "@drax/identity-share";
 import {AbstractSqliteRepository} from "@drax/crud-back";
 import {
-    SqliteErrorToValidationError,
     SqliteTableField,
-    SqlQueryFilter,
-    SqlSort
 } from "@drax/common-back";
 
 

package/src/repository/sqlite/UserLoginFailSqliteRepository.ts

@@ -0,0 +1,44 @@
+import {IUserLoginFail, IUserLoginFailBase} from '@drax/identity-share'
+import {IUserLoginFailRepository} from '../../interfaces/IUserLoginFailRepository'
+import type {SqliteTableField} from "@drax/common-back";
+import {AbstractSqliteRepository} from "@drax/crud-back";
+import UserSqliteRepository from "./UserSqliteRepository.js";
+
+class UserLoginFailSqliteRepository extends AbstractSqliteRepository<IUserLoginFail,IUserLoginFailBase,IUserLoginFailBase> implements IUserLoginFailRepository{
+
+    protected db: any;
+    protected tableName: string = 'user_sessions';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = [];
+    protected booleanFields: string[] = [];
+    protected identifier: string = '_id';
+    protected populateFields = [{field: 'user', table: 'users', identifier: '_id'}]
+    protected tableFields: SqliteTableField[] = [
+        {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},
+    ]
+    protected verbose: boolean;
+
+
+
+    async prepareData(data: any): Promise<void> {
+        // Transform data before saving to database if needed
+    }
+
+    async prepareItem(item: any): Promise<void> {
+        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

package/src/repository/sqlite/UserSessionSqliteRepository.ts

@@ -0,0 +1,44 @@
+import {IUserSession, IUserSessionBase} from '@drax/identity-share'
+import {IUserSessionRepository} from '../../interfaces/IUserSessionRepository'
+import type {SqliteTableField} from "@drax/common-back";
+import {AbstractSqliteRepository} from "@drax/crud-back";
+import UserSqliteRepository from "./UserSqliteRepository.js";
+
+class UserSessionSqliteRepository extends AbstractSqliteRepository<IUserSession,IUserSessionBase,IUserSessionBase> implements IUserSessionRepository{
+
+
+    protected db: any;
+    protected tableName: string = 'user_sessions';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = [];
+    protected booleanFields: string[] = [];
+    protected identifier: string = '_id';
+    protected populateFields = [{field: 'user', table: 'users', identifier: '_id'}]
+    protected tableFields: SqliteTableField[] = [
+        {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},
+    ]
+    protected verbose: boolean;
+
+
+    async prepareData(data: any): Promise<void> {
+        // Transform data before saving to database if needed
+    }
+
+    async prepareItem(item: any): Promise<void> {
+        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/src/routes/UserLoginFailRoutes.ts

@@ -0,0 +1,20 @@
+
+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: UserLoginFailController = 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/src/routes/UserRoutes.ts

@@ -19,6 +19,8 @@ async function UserRoutes(fastify, options) {
 
     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))

package/src/routes/UserSessionRoutes.ts

@@ -0,0 +1,20 @@
+
+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: UserSessionController = 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/src/schemas/RoleSchema.ts

@@ -5,6 +5,8 @@ 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(),
 })
 
@@ -12,6 +14,8 @@ 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/src/schemas/UserLoginFailSchema.ts

@@ -0,0 +1,18 @@
+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/src/schemas/UserSchema.ts

@@ -33,6 +33,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/src/schemas/UserSessionSchema.ts

@@ -0,0 +1,20 @@
+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/src/services/UserLoginFailService.ts

@@ -0,0 +1,16 @@
+
+import type{IUserLoginFailRepository} from "../interfaces/IUserLoginFailRepository";
+import type {IUserLoginFailBase, IUserLoginFail} from "@drax/identity-share";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class UserLoginFailService extends AbstractService<IUserLoginFail, IUserLoginFailBase, IUserLoginFailBase> {
+
+    constructor(UserLoginFailRepository: IUserLoginFailRepository, schema?: ZodObject<ZodRawShape>) {
+        super(UserLoginFailRepository, schema);
+    }
+
+}
+
+export default UserLoginFailService
+export {UserLoginFailService}

package/src/services/UserService.ts

@@ -9,6 +9,8 @@ import BadCredentialsError from "../errors/BadCredentialsError.js";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 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<IUser, IUserCreate, IUserUpdate> {
 
@@ -20,16 +22,29 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
         console.log("UserService constructor")
     }
 
-    async auth(username: string, password: string) {
+    async auth(username: string, password: string, {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/src/services/UserSessionService.ts

@@ -0,0 +1,16 @@
+
+import type{IUserSessionRepository} from "../interfaces/IUserSessionRepository";
+import type {IUserSessionBase, IUserSession} from "@drax/identity-share";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class UserSessionService extends AbstractService<IUserSession, IUserSessionBase, IUserSessionBase> {
+
+    constructor(UserSessionRepository: IUserSessionRepository, schema?: ZodObject<ZodRawShape>) {
+        super(UserSessionRepository, schema);
+    }
+
+}
+
+export default UserSessionService
+export {UserSessionService}