@bash-app/bash-common 30.265.0 → 30.272.0

package/src/partnerStoreTypes.ts

@@ -1,4 +1,8 @@
-import type { PartnerTier } from "@prisma/client";
+import type {
+  LocalServiceCategory,
+  PartnerListingType,
+  PartnerTier,
+} from "@prisma/client";
 
 /** Product row returned by BashStore / wizard suggestion APIs (no internal counters). */
 export type PartnerProductPublic = {
@@ -28,9 +32,136 @@ export type PartnerStoreResponse = {
   brands: (PartnerBrandSummary & { products: PartnerProductPublic[] })[];
 };
 
-/** GET /api/partner/suggestions — at most one suggestion */
-export type PartnerSuggestionResponse = {
+export type LocalPartnerOfferPublic = {
+  id: string;
+  name: string;
+  description: string | null;
+  imageUrl: string | null;
+  affiliateUrl: string;
+  priceSummary: string | null;
+};
+
+export type LocalPartnerPublic = {
+  id: string;
+  name: string;
+  logoUrl: string | null;
+  websiteUrl: string | null;
+  description: string | null;
+  tier: PartnerTier;
+  address: string | null;
+  phone: string | null;
+  citySlug: string | null;
+  stateSlug: string | null;
+  serviceTimings: string[];
+  serviceCategory: LocalServiceCategory | null;
+  promoHeadline: string | null;
+  promoCode: string | null;
+  bookingUrl: string | null;
+  businessHours: unknown;
+  timezone: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  bashPointsCost: number | null;
+  distanceMiles: number | null;
+  offers: LocalPartnerOfferPublic[];
+};
+
+/** Gear wizard ad slot suggestion */
+export type PartnerGearSuggestion = {
+  kind: "gear";
   slotId: string;
   product: PartnerProductPublic;
   brand: PartnerBrandSummary;
 };
+
+/** Local service partner surfaced in wizard or feed contexts */
+export type PartnerLocalSuggestion = {
+  kind: "local";
+  partner: LocalPartnerPublic;
+};
+
+/** GET /api/partner/suggestions — at most one suggestion */
+export type PartnerSuggestionResponse = PartnerGearSuggestion | PartnerLocalSuggestion;
+
+export type ClaimPartnerPromoResponse = {
+  promoCode: string;
+  bashPointsCost: number;
+  balanceAfter: number;
+};
+
+/** GET /api/partner/local-services */
+export type LocalServiceListingResponse = {
+  featured: LocalPartnerPublic | null;
+  partners: LocalPartnerPublic[];
+};
+
+/** Display labels for LocalServiceCategory enum values. */
+export const LOCAL_SERVICE_CATEGORY_LABELS: Record<LocalServiceCategory, string> = {
+  GetReady: "Get Ready",
+  WearAndStyle: "Wear & Style",
+  EatAndDrink: "Eat & Drink",
+  Move: "Move",
+  Recover: "Recover",
+  Wellness: "Wellness",
+  HealthAndEssentials: "Health & Essentials",
+  HomeAndLife: "Home & Life",
+  ContentAndKeepsakes: "Content & Keepsakes",
+  HostShortcuts: "Host Shortcuts",
+  PerksAndRetail: "Perks & Retail",
+  Other: "Other",
+};
+
+/** Ordered list for filter chips in BashStore Local Partners tab. */
+export const LOCAL_SERVICE_CATEGORY_ORDER: LocalServiceCategory[] = [
+  "GetReady",
+  "WearAndStyle",
+  "EatAndDrink",
+  "Move",
+  "Recover",
+  "Wellness",
+  "HealthAndEssentials",
+  "HomeAndLife",
+  "ContentAndKeepsakes",
+  "HostShortcuts",
+  "PerksAndRetail",
+  "Other",
+];
+
+export const LOCAL_SERVICE_TIMING_OPTIONS = [
+  { value: "pre_event", label: "Pre-event" },
+  { value: "day_of", label: "Day-of" },
+  { value: "post_event", label: "Post-event" },
+] as const;
+
+export type LocalServiceTiming = (typeof LOCAL_SERVICE_TIMING_OPTIONS)[number]["value"];
+
+export const PARTNER_LISTING_TYPE_LABELS: Record<PartnerListingType, string> = {
+  Gear: "Gear",
+  LocalService: "Local Service",
+};
+
+/** Admin / inquiry payloads for BashStore partner listing requests. */
+export type PartnerInquiryRecord = {
+  id: string;
+  contactName: string;
+  email: string;
+  brandName: string;
+  website: string | null;
+  description: string;
+  categories: string[];
+  listingType: PartnerListingType;
+  city: string | null;
+  status: "Pending" | "Reviewed" | "Approved" | "Rejected";
+  adminNote: string | null;
+  createdBrandId: string | null;
+  createdAt: string;
+};
+
+/** GET /api/partner/inquiry-status */
+export type PartnerInquiryStatusResponse = {
+  brandName: string;
+  status: string;
+  listingLive: boolean;
+  storeUrl: string | null;
+  createdBrandId: string | null;
+};

package/src/requestAuthUser.ts

@@ -90,16 +90,18 @@ export function parseRequestAuthFromJwtPayload(decoded: unknown): RequestAuthUse
 export function userHasSuperUserAccess(
   auth: Pick<RequestAuthUser, "roles" | "isSuperUser">,
 ): boolean {
-  return auth.isSuperUser === true || auth.roles.includes(UserRole.SuperUser);
+  const roles = auth.roles ?? [];
+  return auth.isSuperUser === true || roles.includes(UserRole.SuperUser);
 }
 
 /** Admin or SuperUser role, or legacy `isSuperUser` flag. */
 export function userHasAdminAccess(
   auth: Pick<RequestAuthUser, "roles" | "isSuperUser">,
 ): boolean {
+  const roles = auth.roles ?? [];
   return (
     auth.isSuperUser === true ||
-    auth.roles.includes(UserRole.SuperUser) ||
-    auth.roles.includes(UserRole.Admin)
+    roles.includes(UserRole.SuperUser) ||
+    roles.includes(UserRole.Admin)
   );
 }

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

@@ -0,0 +1,17 @@
+import { resolveEventCitySlug, resolveEventStateSlug } from "../eventCitySlug.js";
+
+describe("eventCitySlug", () => {
+  it("resolveEventCitySlug slugifies city names", () => {
+    expect(resolveEventCitySlug({ city: "New York City", state: "NY" })).toBe(
+      "new-york-city"
+    );
+    expect(resolveEventCitySlug({ city: "  ", state: "NY" })).toBeNull();
+  });
+
+  it("resolveEventStateSlug normalizes two-letter states", () => {
+    expect(resolveEventStateSlug({ city: "Brooklyn", state: "NY" })).toBe("ny");
+    expect(resolveEventStateSlug({ city: "LA", state: "California" })).toBe(
+      "california"
+    );
+  });
+});

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

@@ -0,0 +1,45 @@
+import {
+  isLocalPartnerOpenNow,
+  type LocalPartnerHoursConfig,
+} from "../localPartnerHours.js";
+
+describe("isLocalPartnerOpenNow", () => {
+  const sampleHours: LocalPartnerHoursConfig = {
+    openDays: {
+      Monday: true,
+      Tuesday: true,
+      Wednesday: true,
+      Thursday: true,
+      Friday: true,
+      Saturday: false,
+      Sunday: false,
+    },
+    hours: {
+      Monday: [{ open: "09:00", close: "17:00" }],
+      Tuesday: [{ open: "09:00", close: "17:00" }],
+      Wednesday: [{ open: "09:00", close: "17:00" }],
+      Thursday: [{ open: "09:00", close: "17:00" }],
+      Friday: [{ open: "09:00", close: "17:00" }],
+      Saturday: [{ open: "", close: "" }],
+      Sunday: [{ open: "", close: "" }],
+    },
+  };
+
+  it("returns null when hours are missing", () => {
+    expect(isLocalPartnerOpenNow(null, "America/New_York")).toBeNull();
+  });
+
+  it("returns true during configured weekday hours", () => {
+    const mondayMorning = new Date("2026-05-25T15:00:00.000Z");
+    expect(
+      isLocalPartnerOpenNow(sampleHours, "America/New_York", mondayMorning)
+    ).toBe(true);
+  });
+
+  it("returns false outside configured hours", () => {
+    const mondayNight = new Date("2026-05-26T03:00:00.000Z");
+    expect(
+      isLocalPartnerOpenNow(sampleHours, "America/New_York", mondayNight)
+    ).toBe(false);
+  });
+});

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

@@ -0,0 +1,73 @@
+import {
+  buildOrgPromoPackageTerms,
+  chunkArray,
+  isBashEventEligibleForOrgPromo,
+  orgPromoPackageTotalCents,
+  parseOrgPromotionalPackageRates,
+  selectMembersForOrgPromoReach,
+} from "../orgPromotionalPackageUtils.js";
+
+describe("orgPromotionalPackageUtils", () => {
+  it("parses valid rates", () => {
+    const rates = parseOrgPromotionalPackageRates({
+      community: { enabled: true, orgFeeCents: 5000 },
+    });
+    expect(rates?.community).toEqual({ enabled: true, orgFeeCents: 5000 });
+  });
+
+  it("rejects negative org fee", () => {
+    expect(
+      parseOrgPromotionalPackageRates({
+        community: { enabled: true, orgFeeCents: -1 },
+      })
+    ).toBeNull();
+  });
+
+  it("builds package terms and total", () => {
+    const rates = { community: { enabled: true, orgFeeCents: 1000 } };
+    const terms = buildOrgPromoPackageTerms("community", rates);
+    expect(terms).not.toBeNull();
+    expect(orgPromoPackageTotalCents(terms!)).toBe(1000 + 300);
+  });
+
+  it("selectMembersForOrgPromoReach caps by joinedAt order", () => {
+    const members = [
+      { id: "b", joinedAt: new Date("2024-02-01") },
+      { id: "a", joinedAt: new Date("2024-01-01") },
+      { id: "c", joinedAt: new Date("2024-03-01") },
+    ];
+    const selected = selectMembersForOrgPromoReach(members, 2);
+    expect(selected.map((m) => m.id)).toEqual(["a", "b"]);
+  });
+
+  it("chunks arrays for FCM", () => {
+    expect(chunkArray([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it("rejects unpublished and org-only events", () => {
+    expect(isBashEventEligibleForOrgPromo({ status: "Draft" }).eligible).toBe(false);
+    const orgOnly = isBashEventEligibleForOrgPromo({
+      status: "Published",
+      isApproved: true,
+      startDateTime: new Date(),
+      requiresOrgMembership: true,
+      ticketTierCount: 1,
+    });
+    expect(orgOnly.eligible).toBe(false);
+    if (!orgOnly.eligible) {
+      expect(orgOnly.reason).toBe("event_org_only");
+    }
+  });
+
+  it("accepts published ticketed events", () => {
+    expect(
+      isBashEventEligibleForOrgPromo({
+        status: "Published",
+        isApproved: true,
+        startDateTime: new Date(Date.now() + 86400000),
+        endDateTime: new Date(Date.now() + 172800000),
+        ticketTierCount: 2,
+      }).eligible
+    ).toBe(true);
+  });
+});

package/src/utils/eventCitySlug.ts

@@ -0,0 +1,23 @@
+import { generateSlug } from "./slugUtils.js";
+
+export type EventCityContext = {
+  city?: string | null;
+  state?: string | null;
+};
+
+/**
+ * Derive a partner-store city slug from bash event location text.
+ * Matches admin `citySlug` conventions (kebab-case).
+ */
+export function resolveEventCitySlug(context: EventCityContext): string | null {
+  const city = context.city?.trim();
+  if (!city) return null;
+  return generateSlug(city);
+}
+
+export function resolveEventStateSlug(context: EventCityContext): string | null {
+  const state = context.state?.trim();
+  if (!state) return null;
+  if (state.length === 2) return state.toLowerCase();
+  return generateSlug(state);
+}

package/src/utils/localPartnerHours.ts

@@ -0,0 +1,98 @@
+/** Weekly hours shape aligned with service profile hours config. */
+export type LocalPartnerHoursConfig = {
+  hours: Record<string, { open: string; close: string }[]>;
+  openDays: Record<string, boolean>;
+};
+
+const WEEKDAYS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+] as const;
+
+function parseMinutes(value: string): number | null {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const match = /^(\d{1,2}):(\d{2})$/.exec(trimmed);
+  if (!match) return null;
+  const hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  if (hours > 23 || minutes > 59) return null;
+  return hours * 60 + minutes;
+}
+
+function parseHoursConfig(raw: unknown): LocalPartnerHoursConfig | null {
+  if (!raw || typeof raw !== "object") return null;
+  const config = raw as Partial<LocalPartnerHoursConfig>;
+  if (!config.hours || typeof config.hours !== "object") return null;
+  if (!config.openDays || typeof config.openDays !== "object") return null;
+  return {
+    hours: config.hours,
+    openDays: config.openDays,
+  };
+}
+
+function getZonedWeekdayAndMinutes(now: Date, timeZone: string): {
+  weekday: (typeof WEEKDAYS)[number];
+  minutes: number;
+} | null {
+  try {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      weekday: "long",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+    });
+    const parts = formatter.formatToParts(now);
+    const weekday = parts.find((p) => p.type === "weekday")?.value;
+    const hour = parts.find((p) => p.type === "hour")?.value;
+    const minute = parts.find((p) => p.type === "minute")?.value;
+    if (!weekday || hour == null || minute == null) return null;
+    if (!WEEKDAYS.includes(weekday as (typeof WEEKDAYS)[number])) return null;
+    return {
+      weekday: weekday as (typeof WEEKDAYS)[number],
+      minutes: Number(hour) * 60 + Number(minute),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Returns null when hours are not configured; true/false when they are. */
+export function isLocalPartnerOpenNow(
+  businessHours: unknown,
+  timezone: string | null | undefined,
+  now: Date = new Date()
+): boolean | null {
+  const config = parseHoursConfig(businessHours);
+  if (!config) return null;
+
+  const tz = timezone?.trim() || "America/New_York";
+  const zoned = getZonedWeekdayAndMinutes(now, tz);
+  if (!zoned) return null;
+
+  if (config.openDays[zoned.weekday] === false) return false;
+
+  const slots = config.hours[zoned.weekday] ?? [];
+  for (const slot of slots) {
+    const open = parseMinutes(slot.open);
+    const close = parseMinutes(slot.close);
+    if (open == null || close == null) continue;
+    if (close > open) {
+      if (zoned.minutes >= open && zoned.minutes < close) return true;
+    } else if (zoned.minutes >= open || zoned.minutes < close) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function localPartnerHasBusinessHours(businessHours: unknown): boolean {
+  return parseHoursConfig(businessHours) != null;
+}

package/src/utils/orgPromotionalPackageUtils.ts

@@ -0,0 +1,212 @@
+/**
+ * Org Promotional Packages — hosts pay orgs to endorse events to org members.
+ */
+
+export type OrgPromotionalPackageTierId = "community" | "spotlight" | "featured";
+
+export type OrgPromoIneligibleReason =
+  | "event_not_published"
+  | "event_ended"
+  | "event_cancelled"
+  | "event_org_only"
+  | "event_not_ticketable"
+  | "event_missing_dates";
+
+export interface OrgPromotionalPackageTerms {
+  tierId: OrgPromotionalPackageTierId;
+  maxReach: number;
+  orgFeeCents: number;
+  bashPlatformFeeCents: number;
+}
+
+export interface OrgPromotionalPackageRates {
+  community?: { enabled: boolean; orgFeeCents: number };
+  spotlight?: { enabled: boolean; orgFeeCents: number };
+  featured?: { enabled: boolean; orgFeeCents: number };
+}
+
+export const ORG_PROMO_PLATFORM_FEES_CENTS: Record<OrgPromotionalPackageTierId, number> = {
+  community: 300,
+  spotlight: 700,
+  featured: 1500,
+};
+
+/** Runtime cap; featured uses MAX_REACH_UNLIMITED_SNAPSHOT in DB. */
+export const ORG_PROMO_MAX_REACH: Record<OrgPromotionalPackageTierId, number> = {
+  community: 500,
+  spotlight: 2000,
+  featured: Number.POSITIVE_INFINITY,
+};
+
+/** Stored on OrgPromotionalPackage.maxReach when tier is featured. */
+export const ORG_PROMO_MAX_REACH_UNLIMITED_SNAPSHOT = 2_147_483_647;
+
+export const ORG_PROMO_MAX_ORG_FEE_CENTS = 500_000;
+export const ORG_PROMO_HOST_NOTE_MAX_LENGTH = 500;
+export const ORG_PROMO_OPEN_STATUSES = ["PENDING_APPROVAL", "ACTIVE"] as const;
+
+export const ORG_PROMO_TIER_IDS: OrgPromotionalPackageTierId[] = [
+  "community",
+  "spotlight",
+  "featured",
+];
+
+export const ORG_PROMO_PI_METADATA_TYPE = "org_promotional_package";
+
+export const FCM_MULTICAST_MAX_TOKENS = 500;
+
+export function orgPromoMaxReachForSnapshot(tierId: OrgPromotionalPackageTierId): number {
+  const reach = ORG_PROMO_MAX_REACH[tierId];
+  if (reach === Number.POSITIVE_INFINITY) {
+    return ORG_PROMO_MAX_REACH_UNLIMITED_SNAPSHOT;
+  }
+  return reach;
+}
+
+export function isOrgPromoTierId(value: string): value is OrgPromotionalPackageTierId {
+  return ORG_PROMO_TIER_IDS.includes(value as OrgPromotionalPackageTierId);
+}
+
+export function parseOrgPromotionalPackageRates(raw: unknown): OrgPromotionalPackageRates | null {
+  if (!raw || typeof raw !== "object") return null;
+  const out: OrgPromotionalPackageRates = {};
+  for (const tierId of ORG_PROMO_TIER_IDS) {
+    const entry = (raw as Record<string, unknown>)[tierId];
+    if (entry === undefined) continue;
+    if (!entry || typeof entry !== "object") return null;
+    const e = entry as Record<string, unknown>;
+    if (typeof e.enabled !== "boolean") return null;
+    if (typeof e.orgFeeCents !== "number" || !Number.isInteger(e.orgFeeCents)) return null;
+    if (e.orgFeeCents < 0 || e.orgFeeCents > ORG_PROMO_MAX_ORG_FEE_CENTS) return null;
+    out[tierId] = { enabled: e.enabled, orgFeeCents: e.orgFeeCents };
+  }
+  return out;
+}
+
+export function orgHasEnabledPromoTier(rates: OrgPromotionalPackageRates | null): boolean {
+  if (!rates) return false;
+  return ORG_PROMO_TIER_IDS.some((t) => rates[t]?.enabled === true);
+}
+
+export function assertOrgPromoRatesAllowEnable(
+  rates: OrgPromotionalPackageRates,
+  stripeConnectedAccountId: string | null
+): { ok: true } | { error: "org_connect_required" } {
+  if (!orgHasEnabledPromoTier(rates)) return { ok: true };
+  if (!stripeConnectedAccountId) return { error: "org_connect_required" };
+  return { ok: true };
+}
+
+export function buildOrgPromoPackageTerms(
+  tierId: OrgPromotionalPackageTierId,
+  rates: OrgPromotionalPackageRates
+): OrgPromotionalPackageTerms | null {
+  const tierRate = rates[tierId];
+  if (!tierRate?.enabled) return null;
+  return {
+    tierId,
+    maxReach: ORG_PROMO_MAX_REACH[tierId],
+    orgFeeCents: tierRate.orgFeeCents,
+    bashPlatformFeeCents: ORG_PROMO_PLATFORM_FEES_CENTS[tierId],
+  };
+}
+
+export function orgPromoPackageTotalCents(terms: OrgPromotionalPackageTerms): number {
+  return terms.orgFeeCents + terms.bashPlatformFeeCents;
+}
+
+export function selectMembersForOrgPromoReach<T extends { joinedAt?: Date | string | null }>(
+  members: T[],
+  maxReach: number
+): T[] {
+  const sorted = [...members].sort((a, b) => {
+    const ta = a.joinedAt ? new Date(a.joinedAt).getTime() : 0;
+    const tb = b.joinedAt ? new Date(b.joinedAt).getTime() : 0;
+    return ta - tb;
+  });
+  if (maxReach === Number.POSITIVE_INFINITY || maxReach >= ORG_PROMO_MAX_REACH_UNLIMITED_SNAPSHOT) {
+    return sorted;
+  }
+  return sorted.slice(0, maxReach);
+}
+
+export function chunkArray<T>(items: T[], size: number): T[][] {
+  if (size <= 0) return [items];
+  const chunks: T[][] = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+
+export type BashEventOrgPromoEligibilityInput = {
+  status?: string | null;
+  isApproved?: boolean | null;
+  startDateTime?: Date | string | null;
+  endDateTime?: Date | string | null;
+  requiresOrgMembership?: boolean | null;
+  ticketTierCount?: number;
+  allowDonations?: boolean | null;
+};
+
+const TICKETABLE_STATUSES = new Set(["Published", "PreSale"]);
+
+export function isBashEventEligibleForOrgPromo(
+  event: BashEventOrgPromoEligibilityInput
+): { eligible: true } | { eligible: false; reason: OrgPromoIneligibleReason } {
+  const status = event.status ?? "Draft";
+  if (status === "Cancelled" || status === "Rejected" || status === "Archived") {
+    return { eligible: false, reason: "event_cancelled" };
+  }
+  if (!TICKETABLE_STATUSES.has(status)) {
+    return { eligible: false, reason: "event_not_published" };
+  }
+  if (event.isApproved === false) {
+    return { eligible: false, reason: "event_not_published" };
+  }
+  if (!event.startDateTime) {
+    return { eligible: false, reason: "event_missing_dates" };
+  }
+  if (event.endDateTime) {
+    const end = new Date(event.endDateTime);
+    if (end.getTime() < Date.now()) {
+      return { eligible: false, reason: "event_ended" };
+    }
+  }
+  if (event.requiresOrgMembership) {
+    return { eligible: false, reason: "event_org_only" };
+  }
+  const tierCount = event.ticketTierCount ?? 0;
+  if (tierCount === 0 && !event.allowDonations) {
+    return { eligible: false, reason: "event_not_ticketable" };
+  }
+  return { eligible: true };
+}
+
+export function formatOrgPromoRatesForHost(
+  rates: OrgPromotionalPackageRates | null,
+  connected: boolean
+): Array<{
+  tierId: OrgPromotionalPackageTierId;
+  enabled: boolean;
+  orgFeeCents: number;
+  platformFeeCents: number;
+  totalCents: number;
+  maxReach: number;
+}> {
+  const parsed = rates ?? {};
+  return ORG_PROMO_TIER_IDS.map((tierId) => {
+    const tier = parsed[tierId];
+    const enabled = Boolean(tier?.enabled && connected);
+    const orgFeeCents = tier?.orgFeeCents ?? 0;
+    const platformFeeCents = ORG_PROMO_PLATFORM_FEES_CENTS[tierId];
+    return {
+      tierId,
+      enabled,
+      orgFeeCents,
+      platformFeeCents,
+      totalCents: orgFeeCents + platformFeeCents,
+      maxReach: orgPromoMaxReachForSnapshot(tierId),
+    };
+  });
+}