@bash-app/bash-common 30.433.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/promoCodeScope.ts

@@ -9,6 +9,17 @@ import { getPublicBashDetailPath } from "./utils/slugUtils.js";
 export type PromoDiscountKind = "NONE" | "PERCENT" | "FIXED_CASH";
 export type PromoEligibilityMode = "ALL_TIERS" | "SELECTED_TIERS";
 
+/** How the host pays a promoter for a code. BashPoints is credited here; the others are paid outside Bash. */
+export const PROMO_COMPENSATION_METHODS = ["Venmo", "Zelle", "CashApp", "BashPoints"] as const;
+export type PromoCompensationMethod = (typeof PROMO_COMPENSATION_METHODS)[number];
+
+export function isPromoCompensationMethod(value: unknown): value is PromoCompensationMethod {
+  return (
+    typeof value === "string" &&
+    (PROMO_COMPENSATION_METHODS as readonly string[]).includes(value)
+  );
+}
+
 export type PromoScopeFields = {
   ticketTierId?: string | null;
   bashEventId?: string | null;
@@ -98,7 +109,7 @@ export type PromoterCodeInput = {
   promoterUserId?: string | null;
   promoterEmail?: string | null;
   discountType: PromoDiscountKind;
-  /** Percent (1-100) for PERCENT, cents for FIXED_CASH, ignored for NONE. */
+  /** Percent (0-100) for PERCENT, cents (0 or more) for FIXED_CASH, ignored for NONE. */
   discountValue?: number | null;
   eligibilityMode: PromoEligibilityMode;
   eligibleTierIds?: string[];
@@ -112,6 +123,8 @@ export type PromoterCodeInput = {
   promoterCommissionBps?: number | null;
   /** The host opened and confirmed the Promoter reward section. */
   promoterRewardReviewed?: boolean;
+  /** Venmo, Zelle, Cash App, or BashPoints. Null clears a saved choice. */
+  compensationMethod?: PromoCompensationMethod | null;
 };
 
 export type PromoterCodeStatusLabel = "active" | "expired" | "exhausted" | "disabled";
@@ -129,12 +142,12 @@ export function promoterCodeInputErrors(
   }
   if (input.discountType === "PERCENT") {
     const pct = Number(input.discountValue);
-    if (!Number.isInteger(pct) || pct < 1 || pct > 100) {
-      errors.push("Guest discount must be between 1% and 100%.");
+    if (!Number.isInteger(pct) || pct < 0 || pct > 100) {
+      errors.push("Guest discount must be between 0% and 100%.");
     }
   } else if (input.discountType === "FIXED_CASH") {
     const cents = Number(input.discountValue);
-    if (!Number.isInteger(cents) || cents <= 0) errors.push("Enter a fixed discount above $0.");
+    if (!Number.isInteger(cents) || cents < 0) errors.push("Enter a fixed discount of $0 or more.");
   }
   if (input.eligibilityMode === "SELECTED_TIERS") {
     const ids = input.eligibleTierIds ?? [];
@@ -160,5 +173,8 @@ export function promoterCodeInputErrors(
   if (hasPromoter && !input.promoterRewardReviewed) {
     errors.push("Review the promoter reward before saving.");
   }
+  if (input.compensationMethod != null && !isPromoCompensationMethod(input.compensationMethod)) {
+    errors.push("Choose Venmo, Zelle, Cash App, or BashPoints.");
+  }
   return errors;
 }