@bash-app/bash-common 30.284.0 → 30.289.0

package/src/__tests__/accessScreening.test.ts

@@ -0,0 +1,29 @@
+import { accessScreeningBlocksAttendeeActions } from "../accessScreening.js";
+
+describe("accessScreeningBlocksAttendeeActions", () => {
+  it("does not block when screening is off", () => {
+    expect(accessScreeningBlocksAttendeeActions(false, null, false)).toBe(false);
+  });
+
+  it("does not block when approved", () => {
+    expect(accessScreeningBlocksAttendeeActions(true, "Approved", false)).toBe(
+      false
+    );
+  });
+
+  it("blocks when pending", () => {
+    expect(accessScreeningBlocksAttendeeActions(true, "Pending", false)).toBe(
+      true
+    );
+  });
+
+  it("blocks when denied", () => {
+    expect(accessScreeningBlocksAttendeeActions(true, "Denied", false)).toBe(
+      true
+    );
+  });
+
+  it("does not block ticket holders", () => {
+    expect(accessScreeningBlocksAttendeeActions(true, "None", true)).toBe(false);
+  });
+});

package/src/__tests__/bookingIntent.test.ts

@@ -0,0 +1,50 @@
+import {
+  BOOKING_INTENT_LABELS,
+  isAcceptingBookings,
+  NOT_TAKING_DATES_MESSAGE,
+  shouldShowBookingIntentBadge,
+} from "../bookingIntent.js";
+
+describe("bookingIntent", () => {
+  it("maps all enum values to labels", () => {
+    expect(BOOKING_INTENT_LABELS.ActivelySeeking).toBe(
+      "Actively taking bookings"
+    );
+    expect(BOOKING_INTENT_LABELS.OpenToOffers).toBe("Open to offers");
+    expect(BOOKING_INTENT_LABELS.NotTakingDates).toBe("Not taking new dates");
+  });
+
+  it("shouldShowBookingIntentBadge hides OpenToOffers", () => {
+    expect(shouldShowBookingIntentBadge("OpenToOffers")).toBe(false);
+    expect(shouldShowBookingIntentBadge("ActivelySeeking")).toBe(true);
+    expect(shouldShowBookingIntentBadge("NotTakingDates")).toBe(true);
+    expect(shouldShowBookingIntentBadge(undefined)).toBe(false);
+  });
+
+  describe("isAcceptingBookings", () => {
+    it("returns true for ActivelySeeking", () => {
+      expect(isAcceptingBookings("ActivelySeeking")).toBe(true);
+    });
+
+    it("returns true for OpenToOffers", () => {
+      expect(isAcceptingBookings("OpenToOffers")).toBe(true);
+    });
+
+    it("returns false for NotTakingDates", () => {
+      expect(isAcceptingBookings("NotTakingDates")).toBe(false);
+    });
+
+    it("returns true for null (treats missing intent as open)", () => {
+      expect(isAcceptingBookings(null)).toBe(true);
+    });
+
+    it("returns true for undefined", () => {
+      expect(isAcceptingBookings(undefined)).toBe(true);
+    });
+  });
+
+  it("NOT_TAKING_DATES_MESSAGE is a non-empty string", () => {
+    expect(typeof NOT_TAKING_DATES_MESSAGE).toBe("string");
+    expect(NOT_TAKING_DATES_MESSAGE.length).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/entertainmentNotableVenues.test.ts

@@ -0,0 +1,110 @@
+import {
+  formatNotableVenueEntryLine,
+  formatNotableVenueReasons,
+  getNotableVenueReasonLabel,
+  notableVenueEntriesFromNames,
+  notableVenueNamesFromEntries,
+  parseNotableVenueEntries,
+  resolveNotableVenueEntries,
+} from "../entertainmentNotableVenues.js";
+
+describe("parseNotableVenueEntries", () => {
+  it("parses structured entries", () => {
+    expect(
+      parseNotableVenueEntries([
+        {
+          name: "The Fillmore",
+          isFavorite: true,
+          reasonTags: ["GreatSound", "Other"],
+          otherNote: "Legendary room",
+        },
+      ])
+    ).toEqual([
+      {
+        name: "The Fillmore",
+        isFavorite: true,
+        reasonTags: ["GreatSound", "Other"],
+        otherNote: "Legendary room",
+      },
+    ]);
+  });
+
+  it("filters invalid tags and empty names", () => {
+    expect(
+      parseNotableVenueEntries([
+        { name: "  ", reasonTags: ["NotARealTag"] },
+        { name: "Valid", reasonTags: ["NiceAesthetic"] },
+      ])
+    ).toEqual([{ name: "Valid", reasonTags: ["NiceAesthetic"] }]);
+  });
+});
+
+describe("resolveNotableVenueEntries", () => {
+  it("prefers structured JSON over legacy strings", () => {
+    expect(
+      resolveNotableVenueEntries({
+        notableVenueEntries: [{ name: "A", isFavorite: true }],
+        notableVenuesPerformed: ["Legacy"],
+      })
+    ).toEqual([{ name: "A", isFavorite: true }]);
+  });
+
+  it("falls back to legacy string array", () => {
+    expect(
+      resolveNotableVenueEntries({
+        notableVenuesPerformed: ["Brooklyn Bowl"],
+      })
+    ).toEqual([{ name: "Brooklyn Bowl" }]);
+  });
+});
+
+describe("notableVenueNamesFromEntries", () => {
+  it("dedupes case-insensitively", () => {
+    expect(
+      notableVenueNamesFromEntries([
+        { name: "Club A" },
+        { name: "club a" },
+        { name: "Club B" },
+      ])
+    ).toEqual(["Club A", "Club B"]);
+  });
+});
+
+describe("formatNotableVenueEntryLine", () => {
+  it("includes favorite star and reason labels", () => {
+    expect(
+      formatNotableVenueEntryLine({
+        name: "Main Room",
+        isFavorite: true,
+        reasonTags: ["GreatSound", "ProStaff"],
+      })
+    ).toBe("Main Room ★ — Great sound · Pro staff / crew");
+  });
+
+  it("includes other note when Other tag selected", () => {
+    expect(
+      formatNotableVenueReasons({
+        name: "X",
+        reasonTags: ["Other"],
+        otherNote: "Killer green room",
+      })
+    ).toBe("Killer green room");
+  });
+});
+
+describe("notableVenueEntriesFromNames", () => {
+  it("maps legacy names to minimal entries", () => {
+    expect(notableVenueEntriesFromNames([" A ", "B"])).toEqual([
+      { name: "A" },
+      { name: "B" },
+    ]);
+  });
+});
+
+describe("getNotableVenueReasonLabel", () => {
+  it("returns human label for tag id", () => {
+    expect(getNotableVenueReasonLabel("NiceAesthetic")).toBe(
+      "Nice vibe & look"
+    );
+  });
+});

package/src/__tests__/influencerAudience.test.ts

@@ -0,0 +1,38 @@
+import {
+  formatInfluencerAudienceTier,
+  isInfluencerEventService,
+  suggestInfluencerAudienceTierFromFollowerCount,
+  followerCountMatchesTier,
+} from "../influencerAudience.js";
+
+describe("influencerAudience", () => {
+  it("identifies Influencer subtype", () => {
+    expect(isInfluencerEventService("Influencer")).toBe(true);
+    expect(isInfluencerEventService("ContentCreator")).toBe(false);
+  });
+
+  it("formats tier with follower band", () => {
+    expect(formatInfluencerAudienceTier("Micro")).toBe(
+      "Micro (10K–100K followers)"
+    );
+  });
+
+  it("suggests tier from follower count", () => {
+    expect(suggestInfluencerAudienceTierFromFollowerCount(5_000)).toBe("Nano");
+    expect(suggestInfluencerAudienceTierFromFollowerCount(50_000)).toBe(
+      "Micro"
+    );
+    expect(suggestInfluencerAudienceTierFromFollowerCount(250_000)).toBe(
+      "Macro"
+    );
+    expect(suggestInfluencerAudienceTierFromFollowerCount(2_000_000)).toBe(
+      "Mega"
+    );
+  });
+
+  it("validates count against selected tier", () => {
+    expect(followerCountMatchesTier(25_000, "Micro")).toBe(true);
+    expect(followerCountMatchesTier(25_000, "Macro")).toBe(false);
+    expect(followerCountMatchesTier(null, "Micro")).toBe(true);
+  });
+});

package/src/__tests__/productLaunch.test.ts

@@ -0,0 +1,52 @@
+import {
+  BASH_LABS_WAITLIST_PRODUCTS,
+  isBashLabsWaitlistProduct,
+  isProductLaunchProduct,
+  PRODUCT_LAUNCH_PRIORITY,
+  PRODUCT_LAUNCH_PRODUCTS,
+  PRODUCT_LAUNCH_ROUTES,
+  productLaunchRankWeight,
+} from "../productLaunch.js";
+
+describe("productLaunch", () => {
+  describe("product id guards", () => {
+    it("accepts known launch products", () => {
+      for (const id of PRODUCT_LAUNCH_PRODUCTS) {
+        expect(isProductLaunchProduct(id)).toBe(true);
+      }
+    });
+
+    it("rejects unknown strings", () => {
+      expect(isProductLaunchProduct("NotAProduct")).toBe(false);
+    });
+
+    it("waitlist guard excludes Enterprise", () => {
+      expect(isBashLabsWaitlistProduct("Enterprise")).toBe(false);
+      for (const id of BASH_LABS_WAITLIST_PRODUCTS) {
+        expect(isBashLabsWaitlistProduct(id)).toBe(true);
+      }
+    });
+  });
+
+  describe("productLaunchRankWeight", () => {
+    it("maps rank index to 1-based weight (lower = higher priority)", () => {
+      expect(productLaunchRankWeight(0)).toBe(1);
+      expect(productLaunchRankWeight(4)).toBe(5);
+      expect(productLaunchRankWeight(0)).toBeLessThan(productLaunchRankWeight(4));
+    });
+  });
+
+  describe("metadata maps", () => {
+    it("defines routes for every launch product", () => {
+      for (const id of PRODUCT_LAUNCH_PRODUCTS) {
+        expect(PRODUCT_LAUNCH_ROUTES[id]).toBeTruthy();
+      }
+    });
+
+    it("defines priority for every launch product", () => {
+      for (const id of PRODUCT_LAUNCH_PRODUCTS) {
+        expect(PRODUCT_LAUNCH_PRIORITY[id]).toBeGreaterThan(0);
+      }
+    });
+  });
+});

package/src/accessScreening.ts

@@ -0,0 +1,23 @@
+/**
+ * Event access screening — shared status values for API + app.
+ */
+export const ACCESS_REQUEST_STATUSES = [
+  "None",
+  "Pending",
+  "Approved",
+  "Denied",
+] as const;
+
+export type AccessRequestStatus =
+  (typeof ACCESS_REQUEST_STATUSES)[number];
+
+/** True when the viewer must complete access screening before tickets / affirmative RSVP. */
+export function accessScreeningBlocksAttendeeActions(
+  enabled: boolean | undefined,
+  status: AccessRequestStatus | null | undefined,
+  hasTicket: boolean
+): boolean {
+  if (!enabled) return false;
+  if (hasTicket) return false;
+  return status !== "Approved";
+}

package/src/aiEventPlan.ts

@@ -0,0 +1,75 @@
+/** Shape of a single AI-suggested itinerary block (matches WhatItinerary / BashEvent.itinerary). */
+export interface AiItineraryItem {
+  id: string;
+  title: string;
+  startTime: string;
+  endTime: string;
+  description?: string;
+}
+
+/** Shape of a single AI-suggested host prep task before accept. */
+export interface AiSuggestedTask {
+  title: string;
+  description?: string;
+  dueDaysBeforeEvent?: number;
+  category?: "Venue" | "Vendors" | "Marketing" | "Tickets" | "DayOf" | "Other";
+}
+
+export function parseAiItinerarySuggestions(raw: unknown): AiItineraryItem[] {
+  if (!Array.isArray(raw)) return [];
+  const out: AiItineraryItem[] = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const row = item as Record<string, unknown>;
+    const title = typeof row.title === "string" ? row.title.trim() : "";
+    const startTime = typeof row.startTime === "string" ? row.startTime : "";
+    const endTime = typeof row.endTime === "string" ? row.endTime : "";
+    if (!title || !startTime || !endTime) continue;
+    out.push({
+      id: typeof row.id === "string" && row.id ? row.id : cryptoRandomId(),
+      title,
+      startTime,
+      endTime,
+      description:
+        typeof row.description === "string" ? row.description : undefined,
+    });
+  }
+  return out;
+}
+
+export function parseAiTaskSuggestions(raw: unknown): AiSuggestedTask[] {
+  if (!Array.isArray(raw)) return [];
+  const out: AiSuggestedTask[] = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const row = item as Record<string, unknown>;
+    const title = typeof row.title === "string" ? row.title.trim() : "";
+    if (!title) continue;
+    out.push({
+      title,
+      description:
+        typeof row.description === "string" ? row.description : undefined,
+      dueDaysBeforeEvent:
+        typeof row.dueDaysBeforeEvent === "number"
+          ? row.dueDaysBeforeEvent
+          : undefined,
+      category:
+        row.category === "Venue" ||
+        row.category === "Vendors" ||
+        row.category === "Marketing" ||
+        row.category === "Tickets" ||
+        row.category === "DayOf" ||
+        row.category === "Other"
+          ? row.category
+          : undefined,
+    });
+  }
+  return out;
+}
+
+function cryptoRandomId(): string {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `ai-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}

package/src/bookingIntent.ts

@@ -0,0 +1,54 @@
+import type { BookingIntent } from "@prisma/client";
+
+/** User-facing labels for each booking intent value. */
+export const BOOKING_INTENT_LABELS: Record<BookingIntent, string> = {
+  ActivelySeeking: "Actively taking bookings",
+  OpenToOffers: "Open to offers",
+  NotTakingDates: "Not taking new dates",
+};
+
+/** Tailwind classes for intent badges on cards and detail headers. */
+export const BOOKING_INTENT_BADGE_STYLE: Record<
+  BookingIntent,
+  { bg: string; text: string }
+> = {
+  ActivelySeeking: {
+    bg: "bg-green-100 dark:bg-green-900",
+    text: "text-green-800 dark:text-green-200",
+  },
+  OpenToOffers: {
+    bg: "bg-blue-100 dark:bg-blue-900",
+    text: "text-blue-800 dark:text-blue-200",
+  },
+  NotTakingDates: {
+    bg: "bg-gray-100 dark:bg-gray-800",
+    text: "text-gray-700 dark:text-gray-300",
+  },
+};
+
+/** Short browse-card label for actively seeking providers. */
+export const BOOKING_INTENT_BROWSE_CARD_LABEL = "Taking Bookings";
+
+/**
+ * Whether to show a public intent badge. OpenToOffers is the quiet default and
+ * is hidden to avoid cluttering every listing.
+ */
+export function shouldShowBookingIntentBadge(
+  intent: BookingIntent | null | undefined
+): intent is Exclude<BookingIntent, "OpenToOffers"> {
+  return intent === "ActivelySeeking" || intent === "NotTakingDates";
+}
+
+/**
+ * Whether a provider currently accepts new bookings or offers.
+ * Used by both the API (server-side guard) and the app (CTA gating).
+ */
+export function isAcceptingBookings(
+  intent: BookingIntent | null | undefined
+): boolean {
+  return intent !== "NotTakingDates";
+}
+
+/** User-facing message when a provider has paused inbound bookings. */
+export const NOT_TAKING_DATES_MESSAGE =
+  "This provider isn't taking new dates right now.";

package/src/definitions.ts

@@ -1,6 +1,5 @@
 import {
     BashEventType,
-    BracketType,
     CompetitionType,
     Contact,
     DietaryOption,
@@ -815,6 +814,8 @@ export interface ApiResult<T, P extends ErrorDataType = ErrorDataType> {
   /** e.g. safe path to navigate after password reset */
   returnTo?: string;
   error?: string;
+  /** Milliseconds until a rate-limited action may be retried (HTTP 429). */
+  retryAfterMs?: number;
   /** Machine-readable error code for clients (e.g. duplicate ticket transfer). */
   code?: string;
   errorType?: ApiErrorType;
@@ -1137,9 +1138,10 @@ export const YearsOfExperienceToString: { [key in YearsOfExperienceEnum]: string
     [YearsOfExperience.FivePlusYears]: "More than five years",
   };
 
+export { BracketType } from "./mirroredPrismaEnums.js";
+
 // Export Prisma enums for use in frontend
 export {
-    BracketType,
     CompetitionType,
     EntertainmentServiceType,
     JudgingType,

package/src/entertainmentNotableVenues.ts

@@ -0,0 +1,137 @@
+/**
+ * Structured notable-venue history for entertainment listings.
+ * Stored as JSON on EntertainmentService.notableVenueEntries; names are
+ * denormalized to notableVenuesPerformed for matching queries.
+ */
+
+export const NOTABLE_VENUE_REASON_TAGS = [
+  { id: "GreatSound", label: "Great sound" },
+  { id: "NiceAesthetic", label: "Nice vibe & look" },
+  { id: "ProStaff", label: "Pro staff / crew" },
+  { id: "GoodCrowd", label: "Great crowd energy" },
+  { id: "EasyLoadIn", label: "Easy load-in" },
+  { id: "FairPay", label: "Fair pay" },
+  { id: "GoodHospitality", label: "Good hospitality" },
+  { id: "Other", label: "Other" },
+] as const;
+
+export type NotableVenueReasonTagId =
+  (typeof NOTABLE_VENUE_REASON_TAGS)[number]["id"];
+
+export interface EntertainmentNotableVenueEntry {
+  name: string;
+  isFavorite?: boolean;
+  reasonTags?: NotableVenueReasonTagId[];
+  /** Free text when reasonTags includes Other */
+  otherNote?: string | null;
+}
+
+const REASON_LABEL_BY_ID = Object.fromEntries(
+  NOTABLE_VENUE_REASON_TAGS.map((t) => [t.id, t.label])
+) as Record<NotableVenueReasonTagId, string>;
+
+export function getNotableVenueReasonLabel(
+  tagId: NotableVenueReasonTagId
+): string {
+  return REASON_LABEL_BY_ID[tagId] ?? tagId;
+}
+
+function isReasonTagId(value: string): value is NotableVenueReasonTagId {
+  return NOTABLE_VENUE_REASON_TAGS.some((t) => t.id === value);
+}
+
+function normalizeEntry(raw: unknown): EntertainmentNotableVenueEntry | null {
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw as Record<string, unknown>;
+  const name = typeof record.name === "string" ? record.name.trim() : "";
+  if (!name) return null;
+
+  const reasonTags = Array.isArray(record.reasonTags)
+    ? record.reasonTags.filter(
+        (t): t is NotableVenueReasonTagId =>
+          typeof t === "string" && isReasonTagId(t)
+      )
+    : undefined;
+
+  const otherNote =
+    typeof record.otherNote === "string" ? record.otherNote.trim() : undefined;
+
+  return {
+    name,
+    isFavorite: record.isFavorite === true,
+    reasonTags: reasonTags?.length ? reasonTags : undefined,
+    otherNote: otherNote || undefined,
+  };
+}
+
+/** Parse Prisma JSON / API payload into typed venue entries. */
+export function parseNotableVenueEntries(
+  value: unknown
+): EntertainmentNotableVenueEntry[] {
+  if (!value) return [];
+  if (Array.isArray(value)) {
+    return value
+      .map(normalizeEntry)
+      .filter((e): e is EntertainmentNotableVenueEntry => e != null);
+  }
+  return [];
+}
+
+/** Build entries from legacy string[] column (pre-structured migration). */
+export function notableVenueEntriesFromNames(
+  names: string[] | null | undefined
+): EntertainmentNotableVenueEntry[] {
+  if (!names?.length) return [];
+  return names
+    .map((name) => name.trim())
+    .filter(Boolean)
+    .map((name) => ({ name }));
+}
+
+/** Resolve entries from structured JSON or legacy string list. */
+export function resolveNotableVenueEntries(input: {
+  notableVenueEntries?: unknown;
+  notableVenuesPerformed?: string[] | null;
+}): EntertainmentNotableVenueEntry[] {
+  const parsed = parseNotableVenueEntries(input.notableVenueEntries);
+  if (parsed.length > 0) return parsed;
+  return notableVenueEntriesFromNames(input.notableVenuesPerformed);
+}
+
+/** Denormalized venue names for matching and simple filters. */
+export function notableVenueNamesFromEntries(
+  entries: EntertainmentNotableVenueEntry[]
+): string[] {
+  const seen = new Set<string>();
+  const names: string[] = [];
+  for (const entry of entries) {
+    const key = entry.name.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    names.push(entry.name);
+  }
+  return names;
+}
+
+export function formatNotableVenueReasons(
+  entry: EntertainmentNotableVenueEntry
+): string | null {
+  const parts: string[] = [];
+  for (const tag of entry.reasonTags ?? []) {
+    if (tag === "Other") {
+      if (entry.otherNote) parts.push(entry.otherNote);
+    } else {
+      parts.push(getNotableVenueReasonLabel(tag));
+    }
+  }
+  return parts.length > 0 ? parts.join(" · ") : null;
+}
+
+export function formatNotableVenueEntryLine(
+  entry: EntertainmentNotableVenueEntry
+): string {
+  const reasons = formatNotableVenueReasons(entry);
+  const favorite = entry.isFavorite ? " ★" : "";
+  if (reasons) return `${entry.name}${favorite} — ${reasons}`;
+  return `${entry.name}${favorite}`;
+}