@drax/identity-back 0.11.4 → 0.12.1

package/src/repository/mongo/UserApiKeyMongoRepository.ts

@@ -1,75 +1,48 @@
 import {UserApiKeyModel} from "../../models/UserApiKeyModel.js";
 import {
     mongoose,
-    MongooseErrorToValidationError, MongooseQueryFilter, MongooseSort,
-    MongoServerErrorToValidationError,
-    ValidationError
+    MongooseQueryFilter,
+    MongooseSort,
 } 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/crud-share";
 import {IUserApiKeyRepository} from "../../interfaces/IUserApiKeyRepository";
+import {AbstractMongoRepository} from "@drax/crud-back";
 
-class UserApiKeyMongoRepository implements IUserApiKeyRepository {
+class UserApiKeyMongoRepository extends AbstractMongoRepository<IUserApiKey,IUserApiKeyBase,IUserApiKeyBase> implements IUserApiKeyRepository {
 
+    protected _searchFields=['name']
+    protected _populateFields  = [
+        {path: 'user', populate: {path: 'tenant role'} },
+        {path: 'createdBy', populate: {path: 'tenant role'} },
+    ]
+    protected _model = UserApiKeyModel
+    protected _lean = false
 
-    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)
+        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: {$eq: secret}, deleted: {$ne: true} }).populate({path: 'user', populate: {path: 'tenant role'}}).exec()
-        return userApiKey
+        const userApiKey = await UserApiKeyModel
+            .findOne({secret: {$eq: secret}, deleted: {$ne: true} })
+            .populate(this._populateFields)
+            .exec()
+        return userApiKey as IUserApiKey
     }
 
     async paginate({
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       order = false,
+                       order = "asc",
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
@@ -78,17 +51,22 @@ class UserApiKeyMongoRepository implements IUserApiKeyRepository {
             deleted: false
         }
 
-        if (search) {
-            query['$or'] = [
-                {name: new RegExp(search, 'i')},
-            ]
+        if(search){
+            if(mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search)
+            }else{
+                query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
+            }
         }
 
         MongooseQueryFilter.applyFilters(query, filters)
 
         const sort = MongooseSort.applySort(orderBy, order)
-
-        const options = {populate: ['user', 'user.tenant', 'user.role'], page, limit, sort}
+        const populate = ['user', 'user.tenant', 'user.role', 'createdBy']
+        const lean = this._lean
+        const leanWithId = this._lean
+        const leanWithVirtuals = this._lean
+        const options = {populate , page, limit, sort, lean, leanWithId, leanWithVirtuals}
 
         const userApiKeyPaginated: PaginateResult<IUserApiKey> = await UserApiKeyModel.paginate(query, options)
         return {

package/src/repository/mongo/UserMongoRepository.ts

@@ -1,24 +1,28 @@
 import {UserModel} from "../../models/UserModel.js";
 import {
     mongoose,
-    MongooseErrorToValidationError,
-    MongooseQueryFilter, MongooseSort,
-    MongoServerErrorToValidationError,
-    ValidationError
+    MongooseValidationErrorToValidationError,
+    MongooseQueryFilter,
+    MongooseSort,
+    ValidationError, MongooseCastErrorToValidationError
 } from "@drax/common-back"
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
-import {DeleteResult, MongoServerError} from "mongodb";
 import type {IUserRepository} from "../../interfaces/IUserRepository";
-import {Cursor, PaginateResult} from "mongoose";
+import {Cursor} from "mongoose";
 import RoleMongoRepository from "./RoleMongoRepository.js";
-import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
-import type {IDraxFieldFilter} from "@drax/crud-share/dist";
+import {IDraxFindOptions} from "@drax/crud-share";
+import {AbstractMongoRepository} from "@drax/crud-back";
 
-class UserMongoRepository implements IUserRepository {
-    private roleRepository: RoleMongoRepository;
-    _searchFields = ['name','username','email','phone']
+class UserMongoRepository extends AbstractMongoRepository<IUser,IUserCreate,IUserUpdate> implements IUserRepository {
+    protected roleRepository: RoleMongoRepository;
+
+    protected _searchFields = ['name','username','email','phone']
+    protected _populateFields = ['role','tenant']
+    protected _model = UserModel
+    protected _lean = false
 
     constructor() {
+        super()
         this.roleRepository = new RoleMongoRepository()
     }
 
@@ -31,123 +35,82 @@ class UserMongoRepository implements IUserRepository {
 
             const user: mongoose.HydratedDocument<IUser> = new UserModel(userData)
             await user.save()
-            await user.populate(['role','tenant'])
+            await user.populate(this._populateFields)
             return user
         }catch (e){
             if(e instanceof mongoose.Error.ValidationError){
-                throw MongooseErrorToValidationError(e)
-            }
-            throw e
-        }
-
-    }
-
-    async update(id: string, userData: IUserUpdate): Promise<IUser> {
-        try{
-        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOneAndUpdate({_id: id}, userData, {new: true}).populate(['role','tenant']).exec()
-        return user
-        }catch (e){
-            if(e instanceof mongoose.Error.ValidationError){
-                throw MongooseErrorToValidationError(e)
+                throw MongooseValidationErrorToValidationError(e)
             }
-            if(e instanceof MongoServerError || e.name === 'MongoServerError'){
-                throw MongoServerErrorToValidationError(e)
+            if (e instanceof mongoose.Error.CastError) {
+                throw MongooseCastErrorToValidationError(e)
             }
             throw e
         }
-    }
 
-    async updatePartial(id: string, data: any): Promise<IUser> {
-        try {
-            const item: mongoose.HydratedDocument<IUser> = await UserModel.findOneAndUpdate({_id: id}, data, {new: true}).populate(['role','tenant']).exec()
-            return item
-        } catch (e) {
-            if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e)
-            }
-            throw e
-        }
-    }
-
-    async delete(id: string): Promise<boolean> {
-        const result: DeleteResult = await UserModel.deleteOne({_id: id}).exec()
-        return result.deletedCount == 1
-    }
-
-
-    async findById(id:string): Promise<IUser> {
-        const user: mongoose.HydratedDocument<IUser> = await UserModel.findById(id).populate(['role','tenant']).exec()
-        return user
     }
 
     async findByUsername(username: string): Promise<IUser> {
-        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOne({username: username}).populate(['role','tenant']).exec()
-        return user
+        const user = await UserModel
+            .findOne({username: username})
+            .populate(['role','tenant'])
+            .lean(this._lean)
+            .exec()
+        return user as IUser
     }
 
     async findByUsernameWithPassword(username: string): Promise<IUser> {
-        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOne({username: username}).select('+password').populate(['role','tenant']).exec()
-        return user
+        const user = await UserModel
+            .findOne({username: username})
+            .select('+password')
+            .populate(['role','tenant'])
+            .lean(this._lean)
+            .exec()
+        return user as IUser
+    }
+
+    async findByIdWithPassword(id: string): Promise<IUser> {
+        const user = await UserModel.findById(id)
+            .select('+password')
+            .populate(['role','tenant'])
+            .lean(this._lean)
+            .exec()
+        return user as IUser
     }
 
     async findByEmail(email: string): Promise<IUser> {
-        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOne({email: email}).populate(['role','tenant']).exec()
-        return user
+        const user = await UserModel
+            .findOne({email: email})
+            .populate(['role','tenant'])
+            .lean(this._lean)
+            .exec()
+        return user as IUser
     }
 
     async findByEmailCode(code: string): Promise<IUser> {
-        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOne({emailCode: {$eq: code}, emailVerified: {$eq: false} }).populate(['role','tenant']).exec()
-        return user
+        const user = await UserModel
+            .findOne({emailCode: {$eq: code}, emailVerified: {$eq: false} })
+            .populate(['role','tenant'])
+            .lean(this._lean)
+            .exec()
+        return user as IUser
     }
 
     async findByPhoneCode(code: string): Promise<IUser> {
-        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOne({phoneCode: {$eq: code}, phoneVerified: {$eq: false} }).populate(['role','tenant']).exec()
-        return user
+        const user = await UserModel
+            .findOne({phoneCode: {$eq: code}, phoneVerified: {$eq: false} })
+            .populate(['role','tenant'])
+            .lean(this._lean)
+            .exec()
+        return user as IUser
     }
 
     async findByRecoveryCode(code: string): Promise<IUser> {
-        const user: mongoose.HydratedDocument<IUser> = await UserModel.findOne({recoveryCode: {$eq: code}, active: {$eq: true} }).populate(['role','tenant']).exec()
-        return user
-    }
-
-    async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       order= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
-
-        const query = {}
-
-        if(search){
-            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
-        }
-
-        MongooseQueryFilter.applyFilters(query, filters)
-
-        const sort = MongooseSort.applySort(orderBy, order)
-
-        const options = {populate: ['role','tenant'], page, limit, sort }
-
-        const userPaginated: PaginateResult<IUser> = await UserModel.paginate(query, options)
-        return {
-            page: page,
-            limit: limit,
-            total: userPaginated.totalDocs,
-            items: userPaginated.docs
-        }
-    }
-
-
-    async search(value: string, limit: number = 1000, filters: IDraxFieldFilter[] = []): Promise<IUser[]> {
-        const query = {}
-        if(value){
-            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(value.toString(), 'i')}))
-        }
-        MongooseQueryFilter.applyFilters(query, filters)
-        const items: mongoose.HydratedDocument<IUser>[] = await UserModel.find(query).limit(limit).exec()
-        return items
+        const user = await UserModel
+            .findOne({recoveryCode: {$eq: code}, active: {$eq: true} })
+            .populate(['role','tenant'])
+            .lean(this._lean)
+            .exec()
+        return user as IUser
     }
 
     async changePassword(id: string, password: string):Promise<boolean> {
@@ -170,29 +133,6 @@ class UserMongoRepository implements IUserRepository {
         }
     }
 
-    async find({
-                   limit = 0,
-                   orderBy = '',
-                   order = false,
-                   search = '',
-                   filters = []
-               }: IDraxFindOptions): Promise<IUser[]> {
-
-        const query = {}
-
-        if (search) {
-            query['$or'] = [
-                {name: new RegExp(search, 'i')},
-            ]
-        }
-
-        MongooseQueryFilter.applyFilters(query, filters)
-
-        const sort = MongooseSort.applySort(orderBy, order)
-
-        return await UserModel.find(query).populate(['role','tenant']).limit(limit).sort(sort)
-    }
-
     async findCursor({
                          limit = 0,
                          orderBy = '',
@@ -200,13 +140,14 @@ class UserMongoRepository implements IUserRepository {
                          search = '',
                          filters = []
                      }: IDraxFindOptions): Promise<Cursor> {
-        console.log("RoleMongoRepository.findCursor called")
         const query = {}
 
-        if (search) {
-            query['$or'] = [
-                {name: new RegExp(search, 'i')},
-            ]
+        if(search){
+            if(mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search)
+            }else{
+                query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
+            }
         }
 
         MongooseQueryFilter.applyFilters(query, filters)

package/src/repository/sqlite/RoleSqliteRepository.ts

@@ -4,45 +4,42 @@ 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,
-    SqliteTableBuilder,
     SqliteTableField,
     SqlQueryFilter,
     SqlSort
 } 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(dataBaseFile:string, verbose:boolean = false) {
-        this.dataBaseFile = dataBaseFile;
-        this.db = new sqlite(dataBaseFile, {verbose: verbose ? console.log : null});
-        this.table()
+class RoleSqliteRepository extends AbstractSqliteRepository<IRole, IRoleBase, IRoleBase> implements IRoleRepository{
+
+    protected db: any;
+    protected tableName: string = 'roles';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = [];
+    protected booleanFields: string[] = [];
+    protected identifier: string = '_id';
+    protected populateFields = []
+    protected 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},
+    ]
+    protected verbose: boolean;
+
+    constructor(dataBaseFile: string, verbose: boolean = false) {
+        super(dataBaseFile, verbose);
+        this.tableName = 'roles'
     }
 
-    table() {
-        const builder = new SqliteTableBuilder(
-            this.dataBaseFile,
-            'roles',
-            tableFields,
-            false);
-        builder.build('id')
-    }
 
-    normalizeData(roleData: IRoleBase){
+    async prepareData(roleData: any){
 
         roleData.readonly = roleData.readonly ? 1 : 0
 
@@ -55,152 +52,46 @@ class RoleSqliteRepository implements IRoleRepository{
         }
     }
 
-    async create(roleData: IRoleBase): Promise<IRole> {
-        try{
-
-            if(!roleData.id){
-                roleData.id = randomUUID()
-            }
-
-            this.normalizeData(roleData)
-            roleData.createdAt = (new Date().toISOString())
-
-            const fields = Object.keys(roleData)
-                .map(field => `${field}`)
-                .join(', ');
-
-            const values = Object.keys(roleData)
-                .map(field => `@${field}`)
-                .join(', ');
-
-
-        const stmt = this.db.prepare(`INSERT INTO roles (${fields}) VALUES (${values})`);
-        stmt.run(roleData)
-        return this.findById(roleData.id as UUID)
-        }catch (e){
-            console.log(e)
-            throw SqliteErrorToValidationError(e, roleData)
-        }
-    }
-
-
-
-    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)
-            throw SqliteErrorToValidationError(e, roleData)
-        }
-
-    }
-
-    async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       order= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>>{
-        const offset = page > 1 ? (page - 1) * limit : 0
-
-        let where=""
-        if (search) {
-            where = ` WHERE name LIKE '%${search}%'`
-        }
+    async prepareItem(role: any): Promise<IRole>{
+        if(role){
 
-        where = SqlQueryFilter.applyFilters(where, filters)
-        const sort = SqlSort.applySort(orderBy, order)
+            role.permissions = role && role.permissions ? role.permissions.split(",") : []
 
-        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM roles'+where).get();
-        where += sort
-        const roles = this.db.prepare('SELECT * FROM roles '  + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
+            role.childRoles = role && role.childRoles ? role.childRoles.split(",") : []
 
-        for (const role of roles) {
-            await this.populateRole(role)
+            const childRoles = []
+            for(const childRoleId of role.childRoles){
+                const childRole:IRole = await this.findWithoutPopulateById(childRoleId)
+                childRoles.push(childRole)
+            }
+            role.childRoles = childRoles
+            return role
         }
 
-        return {
-            page: page,
-            limit: limit,
-            total: rCount.count,
-            items: roles
-        }
     }
 
-    async delete(id: string): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM roles WHERE id = ?');
-        stmt.run(id);
-        return true
-    }
 
-    async deleteAll(): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM roles');
-        stmt.run();
-        return true
-    }
-
-    async findById(id: string): Promise<IRole | null>{
-        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
-        if(role){
-            await this.populateRole(role)
-            return role
-        }
-        return undefined
-    }
 
     async findByName(name: string): Promise<IRole | null>{
         const role = this.db.prepare('SELECT * FROM roles WHERE name = ?').get(name);
         if(role){
-            await this.populateRole(role)
+            await this.decorate(role)
             return role
         }
         return undefined
     }
 
-    async fetchAll(): Promise<IRole[]>{
-        const roles = this.db.prepare('SELECT * FROM roles').all();
-        for (const role of roles) {
-            await this.populateRole(role)
-        }
-        return roles
-    }
-
 
 
     async findWithoutPopulateById(id: string): Promise<IRole | null>{
-        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
+        const role = this.db.prepare(`SELECT * FROM roles WHERE ${this.identifier} = ?`).get(id);
         if(role){
             return role
         }
         return undefined
     }
 
-    async populateRole(role){
-        role.permissions = role.permissions? role.permissions.split(",") : []
-        role.childRoles = role.childRoles? role.childRoles.split(",") : []
 
-        const childRoles = []
-        for(const childRoleId of role.childRoles){
-            const childRole:IRole = await this.findWithoutPopulateById(childRoleId)
-            childRoles.push(childRole)
-        }
-        role.childRoles = childRoles
-        return role
-    }
 
 
 }