@bash-app/bash-common 30.260.0 → 30.262.0

package/src/utils/service/serviceBookingExposureUtils.ts

@@ -19,7 +19,7 @@
 import {
   DEFAULT_MAX_BILLABLE_MULTIPLIER,
   isFlatPricingModel,
-} from "./billingCapUtils";
+} from "./billingCapUtils.js";
 
 /**
  * Pricing-model strings recognized by the exposure util. Stays a string

package/src/utils/ticketTierSchedule.ts

@@ -0,0 +1,387 @@
+/**
+ * Ticket tier release / expiry / sold-out schedule resolver — shared by API + bash-app.
+ */
+
+import type { TicketTierAvailability } from "../definitions.js";
+
+export type PreReleaseDisplay = "Tease" | "Hidden";
+
+export type PresaleAudience = "Public" | "Ambashador" | "BashInsider" | "Promoters";
+
+export type TicketTierSchedulePhase =
+  | "HostHidden"
+  | "HiddenPreRelease"
+  | "TeasePreRelease"
+  | "Live"
+  | "Expired"
+  | "SoldOut";
+
+export type TicketTierScheduleInput = {
+  availabilityType?: string | null;
+  availableAt?: Date | string | null;
+  expiresAt?: Date | string | null;
+  preReleaseDisplay?: string | null;
+  hidden?: boolean | null;
+  isManuallySoldOut?: boolean | null;
+  isWaitlistTier?: boolean | null;
+  availabilityTypeUnlock?: string | null;
+  availableWhenInterestReached?: number | null;
+  unlockWhenTicketsSold?: number | null;
+  presaleAudience?: string | null;
+  publicAvailableAt?: Date | string | null;
+};
+
+export type TicketTierScheduleContext = {
+  now?: Date;
+  availableInventory?: number;
+  ideaInterestCount?: number;
+  ticketsSoldCount?: number;
+  isViewerEngaged?: boolean;
+  isViewerAmbashador?: boolean;
+  isViewerBashInsider?: boolean;
+  isViewerPromoterForEvent?: boolean;
+};
+
+export type TicketTierScheduleState = {
+  phase: TicketTierSchedulePhase;
+  availableAt: string | null;
+  expiresAt: string | null;
+  canPurchase: boolean;
+  soldOut: boolean;
+  showWaitlistCta: boolean;
+  guestVisible: boolean;
+  availability: TicketTierAvailability;
+  hostPreviewLabel: string;
+};
+
+export type ScheduleValidationIssue = {
+  field: string;
+  message: string;
+  severity: "error" | "warn";
+};
+
+function toDate(value: Date | string | null | undefined): Date | null {
+  if (value == null) return null;
+  const d = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+function toIso(value: Date | string | null | undefined): string | null {
+  const d = toDate(value);
+  return d ? d.toISOString() : null;
+}
+
+function normalizePreReleaseDisplay(value: string | null | undefined): PreReleaseDisplay {
+  return value === "Hidden" ? "Hidden" : "Tease";
+}
+
+function isOnDate(type: string | null | undefined): boolean {
+  return type === "OnDate";
+}
+
+function isPresaleAudienceEligible(
+  audience: string | null | undefined,
+  ctx: TicketTierScheduleContext
+): boolean {
+  switch (audience) {
+    case "Ambashador":
+      return ctx.isViewerAmbashador === true;
+    case "BashInsider":
+      return ctx.isViewerBashInsider === true;
+    case "Promoters":
+      return ctx.isViewerPromoterForEvent === true;
+    default:
+      return true;
+  }
+}
+
+function resolveUnlockAvailability(
+  tier: TicketTierScheduleInput,
+  ctx: TicketTierScheduleContext
+): TicketTierAvailability | null {
+  const type = tier.availabilityType ?? "Immediate";
+  if (type === "UnlockWhenInterestReached") {
+    const threshold = tier.availableWhenInterestReached ?? 0;
+    const count = ctx.ideaInterestCount ?? 0;
+    const available = count >= threshold;
+    return {
+      available,
+      reason: "UnlockWhenInterestReached",
+      interestCount: count,
+      interestThreshold: threshold,
+    };
+  }
+  if (type === "UnlockWhenTicketsSold") {
+    const threshold = tier.unlockWhenTicketsSold ?? 0;
+    const count = ctx.ticketsSoldCount ?? 0;
+    const available = count >= threshold;
+    return {
+      available,
+      reason: "UnlockWhenTicketsSold",
+      ticketsSoldCount: count,
+      ticketsSoldThreshold: threshold,
+    };
+  }
+  return null;
+}
+
+/**
+ * Resolve guest-visible phase and purchase eligibility for a ticket tier.
+ */
+export function resolveTicketTierScheduleState(
+  tier: TicketTierScheduleInput,
+  ctx: TicketTierScheduleContext = {}
+): TicketTierScheduleState {
+  const now = ctx.now ?? new Date();
+  const availableAt = toDate(tier.availableAt);
+  const expiresAt = toDate(tier.expiresAt);
+  const publicAvailableAt = toDate(tier.publicAvailableAt);
+  const inventory = ctx.availableInventory;
+  const manualSoldOut = tier.isManuallySoldOut === true;
+  /** Only treat as inventory sold-out when callers supply a count — unknown ≠ zero. */
+  const soldOut =
+    manualSoldOut || (inventory !== undefined && inventory <= 0);
+  const preDisplay = normalizePreReleaseDisplay(tier.preReleaseDisplay);
+  const type = tier.availabilityType ?? "Immediate";
+
+  if (tier.hidden) {
+    return buildState({
+      phase: "HostHidden",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: { available: false },
+      hostPreviewLabel: "Hidden by host",
+    });
+  }
+
+  if (expiresAt && now >= expiresAt) {
+    return buildState({
+      phase: "Expired",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: { available: false },
+      hostPreviewLabel: "Expired",
+    });
+  }
+
+  const unlockAvail = resolveUnlockAvailability(tier, ctx);
+  if (unlockAvail && !unlockAvail.available) {
+    return buildState({
+      phase: type === "OnDate" && availableAt && now < availableAt
+        ? preDisplay === "Hidden" ? "HiddenPreRelease" : "TeasePreRelease"
+        : "TeasePreRelease",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: unlockAvail,
+      hostPreviewLabel: "Unlock pending",
+    });
+  }
+
+  if (isOnDate(type) && availableAt && now < availableAt) {
+    const phase: TicketTierSchedulePhase =
+      preDisplay === "Hidden" ? "HiddenPreRelease" : "TeasePreRelease";
+    return buildState({
+      phase,
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: {
+        available: false,
+        reason: "OnDate",
+        availableAt: availableAt.toISOString(),
+      },
+      hostPreviewLabel: phase === "HiddenPreRelease" ? "Hidden until release" : "Tease + countdown",
+    });
+  }
+
+  const presaleAudience = tier.presaleAudience ?? "Public";
+  if (presaleAudience !== "Public") {
+    const publicOpensAt = publicAvailableAt ?? availableAt;
+    const presaleOpen = !availableAt || now >= availableAt;
+    const publicOpen = !publicOpensAt || now >= publicOpensAt;
+    const eligible = isPresaleAudienceEligible(presaleAudience, ctx);
+    if (!publicOpen && (!presaleOpen || !eligible)) {
+      return buildState({
+        phase: presaleOpen && !publicOpen ? "TeasePreRelease" : "HiddenPreRelease",
+        availableAt: publicOpensAt ?? availableAt,
+        expiresAt,
+        canPurchase: false,
+        soldOut,
+        isWaitlistTier: tier.isWaitlistTier,
+        availability: {
+          available: false,
+          reason: "OnDate",
+          availableAt: (publicOpensAt ?? availableAt)?.toISOString(),
+        },
+        hostPreviewLabel: `${presaleAudience} presale`,
+      });
+    }
+    if (presaleOpen && !publicOpen && !eligible) {
+      return buildState({
+        phase: "TeasePreRelease",
+        availableAt: publicOpensAt,
+        expiresAt,
+        canPurchase: false,
+        soldOut,
+        isWaitlistTier: tier.isWaitlistTier,
+        availability: {
+          available: false,
+          reason: "OnDate",
+          availableAt: publicOpensAt?.toISOString(),
+        },
+        hostPreviewLabel: "Public sale scheduled",
+      });
+    }
+  }
+
+  if (type === "EngagedUsersOnly" && ctx.isViewerEngaged === false) {
+    return buildState({
+      phase: soldOut ? "SoldOut" : "Live",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: {
+        available: false,
+        reason: "EngagedUsersOnly",
+        isViewerEngaged: false,
+      },
+      hostPreviewLabel: soldOut ? "Sold out" : "RSVP required",
+    });
+  }
+
+  if (soldOut) {
+    return buildState({
+      phase: "SoldOut",
+      availableAt,
+      expiresAt,
+      canPurchase: false,
+      soldOut: true,
+      isWaitlistTier: tier.isWaitlistTier,
+      availability: { available: false },
+      hostPreviewLabel: manualSoldOut ? "Sold out (manual)" : "Sold out",
+    });
+  }
+
+  const availability: TicketTierAvailability = unlockAvail ?? { available: true };
+  if (type === "EngagedUsersOnly") {
+    availability.reason = "EngagedUsersOnly";
+    availability.isViewerEngaged = ctx.isViewerEngaged;
+  }
+
+  return buildState({
+    phase: "Live",
+    availableAt,
+    expiresAt,
+    canPurchase: true,
+    soldOut: false,
+    isWaitlistTier: tier.isWaitlistTier,
+    availability,
+    hostPreviewLabel: "Live",
+  });
+}
+
+function buildState(args: {
+  phase: TicketTierSchedulePhase;
+  availableAt: Date | null;
+  expiresAt: Date | null;
+  canPurchase: boolean;
+  soldOut: boolean;
+  isWaitlistTier?: boolean | null;
+  availability: TicketTierAvailability;
+  hostPreviewLabel: string;
+}): TicketTierScheduleState {
+  const guestVisible =
+    args.phase !== "HostHidden" &&
+    args.phase !== "HiddenPreRelease" &&
+    args.phase !== "Expired";
+  return {
+    phase: args.phase,
+    availableAt: toIso(args.availableAt),
+    expiresAt: toIso(args.expiresAt),
+    canPurchase: args.canPurchase,
+    soldOut: args.soldOut,
+    showWaitlistCta: args.soldOut && args.isWaitlistTier === true,
+    guestVisible,
+    availability: args.availability,
+    hostPreviewLabel: args.hostPreviewLabel,
+  };
+}
+
+export function validateTicketTierScheduleInput(
+  tier: TicketTierScheduleInput,
+  bashEvent?: { startDateTime?: Date | string | null }
+): ScheduleValidationIssue[] {
+  const issues: ScheduleValidationIssue[] = [];
+  const type = tier.availabilityType ?? "Immediate";
+  const availableAt = toDate(tier.availableAt);
+  const expiresAt = toDate(tier.expiresAt);
+  const start = bashEvent ? toDate(bashEvent.startDateTime) : null;
+
+  if (isOnDate(type) && !availableAt) {
+    issues.push({
+      field: "availableAt",
+      message: "Release date and time are required when scheduling a tier.",
+      severity: "error",
+    });
+  }
+
+  if (availableAt && expiresAt && expiresAt <= availableAt) {
+    issues.push({
+      field: "expiresAt",
+      message: "Expires must be after the release time.",
+      severity: "error",
+    });
+  }
+
+  if (expiresAt && expiresAt <= new Date()) {
+    issues.push({
+      field: "expiresAt",
+      message: "Expires must be in the future.",
+      severity: "error",
+    });
+  }
+
+  if (start && availableAt && availableAt > start) {
+    issues.push({
+      field: "availableAt",
+      message: "Release is after the event start — double-check the time.",
+      severity: "warn",
+    });
+  }
+
+  if (start && expiresAt && expiresAt > start) {
+    issues.push({
+      field: "expiresAt",
+      message: "Tier expires after the event starts — unusual but allowed.",
+      severity: "warn",
+    });
+  }
+
+  return issues;
+}
+
+export function scheduleValidationHasErrors(issues: ScheduleValidationIssue[]): boolean {
+  return issues.some((i) => i.severity === "error");
+}
+
+/** Whether tier should appear on guest detail ticket list (incl. tease). */
+export function isTicketTierGuestListVisible(state: TicketTierScheduleState): boolean {
+  return (
+    state.guestVisible ||
+    state.phase === "TeasePreRelease" ||
+    state.phase === "SoldOut"
+  );
+}