@bash-app/bash-common 30.293.0 → 30.297.0

package/src/definitions.ts

@@ -1471,6 +1471,7 @@ export const INCOME_RANGE_VALUES: ReadonlyArray<IncomeRange> = [
 
 /** Homepage / discovery section labels for synthetic rows (not `BashEventType` enum values). */
 const SYNTHETIC_BASH_SECTION_TITLE: Record<string, string> = {
+  Ideas: "Ideas",
   Featured: "Featured",
   Trending: "Trending",
 };
@@ -1817,11 +1818,19 @@ export interface UserTemporaryBadge {
 
 export interface Review {
   id: string;
-  rating: number; // 1-5 stars
+  rating: number; // 1-5 stars (Overall)
   creatorId: string;
   bashEventId: string;
   createdAt: string;
   updatedAt: string;
+  organizationRating?: number | null;
+  atmosphereRating?: number | null;
+  valueRating?: number | null;
+  safetyRating?: number | null;
+  wouldAttendAgain?: boolean | null;
+  verifiedBooking?: boolean;
+  verifiedAttendance?: boolean;
+  verifiedServiceCompletion?: boolean;
   comments?: ReviewComment[];
 }
 
@@ -1853,10 +1862,83 @@ export interface ReviewWithUser extends Review {
 
 export interface ReviewWithUserAndEvent extends ReviewWithUser, ReviewWithEvent {}
 
+/** Wizard / API shape for BashEvent.itinerary JSON (see prisma BashEvent.itinerary). */
+export interface ItineraryItem {
+  id: string;
+  title: string;
+  startTime: string;
+  endTime: string;
+  description?: string;
+}
+
 export interface NewReview {
   rating: number;
   bashEventId: string;
   commentContent?: string;
+  organizationRating?: number;
+  atmosphereRating?: number;
+  valueRating?: number;
+  safetyRating?: number;
+  wouldAttendAgain?: boolean;
+}
+
+export interface ServiceReviewDimensions {
+  communicationRating?: number | null;
+  professionalismRating?: number | null;
+  qualityRating?: number | null;
+  wouldHireAgain?: boolean | null;
+}
+
+export interface NewServiceReview extends ServiceReviewDimensions {
+  overallRating: number;
+  bashEventId: string;
+  comment?: string;
+  createPost?: boolean;
+  postContent?: string;
+}
+
+export interface ServiceReviewPublic {
+  id: string;
+  overallRating: number;
+  reviewerRole: "Attendee" | "Host";
+  comment?: string | null;
+  createdAt: string;
+  publishedAt?: string | null;
+  verifiedBooking: boolean;
+  verifiedAttendance: boolean;
+  verifiedServiceCompletion: boolean;
+  communicationRating?: number | null;
+  professionalismRating?: number | null;
+  qualityRating?: number | null;
+  wouldHireAgain?: boolean | null;
+  providerReplyText?: string | null;
+  providerReplyAt?: string | null;
+  feedPostId?: string | null;
+  creator?: {
+    id: string;
+    givenName?: string | null;
+    familyName?: string | null;
+    image?: string | null;
+  };
+  bashEvent?: {
+    id: string;
+    title: string;
+    startDateTime: string;
+  };
+}
+
+export interface ServiceReviewStats {
+  overallAverage: number | null;
+  totalReviews: number;
+  dimensionAverages: import("./utils/reviewDimensionUtils.js").ReviewDimensionAverages;
+  googleAverage?: number | null;
+  googleCount?: number;
+  trustScore?: number | null;
+}
+
+export interface TrustScoreBreakdownPublic {
+  score: number | null;
+  components: Record<string, number>;
 }
 
 export interface ReviewStats {
@@ -1869,6 +1951,8 @@ export interface ReviewStats {
     4: number;
     5: number;
   };
+  dimensionAverages?: import("./utils/reviewDimensionUtils.js").ReviewDimensionAverages;
+  trustScore?: number | null;
 }
 
 /** Helpful / Not helpful tallies on profile review cards (API: host-reviews). */

package/src/extendedSchemas.ts

@@ -287,6 +287,7 @@ export interface CompetitionPrizeOfferExt {
   sponsorLabel?: string | null;
   sourceServiceId?: string | null;
   sourceSku?: string | null;
+  targetPrizeId?: string | null;
   hostNote?: string | null;
   createdAt: Date | string;
   respondedAt?: Date | string | null;
@@ -296,6 +297,12 @@ export interface CompetitionPrizeOfferExt {
     serviceName: string | null;
     coverPhoto: string | null;
   } | null;
+  targetPrize?: {
+    id: string;
+    name: string;
+    placeName: string | null;
+    sponsorCostCents: number | null;
+  } | null;
 }
 
 /** Competition row + relations; Override keeps new columns visible before consumers refresh Prisma. */

package/src/index.ts

@@ -366,6 +366,7 @@ export * from "./utils/service/serviceFeaturedSortUtils.js";
 export * from "./utils/service/serviceBookingExposureUtils.js";
 export * from "./utils/agencyBookingCheckoutCopy.js";
 export * from "./utils/service/serviceUtils.js";
+export * from "./utils/service/serviceListingMediaUtils.js";
 export * from "./utils/service/venueSettlementUtils.js";
 export * from "./utils/service/offerAllowListUtils.js";
 export * from "./utils/service/offerComparisonUtils.js";
@@ -407,6 +408,8 @@ export * from "./utils/service/serviceRateUtils.js";
 export * from "./utils/serviceAvailabilityDisplay.js";
 export * from "./utils/entertainmentServiceTypeOptions.js";
 export * from "./utils/reputationUtils.js";
+export * from "./utils/reviewDimensionUtils.js";
+export * from "./utils/trustScoreUtils.js";
 export * from "./utils/stripeAccountUtils.js";
 export * from "./utils/userUtils.js";
 export * from "./utils/venueTypeFormatter.js";

package/src/membershipDefinitions.ts

@@ -219,6 +219,17 @@ export const BASHPOINTS_REWARDS: Record<MembershipTier, {
   },
 } as const;
 
+/** Referral tier qualification thresholds — single source of truth for grant + stats UI. */
+export const AMBASHADOR_QUALIFICATION = {
+  freeSignups: 1,
+  paidSignups: 1,
+} as const;
+
+export const INSIDER_QUALIFICATION = {
+  freeSignups: 100,
+  paidSignups: 10,
+} as const;
+
 /**
  * BashPoints system rules and limits
  * 
@@ -233,7 +244,7 @@ export const BASHPOINTS_CONFIG = {
   paymentVerificationBonus: 500,
 
   // Tier achievement bonuses (one-time when user reaches each tier)
-  ambashadorAchievementBonus: 500,      // Ambashador: 3 free or 1 paid referral
+  ambashadorAchievementBonus: 500,      // Ambashador: 1 free or 1 paid referral
   scoutAchievementBonus: 250,           // Scout: first service profile referral
   insiderAchievementBonus: 1000,       // Bash Insider: 10 paid or 100 free referrals
   agentAchievementBonus: 500,           // Agent: 5+ service profile referrals

package/src/utils/__tests__/reputationUtils.serviceListing.test.ts

@@ -33,4 +33,28 @@ describe("getServiceListingReputation", () => {
       })?.sourceLabel
     ).toBeUndefined();
   });
+
+  it("uses Bash sourceLabel when native reviews exist", () => {
+    expect(
+      getServiceListingReputation({
+        serviceRating: 4.6,
+        totalRatings: 12,
+        externalReviewSource: "google",
+      })
+    ).toEqual({
+      averageRating: 4.6,
+      totalRatings: 12,
+      sourceLabel: "Bash",
+    });
+  });
+
+  it("returns null below threshold even with google external source", () => {
+    expect(
+      getServiceListingReputation({
+        serviceRating: 4.9,
+        totalRatings: 0,
+        externalReviewSource: "google",
+      })
+    ).toBeNull();
+  });
 });

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

@@ -0,0 +1,65 @@
+import {
+  averageNullable,
+  parseOptionalDimensionRating,
+  parseRequiredOverallRating,
+  percentTrue,
+} from "../reviewDimensionUtils.js";
+
+describe("reviewDimensionUtils", () => {
+  describe("parseRequiredOverallRating", () => {
+    it("accepts integers 1–5", () => {
+      expect(parseRequiredOverallRating(4)).toBe(4);
+    });
+
+    it("rejects out of range", () => {
+      expect(() => parseRequiredOverallRating(0)).toThrow();
+      expect(() => parseRequiredOverallRating(6)).toThrow();
+    });
+  });
+
+  describe("parseOptionalDimensionRating", () => {
+    it("returns null when omitted", () => {
+      expect(parseOptionalDimensionRating(undefined, "communication")).toBeNull();
+    });
+
+    it("parses valid optional ratings", () => {
+      expect(parseOptionalDimensionRating(3, "communication")).toBe(3);
+    });
+  });
+
+  describe("averageNullable", () => {
+    it("returns null for empty input", () => {
+      expect(averageNullable([])).toBeNull();
+    });
+
+    it("averages present values", () => {
+      expect(averageNullable([4, 5, null])).toBe(4.5);
+    });
+  });
+
+  describe("percentTrue", () => {
+    it("returns null when no booleans", () => {
+      expect(percentTrue([null, undefined])).toBeNull();
+    });
+
+    it("computes yes percentage", () => {
+      expect(percentTrue([true, false, true])).toBe(67);
+    });
+
+    it("returns 100 when all true", () => {
+      expect(percentTrue([true, true])).toBe(100);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("parseOptionalDimensionRating rejects non-integers", () => {
+      expect(() =>
+        parseOptionalDimensionRating(3.5, "qualityRating")
+      ).toThrow(/integer/i);
+    });
+
+    it("averageNullable ignores NaN", () => {
+      expect(averageNullable([4, Number.NaN, 2])).toBe(3);
+    });
+  });
+});

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

@@ -0,0 +1,105 @@
+import { computeTrustScoreFromInputs } from "../trustScoreUtils.js";
+
+describe("trustScoreUtils", () => {
+  it("returns a score between 0 and 100 for services", () => {
+    const result = computeTrustScoreFromInputs("service", {
+      bayesianReviewScore: 4.5,
+      completedVolume: 25,
+      cancellationRate: 0.05,
+      responseRate: 1,
+      identityVerified: true,
+      verifiedCompletionRate: 0.9,
+      accountAgeDays: 400,
+      disputeRate: 0,
+      repeatCustomerRate: 0.2,
+    });
+    expect(result.score).not.toBeNull();
+    expect(result.score!).toBeGreaterThanOrEqual(0);
+    expect(result.score!).toBeLessThanOrEqual(100);
+    expect(result.components.reviews).toBeGreaterThan(0);
+  });
+
+  it("uses host weights including attendance signal", () => {
+    const result = computeTrustScoreFromInputs("host", {
+      bayesianReviewScore: 4,
+      completedVolume: 10,
+      cancellationRate: 0.1,
+      responseRate: 0.8,
+      identityVerified: false,
+      verifiedAttendanceRate: 0.75,
+      accountAgeDays: 30,
+      disputeRate: 0.02,
+      repeatCustomerRate: 0.1,
+    });
+    expect(result.weights.attendance).toBe(0.05);
+    expect(result.score).not.toBeNull();
+  });
+
+  it("returns null score when insufficient review signal defaults", () => {
+    const result = computeTrustScoreFromInputs("service", {
+      bayesianReviewScore: null,
+      completedVolume: 0,
+      cancellationRate: 0,
+      responseRate: 1,
+      identityVerified: false,
+      verifiedCompletionRate: 0,
+      accountAgeDays: 1,
+      disputeRate: 0,
+      repeatCustomerRate: 0,
+    });
+    expect(result.score).not.toBeNull();
+    expect(result.components.reviews).toBe(0.5);
+  });
+
+  it("penalizes high cancellation and dispute rates", () => {
+    const good = computeTrustScoreFromInputs("service", {
+      bayesianReviewScore: 4.5,
+      completedVolume: 50,
+      cancellationRate: 0.05,
+      responseRate: 1,
+      identityVerified: true,
+      verifiedCompletionRate: 0.9,
+      accountAgeDays: 500,
+      disputeRate: 0,
+      repeatCustomerRate: 0.3,
+    });
+    const bad = computeTrustScoreFromInputs("service", {
+      bayesianReviewScore: 4.5,
+      completedVolume: 50,
+      cancellationRate: 0.5,
+      responseRate: 0.5,
+      identityVerified: true,
+      verifiedCompletionRate: 0.2,
+      accountAgeDays: 500,
+      disputeRate: 0.2,
+      repeatCustomerRate: 0,
+    });
+    expect(good.score!).toBeGreaterThan(bad.score!);
+  });
+
+  it("boosts score when identity is verified", () => {
+    const verified = computeTrustScoreFromInputs("service", {
+      bayesianReviewScore: 4,
+      completedVolume: 10,
+      cancellationRate: 0.1,
+      responseRate: 1,
+      identityVerified: true,
+      verifiedCompletionRate: 0.5,
+      accountAgeDays: 200,
+      disputeRate: 0,
+      repeatCustomerRate: 0.1,
+    });
+    const unverified = computeTrustScoreFromInputs("service", {
+      bayesianReviewScore: 4,
+      completedVolume: 10,
+      cancellationRate: 0.1,
+      responseRate: 1,
+      identityVerified: false,
+      verifiedCompletionRate: 0.5,
+      accountAgeDays: 200,
+      disputeRate: 0,
+      repeatCustomerRate: 0.1,
+    });
+    expect(verified.score!).toBeGreaterThan(unverified.score!);
+  });
+});

package/src/utils/reputationUtils.ts

@@ -85,7 +85,13 @@ export function getServiceListingReputation(service: {
     return null;
   }
   const sourceLabel =
-    service.externalReviewSource === "google" ? "Google" : undefined;
+    service.externalReviewSource === "google" && (service.totalRatings ?? 0) === 0
+      ? "Google"
+      : (service.totalRatings ?? 0) > 0
+        ? "Bash"
+        : service.externalReviewSource === "google"
+          ? "Google"
+          : undefined;
   return {
     averageRating: summary.averageRating,
     totalRatings: summary.totalRatings,

package/src/utils/reviewDimensionUtils.ts

@@ -0,0 +1,70 @@
+/** Optional 1–5 dimension rating from API/UI payloads. */
+export type OptionalDimensionRating = number | null | undefined;
+
+export interface EventReviewDimensionsInput {
+  organizationRating?: OptionalDimensionRating;
+  atmosphereRating?: OptionalDimensionRating;
+  valueRating?: OptionalDimensionRating;
+  safetyRating?: OptionalDimensionRating;
+  wouldAttendAgain?: boolean | null;
+}
+
+export interface ServiceReviewDimensionsInput {
+  communicationRating?: OptionalDimensionRating;
+  professionalismRating?: OptionalDimensionRating;
+  qualityRating?: OptionalDimensionRating;
+  wouldHireAgain?: boolean | null;
+}
+
+export interface ReviewDimensionAverages {
+  organization?: number | null;
+  atmosphere?: number | null;
+  value?: number | null;
+  safety?: number | null;
+  communication?: number | null;
+  professionalism?: number | null;
+  quality?: number | null;
+  wouldAttendAgainPercent?: number | null;
+  wouldHireAgainPercent?: number | null;
+  wouldWorkAgainPercent?: number | null;
+}
+
+const MIN_DIM = 1;
+const MAX_DIM = 5;
+
+/** Validate optional 1–5 dimension; returns null when omitted. */
+export function parseOptionalDimensionRating(
+  value: OptionalDimensionRating,
+  fieldName: string
+): number | null {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < MIN_DIM || n > MAX_DIM) {
+    throw new Error(`${fieldName} must be an integer from ${MIN_DIM} to ${MAX_DIM}`);
+  }
+  return n;
+}
+
+export function parseRequiredOverallRating(value: unknown): number {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < MIN_DIM || n > MAX_DIM) {
+    throw new Error(`Overall rating must be an integer from ${MIN_DIM} to ${MAX_DIM}`);
+  }
+  return n;
+}
+
+export function averageNullable(values: (number | null | undefined)[]): number | null {
+  const nums = values.filter((v): v is number => typeof v === "number" && !Number.isNaN(v));
+  if (nums.length === 0) return null;
+  const sum = nums.reduce((a, b) => a + b, 0);
+  return Math.round((sum / nums.length) * 100) / 100;
+}
+
+export function percentTrue(values: (boolean | null | undefined)[]): number | null {
+  const defined = values.filter((v): v is boolean => typeof v === "boolean");
+  if (defined.length === 0) return null;
+  const yes = defined.filter(Boolean).length;
+  return Math.round((yes / defined.length) * 100);
+}

package/src/utils/service/__tests__/serviceListingMediaUtils.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "@jest/globals";
+import { MediaType } from "@prisma/client";
+import type { ServiceExt } from "../../../extendedSchemas.js";
+import {
+  filterServiceListingMedia,
+  resolveServiceListingImage,
+} from "../serviceListingMediaUtils.js";
+
+describe("serviceListingMediaUtils", () => {
+  test("resolveServiceListingImage prefers coverPhoto when gallery has videos", () => {
+    expect(
+      resolveServiceListingImage({
+        coverPhoto: "https://cdn.example.com/cover.jpg",
+        media: [
+          { type: MediaType.Video, url: "https://cdn.example.com/live.mp4" },
+        ],
+      } as Pick<ServiceExt, "coverPhoto" | "media">)
+    ).toBe("https://cdn.example.com/cover.jpg");
+  });
+
+  test("filterServiceListingMedia excludes supporting videos", () => {
+    const filtered = filterServiceListingMedia({
+      media: [
+        { type: MediaType.Video, url: "https://cdn.example.com/live.mp4" },
+        { type: MediaType.Image, url: "https://cdn.example.com/still.jpg" },
+      ],
+    } as Pick<ServiceExt, "media">);
+
+    expect(filtered.map((item) => item.url)).toEqual([
+      "https://cdn.example.com/still.jpg",
+    ]);
+  });
+
+  test("resolveServiceListingImage returns undefined when only videos exist", () => {
+    expect(
+      resolveServiceListingImage({
+        coverPhoto: null,
+        media: [
+          { type: MediaType.Video, url: "https://cdn.example.com/live.mp4" },
+        ],
+      } as Pick<ServiceExt, "coverPhoto" | "media">)
+    ).toBeUndefined();
+  });
+});

package/src/utils/service/serviceListingMediaUtils.ts

@@ -0,0 +1,62 @@
+import { MediaType, type Media } from "@prisma/client";
+import type { ServiceExt } from "../../extendedSchemas.js";
+
+export type ServiceListingOwner = {
+  uploadedImage?: string | null;
+  image?: string | null;
+} | null | undefined;
+
+function normalizeListingImageUrl(
+  url: string | null | undefined
+): string | null {
+  if (!url?.trim()) return null;
+  return url.trim();
+}
+
+/** True when a URL is the service owner's personal profile photo, not listing media. */
+export function isOwnerProfileListingImageUrl(
+  url: string,
+  owner?: ServiceListingOwner
+): boolean {
+  if (!owner) return false;
+  const normalized = url.trim();
+  const profileUrls = [owner.uploadedImage, owner.image]
+    .map(normalizeListingImageUrl)
+    .filter((value): value is string => Boolean(value));
+  return profileUrls.some((profileUrl) => profileUrl === normalized);
+}
+
+/** Gallery images suitable for public service cards — excludes videos and profile avatars. */
+export function filterServiceListingMedia(
+  service: Pick<ServiceExt, "media"> & { owner?: ServiceListingOwner }
+): Media[] {
+  const media = Array.isArray(service.media) ? service.media : [];
+  return media.filter(
+    (item) =>
+      item?.type === MediaType.Image &&
+      typeof item.url === "string" &&
+      item.url.trim().length > 0 &&
+      !item.url.startsWith("https://maps.googleapis.com/") &&
+      !isOwnerProfileListingImageUrl(item.url, service.owner)
+  );
+}
+
+/**
+ * Resolve the still image for browse cards and list heroes.
+ *
+ * Prefers `coverPhoto`, then the first gallery image. Supporting videos in
+ * `media` are never used — cards must not autoplay performance clips.
+ */
+export function resolveServiceListingImage(
+  service: Pick<ServiceExt, "coverPhoto" | "media"> & {
+    owner?: ServiceListingOwner;
+  }
+): string | undefined {
+  const cover = normalizeListingImageUrl(service.coverPhoto);
+  if (cover && !isOwnerProfileListingImageUrl(cover, service.owner)) {
+    return cover;
+  }
+
+  const firstImage = filterServiceListingMedia(service)[0];
+  return firstImage?.url?.trim() || undefined;
+}