@bash-app/bash-common 30.432.0 → 30.434.0

package/src/intros/validation.ts

@@ -0,0 +1,248 @@
+import {
+  attributeMayBeUsedInExperiments,
+  isIntrosAttributeKind,
+  validateAttributeValue,
+  type IntrosAttributeKind,
+} from "./attributeCatalog.js";
+import { isIntrosIntent, type IntrosIntent } from "./intents.js";
+
+export const WARM_INVITE_PREFS = ["Off", "Anonymous", "Named"] as const;
+export type WarmIntroInvitePref = (typeof WARM_INVITE_PREFS)[number];
+
+export const INTROS_EVENT_MODES = ["Off", "Platonic", "All"] as const;
+export type IntrosEventMode = (typeof INTROS_EVENT_MODES)[number];
+
+const GENDERS = ["women", "men", "nonbinary", "everyone"] as const;
+
+export type AttributePatch = {
+  value: unknown;
+  visibility: "OnlyMe" | "RevealedIntros";
+  allowExperimentalMatching: boolean;
+};
+
+export type ProfilePatch = {
+  shortIntro?: string | null;
+  conversationTopics?: string[];
+  professionalInterests?: string[];
+  travelRadiusMiles?: number | null;
+  intents?: IntrosIntent[];
+  warmIntroInvites?: WarmIntroInvitePref | null;
+  shareRegistrationStatus?: boolean;
+  revealOnlyAfterCheckIn?: boolean;
+  notifyIntros?: boolean;
+  warmSuggestionAudience?: "None" | "Connections" | "ConnectionsAndHosts";
+  romance?: { seekingGenders: string[]; ageMin: number; ageMax: number } | null;
+  attributes?: Partial<Record<IntrosAttributeKind, AttributePatch | null>>;
+  /** Unknown attribute keys sent as null, so a retired note can be removed. */
+  discardAttributes?: string[];
+  activate?: boolean;
+  globalMatching?: boolean;
+  romanceConsent?: boolean;
+  psychologyExperiment?: boolean;
+};
+
+export type ValidationOk<T> = { ok: true; value: T };
+export type ValidationErr = { ok: false; error: string };
+
+function cleanList(raw: unknown, label: string): ValidationOk<string[]> | ValidationErr {
+  if (!Array.isArray(raw)) return { ok: false, error: `${label} must be a list` };
+  if (raw.length > 10) return { ok: false, error: `${label} can have at most 10 items` };
+  const next: string[] = [];
+  for (const item of raw) {
+    if (typeof item !== "string") return { ok: false, error: `${label} must be text` };
+    const trimmed = item.trim().slice(0, 40);
+    if (trimmed) next.push(trimmed);
+  }
+  return { ok: true, value: next };
+}
+
+export function parseWarmIntroInvites(
+  raw: unknown
+): ValidationOk<WarmIntroInvitePref | null> | ValidationErr {
+  if (raw == null) return { ok: true, value: null };
+  if (typeof raw !== "string" || !(WARM_INVITE_PREFS as readonly string[]).includes(raw)) {
+    return { ok: false, error: "Choose Off, Anonymous, or Named" };
+  }
+  return { ok: true, value: raw as WarmIntroInvitePref };
+}
+
+export function parseIntrosEventMode(raw: unknown): ValidationOk<IntrosEventMode> | ValidationErr {
+  if (typeof raw !== "string" || !(INTROS_EVENT_MODES as readonly string[]).includes(raw)) {
+    return { ok: false, error: "Choose Off, Platonic, or All" };
+  }
+  return { ok: true, value: raw as IntrosEventMode };
+}
+
+export function parseProfilePatch(body: unknown): ValidationOk<ProfilePatch> | ValidationErr {
+  if (body == null || typeof body !== "object") {
+    return { ok: false, error: "Request body is required" };
+  }
+  const record = body as Record<string, unknown>;
+  const patch: ProfilePatch = {};
+
+  if ("shortIntro" in record) {
+    if (record.shortIntro == null) patch.shortIntro = null;
+    else if (typeof record.shortIntro !== "string") {
+      return { ok: false, error: "Introduction must be text" };
+    } else {
+      const text = record.shortIntro.replace(/https?:\/\/\S+/gi, "").trim();
+      if (text.length > 140) {
+        return { ok: false, error: "Introduction must be 140 characters or fewer" };
+      }
+      patch.shortIntro = text;
+    }
+  }
+  if ("conversationTopics" in record) {
+    const parsed = cleanList(record.conversationTopics, "Conversation topics");
+    if (!parsed.ok) return parsed;
+    patch.conversationTopics = parsed.value;
+  }
+  if ("professionalInterests" in record) {
+    const parsed = cleanList(record.professionalInterests, "Interests");
+    if (!parsed.ok) return parsed;
+    patch.professionalInterests = parsed.value;
+  }
+  if ("travelRadiusMiles" in record) {
+    if (record.travelRadiusMiles == null) patch.travelRadiusMiles = null;
+    else if (
+      typeof record.travelRadiusMiles !== "number" ||
+      record.travelRadiusMiles < 1 ||
+      record.travelRadiusMiles > 200
+    ) {
+      return { ok: false, error: "Travel distance must be between 1 and 200 miles" };
+    } else patch.travelRadiusMiles = Math.round(record.travelRadiusMiles);
+  }
+  if ("intents" in record) {
+    if (!Array.isArray(record.intents)) return { ok: false, error: "Intents must be a list" };
+    const intents: IntrosIntent[] = [];
+    for (const item of record.intents) {
+      if (typeof item !== "string" || !isIntrosIntent(item)) {
+        return { ok: false, error: "Unknown connection intention" };
+      }
+      if (!intents.includes(item)) intents.push(item);
+    }
+    patch.intents = intents;
+  }
+  if ("warmIntroInvites" in record) {
+    const parsed = parseWarmIntroInvites(record.warmIntroInvites);
+    if (!parsed.ok) return parsed;
+    patch.warmIntroInvites = parsed.value;
+  }
+  for (const key of [
+    "shareRegistrationStatus",
+    "revealOnlyAfterCheckIn",
+    "notifyIntros",
+    "activate",
+    "globalMatching",
+    "romanceConsent",
+    "psychologyExperiment",
+  ] as const) {
+    if (key in record) {
+      if (typeof record[key] !== "boolean") return { ok: false, error: `${key} must be on or off` };
+      patch[key] = record[key] as boolean;
+    }
+  }
+  if ("warmSuggestionAudience" in record) {
+    const value = record.warmSuggestionAudience;
+    if (value !== "None" && value !== "Connections" && value !== "ConnectionsAndHosts") {
+      return { ok: false, error: "Choose who may be asked to introduce you" };
+    }
+    patch.warmSuggestionAudience = value;
+  }
+  if ("romance" in record) {
+    if (record.romance == null) patch.romance = null;
+    else if (typeof record.romance !== "object") {
+      return { ok: false, error: "Romance preferences are invalid" };
+    } else {
+      const romance = record.romance as Record<string, unknown>;
+      const ageMin = romance.ageMin;
+      const ageMax = romance.ageMax;
+      if (
+        typeof ageMin !== "number" ||
+        typeof ageMax !== "number" ||
+        ageMin < 18 ||
+        ageMax > 99 ||
+        ageMin > ageMax
+      ) {
+        return { ok: false, error: "Romance ages must be between 18 and 99" };
+      }
+      if (!Array.isArray(romance.seekingGenders)) {
+        return { ok: false, error: "Choose who you want to meet" };
+      }
+      const seeking = romance.seekingGenders.filter((g): g is string => typeof g === "string");
+      if (seeking.some((g) => !(GENDERS as readonly string[]).includes(g))) {
+        return { ok: false, error: "Choose who you want to meet" };
+      }
+      patch.romance = { seekingGenders: seeking, ageMin, ageMax };
+    }
+  }
+  if (record.attributes != null && typeof record.attributes === "object") {
+    const attributes: NonNullable<ProfilePatch["attributes"]> = {};
+    for (const [key, raw] of Object.entries(record.attributes as Record<string, unknown>)) {
+      if (!isIntrosAttributeKind(key)) {
+        if (raw == null) {
+          patch.discardAttributes = [...(patch.discardAttributes ?? []), key];
+          continue;
+        }
+        return { ok: false, error: "Unknown profile attribute" };
+      }
+      if (raw == null) {
+        attributes[key] = null;
+        continue;
+      }
+      if (typeof raw !== "object") return { ok: false, error: "Attributes are invalid" };
+      const attr = raw as Record<string, unknown>;
+      const parsed = validateAttributeValue(key, attr.value);
+      if (!parsed.ok) return parsed;
+      if (attr.visibility !== "OnlyMe" && attr.visibility !== "RevealedIntros") {
+        return { ok: false, error: "Choose who can see this attribute" };
+      }
+      if (attr.allowExperimentalMatching === true && !attributeMayBeUsedInExperiments(key)) {
+        return { ok: false, error: "This attribute cannot be used for matching" };
+      }
+      attributes[key] = {
+        value: parsed.value,
+        visibility: attr.visibility,
+        allowExperimentalMatching: attr.allowExperimentalMatching === true,
+      };
+    }
+    patch.attributes = attributes;
+  }
+  return { ok: true, value: patch };
+}
+
+export function validateLegacyIntroPreference(key: string, value: unknown): string | null {
+  if (key === "introIntents") {
+    if (!Array.isArray(value)) return "Intro intents must be a list";
+    const allowed = new Set(["friends", "professional", "mentorship"]);
+    if (value.some((item) => typeof item !== "string" || !allowed.has(item))) {
+      return "Unknown intro intent";
+    }
+  }
+  if (key === "personalityType" && value != null) {
+    if (typeof value !== "string" || !/^[A-Za-z]{1,4}$/.test(value)) {
+      return "Personality type must be 1 to 4 letters";
+    }
+  }
+  if (
+    key === "locusOfControl" &&
+    value != null &&
+    value !== "internal" &&
+    value !== "external" &&
+    value !== "mixed"
+  ) {
+    return "Locus of control must be internal, external, or mixed";
+  }
+  if (key === "openToIntros" && typeof value !== "boolean") {
+    return "Open to intros must be on or off";
+  }
+  return null;
+}
+
+/** Warm invite names the other person only when both recipients chose Named. */
+export function warmInviteNamesOtherPerson(
+  a: WarmIntroInvitePref | null | undefined,
+  b: WarmIntroInvitePref | null | undefined
+): boolean {
+  return a === "Named" && b === "Named";
+}

package/src/mirroredPrismaEnums.ts

@@ -202,6 +202,7 @@ export const CreditSourceType = {
   CompetitionFinalist: "CompetitionFinalist",
   CompetitionWin: "CompetitionWin",
   HornClear: "HornClear",
+  IntrosEarlyReveal: "IntrosEarlyReveal",
 } as const satisfies Record<CreditSourceTypeEnum, CreditSourceTypeEnum>;
 
 export type CreditSourceType = CreditSourceTypeEnum;

package/src/promoCartEngine.ts

@@ -0,0 +1,193 @@
+/**
+ * Multi-tier promo engine (pure). Decides, per cart line, whether a code applies
+ * and how much cash and BashPoints it takes off, with a deterministic fixed-cash
+ * allocation that the API persists so refunds and reports reproduce exactly.
+ */
+import {
+  promoCodeAppliesToTier,
+  promoCodeDiscountKind,
+  type PromoDiscountKind,
+  type PromoScopeFields,
+} from "./promoCodeScope.js";
+
+export type PromoCartLinePricing = "USD" | "BASHPOINTS" | "FREE";
+
+export type PromoCartLine = {
+  ticketTierId: string;
+  pricing: PromoCartLinePricing;
+  quantity: number;
+  /** Cash subtotal for the line after special offers, in cents. */
+  cashSubtotalCents: number;
+  /** BashPoints subtotal for the line. */
+  pointsSubtotal: number;
+};
+
+export type PromoForCart = PromoScopeFields & {
+  discountAppliesToBashPoints?: boolean | null;
+  redeemBy?: Date | null;
+  disabledAt?: Date | null;
+};
+
+export type PromoCartLineResult = {
+  ticketTierId: string;
+  eligible: boolean;
+  cashDiscountCents: number;
+  pointsDiscount: number;
+  finalCashCents: number;
+  finalPoints: number;
+  attributedTicketCount: number;
+};
+
+export type PromoCartResult = {
+  status: "applied" | "not_applicable" | "expired" | "disabled";
+  discountKind: PromoDiscountKind;
+  lines: PromoCartLineResult[];
+  eligibleTierIds: string[];
+  cashDiscountTotalCents: number;
+  pointsDiscountTotal: number;
+  attributedTicketCount: number;
+};
+
+function clampPercent(value: number | null | undefined): number {
+  const pct = Math.floor(Number(value) || 0);
+  return Math.max(0, Math.min(100, pct));
+}
+
+/**
+ * Split `amount` across `weights` in proportion, flooring each share, then give
+ * leftover units one at a time to the largest weight first, ties by key ascending.
+ */
+export function allocateProportionally(
+  amount: number,
+  items: ReadonlyArray<{ key: string; weight: number }>
+): Map<string, number> {
+  const result = new Map<string, number>();
+  const total = items.reduce((s, i) => s + Math.max(0, i.weight), 0);
+  const whole = Math.max(0, Math.floor(amount));
+  if (total <= 0 || whole <= 0) {
+    for (const i of items) result.set(i.key, 0);
+    return result;
+  }
+  const capped = Math.min(whole, total);
+  let assigned = 0;
+  for (const i of items) {
+    const share = Math.floor((capped * Math.max(0, i.weight)) / total);
+    result.set(i.key, share);
+    assigned += share;
+  }
+  // Fractional parts sum to fewer units than there are lines, so one pass suffices.
+  let leftover = capped - assigned;
+  const order = [...items]
+    .filter((i) => i.weight > 0)
+    .sort((a, b) => b.weight - a.weight || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+  for (const i of order) {
+    if (leftover <= 0) break;
+    result.set(i.key, (result.get(i.key) ?? 0) + 1);
+    leftover--;
+  }
+  return result;
+}
+
+/** Per-ticket split of a line amount: equal shares, leftover cents to tickets in id order. */
+export function allocateAcrossTickets(
+  lineAmount: number,
+  ticketIds: readonly string[]
+): Map<string, number> {
+  const sorted = [...ticketIds].sort();
+  const result = new Map<string, number>();
+  const amount = Math.max(0, Math.floor(lineAmount));
+  if (sorted.length === 0) return result;
+  const base = Math.floor(amount / sorted.length);
+  let leftover = amount - base * sorted.length;
+  for (const id of sorted) {
+    result.set(id, base + (leftover > 0 ? 1 : 0));
+    if (leftover > 0) leftover--;
+  }
+  return result;
+}
+
+export function resolvePromoForCart(args: {
+  promo: PromoForCart;
+  cartLines: readonly PromoCartLine[];
+  now: Date;
+}): PromoCartResult {
+  const { promo, cartLines, now } = args;
+  const kind = promoCodeDiscountKind(promo);
+  const empty = (status: PromoCartResult["status"]): PromoCartResult => ({
+    status,
+    discountKind: kind,
+    lines: cartLines.map((l) => ({
+      ticketTierId: l.ticketTierId,
+      eligible: false,
+      cashDiscountCents: 0,
+      pointsDiscount: 0,
+      finalCashCents: Math.max(0, l.cashSubtotalCents),
+      finalPoints: Math.max(0, l.pointsSubtotal),
+      attributedTicketCount: 0,
+    })),
+    eligibleTierIds: [],
+    cashDiscountTotalCents: 0,
+    pointsDiscountTotal: 0,
+    attributedTicketCount: 0,
+  });
+  if (promo.disabledAt) return empty("disabled");
+  if (promo.redeemBy && promo.redeemBy.getTime() < now.getTime()) return empty("expired");
+
+  const eligibleSet = new Set(
+    cartLines.filter((l) => promoCodeAppliesToTier(promo, l.ticketTierId)).map((l) => l.ticketTierId)
+  );
+  if (eligibleSet.size === 0) return empty("not_applicable");
+
+  const pct = clampPercent(promo.discountAmountPercentage);
+  const fixed = Math.max(0, Math.floor(promo.discountAmountInCents ?? 0));
+  const pointsAllowed = promo.discountAppliesToBashPoints === true;
+
+  const fixedAllocation =
+    kind === "FIXED_CASH"
+      ? allocateProportionally(
+          fixed,
+          cartLines
+            .filter((l) => eligibleSet.has(l.ticketTierId) && l.pricing === "USD")
+            .map((l) => ({ key: l.ticketTierId, weight: Math.max(0, l.cashSubtotalCents) }))
+        )
+      : new Map<string, number>();
+
+  const lines = cartLines.map((l): PromoCartLineResult => {
+    const eligible = eligibleSet.has(l.ticketTierId);
+    const cash = Math.max(0, l.cashSubtotalCents);
+    const points = Math.max(0, l.pointsSubtotal);
+    let cashDiscount = 0;
+    let pointsDiscount = 0;
+    if (eligible) {
+      if (kind === "PERCENT") {
+        if (l.pricing === "USD") cashDiscount = Math.floor((cash * pct) / 100);
+        if (l.pricing === "BASHPOINTS" && pointsAllowed) {
+          pointsDiscount = Math.floor((points * pct) / 100);
+        }
+      } else if (kind === "FIXED_CASH" && l.pricing === "USD") {
+        cashDiscount = fixedAllocation.get(l.ticketTierId) ?? 0;
+      }
+    }
+    cashDiscount = Math.min(cashDiscount, cash);
+    pointsDiscount = Math.min(pointsDiscount, points);
+    return {
+      ticketTierId: l.ticketTierId,
+      eligible,
+      cashDiscountCents: cashDiscount,
+      pointsDiscount,
+      finalCashCents: cash - cashDiscount,
+      finalPoints: points - pointsDiscount,
+      attributedTicketCount: eligible ? Math.max(0, l.quantity) : 0,
+    };
+  });
+
+  return {
+    status: "applied",
+    discountKind: kind,
+    lines,
+    eligibleTierIds: [...eligibleSet],
+    cashDiscountTotalCents: lines.reduce((s, l) => s + l.cashDiscountCents, 0),
+    pointsDiscountTotal: lines.reduce((s, l) => s + l.pointsDiscount, 0),
+    attributedTicketCount: lines.reduce((s, l) => s + l.attributedTicketCount, 0),
+  };
+}

package/src/promoCodeRedemption.ts

@@ -0,0 +1,123 @@
+/**
+ * Promo code redemption rules shared by the API and the app.
+ * The API owns the ledger; these helpers are pure.
+ */
+
+export const PROMO_CODE_REJECT_REASONS = [
+  "expired",
+  "exhausted",
+  "already_used",
+  "disabled",
+  "invalid",
+  "host_review_required",
+] as const;
+
+export type PromoCodeRejectReason = (typeof PROMO_CODE_REJECT_REASONS)[number];
+
+/** Guest-facing copy. Plain and specific: this is about money. */
+export const PROMO_CODE_REJECT_MESSAGES: Record<PromoCodeRejectReason, string> = {
+  expired: "This code has expired.",
+  exhausted: "This code has reached its order limit.",
+  already_used: "You've already used this code as many times as it allows.",
+  disabled: "This code is no longer active.",
+  invalid: "We couldn't find that code for this bash.",
+  host_review_required: "This code needs the host to review it.",
+};
+
+export function isPromoCodeRejectReason(value: unknown): value is PromoCodeRejectReason {
+  return (
+    typeof value === "string" &&
+    (PROMO_CODE_REJECT_REASONS as readonly string[]).includes(value)
+  );
+}
+
+export type PromoRedeemabilityInput = {
+  redeemBy: Date | null | undefined;
+  disabledAt?: Date | null;
+  maxRedemptions: number | null | undefined;
+  maxUsesPerAccount?: number | null;
+  /** Consumed plus unexpired Reserved orders for the code. */
+  activeOrderCount: number;
+  /** Same count for the buyer's account (user id, else normalized email). */
+  accountOrderCount: number;
+  now: Date;
+};
+
+/** First failing rule, or null when the code can be used for one more order. */
+export function evaluatePromoRedeemability(
+  input: PromoRedeemabilityInput
+): PromoCodeRejectReason | null {
+  if (input.disabledAt) return "disabled";
+  if (input.redeemBy && input.redeemBy.getTime() < input.now.getTime()) {
+    return "expired";
+  }
+  if (
+    input.maxRedemptions != null &&
+    input.maxRedemptions > 0 &&
+    input.activeOrderCount >= input.maxRedemptions
+  ) {
+    return "exhausted";
+  }
+  if (
+    input.maxUsesPerAccount != null &&
+    input.maxUsesPerAccount > 0 &&
+    input.accountOrderCount >= input.maxUsesPerAccount
+  ) {
+    return "already_used";
+  }
+  return null;
+}
+
+export type PromoCodeDuplicateCandidate = {
+  id: string;
+  ticketTierId: string | null;
+  promoterId: string | null;
+  discountAmountInCents: number | null;
+  discountAmountPercentage: number | null;
+  redeemBy: Date | null;
+  maxRedemptions: number | null;
+  bashPointsRewardPerTicket: number | null;
+};
+
+function duplicateSignature(row: PromoCodeDuplicateCandidate): string {
+  return JSON.stringify([
+    row.promoterId ?? null,
+    row.discountAmountInCents ?? null,
+    row.discountAmountPercentage ?? null,
+    row.redeemBy ? new Date(row.redeemBy).getTime() : null,
+    row.maxRedemptions ?? null,
+    row.bashPointsRewardPerTicket ?? null,
+  ]);
+}
+
+/**
+ * Legacy codes are unique per tier, so one bash can hold several rows with the
+ * same code. Identical rows resolve to the oldest id, preferring a row whose tier
+ * is in the cart. Rows that differ need the host to review them.
+ */
+export function pickPromoCodeAmongDuplicates<T extends PromoCodeDuplicateCandidate>(
+  rows: readonly T[],
+  cartTierIds?: readonly string[]
+): { row: T } | { reason: "host_review_required" } {
+  if (rows.length === 0) {
+    throw new Error("pickPromoCodeAmongDuplicates needs at least one row");
+  }
+  if (rows.length === 1) return { row: rows[0] };
+  const signature = duplicateSignature(rows[0]);
+  if (rows.some((r) => duplicateSignature(r) !== signature)) {
+    return { reason: "host_review_required" };
+  }
+  const inCart = cartTierIds?.length
+    ? rows.filter((r) => r.ticketTierId && cartTierIds.includes(r.ticketTierId))
+    : [];
+  const pool = inCart.length ? inCart : rows;
+  const oldest = [...pool].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))[0];
+  return { row: oldest };
+}
+
+export function normalizePromoRedemptionEmail(
+  email: string | null | undefined
+): string | null {
+  const trimmed = email?.trim().toLowerCase() ?? "";
+  return trimmed ? trimmed : null;
+}