@bash-app/bash-common 30.285.0 → 30.289.0

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

@@ -0,0 +1,122 @@
+import {
+  entertainerFitsHostExpectedCrowd,
+  findNotableVenueNameMatch,
+  getEntertainerEffectiveDraw,
+  getVenueEffectiveCapacity,
+  scoreDrawCapacityFit,
+} from "../entertainmentDrawFit.js";
+
+describe("getEntertainerEffectiveDraw", () => {
+  it("prefers shared expected draw", () => {
+    expect(
+      getEntertainerEffectiveDraw({
+        expected: 120,
+        showExpectedGuests: true,
+        ideal: 80,
+        showIdealGuests: true,
+        minimum: 40,
+        showMinimumGuests: true,
+      })
+    ).toBe(120);
+  });
+
+  it("falls back to ideal then minimum", () => {
+    expect(
+      getEntertainerEffectiveDraw({
+        expected: 120,
+        showExpectedGuests: false,
+        ideal: 80,
+        showIdealGuests: true,
+        minimum: 40,
+        showMinimumGuests: true,
+      })
+    ).toBe(80);
+  });
+});
+
+describe("scoreDrawCapacityFit", () => {
+  it("awards full points when draw fits capacity", () => {
+    const result = scoreDrawCapacityFit(
+      { capacity: 200 },
+      {
+        expected: 150,
+        showExpectedGuests: true,
+        ideal: null,
+        showIdealGuests: false,
+        minimum: null,
+        showMinimumGuests: false,
+      }
+    );
+    expect(result.points).toBe(15);
+    expect(result.reason).toMatch(/fits venue capacity/i);
+  });
+
+  it("gives partial credit when draw is unspecified", () => {
+    const result = scoreDrawCapacityFit({ capacity: 200 }, null);
+    expect(result.points).toBe(5);
+  });
+});
+
+describe("entertainerFitsHostExpectedCrowd", () => {
+  it("passes when draw is in a reasonable band around host expectation", () => {
+    expect(
+      entertainerFitsHostExpectedCrowd(100, {
+        expected: 80,
+        showExpectedGuests: true,
+        ideal: null,
+        showIdealGuests: false,
+        minimum: null,
+        showMinimumGuests: false,
+      })
+    ).toBe(true);
+  });
+
+  it("does not exclude entertainers without draw data", () => {
+    expect(entertainerFitsHostExpectedCrowd(200, null)).toBe(true);
+  });
+
+  it("filters entertainers whose draw is far from host expectation", () => {
+    expect(
+      entertainerFitsHostExpectedCrowd(50, {
+        expected: 500,
+        showExpectedGuests: true,
+        ideal: null,
+        showIdealGuests: false,
+        minimum: null,
+        showMinimumGuests: false,
+      })
+    ).toBe(false);
+  });
+});
+
+describe("findNotableVenueNameMatch", () => {
+  it("matches substring venue names case-insensitively when sharing is enabled", () => {
+    expect(
+      findNotableVenueNameMatch("The Fillmore SF", ["Fillmore"], true)
+    ).toBe("Fillmore");
+  });
+
+  it("returns null when sharing is disabled", () => {
+    expect(
+      findNotableVenueNameMatch("The Fillmore SF", ["Fillmore"], false)
+    ).toBeNull();
+  });
+
+  it("returns null when no overlap", () => {
+    expect(
+      findNotableVenueNameMatch("Small Bar NYC", ["Madison Square Garden"], true)
+    ).toBeNull();
+  });
+});
+
+describe("getVenueEffectiveCapacity", () => {
+  it("uses capacity before anticipated attendees", () => {
+    expect(
+      getVenueEffectiveCapacity({ capacity: 300, anticipatedAttendees: 100 })
+    ).toBe(300);
+  });
+
+  it("falls back to anticipated attendees", () => {
+    expect(getVenueEffectiveCapacity({ anticipatedAttendees: 150 })).toBe(150);
+  });
+});

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

@@ -19,6 +19,15 @@ describe("resolveAttendeeListAccess", () => {
     ).toBe("TicketHolders");
   });
 
+  it("accepts RsvpGoing attendee list access", () => {
+    expect(
+      resolveAttendeeListAccess({
+        attendeeListAccess: "RsvpGoing",
+        attendeeListPublic: false,
+      })
+    ).toBe("RsvpGoing");
+  });
+
   it("falls back to legacy attendeeListPublic boolean", () => {
     expect(resolveAttendeeListAccess({ attendeeListPublic: true })).toBe(
       "Public"

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

@@ -121,6 +121,20 @@ describe("viewerCanSeeFullBashLocation", () => {
       })
     ).toBe(true);
   });
+
+  it("guest session Going unlocks address without a logged-in user", () => {
+    const bash = { ...baseBash, locationRevealAudience: "TicketHoldersAndRsvps" as const };
+    expect(
+      viewerCanSeeFullBashLocation(bash, {
+        viewerUserId: null,
+        isHostOrOrganizer: false,
+        viewerOwnsValidTicket: false,
+        viewerPublicRsvpGoing: false,
+        viewerHasAcceptedInvitation: false,
+        viewerGuestRsvpGoing: true,
+      })
+    ).toBe(true);
+  });
 });
 
 describe("isLocationGloballyPublic", () => {

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

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "@jest/globals";
+
+import { organizationHasVanitySubdomain } from "../organizationEntitlements.js";
+
+describe("organizationHasVanitySubdomain", () => {
+  test("null / undefined return false", () => {
+    expect(organizationHasVanitySubdomain(null)).toBe(false);
+    expect(organizationHasVanitySubdomain(undefined)).toBe(false);
+  });
+
+  test("non-Enterprise tiers are never entitled", () => {
+    for (const tier of ["Starter", "Growth", "Church", "Legacy", null]) {
+      expect(
+        organizationHasVanitySubdomain({
+          subscriptionTier: tier,
+          subscriptionStatus: "Active",
+        })
+      ).toBe(false);
+    }
+  });
+
+  test("Enterprise with active or trialing status is entitled", () => {
+    expect(
+      organizationHasVanitySubdomain({
+        subscriptionTier: "Enterprise",
+        subscriptionStatus: "Active",
+      })
+    ).toBe(true);
+    expect(
+      organizationHasVanitySubdomain({
+        subscriptionTier: "Enterprise",
+        subscriptionStatus: "Trialing",
+      })
+    ).toBe(true);
+  });
+
+  test("Enterprise with a missing status is treated as active (legacy/ops orgs)", () => {
+    expect(
+      organizationHasVanitySubdomain({ subscriptionTier: "Enterprise" })
+    ).toBe(true);
+    expect(
+      organizationHasVanitySubdomain({
+        subscriptionTier: "Enterprise",
+        subscriptionStatus: null,
+      })
+    ).toBe(true);
+  });
+
+  test("Enterprise with a lapsed status is not entitled", () => {
+    for (const status of ["Canceled", "PastDue", "Canceling"]) {
+      expect(
+        organizationHasVanitySubdomain({
+          subscriptionTier: "Enterprise",
+          subscriptionStatus: status,
+        })
+      ).toBe(false);
+    }
+  });
+});

package/src/utils/__tests__/reputationUtils.bayesian.test.ts

@@ -0,0 +1,48 @@
+import {
+  bayesianAverage,
+  getReputationSummary,
+  MIN_RATINGS_FOR_DISPLAY,
+} from "../reputationUtils.js";
+
+describe("bayesianAverage", () => {
+  it("returns null when there are no ratings", () => {
+    expect(bayesianAverage(null, 0)).toBeNull();
+    expect(bayesianAverage(5, 0)).toBeNull();
+  });
+
+  it("pulls low-volume averages toward the prior mean", () => {
+    const score = bayesianAverage(5, 2);
+    expect(score).not.toBeNull();
+    expect(score!).toBeLessThan(5);
+    expect(score!).toBeGreaterThan(4);
+  });
+
+  it("approaches the raw average with many ratings", () => {
+    const score = bayesianAverage(4.8, 500);
+    expect(score).toBeGreaterThan(4.7);
+    expect(score).toBeLessThanOrEqual(4.8);
+  });
+
+  it("respects custom prior options", () => {
+    const strict = bayesianAverage(5, 1, { priorCount: 50, priorMean: 3 });
+    const loose = bayesianAverage(5, 1, { priorCount: 2, priorMean: 3 });
+    expect(strict!).toBeLessThan(loose!);
+  });
+});
+
+describe("getReputationSummary", () => {
+  it("hides average until MIN_RATINGS_FOR_DISPLAY", () => {
+    const summary = getReputationSummary("host", 4.9, MIN_RATINGS_FOR_DISPLAY - 1);
+    expect(summary.hasEnoughSignal).toBe(false);
+    expect(summary.averageRating).toBeNull();
+    expect(summary.bayesianScore).not.toBeNull();
+  });
+
+  it("exposes average and bayesian score above threshold", () => {
+    const summary = getReputationSummary("venue", 4.5, 20);
+    expect(summary.hasEnoughSignal).toBe(true);
+    expect(summary.averageRating).toBe(4.5);
+    expect(summary.bayesianScore).toBeGreaterThan(4);
+    expect(summary.actorType).toBe("venue");
+  });
+});

package/src/utils/__tests__/reputationUtils.serviceListing.test.ts

@@ -0,0 +1,36 @@
+import { MIN_RATINGS_FOR_DISPLAY } from "../reputationUtils.js";
+import { getServiceListingReputation } from "../reputationUtils.js";
+
+describe("getServiceListingReputation", () => {
+  it("returns null below MIN_RATINGS_FOR_DISPLAY", () => {
+    expect(
+      getServiceListingReputation({
+        serviceRating: 4.9,
+        totalRatings: MIN_RATINGS_FOR_DISPLAY - 1,
+      })
+    ).toBeNull();
+  });
+
+  it("returns rating summary at the display threshold", () => {
+    expect(
+      getServiceListingReputation({
+        serviceRating: 4.0,
+        totalRatings: MIN_RATINGS_FOR_DISPLAY,
+      })
+    ).toEqual({
+      averageRating: 4,
+      totalRatings: MIN_RATINGS_FOR_DISPLAY,
+      sourceLabel: undefined,
+    });
+  });
+
+  it("omits sourceLabel for non-google external sources", () => {
+    expect(
+      getServiceListingReputation({
+        serviceRating: 4.2,
+        totalRatings: 8,
+        externalReviewSource: "yelp",
+      })?.sourceLabel
+    ).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,152 @@
+import {
+  applyAvailabilityPreset,
+  computeEarliestOpenDate,
+  detectAvailabilityPreset,
+  formatAvailabilityPresetLabel,
+  parseAvailableHours,
+} from "../serviceAvailabilityDisplay.js";
+
+describe("applyAvailabilityPreset", () => {
+  it("opens Mon-Fri and closes weekend for the weekdays preset", () => {
+    const config = applyAvailabilityPreset("weekdays");
+    expect(config.openDays).toEqual({
+      Monday: true,
+      Tuesday: true,
+      Wednesday: true,
+      Thursday: true,
+      Friday: true,
+      Saturday: false,
+      Sunday: false,
+    });
+    expect(config.hours?.Monday?.[0]).toEqual({
+      open: "12:00 AM",
+      close: "11:59 PM",
+    });
+    expect(config.hours?.Saturday?.[0]).toEqual({ open: "", close: "" });
+  });
+
+  it("opens Sat-Sun and closes weekdays for the weekends preset", () => {
+    const config = applyAvailabilityPreset("weekends");
+    expect(config.openDays).toEqual({
+      Monday: false,
+      Tuesday: false,
+      Wednesday: false,
+      Thursday: false,
+      Friday: false,
+      Saturday: true,
+      Sunday: true,
+    });
+  });
+
+  it("preserves base fields such as enableInstantBooking", () => {
+    const config = applyAvailabilityPreset("weekdays", {
+      enableInstantBooking: true,
+    });
+    expect(config.enableInstantBooking).toBe(true);
+  });
+});
+
+describe("detectAvailabilityPreset", () => {
+  it("round-trips applyAvailabilityPreset output", () => {
+    expect(detectAvailabilityPreset(applyAvailabilityPreset("weekdays").openDays)).toBe(
+      "weekdays"
+    );
+    expect(detectAvailabilityPreset(applyAvailabilityPreset("weekends").openDays)).toBe(
+      "weekends"
+    );
+  });
+
+  it("returns custom for mixed schedules", () => {
+    expect(
+      detectAvailabilityPreset({
+        Monday: true,
+        Tuesday: true,
+        Saturday: true,
+      })
+    ).toBe("custom");
+  });
+
+  it("returns null when there is no day information", () => {
+    expect(detectAvailabilityPreset(undefined)).toBeNull();
+    expect(detectAvailabilityPreset({})).toBeNull();
+  });
+});
+
+describe("formatAvailabilityPresetLabel", () => {
+  it("maps presets to copy", () => {
+    expect(formatAvailabilityPresetLabel("weekdays")).toBe(
+      "Available on weekdays"
+    );
+    expect(formatAvailabilityPresetLabel("weekends")).toBe(
+      "Available on weekends"
+    );
+    expect(formatAvailabilityPresetLabel("custom")).toBe("Custom availability");
+  });
+});
+
+describe("parseAvailableHours", () => {
+  it("parses a JSON string", () => {
+    const parsed = parseAvailableHours(
+      JSON.stringify({ openDays: { Monday: true } })
+    );
+    expect(parsed?.openDays?.Monday).toBe(true);
+  });
+
+  it("passes through an object and returns null for junk", () => {
+    expect(parseAvailableHours({ openDays: {} })).toEqual({ openDays: {} });
+    expect(parseAvailableHours("not json")).toBeNull();
+    expect(parseAvailableHours(null)).toBeNull();
+  });
+});
+
+describe("computeEarliestOpenDate", () => {
+  // A Wednesday, so weekday/weekend logic is easy to reason about.
+  const wednesday = new Date(2026, 0, 7);
+
+  it("returns the start date when that day is open and unblocked", () => {
+    const result = computeEarliestOpenDate({
+      openDays: applyAvailabilityPreset("weekdays").openDays,
+      fromDate: wednesday,
+    });
+    expect(result).toEqual(new Date(2026, 0, 7));
+  });
+
+  it("skips closed weekend days for a weekdays schedule", () => {
+    // Start on Saturday Jan 10 -> first open weekday is Monday Jan 12.
+    const saturday = new Date(2026, 0, 10);
+    const result = computeEarliestOpenDate({
+      openDays: applyAvailabilityPreset("weekdays").openDays,
+      fromDate: saturday,
+    });
+    expect(result).toEqual(new Date(2026, 0, 12));
+  });
+
+  it("skips owner-blocked ranges", () => {
+    const result = computeEarliestOpenDate({
+      openDays: applyAvailabilityPreset("weekdays").openDays,
+      fromDate: wednesday,
+      blockedRanges: [
+        { start: new Date(2026, 0, 7), end: new Date(2026, 0, 8) },
+      ],
+    });
+    // Wed 7 and Thu 8 blocked -> Friday Jan 9.
+    expect(result).toEqual(new Date(2026, 0, 9));
+  });
+
+  it("returns null when no day is open within the lookahead", () => {
+    const result = computeEarliestOpenDate({
+      openDays: {
+        Monday: false,
+        Tuesday: false,
+        Wednesday: false,
+        Thursday: false,
+        Friday: false,
+        Saturday: false,
+        Sunday: false,
+      },
+      fromDate: wednesday,
+      maxLookaheadDays: 14,
+    });
+    expect(result).toBeNull();
+  });
+});

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

@@ -0,0 +1,37 @@
+import { SocialEventCadence } from "@prisma/client";
+import { describe, expect, test } from "@jest/globals";
+import {
+  SOCIAL_EVENT_CADENCE_LABELS,
+  SOCIAL_EVENT_CADENCE_PROFILE_LABELS,
+  getSocialEventCadenceDisplay,
+} from "../userUtils.js";
+
+describe("getSocialEventCadenceDisplay", () => {
+  test("returns the promoter-voice label for a set cadence", () => {
+    expect(getSocialEventCadenceDisplay(SocialEventCadence.Always)).toBe(
+      "Always down for a bash"
+    );
+    expect(getSocialEventCadenceDisplay(SocialEventCadence.Never)).toBe(
+      "Prefers to stay in"
+    );
+  });
+
+  test("returns null when cadence is unset", () => {
+    expect(getSocialEventCadenceDisplay(null)).toBeNull();
+    expect(getSocialEventCadenceDisplay(undefined)).toBeNull();
+  });
+});
+
+describe("social event cadence label maps", () => {
+  test("plain labels cover every enum value", () => {
+    for (const value of Object.values(SocialEventCadence)) {
+      expect(SOCIAL_EVENT_CADENCE_LABELS[value]).toBeTruthy();
+    }
+  });
+
+  test("profile labels cover every enum value", () => {
+    for (const value of Object.values(SocialEventCadence)) {
+      expect(SOCIAL_EVENT_CADENCE_PROFILE_LABELS[value]).toBeTruthy();
+    }
+  });
+});

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

@@ -0,0 +1,49 @@
+import {
+  getTicketCheckInDisplayLabel,
+  isGpsCheckInMethod,
+} from "../ticketCheckInDisplay";
+
+describe("isGpsCheckInMethod", () => {
+  it("recognizes GPS / geofence method strings", () => {
+    expect(isGpsCheckInMethod("geofence")).toBe(true);
+    expect(isGpsCheckInMethod("auto")).toBe(true);
+    expect(isGpsCheckInMethod("GPS_RADIUS")).toBe(true);
+    expect(isGpsCheckInMethod("manual")).toBe(false);
+  });
+});
+
+describe("getTicketCheckInDisplayLabel", () => {
+  const checkedInAt = new Date("2030-06-01T20:00:00.000Z");
+
+  it("returns null when not checked in", () => {
+    expect(getTicketCheckInDisplayLabel(null, "manual")).toBeNull();
+    expect(getTicketCheckInDisplayLabel(null, "manual", "Pending")).toBeNull();
+  });
+
+  it("labels CheckedIn status when checkedInAt is missing (legacy rows)", () => {
+    expect(getTicketCheckInDisplayLabel(null, "manual", "CheckedIn")).toBe(
+      "Scanned at door"
+    );
+    expect(getTicketCheckInDisplayLabel(null, "geofence", "CheckedIn")).toBe(
+      "GPS check-in"
+    );
+    expect(getTicketCheckInDisplayLabel(null, null, "CheckedIn")).toBe(
+      "Checked in"
+    );
+  });
+
+  it("labels GPS check-in", () => {
+    expect(getTicketCheckInDisplayLabel(checkedInAt, "geofence")).toBe(
+      "GPS check-in"
+    );
+    expect(getTicketCheckInDisplayLabel(checkedInAt, "auto")).toBe(
+      "GPS check-in"
+    );
+  });
+
+  it("labels door scan", () => {
+    expect(getTicketCheckInDisplayLabel(checkedInAt, "manual")).toBe(
+      "Scanned at door"
+    );
+  });
+});

package/src/utils/agencyBookingCheckoutCopy.ts

@@ -0,0 +1,50 @@
+import type { AgencyPayoutModel } from "@prisma/client";
+
+export type AgencyBookingCheckoutNoticeInput = {
+  representedByOrganizationId?: string | null;
+  payoutModelSnapshot?: AgencyPayoutModel | null;
+  representedByOrganization?: { name: string | null } | null;
+};
+
+/** Host-facing payment note when a booking is on an agency roster. */
+export function getAgencyBookingCheckoutPaymentNotice(
+  booking: AgencyBookingCheckoutNoticeInput
+): string | null {
+  if (!booking.representedByOrganizationId) {
+    return null;
+  }
+
+  const agencyName =
+    booking.representedByOrganization?.name?.trim() || "the talent agency";
+
+  if (booking.payoutModelSnapshot === "AgencyMerchantOfRecord") {
+    return `Payment is processed through ${agencyName}. Your card charge goes to the agency's connected Stripe account; the artist is paid from that account after checkout. Bash's platform fee is collected separately at checkout.`;
+  }
+
+  if (booking.payoutModelSnapshot === "ManualOffPlatform") {
+    return `This booking is represented by ${agencyName}. Payment goes to the artist; agency commission is handled outside Stripe per your roster terms.`;
+  }
+
+  return `This booking is represented by ${agencyName}. Payment goes to the artist's Stripe account. Agency commission is tracked separately and settled per your roster terms.`;
+}
+
+export const AGENCY_PAYOUT_MODEL_LABELS: Record<
+  AgencyPayoutModel,
+  { title: string; summary: string }
+> = {
+  ArtistMerchantOfRecord: {
+    title: "Artist collects (default)",
+    summary:
+      "Checkout pays the artist's Stripe account. Bash keeps the platform fee. Your commission appears in Commissions and is settled per roster terms.",
+  },
+  AgencyMerchantOfRecord: {
+    title: "Agency collects (Stripe Connect)",
+    summary:
+      "Checkout pays your org Stripe account. Bash keeps the platform fee; you keep commission on your balance. The artist's share is transferred to their Connect account after payment.",
+  },
+  ManualOffPlatform: {
+    title: "Manual / off-platform",
+    summary:
+      "Commission is tracked in Bash only. You and the artist settle money outside Stripe.",
+  },
+};