@bash-app/bash-common 30.236.0 → 30.238.0

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

@@ -0,0 +1,396 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  EVENT_PROMOTER_LATE_CANCEL_HOURS,
+  EVENT_PROMOTER_LATE_CANCEL_PENALTY_FRACTION,
+  EVENT_PROMOTER_LOCKED_PRICING_MODEL,
+  buildIssuePromoCodeDeepLink,
+  computeEventPromoterDepositCents,
+  computeEventPromoterSettlement,
+  decideEventPromoterCancellation,
+  isPerAttendeeLockedPromotionSubType,
+  validateEventPromoterPricing,
+} from "../eventPromoterUtils.js";
+
+describe("isPerAttendeeLockedPromotionSubType", () => {
+  it("returns true for Promoter subtype", () => {
+    expect(isPerAttendeeLockedPromotionSubType("Promoter")).toBe(true);
+  });
+
+  it("returns false for other Promotion subtypes", () => {
+    expect(isPerAttendeeLockedPromotionSubType("Influencer")).toBe(false);
+    expect(isPerAttendeeLockedPromotionSubType("ContentCreator")).toBe(false);
+    expect(isPerAttendeeLockedPromotionSubType("CelebrityAppearance")).toBe(
+      false
+    );
+  });
+
+  it("returns false for null / undefined / unrelated strings", () => {
+    expect(isPerAttendeeLockedPromotionSubType(null)).toBe(false);
+    expect(isPerAttendeeLockedPromotionSubType(undefined)).toBe(false);
+    expect(isPerAttendeeLockedPromotionSubType("AnythingElse")).toBe(false);
+  });
+});
+
+describe("validateEventPromoterPricing", () => {
+  it("passes when subtype is locked and pricing is PER_ATTENDEE", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Promoter",
+        pricingModel: EVENT_PROMOTER_LOCKED_PRICING_MODEL,
+      })
+    ).toEqual({ ok: true });
+  });
+
+  it("rejects PROMOTER + non-PER_ATTENDEE pricing model", () => {
+    const result = validateEventPromoterPricing({
+      eventServiceSubType: "Promoter",
+      pricingModel: "HOURLY",
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.expected).toEqual([
+        "PER_ATTENDEE",
+        "PER_PAID_ATTENDEE",
+        "PER_BASHPOINTS_ATTENDEE",
+      ]);
+      expect(result.reason).toContain("PER_ATTENDEE");
+    }
+  });
+
+  it("rejects PROMOTER + null pricing model", () => {
+    const result = validateEventPromoterPricing({
+      eventServiceSubType: "Promoter",
+      pricingModel: null,
+    });
+    expect(result.ok).toBe(false);
+  });
+
+  it("passes any pricing model for non-Promoter subtypes", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Influencer",
+        pricingModel: "HOURLY",
+      })
+    ).toEqual({ ok: true });
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "ContentCreator",
+        pricingModel: "FLAT_FEE",
+      })
+    ).toEqual({ ok: true });
+  });
+});
+
+describe("computeEventPromoterDepositCents", () => {
+  it("returns expected attendees * baseRate when minimum is below expected", () => {
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: 200,
+        baseRateCents: 500,
+        minimumQuantity: 50,
+      })
+    ).toBe(100_000);
+  });
+
+  it("uses minimumQuantity floor when expected is below it", () => {
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: 30,
+        baseRateCents: 500,
+        minimumQuantity: 100,
+      })
+    ).toBe(50_000);
+  });
+
+  it("returns null when baseRateCents is missing or 0", () => {
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: 200,
+        baseRateCents: null,
+        minimumQuantity: 100,
+      })
+    ).toBeNull();
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: 200,
+        baseRateCents: 0,
+        minimumQuantity: 100,
+      })
+    ).toBeNull();
+  });
+
+  it("treats negative expected attendees as 0", () => {
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: -10,
+        baseRateCents: 500,
+        minimumQuantity: null,
+      })
+    ).toBe(0);
+  });
+});
+
+describe("computeEventPromoterSettlement", () => {
+  const baseInput = {
+    baseRateCents: 500,
+    expectedAttendeesAtBooking: 200,
+  };
+
+  it("returns zero delta when checked-in matches expected exactly", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 200,
+    });
+    expect(result.finalCount).toBe(200);
+    expect(result.settlementDeltaCents).toBe(0);
+    expect(result.totalCents).toBe(100_000);
+    expect(result.ceilingHit).toBe(false);
+  });
+
+  it("returns positive delta when more attendees show up than expected", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 250,
+    });
+    expect(result.finalCount).toBe(250);
+    expect(result.settlementDeltaCents).toBe(25_000);
+    expect(result.totalCents).toBe(125_000);
+    expect(result.ceilingHit).toBe(false);
+  });
+
+  it("returns negative delta (refund) when fewer attendees show up", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 150,
+    });
+    expect(result.finalCount).toBe(150);
+    expect(result.settlementDeltaCents).toBe(-25_000);
+    expect(result.totalCents).toBe(75_000);
+  });
+
+  it("caps finalCount at maxAttendeesAttributable and sets ceilingHit", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 500,
+      maxAttendeesAttributable: 250,
+    });
+    expect(result.finalCount).toBe(250);
+    expect(result.ceilingHit).toBe(true);
+    expect(result.settlementDeltaCents).toBe(25_000);
+  });
+
+  it("does not set ceilingHit when checked-in is exactly the ceiling", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 250,
+      maxAttendeesAttributable: 250,
+    });
+    expect(result.finalCount).toBe(250);
+    expect(result.ceilingHit).toBe(false);
+  });
+
+  it("applies minimumQuantity floor when checked-in is below it", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 50,
+      minimumQuantity: 100,
+    });
+    expect(result.finalCount).toBe(100);
+    expect(result.settlementDeltaCents).toBe(-50_000);
+  });
+
+  it("worked example A: 200 expected / 250 ceiling / 220 checked-in", () => {
+    const result = computeEventPromoterSettlement({
+      baseRateCents: 500,
+      expectedAttendeesAtBooking: 200,
+      totalCheckedInAttendees: 220,
+      maxAttendeesAttributable: 250,
+    });
+    expect(result.finalCount).toBe(220);
+    expect(result.settlementDeltaCents).toBe(10_000);
+    expect(result.ceilingHit).toBe(false);
+  });
+
+  it("worked example B: 100 expected / 150 ceiling / 220 checked-in (capped)", () => {
+    const result = computeEventPromoterSettlement({
+      baseRateCents: 500,
+      expectedAttendeesAtBooking: 100,
+      totalCheckedInAttendees: 220,
+      maxAttendeesAttributable: 150,
+    });
+    expect(result.finalCount).toBe(150);
+    expect(result.settlementDeltaCents).toBe(25_000);
+    expect(result.ceilingHit).toBe(true);
+  });
+
+  it("treats negative checked-in as 0", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: -10,
+    });
+    expect(result.finalCount).toBe(0);
+    expect(result.settlementDeltaCents).toBe(-100_000);
+  });
+
+  it("treats null ceiling as no cap", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 999,
+      maxAttendeesAttributable: null,
+    });
+    expect(result.finalCount).toBe(999);
+    expect(result.ceilingHit).toBe(false);
+  });
+});
+
+describe("buildIssuePromoCodeDeepLink", () => {
+  it("includes bashEventId, promoterUserId, and source param", () => {
+    const url = buildIssuePromoCodeDeepLink({
+      bashEventId: "bash-1",
+      promoterUserId: "user-9",
+    });
+    expect(url).toContain("/bashes/bash-1/edit");
+    expect(url).toContain("step=how");
+    expect(url).toContain("open=promo-codes");
+    expect(url).toContain("promoterUserId=user-9");
+    expect(url).toContain("source=event-promoter-booking");
+    expect(url).not.toContain("ticketTierId=");
+  });
+
+  it("adds ticketTierId when provided", () => {
+    const url = buildIssuePromoCodeDeepLink({
+      bashEventId: "bash-1",
+      promoterUserId: "user-9",
+      ticketTierId: "tier-42",
+    });
+    expect(url).toContain("ticketTierId=tier-42");
+  });
+
+  it("omits ticketTierId when null/undefined", () => {
+    const urlNull = buildIssuePromoCodeDeepLink({
+      bashEventId: "bash-1",
+      promoterUserId: "user-9",
+      ticketTierId: null,
+    });
+    const urlUndef = buildIssuePromoCodeDeepLink({
+      bashEventId: "bash-1",
+      promoterUserId: "user-9",
+    });
+    expect(urlNull).not.toContain("ticketTierId=");
+    expect(urlUndef).not.toContain("ticketTierId=");
+  });
+});
+
+describe("decideEventPromoterCancellation", () => {
+  const HOUR = 60 * 60 * 1000;
+  const now = Date.parse("2026-05-12T12:00:00Z");
+
+  it("blocks any cancellation once the booking is settled", () => {
+    const result = decideEventPromoterCancellation({
+      who: "host",
+      nowMs: now,
+      bashStartMs: now + 100 * HOUR,
+      bashEndMs: now + 105 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: true,
+    });
+    expect(result.allow).toBe(false);
+    expect(result.outcome).toBe("Blocked");
+    expect(result.refundCents).toBe(0);
+  });
+
+  it("host: full refund when bash is far in the future", () => {
+    const result = decideEventPromoterCancellation({
+      who: "host",
+      nowMs: now,
+      bashStartMs: now + 100 * HOUR,
+      bashEndMs: now + 105 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.allow).toBe(true);
+    expect(result.outcome).toBe("FullRefund");
+    expect(result.refundCents).toBe(100_000);
+    expect(result.penaltyFraction).toBe(0);
+  });
+
+  it("host: partial refund inside the late-cancel window", () => {
+    const result = decideEventPromoterCancellation({
+      who: "host",
+      nowMs: now,
+      bashStartMs: now + (EVENT_PROMOTER_LATE_CANCEL_HOURS - 6) * HOUR,
+      bashEndMs: now + (EVENT_PROMOTER_LATE_CANCEL_HOURS - 1) * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.outcome).toBe("PartialRefund");
+    expect(result.penaltyFraction).toBe(
+      EVENT_PROMOTER_LATE_CANCEL_PENALTY_FRACTION
+    );
+    expect(result.refundCents).toBe(75_000);
+  });
+
+  it("host: NoRefund once the bash has started — settlement handles money", () => {
+    const result = decideEventPromoterCancellation({
+      who: "host",
+      nowMs: now,
+      bashStartMs: now - 1 * HOUR,
+      bashEndMs: now + 4 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.allow).toBe(false);
+    expect(result.outcome).toBe("NoRefund");
+  });
+
+  it("promoter: full refund any time before the bash starts", () => {
+    const result = decideEventPromoterCancellation({
+      who: "promoter",
+      nowMs: now,
+      bashStartMs: now + 3 * HOUR,
+      bashEndMs: now + 8 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.allow).toBe(true);
+    expect(result.outcome).toBe("FullRefund");
+    expect(result.refundCents).toBe(100_000);
+  });
+
+  it("promoter: blocked once the bash has started", () => {
+    const result = decideEventPromoterCancellation({
+      who: "promoter",
+      nowMs: now,
+      bashStartMs: now - 1 * HOUR,
+      bashEndMs: now + 4 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.allow).toBe(false);
+    expect(result.outcome).toBe("Blocked");
+  });
+
+  it("admin: always allowed, full refund before bash, NoRefund after", () => {
+    const before = decideEventPromoterCancellation({
+      who: "admin",
+      nowMs: now,
+      bashStartMs: now + 100 * HOUR,
+      bashEndMs: now + 105 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(before.allow).toBe(true);
+    expect(before.outcome).toBe("FullRefund");
+
+    const after = decideEventPromoterCancellation({
+      who: "admin",
+      nowMs: now,
+      bashStartMs: now - 5 * HOUR,
+      bashEndMs: now - 1 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(after.allow).toBe(true);
+    expect(after.outcome).toBe("NoRefund");
+  });
+});

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

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE,
+  validateOfferAgainstAllowList,
+} from "../offerAllowListUtils.js";
+
+describe("validateOfferAgainstAllowList", () => {
+  it("passes when allow-list is empty (no host restriction)", () => {
+    expect(
+      validateOfferAgainstAllowList({
+        offered: "PER_ATTENDEE",
+        allowList: [],
+      }).ok
+    ).toBe(true);
+    expect(
+      validateOfferAgainstAllowList({
+        offered: "FLAT_FEE",
+        allowList: null,
+      }).ok
+    ).toBe(true);
+  });
+
+  it("passes when offered model is on the allow-list", () => {
+    expect(
+      validateOfferAgainstAllowList({
+        offered: "PER_PAID_ATTENDEE",
+        allowList: ["FLAT_FEE", "PER_PAID_ATTENDEE"],
+      }).ok
+    ).toBe(true);
+  });
+
+  it("rejects when offered model is NOT on the allow-list", () => {
+    const r = validateOfferAgainstAllowList({
+      offered: "PER_BASHPOINTS_ATTENDEE",
+      allowList: ["FLAT_FEE", "PER_PAID_ATTENDEE"],
+    });
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.reason).toContain("FLAT_FEE");
+      expect(r.reason).toContain("PER_BASHPOINTS_ATTENDEE");
+    }
+  });
+
+  it("rejects when offered is missing", () => {
+    const r = validateOfferAgainstAllowList({
+      offered: null,
+      allowList: ["FLAT_FEE"],
+    });
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toMatch(/missing/);
+  });
+});
+
+describe("DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE", () => {
+  it("has a default for every service vertical the wizard ships", () => {
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.Vendors.length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.Exhibitors.length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.Sponsors.length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.Venues.length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.EntertainmentServices
+        .length
+    ).toBeGreaterThan(0);
+    expect(
+      DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE.EventServices.length
+    ).toBeGreaterThan(0);
+  });
+});

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

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "@jest/globals";
+import { computeOfferComparisonBands } from "../offerComparisonUtils.js";
+
+describe("computeOfferComparisonBands FLAT family", () => {
+  it("returns identical bands for FLAT_FEE", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "FLAT_FEE",
+      flatRateCents: 50_000,
+    });
+    expect(r.expectedTotalCents).toBe(50_000);
+    expect(r.worstCaseCents).toBe(50_000);
+    expect(r.bestCaseCents).toBe(50_000);
+    expect(r.reasoning).toContain("Fixed price");
+  });
+
+  it("HOURLY and PER_DAY treated as flat", () => {
+    expect(
+      computeOfferComparisonBands({
+        pricingModel: "HOURLY",
+        baseRateCents: 15_000,
+      }).expectedTotalCents
+    ).toBe(15_000);
+    expect(
+      computeOfferComparisonBands({
+        pricingModel: "PER_DAY",
+        baseRateCents: 40_000,
+      }).expectedTotalCents
+    ).toBe(40_000);
+  });
+});
+
+describe("computeOfferComparisonBands PER_ATTENDEE family", () => {
+  it("expects rate * expected, applies minimum floor", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PER_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendees: 200,
+      minimumQuantity: 100,
+      minimumChargeCents: 70_000,
+    });
+    expect(r.expectedTotalCents).toBe(100_000);
+    expect(r.bestCaseCents).toBeGreaterThanOrEqual(70_000);
+  });
+
+  it("worst case respects maxBillableCents when present", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PER_PAID_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendees: 200,
+      maxBillableCents: 200_000,
+    });
+    expect(r.worstCaseCents).toBe(200_000);
+  });
+
+  it("worst case defaults to 1.5x when no cap", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PER_ATTENDEE",
+      baseRateCents: 500,
+      expectedAttendees: 200,
+    });
+    expect(r.worstCaseCents).toBe(Math.round(200 * 500 * 1.5));
+  });
+});
+
+describe("computeOfferComparisonBands PER_BASHPOINTS_ATTENDEE", () => {
+  it("returns BP bands only, USD bands null", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PER_BASHPOINTS_ATTENDEE",
+      baseRateBashPoints: 10,
+      expectedAttendees: 200,
+      minimumQuantity: 100,
+    });
+    expect(r.expectedTotalCents).toBeNull();
+    expect(r.expectedTotalBp).toBe(2000);
+    expect(r.bestCaseBp).toBe(1000);
+  });
+});
+
+describe("computeOfferComparisonBands revenue-share", () => {
+  it("expected = basis * pct; worst case zero", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "TICKET_REVENUE_PERCENTAGE",
+      expectedBasisCents: 1_000_000,
+      percentage: 30,
+    });
+    expect(r.expectedTotalCents).toBe(300_000);
+    expect(r.bestCaseCents).toBe(300_000);
+    expect(r.worstCaseCents).toBe(0);
+  });
+
+  it("clamps percentage", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "PRODUCT_SALES_PERCENTAGE",
+      expectedBasisCents: 1_000_000,
+      percentage: 200,
+    });
+    expect(r.expectedTotalCents).toBe(1_000_000);
+  });
+});
+
+describe("computeOfferComparisonBands TIERED", () => {
+  it("uses chosen tier as expected, low/high for bands", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "TIERED",
+      tieredExpectedTierCents: 200_000,
+      tieredLowestTierCents: 100_000,
+      tieredHighestTierCents: 500_000,
+    });
+    expect(r.expectedTotalCents).toBe(200_000);
+    expect(r.bestCaseCents).toBe(100_000);
+    expect(r.worstCaseCents).toBe(500_000);
+  });
+});
+
+describe("computeOfferComparisonBands fallback", () => {
+  it("treats unknown model as flat", () => {
+    const r = computeOfferComparisonBands({
+      pricingModel: "MYSTERY_MODEL",
+      baseRateCents: 30_000,
+    });
+    expect(r.expectedTotalCents).toBe(30_000);
+    expect(r.reasoning).toContain("Unrecognized");
+  });
+});