@bash-app/bash-common 30.265.0 → 30.273.0

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,278 @@
+/**
+ * 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;
+}
+
+/** PaymentIntent.metadata shape written by createOrgPromoPaymentIntent. */
+export type OrgPromoPaymentIntentMetadata = {
+  type?: string;
+  organizationId?: string;
+  bashEventId?: string;
+  tierId?: string;
+  hostUserId?: string;
+  orgFeeCents?: string;
+  bashPlatformFeeCents?: string;
+};
+
+function parseMetadataInt(value: string | undefined): number | null {
+  if (value === undefined || value === "") return null;
+  const n = Number.parseInt(value, 10);
+  if (!Number.isInteger(n) || n < 0) return null;
+  return n;
+}
+
+/**
+ * Build package fee snapshot from an authorized PI (confirm-paid).
+ * Amount and metadata must match what was set at intent time.
+ */
+export function orgPromoPackageTermsFromPaymentIntent(
+  pi: { amount: number | null; metadata?: OrgPromoPaymentIntentMetadata | null },
+  expectedTierId: OrgPromotionalPackageTierId
+):
+  | { ok: true; terms: OrgPromotionalPackageTerms; totalCents: number }
+  | { ok: false; error: string } {
+  const m = pi.metadata ?? {};
+  if (m.type !== ORG_PROMO_PI_METADATA_TYPE) {
+    return { ok: false, error: "invalid_payment_type" };
+  }
+  if (!isOrgPromoTierId(m.tierId ?? "") || m.tierId !== expectedTierId) {
+    return { ok: false, error: "payment_tier_mismatch" };
+  }
+  const orgFeeCents = parseMetadataInt(m.orgFeeCents);
+  const bashPlatformFeeCents = parseMetadataInt(m.bashPlatformFeeCents);
+  if (orgFeeCents === null || bashPlatformFeeCents === null) {
+    return { ok: false, error: "invalid_payment_amounts" };
+  }
+  if (orgFeeCents > ORG_PROMO_MAX_ORG_FEE_CENTS) {
+    return { ok: false, error: "invalid_payment_amounts" };
+  }
+  const expectedPlatform = ORG_PROMO_PLATFORM_FEES_CENTS[expectedTierId];
+  if (bashPlatformFeeCents !== expectedPlatform) {
+    return { ok: false, error: "invalid_platform_fee" };
+  }
+  const totalCents = orgFeeCents + bashPlatformFeeCents;
+  if (totalCents < 50) {
+    return { ok: false, error: "invalid_payment_amounts" };
+  }
+  if (pi.amount !== null && pi.amount !== totalCents) {
+    return { ok: false, error: "payment_amount_mismatch" };
+  }
+  return {
+    ok: true,
+    totalCents,
+    terms: {
+      tierId: expectedTierId,
+      maxReach: ORG_PROMO_MAX_REACH[expectedTierId],
+      orgFeeCents,
+      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),
+    };
+  });
+}