@drax/identity-back 0.1.8 → 0.3.0

package/src/repository/mongo/UserMongoRepository.ts

@@ -1,5 +1,11 @@
 import {UserModel} from "../../models/UserModel.js";
-import {mongoose, MongooseErrorToValidationError, MongoServerErrorToValidationError, ValidationError} from "@drax/common-back"
+import {
+    mongoose,
+    MongooseErrorToValidationError,
+    MongooseQueryFilter, MongooseSort,
+    MongoServerErrorToValidationError,
+    ValidationError
+} from "@drax/common-back"
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
 import {DeleteResult, MongoServerError} from "mongodb";
 import type {IUserRepository} from "../../interfaces/IUserRepository";
@@ -70,7 +76,7 @@ class UserMongoRepository implements IUserRepository {
                        page= 1,
                        limit= 5,
                        orderBy= '',
-                       orderDesc= false,
+                       order= false,
                        search= '',
                        filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
 
@@ -84,21 +90,11 @@ class UserMongoRepository implements IUserRepository {
             ]
         }
 
-        if(filters){
-            for(const filter of filters){
-                if(['eq','$eq'].includes(filter.operator)){
-                    query[filter.field] = {$eq: filter.value}
-                }
-                if(['ne','$ne'].includes(filter.operator)){
-                    query[filter.field] = {$ne: filter.value}
-                }
-                if(['in','$in'].includes(filter.operator)){
-                    query[filter.field] = {$in: filter.value}
-                }
-            }
-        }
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const sort = MongooseSort.applySort(orderBy, order)
 
-        const options = {populate: ['role','tenant'], page: page, limit: limit }
+        const options = {populate: ['role','tenant'], page, limit, sort }
 
         const userPaginated: PaginateResult<IUser> = await UserModel.paginate(query, options)
         return {

package/src/repository/sqlite/RoleSqliteRepository.ts

@@ -4,7 +4,13 @@ import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
 import {IRole, IRoleBase} from "@drax/identity-share";
-import {SqliteErrorToValidationError, SqliteTableBuilder, SqliteTableField} from "@drax/common-back";
+import {
+    SqliteErrorToValidationError,
+    SqliteTableBuilder,
+    SqliteTableField,
+    SqlQueryFilter,
+    SqlSort
+} from "@drax/common-back";
 
 const tableFields: SqliteTableField[] = [
     {name: "name", type: "TEXT", unique: true, primary: false},
@@ -106,7 +112,7 @@ class RoleSqliteRepository implements IRoleRepository{
                        page= 1,
                        limit= 5,
                        orderBy= '',
-                       orderDesc= false,
+                       order= false,
                        search= '',
                        filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>>{
         const offset = page > 1 ? (page - 1) * limit : 0
@@ -116,7 +122,11 @@ class RoleSqliteRepository implements IRoleRepository{
             where = ` WHERE name LIKE '%${search}%'`
         }
 
+        where = SqlQueryFilter.applyFilters(where, filters)
+        const sort = SqlSort.applySort(orderBy, order)
+
         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]);
 
         for (const role of roles) {

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -4,7 +4,7 @@ import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
-import {SqliteErrorToValidationError, SqliteTableBuilder} from "@drax/common-back";
+import {SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort} from "@drax/common-back";
 import type {SqliteTableField} from "@drax/common-back";
 
 
@@ -118,7 +118,7 @@ class TenantSqliteRepository implements ITenantRepository{
                        page= 1,
                        limit= 5,
                        orderBy= '',
-                       orderDesc= false,
+                       order= false,
                        search= '',
                        filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>>{
         const offset = page > 1 ? (page - 1) * limit : 0
@@ -128,7 +128,11 @@ class TenantSqliteRepository implements ITenantRepository{
             where = ` WHERE name LIKE '%${search}%'`
         }
 
+        where = SqlQueryFilter.applyFilters(where, filters)
+        const sort = SqlSort.applySort(orderBy, order)
+
         const rCount = this.db.prepare('SELECT COUNT(*) as count FROM tenants'+where).get();
+        where += sort
         const tenants = this.db.prepare('SELECT * FROM tenants '  + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
 
         return {

package/src/repository/sqlite/UserApiKeySqliteRepository.ts

@@ -4,7 +4,7 @@ import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
-import {SqliteErrorToValidationError, SqliteTableBuilder} from "@drax/common-back";
+import {SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort} from "@drax/common-back";
 import type {SqliteTableField} from "@drax/common-back";
 import UserSqliteRepository from "./UserSqliteRepository.js";
 
@@ -146,7 +146,7 @@ class UserApiKeySqliteRepository implements IUserApiKeyRepository {
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       orderDesc = false,
+                       order = false,
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
@@ -157,24 +157,13 @@ class UserApiKeySqliteRepository implements IUserApiKeyRepository {
             where = ` WHERE name LIKE '%${search}%'`
         }
 
-        let whereFilters= []
-        if(filters && filters.length > 0 ){
-            where = where ? ` AND ` : ` WHERE `
-            for(const filter of filters){
-                if(['eq','$eq'].includes(filter.operator)){
-                    whereFilters.push(` ${filter.field} = '${filter.value}' `)
-                }
-                if(['ne','$ne'].includes(filter.operator)){
-                    whereFilters.push(` ${filter.field} != '${filter.value}' `)
-                }
-                if(['in','$in'].includes(filter.operator)){
-                    whereFilters.push(` ${filter.field} LIKE '%${filter.value}%' `)
-                }
-            }
-            where += whereFilters.join(" AND ")
-        }
+        where = SqlQueryFilter.applyFilters(where, filters)
+        const sort = SqlSort.applySort(orderBy, order)
+
+        console.log("where", where)
 
         const rCount = this.db.prepare('SELECT COUNT(*) as count FROM user_api_keys' + where).get();
+        where += sort
         const userApiKeys = this.db.prepare('SELECT * FROM user_api_keys ' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
 
         for (const userApiKey of userApiKeys) {

package/src/repository/sqlite/UserSqliteRepository.ts

@@ -4,7 +4,13 @@ import {randomUUID} from "node:crypto";
 import {UUID} from "crypto";
 import {IUserRepository} from "../../interfaces/IUserRepository";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
-import {SqliteErrorToValidationError, SqliteTableBuilder, ValidationError} from "@drax/common-back";
+import {
+    SqliteErrorToValidationError,
+    SqliteTableBuilder,
+    SqlQueryFilter,
+    SqlSort,
+    ValidationError
+} from "@drax/common-back";
 import type {SqliteTableField} from "@drax/common-back";
 import RoleSqliteRepository from "./RoleSqliteRepository.js";
 import TenantSqliteRepository from "./TenantSqliteRepository.js";
@@ -148,7 +154,7 @@ class UserSqliteRepository implements IUserRepository {
                        page= 1,
                        limit= 5,
                        orderBy= '',
-                       orderDesc= false,
+                       order= false,
                        search= '',
                        filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
 
@@ -159,27 +165,14 @@ class UserSqliteRepository implements IUserRepository {
             where = ` WHERE (name LIKE '%${search}%' OR username LIKE '%${search}%') `
         }
 
-        let whereFilters= []
-        if(filters && filters.length > 0 ){
-            where = where ? ` AND ` : ` WHERE `
-            for(const filter of filters){
-                if(['eq','$eq'].includes(filter.operator)){
-                    whereFilters.push(` ${filter.field} = '${filter.value}' `)
-                }
-                if(['ne','$ne'].includes(filter.operator)){
-                    whereFilters.push(` ${filter.field} != '${filter.value}' `)
-                }
-                if(['in','$in'].includes(filter.operator)){
-                    whereFilters.push(` ${filter.field} LIKE '%${filter.value}%' `)
-                }
-            }
-            where += whereFilters.join(" AND ")
-        }
+        where = SqlQueryFilter.applyFilters(where, filters)
+        const sort = SqlSort.applySort(orderBy, order)
 
-        console.log("paginate where ", where, "search", search, "filters", filters, "whereFilters", whereFilters)
 
-        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM users' + where).get();
+        console.log("paginate where ", where, "search", search, "filters", filters)
 
+        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM users' + where).get();
+        where += sort
         const users = this.db.prepare('SELECT * FROM users'  + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
 
         for (const user of users) {

package/src/routes/RoleRoutes.ts

@@ -102,10 +102,10 @@ async function RoleRoutes(fastify, options) {
             const page = request.query.page
             const limit = request.query.limit
             const orderBy = request.query.orderBy
-            const orderDesc = request.query.orderDesc
+            const order = request.query.order
             const search = request.query.search
             const roleService = RoleServiceFactory()
-            let paginateResult = await roleService.paginate({page, limit, search, orderBy, orderDesc})
+            let paginateResult = await roleService.paginate({page, limit, search, orderBy, order})
             return paginateResult
         } catch (e) {
             console.error(e)

package/src/routes/TenantRoutes.ts

@@ -84,10 +84,10 @@ async function TenantRoutes(fastify, options) {
             const page = request.query.page
             const limit = request.query.limit
             const orderBy = request.query.orderBy
-            const orderDesc = request.query.orderDesc
+            const order = request.query.order
             const search = request.query.search
             const tenantService = TenantServiceFactory()
-            let paginateResult = await tenantService.paginate({page, limit,orderBy, orderDesc, search})
+            let paginateResult = await tenantService.paginate({page, limit,orderBy, order, search})
             return paginateResult
         } catch (e) {
             console.error(e)

package/src/routes/UserApiKeyRoutes.ts

@@ -27,12 +27,12 @@ async function UserApiKeyRoutes(fastify, options) {
             const page = request.query.page
             const limit = request.query.limit
             const orderBy = request.query.orderBy
-            const orderDesc = request.query.orderDesc
+            const order = request.query.order
             const search = request.query.search
             const userApiKeyService = UserApiKeyServiceFactory()
 
 
-            let paginateResult = await userApiKeyService.paginate({page, limit, orderBy, orderDesc, search, filters})
+            let paginateResult = await userApiKeyService.paginate({page, limit, orderBy, order, search, filters})
             return paginateResult
         } catch (e) {
             console.log("/api/user-api-keys",e)

package/src/routes/UserRoutes.ts

@@ -62,14 +62,14 @@ async function UserRoutes(fastify, options) {
             const page = request.query.page
             const limit = request.query.limit
             const orderBy = request.query.orderBy
-            const orderDesc = request.query.orderDesc
+            const order = request.query.order
             const search = request.query.search
             const userService = UserServiceFactory()
             const filters = []
             if(request.rbac.getAuthUser.tenantId){
-                filters.push({field: 'tenant', operator: '$eq', value: request.rbac.getAuthUser.tenantId})
+                filters.push({field: 'tenant', operator: 'eq', value: request.rbac.getAuthUser.tenantId})
             }
-            let paginateResult = await userService.paginate({page, limit, orderBy, orderDesc, search, filters})
+            let paginateResult = await userService.paginate({page, limit, orderBy, order, search, filters})
             for(let item of paginateResult.items){
                 item.password = undefined
                 delete item.password

package/src/services/RoleService.ts

@@ -85,12 +85,12 @@ class RoleService {
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       orderDesc = false,
+                       order = false,
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
         try{
-            const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
+            const pagination = await this._repository.paginate({page, limit, orderBy, order, search, filters});
             return pagination;
         }catch (e){
             console.error("Error paginating roles", e)

package/src/services/TenantService.ts

@@ -92,12 +92,12 @@ class TenantService {
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       orderDesc = false,
+                       order = false,
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
         try {
-            const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
+            const pagination = await this._repository.paginate({page, limit, orderBy, order, search, filters});
             return pagination;
         } catch (e) {
             console.error("Error paginating tenants", e)

package/src/services/UserApiKeyService.ts

@@ -92,12 +92,12 @@ class UserApiKeyService {
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       orderDesc = false,
+                       order = false,
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
         try {
-            const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
+            const pagination = await this._repository.paginate({page, limit, orderBy, order, search, filters});
             return pagination;
         } catch (e) {
             console.error("Error paginating userApiKeys", e)

package/src/services/UserService.ts

@@ -158,12 +158,12 @@ class UserService {
                        page = 1,
                        limit = 5,
                        orderBy = '',
-                       orderDesc = false,
+                       order = false,
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
         try {
-            const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
+            const pagination = await this._repository.paginate({page, limit, orderBy, order, search, filters});
             return pagination;
         } catch (e) {
             console.error("Error paginating users", e)