@drax/identity-back 0.5.4 → 0.5.6

package/dist/repository/mongo/RoleMongoRepository.js

@@ -2,7 +2,7 @@ import { RoleModel } from "../../models/RoleModel.js";
 import { MongooseQueryFilter, MongooseSort } from "@drax/common-back";
 class RoleMongoRepository {
     constructor() {
-        this._searchFields = ['_id', 'name'];
+        this._searchFields = ['name'];
     }
     async create(roleData) {
         const role = new RoleModel(roleData);
@@ -54,5 +54,28 @@ class RoleMongoRepository {
             items: roles.docs
         };
     }
+    async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+        const query = {};
+        if (search) {
+            query['$or'] = [
+                { name: new RegExp(search, 'i') },
+            ];
+        }
+        MongooseQueryFilter.applyFilters(query, filters);
+        const sort = MongooseSort.applySort(orderBy, order);
+        return await RoleModel.find(query).limit(limit).sort(sort);
+    }
+    async findCursor({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+        console.log("RoleMongoRepository.findCursor called");
+        const query = {};
+        if (search) {
+            query['$or'] = [
+                { name: new RegExp(search, 'i') },
+            ];
+        }
+        MongooseQueryFilter.applyFilters(query, filters);
+        const sort = MongooseSort.applySort(orderBy, order);
+        return RoleModel.find(query).limit(limit).sort(sort).cursor();
+    }
 }
 export default RoleMongoRepository;

package/dist/repository/mongo/TenantMongoRepository.js

@@ -55,7 +55,7 @@ class TenantMongoRepository {
             items: tenants.docs
         };
     }
-    async find({ cursor = false, limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+    async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
         const query = {};
         if (search) {
             query['$or'] = [
@@ -64,8 +64,20 @@ class TenantMongoRepository {
         }
         MongooseQueryFilter.applyFilters(query, filters);
         const sort = MongooseSort.applySort(orderBy, order);
-        const items = await TenantModel.find(query).sort(sort);
+        const items = await TenantModel.find(query).limit(limit).sort(sort);
         return items;
     }
+    async findCursor({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+        console.log("TenantMongoRepository.findCursor called");
+        const query = {};
+        if (search) {
+            query['$or'] = [
+                { name: new RegExp(search, 'i') },
+            ];
+        }
+        MongooseQueryFilter.applyFilters(query, filters);
+        const sort = MongooseSort.applySort(orderBy, order);
+        return TenantModel.find(query).limit(limit).sort(sort).cursor();
+    }
 }
 export default TenantMongoRepository;

package/dist/repository/mongo/UserMongoRepository.js

@@ -90,5 +90,28 @@ class UserMongoRepository {
             return false;
         }
     }
+    async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+        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 = '', order = false, search = '', filters = [] }) {
+        console.log("RoleMongoRepository.findCursor called");
+        const query = {};
+        if (search) {
+            query['$or'] = [
+                { name: new RegExp(search, 'i') },
+            ];
+        }
+        MongooseQueryFilter.applyFilters(query, filters);
+        const sort = MongooseSort.applySort(orderBy, order);
+        return UserModel.find(query).populate(['role', 'tenant']).limit(limit).sort(sort).cursor();
+    }
 }
 export default UserMongoRepository;

package/dist/repository/sqlite/TenantSqliteRepository.js

@@ -96,7 +96,7 @@ class TenantSqliteRepository {
             items: tenants
         };
     }
-    async find({ cursor = false, limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
+    async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
         let where = "";
         if (search) {
             where = ` WHERE name LIKE '%${search}%'`;

package/dist/routes/RoleRoutes.js

@@ -2,6 +2,7 @@ import RoleController from "../controllers/RoleController.js";
 async function RoleRoutes(fastify, options) {
     const controller = new RoleController();
     fastify.get('/api/permissions', (req, rep) => controller.permissions(req, rep));
+    fastify.get('/api/roles/export', (req, rep) => controller.export(req, rep));
     fastify.get('/api/roles/search', (req, rep) => controller.search(req, rep));
     fastify.get('/api/roles/:id', (req, rep) => controller.findById(req, rep));
     fastify.get('/api/roles/name/:name', (req, rep) => controller.findByName(req, rep));

package/dist/routes/UserRoutes.js

@@ -3,6 +3,7 @@ async function UserRoutes(fastify, options) {
     const controller = new UserController();
     fastify.post('/api/auth', (req, rep) => controller.auth(req, rep));
     fastify.get('/api/me', (req, rep) => controller.me(req, rep));
+    fastify.get('/api/users/export', (req, rep) => controller.export(req, rep));
     fastify.get('/api/users', (req, rep) => controller.paginate(req, rep));
     fastify.post('/api/users', (req, rep) => controller.create(req, rep));
     fastify.put('/api/users/:id', (req, rep) => controller.update(req, rep));

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
@@ -28,9 +28,9 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^0.5.3",
-    "@drax/crud-back": "^0.5.4",
-    "@drax/crud-share": "^0.5.4",
+    "@drax/common-back": "^0.5.6",
+    "@drax/crud-back": "^0.5.6",
+    "@drax/crud-share": "^0.5.5",
     "@drax/identity-share": "^0.5.1",
     "bcryptjs": "^2.4.3",
     "express-jwt": "^8.4.1",
@@ -62,5 +62,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "6db0bebb2df9edecd2c3caa7288fb5c7001c4243"
+  "gitHead": "ecb0ad934d7e7b25ee3e74e91a7fbba768305e01"
 }

package/src/interfaces/IRoleRepository.ts

@@ -1,7 +1,7 @@
 import {IRole, IRoleBase} from "@drax/identity-share";
-import {IDraxCrud} from "@drax/crud-share";
+import {IDraxCrudRepository} from "@drax/crud-share";
 
-interface IRoleRepository extends IDraxCrud<IRole, IRoleBase, IRoleBase> {
+interface IRoleRepository extends IDraxCrudRepository<IRole, IRoleBase, IRoleBase> {
     findById(id: string): Promise<IRole | null>;
     findByName(name: string): Promise<IRole | null>;
     fetchAll(): Promise<IRole[]>;

package/src/repository/mongo/RoleMongoRepository.ts

@@ -1,50 +1,50 @@
 import {RoleModel} from "../../models/RoleModel.js";
 import {IRoleRepository} from '../../interfaces/IRoleRepository'
 import {mongoose, MongooseQueryFilter, MongooseSort} from "@drax/common-back";
-import {PaginateOptions, PaginateResult} from "mongoose";
+import {Cursor, PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {IRoleBase, IRole} from "@drax/identity-share";
 
-class RoleMongoRepository implements IRoleRepository{
+class RoleMongoRepository implements IRoleRepository {
 
-    _searchFields = ['_id','name']
+    _searchFields = ['name']
 
     async create(roleData: IRoleBase): Promise<IRole> {
-        const role : mongoose.HydratedDocument<IRole> = new RoleModel(roleData)
+        const role: mongoose.HydratedDocument<IRole> = new RoleModel(roleData)
         await role.save()
         await role.populate('childRoles')
         return role
     }
 
     async update(id: string, roleData: IRoleBase): Promise<IRole> {
-        const role : mongoose.HydratedDocument<IRole> = await RoleModel.findOneAndUpdate({_id: id}, roleData, {new: true}).populate('childRoles').exec()
+        const role: mongoose.HydratedDocument<IRole> = await RoleModel.findOneAndUpdate({_id: id}, roleData, {new: true}).populate('childRoles').exec()
         return role
     }
 
     async delete(id: string): Promise<boolean> {
-        const result : DeleteResult = await RoleModel.deleteOne({_id: id}).exec()
+        const result: DeleteResult = await RoleModel.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
     }
 
-    async findById(id: string): Promise<IRole | null>{
+    async findById(id: string): Promise<IRole | null> {
         const role: mongoose.HydratedDocument<IRole> | null = await RoleModel.findById(id).populate('childRoles').exec()
         return role
     }
 
-    async findByName(name: string): Promise<IRole | null>{
+    async findByName(name: string): Promise<IRole | null> {
         const role: mongoose.HydratedDocument<IRole> | null = await RoleModel.findOne({name}).populate('childRoles').exec()
         return role
     }
 
-    async fetchAll(): Promise<IRole[]>{
+    async fetchAll(): Promise<IRole[]> {
         const roles: mongoose.HydratedDocument<IRole>[] = await RoleModel.find().populate('childRoles').exec()
         return roles
     }
 
     async search(value: string, limit: number = 1000): Promise<IRole[]> {
         const query = {}
-        if(value){
+        if (value) {
             query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(value.toString(), 'i')}))
         }
         const items: mongoose.HydratedDocument<IRole>[] = await RoleModel.find(query).limit(limit).exec()
@@ -52,15 +52,16 @@ class RoleMongoRepository implements IRoleRepository{
     }
 
     async paginate({
-                       page= 1,
-                       limit= 5,
-                       orderBy= '',
-                       order= false,
-                       search= '',
-                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       order = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
         const query = {}
 
-        if(search){
+        if (search) {
             query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search.toString(), 'i')}))
         }
 
@@ -77,6 +78,52 @@ class RoleMongoRepository implements IRoleRepository{
             items: roles.docs
         }
     }
+
+    async find({
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<IRole[]> {
+
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return await RoleModel.find(query).limit(limit).sort(sort)
+    }
+
+    async findCursor({
+                   limit = 0,
+                   orderBy = '',
+                   order = false,
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<Cursor> {
+        console.log("RoleMongoRepository.findCursor called")
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return RoleModel.find(query).limit(limit).sort(sort).cursor() as Cursor;
+    }
 }
 
 export default RoleMongoRepository

package/src/repository/mongo/TenantMongoRepository.ts

@@ -1,7 +1,7 @@
 import {TenantModel} from "../../models/TenantModel.js";
 import {ITenantRepository} from '../../interfaces/ITenantRepository'
 import {mongoose, MongooseSort, MongooseQueryFilter} from "@drax/common-back";
-import {PaginateOptions, PaginateResult} from "mongoose";
+import {Cursor, PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
 import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {ITenant, ITenantBase} from "@drax/identity-share";
@@ -82,7 +82,6 @@ class TenantMongoRepository implements ITenantRepository {
     }
 
     async find({
-                   cursor = false,
                    limit = 0,
                    orderBy = '',
                    order = false,
@@ -101,9 +100,32 @@ class TenantMongoRepository implements ITenantRepository {
         MongooseQueryFilter.applyFilters(query, filters)
 
         const sort = MongooseSort.applySort(orderBy, order)
-        const items: ITenant[] = await TenantModel.find(query).sort(sort)
+        const items: ITenant[] = await TenantModel.find(query).limit(limit).sort(sort)
         return items
     }
+
+    async findCursor({
+                         limit = 0,
+                         orderBy = '',
+                         order = false,
+                         search = '',
+                         filters = []
+                     }: IDraxFindOptions): Promise<Cursor> {
+        console.log("TenantMongoRepository.findCursor called")
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return TenantModel.find(query).limit(limit).sort(sort).cursor() as Cursor;
+    }
 }
 
 export default TenantMongoRepository

package/src/repository/mongo/UserMongoRepository.ts

@@ -9,9 +9,10 @@ import {
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
 import {DeleteResult, MongoServerError} from "mongodb";
 import type {IUserRepository} from "../../interfaces/IUserRepository";
-import {PaginateResult} from "mongoose";
+import {Cursor, PaginateResult} from "mongoose";
 import RoleMongoRepository from "./RoleMongoRepository.js";
-import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {IDraxFindOptions, IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {IRole} from "@drax/identity-share";
 
 class UserMongoRepository implements IUserRepository {
     private roleRepository: RoleMongoRepository;
@@ -124,6 +125,52 @@ class UserMongoRepository implements IUserRepository {
             return false
         }
     }
+
+    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 = '',
+                         order = false,
+                         search = '',
+                         filters = []
+                     }: IDraxFindOptions): Promise<Cursor> {
+        console.log("RoleMongoRepository.findCursor called")
+        const query = {}
+
+        if (search) {
+            query['$or'] = [
+                {name: new RegExp(search, 'i')},
+            ]
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
+
+        return UserModel.find(query).populate(['role','tenant']).limit(limit).sort(sort).cursor() as Cursor;
+    }
 }
 
 export default UserMongoRepository

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -144,7 +144,6 @@ class TenantSqliteRepository implements ITenantRepository{
     }
 
     async find({
-                   cursor = false,
                    limit = 0,
                    orderBy = '',
                    order = false,

package/src/routes/RoleRoutes.ts

@@ -8,6 +8,8 @@ async function RoleRoutes(fastify, options) {
 
     fastify.get('/api/permissions', (req,rep) => controller.permissions(req,rep))
 
+    fastify.get('/api/roles/export', (req,rep) => controller.export(req,rep) )
+
     fastify.get('/api/roles/search', (req,rep) => controller.search(req,rep))
 
     fastify.get('/api/roles/:id', (req,rep) => controller.findById(req,rep))

package/src/routes/UserRoutes.ts

@@ -8,6 +8,8 @@ async function UserRoutes(fastify, options) {
 
     fastify.get('/api/me', (req,rep) => controller.me(req,rep))
 
+    fastify.get('/api/users/export', (req,rep) => controller.export(req,rep) )
+
     fastify.get('/api/users', (req,rep) => controller.paginate(req,rep))
 
     fastify.post('/api/users', (req,rep) => controller.create(req,rep))