@drax/crud-back 1.1.1 → 1.3.0

package/src/services/AbstractService.ts

@@ -17,8 +17,10 @@ import {IDraxFindOneOptions} from "@drax/crud-share/types/interfaces/IDraxFindOn
 abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
 
     protected _repository: IDraxCrudRepository<T, C, U>
-    protected _schema?: ZodObject<ZodRawShape> | undefined
+    protected _baseSchema?: ZodObject<ZodRawShape> | undefined
+    protected _fullSchema?: ZodObject<ZodRawShape> | undefined
     protected _defaultOrder?: string | undefined
+    protected _validateOutput: boolean = true
 
     transformCreate?: (data: C) => Promise<C>;
     transformUpdate?: (data: U) => Promise<U>;
@@ -29,88 +31,139 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
     onDeleted?: (id: string) => Promise<void>;
 
 
-
-    constructor(repository: IDraxCrudRepository<T, C, U>, schema?: ZodObject<ZodRawShape>) {
+    constructor(repository: IDraxCrudRepository<T, C, U>, baseSchema?: ZodObject<ZodRawShape>, fullSchema?: ZodObject<ZodRawShape>) {
         this._repository = repository
-        this._schema = schema
+        this._baseSchema = baseSchema
+        this._fullSchema = fullSchema
     }
 
-
-    async create(data: C): Promise<T> {
-        try {
-            if (this._schema) {
-                data = await this._schema.parseAsync(data) as C
+    async validateInputCreate(data: C): Promise<C> {
+        if (this._baseSchema) {
+            try {
+                return await this._baseSchema.parseAsync(data) as C
+            } catch (e) {
+                console.error("Error on validateInput", {
+                    name: e?.name,
+                    message: e?.message,
+                    stack: e?.stack,
+                });
+                if (e instanceof ZodError) {
+                    throw ZodErrorToValidationError(e, data)
+                }
+                throw e
             }
-            if (this.transformCreate) {
-                data = await this.transformCreate(data)
+        }
+        return data
+    }
+
+    async validateInputUpdate(data: U): Promise<U> {
+        if (this._baseSchema) {
+            try {
+                return await this._baseSchema.parseAsync(data) as U
+            } catch (e) {
+                console.error("Error on validateInput", {
+                    name: e?.name,
+                    message: e?.message,
+                    stack: e?.stack,
+                });
+                if (e instanceof ZodError) {
+                    throw ZodErrorToValidationError(e, data)
+                }
+                throw e
             }
-            const item: T = await this._repository.create(data)
-            if (this.onCreated) {
-                await this.onCreated(item)
+        }
+        return data
+    }
+
+    async validateInputUpdatePartial(data: U): Promise<U> {
+        if (this._baseSchema) {
+            try {
+                return await this._baseSchema.partial().parseAsync(data) as U
+            } catch (e) {
+                console.error("Error on validateInput", {
+                    name: e?.name,
+                    message: e?.message,
+                    stack: e?.stack,
+                });
+                if (e instanceof ZodError) {
+                    throw ZodErrorToValidationError(e, data)
+                }
+                throw e
             }
-            return item
-        } catch (e) {
-            console.error("Error create", {
-                name: e?.name,
-                message: e?.message,
-                stack: e?.stack,
-            });
-            if (e instanceof ZodError) {
-                throw ZodErrorToValidationError(e, data)
+        }
+        return data
+    }
+
+    async validateOutput(item: T): Promise<T> {
+        if (this._validateOutput && item && this._fullSchema) {
+            try {
+                return await this._fullSchema.parseAsync(item) as T
+            } catch (e) {
+                console.error("Error on validateOutput", {
+                    name: e?.name,
+                    message: e?.message,
+                    stack: e?.stack,
+                });
+                throw e
             }
-            throw e
         }
+        return item
+    }
+
+    async create(data: C): Promise<T> {
+
+        data = await this.validateInputCreate(data)
+
+        if (this.transformCreate) {
+            data = await this.transformCreate(data)
+        }
+
+        let item: T = await this._repository.create(data)
+
+        if (this.onCreated) {
+            await this.onCreated(item)
+        }
+
+        item = await this.validateOutput(item)
+
+        return item
+
     }
 
     async update(id: string, data: U): Promise<T> {
-        try {
-            if (this._schema) {
-                data = await this._schema.parseAsync(data) as U
-            }
-            if (this.transformUpdate) {
-                data = await this.transformUpdate(data)
-            }
-            const item: T = await this._repository.update(id, data)
-            if (this.onUpdated) {
-                await this.onUpdated(item)
-            }
-            return item
-        } catch (e) {
-            console.error("Error update", {
-                name: e?.name,
-                message: e?.message,
-                stack: e?.stack,
-            });
-            if (e instanceof ZodError) {
-                throw ZodErrorToValidationError(e, data)
-            }
-            throw e
+
+        data = await this.validateInputUpdate(data)
+
+        if (this.transformUpdate) {
+            data = await this.transformUpdate(data)
         }
+
+        let item: T = await this._repository.update(id, data)
+
+        if (this.onUpdated) {
+            await this.onUpdated(item)
+        }
+
+        item = await this.validateOutput(item)
+
+        return item
+
     }
 
     async updatePartial(id: string, data: any): Promise<T> {
-        try {
 
-            if (this._schema) {
-                data = await this._schema.partial().parseAsync(data)
-            }
+        data = await this.validateInputUpdatePartial(data)
 
-            const item: T = await this._repository.updatePartial(id, data)
-            if (this.onUpdated) {
-                await this.onUpdated(item)
-            }
-            return item
-        } catch (e) {
-            console.error("Error updatePartial", {
-                name: e?.name,
-                message: e?.message,
-                stack: e?.stack,
-            });
-            if (e instanceof ZodError) {
-                throw ZodErrorToValidationError(e, data)
-            }
-            throw e
+        let item: T = await this._repository.updatePartial(id, data)
+
+        if (this.onUpdated) {
+            await this.onUpdated(item)
         }
+
+        item = await this.validateOutput(item)
+
+        return item
+
     }
 
     async delete(id: string): Promise<boolean> {
@@ -119,7 +172,7 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
             if (!result) {
                 throw new Error("error.deletionFailed");
             }
-            if(this.onDeleted) {
+            if (this.onDeleted) {
                 await this.onDeleted(id)
             }
             return result;
@@ -136,11 +189,17 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
 
     async findById(id: string): Promise<T | null> {
         try {
-            let item: T = await this._repository.findById(id);
+
+            let item: T = await this._repository.findById(id)
+
             if (item && this.transformRead) {
                 item = await this.transformRead(item)
             }
+
+            item = await this.validateOutput(item)
+
             return item
+
         } catch (e) {
             console.error("Error findById", {
                 name: e?.name,
@@ -151,32 +210,47 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
         }
     }
 
-    async findByIds(ids: Array<string>): Promise<T[]> {
+
+
+    async findOneBy(field: string, value: any): Promise<T | null> {
         try {
-            let items: T[] = await this._repository.findByIds(ids);
-            if (this.transformRead) {
-                items = await Promise.all(items.map(item => this.transformRead(item)))
+
+            let item: T = await this._repository.findOneBy(field, value)
+
+            if (item && this.transformRead) {
+                item = await this.transformRead(item)
             }
-            return items
+
+            item = await this.validateOutput(item)
+
+            return item
         } catch (e) {
-            console.error("Error findByIds", {
+            console.error("Error findOneBy", {
                 name: e?.name,
                 message: e?.message,
                 stack: e?.stack,
             });
             throw e;
         }
+
     }
 
-    async findOneBy(field: string, value: any): Promise<T | null> {
+    async findOne({
+                      search = '',
+                      filters = []
+                  }: IDraxFindOneOptions): Promise<T> {
         try {
-            let item: T = await this._repository.findOneBy(field, value);
+            let item = await this._repository.findOne({search, filters});
+
             if (item && this.transformRead) {
                 item = await this.transformRead(item)
             }
+
+            item = await this.validateOutput(item)
+
             return item
         } catch (e) {
-            console.error("Error findOneBy", {
+            console.error("Error findOne", {
                 name: e?.name,
                 message: e?.message,
                 stack: e?.stack,
@@ -186,6 +260,30 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
 
     }
 
+    async findByIds(ids: Array<string>): Promise<T[]> {
+        try {
+
+            let items: T[] = await this._repository.findByIds(ids)
+
+            if (this.transformRead) {
+                items = await Promise.all(items.map(item => this.transformRead(item)))
+            }
+
+            if(this._fullSchema){
+                items = await Promise.all(items.map(item => this.validateOutput(item)))
+            }
+
+            return items
+        } catch (e) {
+            console.error("Error findByIds", {
+                name: e?.name,
+                message: e?.message,
+                stack: e?.stack,
+            });
+            throw e;
+        }
+    }
+
     async findBy(field: string, value: any, limit: number = 1000): Promise<T[] | null> {
         try {
 
@@ -193,6 +291,9 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
             if (this.transformRead) {
                 items = await Promise.all(items.map(item => this.transformRead(item)))
             }
+            if(this._fullSchema){
+                items = await Promise.all(items.map(item => this.validateOutput(item)))
+            }
             return items
         } catch (e) {
             console.error("Error findBy", {
@@ -211,6 +312,9 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
             if (this.transformRead) {
                 items = await Promise.all(items.map(item => this.transformRead(item)))
             }
+            if(this._fullSchema){
+                items = await Promise.all(items.map(item => this.validateOutput(item)))
+            }
             return items
         } catch (e) {
             console.error("Error fetchAll", {
@@ -230,6 +334,9 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
             if (this.transformRead) {
                 items = await Promise.all(items.map(item => this.transformRead(item)))
             }
+            if(this._fullSchema){
+                items = await Promise.all(items.map(item => this.validateOutput(item)))
+            }
             return items
         } catch (e) {
             console.error("Error search", {
@@ -259,6 +366,10 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
                 pagination.items = await Promise.all(pagination.items.map(item => this.transformRead(item)))
             }
 
+            if(this._fullSchema){
+                pagination.items = await Promise.all(pagination.items.map(item => this.validateOutput(item)))
+            }
+
             return pagination;
         } catch (e) {
             console.error("Error paginate", {
@@ -284,6 +395,9 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
             if (this.transformRead) {
                 items = await Promise.all(items.map(item => this.transformRead(item)))
             }
+            if(this._fullSchema){
+                items = await Promise.all(items.map(item => this.validateOutput(item)))
+            }
             return items;
         } catch (e) {
             console.error("Error find", {
@@ -296,25 +410,9 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
 
     }
 
-    async findOne({
-                      search = '',
-                      filters = []
-                  }: IDraxFindOneOptions): Promise<T> {
-        try {
-            let item = await this._repository.findOne({search, filters});
-            return item;
-        } catch (e) {
-            console.error("Error findOne", {
-                name: e?.name,
-                message: e?.message,
-                stack: e?.stack,
-            });
-            throw e;
-        }
 
-    }
 
-    async groupBy({fields= [], filters= [], dateFormat= 'day'}: IDraxGroupByOptions): Promise<Array<any>> {
+    async groupBy({fields = [], filters = [], dateFormat = 'day'}: IDraxGroupByOptions): Promise<Array<any>> {
         return await this._repository.groupBy({fields, filters, dateFormat})
     }
 
@@ -346,7 +444,14 @@ abstract class AbstractService<T, C, U> implements IDraxCrudService<T, C, U> {
                     exporter = new ExportJson({cursor, destinationPath: destinationPath, headers, fileName});
                     return await exporter.process()
                 case 'CSV':
-                    exporter = new ExportCsv({cursor, destinationPath: destinationPath, headers, headersTranslate, fileName, separator});
+                    exporter = new ExportCsv({
+                        cursor,
+                        destinationPath: destinationPath,
+                        headers,
+                        headersTranslate,
+                        fileName,
+                        separator
+                    });
                     return await exporter.process()
                 default:
                     throw new Error(`Unsupported export format: ${format}`);