@drax/crud-back 0.7.15 → 0.7.18

package/dist/controllers/AbstractFastifyController.js

@@ -196,6 +196,72 @@ class AbstractFastifyController {
             }
         }
     }
+    async find(request, reply) {
+        var _a;
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            if (!request.params.field || !request.params.value) {
+                reply.statusCode = 400;
+                reply.send({ error: 'BAD REQUEST' });
+            }
+            const search = (_a = request.query).search ?? (_a.search = undefined);
+            const filters = this.parseFilters(request.query.filters);
+            this.applyUserAndTenantFilters(filters, request.rbac);
+            let items = await this.service.find({ search, filters });
+            if (this.tenantAssert) {
+                items = items.filter(item => request.rbac.tenantId === item[this.tenantField].id);
+            }
+            return items;
+        }
+        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 findOne(request, reply) {
+        var _a;
+        try {
+            request.rbac.assertPermission(this.permission.View);
+            if (!request.params.field || !request.params.value) {
+                reply.statusCode = 400;
+                reply.send({ error: 'BAD REQUEST' });
+            }
+            const search = (_a = request.query).search ?? (_a.search = undefined);
+            const filters = this.parseFilters(request.query.filters);
+            this.applyUserAndTenantFilters(filters, request.rbac);
+            let item = await this.service.findOne({ search, filters });
+            if (this.tenantAssert) {
+                request.rbac.assertTenantId(item[this.tenantField].id);
+            }
+            return item;
+        }
+        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 findBy(request, reply) {
         try {
             request.rbac.assertPermission(this.permission.View);

package/dist/repository/AbstractMongoRepository.js

@@ -33,6 +33,18 @@ class AbstractMongoRepository {
             throw e;
         }
     }
+    async updatePartial(id, data) {
+        try {
+            const item = await this._model.findOneAndUpdate({ _id: id }, data, { new: true }).populate(this._populateFields).exec();
+            return item;
+        }
+        catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e);
+            }
+            throw e;
+        }
+    }
     async delete(id) {
         const result = await this._model.deleteOne({ _id: id }).exec();
         return result.deletedCount == 1;
@@ -85,6 +97,15 @@ class AbstractMongoRepository {
             items: items.docs
         };
     }
+    async findOne({ search = '', filters = [] }) {
+        const query = {};
+        if (search) {
+            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search, 'i') }));
+        }
+        MongooseQueryFilter.applyFilters(query, filters);
+        const populate = this._populateFields;
+        return this._model.findOne(query).populate(populate);
+    }
     async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
         const query = {};
         if (search) {

package/dist/services/AbstractService.js

@@ -45,6 +45,19 @@ class AbstractService {
             throw e;
         }
     }
+    async updatePartial(id, data) {
+        try {
+            const item = await this._repository.updatePartial(id, data);
+            return item;
+        }
+        catch (e) {
+            console.error("Error updating", e);
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data);
+            }
+            throw e;
+        }
+    }
     async delete(id) {
         try {
             const result = await this._repository.delete(id);
@@ -155,7 +168,17 @@ class AbstractService {
             return items;
         }
         catch (e) {
-            console.error("Error paginating", e);
+            console.error("Error find", e);
+            throw e;
+        }
+    }
+    async findOne({ search = '', filters = [] }) {
+        try {
+            let item = await this._repository.findOne({ search, filters });
+            return item;
+        }
+        catch (e) {
+            console.error("Error findOne", e);
             throw e;
         }
     }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.7.15",
+  "version": "0.7.18",
   "description": "Crud utils across modules",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -25,7 +25,7 @@
     "@drax/common-back": "^0.7.0",
     "@drax/common-share": "^0.7.0",
     "@drax/identity-share": "^0.7.0",
-    "@drax/media-back": "^0.7.15",
+    "@drax/media-back": "^0.7.18",
     "@graphql-tools/load-files": "^7.0.0",
     "@graphql-tools/merge": "^9.0.4",
     "mongoose": "^8.6.3",
@@ -44,5 +44,5 @@
     "tsc-alias": "^1.8.10",
     "typescript": "^5.6.2"
   },
-  "gitHead": "d1b96ce648f538b1b70bd9cecbdbfc1dc39b282a"
+  "gitHead": "c6bef958c68e2738724b77cc877e98108476c2a7"
 }

package/src/controllers/AbstractFastifyController.ts

@@ -241,6 +241,75 @@ class AbstractFastifyController<T, C, U> {
         }
     }
 
+    async find(request: CustomRequest, reply: FastifyReply):Promise<T[]> {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+            if (!request.params.field || !request.params.value) {
+                reply.statusCode = 400
+                reply.send({error: 'BAD REQUEST'})
+            }
+
+            const search = request.query.search ??= undefined
+            const filters = this.parseFilters(request.query.filters)
+
+            this.applyUserAndTenantFilters(filters, request.rbac);
+
+            let items = await this.service.find({search,filters})
+
+            if (this.tenantAssert) {
+                items = items.filter(item => request.rbac.tenantId === item[this.tenantField].id)
+            }
+            return items
+        } 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 findOne(request: CustomRequest, reply: FastifyReply):Promise<T> {
+        try {
+            request.rbac.assertPermission(this.permission.View)
+            if (!request.params.field || !request.params.value) {
+                reply.statusCode = 400
+                reply.send({error: 'BAD REQUEST'})
+            }
+
+            const search = request.query.search ??= undefined
+            const filters = this.parseFilters(request.query.filters)
+
+            this.applyUserAndTenantFilters(filters, request.rbac);
+
+            let item = await this.service.findOne({search,filters})
+
+            if (this.tenantAssert) {
+                request.rbac.assertTenantId(item[this.tenantField].id)
+            }
+
+            return item
+        } 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 findBy(request: CustomRequest, reply: FastifyReply):Promise<T[]> {
         try {
             request.rbac.assertPermission(this.permission.View)

package/src/repository/AbstractMongoRepository.ts

@@ -42,6 +42,18 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         }
     }
 
+    async updatePartial(id: string, data: any): Promise<T> {
+        try {
+            const item: mongoose.HydratedDocument<T> = await this._model.findOneAndUpdate({_id: id}, data, {new: true}).populate(this._populateFields).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 this._model.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
@@ -118,6 +130,23 @@ class AbstractMongoRepository<T, C, U> implements IDraxCrud<T, C, U> {
         }
     }
 
+    async findOne({
+                   search = '',
+                   filters = []
+               }: IDraxFindOptions): Promise<T> {
+
+        const query = {}
+
+        if (search) {
+            query['$or'] = this._searchFields.map(field => ({[field]: new RegExp(search, 'i')}))
+        }
+
+        MongooseQueryFilter.applyFilters(query, filters)
+
+        const populate = this._populateFields
+        return this._model.findOne(query).populate(populate)
+    }
+
     async find({
                    limit = 0,
                    orderBy = '',

package/src/services/AbstractService.ts

@@ -12,6 +12,7 @@ import {IDraxCrudService} from "@drax/crud-share";
 import ExportCsv from "../exports/ExportCsv.js";
 import ExportJson from "../exports/ExportJson.js";
 import {IDraxExportResult} from "@drax/crud-share";
+import {IDraxFindOneOptions} from "@drax/crud-share/types/interfaces/IDraxFindOneOptions";
 
 abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
 
@@ -69,6 +70,21 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
         }
     }
 
+    async updatePartial(id: string, data: any): Promise<T> {
+        try {
+
+            const item: T = await this._repository.updatePartial(id, data)
+
+            return item
+        } catch (e) {
+            console.error("Error updating", e)
+            if (e instanceof ZodError) {
+                throw ZodErrorToValidationError(e, data)
+            }
+            throw e
+        }
+    }
+
     async delete(id: string): Promise<boolean> {
         try {
             const result: boolean = await this._repository.delete(id);
@@ -198,7 +214,21 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
             let items = await this._repository.find({orderBy, order, search, filters});
             return items;
         } catch (e) {
-            console.error("Error paginating", e)
+            console.error("Error find", e)
+            throw e;
+        }
+
+    }
+
+    async findOne({
+                   search = '',
+                   filters = []
+               }: IDraxFindOneOptions): Promise<T> {
+        try {
+            let item = await this._repository.findOne({ search, filters});
+            return item;
+        } catch (e) {
+            console.error("Error findOne", e)
             throw e;
         }