@bash-app/bash-common 30.285.0 → 30.291.0

package/src/utils/entertainmentDrawFit.ts

@@ -0,0 +1,180 @@
+import type { AmountOfGuests } from "@prisma/client";
+
+export type CrowdSizeLike = Pick<
+  AmountOfGuests,
+  | "minimum"
+  | "ideal"
+  | "expected"
+  | "showMinimumGuests"
+  | "showIdealGuests"
+  | "showExpectedGuests"
+> | null | undefined;
+
+export type VenueCapacityLike = {
+  capacity?: number | null;
+  anticipatedAttendees?: number | null;
+} | null | undefined;
+
+/** Effective draw the entertainer shares publicly, or best estimate from preferences. */
+export function getEntertainerEffectiveDraw(
+  crowdSize: CrowdSizeLike
+): number | null {
+  if (!crowdSize) return null;
+
+  if (
+    crowdSize.showExpectedGuests &&
+    crowdSize.expected != null &&
+    crowdSize.expected > 0
+  ) {
+    return crowdSize.expected;
+  }
+
+  if (crowdSize.showIdealGuests && crowdSize.ideal != null && crowdSize.ideal > 0) {
+    return crowdSize.ideal;
+  }
+
+  if (
+    crowdSize.showMinimumGuests &&
+    crowdSize.minimum != null &&
+    crowdSize.minimum > 0
+  ) {
+    return crowdSize.minimum;
+  }
+
+  return null;
+}
+
+export function getVenueEffectiveCapacity(
+  venue: VenueCapacityLike
+): number | null {
+  if (!venue) return null;
+  const capacity = venue.capacity ?? venue.anticipatedAttendees;
+  return capacity != null && capacity > 0 ? capacity : null;
+}
+
+export interface DrawCapacityFitResult {
+  points: number;
+  maxPoints: number;
+  reason?: string;
+}
+
+/**
+ * Score how well an entertainer's draw fits a venue's capacity (0–15 points).
+ * Partial credit when only one side has data.
+ */
+export function scoreDrawCapacityFit(
+  venue: VenueCapacityLike,
+  crowdSize: CrowdSizeLike
+): DrawCapacityFitResult {
+  const maxPoints = 15;
+  const venueCapacity = getVenueEffectiveCapacity(venue);
+  const draw = getEntertainerEffectiveDraw(crowdSize);
+
+  if (!venueCapacity && !draw) {
+    return { points: 3, maxPoints, reason: "Draw and capacity not specified" };
+  }
+
+  if (!venueCapacity || !draw) {
+    return {
+      points: 5,
+      maxPoints,
+      reason: venueCapacity
+        ? "Entertainer draw not specified"
+        : "Venue capacity not specified",
+    };
+  }
+
+  const ratio = draw / venueCapacity;
+
+  if (ratio >= 0.2 && ratio <= 1.25) {
+    return {
+      points: maxPoints,
+      maxPoints,
+      reason: `Draw (~${draw}) fits venue capacity (~${venueCapacity})`,
+    };
+  }
+
+  if (ratio > 1.25 && ratio <= 1.75) {
+    return {
+      points: 8,
+      maxPoints,
+      reason: `Draw (~${draw}) slightly above capacity (~${venueCapacity})`,
+    };
+  }
+
+  if (ratio < 0.2 && ratio >= 0.05) {
+    return {
+      points: 7,
+      maxPoints,
+      reason: `Draw (~${draw}) modest for venue size (~${venueCapacity})`,
+    };
+  }
+
+  return {
+    points: 2,
+    maxPoints,
+    reason: `Draw (~${draw}) and capacity (~${venueCapacity}) may not align`,
+  };
+}
+
+/**
+ * Host browse filter: expected guest count vs entertainer's shared draw.
+ * When entertainer has no draw data, do not exclude them.
+ */
+export function entertainerFitsHostExpectedCrowd(
+  hostExpectedGuests: number,
+  crowdSize: CrowdSizeLike
+): boolean {
+  if (!Number.isFinite(hostExpectedGuests) || hostExpectedGuests <= 0) {
+    return true;
+  }
+
+  const draw = getEntertainerEffectiveDraw(crowdSize);
+  if (draw == null) {
+    return true;
+  }
+
+  const low = hostExpectedGuests * 0.2;
+  const high = hostExpectedGuests * 2.5;
+  return draw >= low && draw <= high;
+}
+
+function normalizeVenueName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** Fuzzy match venue listing name against entertainer's notable venue names. */
+export function findNotableVenueNameMatch(
+  venueServiceName: string | null | undefined,
+  notableVenuesPerformed: string[] | null | undefined,
+  showNotableVenuesPerformed?: boolean
+): string | null {
+  if (!showNotableVenuesPerformed) {
+    return null;
+  }
+
+  if (!venueServiceName?.trim() || !notableVenuesPerformed?.length) {
+    return null;
+  }
+
+  const normalizedVenue = normalizeVenueName(venueServiceName);
+  if (!normalizedVenue) return null;
+
+  for (const notable of notableVenuesPerformed) {
+    const normalizedNotable = normalizeVenueName(notable);
+    if (!normalizedNotable) continue;
+
+    if (
+      normalizedVenue.includes(normalizedNotable) ||
+      normalizedNotable.includes(normalizedVenue)
+    ) {
+      return notable.trim();
+    }
+  }
+
+  return null;
+}

package/src/utils/entertainmentServiceTypeOptions.ts

@@ -0,0 +1,56 @@
+import { EntertainmentServiceType } from "../definitions.js";
+
+/** Human labels for every `EntertainmentServiceType` enum value (wizard + filters). */
+export const ENTERTAINMENT_SERVICE_TYPE_LABELS: Record<
+  EntertainmentServiceType,
+  string
+> = {
+  Emcees: "Emcees",
+  DJs: "DJs",
+  Bands: "Bands",
+  SoloMusicians: "Solo Musicians",
+  Comedy: "Comedy",
+  VarietyActs: "Variety Acts",
+  PerformanceArtists: "Performance Artists",
+  Magic: "Magic",
+  Dancers: "Dancers",
+  Aerialists: "Aerialists",
+  Impersonators: "Impersonators",
+  Speakers: "Speakers",
+  Auctioneers: "Auctioneers",
+  Musicians: "Musicians",
+  Producers: "Producers",
+  Singers: "Singers",
+  Instrumentalists: "Instrumentalists",
+  Other: "Other",
+};
+
+/** Ordered options for multi-select UIs (common types first, then extended enum values). */
+export const ENTERTAINMENT_SERVICE_TYPE_OPTIONS: ReadonlyArray<{
+  value: EntertainmentServiceType;
+  label: string;
+}> = (
+  [
+    "Emcees",
+    "DJs",
+    "Bands",
+    "SoloMusicians",
+    "Musicians",
+    "Singers",
+    "Instrumentalists",
+    "Producers",
+    "Comedy",
+    "VarietyActs",
+    "PerformanceArtists",
+    "Magic",
+    "Dancers",
+    "Aerialists",
+    "Impersonators",
+    "Speakers",
+    "Auctioneers",
+    "Other",
+  ] as const
+).map((value) => ({
+  value,
+  label: ENTERTAINMENT_SERVICE_TYPE_LABELS[value],
+}));

package/src/utils/guestSurface.ts

@@ -20,7 +20,11 @@ export type AttendeeVisibility =
 export type GuestListDepth = "None" | "Partial" | "Full";
 
 /** Who may see the full attendee roster on the bash detail page (Layer 1). */
-export type AttendeeListAccess = "Preview" | "Public" | "TicketHolders";
+export type AttendeeListAccess =
+  | "Preview"
+  | "Public"
+  | "TicketHolders"
+  | "RsvpGoing";
 
 export type { PublicTeaserUser };
 
@@ -35,7 +39,12 @@ export type NetworkOverlapPayload = {
 };
 
 export type GuestSurfacePayload = {
-  count: { totalTickets: number; visibleAttendees: number };
+  count: {
+    totalTickets: number;
+    visibleAttendees: number;
+    /** Going RSVPs on Rsvp-mode events (ticket count may be 0). */
+    rsvpGoingCount?: number;
+  };
   preview: PublicTeaserUser[];
   featured: PublicTeaserUser[];
   featuredHeadline: string | null;
@@ -65,6 +74,14 @@ export type GuestSurfacePayload = {
   attendeeListPublic?: boolean;
   /** Preview | Public | TicketHolders — supersedes attendeeListPublic when set */
   attendeeListAccess?: string | null;
+  /**
+   * When set, the viewer sees a blurred preview and must RSVP (or buy a ticket)
+   * to unlock the full attendee list.
+   */
+  listLock?: {
+    reason: "rsvp_required" | "ticket_required";
+    goingCount: number;
+  } | null;
 };
 
 export type AttendeeRosterMeta = {
@@ -109,7 +126,7 @@ export function resolveAttendeeListAccess(event: {
   attendeeListPublic?: boolean | null;
 }): AttendeeListAccess {
   const raw = event.attendeeListAccess;
-  if (raw === "Public" || raw === "TicketHolders" || raw === "Preview") {
+  if (raw === "Public" || raw === "TicketHolders" || raw === "Preview" || raw === "RsvpGoing") {
     return raw;
   }
   return event.attendeeListPublic ? "Public" : "Preview";

package/src/utils/locationVisibility.ts

@@ -17,6 +17,11 @@ export type ViewerLocationContext = {
   viewerOwnsValidTicket: boolean;
   viewerPublicRsvpGoing: boolean;
   viewerHasAcceptedInvitation: boolean;
+  /**
+   * Active guest-session grant with status Going for this event (no password account).
+   * Mirrors viewerPublicRsvpGoing for location unlock when hideLocation is on.
+   */
+  viewerGuestRsvpGoing?: boolean;
 };
 
 const VALID_TICKET_STATUSES_EXCLUDED = new Set(["Cancelled", "WaitlistPending"]);
@@ -47,7 +52,9 @@ export function viewerCanSeeFullBashLocation(
   if (!bash.hideLocation) return true;
   if (bash.locationRevealedAt) return true;
   if (ctx.isHostOrOrganizer) return true;
-  if (!ctx.viewerUserId) return false;
+
+  const guestGoing = ctx.viewerGuestRsvpGoing === true;
+  if (!ctx.viewerUserId && !guestGoing) return false;
 
   const audience = bash.locationRevealAudience ?? "TicketHolders";
 
@@ -55,8 +62,10 @@ export function viewerCanSeeFullBashLocation(
 
   if (audience === "TicketHolders") return false;
 
+  const rsvpGoing = ctx.viewerPublicRsvpGoing || guestGoing;
+
   if (audience === "TicketHoldersAndRsvps" || audience === "TicketHoldersAndInvited") {
-    if (ctx.viewerPublicRsvpGoing) return true;
+    if (rsvpGoing) return true;
   }
 
   if (audience === "TicketHoldersAndInvited" && ctx.viewerHasAcceptedInvitation) {

package/src/utils/luxonUtils.ts

@@ -146,21 +146,29 @@ export function dateTimeFromComponents(
   interpretAsTimezone?: string,
   timezoneToConvertTo?: string
 ): DateTime | null {
-  let res = date
-    ? DateTime.isDateTime(date)
-      ? date.setZone(interpretAsTimezone)
-      : dateTimeFromDate(date, interpretAsTimezone, timezoneToConvertTo)
-    : DateTime.now().setZone(
-        timezoneToConvertTo ?? interpretAsTimezone ?? undefined
-      );
+  let res: DateTime;
+  if (date == null) {
+    res = DateTime.now().setZone(
+      timezoneToConvertTo ?? interpretAsTimezone ?? undefined
+    );
+  } else if (typeof date === "string" || date instanceof Date) {
+    res = dateTimeFromDate(date, interpretAsTimezone, timezoneToConvertTo);
+  } else {
+    res = date.setZone(interpretAsTimezone);
+  }
 
-  const timeComp = DateTime.isDateTime(time)
-    ? time.setZone(interpretAsTimezone)
-    : dateTimeFromTime(
-        time ?? "12:00 AM",
-        interpretAsTimezone,
-        timezoneToConvertTo
-      );
+  let timeComp: DateTime | null;
+  if (time == null) {
+    timeComp = dateTimeFromTime(
+      "12:00 AM",
+      interpretAsTimezone,
+      timezoneToConvertTo
+    );
+  } else if (typeof time === "string" || time instanceof Date) {
+    timeComp = dateTimeFromTime(time, interpretAsTimezone, timezoneToConvertTo);
+  } else {
+    timeComp = time.setZone(interpretAsTimezone);
+  }
 
   if (!timeComp) {
     return null;

package/src/utils/organizationEntitlements.ts

@@ -0,0 +1,37 @@
+/**
+ * Organization plan entitlements (pure predicates shared by api + bash-app).
+ *
+ * Keep these free of Prisma/DB access so both the frontend (gating UI + subdomain
+ * routing) and backend (SSR + API responses) evaluate the same rules. Pass only the
+ * subscription fields, not a full Prisma model, so partial selects work everywhere.
+ */
+
+/** Subscription statuses where a paid plan's perks are considered live. */
+export const ACTIVE_ORG_SUBSCRIPTION_STATUSES = [
+  "Active",
+  "Trialing",
+] as const;
+
+export interface OrganizationEntitlementInput {
+  subscriptionTier?: string | null;
+  subscriptionStatus?: string | null;
+}
+
+/**
+ * Vanity subdomains ({slug}.bash.community) are an Enterprise-only perk. All other
+ * orgs use the canonical path URL (bash.community/org/{slug}). Requires an active
+ * (or trialing) subscription so a lapsed Enterprise org falls back to the path.
+ */
+export function organizationHasVanitySubdomain(
+  org: OrganizationEntitlementInput | null | undefined
+): boolean {
+  if (!org) return false;
+  if (org.subscriptionTier !== "Enterprise") return false;
+  // Treat a missing status as active: legacy/ops-provisioned Enterprise orgs may
+  // predate subscriptionStatus being populated, and we don't want to silently
+  // drop their vanity domain.
+  if (org.subscriptionStatus == null) return true;
+  return (ACTIVE_ORG_SUBSCRIPTION_STATUSES as readonly string[]).includes(
+    org.subscriptionStatus
+  );
+}

package/src/utils/recurrenceUtils.ts

@@ -39,9 +39,12 @@ export type RecurrenceWireInput = Omit<
 export function occurrenceOverrideKey(
   occurrenceStart: Date | string | DateTime
 ): string {
-  const dt = DateTime.isDateTime(occurrenceStart)
-    ? occurrenceStart
-    : dateTimeFromDate(occurrenceStart);
+  let dt: DateTime;
+  if (typeof occurrenceStart === "string" || occurrenceStart instanceof Date) {
+    dt = dateTimeFromDate(occurrenceStart);
+  } else {
+    dt = occurrenceStart;
+  }
   return dt.toFormat(LUXON_DATETIME_FORMAT_ISO_LIKE);
 }
 

package/src/utils/reputationUtils.ts

@@ -0,0 +1,94 @@
+/**
+ * Unified reputation summary across actor types (hosts, services/venues/artists).
+ *
+ * Stars on profiles show the raw average; leaderboards and cross-actor comparisons
+ * use a Bayesian-adjusted score so a 5.0 from two people doesn't outrank a 4.8
+ * from two hundred (see the Ratings explainer copy). Keeping the math here means
+ * host and service reputation stay consistent without duplicating the formula.
+ */
+
+export type ReputationActorType = "host" | "service" | "venue" | "artist";
+
+export interface ReputationSummary {
+  actorType: ReputationActorType;
+  /** Raw average rating (0–5), or null when there isn't enough signal. */
+  averageRating: number | null;
+  /** Number of ratings behind the average. */
+  totalRatings: number;
+  /** Bayesian-adjusted score (0–5) for ranking; null below the minimum. */
+  bayesianScore: number | null;
+  /** Whether there are enough ratings to show stars publicly. */
+  hasEnoughSignal: boolean;
+}
+
+/** Below this many ratings we don't show a star number (avoids misleading 5.0s). */
+export const MIN_RATINGS_FOR_DISPLAY = 3;
+
+/** Prior strength (how many "virtual" average-rated reviews to blend in). */
+const BAYESIAN_PRIOR_COUNT = 10;
+/** Prior mean — the platform's assumed baseline rating. */
+const BAYESIAN_PRIOR_MEAN = 4.0;
+
+/**
+ * Bayesian average: pulls low-volume ratings toward the prior mean, so a couple
+ * of glowing reviews can't outrank a large, consistently-strong record.
+ */
+export function bayesianAverage(
+  averageRating: number | null | undefined,
+  totalRatings: number | null | undefined,
+  opts: { priorCount?: number; priorMean?: number } = {}
+): number | null {
+  const avg = averageRating ?? 0;
+  const count = totalRatings ?? 0;
+  if (count <= 0) return null;
+  const priorCount = opts.priorCount ?? BAYESIAN_PRIOR_COUNT;
+  const priorMean = opts.priorMean ?? BAYESIAN_PRIOR_MEAN;
+  const score = (priorCount * priorMean + count * avg) / (priorCount + count);
+  return Math.round(score * 100) / 100;
+}
+
+/** Build a normalized reputation summary from a rating + count pair. */
+export function getReputationSummary(
+  actorType: ReputationActorType,
+  averageRating: number | null | undefined,
+  totalRatings: number | null | undefined
+): ReputationSummary {
+  const count = totalRatings ?? 0;
+  const hasEnoughSignal = count >= MIN_RATINGS_FOR_DISPLAY;
+  return {
+    actorType,
+    averageRating: hasEnoughSignal ? (averageRating ?? null) : null,
+    totalRatings: count,
+    bayesianScore: bayesianAverage(averageRating, totalRatings),
+    hasEnoughSignal,
+  };
+}
+
+export interface ServiceListingReputation {
+  averageRating: number;
+  totalRatings: number;
+  sourceLabel?: string;
+}
+
+/** Compact browse/detail reputation from aggregate service rating fields. */
+export function getServiceListingReputation(service: {
+  serviceRating?: number | null;
+  totalRatings?: number | null;
+  externalReviewSource?: string | null;
+}): ServiceListingReputation | null {
+  const summary = getReputationSummary(
+    "service",
+    service.serviceRating,
+    service.totalRatings
+  );
+  if (!summary.hasEnoughSignal || summary.averageRating == null) {
+    return null;
+  }
+  const sourceLabel =
+    service.externalReviewSource === "google" ? "Google" : undefined;
+  return {
+    averageRating: summary.averageRating,
+    totalRatings: summary.totalRatings,
+    sourceLabel,
+  };
+}

package/src/utils/service/serviceUtils.ts

@@ -411,8 +411,12 @@ export interface ServiceSpecificTypeInfo {
   specificId: string;
 }
 
-export function serviceGetSpecificType<BookingType extends Service>(
-  service: BookingType
+export type ServiceSpecificTypeLookup = Pick<Service, "id"> & {
+  serviceType: ServiceTypes | null;
+} & Partial<Record<`${ServiceSpecificName}Id`, string | null>>;
+
+export function serviceGetSpecificType(
+  service: ServiceSpecificTypeLookup
 ): ServiceSpecificTypeInfo | null {
   if (service.serviceType == null) {
     // throw new Error(`serviceGetSpecificType invalid serviceType`);