@drax/identity-back 0.5.3 → 0.5.5

package/dist/controllers/RoleController.js

@@ -0,0 +1,84 @@
+import { AbstractFastifyController } from "@drax/crud-back";
+import { ValidationError, UnauthorizedError } from "@drax/common-back";
+import RoleServiceFactory from "../factory/RoleServiceFactory.js";
+import RolePermissions from "../permissions/RolePermissions.js";
+import PermissionService from "../services/PermissionService.js";
+class RoleController extends AbstractFastifyController {
+    constructor() {
+        super(RoleServiceFactory(), RolePermissions);
+    }
+    async findByName(request, reply) {
+        try {
+            request.rbac.assertPermission(RolePermissions.View);
+            const name = request.params.name;
+            const roleService = RoleServiceFactory();
+            let role = await roleService.findByName(name);
+            return role;
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+    async all(request, reply) {
+        try {
+            request.rbac.assertPermission(RolePermissions.View);
+            const roleService = RoleServiceFactory();
+            let roles = await roleService.fetchAll();
+            if (request.rbac.getRole?.childRoles?.length > 0) {
+                return roles.filter(role => request.rbac.getRole.childRoles.some(childRole => childRole.id === role.id));
+            }
+            else {
+                return roles;
+            }
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+    async permissions(request, reply) {
+        try {
+            request.rbac.assertPermission(RolePermissions.Permissions);
+            let permissions = PermissionService.getPermissions();
+            return permissions;
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+    async xxxx(request, reply) {
+    }
+}
+export default RoleController;
+export { RoleController };

package/dist/controllers/TenantController.js

@@ -1,8 +1,7 @@
 import { AbstractFastifyController } from "@drax/crud-back";
-import { ValidationError } from "@drax/common-back";
+import { ValidationError, UnauthorizedError } from "@drax/common-back";
 import TenantServiceFactory from "../factory/TenantServiceFactory.js";
 import TenantPermissions from "../permissions/TenantPermissions.js";
-import { UnauthorizedError } from "@drax/common-back";
 class TenantController extends AbstractFastifyController {
     constructor() {
         super(TenantServiceFactory(), TenantPermissions);

package/dist/controllers/UserApiKeyController.js

@@ -0,0 +1,127 @@
+import { AbstractFastifyController } from "@drax/crud-back";
+import { ValidationError, UnauthorizedError } from "@drax/common-back";
+import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
+import UserApiKeyPermissions from "../permissions/UserApiKeyPermissions.js";
+class UserApiKeyController extends AbstractFastifyController {
+    constructor() {
+        super(UserApiKeyServiceFactory(), UserApiKeyPermissions);
+    }
+    async paginate(request, reply) {
+        try {
+            request.rbac.assertAuthenticated();
+            request.rbac.assertOrPermissions([
+                UserApiKeyPermissions.View,
+                UserApiKeyPermissions.ViewMy
+            ]);
+            const filters = [];
+            if (!request.rbac.hasPermission(UserApiKeyPermissions.View)) {
+                filters.push({ field: "user", operator: "eq", value: request.rbac.authUser.id });
+            }
+            const page = request.query.page;
+            const limit = request.query.limit;
+            const orderBy = request.query.orderBy;
+            const order = request.query.order;
+            const search = request.query.search;
+            const userApiKeyService = UserApiKeyServiceFactory();
+            let paginateResult = await userApiKeyService.paginate({ page, limit, orderBy, order, search, filters });
+            return paginateResult;
+        }
+        catch (e) {
+            console.log("/api/user-api-keys", e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async create(request, reply) {
+        try {
+            request.rbac.assertPermission(UserApiKeyPermissions.Create);
+            const payload = request.body;
+            payload.user = request.rbac.authUser.id;
+            const userApiKeyService = UserApiKeyServiceFactory();
+            let userApiKey = await userApiKeyService.create(payload);
+            return userApiKey;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async update(request, reply) {
+        try {
+            request.rbac.assertPermission(UserApiKeyPermissions.Update);
+            const id = request.params.id;
+            const payload = request.body;
+            const userApiKeyService = UserApiKeyServiceFactory();
+            let userApiKey = await userApiKeyService.update(id, payload);
+            return userApiKey;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async delete(request, reply) {
+        try {
+            request.rbac.assertPermission(UserApiKeyPermissions.Delete);
+            const id = request.params.id;
+            const userApiKeyService = UserApiKeyServiceFactory();
+            let r = await userApiKeyService.delete(id);
+            if (r) {
+                reply.send({ message: 'Deleted successfully' });
+            }
+            else {
+                reply.statusCode(400).send({ message: 'Not deleted' });
+            }
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+}
+export default UserApiKeyController;
+export { UserApiKeyController };

package/dist/controllers/UserController.js

@@ -0,0 +1,295 @@
+import { AbstractFastifyController } from "@drax/crud-back";
+import { CommonConfig, DraxConfig, StoreManager, UploadFileError, ValidationError, UnauthorizedError } from "@drax/common-back";
+import UserServiceFactory from "../factory/UserServiceFactory.js";
+import UserPermissions from "../permissions/UserPermissions.js";
+import BadCredentialsError from "../errors/BadCredentialsError.js";
+import { join } from "path";
+import { IdentityConfig } from "../config/IdentityConfig.js";
+const BASE_FILE_DIR = DraxConfig.getOrLoad(CommonConfig.FileDir) || 'files';
+const AVATAR_DIR = DraxConfig.getOrLoad(IdentityConfig.AvatarDir) || 'avatar';
+const BASE_URL = DraxConfig.getOrLoad(CommonConfig.BaseUrl) ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, '') : '';
+class UserController extends AbstractFastifyController {
+    constructor() {
+        super(UserServiceFactory(), UserPermissions);
+    }
+    async auth(request, reply) {
+        try {
+            const username = request.body.username;
+            const password = request.body.password;
+            const userService = UserServiceFactory();
+            return await userService.auth(username, password);
+        }
+        catch (e) {
+            console.error('/api/auth error', e);
+            if (e instanceof BadCredentialsError) {
+                reply.code(401);
+                reply.send({ error: e.message });
+            }
+            reply.code(500);
+            reply.send({ error: 'error.server' });
+        }
+    }
+    async me(request, reply) {
+        try {
+            if (request.authUser) {
+                const userService = UserServiceFactory();
+                let user = await userService.findById(request.authUser.id);
+                user.password = undefined;
+                delete user.password;
+                return user;
+            }
+            else {
+                throw new UnauthorizedError();
+            }
+        }
+        catch (e) {
+            if (e instanceof UnauthorizedError) {
+                reply.code(401);
+                reply.send({ error: "Unauthorized" });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async paginate(request, reply) {
+        try {
+            request.rbac.assertPermission(UserPermissions.View);
+            const page = request.query.page;
+            const limit = request.query.limit;
+            const orderBy = request.query.orderBy;
+            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 });
+            }
+            let paginateResult = await userService.paginate({ page, limit, orderBy, order, search, filters });
+            for (let item of paginateResult.items) {
+                item.password = undefined;
+                delete item.password;
+            }
+            return paginateResult;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async create(request, reply) {
+        try {
+            request.rbac.assertPermission(UserPermissions.Create);
+            const payload = request.body;
+            const userService = UserServiceFactory();
+            if (request.rbac.getAuthUser.tenantId) {
+                payload.tenant = request.rbac.getAuthUser.tenantId;
+            }
+            let user = await userService.create(payload);
+            return user;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async update(request, reply) {
+        try {
+            request.rbac.assertPermission(UserPermissions.Update);
+            const id = request.params.id;
+            const payload = request.body;
+            const userService = UserServiceFactory();
+            if (request.rbac.getAuthUser.tenantId) {
+                payload.tenant = request.rbac.getAuthUser.tenantId;
+            }
+            let user = await userService.update(id, payload);
+            return user;
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async delete(request, reply) {
+        try {
+            request.rbac.assertPermission(UserPermissions.Delete);
+            const id = request.params.id;
+            const userService = UserServiceFactory();
+            let r = await userService.delete(id);
+            if (r) {
+                reply.send({ message: 'Deleted successfully' });
+            }
+            else {
+                reply.statusCode(400).send({ message: 'Not deleted' });
+            }
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async myPassword(request, reply) {
+        try {
+            if (!request.authUser) {
+                throw new UnauthorizedError();
+            }
+            const userId = request.authUser.id;
+            const currentPassword = request.body.currentPassword;
+            const newPassword = request.body.newPassword;
+            const userService = UserServiceFactory();
+            return await userService.changeOwnPassword(userId, currentPassword, newPassword);
+        }
+        catch (e) {
+            console.error('/api/password error', e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async password(request, reply) {
+        try {
+            request.rbac.assertPermission(UserPermissions.Update);
+            const userId = request.params.id;
+            if (!userId) {
+                throw new UnauthorizedError();
+            }
+            const newPassword = request.body.newPassword;
+            const userService = UserServiceFactory();
+            return await userService.changeUserPassword(userId, newPassword);
+        }
+        catch (e) {
+            console.error('/api/password error', e);
+            if (e instanceof ValidationError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message, inputErrors: e.errors });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'error.server' });
+            }
+        }
+    }
+    async updateAvatar(request, reply) {
+        try {
+            request.rbac.assertAuthenticated();
+            const userId = request.rbac.getAuthUser.id;
+            const data = await request.file();
+            const file = {
+                filename: data.filename,
+                fileStream: data.file,
+                mimetype: data.mimetype
+            };
+            const destinationPath = join(BASE_FILE_DIR, AVATAR_DIR);
+            const storedFile = await StoreManager.saveFile(file, destinationPath);
+            const urlFile = BASE_URL + '/api/user/avatar/' + storedFile.filename;
+            //Save into DB
+            const userService = UserServiceFactory();
+            await userService.changeAvatar(userId, urlFile);
+            return {
+                filename: storedFile.filename,
+                size: storedFile.size,
+                mimetype: storedFile.mimetype,
+                url: urlFile,
+            };
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof UploadFileError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+    async getAvatar(request, reply) {
+        try {
+            const filename = request.params.filename;
+            const subPath = 'avatar';
+            const fileDir = join(BASE_FILE_DIR, subPath);
+            //console.log("FILE_DIR: ",fileDir, " FILENAME:", filename)
+            return reply.sendFile(filename, fileDir);
+        }
+        catch (e) {
+            console.error(e);
+            if (e instanceof UnauthorizedError) {
+                reply.statusCode = e.statusCode;
+                reply.send({ error: e.message });
+            }
+            else {
+                reply.statusCode = 500;
+                reply.send({ error: 'INTERNAL_SERVER_ERROR' });
+            }
+        }
+    }
+}
+export default UserController;
+export { UserController };

package/dist/index.js

@@ -8,7 +8,6 @@ import TenantService from "./services/TenantService.js";
 import PermissionService from "./services/PermissionService.js";
 import Rbac from "./rbac/Rbac.js";
 import { UserRoutes } from "./routes/UserRoutes.js";
-import { UserAvatarRoutes } from "./routes/UserAvatarRoutes.js";
 import { RoleRoutes } from "./routes/RoleRoutes.js";
 import { TenantRoutes } from "./routes/TenantRoutes.js";
 import { UserApiKeyRoutes } from "./routes/UserApiKeyRoutes.js";
@@ -39,7 +38,7 @@ UserServiceFactory, RoleServiceFactory, TenantServiceFactory,
 //GQL
 identityTypeDefs, identityResolvers, 
 //API REST
-UserRoutes, RoleRoutes, TenantRoutes, UserAvatarRoutes, UserApiKeyRoutes, AuthUtils, 
+UserRoutes, RoleRoutes, TenantRoutes, UserApiKeyRoutes, AuthUtils, 
 //API MIDDLEWARE
 jwtMiddleware, rbacMiddleware, apiKeyMiddleware, 
 //Permissions

package/dist/repository/mongo/RoleMongoRepository.js

@@ -1,6 +1,9 @@
 import { RoleModel } from "../../models/RoleModel.js";
 import { MongooseQueryFilter, MongooseSort } from "@drax/common-back";
 class RoleMongoRepository {
+    constructor() {
+        this._searchFields = ['name'];
+    }
     async create(roleData) {
         const role = new RoleModel(roleData);
         await role.save();
@@ -27,12 +30,18 @@ class RoleMongoRepository {
         const roles = await RoleModel.find().populate('childRoles').exec();
         return roles;
     }
+    async search(value, limit = 1000) {
+        const query = {};
+        if (value) {
+            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(value.toString(), 'i') }));
+        }
+        const items = await RoleModel.find(query).limit(limit).exec();
+        return items;
+    }
     async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
         const query = {};
         if (search) {
-            query['$or'] = [
-                { name: new RegExp(search, 'i') },
-            ];
+            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
         }
         MongooseQueryFilter.applyFilters(query, filters);
         const sort = MongooseSort.applySort(orderBy, order);
@@ -45,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

@@ -1,6 +1,9 @@
 import { TenantModel } from "../../models/TenantModel.js";
 import { MongooseSort, MongooseQueryFilter } from "@drax/common-back";
 class TenantMongoRepository {
+    constructor() {
+        this._searchFields = ['_id', 'name'];
+    }
     async create(tenantData) {
         const tenant = new TenantModel(tenantData);
         await tenant.save();
@@ -26,6 +29,14 @@ class TenantMongoRepository {
         const tenants = await TenantModel.find().exec();
         return tenants;
     }
+    async search(value, limit = 1000) {
+        const query = {};
+        if (value) {
+            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(value.toString(), 'i') }));
+        }
+        const items = await TenantModel.find(query).limit(limit).exec();
+        return items;
+    }
     async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
         const query = {};
         if (search) {
@@ -44,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'] = [
@@ -53,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}%'`;