@bash-app/bash-common 30.246.0 → 30.253.0

package/prisma/schema.prisma

@@ -1791,6 +1791,8 @@ model Ticket {
    * Set when we send the "your waitlist window expires soon" reminder (once per ticket).
    */
   waitlistReminderSentAt     DateTime?
+  /// When we last sent the 1-hour-before-start reminder (email/push/SMS); avoids duplicate cron sends.
+  lastReminded1hAt          DateTime?
   refundRequestedAt          DateTime? // Set when RefundPending; cleared once refund processes
   checkInLocation            String?
   checkOutLocation           String?
@@ -2332,6 +2334,8 @@ model User {
   zipCode                         String?
   country                         String?               @default("US")
   phone                           String?
+  /// Set when the user completes SMS phone verification (OTP).
+  phoneVerifiedAt                 DateTime?
   documentIDId                    String?               @unique
   /// Encrypted-S3 key for the user's stored government-ID image (deleted per retention policy / on ID expiration)
   govIdImageS3Key                 String?
@@ -2639,6 +2643,24 @@ model User {
   // Vanity paths
   requestedVanityPaths EventVanityPath[] @relation("VanityRequests")
   approvedVanityPaths  EventVanityPath[] @relation("VanityApprovals")
+
+  phoneVerificationCodes PhoneVerificationCode[]
+  smsSendLogs            SmsSendLog[]
+}
+
+model PhoneVerificationCode {
+  id         String    @id @default(cuid())
+  userId     String
+  phoneE164  String
+  codeHash   String
+  attempts   Int       @default(0)
+  expiresAt  DateTime
+  consumedAt DateTime?
+  createdAt  DateTime  @default(now())
+  user       User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@index([phoneE164])
 }
 
 model UserPreferences {
@@ -3843,12 +3865,37 @@ model Organization {
   /// Recorded for analytics — informational only, NOT a gate for verification or fee waivers.
   stripeNonprofitPricingStatus StripeNonprofitPricingStatus @default(NotApplied)
 
+  /// Monthly cap on estimated SMS spend (cents) for transactional templated SMS tied to this org.
+  smsMonthlyCapCents  Int       @default(500)
+  smsMonthlySentCents Int       @default(0)
+  smsMonthAnchor      DateTime  @default(now())
+  smsAutoShutoffAt    DateTime?
+
+  smsSendLogs SmsSendLog[]
+
   @@index([ownerId])
   @@index([slug])
   @@index([parentOrganizationId])
   @@index([nonprofitVerifiedAt])
 }
 
+model SmsSendLog {
+  id             String        @id @default(cuid())
+  organizationId String?
+  userId         String
+  templateKey    String
+  phoneE164      String
+  segments       Int
+  estCostCents   Int
+  snsMessageId   String?
+  sentAt         DateTime      @default(now())
+  organization   Organization? @relation(fields: [organizationId], references: [id], onDelete: SetNull)
+  user           User          @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([organizationId, sentAt])
+  @@index([userId, sentAt])
+}
+
 /// Sports-specific metadata for league or team organizations (1:1 with Organization).
 model SportsProfile {
   id             String       @id @default(cuid())

package/src/__tests__/bashSectionTitleForBashType.test.ts

@@ -14,7 +14,10 @@
  */
 import { BashEventType } from "@prisma/client";
 
-import { bashSectionTitleForBashType } from "../definitions.js";
+import {
+  bashSectionTitleForBashType,
+  canonicalBashEventRowKey,
+} from "../definitions.js";
 
 describe("bashSectionTitleForBashType", () => {
   describe("free-text scraper section keys (non-enum)", () => {
@@ -92,4 +95,48 @@ describe("bashSectionTitleForBashType", () => {
       expect(bashSectionTitleForBashType("Party")).toBe("Parties");
     });
   });
+
+  describe("keys that diverge from Prisma enum literals (case or display labels)", () => {
+    it("lower-case prisma value 'party' → 'Parties'", () => {
+      expect(bashSectionTitleForBashType("party")).toBe("Parties");
+    });
+
+    it("lower-case 'fundraiser' → 'Fundraisers'", () => {
+      expect(bashSectionTitleForBashType("fundraiser")).toBe("Fundraisers");
+    });
+
+    it("singular display label row key 'House Party' → 'House Parties'", () => {
+      expect(bashSectionTitleForBashType("House Party")).toBe("House Parties");
+    });
+
+    it("trimmed stray whitespace still pluralizes", () => {
+      expect(bashSectionTitleForBashType("  Fundraiser  ")).toBe("Fundraisers");
+    });
+  });
+
+  describe("already-plural enum headings", () => {
+    it("normalizes casing when the row key matches a pluralized enum title", () => {
+      expect(bashSectionTitleForBashType("House Parties")).toBe(
+        "House Parties"
+      );
+      expect(bashSectionTitleForBashType("house parties")).toBe("House Parties");
+      expect(bashSectionTitleForBashType("Comedy Shows")).toBe("Comedy Shows");
+    });
+  });
+});
+
+describe("canonicalBashEventRowKey", () => {
+  it("maps singular labels and enum literals to the Prisma enum string", () => {
+    expect(canonicalBashEventRowKey("House Party")).toBe(
+      BashEventType.HouseParty
+    );
+    expect(canonicalBashEventRowKey(BashEventType.HouseParty)).toBe(
+      BashEventType.HouseParty
+    );
+    expect(canonicalBashEventRowKey("houseparty")).toBe(BashEventType.HouseParty);
+  });
+
+  it("returns trimmed free-text when no enum matches", () => {
+    expect(canonicalBashEventRowKey("Graduation")).toBe("Graduation");
+  });
 });

package/src/__tests__/definitionsHelpers.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  createEmptyFilterFields,
+  removeDataFromResult,
+  canonicalBashEventRowKey,
+  PASSWORD_REQUIREMENTS_REGEX,
+  PASSWORD_MIN_LENGTH,
+  EMPTY_FILTER_FIELDS,
+  ticketIsPaidForEventAdmission,
+  isUnpaidPayAtDoorTicket,
+  TICKET_PURCHASE_TYPE_COMP,
+  TICKET_PURCHASE_TYPE_PAY_AT_DOOR,
+} from "../definitions.js";
+
+describe("definitions helpers", () => {
+  describe("createEmptyFilterFields", () => {
+    test("returns fresh arrays not shared with EMPTY_FILTER_FIELDS", () => {
+      const a = createEmptyFilterFields();
+      const b = createEmptyFilterFields();
+      a.price.push("free");
+      expect(b.price).toEqual([]);
+      expect(EMPTY_FILTER_FIELDS.price).toEqual([]);
+    });
+
+    test("includes default boolean flags", () => {
+      expect(createEmptyFilterFields()).toMatchObject({
+        hasOpenTasks: false,
+        acceptsBashPoints: false,
+        ambashadorOnly: false,
+      });
+    });
+  });
+
+  describe("removeDataFromResult", () => {
+    test("strips data while preserving error metadata", () => {
+      const result = {
+        data: { id: "1" },
+        error: true,
+        code: "ERR",
+      } as any;
+      expect(removeDataFromResult(result)).toEqual({ error: true, code: "ERR" });
+    });
+
+    test("returns undefined for nullish input", () => {
+      expect(removeDataFromResult(null)).toBeUndefined();
+      expect(removeDataFromResult(undefined)).toBeUndefined();
+    });
+  });
+
+  describe("canonicalBashEventRowKey", () => {
+    test("normalizes singular labels to enum keys", () => {
+      expect(canonicalBashEventRowKey("House Party")).toBe("HouseParty");
+    });
+
+    test("passes through unknown trimmed values", () => {
+      expect(canonicalBashEventRowKey("  Custom Row  ")).toBe("Custom Row");
+    });
+
+    test("returns empty string for blank input", () => {
+      expect(canonicalBashEventRowKey("   ")).toBe("");
+    });
+  });
+
+  describe("PASSWORD_REQUIREMENTS_REGEX", () => {
+    test("requires min length and mixed character classes", () => {
+      expect(PASSWORD_MIN_LENGTH).toBe(8);
+      expect(PASSWORD_REQUIREMENTS_REGEX.test("Abcd1234!")).toBe(true);
+      expect(PASSWORD_REQUIREMENTS_REGEX.test("Sh0rt!")).toBe(false);
+      expect(PASSWORD_REQUIREMENTS_REGEX.test("alllowercase1!")).toBe(false);
+    });
+  });
+
+  describe("ticketIsPaidForEventAdmission", () => {
+    test("free tiers always admit without payment", () => {
+      expect(
+        ticketIsPaidForEventAdmission({ purchaseType: "USD", paidOn: null }, 0)
+      ).toBe(true);
+    });
+
+    test("comp tickets admit without paidOn", () => {
+      expect(
+        ticketIsPaidForEventAdmission(
+          { purchaseType: TICKET_PURCHASE_TYPE_COMP, paidOn: null },
+          2500
+        )
+      ).toBe(true);
+    });
+
+    test("pay-at-door requires paidOn when tier has price", () => {
+      expect(
+        ticketIsPaidForEventAdmission(
+          { purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR, paidOn: null },
+          1000
+        )
+      ).toBe(false);
+      expect(
+        ticketIsPaidForEventAdmission(
+          { purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR, paidOn: new Date() },
+          1000
+        )
+      ).toBe(true);
+    });
+
+    test("standard paid tickets require paidOn", () => {
+      expect(
+        ticketIsPaidForEventAdmission({ purchaseType: "USD", paidOn: null }, 500)
+      ).toBe(false);
+      expect(
+        ticketIsPaidForEventAdmission({ purchaseType: "USD", paidOn: new Date() }, 500)
+      ).toBe(true);
+    });
+  });
+
+  describe("isUnpaidPayAtDoorTicket", () => {
+    test("true only for pay-at-door without paidOn", () => {
+      expect(
+        isUnpaidPayAtDoorTicket({
+          purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR,
+          paidOn: null,
+        })
+      ).toBe(true);
+    });
+
+    test("false once paid or for other purchase types", () => {
+      expect(
+        isUnpaidPayAtDoorTicket({
+          purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR,
+          paidOn: new Date(),
+        })
+      ).toBe(false);
+      expect(
+        isUnpaidPayAtDoorTicket({ purchaseType: "USD", paidOn: null })
+      ).toBe(false);
+    });
+  });
+});

package/src/__tests__/extendedSchemas.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  BASH_EVENT_DATA_TO_CLONE,
+  BASH_EVENT_DATA_TO_REMOVE,
+  FRONT_END_USER_DATA_TO_SELECT,
+  PUBLIC_USER_SUBSCRIPTION_DATA_TO_SELECT,
+  TICKET_TIER_DATA_TO_INCLUDE,
+} from "../extendedSchemas.js";
+
+describe("extendedSchemas exports", () => {
+  test("PUBLIC_USER_SUBSCRIPTION_DATA_TO_SELECT includes subscription counters", () => {
+    expect(PUBLIC_USER_SUBSCRIPTION_DATA_TO_SELECT).toMatchObject({
+      type: true,
+      status: true,
+      ownerId: true,
+      subscriptionCount: true,
+      listedCount: true,
+    });
+  });
+
+  test("FRONT_END_USER_DATA_TO_SELECT exposes public profile fields", () => {
+    expect(FRONT_END_USER_DATA_TO_SELECT).toMatchObject({
+      id: true,
+      username: true,
+      email: true,
+      givenName: true,
+      familyName: true,
+    });
+  });
+
+  test("TICKET_TIER_DATA_TO_INCLUDE nests tickets and promoCodes", () => {
+    expect(TICKET_TIER_DATA_TO_INCLUDE.tickets).toBeDefined();
+    expect(TICKET_TIER_DATA_TO_INCLUDE.promoCodes).toBe(true);
+  });
+
+  test("BASH_EVENT_DATA_TO_CLONE lists cloneable relations", () => {
+    expect(BASH_EVENT_DATA_TO_CLONE).toEqual([
+      "ticketTiers",
+      "media",
+      "recurrence",
+      "invitations",
+    ]);
+  });
+
+  test("BASH_EVENT_DATA_TO_REMOVE strips nested creator and tasks", () => {
+    expect(BASH_EVENT_DATA_TO_REMOVE).toContain("creator");
+    expect(BASH_EVENT_DATA_TO_REMOVE).toContain("eventTasks");
+    expect(BASH_EVENT_DATA_TO_REMOVE).toContain("tickets");
+  });
+});

package/src/__tests__/membershipDefinitions.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, test } from "@jest/globals";
+import { MembershipTier } from "@prisma/client";
+import { BashPassTier } from "@prisma/client";
+import {
+  calculateBashEventFee,
+  calculateServiceBookingFee,
+  calculatePartnerPaymentFee,
+  isTrustedHostMembershipTier,
+  hasFeatureAccess,
+  getRequiredTierForFeature,
+  hasFeatureLimit,
+  getFeatureLimit,
+  hasReachedFeatureLimit,
+  MEMBERSHIP_FEATURES,
+  BASIC_TIER_MAX_PROMO_CODES_PER_EVENT,
+  MEMBERSHIP_BASH_PASS_TIER,
+  MEMBERSHIP_TIER_ORDER,
+  MEMBERSHIP_TIER_HIERARCHY,
+} from "../membershipDefinitions.js";
+
+describe("membershipDefinitions helpers", () => {
+  describe("fee calculators", () => {
+    test("calculateBashEventFee applies percent, minimum, and cap", () => {
+      expect(calculateBashEventFee(10000, MembershipTier.Basic)).toBeGreaterThanOrEqual(0);
+      expect(calculateBashEventFee(0, MembershipTier.Premium)).toBe(
+        calculateBashEventFee(1, MembershipTier.Premium)
+      );
+    });
+
+    test("calculateServiceBookingFee includes Stripe fixed fee", () => {
+      const fee = calculateServiceBookingFee(10000, MembershipTier.Basic);
+      expect(fee).toBeGreaterThan(0);
+    });
+
+    test("calculatePartnerPaymentFee scales with amount", () => {
+      const small = calculatePartnerPaymentFee(1000, MembershipTier.Pro);
+      const large = calculatePartnerPaymentFee(100000, MembershipTier.Pro);
+      expect(large).toBeGreaterThan(small);
+    });
+  });
+
+  describe("isTrustedHostMembershipTier", () => {
+    test("Premium and above are trusted", () => {
+      expect(isTrustedHostMembershipTier(MembershipTier.Premium)).toBe(true);
+      expect(isTrustedHostMembershipTier(MembershipTier.Legend)).toBe(true);
+    });
+
+    test("Basic and missing tier are not trusted", () => {
+      expect(isTrustedHostMembershipTier(MembershipTier.Basic)).toBe(false);
+      expect(isTrustedHostMembershipTier(null)).toBe(false);
+    });
+  });
+
+  describe("hasFeatureAccess", () => {
+    test("Basic gets promo codes", () => {
+      expect(hasFeatureAccess(MembershipTier.Basic, MEMBERSHIP_FEATURES.PROMO_CODES)).toBe(true);
+    });
+
+    test("Pro unlocks vendor directory", () => {
+      expect(hasFeatureAccess(MembershipTier.Pro, MEMBERSHIP_FEATURES.VENDOR_DIRECTORY)).toBe(
+        true
+      );
+      expect(hasFeatureAccess(MembershipTier.Premium, MEMBERSHIP_FEATURES.VENDOR_DIRECTORY)).toBe(
+        false
+      );
+    });
+
+    test("unknown feature returns false", () => {
+      expect(hasFeatureAccess(MembershipTier.Legend, "not_a_feature")).toBe(false);
+    });
+  });
+
+  describe("getRequiredTierForFeature", () => {
+    test("returns minimum tier that unlocks feature", () => {
+      expect(getRequiredTierForFeature(MEMBERSHIP_FEATURES.PROMO_CODES)).toBe(MembershipTier.Basic);
+      expect(getRequiredTierForFeature(MEMBERSHIP_FEATURES.VENDOR_DIRECTORY)).toBe(
+        MembershipTier.Pro
+      );
+    });
+  });
+
+  describe("hasFeatureLimit / getFeatureLimit", () => {
+    test("reads boolean limits from MEMBERSHIP_LIMITS", () => {
+      expect(hasFeatureLimit(MembershipTier.Basic, "canCreateEvents")).toBe(true);
+      expect(hasFeatureLimit(MembershipTier.Basic, "analyticsAccess")).toBe(false);
+      expect(getFeatureLimit(MembershipTier.Pro, "maxServiceListings")).toBe(3);
+    });
+  });
+
+  describe("hasReachedFeatureLimit", () => {
+    test("blocks when featured event quota is exhausted", () => {
+      expect(hasReachedFeatureLimit(MembershipTier.Pro, "featuredEvents", 1)).toBe(true);
+      expect(hasReachedFeatureLimit(MembershipTier.Pro, "featuredEvents", 0)).toBe(false);
+    });
+  });
+
+  test("Basic tier promo code cap constant", () => {
+    expect(BASIC_TIER_MAX_PROMO_CODES_PER_EVENT).toBe(3);
+  });
+
+  describe("tier ordering constants", () => {
+    test("MEMBERSHIP_TIER_HIERARCHY starts at Basic and ends at Legend", () => {
+      expect(MEMBERSHIP_TIER_HIERARCHY[0]).toBe(MembershipTier.Basic);
+      expect(MEMBERSHIP_TIER_HIERARCHY.at(-1)).toBe(MembershipTier.Legend);
+    });
+
+    test("MEMBERSHIP_TIER_ORDER increases with tier level", () => {
+      expect(MEMBERSHIP_TIER_ORDER[MembershipTier.Basic]).toBeLessThan(
+        MEMBERSHIP_TIER_ORDER[MembershipTier.Premium]
+      );
+      expect(MEMBERSHIP_TIER_ORDER[MembershipTier.Pro]).toBeLessThan(
+        MEMBERSHIP_TIER_ORDER[MembershipTier.Legend]
+      );
+    });
+  });
+
+  describe("MEMBERSHIP_BASH_PASS_TIER", () => {
+    test("maps paid membership tiers to bundled BashPass levels", () => {
+      expect(MEMBERSHIP_BASH_PASS_TIER[MembershipTier.Premium]).toBe(BashPassTier.LITE);
+      expect(MEMBERSHIP_BASH_PASS_TIER[MembershipTier.Pro]).toBe(BashPassTier.STANDARD);
+      expect(MEMBERSHIP_BASH_PASS_TIER[MembershipTier.Elite]).toBe(BashPassTier.UNLIMITED);
+      expect(MEMBERSHIP_BASH_PASS_TIER[MembershipTier.Basic]).toBeUndefined();
+    });
+  });
+
+  describe("getRequiredTierForFeature edge cases", () => {
+    test("returns null for unknown feature", () => {
+      expect(getRequiredTierForFeature("__not_a_real_feature__")).toBeNull();
+    });
+  });
+
+  describe("hasReachedFeatureLimit default branch", () => {
+    test("returns false for unsupported feature keys", () => {
+      expect(hasReachedFeatureLimit(MembershipTier.Pro, "featuredEvents", 999)).toBe(true);
+      expect(
+        hasReachedFeatureLimit(
+          MembershipTier.Pro,
+          "unknownFeature" as unknown as "featuredEvents",
+          0
+        )
+      ).toBe(false);
+    });
+  });
+});

package/src/__tests__/ticketAdmission.test.ts

@@ -0,0 +1,73 @@
+/**
+ * Ticket admission helpers — paid vs pay-at-door state.
+ */
+
+import { describe, expect, test } from "@jest/globals";
+import {
+  ticketIsPaidForEventAdmission,
+  isUnpaidPayAtDoorTicket,
+  TICKET_PURCHASE_TYPE_COMP,
+  TICKET_PURCHASE_TYPE_PAY_AT_DOOR,
+  TICKET_PURCHASE_TYPE_USD,
+} from "../definitions.js";
+
+describe("ticketIsPaidForEventAdmission", () => {
+  test("free tiers always admit without payment", () => {
+    expect(ticketIsPaidForEventAdmission({ purchaseType: TICKET_PURCHASE_TYPE_USD, paidOn: null }, 0)).toBe(
+      true
+    );
+    expect(
+      ticketIsPaidForEventAdmission({ purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR, paidOn: null }, 0)
+    ).toBe(true);
+  });
+
+  test("comp tickets admit regardless of paidOn", () => {
+    expect(
+      ticketIsPaidForEventAdmission({ purchaseType: TICKET_PURCHASE_TYPE_COMP, paidOn: null }, 2500)
+    ).toBe(true);
+  });
+
+  test("paid USD tickets admit when paidOn is set", () => {
+    expect(
+      ticketIsPaidForEventAdmission(
+        { purchaseType: TICKET_PURCHASE_TYPE_USD, paidOn: new Date("2024-01-01") },
+        2500
+      )
+    ).toBe(true);
+  });
+
+  test("unpaid USD tickets do not admit", () => {
+    expect(
+      ticketIsPaidForEventAdmission({ purchaseType: TICKET_PURCHASE_TYPE_USD, paidOn: null }, 2500)
+    ).toBe(false);
+  });
+
+  test("pay-at-door tickets admit only after paidOn is set", () => {
+    const unpaid = { purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR, paidOn: null };
+    const paid = { purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR, paidOn: "2024-06-01T12:00:00Z" };
+    expect(ticketIsPaidForEventAdmission(unpaid, 1500)).toBe(false);
+    expect(ticketIsPaidForEventAdmission(paid, 1500)).toBe(true);
+  });
+});
+
+describe("isUnpaidPayAtDoorTicket", () => {
+  test("returns true only for pay-at-door without paidOn", () => {
+    expect(isUnpaidPayAtDoorTicket({ purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR, paidOn: null })).toBe(
+      true
+    );
+  });
+
+  test("returns false once pay-at-door ticket is marked paid", () => {
+    expect(
+      isUnpaidPayAtDoorTicket({
+        purchaseType: TICKET_PURCHASE_TYPE_PAY_AT_DOOR,
+        paidOn: new Date(),
+      })
+    ).toBe(false);
+  });
+
+  test("returns false for other purchase types even when unpaid", () => {
+    expect(isUnpaidPayAtDoorTicket({ purchaseType: TICKET_PURCHASE_TYPE_USD, paidOn: null })).toBe(false);
+    expect(isUnpaidPayAtDoorTicket({ purchaseType: TICKET_PURCHASE_TYPE_COMP, paidOn: null })).toBe(false);
+  });
+});

package/src/__tests__/utmAttribution.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test, beforeEach, afterEach } from "@jest/globals";
+import {
+  getStoredUtmFields,
+  utmFieldsFromCheckoutArgs,
+  utmFieldsFromStripeMetadata,
+  utmFieldsToStripeMetadata,
+  utmFieldsToTicketColumns,
+} from "../utmAttribution.js";
+
+describe("utmAttribution", () => {
+  describe("utmFieldsFromCheckoutArgs", () => {
+    test("returns undefined when all fields blank", () => {
+      expect(utmFieldsFromCheckoutArgs({ utmSource: "  ", utmMedium: "", utmCampaign: undefined })).toBeUndefined();
+    });
+
+    test("trims and includes only non-empty fields", () => {
+      expect(
+        utmFieldsFromCheckoutArgs({
+          utmSource: "  newsletter  ",
+          utmMedium: "email",
+        })
+      ).toEqual({ utmSource: "newsletter", utmMedium: "email" });
+    });
+
+    test("caps field length at 500 characters", () => {
+      const long = "a".repeat(600);
+      const result = utmFieldsFromCheckoutArgs({ utmSource: long });
+      expect(result?.utmSource?.length).toBe(500);
+    });
+  });
+
+  describe("utmFieldsToStripeMetadata", () => {
+    test("maps to snake_case Stripe keys", () => {
+      expect(
+        utmFieldsToStripeMetadata({
+          utmSource: "google",
+          utmCampaign: "spring",
+        })
+      ).toEqual({ utm_source: "google", utm_campaign: "spring" });
+    });
+
+    test("returns empty object for undefined input", () => {
+      expect(utmFieldsToStripeMetadata(undefined)).toEqual({});
+    });
+  });
+
+  describe("utmFieldsToTicketColumns", () => {
+    test("maps to Prisma Ticket column names", () => {
+      expect(
+        utmFieldsToTicketColumns({
+          utmSource: "fb",
+          utmMedium: "cpc",
+          utmCampaign: "launch",
+        })
+      ).toEqual({
+        utmSource: "fb",
+        utmMedium: "cpc",
+        utmCampaign: "launch",
+      });
+    });
+
+    test("omits empty fields", () => {
+      expect(utmFieldsToTicketColumns({ utmSource: "x" })).toEqual({ utmSource: "x" });
+    });
+  });
+
+  describe("utmFieldsFromStripeMetadata", () => {
+    test("reads snake_case metadata into camelCase fields", () => {
+      expect(
+        utmFieldsFromStripeMetadata({
+          utm_source: "  twitter ",
+          utm_medium: "social",
+        })
+      ).toEqual({ utmSource: "twitter", utmMedium: "social" });
+    });
+
+    test("returns empty object for null metadata", () => {
+      expect(utmFieldsFromStripeMetadata(null)).toEqual({});
+    });
+  });
+
+  describe("getStoredUtmFields", () => {
+    const originalSessionStorage = global.sessionStorage;
+
+    beforeEach(() => {
+      const store = new Map<string, string>();
+      Object.defineProperty(global, "sessionStorage", {
+        configurable: true,
+        value: {
+          getItem: (key: string) => store.get(key) ?? null,
+          setItem: (key: string, value: string) => {
+            store.set(key, value);
+          },
+          removeItem: (key: string) => {
+            store.delete(key);
+          },
+          clear: () => store.clear(),
+        },
+      });
+    });
+
+    afterEach(() => {
+      Object.defineProperty(global, "sessionStorage", {
+        configurable: true,
+        value: originalSessionStorage,
+      });
+    });
+
+    test("reads previously stored session values", () => {
+      sessionStorage.setItem("bash_utm_source", "newsletter");
+      sessionStorage.setItem("bash_utm_campaign", "june");
+      expect(getStoredUtmFields()).toEqual({
+        utmSource: "newsletter",
+        utmCampaign: "june",
+      });
+    });
+  });
+});