@bash-app/bash-common 30.235.0 → 30.237.0

package/src/utils/__tests__/nonprofitUtils.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  isVerifiedNonprofitOrganization,
+  type NonprofitVerificationFields,
+} from "../nonprofitUtils.js";
+
+const fullyVerified: NonprofitVerificationFields = {
+  nonprofitCountry: "US",
+  nonprofitRegistrationNumber: "12-3456789",
+  nonprofitVerifiedAt: new Date("2025-01-15T00:00:00Z"),
+  stripeNonprofitPricingStatus: "NotApplied",
+};
+
+describe("isVerifiedNonprofitOrganization", () => {
+  test("null returns false", () => {
+    expect(isVerifiedNonprofitOrganization(null)).toBe(false);
+  });
+
+  test("undefined returns false", () => {
+    expect(isVerifiedNonprofitOrganization(undefined)).toBe(false);
+  });
+
+  test("missing nonprofitVerifiedAt returns false even with country + EIN", () => {
+    expect(
+      isVerifiedNonprofitOrganization({
+        ...fullyVerified,
+        nonprofitVerifiedAt: null,
+      })
+    ).toBe(false);
+  });
+
+  test("missing nonprofitRegistrationNumber returns false", () => {
+    expect(
+      isVerifiedNonprofitOrganization({
+        ...fullyVerified,
+        nonprofitRegistrationNumber: null,
+      })
+    ).toBe(false);
+  });
+
+  test("blank/whitespace nonprofitRegistrationNumber returns false", () => {
+    expect(
+      isVerifiedNonprofitOrganization({
+        ...fullyVerified,
+        nonprofitRegistrationNumber: "   ",
+      })
+    ).toBe(false);
+  });
+
+  test("missing nonprofitCountry returns false", () => {
+    expect(
+      isVerifiedNonprofitOrganization({
+        ...fullyVerified,
+        nonprofitCountry: null,
+      })
+    ).toBe(false);
+  });
+
+  test("blank/whitespace nonprofitCountry returns false", () => {
+    expect(
+      isVerifiedNonprofitOrganization({
+        ...fullyVerified,
+        nonprofitCountry: "   ",
+      })
+    ).toBe(false);
+  });
+
+  test("all required fields set returns true", () => {
+    expect(isVerifiedNonprofitOrganization(fullyVerified)).toBe(true);
+  });
+
+  test("non-US verified charity (e.g. UK) returns true", () => {
+    expect(
+      isVerifiedNonprofitOrganization({
+        ...fullyVerified,
+        nonprofitCountry: "GB",
+        nonprofitRegistrationNumber: "1234567",
+      })
+    ).toBe(true);
+  });
+
+  test("Stripe nonprofit-pricing status does NOT affect verification truthiness", () => {
+    const statuses: NonprofitVerificationFields["stripeNonprofitPricingStatus"][] = [
+      "NotApplied",
+      "Pending",
+      "Approved",
+      "Declined",
+    ];
+    for (const status of statuses) {
+      expect(
+        isVerifiedNonprofitOrganization({
+          ...fullyVerified,
+          stripeNonprofitPricingStatus: status,
+        })
+      ).toBe(true);
+    }
+  });
+
+  test("Declined Stripe status with no Bash verification stamp is still NOT verified", () => {
+    expect(
+      isVerifiedNonprofitOrganization({
+        ...fullyVerified,
+        nonprofitVerifiedAt: null,
+        stripeNonprofitPricingStatus: "Declined",
+      })
+    ).toBe(false);
+  });
+
+  test("future nonprofitVerifiedAt is NOT yet verified", () => {
+    expect(
+      isVerifiedNonprofitOrganization({
+        ...fullyVerified,
+        nonprofitVerifiedAt: new Date(Date.now() + 60_000),
+      })
+    ).toBe(false);
+  });
+});

package/src/utils/__tests__/paymentUtils.test.ts

@@ -147,6 +147,99 @@ describe("PaymentUtils - Core Functions", () => {
       expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents + 300);
     });
 
+    test("computeTicketApplicationFeeAmountCents — explicit isVerifiedNonprofitHost: false matches default", () => {
+      const baseArgs = {
+        discountedSubtotalCents: 10000,
+        platformFeeEnabled: true,
+        platformFeeRate: 0.03,
+        feeHandling: "HostAbsorbs" as const,
+        bashPassWaivesGuestFee: false,
+      };
+      const defaulted = computeTicketApplicationFeeAmountCents(baseArgs);
+      const explicitFalse = computeTicketApplicationFeeAmountCents({
+        ...baseArgs,
+        isVerifiedNonprofitHost: false,
+      });
+      expect(explicitFalse).toEqual(defaulted);
+    });
+
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit host: zero Bash platform, Stripe untouched", () => {
+      const r = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 10000,
+        platformFeeEnabled: true,
+        platformFeeRate: 0.03,
+        feeHandling: "GuestPays",
+        bashPassWaivesGuestFee: false,
+        isVerifiedNonprofitHost: true,
+      });
+      expect(r.bashPlatformTotalCents).toBe(0);
+      expect(r.guestPlatformLineCents).toBe(0);
+      expect(r.totalChargedCents).toBe(10000);
+      expect(r.stripeProcessingCents).toBe(calculateStripeProcessingFeeCents(10000));
+      expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
+    });
+
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit waiver overrides feeHandling=GuestPays", () => {
+      const nonNonprofit = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 5000,
+        platformFeeEnabled: true,
+        platformFeeRate: 0.05,
+        feeHandling: "GuestPays",
+        bashPassWaivesGuestFee: false,
+      });
+      expect(nonNonprofit.bashPlatformTotalCents).toBe(250);
+      expect(nonNonprofit.guestPlatformLineCents).toBe(250);
+      expect(nonNonprofit.totalChargedCents).toBe(5250);
+
+      const nonprofit = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 5000,
+        platformFeeEnabled: true,
+        platformFeeRate: 0.05,
+        feeHandling: "GuestPays",
+        bashPassWaivesGuestFee: false,
+        isVerifiedNonprofitHost: true,
+      });
+      expect(nonprofit.bashPlatformTotalCents).toBe(0);
+      expect(nonprofit.guestPlatformLineCents).toBe(0);
+      expect(nonprofit.totalChargedCents).toBe(5000);
+      expect(nonprofit.applicationFeeAmountCents).toBe(nonprofit.stripeProcessingCents);
+    });
+
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit waiver beats any membership-tier math", () => {
+      const tierCases = [
+        { feeHandling: "HostAbsorbs" as const, bashPassWaivesGuestFee: false },
+        { feeHandling: "Split" as const, bashPassWaivesGuestFee: false },
+        { feeHandling: "GuestPays" as const, bashPassWaivesGuestFee: true },
+      ];
+      for (const tier of tierCases) {
+        const r = computeTicketApplicationFeeAmountCents({
+          discountedSubtotalCents: 12345,
+          platformFeeEnabled: true,
+          platformFeeRate: 0.04,
+          feeHandling: tier.feeHandling,
+          bashPassWaivesGuestFee: tier.bashPassWaivesGuestFee,
+          isVerifiedNonprofitHost: true,
+        });
+        expect(r.bashPlatformTotalCents).toBe(0);
+        expect(r.guestPlatformLineCents).toBe(0);
+        expect(r.totalChargedCents).toBe(12345);
+        expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
+      }
+    });
+
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit + platformFeeEnabled=false still zeroes the take", () => {
+      const r = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 2500,
+        platformFeeEnabled: false,
+        platformFeeRate: 0.03,
+        feeHandling: "HostAbsorbs",
+        bashPassWaivesGuestFee: false,
+        isVerifiedNonprofitHost: true,
+      });
+      expect(r.bashPlatformTotalCents).toBe(0);
+      expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
+    });
+
     test("userHasActiveBashPass", () => {
       expect(userHasActiveBashPass({ bashPassStripeSubscriptionId: null, bashPassCurrentPeriodEnd: null })).toBe(false);
       expect(userHasActiveBashPass({ bashPassStripeSubscriptionId: "sub_1", bashPassCurrentPeriodEnd: null })).toBe(true);

package/src/utils/nonprofitUtils.ts

@@ -0,0 +1,44 @@
+import type { Organization } from "@prisma/client";
+
+/**
+ * Subset of `Organization` fields the verified-nonprofit helpers need. Callers
+ * may pass any prisma payload that selects (or includes) at least these
+ * columns — keeps consumers free to use narrow `select` shapes.
+ */
+export type NonprofitVerificationFields = Pick<
+  Organization,
+  | "nonprofitCountry"
+  | "nonprofitRegistrationNumber"
+  | "nonprofitVerifiedAt"
+  | "stripeNonprofitPricingStatus"
+>;
+
+/**
+ * Verified-nonprofit status is determined solely by an admin stamp:
+ * `nonprofitVerifiedAt` is set (in the past or now — future timestamps do
+ * NOT count) AND we captured `nonprofitCountry` + `nonprofitRegistrationNumber`.
+ * The Stripe nonprofit-pricing status is informational only and DOES NOT gate
+ * verification (a charity can be verified by Bash even before applying to
+ * Stripe).
+ *
+ * IMPORTANT: `BashEvent.nonProfit` is a user-entered flag and MUST NOT be
+ * passed in here. Fee-waiver code reads only the Organization's verification
+ * fields — see Phase 3 of the donation-followups-leak-fix plan.
+ */
+export function isVerifiedNonprofitOrganization(
+  org: NonprofitVerificationFields | null | undefined
+): boolean {
+  if (!org) return false;
+  if (!org.nonprofitVerifiedAt) return false;
+  if (org.nonprofitVerifiedAt.getTime() > Date.now()) return false;
+  if (!org.nonprofitCountry || org.nonprofitCountry.trim().length === 0) {
+    return false;
+  }
+  if (
+    !org.nonprofitRegistrationNumber ||
+    org.nonprofitRegistrationNumber.trim().length === 0
+  ) {
+    return false;
+  }
+  return true;
+}

package/src/utils/paymentUtils.ts

@@ -275,26 +275,52 @@ export function splitBashPlatformFeeForTicketCheckout(args: {
   return { totalPlatformCents: total, guestPlatformLineCents: guestLine };
 }
 
+/**
+ * Compute the Stripe Connect `application_fee_amount` for a ticket-style charge,
+ * along with its constituent parts.
+ *
+ * `isVerifiedNonprofitHost` waives ONLY Bash's platform take
+ * (`bashPlatformTotalCents`) — Stripe's pass-through (2.9% + $0.30) is untouched
+ * because that's not ours to waive. The host applies for Stripe nonprofit
+ * pricing directly. When `true`:
+ *   - `bashPlatformTotalCents` and `guestPlatformLineCents` are both zero
+ *   - `totalChargedCents` collapses to the discounted subtotal (no guest-line fee added)
+ *   - `applicationFeeAmountCents` equals `stripeProcessingCents`
+ *
+ * Default (`false`) preserves existing math bit-exact for every current caller.
+ */
 export function computeTicketApplicationFeeAmountCents(args: {
   discountedSubtotalCents: number;
   platformFeeEnabled: boolean;
   platformFeeRate: number;
   feeHandling: string | null | undefined;
   bashPassWaivesGuestFee: boolean;
+  /**
+   * Verified-nonprofit hosts pay no Bash platform fee. Sourced from
+   * `isVerifiedNonprofitOrganization()` over the host's Organization row —
+   * NEVER from `BashEvent.nonProfit`, which is user-entered.
+   */
+  isVerifiedNonprofitHost?: boolean;
 }): {
   totalChargedCents: number;
+  /** Stripe's 2.9% + $0.30 pass-through; unchanged by the nonprofit waiver. */
   stripeProcessingCents: number;
+  /** Bash's platform take. Zero when `isVerifiedNonprofitHost` is true. */
   bashPlatformTotalCents: number;
   applicationFeeAmountCents: number;
+  /** Guest-visible portion of the platform line. Zero when `isVerifiedNonprofitHost` is true. */
   guestPlatformLineCents: number;
 } {
-  const split = splitBashPlatformFeeForTicketCheckout({
-    grossCents: args.discountedSubtotalCents,
-    platformFeeEnabled: args.platformFeeEnabled,
-    platformFeeRate: args.platformFeeRate,
-    feeHandling: args.feeHandling,
-    bashPassWaivesGuestFee: args.bashPassWaivesGuestFee,
-  });
+  const isVerifiedNonprofitHost = args.isVerifiedNonprofitHost === true;
+  const split = isVerifiedNonprofitHost
+    ? { totalPlatformCents: 0, guestPlatformLineCents: 0 }
+    : splitBashPlatformFeeForTicketCheckout({
+        grossCents: args.discountedSubtotalCents,
+        platformFeeEnabled: args.platformFeeEnabled,
+        platformFeeRate: args.platformFeeRate,
+        feeHandling: args.feeHandling,
+        bashPassWaivesGuestFee: args.bashPassWaivesGuestFee,
+      });
   const guestPlatformLineCents = split.guestPlatformLineCents;
   const bashPlatformTotalCents = split.totalPlatformCents;
   const totalChargedCents = args.discountedSubtotalCents + guestPlatformLineCents;

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

@@ -0,0 +1,175 @@
+import {
+  DEFAULT_MAX_BILLABLE_MULTIPLIER,
+  DEFAULT_MAX_BILLABLE_ROUNDING_CENTS,
+  DEFAULT_VARIABLE_PAYOUT_TIMING_NOTE,
+  defaultMaxBillableBashPoints,
+  defaultMaxBillableCents,
+  isFlatPricingModel,
+} from "../billingCapUtils";
+
+describe("defaultMaxBillableCents", () => {
+  it("computes 1.5x of expectedAttendees * baseRateCents, rounded up to $10", () => {
+    // 200 * $5 * 1.5 = $1500 — already a $10 multiple.
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 200, baseRateCents: 500 })
+    ).toBe(150_000);
+  });
+
+  it("rounds the cap UP to the nearest $10", () => {
+    // 217 * 500 * 1.5 = 162,750 cents = $1,627.50 → round up to $1,630.
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 217, baseRateCents: 500 })
+    ).toBe(163_000);
+  });
+
+  it("returns 0 when expectedAttendees is zero", () => {
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 0, baseRateCents: 500 })
+    ).toBe(0);
+  });
+
+  it("returns 0 when expectedAttendees is null or undefined", () => {
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: null, baseRateCents: 500 })
+    ).toBe(0);
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: undefined,
+        baseRateCents: 500,
+      })
+    ).toBe(0);
+  });
+
+  it("returns null when baseRateCents is missing or zero", () => {
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 100, baseRateCents: null })
+    ).toBeNull();
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 100, baseRateCents: 0 })
+    ).toBeNull();
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: 100,
+        baseRateCents: undefined,
+      })
+    ).toBeNull();
+  });
+
+  it("clamps negative expectedAttendees to zero", () => {
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: -50, baseRateCents: 500 })
+    ).toBe(0);
+  });
+
+  it("respects an explicit multiplier override", () => {
+    // 100 * 500 * 2.0 = 100,000 → $1,000.
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: 100,
+        baseRateCents: 500,
+        multiplier: 2,
+      })
+    ).toBe(100_000);
+  });
+
+  it("falls back to default multiplier when override is invalid", () => {
+    const out = defaultMaxBillableCents({
+      expectedAttendees: 100,
+      baseRateCents: 500,
+      multiplier: 0,
+    });
+    expect(out).toBe(100 * 500 * DEFAULT_MAX_BILLABLE_MULTIPLIER);
+  });
+
+  it("respects a custom rounding granularity", () => {
+    // 200 * 500 * 1.5 = 150,000 cents = $1,500 — already a $100 multiple.
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: 200,
+        baseRateCents: 500,
+        roundingCents: 10_000,
+      })
+    ).toBe(150_000);
+    // 101 * 500 * 1.5 = 75,750 cents = $757.50 → round up to nearest $100 = $800 = 80_000 cents.
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: 101,
+        baseRateCents: 500,
+        roundingCents: 10_000,
+      })
+    ).toBe(80_000);
+  });
+
+  it("uses the platform default rounding when override is invalid", () => {
+    const out = defaultMaxBillableCents({
+      expectedAttendees: 217,
+      baseRateCents: 500,
+      roundingCents: 0,
+    });
+    // Falls back to DEFAULT rounding ($10) → same as the rounded case above.
+    expect(out).toBe(
+      Math.ceil((217 * 500 * 1.5) / DEFAULT_MAX_BILLABLE_ROUNDING_CENTS) *
+        DEFAULT_MAX_BILLABLE_ROUNDING_CENTS
+    );
+  });
+});
+
+describe("defaultMaxBillableBashPoints", () => {
+  it("computes the BP parallel of the USD cap, rounded up to nearest 100 BP", () => {
+    // 100 * 50 * 1.5 = 7,500 — already a 100-multiple.
+    expect(
+      defaultMaxBillableBashPoints({
+        expectedAttendees: 100,
+        baseRateBashPoints: 50,
+      })
+    ).toBe(7_500);
+  });
+
+  it("rounds up to the nearest 100 BashPoints", () => {
+    // 33 * 50 * 1.5 = 2,475 → round up to 2,500.
+    expect(
+      defaultMaxBillableBashPoints({
+        expectedAttendees: 33,
+        baseRateBashPoints: 50,
+      })
+    ).toBe(2_500);
+  });
+
+  it("returns null when baseRateBashPoints is missing", () => {
+    expect(
+      defaultMaxBillableBashPoints({
+        expectedAttendees: 100,
+        baseRateBashPoints: null,
+      })
+    ).toBeNull();
+  });
+});
+
+describe("isFlatPricingModel", () => {
+  it("recognizes the three flat models", () => {
+    expect(isFlatPricingModel("FLAT_FEE")).toBe(true);
+    expect(isFlatPricingModel("HOURLY")).toBe(true);
+    expect(isFlatPricingModel("PER_DAY")).toBe(true);
+  });
+
+  it("returns false for variable models", () => {
+    expect(isFlatPricingModel("PER_ATTENDEE")).toBe(false);
+    expect(isFlatPricingModel("PER_PAID_ATTENDEE")).toBe(false);
+    expect(isFlatPricingModel("PER_BASHPOINTS_ATTENDEE")).toBe(false);
+    expect(isFlatPricingModel("TICKET_REVENUE_PERCENTAGE")).toBe(false);
+    expect(isFlatPricingModel("TIERED")).toBe(false);
+    expect(isFlatPricingModel("CUSTOM")).toBe(false);
+  });
+
+  it("returns false for null / undefined / empty", () => {
+    expect(isFlatPricingModel(null)).toBe(false);
+    expect(isFlatPricingModel(undefined)).toBe(false);
+    expect(isFlatPricingModel("")).toBe(false);
+  });
+});
+
+describe("DEFAULT_VARIABLE_PAYOUT_TIMING_NOTE", () => {
+  it("mentions the ~3 business day window", () => {
+    expect(DEFAULT_VARIABLE_PAYOUT_TIMING_NOTE).toMatch(/3 business days/i);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { ServiceCancellationPolicy } from "@prisma/client";
+import { ServiceCancellationPolicy } from "../../../mirroredPrismaEnums.js";
 import {
   hoursUntilEventStart,
   cancellationRuleThresholdHours,