@bash-app/bash-common 30.276.0 → 30.279.0

package/src/utils/paymentUtils.ts

@@ -316,6 +316,120 @@ export function splitBashPlatformFeeForTicketCheckout(args: {
   return { totalPlatformCents: total, guestPlatformLineCents: guestLine };
 }
 
+/** Event fields needed for guest-facing ticket fee display and checkout breakdown. */
+export type TicketFeeEventContext = {
+  feeHandling?: string | null;
+  platformFeeEnabled?: boolean;
+  platformFeeRate?: number;
+  externalTicketUrl?: string | null;
+};
+
+export type GuestTicketCheckoutBreakdown = {
+  ticketSubtotalCents: number;
+  /** Guest-visible Stripe processing line (0 when host absorbs). */
+  guestProcessingLineCents: number;
+  guestPlatformLineCents: number;
+  /** Amount the guest pays (before tax). */
+  totalDueCents: number;
+  /** Stripe's 2.9% + $0.30 pass-through on the charge amount. */
+  stripeProcessingCents: number;
+  bashPlatformTotalCents: number;
+  applicationFeeAmountCents: number;
+};
+
+/** True when the host absorbs Stripe processing (`feeHandling` default). */
+export function hostAbsorbsTicketProcessing(
+  feeHandling: string | null | undefined,
+): boolean {
+  return (feeHandling ?? "HostAbsorbs") === "HostAbsorbs";
+}
+
+/**
+ * Whether the event qualifies for the public "No fees for attendees" badge.
+ * External-ticket events are excluded (Bash does not control checkout).
+ */
+export function guestCheckoutHasNoAddedFees(
+  event: TicketFeeEventContext,
+): boolean {
+  if (event.externalTicketUrl) return false;
+  return hostAbsorbsTicketProcessing(event.feeHandling);
+}
+
+/**
+ * Full guest ticket checkout breakdown — single source for API charges and UI copy.
+ *
+ * HostAbsorbs (default): guest pays subtotal (+ optional platform guest line only).
+ * GuestPays/Split (enterprise): guest also pays a visible processing line (fee on subtotal, donation-style).
+ */
+export function computeGuestTicketCheckoutBreakdown(args: {
+  discountedSubtotalCents: number;
+  platformFeeEnabled: boolean;
+  platformFeeRate: number;
+  feeHandling: string | null | undefined;
+  bashPassWaivesGuestFee: boolean;
+  isVerifiedNonprofitHost?: boolean;
+}): GuestTicketCheckoutBreakdown {
+  const ticketSubtotalCents = args.discountedSubtotalCents;
+  const isVerifiedNonprofitHost = args.isVerifiedNonprofitHost === true;
+  const split = isVerifiedNonprofitHost
+    ? { totalPlatformCents: 0, guestPlatformLineCents: 0 }
+    : splitBashPlatformFeeForTicketCheckout({
+        grossCents: ticketSubtotalCents,
+        platformFeeEnabled: args.platformFeeEnabled,
+        platformFeeRate: args.platformFeeRate,
+        feeHandling: args.feeHandling,
+        bashPassWaivesGuestFee: args.bashPassWaivesGuestFee,
+      });
+  const guestPlatformLineCents = split.guestPlatformLineCents;
+  const bashPlatformTotalCents = split.totalPlatformCents;
+  const guestProcessingLineCents = hostAbsorbsTicketProcessing(args.feeHandling)
+    ? 0
+    : calculateStripeProcessingFeeCents(ticketSubtotalCents);
+  const totalDueCents =
+    ticketSubtotalCents + guestProcessingLineCents + guestPlatformLineCents;
+  const stripeProcessingCents = calculateStripeProcessingFeeCents(totalDueCents);
+  const applicationFeeAmountCents =
+    stripeProcessingCents + bashPlatformTotalCents;
+  return {
+    ticketSubtotalCents,
+    guestProcessingLineCents,
+    guestPlatformLineCents,
+    totalDueCents,
+    stripeProcessingCents,
+    bashPlatformTotalCents,
+    applicationFeeAmountCents,
+  };
+}
+
+/** All-in mandatory guest price for one USD tier (cards, detail page). */
+export function guestAllInUnitPriceCents(
+  unitPriceCents: number,
+  event: TicketFeeEventContext,
+): number {
+  if (unitPriceCents <= 0) return 0;
+  return computeGuestTicketCheckoutBreakdown({
+    discountedSubtotalCents: unitPriceCents,
+    platformFeeEnabled: event.platformFeeEnabled ?? false,
+    platformFeeRate: event.platformFeeRate ?? 0.03,
+    feeHandling: event.feeHandling,
+    bashPassWaivesGuestFee: false,
+  }).totalDueCents;
+}
+
+/** Lowest all-in USD tier price for "From $X" previews. */
+export function lowestGuestAllInPriceCents(
+  tiers: ReadonlyArray<Pick<TicketTier, "price" | "pricingType">>,
+  event: TicketFeeEventContext,
+): number | null {
+  let min: number | null = null;
+  for (const tier of tiers) {
+    if (tier.pricingType === "BASHPOINTS" || tier.price <= 0) continue;
+    const allIn = guestAllInUnitPriceCents(tier.price, event);
+    if (min === null || allIn < min) min = allIn;
+  }
+  return min;
+}
+
 /**
  * Compute the Stripe Connect `application_fee_amount` for a ticket-style charge,
  * along with its constituent parts.
@@ -351,28 +465,17 @@ export function computeTicketApplicationFeeAmountCents(args: {
   applicationFeeAmountCents: number;
   /** Guest-visible portion of the platform line. Zero when `isVerifiedNonprofitHost` is true. */
   guestPlatformLineCents: number;
+  /** Guest-visible Stripe processing line (0 when host absorbs). */
+  guestProcessingLineCents: number;
 } {
-  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;
-  const stripeProcessingCents = calculateStripeProcessingFeeCents(totalChargedCents);
-  const applicationFeeAmountCents = stripeProcessingCents + bashPlatformTotalCents;
+  const breakdown = computeGuestTicketCheckoutBreakdown(args);
   return {
-    totalChargedCents,
-    stripeProcessingCents,
-    bashPlatformTotalCents,
-    applicationFeeAmountCents,
-    guestPlatformLineCents,
+    totalChargedCents: breakdown.totalDueCents,
+    stripeProcessingCents: breakdown.stripeProcessingCents,
+    bashPlatformTotalCents: breakdown.bashPlatformTotalCents,
+    applicationFeeAmountCents: breakdown.applicationFeeAmountCents,
+    guestPlatformLineCents: breakdown.guestPlatformLineCents,
+    guestProcessingLineCents: breakdown.guestProcessingLineCents,
   };
 }
 

package/src/utils/recurrenceUtils.ts

@@ -1,4 +1,4 @@
-import { DayOfWeek, Recurrence, RecurringFrequency } from "@prisma/client";
+import { DayOfWeek, Prisma, Recurrence, RecurringFrequency } from "@prisma/client";
 import { DateTime, WeekdayNumbers } from "luxon";
 import { DateTimeArgType } from "../definitions.js";
 import {
@@ -10,6 +10,77 @@ import {
 import { compareDateTime } from "./dateTimeUtils.js";
 import { dayOfWeekToIdx } from "./generalDateTimeUtils.js";
 
+/**
+ * Per-occurrence date/time move. Keyed (in `Recurrence.occurrenceOverrides`) by the
+ * original generated occurrence's `LUXON_DATETIME_FORMAT_ISO_LIKE` string.
+ */
+export interface OccurrenceOverride {
+  startDateTime: string; // ISO
+  endDateTime?: string | null; // ISO
+}
+
+export type OccurrenceOverrideMap = Record<string, OccurrenceOverride>;
+
+/**
+ * Recurrence fields sent on create/update; `occurrenceOverrides` is the typed map
+ * (not Prisma `JsonValue`) so app/API mappers compile without casts.
+ */
+export type RecurrenceWireInput = Omit<
+  Partial<Recurrence>,
+  "occurrenceOverrides"
+> & {
+  occurrenceOverrides?: OccurrenceOverrideMap | Prisma.JsonValue | null;
+};
+
+/**
+ * Stable key for an occurrence within a series. Both the generator and the
+ * skip/move persistence must derive the key the same way, so callers should use this.
+ */
+export function occurrenceOverrideKey(
+  occurrenceStart: Date | string | DateTime
+): string {
+  const dt = DateTime.isDateTime(occurrenceStart)
+    ? occurrenceStart
+    : dateTimeFromDate(occurrenceStart);
+  return dt.toFormat(LUXON_DATETIME_FORMAT_ISO_LIKE);
+}
+
+/** Safely coerce the `Recurrence.occurrenceOverrides` Json column into a typed map. */
+export function parseOccurrenceOverrides(
+  raw: unknown
+): OccurrenceOverrideMap {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const out: OccurrenceOverrideMap = {};
+  for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (
+      value &&
+      typeof value === "object" &&
+      typeof (value as { startDateTime?: unknown }).startDateTime === "string"
+    ) {
+      const v = value as { startDateTime: string; endDateTime?: unknown };
+      out[key] = {
+        startDateTime: v.startDateTime,
+        endDateTime:
+          typeof v.endDateTime === "string" ? v.endDateTime : null,
+      };
+    }
+  }
+  return out;
+}
+
+/** True when the host has skipped or moved at least one occurrence in the series. */
+export function recurrenceHasOccurrenceExceptions(
+  recurrence: Recurrence | null | undefined
+): boolean {
+  if (!recurrence) return false;
+  const excluded = (recurrence as { excludedDates?: Date[] }).excludedDates ?? [];
+  if (excluded.length > 0) return true;
+  const overrides = parseOccurrenceOverrides(
+    (recurrence as { occurrenceOverrides?: unknown }).occurrenceOverrides
+  );
+  return Object.keys(overrides).length > 0;
+}
+
 export function getRecurringBashEventPossibleDateTimes(
   startDateTime: DateTimeArgType,
   recurrence: Recurrence | undefined | null
@@ -79,6 +150,11 @@ function getRecurringBashEventPossibleDatesTimesInternal(
     recurrenceDates = recurrenceDates.slice(0, recurrence.repeatCount);
   }
 
+  // Apply per-occurrence exceptions against the original generated instants:
+  // 1) drop occurrences the host removed (excludedDates)
+  // 2) move occurrences the host rescheduled (occurrenceOverrides)
+  recurrenceDates = applyOccurrenceExceptions(recurrenceDates, recurrence);
+
   return recurrenceDates
     .map((date: DateTime): string =>
       date.toFormat(LUXON_DATETIME_FORMAT_ISO_LIKE)
@@ -97,6 +173,45 @@ function getRecurringBashEventPossibleDatesTimesInternal(
     });
 }
 
+/**
+ * Remove skipped occurrences and apply rescheduled (moved) occurrences. Matching is by
+ * the original occurrence's `LUXON_DATETIME_FORMAT_ISO_LIKE` key so it survives the
+ * format→reparse round-trip the generator already does.
+ */
+function applyOccurrenceExceptions(
+  occurrences: DateTime[],
+  recurrence: Recurrence
+): DateTime[] {
+  const excludedKeys = new Set(
+    (
+      ((recurrence as { excludedDates?: Date[] }).excludedDates) ?? []
+    ).map((d) => occurrenceOverrideKey(d))
+  );
+  const overrides = parseOccurrenceOverrides(
+    (recurrence as { occurrenceOverrides?: unknown }).occurrenceOverrides
+  );
+
+  if (excludedKeys.size === 0 && Object.keys(overrides).length === 0) {
+    return occurrences;
+  }
+
+  const result: DateTime[] = [];
+  for (const occ of occurrences) {
+    const key = occurrenceOverrideKey(occ);
+    if (excludedKeys.has(key)) continue;
+    const override = overrides[key];
+    if (override?.startDateTime) {
+      const moved = dateTimeFromDate(new Date(override.startDateTime));
+      if (moved.isValid) {
+        result.push(moved);
+        continue;
+      }
+    }
+    result.push(occ);
+  }
+  return result;
+}
+
 /**
  * Get the daily recurring dates
  * @param beginningDateTime The beginning DateTime of the event, adjusted to be no earlier than now.

package/src/utils/service/serviceBookingTypes.ts

@@ -67,6 +67,9 @@ export type ServiceBookingRequiredData = MakeNullablePropsOptional<
     // so callers building a new booking shape may omit them.
     | "settlementStatus"
     | "settlementAttempts"
+    // Reschedule lifecycle — DB defaults `rescheduleStatus` to None; the rest are
+    // nullable and set only when a host moves the date.
+    | "rescheduleStatus"
   >
 >;