@bash-app/bash-common 30.391.0 → 30.396.0

package/src/suggestionScore.ts

@@ -0,0 +1,140 @@
+import { DiscoveryScope, isNationalOrInternational } from "./discoveryScope.js";
+import { UserTasteKind, UserTasteSource } from "./userTaste.js";
+
+export type SuggestionTasteRow = {
+  kind: string;
+  value: string;
+  weight: number;
+  source: string;
+};
+
+export type SuggestionSignals = {
+  connectionsGoingVisible: number;
+  connectionsGoingHidden: number;
+  followedHost: boolean;
+  attendedHost: boolean;
+  eventType: string;
+  causeTags: readonly string[];
+  musicGenre?: string | null;
+  discoveryScope: string;
+  artistsToSee: readonly string[];
+  eventTitle: string;
+  distanceMiles: number | null;
+  radiusMiles: number;
+  isFeatured: boolean;
+  trendingScore: number;
+  paidFeatureTasteOverlap: boolean;
+  tastes: readonly SuggestionTasteRow[];
+};
+
+export const SUGGESTION_WEIGHTS = {
+  connectionsGoing: 40,
+  followedHost: 24,
+  attendedHost: 20,
+  explicitTaste: 16,
+  explicitTasteLove: 32,
+  inferredTaste: 8,
+  travelScope: 10,
+  featured: 3,
+  trending: 2,
+  paidFeatureTaste: 1,
+  artistsToSee: 4,
+} as const;
+
+export const PAID_FEATURE_TASTE_CAP = SUGGESTION_WEIGHTS.paidFeatureTaste;
+
+export function scoreSuggestion(signals: SuggestionSignals): number {
+  let score = 0;
+  if (signals.connectionsGoingVisible + signals.connectionsGoingHidden > 0) {
+    score += SUGGESTION_WEIGHTS.connectionsGoing;
+  }
+  if (signals.followedHost) score += SUGGESTION_WEIGHTS.followedHost;
+  if (signals.attendedHost) score += SUGGESTION_WEIGHTS.attendedHost;
+
+  for (const taste of signals.tastes) {
+    if (taste.weight < 0) {
+      if (tasteMatchesEvent(taste, signals)) return Number.NEGATIVE_INFINITY;
+      continue;
+    }
+    if (!tasteMatchesEvent(taste, signals)) continue;
+    if (taste.kind === UserTasteKind.DiscoveryScope) {
+      score += SUGGESTION_WEIGHTS.travelScope;
+      continue;
+    }
+    if (taste.source === UserTasteSource.Explicit) {
+      score +=
+        taste.weight === 2
+          ? SUGGESTION_WEIGHTS.explicitTasteLove
+          : SUGGESTION_WEIGHTS.explicitTaste;
+    } else {
+      score += SUGGESTION_WEIGHTS.inferredTaste;
+    }
+  }
+
+  if (signals.isFeatured) score += SUGGESTION_WEIGHTS.featured;
+  if (signals.trendingScore > 0) score += SUGGESTION_WEIGHTS.trending;
+  if (signals.paidFeatureTasteOverlap) {
+    score += PAID_FEATURE_TASTE_CAP;
+  }
+  if (
+    signals.artistsToSee.some((a) =>
+      signals.eventTitle.toLowerCase().includes(a.toLowerCase())
+    )
+  ) {
+    score += SUGGESTION_WEIGHTS.artistsToSee;
+  }
+
+  const withinRadius = isWithinDiscoveryRadius(signals);
+  if (!withinRadius) return Number.NEGATIVE_INFINITY;
+
+  if (signals.distanceMiles != null && signals.radiusMiles > 0) {
+    const decay = Math.min(1, signals.distanceMiles / signals.radiusMiles);
+    score -= decay * 4;
+  }
+
+  return score;
+}
+
+export function isWithinDiscoveryRadius(signals: SuggestionSignals): boolean {
+  const travel = signals.tastes.some(
+    (t) =>
+      t.kind === UserTasteKind.DiscoveryScope &&
+      isNationalOrInternational(t.value as DiscoveryScope) &&
+      t.weight > 0
+  );
+  if (
+    travel &&
+    isNationalOrInternational(signals.discoveryScope as DiscoveryScope)
+  ) {
+    return true;
+  }
+  if (signals.distanceMiles == null) return true;
+  return signals.distanceMiles <= signals.radiusMiles;
+}
+
+function tasteMatchesEvent(
+  taste: SuggestionTasteRow,
+  signals: SuggestionSignals
+): boolean {
+  switch (taste.kind) {
+    case UserTasteKind.EventType:
+      return signals.eventType === taste.value;
+    case UserTasteKind.CauseTag:
+      return signals.causeTags.includes(taste.value);
+    case UserTasteKind.MusicGenre:
+      return (signals.musicGenre ?? "") === taste.value;
+    case UserTasteKind.DiscoveryScope:
+      return signals.discoveryScope === taste.value;
+    default:
+      return false;
+  }
+}
+
+export function crewOutranksPaid(signals: SuggestionSignals): boolean {
+  const crew =
+    signals.connectionsGoingVisible +
+    signals.connectionsGoingHidden +
+    (signals.followedHost ? 1 : 0) +
+    (signals.attendedHost ? 1 : 0);
+  return crew > 0;
+}

package/src/userTaste.ts

@@ -0,0 +1,152 @@
+import { BashEventType } from "@prisma/client";
+
+import { isCauseTagId } from "./causeTags.js";
+import {
+  DiscoveryScope,
+  DISCOVERY_SCOPE_VALUES,
+  isDiscoveryScope,
+} from "./discoveryScope.js";
+
+export const UserTasteKind = {
+  EventType: "EventType",
+  CauseTag: "CauseTag",
+  MusicGenre: "MusicGenre",
+  DiscoveryScope: "DiscoveryScope",
+} as const;
+
+export type UserTasteKind =
+  (typeof UserTasteKind)[keyof typeof UserTasteKind];
+
+export const UserTasteSource = {
+  Explicit: "Explicit",
+  Inferred: "Inferred",
+} as const;
+
+export type UserTasteSource =
+  (typeof UserTasteSource)[keyof typeof UserTasteSource];
+
+const BASH_EVENT_TYPE_VALUES = new Set(
+  Object.values(BashEventType) as string[]
+);
+
+/** Mirrors Prisma MusicGenreType — kept local so validation works without extra imports. */
+export const MUSIC_GENRE_TASTE_VALUES = [
+  "EDM",
+  "Electronic",
+  "House",
+  "Techno",
+  "Dubstep",
+  "Trance",
+  "Pop",
+  "Rock",
+  "HipHop",
+  "Country",
+  "RnB",
+  "Jazz",
+  "Blues",
+  "Indie",
+  "Alternative",
+  "Folk",
+  "Acoustic",
+  "Classical",
+  "Opera",
+  "World",
+  "Latin",
+  "Experimental",
+  "Fusion",
+  "Other",
+] as const;
+
+export type MusicGenreTasteValue = (typeof MUSIC_GENRE_TASTE_VALUES)[number];
+
+const MUSIC_GENRE_SET = new Set<string>(MUSIC_GENRE_TASTE_VALUES);
+
+const CIVIC_EVENT_TYPES = new Set(["ChurchEvent", "SchoolEvent"]);
+
+export function isUserTasteKind(value: unknown): value is UserTasteKind {
+  return (
+    value === UserTasteKind.EventType ||
+    value === UserTasteKind.CauseTag ||
+    value === UserTasteKind.MusicGenre ||
+    value === UserTasteKind.DiscoveryScope
+  );
+}
+
+export function isValidTasteValue(kind: UserTasteKind, value: string): boolean {
+  if (!value.trim()) return false;
+  switch (kind) {
+    case UserTasteKind.EventType:
+      return BASH_EVENT_TYPE_VALUES.has(value);
+    case UserTasteKind.CauseTag:
+      return isCauseTagId(value);
+    case UserTasteKind.MusicGenre:
+      return MUSIC_GENRE_SET.has(value);
+    case UserTasteKind.DiscoveryScope:
+      return (
+        isDiscoveryScope(value) &&
+        value !== DiscoveryScope.Unspecified &&
+        (DISCOVERY_SCOPE_VALUES as readonly string[]).includes(value)
+      );
+    default:
+      return false;
+  }
+}
+
+export function isCivicEventType(eventType: string): boolean {
+  return CIVIC_EVENT_TYPES.has(eventType);
+}
+
+export type SceneTasteChip = {
+  id: string;
+  label: string;
+  kind: UserTasteKind;
+  value: string;
+};
+
+/** First-screen chips — no Networking. */
+export const SCENE_TASTE_CHIPS: readonly SceneTasteChip[] = [
+  { id: "festival", label: "Festivals", kind: UserTasteKind.EventType, value: "Festival" },
+  { id: "concert", label: "Concerts", kind: UserTasteKind.EventType, value: "Concert" },
+  { id: "comedy", label: "Comedy", kind: UserTasteKind.EventType, value: "ComedyShow" },
+  { id: "rave", label: "Raves / nightlife", kind: UserTasteKind.EventType, value: "Rave" },
+  { id: "fair", label: "Fairs", kind: UserTasteKind.EventType, value: "Fair" },
+  { id: "sports", label: "Sports", kind: UserTasteKind.EventType, value: "SportsWatchParty" },
+  { id: "pride", label: "Drag / Pride", kind: UserTasteKind.CauseTag, value: "lgbtq" },
+  { id: "arts", label: "Arts & culture", kind: UserTasteKind.CauseTag, value: "arts_culture" },
+  { id: "food", label: "Food", kind: UserTasteKind.EventType, value: "FestivalFood" },
+  { id: "outdoor", label: "Outdoor", kind: UserTasteKind.EventType, value: "OutdoorActivity" },
+];
+
+export const TRAVEL_TASTE_CHIP: SceneTasteChip = {
+  id: "travel",
+  label: "I'll travel for the right night",
+  kind: UserTasteKind.DiscoveryScope,
+  value: DiscoveryScope.National,
+};
+
+export const TRAVEL_TASTE_VALUES: readonly string[] = [
+  DiscoveryScope.National,
+  DiscoveryScope.International,
+];
+
+export type TastePreferenceInput = {
+  kind: UserTasteKind;
+  value: string;
+  weight?: number;
+  source?: UserTasteSource;
+};
+
+export function normalizeTasteWeight(weight: number | undefined): number {
+  if (weight === 2 || weight === -1 || weight === 1) return weight;
+  return 1;
+}
+
+export function userHasTravelTaste(
+  rows: ReadonlyArray<{ kind: string; value: string }>
+): boolean {
+  return rows.some(
+    (r) =>
+      r.kind === UserTasteKind.DiscoveryScope &&
+      TRAVEL_TASTE_VALUES.includes(r.value)
+  );
+}

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

@@ -1,4 +1,7 @@
+import { SUGGESTION_WEIGHTS } from "../../suggestionScore.js";
 import {
+  applyFeaturedTasteMultiplier,
+  FEATURED_TASTE_MATCH_SCORE,
   haversineMiles,
   effectiveFeaturedForGeoScope,
   sortPublicEventsForFeaturedDiscovery,
@@ -118,3 +121,13 @@ describe("sortPublicEventsForFeaturedDiscovery", () => {
     ]);
   });
 });
+
+describe("applyFeaturedTasteMultiplier", () => {
+  it("stays smaller than crew-going weights", () => {
+    expect(applyFeaturedTasteMultiplier(10, false)).toBe(10);
+    expect(applyFeaturedTasteMultiplier(10, true)).toBe(10.5);
+    expect(FEATURED_TASTE_MATCH_SCORE).toBeLessThan(
+      SUGGESTION_WEIGHTS.connectionsGoing
+    );
+  });
+});

package/src/utils/featuredDiscoveryGeo.ts

@@ -73,3 +73,18 @@ export function sortPublicEventsForFeaturedDiscovery<
   });
   return withKeys.map((x) => x.e);
 }
+
+/**
+ * Paid featuring × taste overlap. Must stay smaller than any crew-going
+ * boost (`SUGGESTION_WEIGHTS.connectionsGoing` / followed / attended host).
+ */
+export const FEATURED_TASTE_MATCH_MULTIPLIER = 1.05;
+export const FEATURED_TASTE_MATCH_SCORE = 1;
+
+export function applyFeaturedTasteMultiplier(
+  featuredScore: number,
+  tasteOverlaps: boolean
+): number {
+  if (!tasteOverlaps) return featuredScore;
+  return featuredScore * FEATURED_TASTE_MATCH_MULTIPLIER;
+}