@bash-app/bash-common 30.400.0 → 30.406.0

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__/definitionsHelpers.test.ts

@@ -15,6 +15,16 @@ import {
   COMPLEMENTARY_SERVICE_TYPE,
   complementaryServiceTypeFor,
   ServiceTypes,
+  isIntroIntentId,
+  INTRO_INTENT_OPTIONS,
+  isLocusOfControlId,
+  LOCUS_OF_CONTROL_OPTIONS,
+  hasSensingIntuitionOverlap,
+  personalityOverlapHint,
+  normalizePersonalityType,
+  isInterestExpressionMode,
+  sharedIntroIntentHint,
+  locusOfControlShortLabel,
 } from "../definitions.js";
 
 describe("definitions helpers", () => {
@@ -183,4 +193,44 @@ describe("definitions helpers", () => {
       ).toBeUndefined();
     });
   });
+
+  describe("Intros intents", () => {
+    test("accepts the three platonic/professional intent ids", () => {
+      expect(INTRO_INTENT_OPTIONS.map((option) => option.id)).toEqual([
+        "friends",
+        "professional",
+        "mentorship",
+      ]);
+      expect(isIntroIntentId("friends")).toBe(true);
+      expect(isIntroIntentId("dating")).toBe(false);
+    });
+
+    test("normalizes personality type and detects S/N overlap", () => {
+      expect(normalizePersonalityType("enfp!")).toBe("ENFP");
+      expect(normalizePersonalityType("  ")).toBeNull();
+      expect(hasSensingIntuitionOverlap("ENFP", "INTJ")).toBe(true);
+      expect(hasSensingIntuitionOverlap("ESFP", "INTJ")).toBe(false);
+      expect(personalityOverlapHint("ENFP", "INTJ")).toBe(
+        "You both picked N — good icebreaker."
+      );
+      expect(isLocusOfControlId("internal")).toBe(true);
+      expect(isLocusOfControlId("random")).toBe(false);
+      expect(LOCUS_OF_CONTROL_OPTIONS.map((option) => option.id)).toEqual([
+        "internal",
+        "external",
+        "mixed",
+      ]);
+      expect(isInterestExpressionMode("named")).toBe(true);
+      expect(isInterestExpressionMode("crush")).toBe(false);
+    });
+
+    test("shared intro intent and locus labels stay conversational", () => {
+      expect(
+        sharedIntroIntentHint(["friends", "mentorship"], ["professional", "friends"])
+      ).toBe("You're both here for making friends.");
+      expect(sharedIntroIntentHint(["friends"], ["professional"])).toBeNull();
+      expect(locusOfControlShortLabel("internal")).toBe("Internal");
+      expect(locusOfControlShortLabel("nope")).toBeNull();
+    });
+  });
 });

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);
+}