feat(sync): synchronize customer orders from Hiboutik sales

For each customer sale not yet stored as completed, fetch the full sale
(GET /sales/:id) and upsert it as a STORE order keyed on hiboutikSaleId.
Lines are replaced on each upsert and linked to the matching product
version when it still exists. Quotations are skipped, orders are never
deleted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/services/hiboutik/customer.hiboutik.service.spec.ts

@@ -7,6 +7,9 @@ describe('CustomerHiboutikService', () => {
   const customerConverter = { fromHiboutik: jest.fn() };
   const customerAddressDatabaseRepository = { upsert: jest.fn(), deleteMissing: jest.fn() };
   const customerAddressConverter = { fromHiboutik: jest.fn((dto: unknown) => dto) };
+  const saleHiboutikRepository = { getSaleById: jest.fn() };
+  const orderDatabaseRepository = { upsert: jest.fn(), getCompletedSaleIds: jest.fn() };
+  const orderConverter = { fromHiboutik: jest.fn((dto: unknown) => dto) };
   let service: CustomerHiboutikService;
 
   beforeAll(() => {
@@ -22,12 +25,17 @@ describe('CustomerHiboutikService', () => {
     customerDatabaseRepository.upsert.mockResolvedValue({ id: 'customer-uuid' });
     customerDatabaseRepository.deleteMissing.mockResolvedValue(0);
     customerAddressDatabaseRepository.deleteMissing.mockResolvedValue(0);
+    orderDatabaseRepository.getCompletedSaleIds.mockResolvedValue(new Set());
+    saleHiboutikRepository.getSaleById.mockImplementation((id: number) => Promise.resolve({ sale_id: id, quotation: 0 }));
     service = new CustomerHiboutikService(
       customerHiboutikRepository as never,
       customerDatabaseRepository as never,
       customerConverter as never,
       customerAddressDatabaseRepository as never,
       customerAddressConverter as never,
+      saleHiboutikRepository as never,
+      orderDatabaseRepository as never,
+      orderConverter as never,
     );
   });
 
@@ -148,4 +156,51 @@ describe('CustomerHiboutikService', () => {
       expect(customerAddressDatabaseRepository.upsert).toHaveBeenCalledTimes(2);
     });
   });
+
+  describe('orders', () => {
+    beforeEach(() => {
+      customerHiboutikRepository.getCustomers.mockResolvedValue([{ customers_id: 1 }]);
+      customerHiboutikRepository.getCustomerById.mockResolvedValue({
+        customers_id: 1,
+        addresses: [],
+        sales: [{ sale_id: 5 }, { sale_id: '6' }, { sale_id: 7 }],
+      });
+    });
+
+    it('fetches and upserts the sales not yet stored as completed, linked to the customer', async () => {
+      orderDatabaseRepository.getCompletedSaleIds.mockResolvedValue(new Set([6]));
+
+      await service.syncCustomers();
+
+      expect(orderDatabaseRepository.getCompletedSaleIds).toHaveBeenCalledWith([5, 6, 7]);
+      expect(saleHiboutikRepository.getSaleById.mock.calls.map((call: unknown[]) => call[0])).toEqual([5, 7]);
+      expect(orderDatabaseRepository.upsert).toHaveBeenCalledTimes(2);
+      expect(orderConverter.fromHiboutik).toHaveBeenCalledWith({ sale_id: 5, quotation: 0, customer_id: 1 });
+    });
+
+    it('ignores quotations', async () => {
+      saleHiboutikRepository.getSaleById.mockResolvedValueOnce({ sale_id: 5, quotation: 1 });
+
+      await service.syncCustomers();
+
+      expect(orderDatabaseRepository.upsert).toHaveBeenCalledTimes(2);
+    });
+
+    it('keeps syncing the other sales when one fails', async () => {
+      saleHiboutikRepository.getSaleById.mockRejectedValueOnce(new Error('boom'));
+
+      await service.syncCustomers();
+
+      expect(orderDatabaseRepository.upsert).toHaveBeenCalledTimes(2);
+    });
+
+    it('skips orders when the payload has no sales array', async () => {
+      customerHiboutikRepository.getCustomerById.mockResolvedValue({ customers_id: 1, addresses: [] });
+
+      await service.syncCustomers();
+
+      expect(saleHiboutikRepository.getSaleById).not.toHaveBeenCalled();
+      expect(orderDatabaseRepository.upsert).not.toHaveBeenCalled();
+    });
+  });
 });

src/services/hiboutik/customer.hiboutik.service.ts

@@ -10,6 +10,9 @@ import {
   FullCustomerHiboutikDto,
 } from '../../models/hiboutikDTO/customer.hiboutik.dto';
 import { forEachSafely } from '../../utils/sync';
+import { SaleHiboutikRepository } from '../../hiboutik/sale.hiboutik.repository';
+import { OrderDatabaseRepository } from '../../database/order.database.repository';
+import { OrderConverter } from '../../models/converter/order.converter';
 
 @Injectable()
 export class CustomerHiboutikService {
@@ -21,11 +24,15 @@ export class CustomerHiboutikService {
     private readonly customerConverter: CustomerConverter,
     private readonly customerAddressDatabaseRepository: CustomerAddressDatabaseRepository,
     private readonly customerAddressConverter: CustomerAddressConverter,
+    private readonly saleHiboutikRepository: SaleHiboutikRepository,
+    private readonly orderDatabaseRepository: OrderDatabaseRepository,
+    private readonly orderConverter: OrderConverter,
   ) {}
 
   /**
    * Mirrors Hiboutik customers: deletes the customers missing from Hiboutik, then fetches and upserts each of them
-   * with its addresses (one API call per customer, as the list endpoint lacks addresses and sales).
+   * with its addresses and orders (one API call per customer, as the list endpoint lacks addresses and sales, plus one
+   * per sale not yet stored as completed).
    */
   async syncCustomers() {
     const hiboutikCustomers = await this.customerHiboutikRepository.getCustomers();
@@ -40,20 +47,20 @@ export class CustomerHiboutikService {
 
     let nbFailed = 0;
     let nbFailedAddresses = 0;
+    let nbFailedOrders = 0;
     for (const hiboutikCustomer of hiboutikCustomers) {
       try {
         const hiboutikFullCustomer = await this.customerHiboutikRepository.getCustomerById(hiboutikCustomer.customers_id);
         const customer = await this.customerDatabaseRepository.upsert(this.customerConverter.fromHiboutik(hiboutikFullCustomer));
         nbFailedAddresses += await this.syncAddresses(customer.id, hiboutikFullCustomer);
-        // retreive orders DTOs
-        // save orders
+        nbFailedOrders += await this.syncOrders(hiboutikFullCustomer);
       } catch (error) {
         nbFailed++;
         this.logger.error(`Failed to sync Hiboutik customer ${hiboutikCustomer.customers_id}`, (error as Error)?.stack);
       }
     }
     this.logger.log(
-      `Customers sync ended: ${hiboutikCustomers.length - nbFailed}/${hiboutikCustomers.length} synced, ${nbFailed} failed, ${nbDeleted} deleted, ${nbFailedAddresses} addresses failed.`,
+      `Customers sync ended: ${hiboutikCustomers.length - nbFailed}/${hiboutikCustomers.length} synced, ${nbFailed} failed, ${nbDeleted} deleted, ${nbFailedAddresses} addresses failed, ${nbFailedOrders} orders failed.`,
     );
   }
 
@@ -108,4 +115,36 @@ export class CustomerHiboutikService {
       return dto;
     }
   }
+
+  /**
+   * Mirrors the sales of a full Hiboutik customer as orders: each sale not yet stored as completed is fetched (for its
+   * lines) and upserted (a failing sale is logged and skipped). Quotations are ignored. Orders are never deleted.
+   * @returns the number of failed sales.
+   */
+  private async syncOrders(hiboutikCustomer: FullCustomerHiboutikDto): Promise<number> {
+    if (!Array.isArray(hiboutikCustomer.sales)) {
+      this.logger.warn(`Hiboutik customer ${hiboutikCustomer.customers_id} has no sales array: orders sync skipped.`);
+      return 0;
+    }
+
+    // A completed sale no longer changes in Hiboutik: no need to fetch it again
+    const completedSaleIds = await this.orderDatabaseRepository.getCompletedSaleIds(
+      hiboutikCustomer.sales.map((dto) => Number(dto.sale_id)),
+    );
+    const salesToSync = hiboutikCustomer.sales.filter((dto) => !completedSaleIds.has(Number(dto.sale_id)));
+
+    return forEachSafely(
+      salesToSync,
+      async (dto) => {
+        const sale = await this.saleHiboutikRepository.getSaleById(dto.sale_id);
+        if (Number(sale.quotation) === 1) return;
+        // Linked to the parent customer, whatever the sale says
+        await this.orderDatabaseRepository.upsert(
+          this.orderConverter.fromHiboutik({ ...sale, customer_id: hiboutikCustomer.customers_id }),
+        );
+      },
+      this.logger,
+      (dto) => `Hiboutik sale ${dto.sale_id} of customer ${hiboutikCustomer.customers_id}`,
+    );
+  }
 }