feat: adding changes related sales

Author: JoanVasquez

src/__tests__/repositories/BillRepository.test.ts

@@ -20,11 +20,30 @@ describe('BillRepository', () => {
 
   const testBill: Bill = {
     id: 1,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    customer: { id: 1 } as any,
+
+    customer: {
+      id: 1,
+      email: 'test@example.com',
+      first_name: 'John',
+      last_name: 'Doe',
+      bills: [],
+    },
     date: new Date(),
     total_amount: 50.0,
     sales: [],
+    toJSON: () => ({
+      id: 1,
+      customer: {
+        id: 1,
+        email: 'test@example.com',
+        first_name: 'John',
+        last_name: 'Doe',
+        bills: [],
+      },
+      date: new Date(),
+      total_amount: 50.0,
+      sales: [],
+    }),
   };
 
   beforeEach(() => {

src/__tests__/repositories/GenericRepository.test.ts

@@ -77,7 +77,9 @@ describe('GenericRepository', () => {
       expect(result).toEqual(testEntity);
       expect(mockRepository.save).toHaveBeenCalledWith(testEntity);
       expect(logger.info).toHaveBeenCalledWith(
-        expect.stringContaining(JSON.stringify(testEntity)),
+        expect.stringContaining(
+          `Created new entity: { id: 1, name: 'Test Entity' }`,
+        ),
       );
     });
 
@@ -88,14 +90,18 @@ describe('GenericRepository', () => {
       await expect(testRepository.createEntity(testEntity)).rejects.toThrow(
         DatabaseError,
       );
+
+      // ✅ Corrected logger.error expectation
       expect(logger.error).toHaveBeenCalledWith(
-        expect.stringContaining('Error creating entity:'),
-        { error },
+        expect.stringContaining('Error creating entity:'), // Matches the error message
+        {
+          stack: error.stack, // Match the error object correctly
+        },
       );
     });
 
     it('should throw DatabaseError with JSON stringified metadata when save fails with non-Error', async () => {
-      const plainError = { unexpected: true };
+      const plainError = { unexpected: true }; // Plain object error
       mockRepository.save.mockRejectedValue(plainError);
 
       try {
@@ -105,10 +111,15 @@ describe('GenericRepository', () => {
       } catch (err: unknown) {
         expect(err).toBeInstanceOf(DatabaseError);
         if (err instanceof DatabaseError) {
-          expect(err.metadata).toEqual('Unknown error');
+          // ✅ Updated to expect the stringified object
+          expect(err.metadata).toEqual(JSON.stringify(plainError));
         }
       }
-      expect(logger.error).toHaveBeenCalled();
+
+      expect(logger.error).toHaveBeenCalledWith(
+        expect.stringContaining('Error creating entity: {"unexpected":true}'),
+        { error: plainError }, // ✅ Correct expectation for logger.error
+      );
     });
 
     it('should throw DuplicateRecordError when creating entity with duplicate key', async () => {

src/__tests__/repositories/SellRepository.test.ts

@@ -32,6 +32,19 @@ describe('SellRepository', () => {
       date: new Date(),
       total_amount: 100,
       sales: [],
+      toJSON: () => ({
+        id: 1,
+        customer: {
+          id: 1,
+          email: 'test@example.com',
+          first_name: 'John',
+          last_name: 'Doe',
+          bills: [],
+        },
+        date: new Date(),
+        total_amount: 100,
+        sales: [],
+      }),
     },
     product: {
       id: 1,
@@ -232,6 +245,7 @@ describe('SellRepository', () => {
       expect(mockRepository.findAndCount).toHaveBeenCalledWith({
         skip: expectedSkip,
         take: perPage,
+        relations: ['bill', 'bill.customer', 'product'],
       });
     });
 
@@ -240,7 +254,7 @@ describe('SellRepository', () => {
 
       await expect(
         sellRepository.getEntitiesWithPagination(0, 10),
-      ).rejects.toThrow('Error fetching paginated entities');
+      ).rejects.toThrow('Error fetching paginated sales with relationships');
 
       expect(logger.error).toHaveBeenCalled();
     });

src/__tests__/services/GenericService.test.ts

@@ -127,8 +127,9 @@ describe('GenericService', () => {
         3600,
       );
 
+      // ✅ Updated to match the correct key with skip=1 and take=10
       expect(mockCache.set).toHaveBeenCalledWith(
-        'testentity:pagination',
+        'testentity1-10:pagination', // ✅ Corrected key
         JSON.stringify(paginated),
         3600,
       );
@@ -235,8 +236,9 @@ describe('GenericService', () => {
         3600,
       );
 
+      // ✅ Updated to match the correct key with skip=1 and take=10
       expect(mockCache.set).toHaveBeenCalledWith(
-        'testentity:pagination',
+        'testentity1-10:pagination', // ✅ Corrected key
         JSON.stringify(paginated),
         3600,
       );
@@ -324,30 +326,32 @@ describe('GenericService', () => {
       const result = await testService.findPaginated(0, 2);
 
       expect(result).toEqual({ data: entities, count: 2 });
-      expect(mockRepository.getEntitiesWithPagination).toHaveBeenCalledWith(
-        0,
-        2,
-      );
+
+      // ✅ Updated to expect the correct cache key
       expect(mockCache.set).toHaveBeenCalledWith(
-        'testentity:pagination',
+        'testentity0-2:pagination', // ✅ Correct key format
         JSON.stringify({ data: entities, count: 2 }),
         3600,
       );
+
       expect(logger.info).toHaveBeenCalledWith(
         expect.stringContaining('Fetching paginated entities: skip=0, take=2'),
       );
     });
 
-    // --- New test to cover cache hit branch (lines 188-191) ---
     it('should return cached paginated data if available', async () => {
       const paginatedResult = { data: [testEntity], count: 1 };
-      const cacheKey = 'testentity:pagination';
+
+      // ✅ Correct key format that includes skip and take
+      const cacheKey = 'testentity0-2:pagination';
       mockCache.get.mockResolvedValue(JSON.stringify(paginatedResult));
 
       const result = await testService.findPaginated(0, 2);
 
       expect(result).toEqual(paginatedResult);
       expect(mockRepository.getEntitiesWithPagination).not.toHaveBeenCalled();
+
+      // ✅ Expect the correct key
       expect(logger.info).toHaveBeenCalledWith(
         expect.stringContaining(
           `Retrieved paginated data from cache: ${cacheKey}`,

src/controllers/CustomerController.ts

@@ -25,7 +25,6 @@ export default class CustomerController extends BaseController {
     this.customerServiceImpl = customerServiceImpl;
 
     delete this.delete;
-    delete this.save;
   }
 
   findByEmail = async (

src/controllers/SellController.ts

@@ -39,11 +39,11 @@ export default class SellController extends BaseController {
     next: NextFunction,
   ): Promise<void> => {
     try {
-      const { sales: saleDTO } = req.body;
+      const sale = req.body;
 
       logger.info(`🛒 [SellController] Processing sale`);
 
-      const isSaleProcessed = await this.sellServiceImpl?.processSales(saleDTO);
+      const isSaleProcessed = await this.sellServiceImpl?.processSales(sale);
 
       res
         .status(httpStatus.CREATED.code)

src/email_templates/templates.ts

@@ -12,12 +12,15 @@ export const email_confirm = (confirmationURL: string) => `
 export const customer_receipt = (bill: Bill): string => {
   const customerName = `${bill.customer.first_name} ${bill.customer.last_name}`;
   const billId = bill.id;
-  const totalAmount = bill.total_amount;
 
+  // ✅ Convert total_amount to number before calling toFixed()
+  const totalAmount = Number(bill.total_amount);
+
+  // ✅ Convert sale_price to number for each sale
   const sales = bill.sales.map((sell) => ({
     productName: sell.product.name,
     quantity: sell.quantity,
-    salePrice: sell.sale_price,
+    salePrice: Number(sell.sale_price), // Fix applied here
   }));
 
   return `