@bash-app/bash-common 30.386.0 → 30.393.0

package/src/__tests__/scenePulse.test.ts

@@ -0,0 +1,69 @@
+/**
+ * parseScenePulseScope — city default, invalid → null.
+ */
+import { describe, expect, test } from "@jest/globals";
+
+import {
+  emptyScenePulseEnergy,
+  normalizeScenePulseGeoOverride,
+  parseScenePulseScope,
+} from "../scenePulse.js";
+
+describe("parseScenePulseScope", () => {
+  test("defaults missing to city", () => {
+    expect(parseScenePulseScope(undefined)).toBe("city");
+    expect(parseScenePulseScope(null)).toBe("city");
+    expect(parseScenePulseScope("")).toBe("city");
+  });
+
+  test("accepts city region world", () => {
+    expect(parseScenePulseScope("city")).toBe("city");
+    expect(parseScenePulseScope("Region")).toBe("region");
+    expect(parseScenePulseScope(" WORLD ")).toBe("world");
+  });
+
+  test("rejects unknown values", () => {
+    expect(parseScenePulseScope("you")).toBeNull();
+    expect(parseScenePulseScope(12)).toBeNull();
+  });
+});
+
+describe("normalizeScenePulseGeoOverride", () => {
+  test("returns null when city and state are blank", () => {
+    expect(normalizeScenePulseGeoOverride({})).toBeNull();
+    expect(
+      normalizeScenePulseGeoOverride({ city: "  ", state: "" })
+    ).toBeNull();
+  });
+
+  test("trims city and state and ignores empty sibling", () => {
+    expect(
+      normalizeScenePulseGeoOverride({ city: "  Denver  ", state: "  " })
+    ).toEqual({ city: "Denver", state: null });
+    expect(
+      normalizeScenePulseGeoOverride({ city: "", state: "CO" })
+    ).toEqual({ city: null, state: "CO" });
+  });
+
+  test("caps overly long values", () => {
+    const city = "A".repeat(90);
+    const parsed = normalizeScenePulseGeoOverride({ city, state: "Utah" });
+    expect(parsed?.city).toHaveLength(80);
+    expect(parsed?.state).toBe("Utah");
+  });
+});
+
+describe("emptyScenePulseEnergy", () => {
+  test("zeros every energy field", () => {
+    expect(emptyScenePulseEnergy()).toEqual({
+      liveNow: 0,
+      going: 0,
+      tonightBashes: 0,
+      tonightGoing: 0,
+      weekendBashes: 0,
+      weekendGoing: 0,
+      newThisWeek: 0,
+      namesInTheRoom: 0,
+    });
+  });
+});

package/src/__tests__/suggestedNight.test.ts

@@ -0,0 +1,11 @@
+import { unfavoriteSuggestedNightAction } from "../suggestedNight.js";
+
+describe("unfavoriteSuggestedNightAction", () => {
+  it("deletes when never reminded", () => {
+    expect(unfavoriteSuggestedNightAction(null)).toBe("delete");
+  });
+
+  it("dismisses after a nudge", () => {
+    expect(unfavoriteSuggestedNightAction(new Date())).toBe("dismiss");
+  });
+});

package/src/__tests__/suggestionScore.test.ts

@@ -0,0 +1,81 @@
+import { DiscoveryScope } from "../discoveryScope.js";
+import { scoreSuggestion, SUGGESTION_WEIGHTS } from "../suggestionScore.js";
+import { UserTasteKind, UserTasteSource } from "../userTaste.js";
+
+function base() {
+  return {
+    connectionsGoingVisible: 0,
+    connectionsGoingHidden: 0,
+    followedHost: false,
+    attendedHost: false,
+    eventType: "Festival",
+    causeTags: [] as string[],
+    musicGenre: null,
+    discoveryScope: DiscoveryScope.Local,
+    artistsToSee: [] as string[],
+    eventTitle: "Block party",
+    distanceMiles: 5,
+    radiusMiles: 50,
+    isFeatured: false,
+    trendingScore: 0,
+    paidFeatureTasteOverlap: false,
+    tastes: [] as Array<{
+      kind: string;
+      value: string;
+      weight: number;
+      source: string;
+    }>,
+  };
+}
+
+describe("scoreSuggestion", () => {
+  it("ranks crew going above paid taste overlap", () => {
+    const crew = scoreSuggestion({
+      ...base(),
+      connectionsGoingVisible: 1,
+    });
+    const paid = scoreSuggestion({
+      ...base(),
+      paidFeatureTasteOverlap: true,
+      tastes: [
+        {
+          kind: UserTasteKind.EventType,
+          value: "Festival",
+          weight: 1,
+          source: UserTasteSource.Explicit,
+        },
+      ],
+    });
+    expect(crew).toBeGreaterThan(SUGGESTION_WEIGHTS.paidFeatureTaste);
+    expect(crew).toBeGreaterThan(
+      paid - SUGGESTION_WEIGHTS.explicitTaste
+    );
+  });
+
+  it("lets travel taste break radius for National events only", () => {
+    const tastes = [
+      {
+        kind: UserTasteKind.DiscoveryScope,
+        value: DiscoveryScope.National,
+        weight: 1,
+        source: UserTasteSource.Explicit,
+      },
+    ];
+    expect(
+      scoreSuggestion({
+        ...base(),
+        discoveryScope: DiscoveryScope.National,
+        distanceMiles: 900,
+        tastes,
+      })
+    ).toBeGreaterThan(0);
+    expect(
+      scoreSuggestion({
+        ...base(),
+        discoveryScope: DiscoveryScope.Local,
+        distanceMiles: 900,
+        tastes,
+      })
+    ).toBe(Number.NEGATIVE_INFINITY);
+  });
+});

package/src/__tests__/userTaste.test.ts

@@ -0,0 +1,33 @@
+import { UserTasteKind, isValidTasteValue, userHasTravelTaste } from "../userTaste.js";
+import { DiscoveryScope } from "../discoveryScope.js";
+
+describe("userTaste", () => {
+  it("accepts Festival event types and rejects junk", () => {
+    expect(isValidTasteValue(UserTasteKind.EventType, "Festival")).toBe(true);
+    expect(isValidTasteValue(UserTasteKind.EventType, "Networking")).toBe(
+      false
+    );
+  });
+
+  it("accepts cause tags and genres", () => {
+    expect(isValidTasteValue(UserTasteKind.CauseTag, "lgbtq")).toBe(true);
+    expect(isValidTasteValue(UserTasteKind.MusicGenre, "House")).toBe(true);
+    expect(isValidTasteValue(UserTasteKind.DiscoveryScope, DiscoveryScope.National)).toBe(
+      true
+    );
+    expect(
+      isValidTasteValue(UserTasteKind.DiscoveryScope, DiscoveryScope.Unspecified)
+    ).toBe(false);
+  });
+
+  it("detects travel taste", () => {
+    expect(
+      userHasTravelTaste([
+        { kind: UserTasteKind.DiscoveryScope, value: DiscoveryScope.National },
+      ])
+    ).toBe(true);
+    expect(
+      userHasTravelTaste([{ kind: UserTasteKind.EventType, value: "Festival" }])
+    ).toBe(false);
+  });
+});

package/src/budgetApproval.ts

@@ -0,0 +1,303 @@
+/**
+ * Event-level budget approval requests — plan sign-off and pre-plan cap asks.
+ * Shared types and validation for api + bash-app.
+ */
+
+import {
+  BASH_EVENT_WIZARD_HOW_MAJOR_STEP,
+  BASH_EVENT_WIZARD_HOW_SUBSTEP,
+} from "./definitions.js";
+
+export const BUDGET_APPROVAL_TTL_DAYS = 14;
+
+export const BudgetApprovalKind = {
+  CapAsk: "CapAsk",
+  PlanSignOff: "PlanSignOff",
+} as const;
+
+export type BudgetApprovalKind =
+  (typeof BudgetApprovalKind)[keyof typeof BudgetApprovalKind];
+
+export const BUDGET_APPROVAL_KINDS = [
+  BudgetApprovalKind.CapAsk,
+  BudgetApprovalKind.PlanSignOff,
+] as const;
+export type BudgetApprovalKindName = BudgetApprovalKind;
+
+export const BudgetApprovalStatus = {
+  Pending: "Pending",
+  Approved: "Approved",
+  ChangesRequested: "ChangesRequested",
+  Declined: "Declined",
+  Cancelled: "Cancelled",
+  Superseded: "Superseded",
+} as const;
+
+export type BudgetApprovalStatus =
+  (typeof BudgetApprovalStatus)[keyof typeof BudgetApprovalStatus];
+
+export const BUDGET_APPROVAL_STATUSES = [
+  BudgetApprovalStatus.Pending,
+  BudgetApprovalStatus.Approved,
+  BudgetApprovalStatus.ChangesRequested,
+  BudgetApprovalStatus.Declined,
+  BudgetApprovalStatus.Cancelled,
+  BudgetApprovalStatus.Superseded,
+] as const;
+export type BudgetApprovalStatusName = BudgetApprovalStatus;
+
+export const BUDGET_APPROVAL_ACTIONS = [
+  "approve",
+  "changes",
+  "decline",
+] as const;
+export type BudgetApprovalAction = (typeof BUDGET_APPROVAL_ACTIONS)[number];
+
+export type BudgetApprovalSnapshotLine = {
+  id: string;
+  name: string;
+  category: string | null;
+  totalAllocatedCents: number;
+};
+
+export type BudgetApprovalLineNoteInput = {
+  budgetId?: string | null;
+  nameSnapshot: string;
+  categorySnapshot?: string | null;
+  allocatedCentsSnapshot: number;
+  note: string;
+};
+
+export type BudgetApprovalDecideInput = {
+  action: BudgetApprovalAction;
+  kind: BudgetApprovalKindName;
+  approverName?: string | null;
+  decisionNote?: string | null;
+  authorizedCents?: number | null;
+  lineNotes?: BudgetApprovalLineNoteInput[] | null;
+};
+
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+export function normalizeApproverEmail(email: string): string {
+  return email.trim().toLowerCase();
+}
+
+export function isValidApproverEmail(email: string): boolean {
+  return EMAIL_RE.test(email.trim());
+}
+
+export function isBudgetApprovalKind(
+  value: string
+): value is BudgetApprovalKindName {
+  return (BUDGET_APPROVAL_KINDS as readonly string[]).includes(value);
+}
+
+export function isBudgetApprovalAction(
+  value: string
+): value is BudgetApprovalAction {
+  return (BUDGET_APPROVAL_ACTIONS as readonly string[]).includes(value);
+}
+
+export function isBudgetApprovalExpired(
+  expiresAt: Date | string,
+  now: Date = new Date()
+): boolean {
+  return now.getTime() > new Date(expiresAt).getTime();
+}
+
+function canonicalizeSnapshotLines(
+  lines: BudgetApprovalSnapshotLine[]
+): BudgetApprovalSnapshotLine[] {
+  return [...lines]
+    .map((line) => ({
+      id: line.id,
+      name: line.name,
+      category: line.category ?? null,
+      totalAllocatedCents: line.totalAllocatedCents,
+    }))
+    .sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export function buildBudgetApprovalSnapshot(
+  lines: Array<{
+    id: string;
+    name: string;
+    category?: string | null;
+    totalAllocatedCents: number;
+  }>
+): { lines: BudgetApprovalSnapshotLine[]; totalCents: number; hash: string } {
+  const snapshotLines: BudgetApprovalSnapshotLine[] = lines.map((line) => ({
+    id: line.id,
+    name: line.name,
+    category: line.category ?? null,
+    totalAllocatedCents: line.totalAllocatedCents,
+  }));
+  const totalCents = snapshotLines.reduce(
+    (sum, line) => sum + line.totalAllocatedCents,
+    0
+  );
+  return {
+    lines: snapshotLines,
+    totalCents,
+    hash: budgetApprovalSnapshotHash(snapshotLines),
+  };
+}
+
+export function budgetApprovalSnapshotHash(
+  lines: BudgetApprovalSnapshotLine[]
+): string {
+  return JSON.stringify(canonicalizeSnapshotLines(lines));
+}
+
+export function parseBudgetApprovalSnapshot(
+  json: unknown
+): BudgetApprovalSnapshotLine[] {
+  if (!Array.isArray(json)) return [];
+  const lines: BudgetApprovalSnapshotLine[] = [];
+  for (const row of json) {
+    if (!row || typeof row !== "object") continue;
+    const rec = row as Record<string, unknown>;
+    if (typeof rec.id !== "string" || typeof rec.name !== "string") continue;
+    if (typeof rec.totalAllocatedCents !== "number") continue;
+    lines.push({
+      id: rec.id,
+      name: rec.name,
+      category: typeof rec.category === "string" ? rec.category : null,
+      totalAllocatedCents: rec.totalAllocatedCents,
+    });
+  }
+  return lines;
+}
+
+export function budgetApprovalSnapshotsMatch(
+  current: BudgetApprovalSnapshotLine[],
+  snapshot: BudgetApprovalSnapshotLine[]
+): boolean {
+  return (
+    budgetApprovalSnapshotHash(current) === budgetApprovalSnapshotHash(snapshot)
+  );
+}
+
+export function validateBudgetApprovalDecide(
+  input: BudgetApprovalDecideInput
+): { ok: true } | { ok: false; error: string } {
+  const decisionNote = input.decisionNote?.trim() ?? "";
+  const lineNotes = (input.lineNotes ?? []).filter(
+    (note) => note.note.trim().length > 0
+  );
+
+  if (input.kind === "CapAsk" && lineNotes.length > 0) {
+    return { ok: false, error: "A cap ask has no budget lines to annotate." };
+  }
+
+  if (input.action === "approve") {
+    if (input.kind === "CapAsk") {
+      const cents = input.authorizedCents;
+      if (cents == null || !Number.isFinite(cents) || cents <= 0) {
+        return {
+          ok: false,
+          error: "Enter an authorized amount greater than zero.",
+        };
+      }
+    }
+    return { ok: true };
+  }
+
+  if (input.action === "changes") {
+    if (input.kind === "CapAsk") {
+      if (!decisionNote) {
+        return {
+          ok: false,
+          error: "Add a note so the host knows what to change.",
+        };
+      }
+      return { ok: true };
+    }
+    if (!decisionNote && lineNotes.length === 0) {
+      return {
+        ok: false,
+        error: "Add an overall note or a note on at least one line.",
+      };
+    }
+    return { ok: true };
+  }
+
+  return { ok: true };
+}
+
+export function resolveApproverDisplayName(params: {
+  decidedName?: string | null;
+  hostHintName?: string | null;
+  email: string;
+}): string {
+  const decided = params.decidedName?.trim();
+  if (decided) return decided;
+  const hint = params.hostHintName?.trim();
+  if (hint) return hint;
+  return params.email;
+}
+
+export function formatBudgetCents(cents: number): string {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+  }).format(cents / 100);
+}
+
+export function eventBudgetApprovalWizardPath(bashEventId: string): string {
+  return `/bash-event-wizard/${bashEventId}/${BASH_EVENT_WIZARD_HOW_MAJOR_STEP}/${BASH_EVENT_WIZARD_HOW_SUBSTEP.BUDGET}?budgetTab=lines`;
+}
+
+export type BudgetApprovalPublicDto = {
+  kind: BudgetApprovalKindName;
+  status: BudgetApprovalStatusName;
+  hostNote: string | null;
+  hostDisplayName: string;
+  event: {
+    id: string;
+    title: string;
+    startDateTime: string | null;
+    slug: string | null;
+  };
+  snapshotLines: BudgetApprovalSnapshotLine[];
+  snapshotTotalCents: number;
+  expiresAt: string;
+  expired: boolean;
+  alreadyDecided: boolean;
+  eventIsPubliclyViewable: boolean;
+};
+
+export type BudgetApprovalHostDto = {
+  id: string;
+  kind: BudgetApprovalKindName;
+  status: BudgetApprovalStatusName;
+  approverEmail: string;
+  approverName: string | null;
+  hostNote: string | null;
+  decisionNote: string | null;
+  authorizedCents: number | null;
+  snapshotTotalCents: number;
+  staleAt: string | null;
+  decidedAt: string | null;
+  expiresAt: string;
+  createdAt: string;
+  isExpired: boolean;
+  emailError?: boolean;
+  lineNotes: Array<{
+    budgetId: string | null;
+    nameSnapshot: string;
+    categorySnapshot: string | null;
+    allocatedCentsSnapshot: number;
+    note: string;
+  }>;
+};
+
+export type BudgetApprovalHostSummary = {
+  latest: BudgetApprovalHostDto | null;
+  history: BudgetApprovalHostDto[];
+  planMatchesSnapshot: boolean;
+  currentAuthorizedCents: number | null;
+};

package/src/crewSocialCopy.ts

@@ -0,0 +1,37 @@
+/**
+ * Privacy-safe social-proof lines for suggestions and reminders.
+ * Never name hidden attendees. Never use a follow-count when names are hidden.
+ */
+
+export type CrewGoingPerson = {
+  displayName: string;
+  attendanceVisible: boolean;
+};
+
+export type CrewSocialCopy = {
+  line: string | null;
+  named: boolean;
+};
+
+export function crewSocialProofCopy(
+  people: readonly CrewGoingPerson[]
+): CrewSocialCopy {
+  const visible = people.filter((p) => p.attendanceVisible && p.displayName.trim());
+  const hidden = people.filter((p) => !p.attendanceVisible);
+
+  if (visible.length >= 2) {
+    const a = visible[0].displayName.trim();
+    const b = visible[1].displayName.trim();
+    return { line: `${a} and ${b} are going`, named: true };
+  }
+  if (visible.length === 1) {
+    return { line: `${visible[0].displayName.trim()} is going`, named: true };
+  }
+  if (hidden.length > 0) {
+    return { line: "Your crew's on this one", named: false };
+  }
+  return { line: null, named: false };
+}
+
+export const CREW_GOING_RAIL_TITLE = "The crew's going";
+export const SCENE_PROMPT_COPY = "What's your scene?";

package/src/definitions.ts

@@ -675,6 +675,7 @@ export const HTTP_CODE_BAD_REQUEST = 400 as const;
 export const HTTP_CODE_UNAUTHORIZED = 401 as const;
 export const HTTP_CODE_FORBIDDEN = 403 as const;
 export const HTTP_CODE_NOT_FOUND = 404 as const;
+export const HTTP_CODE_GONE = 410 as const;
 export const ERR_UNAUTHORIZED_REQUEST =
   "Unauthorized to perform requested action. Have you logged in?" as const;
 export const ERR_SESSION_EXPIRED =
@@ -831,6 +832,11 @@ export type ApiServiceBookingParams = {
   bashEventId?: string;
   /** Booking-level bundled packages (e.g. "Gold DJ Package"), independent of hourly/daily rates. */
   packages?: ApiServicePackageParams[];
+  /**
+   * F&B per-guest bookings: host-entered guest count snapshotted at booking time.
+   * Saved to ServiceBooking.expectedAttendeesAtBooking. No promoter true-up.
+   */
+  foodAndBeverageHeadcount?: number;
 };
 
 export type ApiServiceCanBookParams = {} & ApiServiceBookingParams;
@@ -1817,6 +1823,11 @@ const SYNTHETIC_BASH_SECTION_TITLE: Record<string, string> = {
   Featured: "Featured",
   Popular: "Popular",
   Trending: "Trending",
+  CrewGoing: "The crew's going",
+  Local: "Local",
+  State: "Statewide",
+  National: "Across the country",
+  International: "Worth the flight",
 };
 
 /**