@bash-app/bash-common 30.225.0 → 30.227.0

package/src/extendedSchemas.ts

@@ -79,7 +79,13 @@ import {
     VendorPreferences,
     VendorSocialMediaExpectation,
     Venue,
-    VolunteerService
+    VolunteerService,
+    FlyerCampaign,
+    FlyerMailingRoute,
+    FlyerArtwork,
+    FlyerCampaignSponsor,
+    FlyerConversion,
+    PostalCarrierRoute,
 } from "@prisma/client";
 import { BlogStatus, SERVICE_LINK_DATA_TO_INCLUDE } from "./definitions.js";
 import {
@@ -143,8 +149,14 @@ export const FRONT_END_USER_DATA_TO_SELECT = {
   state: true,
   createdOn: true,
   dob: true,
-  gender: true,
-  sex: true,
+  // Raw `gender`, `genderIdentity`, `sex` are intentionally NOT in the public select.
+  // The public profile API exposes only the computed `genderDisplay` (gated by
+  // `showGenderOnProfile`). Self-account selects re-add the raw fields below
+  // (see PRIVATE_USER_ACCOUNT_TO_SELECT) so the user can edit their own value.
+  showAgeOnProfile: true,
+  showGenderOnProfile: true,
+  showVerifiedBadgesOnProfile: true,
+  schoolName: true,
   documentIDId: true,
   // documentID: true,
   /** Set when Stripe Identity verification completes (hosted flow). */
@@ -186,6 +198,10 @@ export const FRONT_END_USER_DATA_TO_SELECT = {
 
 export const PRIVATE_USER_ACCOUNT_TO_SELECT = {
   ...FRONT_END_USER_DATA_TO_SELECT,
+  // Self-only sensitive demographics — re-added so /me can populate edit forms.
+  gender: true,
+  genderIdentity: true,
+  sex: true,
   street: true,
   city: true,
   state: true,
@@ -282,6 +298,8 @@ export interface BashEventExt extends Omit<
   merchandiseItems: BashEventMerchCatalog | null;
   // Prisma relation fields (not included in the flat BashEvent model type)
   coordinates?: Coordinates[];
+  /** Linked venue (when bashEvent.venueId is set and `venue` is requested in include params) */
+  venue?: Venue | null;
   targetAudience?: TargetAudience;
   amountOfGuests?: AmountOfGuests;
   recurrence?: Recurrence;
@@ -1125,6 +1143,8 @@ export const INVITATION_DATA_TO_INCLUDE = {
 export interface InvitationExtraData extends Invitation {
   isFreeGuest: boolean;
   isOrganizer?: boolean;
+  isCoHost?: boolean;
+  organizerTitle?: string;
   isOwnershipTransfer?: boolean;
   includeQRCode?: boolean; // Controls whether QR code should be included in the invitation email
 }
@@ -1230,6 +1250,31 @@ export interface UserExt extends User {
    */
   birthdayDisplay?: string;
 
+  /**
+   * Computed by public user API when `showAgeOnProfile` is true and `dob` is set.
+   * Example: "32".
+   */
+  ageDisplay?: string;
+
+  /**
+   * Computed by public user API when `showGenderOnProfile` is true.
+   * Resolves `genderIdentity` (free-text self-describe) ahead of the enum `gender`.
+   */
+  genderDisplay?: string;
+
+  /**
+   * Computed trust badges. Server gates the entire object on
+   * `showVerifiedBadgesOnProfile` and strips the underlying raw fields
+   * (`paymentVerified`, `stripeAccountId`, `studentIdImageS3Key`, `schoolName`)
+   * from the public response.
+   */
+  badges?: {
+    idVerified: boolean;
+    paymentVerified: boolean;
+    verifiedHost: boolean;
+    studentAt: string | null;
+  };
+
   /** Included when the user query selects the `UserAvailability` relation (not on default Prisma `User`). */
   bashAvailability?: BashAvailability | null;
 
@@ -1424,3 +1469,41 @@ export interface BlogTagFormData {
   slug?: string;
   color?: string;
 }
+
+// --- Flyer Blast (EDDM campaigns) ---
+export const FLYER_CAMPAIGN_WITH_RELATIONS_INCLUDE = {
+  bashEvent: {
+    select: {
+      id: true,
+      title: true,
+      slug: true,
+      coverPhoto: true,
+      themeColor: true,
+      startDateTime: true,
+      endDateTime: true,
+      location: true,
+      street: true,
+      city: true,
+      state: true,
+      zipCode: true,
+    },
+  },
+  routes: true,
+  sponsors: true,
+  artworkVersions: { orderBy: { version: "desc" as const }, take: 3 },
+} satisfies Prisma.FlyerCampaignInclude;
+
+export type FlyerCampaignExt = Prisma.FlyerCampaignGetPayload<{
+  include: typeof FLYER_CAMPAIGN_WITH_RELATIONS_INCLUDE;
+}>;
+
+export interface FlyerAnalyticsSummary {
+  campaignId: string;
+  qrScans: number;
+  sponsorQrScans: number;
+  rsvps: number;
+  ticketPurchases: number;
+  byRoute: { crrtCode: string; zipCode: string; scans: number }[];
+}
+
+export type PostalCarrierRouteExt = PostalCarrierRoute;

package/src/index.ts

@@ -7,6 +7,7 @@ export * from "./extendedSchemas.js";
 export * from "./partnerStoreTypes.js";
 export * from "./bashFeedTypes.js";
 export * from "./membershipDefinitions.js";
+export * from "./aiApproval.js";
 
 // Re-export ALL Prisma enums as values (usable as runtime constants, e.g. ServiceTypes.Entertainment)
 // Excludes enums already re-exported by definitions.ts and membershipDefinitions.ts:
@@ -16,6 +17,7 @@ export * from "./membershipDefinitions.js";
 export {
   $Enums,
   AISpecialistFormat,
+  AiApprovalVerdict,
   AVTechnicianFormat,
   AgeRange,
   AmbashadorApplicationStatus,
@@ -84,6 +86,11 @@ export {
   EventTemplateCategory,
   ExhibitorBookingStatus,
   FinancingSubType,
+  FlyerCampaignStatus,
+  FlyerConversionType,
+  FlyerFulfillmentType,
+  FlyerSponsorSlot,
+  FlyerTargetingMode,
   FloralFormat,
   FoodAndBeverageSubType,
   FoodCartStandFormat,
@@ -222,7 +229,13 @@ export type {
   DocumentID,
   EventTask,
   Exhibitor,
+  FlyerArtwork,
+  FlyerCampaign,
+  FlyerCampaignSponsor,
+  FlyerConversion,
+  FlyerMailingRoute,
   GoogleReview,
+  PostalCarrierRoute,
   Invitation,
   Link,
   Media,
@@ -293,8 +306,10 @@ export * from "./utils/urlUtils.js";
 export * from "./utils/userPromoCodeUtils.js";
 export * from "./utils/userSubscriptionUtils.js";
 export * from "./utils/blog/blogDbUtils.js";
+export * from "./utils/blog/blogCommentDbUtils.js";
 export * from "./utils/blogUtils.js";
 export * from "./utils/entityUtils.js";
+export * from "./utils/flyerUtils.js";
 export * from "./utils/generalDateTimeUtils.js";
 export * from "./utils/luxonUtils.js";
 export * from "./utils/mediaClientDefaults.js";

package/src/legalTemplates.ts

@@ -8,7 +8,7 @@ export const DEFAULT_PHOTO_RELEASE_TEXT = `By attending this event, you understa
 If you do not wish to appear in promotional materials, contact the event organizer before or during the event. For minors, a parent or guardian must agree to this consent.`;
 
 /**
- * Effective photo release text for display (wizard preview, event page, checkout).
+ * Effective photo release text for display (wizard preview, bash detail page, checkout).
  */
 export function getPhotoReleaseDisplayText(
   photoReleaseText: string | null | undefined

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

@@ -0,0 +1,191 @@
+/**
+ * badgeUtils — host level / temp-badge helpers.
+ *
+ * The level-badge calculation is the public reputation signal on every host
+ * profile. A bug here either over- or under-credits a host (= unfair / loss
+ * of trust). We pin the actual ladder defined in DEFAULT_LEVEL_BADGES:
+ *
+ *   novice   → 1+ events
+ *   regular  → 5+ events,  rating ≥ 4.0
+ *   maverick → 15+ events, rating ≥ 4.5
+ *   legend   → 30+ events, rating ≥ 4.8
+ *
+ * We also pin temp-badge expiry semantics: missing expiresOn = never expires.
+ */
+import {
+  getLevelBadgeById,
+  getTemporaryBadgeById,
+  isTemporaryBadgeExpired,
+  filterExpiredTemporaryBadges,
+  determineLevelBadge,
+} from "../badgeUtils.js";
+import type { UserTemporaryBadge } from "../../definitions.js";
+
+// ============================================================================
+// getLevelBadgeById / getTemporaryBadgeById — registry lookups
+// ============================================================================
+
+describe("getLevelBadgeById", () => {
+  it("returns the canonical badge object for a known id", () => {
+    const b = getLevelBadgeById("legend");
+    expect(b).toBeDefined();
+    expect(b?.id).toBe("legend");
+    expect(b?.requiredEvents).toBe(30);
+    expect(b?.requiredRating).toBe(4.8);
+  });
+
+  it("returns undefined for an unknown id", () => {
+    expect(getLevelBadgeById("definitely-not-a-badge")).toBeUndefined();
+  });
+
+  it("returns undefined for empty string", () => {
+    expect(getLevelBadgeById("")).toBeUndefined();
+  });
+});
+
+describe("getTemporaryBadgeById", () => {
+  it("returns a known temp badge", () => {
+    expect(getTemporaryBadgeById("trendingStar")?.id).toBe("trendingStar");
+  });
+
+  it("returns undefined for an unknown id", () => {
+    expect(getTemporaryBadgeById("nope")).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// isTemporaryBadgeExpired
+// ============================================================================
+
+describe("isTemporaryBadgeExpired", () => {
+  it("returns false when expiresOn is missing (badge never expires)", () => {
+    const badge: UserTemporaryBadge = {
+      badgeId: "earlyAdopter",
+      earnedOn: "2020-01-01T00:00:00Z",
+    };
+    expect(isTemporaryBadgeExpired(badge)).toBe(false);
+  });
+
+  it("returns true for a clearly past expiresOn", () => {
+    const badge: UserTemporaryBadge = {
+      badgeId: "trendingStar",
+      earnedOn: "2020-01-01T00:00:00Z",
+      expiresOn: "2020-02-01T00:00:00Z",
+    };
+    expect(isTemporaryBadgeExpired(badge)).toBe(true);
+  });
+
+  it("returns false for a clearly future expiresOn", () => {
+    const future = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000)
+      .toISOString();
+    const badge: UserTemporaryBadge = {
+      badgeId: "topHost",
+      earnedOn: new Date().toISOString(),
+      expiresOn: future,
+    };
+    expect(isTemporaryBadgeExpired(badge)).toBe(false);
+  });
+
+  it("returns true when expiresOn is RIGHT NOW (boundary: not strictly in the future)", () => {
+    // Source uses `expiryDate < currentDate`. A simultaneous tick = false (not expired),
+    // but Date.now() inside the function is sampled later than ours — which is enough
+    // to flip <. We pin the practical observable: "earlier than now → expired".
+    const past = new Date(Date.now() - 1).toISOString();
+    const badge: UserTemporaryBadge = {
+      badgeId: "topHost",
+      earnedOn: "2020-01-01T00:00:00Z",
+      expiresOn: past,
+    };
+    expect(isTemporaryBadgeExpired(badge)).toBe(true);
+  });
+});
+
+// ============================================================================
+// filterExpiredTemporaryBadges
+// ============================================================================
+
+describe("filterExpiredTemporaryBadges", () => {
+  it("returns [] for [] (no surprise allocation)", () => {
+    expect(filterExpiredTemporaryBadges([])).toEqual([]);
+  });
+
+  it("keeps non-expiring badges", () => {
+    const badges: UserTemporaryBadge[] = [
+      { badgeId: "earlyAdopter", earnedOn: "2020-01-01T00:00:00Z" },
+    ];
+    expect(filterExpiredTemporaryBadges(badges)).toHaveLength(1);
+  });
+
+  it("drops expired badges and keeps the rest", () => {
+    const future = new Date(Date.now() + 86_400_000).toISOString();
+    const past = new Date(Date.now() - 86_400_000).toISOString();
+    const badges: UserTemporaryBadge[] = [
+      { badgeId: "topHost", earnedOn: "2020-01-01T00:00:00Z", expiresOn: past },
+      { badgeId: "trendingStar", earnedOn: "2020-01-01T00:00:00Z", expiresOn: future },
+      { badgeId: "earlyAdopter", earnedOn: "2020-01-01T00:00:00Z" },
+    ];
+    const result = filterExpiredTemporaryBadges(badges);
+    expect(result.map((b) => b.badgeId)).toEqual(["trendingStar", "earlyAdopter"]);
+  });
+});
+
+// ============================================================================
+// determineLevelBadge — the reputation ladder
+// ============================================================================
+
+describe("determineLevelBadge — host reputation ladder", () => {
+  it("returns null when the host has no events", () => {
+    expect(determineLevelBadge(0, 5)).toBeNull();
+  });
+
+  it("returns null when events are below the lowest threshold (1) even with high rating", () => {
+    expect(determineLevelBadge(0, 5)).toBeNull();
+  });
+
+  it("awards 'novice' at 1 event with no rating threshold", () => {
+    expect(determineLevelBadge(1, 0)).toBe("novice");
+  });
+
+  it("stays at 'novice' between 1 and 4 events", () => {
+    expect(determineLevelBadge(2, 4.9)).toBe("novice");
+    expect(determineLevelBadge(4, 4.9)).toBe("novice");
+  });
+
+  it("awards 'regular' at 5 events when rating ≥ 4.0", () => {
+    expect(determineLevelBadge(5, 4.0)).toBe("regular");
+    expect(determineLevelBadge(10, 4.49)).toBe("regular");
+  });
+
+  it("falls BACK to 'novice' when 5+ events but rating < 4.0 (rating gate failed)", () => {
+    // Rating gate failed for 'regular', so the next-best the host qualifies for is 'novice'.
+    expect(determineLevelBadge(5, 3.9)).toBe("novice");
+    expect(determineLevelBadge(20, 3.0)).toBe("novice");
+  });
+
+  it("awards 'maverick' at 15 events when rating ≥ 4.5", () => {
+    expect(determineLevelBadge(15, 4.5)).toBe("maverick");
+    expect(determineLevelBadge(29, 4.79)).toBe("maverick");
+  });
+
+  it("falls back to 'regular' at 15+ events when rating is between 4.0 and 4.5", () => {
+    expect(determineLevelBadge(15, 4.49)).toBe("regular");
+  });
+
+  it("awards 'legend' at 30 events when rating ≥ 4.8", () => {
+    expect(determineLevelBadge(30, 4.8)).toBe("legend");
+    expect(determineLevelBadge(1000, 5)).toBe("legend");
+  });
+
+  it("falls back to 'maverick' at 30+ events when rating drops below 4.8", () => {
+    expect(determineLevelBadge(30, 4.7)).toBe("maverick");
+  });
+
+  it("falls all the way back to 'novice' for a host with many events but a poor rating", () => {
+    // 1000 events but rating 1.0 → only the no-rating-gate 'novice' qualifies.
+    expect(determineLevelBadge(1000, 1.0)).toBe("novice");
+  });
+
+  it("treats fractional event counts the same as integer (>=)", () => {
+    expect(determineLevelBadge(5.5, 4.0)).toBe("regular");
+  });
+});

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

@@ -0,0 +1,153 @@
+/**
+ * bashPointsPaymentUtils — earning math + display + deprecated stubs.
+ *
+ * BashPoints are loyalty cashback. The active code paths are:
+ *   - calculateBashPointsCashback(amountCents, rate) → integer points
+ *   - formatBashPoints(n)                            → "1,000 points"
+ *
+ * The "service booking" overloads were intentionally deprecated because
+ * BashPoints have no fixed dollar value and cannot pay for services. We pin
+ * the deprecated stubs here so they stay benign (return safe defaults, log a
+ * warning) — accidentally re-enabling them would cause real money loss.
+ */
+import {
+  formatBashPoints,
+  calculateBashPointsCashback,
+  centsToBashPoints,
+  bashPointsToCents,
+  calculateMaxBashPointsForBooking,
+  calculateSplitPayment,
+  validateBashPointsPayment,
+} from "../bashPointsPaymentUtils.js";
+
+describe("formatBashPoints", () => {
+  it("uses singular 'point' for exactly 1", () => {
+    expect(formatBashPoints(1)).toBe("1 point");
+  });
+
+  it("uses plural 'points' for 0", () => {
+    expect(formatBashPoints(0)).toBe("0 points");
+  });
+
+  it("uses plural for >1", () => {
+    expect(formatBashPoints(2)).toBe("2 points");
+  });
+
+  it("inserts en-US thousands separators", () => {
+    expect(formatBashPoints(1000)).toBe("1,000 points");
+    expect(formatBashPoints(28750)).toBe("28,750 points");
+    expect(formatBashPoints(1_000_000)).toBe("1,000,000 points");
+  });
+
+  it("formats negative values (defensive — should never happen but no throw)", () => {
+    // -1 !== 1 so it gets the plural suffix
+    expect(formatBashPoints(-5)).toBe("-5 points");
+  });
+});
+
+describe("calculateBashPointsCashback", () => {
+  it("awards 5% on a $10.00 (1000¢) purchase → 50 points", () => {
+    expect(calculateBashPointsCashback(1000, 0.05)).toBe(50);
+  });
+
+  it("awards 0 points on a $0 purchase", () => {
+    expect(calculateBashPointsCashback(0, 0.05)).toBe(0);
+  });
+
+  it("awards 0 points when the rate is 0", () => {
+    expect(calculateBashPointsCashback(10_000, 0)).toBe(0);
+  });
+
+  it("FLOORS fractional results (never over-awards)", () => {
+    // 333 * 0.05 = 16.65 → floor → 16
+    expect(calculateBashPointsCashback(333, 0.05)).toBe(16);
+  });
+
+  it("handles a 100% rebate rate", () => {
+    expect(calculateBashPointsCashback(2500, 1)).toBe(2500);
+  });
+
+  it("rate > 1 still floors (host can configure bonuses; trust input)", () => {
+    expect(calculateBashPointsCashback(100, 1.5)).toBe(150);
+  });
+
+  it("returns 0 (not negative) for negative amounts after floor", () => {
+    // Math.floor(-1) = -1; we don't bound the result to >=0 in source,
+    // so this pins the actual contract: negative inputs flow through as-is.
+    expect(calculateBashPointsCashback(-100, 0.05)).toBe(-5);
+  });
+});
+
+describe("DEPRECATED stubs — must remain safe defaults", () => {
+  let warnSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  describe("centsToBashPoints", () => {
+    it("returns the input as-is and warns", () => {
+      expect(centsToBashPoints(1234)).toBe(1234);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATED: centsToBashPoints")
+      );
+    });
+  });
+
+  describe("bashPointsToCents", () => {
+    it("returns the input as-is and warns", () => {
+      expect(bashPointsToCents(500)).toBe(500);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATED: bashPointsToCents")
+      );
+    });
+  });
+
+  describe("calculateMaxBashPointsForBooking", () => {
+    it("returns 0 (no BashPoints can be applied to a service booking) and warns", () => {
+      expect(calculateMaxBashPointsForBooking(10_000, 5_000)).toBe(0);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATED: calculateMaxBashPointsForBooking")
+      );
+    });
+  });
+
+  describe("calculateSplitPayment", () => {
+    it("forces the full amount onto Stripe (BashPoints contribution = 0) and warns", () => {
+      const result = calculateSplitPayment(10_000, 9_999);
+      expect(result).toEqual({
+        bashPointsCents: 0,
+        stripeCents: 10_000,
+        bashPointsCredits: 0,
+      });
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATED: calculateSplitPayment")
+      );
+    });
+
+    it("preserves the original total on stripeCents even when called with 0", () => {
+      const result = calculateSplitPayment(0, 100);
+      expect(result.stripeCents).toBe(0);
+    });
+  });
+
+  describe("validateBashPointsPayment", () => {
+    it("ALWAYS returns invalid with a clear redirect-to-Stripe message", () => {
+      const result = validateBashPointsPayment(100, 1_000, 500);
+      expect(result.valid).toBe(false);
+      expect(result.errorMessage).toMatch(/credit card/i);
+      expect(result.errorMessage).toMatch(/BashPoints-priced tickets/i);
+    });
+
+    it("rejects even when the user has enough balance (no special-case bypass)", () => {
+      // 1_000_000 balance, 100 needed → still rejected because services can't take BashPoints.
+      expect(
+        validateBashPointsPayment(100, 1_000_000, 100).valid
+      ).toBe(false);
+    });
+  });
+});