@bash-app/bash-common 30.385.0 → 30.391.0

package/src/utils/paymentUtils.ts

@@ -430,6 +430,32 @@ export function lowestGuestAllInPriceCents(
   return min;
 }
 
+/** Max share of attributed ticket subtotal a host can assign to a performer (50%). */
+export const MAX_TICKET_COMMISSION_BPS = 5000;
+
+/**
+ * Floor cents owed to a promo-code performer from the discounted ticket subtotal.
+ * Guest price is unchanged; this amount is withheld from the host via application_fee.
+ */
+export function ticketCommissionCents(
+  basisCents: number,
+  commissionBps: number | null | undefined
+): number {
+  if (basisCents <= 0) return 0;
+  const bps = Math.floor(Number(commissionBps) || 0);
+  if (bps <= 0) return 0;
+  const clamped = Math.min(MAX_TICKET_COMMISSION_BPS, bps);
+  return Math.floor((basisCents * clamped) / 10_000);
+}
+
+export function clampTicketCommissionBps(
+  commissionBps: number | null | undefined
+): number {
+  const bps = Math.floor(Number(commissionBps) || 0);
+  if (bps <= 0) return 0;
+  return Math.min(MAX_TICKET_COMMISSION_BPS, bps);
+}
+
 /**
  * Compute the Stripe Connect `application_fee_amount` for a ticket-style charge,
  * along with its constituent parts.
@@ -441,8 +467,10 @@ export function lowestGuestAllInPriceCents(
  *   - `bashPlatformTotalCents` and `guestPlatformLineCents` are both zero
  *   - `totalChargedCents` collapses to the discounted subtotal (no guest-line fee added)
  *   - `applicationFeeAmountCents` equals `stripeProcessingCents`
+ *     plus optional `performerCommissionCents`
  *
- * Default (`false`) preserves existing math bit-exact for every current caller.
+ * Default (`false`) preserves existing math bit-exact for every current caller
+ * when `performerCommissionCents` is omitted or 0.
  */
 export function computeTicketApplicationFeeAmountCents(args: {
   discountedSubtotalCents: number;
@@ -456,6 +484,11 @@ export function computeTicketApplicationFeeAmountCents(args: {
    * NEVER from `BashEvent.nonProfit`, which is user-entered.
    */
   isVerifiedNonprofitHost?: boolean;
+  /**
+   * Performer / street-team cut withheld from the host (not added to the guest).
+   * Must be less than remaining charge after Stripe + Bash platform fees.
+   */
+  performerCommissionCents?: number;
 }): {
   totalChargedCents: number;
   /** Stripe's 2.9% + $0.30 pass-through; unchanged by the nonprofit waiver. */
@@ -467,15 +500,27 @@ export function computeTicketApplicationFeeAmountCents(args: {
   guestPlatformLineCents: number;
   /** Guest-visible Stripe processing line (0 when host absorbs). */
   guestProcessingLineCents: number;
+  /** Host-withheld performer cut included in application_fee. */
+  performerCommissionCents: number;
 } {
   const breakdown = computeGuestTicketCheckoutBreakdown(args);
+  const performerCommissionCents = Math.max(
+    0,
+    Math.floor(args.performerCommissionCents ?? 0)
+  );
+  const maxWithhold = Math.max(
+    0,
+    breakdown.totalDueCents - breakdown.applicationFeeAmountCents - 1
+  );
+  const withheld = Math.min(performerCommissionCents, maxWithhold);
   return {
     totalChargedCents: breakdown.totalDueCents,
     stripeProcessingCents: breakdown.stripeProcessingCents,
     bashPlatformTotalCents: breakdown.bashPlatformTotalCents,
-    applicationFeeAmountCents: breakdown.applicationFeeAmountCents,
+    applicationFeeAmountCents: breakdown.applicationFeeAmountCents + withheld,
     guestPlatformLineCents: breakdown.guestPlatformLineCents,
     guestProcessingLineCents: breakdown.guestProcessingLineCents,
+    performerCommissionCents: withheld,
   };
 }
 

package/src/utils/service/__tests__/foodAndBeverageQuote.test.ts

@@ -0,0 +1,502 @@
+import {
+  CELEBRATION_CAKE_FLAVORS,
+  EVENT_SERVICE_FULFILLMENT_MODES,
+  celebrationCakeStartingPriceLabel,
+  encodeCakeOption,
+  filterCelebrationCakeFulfillmentModes,
+  filterFulfillmentModes,
+  foodAndBeverageLeadTimeLabel,
+  foodAndBeverageQuoteCents,
+  foodAndBeverageRateSummary,
+  getFoodAndBeverageMenuCategories,
+  isBelowGuestMinimum,
+  GRAZING_TABLE_STYLES,
+  encodeGrazingOption,
+  grazingTableStartingPriceLabel,
+  isCelebrationCakeEventService,
+  isCelebrationCakeFulfillmentMode,
+  isFoodAndBeverageEventService,
+  isFulfillmentMode,
+  isGrazingTableEventService,
+  isOfficiantEventService,
+  isPackagePricedFoodEventService,
+  isPerGuestFoodAndBeverageEventService,
+  packagePricedFoodStartingPriceLabel,
+  parseCakeOptions,
+  parseGrazingOptions,
+  quotedGuestCount,
+  serializeCakeOptions,
+  serializeGrazingOptions,
+} from "../foodAndBeverageQuote.js";
+
+describe("isFoodAndBeverageEventService", () => {
+  it("returns true for FoodAndBeverage eventServiceType", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceType: "FoodAndBeverage" })
+    ).toBe(true);
+  });
+
+  it("returns true for canonical subtype even without eventServiceType", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "DessertBar" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+  });
+
+  it("returns true for legacy/alias subtypes", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "PrivateChef" })
+    ).toBe(true);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "Bartender" })
+    ).toBe(true);
+  });
+
+  it("returns false for unrelated types", () => {
+    expect(
+      isFoodAndBeverageEventService({ eventServiceType: "EventPlanningAndManagement" })
+    ).toBe(false);
+    expect(
+      isFoodAndBeverageEventService({ eventServiceSubType: "EventPlanner" })
+    ).toBe(false);
+  });
+
+  it("returns false when both are null/undefined", () => {
+    expect(isFoodAndBeverageEventService({})).toBe(false);
+    expect(isFoodAndBeverageEventService({ eventServiceType: null, eventServiceSubType: null })).toBe(false);
+  });
+});
+
+describe("EVENT_SERVICE_FULFILLMENT_MODES", () => {
+  it("contains Pickup, Delivery, and FullService", () => {
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("Pickup");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("Delivery");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toContain("FullService");
+    expect(EVENT_SERVICE_FULFILLMENT_MODES).toHaveLength(3);
+  });
+});
+
+describe("getFoodAndBeverageMenuCategories", () => {
+  it("returns Caterer chips for Caterer subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories("Caterer");
+    expect(chips).toContain("Salads");
+    expect(chips).toContain("Mains");
+    expect(chips).toContain("Sides");
+  });
+
+  it("returns DessertBar chips for DessertBar subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories("DessertBar");
+    expect(chips).toContain("Cakes");
+    expect(chips).toContain("Cupcakes");
+  });
+
+  it("falls back to generic chips for unknown subtypes", () => {
+    const chips = getFoodAndBeverageMenuCategories("SomeUnknownType");
+    expect(chips.length).toBeGreaterThan(0);
+    expect(chips).toContain("Mains");
+  });
+
+  it("returns generic chips for null subtype", () => {
+    const chips = getFoodAndBeverageMenuCategories(null);
+    expect(chips.length).toBeGreaterThan(0);
+  });
+});
+
+describe("quotedGuestCount", () => {
+  it("returns headcount when no minimum is set", () => {
+    expect(quotedGuestCount(80)).toBe(80);
+    expect(quotedGuestCount(80, null)).toBe(80);
+    expect(quotedGuestCount(80, 0)).toBe(80);
+  });
+
+  it("returns headcount when above minimum", () => {
+    expect(quotedGuestCount(80, 25)).toBe(80);
+  });
+
+  it("floors to minimum when headcount is below", () => {
+    expect(quotedGuestCount(10, 25)).toBe(25);
+    expect(quotedGuestCount(0, 25)).toBe(25);
+  });
+
+  it("returns minimum exactly when headcount equals minimum", () => {
+    expect(quotedGuestCount(25, 25)).toBe(25);
+  });
+
+  it("never returns a negative count", () => {
+    expect(quotedGuestCount(-5)).toBe(0);
+  });
+});
+
+describe("foodAndBeverageQuoteCents", () => {
+  it("calculates basic per-guest price", () => {
+    // $18/guest × 100 guests = $1,800
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 1800, headcount: 100 })
+    ).toBe(180000);
+  });
+
+  it("floors headcount at minimumQuantity", () => {
+    // $18/guest × min 25 guests; host enters 10 → billed for 25
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 10,
+        minimumQuantity: 25,
+      })
+    ).toBe(1800 * 25);
+  });
+
+  it("does not floor when headcount is above minimum", () => {
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 80,
+        minimumQuantity: 25,
+      })
+    ).toBe(1800 * 80);
+  });
+
+  it("applies minimumChargeCents dollar floor after guest floor", () => {
+    // $8/guest × 25 guests (floored from 5) = $200. Min charge $500 → $500.
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 800,
+        headcount: 5,
+        minimumQuantity: 25,
+        minimumChargeCents: 50000,
+      })
+    ).toBe(50000);
+  });
+
+  it("dollar floor does not fire when rate total already exceeds it", () => {
+    // $18/guest × 50 guests = $900 > $500 min charge
+    expect(
+      foodAndBeverageQuoteCents({
+        baseRateCents: 1800,
+        headcount: 50,
+        minimumQuantity: 25,
+        minimumChargeCents: 50000,
+      })
+    ).toBe(1800 * 50);
+  });
+
+  it("returns 0 for zero baseRate", () => {
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 0, headcount: 100 })
+    ).toBe(0);
+  });
+
+  it("returns 0 for negative headcount", () => {
+    expect(
+      foodAndBeverageQuoteCents({ baseRateCents: 1800, headcount: -1 })
+    ).toBe(0);
+  });
+});
+
+describe("foodAndBeverageRateSummary", () => {
+  it("formats without a minimum", () => {
+    const result = foodAndBeverageRateSummary(1800);
+    expect(result).toBe("$18 / guest");
+  });
+
+  it("formats with a minimum", () => {
+    const result = foodAndBeverageRateSummary(1800, 25);
+    expect(result).toBe("$18 / guest · min 25 guests");
+  });
+
+  it("formats cents correctly", () => {
+    const result = foodAndBeverageRateSummary(1850);
+    expect(result).toBe("$18.50 / guest");
+  });
+});
+
+describe("foodAndBeverageLeadTimeLabel", () => {
+  it("returns null for falsy inputs", () => {
+    expect(foodAndBeverageLeadTimeLabel(null)).toBeNull();
+    expect(foodAndBeverageLeadTimeLabel(0)).toBeNull();
+    expect(foodAndBeverageLeadTimeLabel(undefined)).toBeNull();
+  });
+
+  it("formats days when not divisible by 7", () => {
+    expect(foodAndBeverageLeadTimeLabel(1)).toBe("Needs 1 day notice");
+    expect(foodAndBeverageLeadTimeLabel(5)).toBe("Needs 5 days notice");
+    expect(foodAndBeverageLeadTimeLabel(10)).toBe("Needs 10 days notice");
+  });
+
+  it("formats weeks when divisible by 7", () => {
+    expect(foodAndBeverageLeadTimeLabel(7)).toBe("Needs 1 week notice");
+    expect(foodAndBeverageLeadTimeLabel(14)).toBe("Needs 2 weeks notice");
+  });
+});
+
+describe("package-priced food detection", () => {
+  it("treats cake and grazing as package-priced, not per-guest", () => {
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+    expect(
+      isPackagePricedFoodEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(false);
+    expect(isPackagePricedFoodEventService({})).toBe(false);
+  });
+
+  it("isPerGuestFoodAndBeverage is false for cake and grazing", () => {
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "CelebrationCake",
+      })
+    ).toBe(false);
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "GrazingTable",
+      })
+    ).toBe(false);
+    expect(
+      isPerGuestFoodAndBeverageEventService({
+        eventServiceType: "FoodAndBeverage",
+        eventServiceSubType: "Caterer",
+      })
+    ).toBe(true);
+  });
+
+  it("isGrazingTableEventService is true only for GrazingTable", () => {
+    expect(
+      isGrazingTableEventService({ eventServiceSubType: "GrazingTable" })
+    ).toBe(true);
+    expect(
+      isGrazingTableEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(false);
+    expect(isGrazingTableEventService({})).toBe(false);
+  });
+
+  it("isOfficiantEventService is true only for Officiant", () => {
+    expect(isOfficiantEventService({ eventServiceSubType: "Officiant" })).toBe(
+      true
+    );
+    expect(
+      isOfficiantEventService({ eventServiceSubType: "HostingSupportOther" })
+    ).toBe(false);
+    expect(isFoodAndBeverageEventService({ eventServiceSubType: "Officiant" })).toBe(
+      false
+    );
+  });
+});
+
+describe("isCelebrationCakeEventService", () => {
+  it("returns true only for CelebrationCake", () => {
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "CelebrationCake" })
+    ).toBe(true);
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "Caterer" })
+    ).toBe(false);
+    expect(
+      isCelebrationCakeEventService({ eventServiceSubType: "DessertBar" })
+    ).toBe(false);
+    expect(isCelebrationCakeEventService({})).toBe(false);
+    expect(isCelebrationCakeEventService({ eventServiceSubType: null })).toBe(
+      false
+    );
+  });
+});
+
+describe("parseCakeOptions", () => {
+  it("returns empty groups for null or empty input", () => {
+    expect(parseCakeOptions(null)).toEqual({
+      flavors: [],
+      frostings: [],
+      fillings: [],
+      dietary: [],
+      other: [],
+    });
+    expect(parseCakeOptions([])).toEqual({
+      flavors: [],
+      frostings: [],
+      fillings: [],
+      dietary: [],
+      other: [],
+    });
+  });
+
+  it("splits prefixed chips and keeps unprefixed leftovers", () => {
+    const parsed = parseCakeOptions([
+      "flavor:Red Velvet",
+      "frosting:Chocolate Buttercream",
+      "filling:Lemon Custard",
+      "dietary:Gluten-Free",
+      "Desserts",
+    ]);
+    expect(parsed.flavors).toEqual(["Red Velvet"]);
+    expect(parsed.frostings).toEqual(["Chocolate Buttercream"]);
+    expect(parsed.fillings).toEqual(["Lemon Custard"]);
+    expect(parsed.dietary).toEqual(["Gluten-Free"]);
+    expect(parsed.other).toEqual(["Desserts"]);
+  });
+
+  it("round-trips through serializeCakeOptions", () => {
+    const serialized = serializeCakeOptions({
+      flavors: ["Vanilla", "Chocolate"],
+      frostings: ["Fondant"],
+      fillings: [],
+      dietary: ["Vegan"],
+    });
+    expect(serialized).toEqual([
+      "flavor:Vanilla",
+      "flavor:Chocolate",
+      "frosting:Fondant",
+      "dietary:Vegan",
+    ]);
+    expect(parseCakeOptions(serialized)).toEqual({
+      flavors: ["Vanilla", "Chocolate"],
+      frostings: ["Fondant"],
+      fillings: [],
+      dietary: ["Vegan"],
+      other: [],
+    });
+  });
+
+  it("encodeCakeOption uses lowercase prefixes", () => {
+    expect(encodeCakeOption("flavor", "Red Velvet")).toBe("flavor:Red Velvet");
+    expect(CELEBRATION_CAKE_FLAVORS).toContain("Red Velvet");
+  });
+});
+
+describe("celebrationCakeStartingPriceLabel", () => {
+  it("returns null when there is no starting price", () => {
+    expect(celebrationCakeStartingPriceLabel(null)).toBeNull();
+    expect(celebrationCakeStartingPriceLabel(0)).toBeNull();
+  });
+
+  it("formats whole-dollar starting prices", () => {
+    expect(celebrationCakeStartingPriceLabel(35000)).toBe("Cakes start at $350");
+  });
+});
+
+describe("grazing options", () => {
+  it("returns empty groups for null or empty input", () => {
+    expect(parseGrazingOptions(null)).toEqual({
+      styles: [],
+      proteins: [],
+      dietary: [],
+      other: [],
+    });
+    expect(parseGrazingOptions([])).toEqual({
+      styles: [],
+      proteins: [],
+      dietary: [],
+      other: [],
+    });
+  });
+
+  it("splits prefixed chips and keeps unprefixed leftovers", () => {
+    const parsed = parseGrazingOptions([
+      "style:Classic Charcuterie",
+      "protein:Cured Meats",
+      "dietary:Gluten-Free",
+      "Mains",
+    ]);
+    expect(parsed.styles).toEqual(["Classic Charcuterie"]);
+    expect(parsed.proteins).toEqual(["Cured Meats"]);
+    expect(parsed.dietary).toEqual(["Gluten-Free"]);
+    expect(parsed.other).toEqual(["Mains"]);
+  });
+
+  it("round-trips through serializeGrazingOptions", () => {
+    const serialized = serializeGrazingOptions({
+      styles: ["Modern Grazing"],
+      proteins: ["Artisan Cheeses"],
+      dietary: ["Vegan"],
+    });
+    expect(serialized).toEqual([
+      "style:Modern Grazing",
+      "protein:Artisan Cheeses",
+      "dietary:Vegan",
+    ]);
+    expect(parseGrazingOptions(serialized)).toEqual({
+      styles: ["Modern Grazing"],
+      proteins: ["Artisan Cheeses"],
+      dietary: ["Vegan"],
+      other: [],
+    });
+  });
+
+  it("encodeGrazingOption uses lowercase prefixes", () => {
+    expect(encodeGrazingOption("style", "Seasonal")).toBe("style:Seasonal");
+    expect(GRAZING_TABLE_STYLES).toContain("Classic Charcuterie");
+  });
+});
+
+describe("grazing and package starting-price labels", () => {
+  it("formats grazing starting prices", () => {
+    expect(grazingTableStartingPriceLabel(null)).toBeNull();
+    expect(grazingTableStartingPriceLabel(17500)).toBe("Boards start at $175");
+  });
+
+  it("delegates packagePricedFoodStartingPriceLabel by subtype", () => {
+    expect(packagePricedFoodStartingPriceLabel("GrazingTable", 17500)).toBe(
+      "Boards start at $175"
+    );
+    expect(packagePricedFoodStartingPriceLabel("CelebrationCake", 35000)).toBe(
+      "Cakes start at $350"
+    );
+    expect(packagePricedFoodStartingPriceLabel("Caterer", 35000)).toBeNull();
+  });
+});
+
+describe("isBelowGuestMinimum", () => {
+  it("returns false when no minimum is set", () => {
+    expect(isBelowGuestMinimum(5)).toBe(false);
+    expect(isBelowGuestMinimum(5, null)).toBe(false);
+    expect(isBelowGuestMinimum(5, 0)).toBe(false);
+  });
+
+  it("returns true when below minimum", () => {
+    expect(isBelowGuestMinimum(10, 25)).toBe(true);
+  });
+
+  it("returns false when exactly at minimum", () => {
+    expect(isBelowGuestMinimum(25, 25)).toBe(false);
+  });
+
+  it("returns false when above minimum", () => {
+    expect(isBelowGuestMinimum(100, 25)).toBe(false);
+  });
+});
+
+describe("fulfillment mode filters", () => {
+  it("keeps known F&B modes and drops unknowns", () => {
+    expect(isFulfillmentMode("Pickup")).toBe(true);
+    expect(isFulfillmentMode("FullService")).toBe(true);
+    expect(isFulfillmentMode("Curbside")).toBe(false);
+    expect(
+      filterFulfillmentModes(["Pickup", "Curbside", "Delivery", "FullService"])
+    ).toEqual(["Pickup", "Delivery", "FullService"]);
+    expect(filterFulfillmentModes(null)).toEqual([]);
+  });
+
+  it("keeps cake pickup/delivery only", () => {
+    expect(isCelebrationCakeFulfillmentMode("Pickup")).toBe(true);
+    expect(isCelebrationCakeFulfillmentMode("FullService")).toBe(false);
+    expect(
+      filterCelebrationCakeFulfillmentModes([
+        "Pickup",
+        "FullService",
+        "Delivery",
+      ])
+    ).toEqual(["Pickup", "Delivery"]);
+    expect(filterCelebrationCakeFulfillmentModes(undefined)).toEqual([]);
+  });
+});