@bash-app/bash-common 30.284.0 → 30.289.0

package/src/influencerAudience.ts

@@ -0,0 +1,156 @@
+import type { InfluencerAudienceTier } from "@prisma/client";
+
+/** Ordered tiers for UI (smallest to largest). */
+export const INFLUENCER_AUDIENCE_TIERS = [
+  "Nano",
+  "Micro",
+  "Macro",
+  "Mega",
+] as const satisfies readonly InfluencerAudienceTier[];
+
+export type InfluencerAudienceTierId =
+  (typeof INFLUENCER_AUDIENCE_TIERS)[number];
+
+export const INFLUENCER_AUDIENCE_TIER_LABELS: Record<
+  InfluencerAudienceTier,
+  string
+> = {
+  Nano: "Nano",
+  Micro: "Micro",
+  Macro: "Macro",
+  Mega: "Mega",
+};
+
+export interface InfluencerAudienceTierRange {
+  min: number;
+  max: number | null;
+  description: string;
+}
+
+/** Industry-standard follower bands (approximate). */
+export const INFLUENCER_AUDIENCE_TIER_RANGES: Record<
+  InfluencerAudienceTier,
+  InfluencerAudienceTierRange
+> = {
+  Nano: {
+    min: 1_000,
+    max: 9_999,
+    description: "1K–10K followers",
+  },
+  Micro: {
+    min: 10_000,
+    max: 99_999,
+    description: "10K–100K followers",
+  },
+  Macro: {
+    min: 100_000,
+    max: 999_999,
+    description: "100K–1M followers",
+  },
+  Mega: {
+    min: 1_000_000,
+    max: null,
+    description: "1M+ followers",
+  },
+};
+
+export const INFLUENCER_PRIMARY_PLATFORMS = [
+  "Instagram",
+  "TikTok",
+  "YouTube",
+  "Facebook",
+  "X",
+  "LinkedIn",
+  "Twitch",
+  "Snapchat",
+  "Pinterest",
+  "BlogNewsletter",
+] as const;
+
+export type InfluencerPrimaryPlatformId =
+  (typeof INFLUENCER_PRIMARY_PLATFORMS)[number];
+
+export const INFLUENCER_PLATFORM_LABELS: Record<
+  InfluencerPrimaryPlatformId,
+  string
+> = {
+  Instagram: "Instagram",
+  TikTok: "TikTok",
+  YouTube: "YouTube",
+  Facebook: "Facebook",
+  X: "X (Twitter)",
+  LinkedIn: "LinkedIn",
+  Twitch: "Twitch",
+  Snapchat: "Snapchat",
+  Pinterest: "Pinterest",
+  BlogNewsletter: "Blog / Newsletter",
+};
+
+export function isInfluencerEventService(
+  subType: string | null | undefined
+): boolean {
+  return subType === "Influencer";
+}
+
+export function formatInfluencerAudienceTier(
+  tier: InfluencerAudienceTier | null | undefined
+): string | null {
+  if (!tier) {
+    return null;
+  }
+  const range = INFLUENCER_AUDIENCE_TIER_RANGES[tier];
+  return `${INFLUENCER_AUDIENCE_TIER_LABELS[tier]} (${range.description})`;
+}
+
+/**
+ * Suggest a tier from a raw follower count (e.g. when the provider enters an exact number).
+ */
+export function suggestInfluencerAudienceTierFromFollowerCount(
+  count: number
+): InfluencerAudienceTier | null {
+  if (!Number.isFinite(count) || count < 0) {
+    return null;
+  }
+  if (count < 1_000) {
+    return null;
+  }
+  if (count < 10_000) {
+    return "Nano";
+  }
+  if (count < 100_000) {
+    return "Micro";
+  }
+  if (count < 1_000_000) {
+    return "Macro";
+  }
+  return "Mega";
+}
+
+export function formatInfluencerPlatforms(
+  platforms: string[] | null | undefined
+): string {
+  if (!platforms?.length) {
+    return "";
+  }
+  return platforms
+    .map((p) => {
+      if (
+        (INFLUENCER_PRIMARY_PLATFORMS as readonly string[]).includes(p)
+      ) {
+        return INFLUENCER_PLATFORM_LABELS[p as InfluencerPrimaryPlatformId];
+      }
+      return p;
+    })
+    .join(", ");
+}
+
+export function followerCountMatchesTier(
+  count: number | null | undefined,
+  tier: InfluencerAudienceTier | null | undefined
+): boolean {
+  if (count == null || tier == null) {
+    return true;
+  }
+  const suggested = suggestInfluencerAudienceTierFromFollowerCount(count);
+  return suggested === tier;
+}

package/src/mirroredPrismaEnums.ts

@@ -180,3 +180,19 @@ export const CreditSourceType = {
 } as const satisfies Record<CreditSourceTypeEnum, CreditSourceTypeEnum>;
 
 export type CreditSourceType = CreditSourceTypeEnum;
+
+/**
+ * Mirrors Prisma `BracketType` — includes HEAT / BATTLE_ROYALE before all consumers
+ * refresh `@prisma/client` (see README-typecheck.md).
+ */
+export const BracketType = {
+  NONE: "NONE",
+  SINGLE_ELIMINATION: "SINGLE_ELIMINATION",
+  DOUBLE_ELIMINATION: "DOUBLE_ELIMINATION",
+  ROUND_ROBIN: "ROUND_ROBIN",
+  SWISS: "SWISS",
+  HEAT: "HEAT",
+  BATTLE_ROYALE: "BATTLE_ROYALE",
+} as const;
+
+export type BracketType = (typeof BracketType)[keyof typeof BracketType];

package/src/productLaunch.ts

@@ -0,0 +1,68 @@
+/**
+ * Bash Labs product launch waitlists — shared product metadata and validation.
+ */
+
+export const PRODUCT_LAUNCH_PRODUCTS = [
+  "BashOne",
+  "SecondaryMarketplace",
+  "Memories",
+  "AiOrganizer",
+  "Enterprise",
+] as const;
+
+export type ProductLaunchProductId = (typeof PRODUCT_LAUNCH_PRODUCTS)[number];
+
+/** Products with dedicated Bash Labs waitlist signup forms (not Enterprise). */
+export const BASH_LABS_WAITLIST_PRODUCTS = [
+  "BashOne",
+  "SecondaryMarketplace",
+  "Memories",
+  "AiOrganizer",
+] as const satisfies readonly ProductLaunchProductId[];
+
+export type BashLabsWaitlistProductId =
+  (typeof BASH_LABS_WAITLIST_PRODUCTS)[number];
+
+export function isProductLaunchProduct(
+  value: string
+): value is ProductLaunchProductId {
+  return (PRODUCT_LAUNCH_PRODUCTS as readonly string[]).includes(value);
+}
+
+export function isBashLabsWaitlistProduct(
+  value: string
+): value is BashLabsWaitlistProductId {
+  return (BASH_LABS_WAITLIST_PRODUCTS as readonly string[]).includes(value);
+}
+
+/** Lower score = higher community priority (rank 1 = weight 1, rank 5 = weight 5). */
+export function productLaunchRankWeight(rankIndex: number): number {
+  return rankIndex + 1;
+}
+
+export const PRODUCT_LAUNCH_LABELS: Record<ProductLaunchProductId, string> = {
+  BashOne: "B-One",
+  SecondaryMarketplace: "Secondary Marketplace",
+  Memories: "Memories",
+  AiOrganizer: "AI Organizer",
+  Enterprise: "Enterprise",
+};
+
+export const PRODUCT_LAUNCH_ROUTES: Partial<
+  Record<ProductLaunchProductId, string>
+> = {
+  BashOne: "/bash-labs/b-one",
+  SecondaryMarketplace: "/bash-labs/marketplace",
+  Memories: "/bash-labs/memories",
+  AiOrganizer: "/bash-labs/ai-organizer",
+  Enterprise: "/enterprise#early-access",
+};
+
+/** Star priority 1–5 for roadmap cards (higher = more strategic). */
+export const PRODUCT_LAUNCH_PRIORITY: Record<ProductLaunchProductId, number> = {
+  Memories: 5,
+  AiOrganizer: 4,
+  SecondaryMarketplace: 4,
+  Enterprise: 3,
+  BashOne: 1,
+};

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

@@ -0,0 +1,27 @@
+import { getAgencyBookingCheckoutPaymentNotice } from "../agencyBookingCheckoutCopy.js";
+
+describe("getAgencyBookingCheckoutPaymentNotice", () => {
+  it("returns null for solo bookings", () => {
+    expect(getAgencyBookingCheckoutPaymentNotice({})).toBeNull();
+  });
+
+  it("describes agency merchant of record checkout", () => {
+    const notice = getAgencyBookingCheckoutPaymentNotice({
+      representedByOrganizationId: "org_1",
+      payoutModelSnapshot: "AgencyMerchantOfRecord",
+      representedByOrganization: { name: "Midnight Artists" },
+    });
+    expect(notice).toContain("Midnight Artists");
+    expect(notice).toContain("agency's connected Stripe account");
+  });
+
+  it("describes artist merchant of record with agency representation", () => {
+    const notice = getAgencyBookingCheckoutPaymentNotice({
+      representedByOrganizationId: "org_1",
+      payoutModelSnapshot: "ArtistMerchantOfRecord",
+      representedByOrganization: { name: "Midnight Artists" },
+    });
+    expect(notice).toContain("artist's Stripe account");
+    expect(notice).toContain("Midnight Artists");
+  });
+});

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

@@ -0,0 +1,122 @@
+import {
+  entertainerFitsHostExpectedCrowd,
+  findNotableVenueNameMatch,
+  getEntertainerEffectiveDraw,
+  getVenueEffectiveCapacity,
+  scoreDrawCapacityFit,
+} from "../entertainmentDrawFit.js";
+
+describe("getEntertainerEffectiveDraw", () => {
+  it("prefers shared expected draw", () => {
+    expect(
+      getEntertainerEffectiveDraw({
+        expected: 120,
+        showExpectedGuests: true,
+        ideal: 80,
+        showIdealGuests: true,
+        minimum: 40,
+        showMinimumGuests: true,
+      })
+    ).toBe(120);
+  });
+
+  it("falls back to ideal then minimum", () => {
+    expect(
+      getEntertainerEffectiveDraw({
+        expected: 120,
+        showExpectedGuests: false,
+        ideal: 80,
+        showIdealGuests: true,
+        minimum: 40,
+        showMinimumGuests: true,
+      })
+    ).toBe(80);
+  });
+});
+
+describe("scoreDrawCapacityFit", () => {
+  it("awards full points when draw fits capacity", () => {
+    const result = scoreDrawCapacityFit(
+      { capacity: 200 },
+      {
+        expected: 150,
+        showExpectedGuests: true,
+        ideal: null,
+        showIdealGuests: false,
+        minimum: null,
+        showMinimumGuests: false,
+      }
+    );
+    expect(result.points).toBe(15);
+    expect(result.reason).toMatch(/fits venue capacity/i);
+  });
+
+  it("gives partial credit when draw is unspecified", () => {
+    const result = scoreDrawCapacityFit({ capacity: 200 }, null);
+    expect(result.points).toBe(5);
+  });
+});
+
+describe("entertainerFitsHostExpectedCrowd", () => {
+  it("passes when draw is in a reasonable band around host expectation", () => {
+    expect(
+      entertainerFitsHostExpectedCrowd(100, {
+        expected: 80,
+        showExpectedGuests: true,
+        ideal: null,
+        showIdealGuests: false,
+        minimum: null,
+        showMinimumGuests: false,
+      })
+    ).toBe(true);
+  });
+
+  it("does not exclude entertainers without draw data", () => {
+    expect(entertainerFitsHostExpectedCrowd(200, null)).toBe(true);
+  });
+
+  it("filters entertainers whose draw is far from host expectation", () => {
+    expect(
+      entertainerFitsHostExpectedCrowd(50, {
+        expected: 500,
+        showExpectedGuests: true,
+        ideal: null,
+        showIdealGuests: false,
+        minimum: null,
+        showMinimumGuests: false,
+      })
+    ).toBe(false);
+  });
+});
+
+describe("findNotableVenueNameMatch", () => {
+  it("matches substring venue names case-insensitively when sharing is enabled", () => {
+    expect(
+      findNotableVenueNameMatch("The Fillmore SF", ["Fillmore"], true)
+    ).toBe("Fillmore");
+  });
+
+  it("returns null when sharing is disabled", () => {
+    expect(
+      findNotableVenueNameMatch("The Fillmore SF", ["Fillmore"], false)
+    ).toBeNull();
+  });
+
+  it("returns null when no overlap", () => {
+    expect(
+      findNotableVenueNameMatch("Small Bar NYC", ["Madison Square Garden"], true)
+    ).toBeNull();
+  });
+});
+
+describe("getVenueEffectiveCapacity", () => {
+  it("uses capacity before anticipated attendees", () => {
+    expect(
+      getVenueEffectiveCapacity({ capacity: 300, anticipatedAttendees: 100 })
+    ).toBe(300);
+  });
+
+  it("falls back to anticipated attendees", () => {
+    expect(getVenueEffectiveCapacity({ anticipatedAttendees: 150 })).toBe(150);
+  });
+});

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

@@ -19,6 +19,15 @@ describe("resolveAttendeeListAccess", () => {
     ).toBe("TicketHolders");
   });
 
+  it("accepts RsvpGoing attendee list access", () => {
+    expect(
+      resolveAttendeeListAccess({
+        attendeeListAccess: "RsvpGoing",
+        attendeeListPublic: false,
+      })
+    ).toBe("RsvpGoing");
+  });
+
   it("falls back to legacy attendeeListPublic boolean", () => {
     expect(resolveAttendeeListAccess({ attendeeListPublic: true })).toBe(
       "Public"

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

@@ -121,6 +121,20 @@ describe("viewerCanSeeFullBashLocation", () => {
       })
     ).toBe(true);
   });
+
+  it("guest session Going unlocks address without a logged-in user", () => {
+    const bash = { ...baseBash, locationRevealAudience: "TicketHoldersAndRsvps" as const };
+    expect(
+      viewerCanSeeFullBashLocation(bash, {
+        viewerUserId: null,
+        isHostOrOrganizer: false,
+        viewerOwnsValidTicket: false,
+        viewerPublicRsvpGoing: false,
+        viewerHasAcceptedInvitation: false,
+        viewerGuestRsvpGoing: true,
+      })
+    ).toBe(true);
+  });
 });
 
 describe("isLocationGloballyPublic", () => {

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

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "@jest/globals";
+
+import { organizationHasVanitySubdomain } from "../organizationEntitlements.js";
+
+describe("organizationHasVanitySubdomain", () => {
+  test("null / undefined return false", () => {
+    expect(organizationHasVanitySubdomain(null)).toBe(false);
+    expect(organizationHasVanitySubdomain(undefined)).toBe(false);
+  });
+
+  test("non-Enterprise tiers are never entitled", () => {
+    for (const tier of ["Starter", "Growth", "Church", "Legacy", null]) {
+      expect(
+        organizationHasVanitySubdomain({
+          subscriptionTier: tier,
+          subscriptionStatus: "Active",
+        })
+      ).toBe(false);
+    }
+  });
+
+  test("Enterprise with active or trialing status is entitled", () => {
+    expect(
+      organizationHasVanitySubdomain({
+        subscriptionTier: "Enterprise",
+        subscriptionStatus: "Active",
+      })
+    ).toBe(true);
+    expect(
+      organizationHasVanitySubdomain({
+        subscriptionTier: "Enterprise",
+        subscriptionStatus: "Trialing",
+      })
+    ).toBe(true);
+  });
+
+  test("Enterprise with a missing status is treated as active (legacy/ops orgs)", () => {
+    expect(
+      organizationHasVanitySubdomain({ subscriptionTier: "Enterprise" })
+    ).toBe(true);
+    expect(
+      organizationHasVanitySubdomain({
+        subscriptionTier: "Enterprise",
+        subscriptionStatus: null,
+      })
+    ).toBe(true);
+  });
+
+  test("Enterprise with a lapsed status is not entitled", () => {
+    for (const status of ["Canceled", "PastDue", "Canceling"]) {
+      expect(
+        organizationHasVanitySubdomain({
+          subscriptionTier: "Enterprise",
+          subscriptionStatus: status,
+        })
+      ).toBe(false);
+    }
+  });
+});

package/src/utils/__tests__/reputationUtils.bayesian.test.ts

@@ -0,0 +1,48 @@
+import {
+  bayesianAverage,
+  getReputationSummary,
+  MIN_RATINGS_FOR_DISPLAY,
+} from "../reputationUtils.js";
+
+describe("bayesianAverage", () => {
+  it("returns null when there are no ratings", () => {
+    expect(bayesianAverage(null, 0)).toBeNull();
+    expect(bayesianAverage(5, 0)).toBeNull();
+  });
+
+  it("pulls low-volume averages toward the prior mean", () => {
+    const score = bayesianAverage(5, 2);
+    expect(score).not.toBeNull();
+    expect(score!).toBeLessThan(5);
+    expect(score!).toBeGreaterThan(4);
+  });
+
+  it("approaches the raw average with many ratings", () => {
+    const score = bayesianAverage(4.8, 500);
+    expect(score).toBeGreaterThan(4.7);
+    expect(score).toBeLessThanOrEqual(4.8);
+  });
+
+  it("respects custom prior options", () => {
+    const strict = bayesianAverage(5, 1, { priorCount: 50, priorMean: 3 });
+    const loose = bayesianAverage(5, 1, { priorCount: 2, priorMean: 3 });
+    expect(strict!).toBeLessThan(loose!);
+  });
+});
+
+describe("getReputationSummary", () => {
+  it("hides average until MIN_RATINGS_FOR_DISPLAY", () => {
+    const summary = getReputationSummary("host", 4.9, MIN_RATINGS_FOR_DISPLAY - 1);
+    expect(summary.hasEnoughSignal).toBe(false);
+    expect(summary.averageRating).toBeNull();
+    expect(summary.bayesianScore).not.toBeNull();
+  });
+
+  it("exposes average and bayesian score above threshold", () => {
+    const summary = getReputationSummary("venue", 4.5, 20);
+    expect(summary.hasEnoughSignal).toBe(true);
+    expect(summary.averageRating).toBe(4.5);
+    expect(summary.bayesianScore).toBeGreaterThan(4);
+    expect(summary.actorType).toBe("venue");
+  });
+});

package/src/utils/__tests__/reputationUtils.serviceListing.test.ts

@@ -0,0 +1,36 @@
+import { MIN_RATINGS_FOR_DISPLAY } from "../reputationUtils.js";
+import { getServiceListingReputation } from "../reputationUtils.js";
+
+describe("getServiceListingReputation", () => {
+  it("returns null below MIN_RATINGS_FOR_DISPLAY", () => {
+    expect(
+      getServiceListingReputation({
+        serviceRating: 4.9,
+        totalRatings: MIN_RATINGS_FOR_DISPLAY - 1,
+      })
+    ).toBeNull();
+  });
+
+  it("returns rating summary at the display threshold", () => {
+    expect(
+      getServiceListingReputation({
+        serviceRating: 4.0,
+        totalRatings: MIN_RATINGS_FOR_DISPLAY,
+      })
+    ).toEqual({
+      averageRating: 4,
+      totalRatings: MIN_RATINGS_FOR_DISPLAY,
+      sourceLabel: undefined,
+    });
+  });
+
+  it("omits sourceLabel for non-google external sources", () => {
+    expect(
+      getServiceListingReputation({
+        serviceRating: 4.2,
+        totalRatings: 8,
+        externalReviewSource: "yelp",
+      })?.sourceLabel
+    ).toBeUndefined();
+  });
+});