feat: Add coupon extraction functionality and update related tests

src/__tests__/fixtures/price.samples.ts

@@ -3553,6 +3553,21 @@ export const compositePriceCashbackCombinedWithComponentCashbacks: CompositePric
   },
 };
 
+export const compositePriceWithCoupons = {
+  ...compositePriceWithComponentsWithCoupons,
+  _coupons: [fixedCashbackCoupon],
+  item_components: [
+    {
+      ...compositePriceWithComponentsWithCoupons.item_components?.[0],
+      _coupons: [percentageDiscountCoupon],
+    },
+    {
+      ...compositePriceWithComponentsWithCoupons.item_components?.[1],
+      _coupons: [percentageDiscountCoupon],
+    },
+  ],
+};
+
 export const unorderedPriceItemsOneTimeRecurrencesWithDiscount = [
   {
     description: 'Price 1 One time - no discount',

src/exports.test.ts

@@ -22,6 +22,7 @@ const expectedNamedExports = [
   'computeAggregatedAndPriceTotals',
   'computeQuantities',
   'extractPricingEntitiesBySlug',
+  'extractCouponsFromItem',
   'isPriceItemApproved',
   'isRequiringApproval',
   'getRecurrencesWithEstimatedPrices',

src/index.ts

@@ -17,7 +17,7 @@ export type { TimeFrequency } from './time-frequency/types';
 export { getRecurrencesWithEstimatedPrices } from './prices/get-recurrences-with-estimated-prices';
 export { isPriceItemApproved, isRequiringApproval } from './prices/approval';
 export { computeQuantities } from './computations/compute-price-item';
-export { extractPricingEntitiesBySlug } from './prices/extract-pricing-entities-by-slug';
+export { extractPricingEntitiesBySlug, extractCouponsFromItem } from './prices/extract-pricing-entities-by-slug';
 export { computeAggregatedAndPriceTotals } from './computations/compute-totals';
 export { PricingModel } from './prices/constants';
 export { getDisplayTierByQuantity, getDisplayTiersByQuantity, getTierDescription } from './tiers/utils';

src/prices/extract-pricing-entities-by-slug.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import * as samples from '../__tests__/fixtures/price.samples';
+import type { CompositePriceItem, PriceItem } from '../shared/types';
 import { extractPricingEntitiesBySlug } from './extract-pricing-entities-by-slug';
 
 describe('extractPricingEntitiesBySlug', () => {
@@ -11,7 +12,7 @@ describe('extractPricingEntitiesBySlug', () => {
       samples.priceItem4,
       samples.priceItem5,
       samples.compositePrice,
-    ];
+    ] as (PriceItem | CompositePriceItem)[];
 
     const result = extractPricingEntitiesBySlug(priceItems);
 
@@ -34,6 +35,44 @@ describe('extractPricingEntitiesBySlug', () => {
     });
   });
 
+  it('should return the pricing relations, including coupons', () => {
+    const priceItems = [
+      samples.priceItem1,
+      samples.priceItem2,
+      samples.priceItem3,
+      samples.priceItem4,
+      samples.priceItem5,
+      samples.compositePrice,
+      samples.compositePriceWithCoupons,
+    ] as (PriceItem | CompositePriceItem)[];
+
+    const result = extractPricingEntitiesBySlug(priceItems);
+
+    expect(result).toStrictEqual({
+      price: {
+        $relation: [
+          { _schema: 'price', _tags: [], entity_id: 'price#1' },
+          { _schema: 'price', _tags: [], entity_id: 'price#2' },
+          { _schema: 'price', _tags: [], entity_id: 'price#3' },
+          { _schema: 'price', _tags: [], entity_id: 'price#4' },
+        ],
+      },
+      product: {
+        $relation: [
+          { _schema: 'product', _tags: [], entity_id: 'prod-id#12324' },
+          { _schema: 'product', _tags: [], entity_id: 'prod-id#1234' },
+        ],
+      },
+      coupon: {
+        $relation: [
+          { _schema: 'coupon', _tags: [], entity_id: 'coupon#3' },
+          { _schema: 'coupon', _tags: [], entity_id: 'coupon#1' },
+        ],
+      },
+      _tags: ['product-tag-1', 'product-tag-2', 'price-tag-1', 'price-tag-2', 'composite'],
+    });
+  });
+
   it('should return no relations with the pricing slugs when there is no data', () => {
     expect(extractPricingEntitiesBySlug([])).toStrictEqual({
       price: { $relation: [] },

src/prices/extract-pricing-entities-by-slug.ts

@@ -1,4 +1,5 @@
 import type { PriceItem, CompositePriceItem } from '../shared/types';
+import { isCompositePriceItem } from './utils';
 
 type RelationAttributeValue = {
   $relation: { entity_id: string; _schema: string; _tags: string[] }[];
@@ -13,26 +14,47 @@ type PricingEntitiesExtractResult = {
    * A relation attribute value containing all product entities from the given price items.
    */
   product: RelationAttributeValue;
+
+  /**
+   * A relation attribute value containing all coupon entities from the given price items.
+   */
+  coupon?: RelationAttributeValue;
   /**
    * All pricing tags inferred from the products and prices of the provided price items.
    */
   _tags: string[];
 };
 
+/**
+ * Extracts all coupon entities ids from a price item and its components (if composite).
+ */
+export const extractCouponsFromItem = (item: PriceItem | CompositePriceItem) => {
+  const coupons = item._coupons ?? [];
+
+  if (isCompositePriceItem(item) && Array.isArray(item.item_components)) {
+    const componentCoupons = item.item_components.flatMap((component) => component._coupons ?? []);
+    return [...coupons, ...componentCoupons];
+  }
+
+  return coupons;
+};
+
 /**
  * Extracts the pricing entities from a list of price items.
  *
  * @param priceItems a list of price items
- * @returns the product and price relations from the price items grouped by their slug.
+ * @returns the product, price and coupon relations from the price items grouped by their slug.
  */
 
 export const extractPricingEntitiesBySlug = (
   priceItems?: (PriceItem | CompositePriceItem)[],
 ): PricingEntitiesExtractResult => {
   const productRelations = [] as RelationAttributeValue['$relation'];
   const priceRelations = [] as RelationAttributeValue['$relation'];
+  const couponRelations = [] as RelationAttributeValue['$relation'];
   const priceLookup: Record<string, boolean> = {};
   const productLookup: Record<string, boolean> = {};
+  const couponLookup: Record<string, boolean> = {};
   const pricingTags: string[] = [];
 
   priceItems?.forEach((item) => {
@@ -45,6 +67,7 @@ export const extractPricingEntitiesBySlug = (
       pricingTags.push(...(item._product?._tags || []));
       productLookup[item.product_id] = true;
     }
+
     if (item?.price_id && !priceLookup[item.price_id]) {
       priceRelations.push({
         entity_id: item.price_id,
@@ -54,11 +77,29 @@ export const extractPricingEntitiesBySlug = (
       pricingTags.push(...(item._price?._tags || []));
       priceLookup[item.price_id] = true;
     }
+
+    const coupons = extractCouponsFromItem(item);
+    if (coupons.length) {
+      for (const coupon of coupons) {
+        if (couponLookup[coupon._id]) {
+          continue;
+        }
+
+        couponRelations.push({
+          entity_id: coupon._id,
+          _schema: 'coupon',
+          _tags: [],
+        });
+
+        couponLookup[coupon._id] = true;
+      }
+    }
   });
 
   return {
     product: { $relation: productRelations },
     price: { $relation: priceRelations },
+    ...(couponRelations.length > 0 ? { coupon: { $relation: couponRelations } } : {}),
     _tags: [...new Set(pricingTags)],
   };
 };