@bash-app/bash-common 30.399.0 → 30.403.0

package/prisma/schema.prisma

@@ -1202,6 +1202,8 @@ model BashEvent {
   lastBroadcastAt        DateTime?
   /// Optional host note appended to ticket purchase confirmation emails.
   confirmationEmailNote  String?   @db.Text
+  /// Guest-facing "meet here" label; pin uses existing coordinates.
+  meetingPointLabel      String?
   /// When true, notify opted-in CRM audience on publish (optional tag in crmPublishNotifyTag).
   crmPublishNotifyEnabled Boolean  @default(false)
   crmPublishNotifyTag     String?
@@ -1244,6 +1246,7 @@ model BashEvent {
   requireExpenseApproval Boolean @default(false)
 
   associatedBashesReferencingMe   AssociatedBash[]
+  eventStaffAudits                EventStaffAudit[]
   comments                        BashComment[]
   amountOfGuests                  AmountOfGuests?                @relation(fields: [amountOfGuestsId], references: [id], onDelete: Cascade)
   creator                         User                           @relation("CreatedEvent", fields: [creatorId], references: [id], onDelete: Cascade)
@@ -2900,6 +2903,80 @@ model HostAttendeeProfile {
   @@index([hostUserId])
 }
 
+enum EventStaffRole {
+  Admin
+  Organizer
+  Promoter
+  DoorStaff
+  ServiceProvider
+  Volunteer
+}
+
+enum AudienceImportSource {
+  Eventbrite
+  Luma
+  Partiful
+  Posh
+  GenericCsv
+}
+
+enum HostImportConnectionProvider {
+  Eventbrite
+  Luma
+}
+
+/// Host-wide standing guestlist (free-entry contacts reused across bashes).
+model HostStandingGuestlistEntry {
+  id         String   @id @default(cuid())
+  hostUserId String
+  email      String?
+  phone      String?
+  fullName   String?
+  createdAt  DateTime @default(now())
+  updatedAt  DateTime @updatedAt
+
+  host User @relation("HostStandingGuestlistOwned", fields: [hostUserId], references: [id], onDelete: Cascade)
+
+  @@index([hostUserId])
+  @@index([hostUserId, email])
+}
+
+/// Encrypted Eventbrite OAuth / Luma API-key connection for audience import.
+model HostImportConnection {
+  id                      String                       @id @default(cuid())
+  hostUserId              String
+  provider                HostImportConnectionProvider
+  encryptedAccessToken    String                       @db.Text
+  encryptedRefreshToken   String?                      @db.Text
+  tokenExpiry             DateTime?
+  createdAt               DateTime                     @default(now())
+  updatedAt               DateTime                     @updatedAt
+
+  host User @relation("HostImportConnectionsOwned", fields: [hostUserId], references: [id], onDelete: Cascade)
+
+  @@unique([hostUserId, provider])
+}
+
+/// Append-only staff role grant/change/revoke log.
+model EventStaffAudit {
+  id              String          @id @default(cuid())
+  bashEventId     String
+  hostUserId      String
+  targetEmail     String?
+  targetUserId    String?
+  action          String
+  fromRole        EventStaffRole?
+  toRole          EventStaffRole?
+  changedByUserId String
+  createdAt       DateTime        @default(now())
+
+  bashEvent BashEvent @relation(fields: [bashEventId], references: [id], onDelete: Cascade)
+  host      User      @relation("EventStaffAuditHost", fields: [hostUserId], references: [id], onDelete: Cascade)
+
+  @@index([bashEventId, createdAt])
+  @@index([hostUserId])
+}
+
 enum HostAttendeeActivityType {
   NoteAdded
   NoteUpdated
@@ -3614,6 +3691,9 @@ model Ticket {
   status                     TicketStatus @default(Pending)
   isFreeGuest                Boolean?
   isNamedGuest               Boolean      @default(false)
+  /// Competitor import: Eventbrite / Luma / Partiful / Posh / GenericCsv
+  importSource               String?
+  importedExternalPaid       Boolean      @default(false)
   geoFenceCheckInUnnecessary Boolean?
   checkedInAt                DateTime?
   checkedOutAt               DateTime?
@@ -4756,6 +4836,9 @@ model User {
   eventDiscussionComments       EventDiscussionComment[] @relation("EventDiscussionComments")
   hostAttendeeProfilesOwned     HostAttendeeProfile[]   @relation("HostAttendeeProfilesOwned")
   hostAttendeeProfilesTarget    HostAttendeeProfile[]   @relation("HostAttendeeProfilesTarget")
+  hostStandingGuestlistEntries  HostStandingGuestlistEntry[] @relation("HostStandingGuestlistOwned")
+  hostImportConnections         HostImportConnection[]  @relation("HostImportConnectionsOwned")
+  eventStaffAuditsAsHost        EventStaffAudit[]       @relation("EventStaffAuditHost")
   hostCrmSavedSegments          HostCrmSavedSegment[]   @relation("HostCrmSavedSegments")
   hostCrmEmailSendLogsAsHost    HostCrmEmailSendLog[]   @relation("HostCrmEmailSendLogsHost")
   hostCrmEmailSendLogsAsUser    HostCrmEmailSendLog[]   @relation("HostCrmEmailSendLogsUser")
@@ -5375,8 +5458,22 @@ model AssociatedBash {
   ownerUserId    String?
   isOrganizer    Boolean?
   isCoHost       Boolean?    @default(false)
+  /// @deprecated — write-through for legacy callers. New rows set eventRole = DoorStaff
+  /// (+ canAccessDoor override when needed). Drop after all read sites use
+  /// associatedBashCanAccessDoor() instead of this boolean directly.
   isDoorStaff    Boolean?    @default(false)
   organizerTitle String?
+  /// Null = legacy row; honor isOrganizer / isDoorStaff. Non-null uses role + overrides.
+  eventRole              EventStaffRole?
+  canEditEvent           Boolean?
+  canEditTickets         Boolean?
+  canManageAttendees     Boolean?
+  canIssueComps          Boolean?
+  canAccessDoor          Boolean?
+  canViewFinances        Boolean?
+  canRefund              Boolean?
+  canMessage             Boolean?
+  canManageTrackingLinks Boolean?
   bashEvent      BashEvent   @relation(fields: [bashEventId], references: [id], onDelete: Cascade)
   invitation     Invitation? @relation(fields: [invitationId], references: [id])
   owner          User?       @relation(fields: [ownerUserId], references: [id], onDelete: Cascade)
@@ -7551,6 +7648,11 @@ model Expense {
   /// Tracks which invoice due reminders were sent: { dueSoon, dueDay, pastDue1, pastDue15 }.
   invoiceDueRemindersSent Json?
 
+  /// Host-entered email for an off-platform vendor (no Bash account required).
+  externalVendorEmail      String?
+  /// True when the host intentionally added an external vendor (vs OCR-only vendorName).
+  externalVendorIsExternal Boolean @default(false)
+
   budget    Budget @relation(fields: [budgetId], references: [id], onDelete: Cascade)
   submitter User   @relation("ExpenseSubmitter", fields: [submittedBy], references: [id])
   approver  User?  @relation("ExpenseApprover", fields: [approvedBy], references: [id])

package/src/__tests__/audienceImport.test.ts

@@ -0,0 +1,58 @@
+import {
+  compareBashVsPartifulTicketFees,
+  importGuestDedupeKey,
+  isAudienceImportDestination,
+  isAudienceImportSource,
+  mapCsvHeaderToImportField,
+  normalizeImportEmail,
+  normalizeImportPhone,
+  stripeProcessingFeeCents,
+} from "../audienceImport.js";
+
+describe("audienceImport", () => {
+  it("maps competitor CSV headers", () => {
+    expect(mapCsvHeaderToImportField("Attendee Email")).toBe("email");
+    expect(mapCsvHeaderToImportField("Ticket Type")).toBe("tierLabel");
+    expect(mapCsvHeaderToImportField("unknown col")).toBeUndefined();
+    expect(mapCsvHeaderToImportField("source")).toBeUndefined();
+  });
+
+  it("normalizes email and phone", () => {
+    expect(normalizeImportEmail("  A@B.com ")).toBe("a@b.com");
+    expect(normalizeImportEmail("not-an-email")).toBeUndefined();
+    expect(normalizeImportPhone("(555) 123-4567")).toBe("5551234567");
+    expect(normalizeImportPhone("12")).toBeUndefined();
+  });
+
+  it("dedupes by email then phone then external id", () => {
+    expect(importGuestDedupeKey({ source: "Eventbrite", email: "A@b.com" })).toBe(
+      "email:a@b.com"
+    );
+    expect(importGuestDedupeKey({ source: "Luma", phone: "5551234567" })).toBe(
+      "phone:5551234567"
+    );
+    expect(
+      importGuestDedupeKey({ source: "Posh", externalId: "ord-1" })
+    ).toBe("ext:Posh:ord-1");
+    expect(importGuestDedupeKey({ source: "GenericCsv" })).toBeUndefined();
+  });
+
+  it("compares Bash vs Partiful with guest-pays primary", () => {
+    const result = compareBashVsPartifulTicketFees({
+      ticketPriceCents: 10000,
+      quantity: 1,
+    });
+    expect(result.bash.guestPaysCents).toBe(10000);
+    expect(result.bash.hostNetsCents).toBe(10000 - stripeProcessingFeeCents(10000));
+    expect(result.partiful.guestPaysCents).toBe(11200);
+    expect(result.partiful.hostNetsCents).toBe(10000);
+    expect(result.citation).toMatch(/June 2026/);
+  });
+
+  it("guards source and destination unions", () => {
+    expect(isAudienceImportSource("Eventbrite")).toBe(true);
+    expect(isAudienceImportSource("Dice")).toBe(false);
+    expect(isAudienceImportDestination("crm")).toBe(true);
+    expect(isAudienceImportDestination("sms")).toBe(false);
+  });
+});

package/src/__tests__/eventStaffRoles.test.ts

@@ -0,0 +1,50 @@
+import {
+  associatedBashCanAccessDoor,
+  associatedBashCanEditEvent,
+  isEventStaffRole,
+  roleFromLegacyFlags,
+  writeThroughAssociatedBashFlags,
+} from "../eventStaffRoles.js";
+
+describe("eventStaffRoles", () => {
+  it("write-through keeps organizer and door flags in sync", () => {
+    expect(writeThroughAssociatedBashFlags("Organizer", true)).toEqual({
+      isOrganizer: true,
+      isDoorStaff: false,
+      isCoHost: true,
+    });
+    expect(writeThroughAssociatedBashFlags("DoorStaff")).toEqual({
+      isOrganizer: false,
+      isDoorStaff: true,
+      isCoHost: false,
+    });
+    expect(writeThroughAssociatedBashFlags("Promoter").isOrganizer).toBe(false);
+  });
+
+  it("edit access honors role when set, else isOrganizer", () => {
+    expect(associatedBashCanEditEvent({ eventRole: "Organizer" })).toBe(true);
+    expect(associatedBashCanEditEvent({ eventRole: "DoorStaff" })).toBe(false);
+    expect(associatedBashCanEditEvent({ eventRole: "Admin", canEditEvent: false })).toBe(
+      false
+    );
+    expect(associatedBashCanEditEvent({ isOrganizer: true })).toBe(true);
+    expect(associatedBashCanEditEvent({ isOrganizer: false })).toBe(false);
+  });
+
+  it("door access honors role when set, else legacy flags", () => {
+    expect(associatedBashCanAccessDoor({ eventRole: "DoorStaff" })).toBe(true);
+    expect(associatedBashCanAccessDoor({ eventRole: "Volunteer" })).toBe(false);
+    expect(associatedBashCanAccessDoor({ isDoorStaff: true })).toBe(true);
+    expect(associatedBashCanAccessDoor({ isOrganizer: true })).toBe(true);
+  });
+
+  it("maps legacy flags and validates roles", () => {
+    expect(roleFromLegacyFlags({ isDoorStaff: true, isOrganizer: false })).toBe(
+      "DoorStaff"
+    );
+    expect(roleFromLegacyFlags({ isOrganizer: true })).toBe("Organizer");
+    expect(roleFromLegacyFlags({})).toBeNull();
+    expect(isEventStaffRole("Admin")).toBe(true);
+    expect(isEventStaffRole("Owner")).toBe(false);
+  });
+});

package/src/audienceImport.ts

@@ -0,0 +1,181 @@
+/**
+ * Competitor audience import — shared types, CSV header maps, and fee comparison math.
+ * Adapters normalize Eventbrite / Luma / Partiful / Posh / generic CSVs into one row shape.
+ */
+
+import { calculateStripeProcessingFeeCents } from "./utils/paymentUtils.js";
+
+export const AUDIENCE_IMPORT_SOURCES = [
+  "Eventbrite",
+  "Luma",
+  "Partiful",
+  "Posh",
+  "GenericCsv",
+] as const;
+
+export type AudienceImportSource = (typeof AUDIENCE_IMPORT_SOURCES)[number];
+
+export const AUDIENCE_IMPORT_DESTINATIONS = [
+  "admission",
+  "crm",
+  "standingGuestlist",
+] as const;
+
+export type AudienceImportDestination = (typeof AUDIENCE_IMPORT_DESTINATIONS)[number];
+
+export type NormalizedImportGuest = {
+  source: AudienceImportSource;
+  externalId?: string;
+  fullName?: string;
+  email?: string;
+  phone?: string;
+  rsvpOrOrderStatus?: string;
+  tierLabel?: string;
+  checkedInAt?: string;
+  isComp?: boolean;
+  plusOnes?: number;
+  importedExternalPaid?: boolean;
+};
+
+export type AudienceImportPreviewRow = NormalizedImportGuest & {
+  willImport: boolean;
+  skipReason?: string;
+};
+
+export type AudienceImportCommitResult = {
+  added: number;
+  skipped: number;
+  failed: number;
+  failures: Array<{ email?: string; fullName?: string; reason: string }>;
+};
+
+export const MAX_IMPORT_ROWS = 5000;
+export const IMPORT_BATCH_SIZE = 500;
+
+/** Partiful's published June 2026 example: guest pays $112 for a $100 organizer price. */
+export const PARTIFUL_PUBLISHED_GUEST_MULTIPLIER = 112 / 100;
+export const PARTIFUL_FEE_EXAMPLE_CITATION =
+  "Based on Partiful's published June 2026 example — their fee varies by event.";
+
+export type TicketFeeCompareInput = {
+  ticketPriceCents: number;
+  quantity: number;
+};
+
+export type TicketFeeCompareSide = {
+  guestPaysCents: number;
+  hostNetsCents: number;
+};
+
+export type TicketFeeCompareResult = {
+  bash: TicketFeeCompareSide;
+  partiful: TicketFeeCompareSide;
+  citation: string;
+};
+
+export function stripeProcessingFeeCents(amountCents: number): number {
+  return calculateStripeProcessingFeeCents(amountCents);
+}
+
+/**
+ * Guest-pays is the primary comparison. Host-nets is secondary.
+ * Bash HostAbsorbs: guest pays listed price; host nets listed minus Stripe.
+ * Partiful fee-inclusive: guest pays listed × published multiplier; host receives listed.
+ */
+export function compareBashVsPartifulTicketFees(
+  input: TicketFeeCompareInput
+): TicketFeeCompareResult {
+  const qty = Math.max(1, Math.floor(input.quantity) || 1);
+  const listed = Math.max(0, Math.floor(input.ticketPriceCents)) * qty;
+  const bashStripe = stripeProcessingFeeCents(listed);
+  const partifulGuest = Math.round(listed * PARTIFUL_PUBLISHED_GUEST_MULTIPLIER);
+  return {
+    bash: {
+      guestPaysCents: listed,
+      hostNetsCents: Math.max(0, listed - bashStripe),
+    },
+    partiful: {
+      guestPaysCents: partifulGuest,
+      hostNetsCents: listed,
+    },
+    citation: PARTIFUL_FEE_EXAMPLE_CITATION,
+  };
+}
+
+export function normalizeImportEmail(value: string | undefined | null): string | undefined {
+  const trimmed = value?.trim().toLowerCase();
+  return trimmed && trimmed.includes("@") ? trimmed : undefined;
+}
+
+export function normalizeImportPhone(value: string | undefined | null): string | undefined {
+  const digits = (value ?? "").replace(/\D/g, "");
+  if (digits.length < 7) return undefined;
+  return digits;
+}
+
+export function importGuestDedupeKey(guest: NormalizedImportGuest): string | undefined {
+  const email = normalizeImportEmail(guest.email);
+  if (email) return `email:${email}`;
+  const phone = normalizeImportPhone(guest.phone);
+  if (phone) return `phone:${phone}`;
+  if (guest.externalId?.trim()) return `ext:${guest.source}:${guest.externalId.trim()}`;
+  return undefined;
+}
+
+/** CSV columns never overwrite `source` (set by the importer) or `importedExternalPaid`. */
+export type AudienceImportCsvMappedField = Exclude<
+  keyof NormalizedImportGuest,
+  "source" | "importedExternalPaid"
+>;
+
+/** Competitor + generic CSV headers → NormalizedImportGuest fields. */
+export const AUDIENCE_IMPORT_CSV_HEADERS: Record<string, AudienceImportCsvMappedField> = {
+  "full name": "fullName",
+  name: "fullName",
+  "attendee name": "fullName",
+  "ticket buyer name": "fullName",
+  "first name last name": "fullName",
+  guest: "fullName",
+  "guest name": "fullName",
+  "first name": "fullName",
+  email: "email",
+  "e-mail": "email",
+  "email address": "email",
+  "attendee email": "email",
+  "ticket holder email": "email",
+  "buyer email": "email",
+  phone: "phone",
+  "phone number": "phone",
+  mobile: "phone",
+  cell: "phone",
+  status: "rsvpOrOrderStatus",
+  "rsvp status": "rsvpOrOrderStatus",
+  "order status": "rsvpOrOrderStatus",
+  "approval status": "rsvpOrOrderStatus",
+  "ticket type": "tierLabel",
+  "ticket class": "tierLabel",
+  tier: "tierLabel",
+  "order id": "externalId",
+  "attendee id": "externalId",
+  "guest id": "externalId",
+  "checked in": "checkedInAt",
+  "checked_in_at": "checkedInAt",
+  complimentary: "isComp",
+  comp: "isComp",
+  "plus ones": "plusOnes",
+  "plus ones count": "plusOnes",
+};
+
+export function mapCsvHeaderToImportField(
+  header: string
+): AudienceImportCsvMappedField | undefined {
+  return AUDIENCE_IMPORT_CSV_HEADERS[header.trim().toLowerCase()];
+}
+
+export function isAudienceImportSource(value: string): value is AudienceImportSource {
+  return (AUDIENCE_IMPORT_SOURCES as readonly string[]).includes(value);
+}
+
+export function isAudienceImportDestination(value: string): value is AudienceImportDestination {
+  return (AUDIENCE_IMPORT_DESTINATIONS as readonly string[]).includes(value);
+}

package/src/eventStaffRoles.ts

@@ -0,0 +1,168 @@
+/**
+ * Per-event staff role templates. Booleans on AssociatedBash stay the live
+ * write-through so existing canUserEditBashEvent / userCanAccessDoor callers
+ * keep working during the transition.
+ */
+
+export const EVENT_STAFF_ROLES = [
+  "Admin",
+  "Organizer",
+  "Promoter",
+  "DoorStaff",
+  "ServiceProvider",
+  "Volunteer",
+] as const;
+
+export type EventStaffRole = (typeof EVENT_STAFF_ROLES)[number];
+
+export type EventStaffPermissionKey =
+  | "canEditEvent"
+  | "canEditTickets"
+  | "canManageAttendees"
+  | "canIssueComps"
+  | "canAccessDoor"
+  | "canViewFinances"
+  | "canRefund"
+  | "canMessage"
+  | "canManageTrackingLinks";
+
+export type EventStaffPermissionFlags = Record<EventStaffPermissionKey, boolean>;
+
+export type EventStaffBooleanWriteThrough = {
+  isOrganizer: boolean;
+  isDoorStaff: boolean;
+  isCoHost: boolean;
+};
+
+export const EVENT_STAFF_TEMPLATE_DEFAULTS: Record<EventStaffRole, EventStaffPermissionFlags> = {
+  Admin: {
+    canEditEvent: true,
+    canEditTickets: true,
+    canManageAttendees: true,
+    canIssueComps: true,
+    canAccessDoor: true,
+    canViewFinances: true,
+    canRefund: true,
+    canMessage: true,
+    canManageTrackingLinks: true,
+  },
+  Organizer: {
+    canEditEvent: true,
+    canEditTickets: true,
+    canManageAttendees: true,
+    canIssueComps: true,
+    canAccessDoor: true,
+    canViewFinances: false,
+    canRefund: false,
+    canMessage: true,
+    canManageTrackingLinks: true,
+  },
+  Promoter: {
+    canEditEvent: false,
+    canEditTickets: false,
+    canManageAttendees: false,
+    canIssueComps: true,
+    canAccessDoor: false,
+    canViewFinances: false,
+    canRefund: false,
+    canMessage: false,
+    canManageTrackingLinks: true,
+  },
+  DoorStaff: {
+    canEditEvent: false,
+    canEditTickets: false,
+    canManageAttendees: true,
+    canIssueComps: true,
+    canAccessDoor: true,
+    canViewFinances: false,
+    canRefund: false,
+    canMessage: false,
+    canManageTrackingLinks: false,
+  },
+  ServiceProvider: {
+    canEditEvent: false,
+    canEditTickets: false,
+    canManageAttendees: false,
+    canIssueComps: false,
+    canAccessDoor: false,
+    canViewFinances: false,
+    canRefund: false,
+    canMessage: false,
+    canManageTrackingLinks: false,
+  },
+  Volunteer: {
+    canEditEvent: false,
+    canEditTickets: false,
+    canManageAttendees: false,
+    canIssueComps: false,
+    canAccessDoor: false,
+    canViewFinances: false,
+    canRefund: false,
+    canMessage: false,
+    canManageTrackingLinks: false,
+  },
+};
+
+export function isEventStaffRole(value: string | null | undefined): value is EventStaffRole {
+  return !!value && (EVENT_STAFF_ROLES as readonly string[]).includes(value);
+}
+
+/** Setting a role also writes the legacy booleans so existing callers stay valid. */
+export function writeThroughAssociatedBashFlags(
+  role: EventStaffRole,
+  isCoHost = false
+): EventStaffBooleanWriteThrough {
+  if (role === "Admin" || role === "Organizer") {
+    return { isOrganizer: true, isDoorStaff: false, isCoHost };
+  }
+  if (role === "DoorStaff") {
+    return { isOrganizer: false, isDoorStaff: true, isCoHost: false };
+  }
+  return { isOrganizer: false, isDoorStaff: false, isCoHost: false };
+}
+
+export function resolveEventStaffPermission(
+  role: EventStaffRole | null | undefined,
+  key: EventStaffPermissionKey,
+  override: boolean | null | undefined
+): boolean {
+  if (typeof override === "boolean") return override;
+  if (!isEventStaffRole(role)) return false;
+  return EVENT_STAFF_TEMPLATE_DEFAULTS[role][key];
+}
+
+/**
+ * Edit access: honor role+overrides when eventRole is set; otherwise the
+ * existing isOrganizer boolean. Never drop the boolean check for legacy rows.
+ */
+export function associatedBashCanEditEvent(row: {
+  eventRole?: string | null;
+  isOrganizer?: boolean | null;
+  canEditEvent?: boolean | null;
+}): boolean {
+  if (isEventStaffRole(row.eventRole)) {
+    return resolveEventStaffPermission(row.eventRole, "canEditEvent", row.canEditEvent);
+  }
+  return !!row.isOrganizer;
+}
+
+export function associatedBashCanAccessDoor(row: {
+  eventRole?: string | null;
+  isOrganizer?: boolean | null;
+  isDoorStaff?: boolean | null;
+  canAccessDoor?: boolean | null;
+}): boolean {
+  if (isEventStaffRole(row.eventRole)) {
+    return resolveEventStaffPermission(row.eventRole, "canAccessDoor", row.canAccessDoor);
+  }
+  return Boolean(row.isOrganizer || row.isDoorStaff);
+}
+
+export function roleFromLegacyFlags(row: {
+  isOrganizer?: boolean | null;
+  isDoorStaff?: boolean | null;
+}): EventStaffRole | null {
+  if (row.isDoorStaff && !row.isOrganizer) return "DoorStaff";
+  if (row.isOrganizer) return "Organizer";
+  return null;
+}

package/src/extendedSchemas.ts

@@ -1794,6 +1794,8 @@ export interface InvitationExtraData extends Invitation {
   isFreeGuest: boolean;
   isOrganizer?: boolean;
   isCoHost?: boolean;
+  isDoorStaff?: boolean;
+  eventRole?: string;
   organizerTitle?: string;
   isOwnershipTransfer?: boolean;
   includeQRCode?: boolean; // Controls whether QR code should be included in the invitation email

package/src/index.ts

@@ -49,6 +49,8 @@ export * from "./hostCrmAutomation.js";
 export * from "./relationshipHealth.js";
 export * from "./hostCrmConstants.js";
 export * from "./hostPromoter.js";
+export * from "./audienceImport.js";
+export * from "./eventStaffRoles.js";
 export * from "./bashEventCancellationPolicy.js";
 export * from "./userReportTypes.js";
 export * from "./mirroredPrismaEnums.js";

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

@@ -5,6 +5,7 @@ import {
   defaultLocationRevealMode,
   geocodeQueryTextForPublicBashMap,
   isLocationGloballyPublic,
+  resolveMeetingPointLabel,
   redactBashEventLocation,
   shouldAutoRevealLocationToPublicNow,
   viewerCanSeeFullBashLocation,
@@ -310,3 +311,40 @@ describe("geocodeQueryTextForPublicBashMap", () => {
     ).toBe("Venue|123 St");
   });
 });
+
+describe("resolveMeetingPointLabel", () => {
+  it("returns the trimmed label when an exact address is present", () => {
+    expect(
+      resolveMeetingPointLabel({
+        meetingPointLabel: "  Side door on 9th  ",
+        location: "123 Main St",
+      })
+    ).toBe("Side door on 9th");
+  });
+
+  it("treats street as an exact address when location is empty", () => {
+    expect(
+      resolveMeetingPointLabel({
+        meetingPointLabel: "Loading dock",
+        street: "88 Pier Ave",
+      })
+    ).toBe("Loading dock");
+  });
+
+  it("returns null when the label is blank or the address is still hidden", () => {
+    expect(
+      resolveMeetingPointLabel({
+        meetingPointLabel: "   ",
+        location: "123 Main St",
+      })
+    ).toBeNull();
+    expect(
+      resolveMeetingPointLabel({
+        meetingPointLabel: "Side door",
+        location: null,
+        street: "  ",
+      })
+    ).toBeNull();
+    expect(resolveMeetingPointLabel({})).toBeNull();
+  });
+});