@bash-app/bash-common 30.284.0 → 30.289.0

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`);

package/src/utils/serviceAvailabilityDisplay.ts

@@ -0,0 +1,199 @@
+/**
+ * Shared helpers for displaying and quick-configuring service availability.
+ *
+ * A service stores weekly availability in `Service.availableHours` as a JSON
+ * string shaped like:
+ *   { hours: { Monday: [{ open, close }] }, openDays: { Monday: true } }
+ *
+ * These helpers derive a simple "weekdays / weekends / custom" preset from that
+ * shape, apply a preset, and compute the earliest open date for a public profile.
+ * They intentionally avoid timezone math and live-booking awareness: the earliest
+ * date reflects the owner's published schedule and owner-blocked dates only.
+ */
+
+export type AvailabilityPreset = "weekdays" | "weekends" | "custom";
+
+export interface AvailabilityTimeSlot {
+  open: string;
+  close: string;
+}
+
+export interface AvailabilityHoursConfig {
+  hours?: Record<string, AvailabilityTimeSlot[]>;
+  openDays?: Record<string, boolean>;
+  enableInstantBooking?: boolean;
+}
+
+/** Inclusive date range a service owner has blocked off (unavailable). */
+export interface AvailabilityBlockedRange {
+  start: Date | string;
+  end: Date | string;
+}
+
+const WEEKDAY_NAMES = [
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+] as const;
+const WEEKEND_NAMES = ["Saturday", "Sunday"] as const;
+const ALL_DAY_NAMES = [...WEEKDAY_NAMES, ...WEEKEND_NAMES] as const;
+
+/** JS `Date.getDay()` index (0 = Sunday) to day name used in `openDays`. */
+const DAY_INDEX_TO_NAME = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+] as const;
+
+/** All-day open slot, matching the wizard's default day hours. */
+const DEFAULT_OPEN_SLOT: AvailabilityTimeSlot = {
+  open: "12:00 AM",
+  close: "11:59 PM",
+};
+const CLOSED_SLOT: AvailabilityTimeSlot = { open: "", close: "" };
+
+/** Parse `Service.availableHours` (string or object) into a config, or null. */
+export function parseAvailableHours(
+  availableHours: unknown
+): AvailabilityHoursConfig | null {
+  if (!availableHours) return null;
+  try {
+    const parsed =
+      typeof availableHours === "string"
+        ? JSON.parse(availableHours)
+        : availableHours;
+    if (parsed && typeof parsed === "object") {
+      return parsed as AvailabilityHoursConfig;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Classify an `openDays` map as a known preset. Returns null when there is no
+ * day information to classify.
+ */
+export function detectAvailabilityPreset(
+  openDays: Record<string, boolean> | null | undefined
+): AvailabilityPreset | null {
+  if (!openDays) return null;
+  const hasAnyKnownDay = ALL_DAY_NAMES.some(
+    (day) => openDays[day] !== undefined
+  );
+  if (!hasAnyKnownDay) return null;
+
+  const weekdaysAllOpen = WEEKDAY_NAMES.every((day) => openDays[day] === true);
+  const weekdaysAllClosed = WEEKDAY_NAMES.every(
+    (day) => openDays[day] === false
+  );
+  const weekendsAllOpen = WEEKEND_NAMES.every((day) => openDays[day] === true);
+  const weekendsAllClosed = WEEKEND_NAMES.every(
+    (day) => openDays[day] === false
+  );
+
+  if (weekdaysAllOpen && weekendsAllClosed) return "weekdays";
+  if (weekendsAllOpen && weekdaysAllClosed) return "weekends";
+  return "custom";
+}
+
+/**
+ * Produce an `availableHours` config for a quick preset. Open days get an
+ * all-day slot; closed days get an empty slot. Any extra fields on `base`
+ * (e.g. `enableInstantBooking`) are preserved.
+ */
+export function applyAvailabilityPreset(
+  preset: Exclude<AvailabilityPreset, "custom">,
+  base?: AvailabilityHoursConfig | null
+): AvailabilityHoursConfig {
+  const openDayNames =
+    preset === "weekdays" ? WEEKDAY_NAMES : WEEKEND_NAMES;
+  const hours: Record<string, AvailabilityTimeSlot[]> = {};
+  const openDays: Record<string, boolean> = {};
+
+  for (const day of ALL_DAY_NAMES) {
+    const isOpen = (openDayNames as readonly string[]).includes(day);
+    openDays[day] = isOpen;
+    hours[day] = isOpen ? [{ ...DEFAULT_OPEN_SLOT }] : [{ ...CLOSED_SLOT }];
+  }
+
+  return { ...(base ?? {}), hours, openDays };
+}
+
+/** User-facing label for a preset (e.g. shown on the public profile). */
+export function formatAvailabilityPresetLabel(
+  preset: AvailabilityPreset
+): string {
+  switch (preset) {
+    case "weekdays":
+      return "Available on weekdays";
+    case "weekends":
+      return "Available on weekends";
+    default:
+      return "Custom availability";
+  }
+}
+
+function startOfLocalDay(date: Date): Date {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+
+/** Whether a given date's weekday is open per the `openDays` map. */
+export function isAvailabilityDayOpen(
+  openDays: Record<string, boolean> | null | undefined,
+  date: Date
+): boolean {
+  if (!openDays) return true;
+  const name = DAY_INDEX_TO_NAME[date.getDay()];
+  // Treat unset days as open; only an explicit false closes a day.
+  return openDays[name] !== false;
+}
+
+/** Whether a date falls within any owner-blocked (unavailable) range. */
+export function isDateBlocked(
+  blockedRanges: AvailabilityBlockedRange[],
+  date: Date
+): boolean {
+  const day = startOfLocalDay(date).getTime();
+  return blockedRanges.some((range) => {
+    const start = startOfLocalDay(new Date(range.start)).getTime();
+    const end = startOfLocalDay(new Date(range.end)).getTime();
+    if (Number.isNaN(start) || Number.isNaN(end)) return false;
+    return day >= start && day <= end;
+  });
+}
+
+/**
+ * Earliest date the service is open per its weekly schedule and not within an
+ * owner-blocked range. Does NOT account for existing bookings, so callers should
+ * frame it as an estimate. Returns null when no day is open within the lookahead.
+ */
+export function computeEarliestOpenDate(params: {
+  openDays?: Record<string, boolean> | null;
+  blockedRanges?: AvailabilityBlockedRange[] | null;
+  fromDate?: Date;
+  maxLookaheadDays?: number;
+}): Date | null {
+  const { openDays, blockedRanges, fromDate, maxLookaheadDays = 365 } = params;
+  const ranges = blockedRanges ?? [];
+  const cursor = startOfLocalDay(fromDate ?? new Date());
+
+  for (let i = 0; i <= maxLookaheadDays; i++) {
+    const candidate = new Date(cursor);
+    candidate.setDate(candidate.getDate() + i);
+    if (
+      isAvailabilityDayOpen(openDays, candidate) &&
+      !isDateBlocked(ranges, candidate)
+    ) {
+      return candidate;
+    }
+  }
+  return null;
+}

package/src/utils/ticketCheckInDisplay.ts

@@ -0,0 +1,37 @@
+/** GPS / geofence auto check-in (legacy values: auto, geofence, GPS_RADIUS). */
+export function isGpsCheckInMethod(
+  method: string | null | undefined
+): boolean {
+  if (!method) return false;
+  const m = method.toLowerCase();
+  return m === "auto" || m === "geofence" || m === "gps_radius";
+}
+
+function isTicketCheckedIn(
+  checkedInAt: Date | string | null | undefined,
+  ticketStatus: string | null | undefined
+): boolean {
+  return checkedInAt != null || ticketStatus === "CheckedIn";
+}
+
+/**
+ * Attendee-facing label for ticket check-in on My Tickets and similar surfaces.
+ * Returns null when the ticket has not been checked in.
+ */
+export function getTicketCheckInDisplayLabel(
+  checkedInAt: Date | string | null | undefined,
+  checkedInMethod: string | null | undefined,
+  ticketStatus?: string | null
+): string | null {
+  if (!isTicketCheckedIn(checkedInAt, ticketStatus ?? null)) return null;
+  if (isGpsCheckInMethod(checkedInMethod)) {
+    return "GPS check-in";
+  }
+  if (checkedInMethod === "manual") {
+    return "Scanned at door";
+  }
+  if (checkedInMethod === "door_card" || checkedInMethod === "door_cash") {
+    return "Checked in at door";
+  }
+  return "Checked in";
+}

package/src/utils/userUtils.ts

@@ -1,4 +1,4 @@
-import { Gender } from "@prisma/client";
+import { Gender, SocialEventCadence } from "@prisma/client";
 
 export const MAX_USER_NAME_CHANGES = 3 as const;
 
@@ -39,3 +39,38 @@ export function getDisplayGender(user: GenderDisplayUser): string | null {
   if (user.gender) return user.gender;
   return null;
 }
+
+/**
+ * Plain labels for the social event cadence enum — used in Settings, the account
+ * edit forms, and the host CRM filter where clarity beats personality.
+ */
+export const SOCIAL_EVENT_CADENCE_LABELS: Record<SocialEventCadence, string> = {
+  Always: "Always",
+  Often: "Often",
+  Sometimes: "Sometimes",
+  Rarely: "Rarely",
+  Never: "Never",
+};
+
+/**
+ * Promoter-voice labels for the public profile — friendlier phrasing of how often
+ * someone likes to go out. Falls back to the plain label when no flourish exists.
+ */
+export const SOCIAL_EVENT_CADENCE_PROFILE_LABELS: Record<SocialEventCadence, string> = {
+  Always: "Always down for a bash",
+  Often: "Out most weekends",
+  Sometimes: "Out now and then",
+  Rarely: "Rarely out",
+  Never: "Prefers to stay in",
+};
+
+/**
+ * Resolve the public-facing cadence label for a user. Returns `null` when the
+ * value is unset so callers can omit the line entirely.
+ */
+export function getSocialEventCadenceDisplay(
+  cadence: SocialEventCadence | null | undefined
+): string | null {
+  if (!cadence) return null;
+  return SOCIAL_EVENT_CADENCE_PROFILE_LABELS[cadence] ?? cadence;
+}

package/src/venueMatch.ts

@@ -0,0 +1,202 @@
+/**
+ * Shared shapes for the Venue Match pipeline (retrieve → score → explain).
+ *
+ * The api worker owns the Zod runtime validation (api/src/services/venueMatch/);
+ * this file is the type-only source of truth read by both the api and bash-app
+ * (host suggestion cards + admin supply-leads pipeline).
+ *
+ * Persisted JSON columns map exactly to these interfaces:
+ *  - `VenueMatchRun.intent`            → `VenueMatchIntent`
+ *  - `VenueMatchCandidate.scoreBreakdown` → `VenueMatchScoreBreakdown`
+ *  - `VenueMatchCandidate.reasons`     → `string[]` (host-facing copy)
+ *  - `VenueMatchCandidate.displaySnapshot` → `VenueCandidateDisplay`
+ */
+
+/** Where a candidate came from. Mirrors prisma enum `VenueMatchCandidateSource`. */
+export const VENUE_MATCH_SOURCES = {
+  Marketplace: "Marketplace",
+  GooglePlaces: "GooglePlaces",
+} as const;
+export type VenueMatchCandidateSource =
+  (typeof VENUE_MATCH_SOURCES)[keyof typeof VENUE_MATCH_SOURCES];
+
+/** Host interaction with a surfaced candidate. Mirrors prisma enum `VenueMatchHostAction`. */
+export const VENUE_MATCH_HOST_ACTIONS = {
+  None: "None",
+  Viewed: "Viewed",
+  Accepted: "Accepted",
+  AcceptedOffPlatform: "AcceptedOffPlatform",
+  Dismissed: "Dismissed",
+  CalledPhone: "CalledPhone",
+  InvitedVenue: "InvitedVenue",
+} as const;
+export type VenueMatchHostAction =
+  (typeof VENUE_MATCH_HOST_ACTIONS)[keyof typeof VENUE_MATCH_HOST_ACTIONS];
+
+/** Sales pipeline stage. Mirrors prisma enum `VenueSupplyLeadStage`. */
+export const VENUE_SUPPLY_LEAD_STAGES = {
+  Surfaced: "Surfaced",
+  Prioritized: "Prioritized",
+  Queued: "Queued",
+  Contacted: "Contacted",
+  Interested: "Interested",
+  DemoScheduled: "DemoScheduled",
+  Listed: "Listed",
+  Declined: "Declined",
+  DoNotContact: "DoNotContact",
+} as const;
+export type VenueSupplyLeadStage =
+  (typeof VENUE_SUPPLY_LEAD_STAGES)[keyof typeof VENUE_SUPPLY_LEAD_STAGES];
+
+/** Admin display labels — single source for the pipeline UI + CSV export. */
+export const VenueSupplyLeadStageLabel: Record<VenueSupplyLeadStage, string> = {
+  Surfaced: "Surfaced",
+  Prioritized: "Hot lead",
+  Queued: "Queued for outreach",
+  Contacted: "Contacted",
+  Interested: "Interested",
+  DemoScheduled: "Demo scheduled",
+  Listed: "Listed on Bash",
+  Declined: "Declined",
+  DoNotContact: "Do not contact",
+};
+
+/** Stages a rep can manually transition to from the admin UI. */
+export const VENUE_SUPPLY_LEAD_REP_STAGES: VenueSupplyLeadStage[] = [
+  "Queued",
+  "Contacted",
+  "Interested",
+  "DemoScheduled",
+  "Declined",
+  "DoNotContact",
+];
+
+/**
+ * Structured intent extracted from the host's prompt + current event fields.
+ * Persisted as `VenueMatchRun.intent` (Json column).
+ * All fields nullable — the scorer omits weights for missing signals.
+ */
+export interface VenueMatchIntent {
+  /** e.g. "bachelor party", "baby shower" — free text, lowercased */
+  occasion: string | null;
+  /** From amountOfGuests.expected or parsed from prompt */
+  guestCount: number | null;
+  city: string | null;
+  state: string | null;
+  /** Geocoded anchor for distance scoring (host geo → profile city → event city) */
+  anchorLat: number | null;
+  anchorLng: number | null;
+  /** e.g. "upscale", "casual" */
+  vibe: string | null;
+  /** Total budget in cents if the host mentioned one */
+  budgetCents: number | null;
+  /** BashEvent.eventType at run time */
+  eventType: string | null;
+}
+
+/** Per-factor contribution. `weight` is the normalized weight actually applied (0..1). */
+export interface VenueMatchFactorScore {
+  /** Raw factor score 0..100 before weighting */
+  score: number;
+  weight: number;
+}
+
+/**
+ * Persisted as `VenueMatchCandidate.scoreBreakdown` (Json).
+ * A factor is null when its signal was unavailable and its weight
+ * was re-distributed across the others.
+ */
+export interface VenueMatchScoreBreakdown {
+  distance: VenueMatchFactorScore | null;
+  capacity: VenueMatchFactorScore | null;
+  occasion: VenueMatchFactorScore | null;
+  rating: VenueMatchFactorScore | null;
+  price: VenueMatchFactorScore | null;
+  platformQuality: VenueMatchFactorScore | null;
+}
+
+/**
+ * Snapshot of everything the host card needs, captured at run time so
+ * `GET /venue-match` never re-hits Google. Persisted as
+ * `VenueMatchCandidate.displaySnapshot` (Json).
+ */
+export interface VenueCandidateDisplay {
+  name: string;
+  photoUrl: string | null;
+  formattedAddress: string | null;
+  city: string | null;
+  state: string | null;
+  /** Bash rating for marketplace, Google rating for off-platform */
+  rating: number | null;
+  reviewCount: number | null;
+  capacity: number | null;
+  distanceMiles: number | null;
+  phone: string | null;
+  /** Marketplace only — deep link target */
+  serviceDetailPath: string | null;
+}
+
+/** One candidate as served to the host UI. */
+export interface VenueMatchCandidateView {
+  id: string;
+  rank: number;
+  score: number;
+  source: VenueMatchCandidateSource;
+  serviceId: string | null;
+  /** Venue model id (for bashEvent.venueId) when marketplace */
+  venueId: string | null;
+  googlePlaceId: string | null;
+  reasons: string[];
+  scoreBreakdown: VenueMatchScoreBreakdown;
+  display: VenueCandidateDisplay;
+  hostAction: VenueMatchHostAction;
+}
+
+/** Response of `GET /event/:id/venue-match`. */
+export interface VenueMatchRunView {
+  runId: string;
+  createdAt: string;
+  intent: VenueMatchIntent;
+  candidates: VenueMatchCandidateView[];
+}
+
+/** Row shape for the admin supply-leads table + CSV export. */
+export interface VenueSupplyLeadRow {
+  id: string;
+  name: string;
+  phoneE164: string | null;
+  city: string | null;
+  state: string | null;
+  fullAddress: string | null;
+  rating: number | null;
+  reviewCount: number | null;
+  category: string | null;
+  website: string | null;
+  googlePlaceId: string | null;
+  distinctEventCount: number;
+  topOccasions: string[];
+  firstSurfacedAt: string;
+  lastSurfacedAt: string;
+  stage: VenueSupplyLeadStage;
+  assignedToUserId: string | null;
+  assignedToName: string | null;
+  notes: string | null;
+  /** Set once the venue lists on Bash (conversion) */
+  serviceId: string | null;
+  catalogSource: string | null;
+}
+
+export interface VenueSupplyLeadStats {
+  byStage: Record<VenueSupplyLeadStage, number>;
+  total: number;
+  hotLeads: number;
+  convertedTotal: number;
+}
+
+/** Feature flag values for `VENUE_MATCH_MODE`. */
+export const VENUE_MATCH_MODES = [
+  "off",
+  "marketplace_only",
+  "marketplace_and_google",
+] as const;
+export type VenueMatchMode = (typeof VENUE_MATCH_MODES)[number];