@bash-app/bash-common 30.203.0 → 30.210.0

package/src/index.ts

@@ -4,16 +4,238 @@ export * from "./extendedSchemas.js";
 export * from "./bashFeedTypes.js";
 export * from "./membershipDefinitions.js";
 
-// Re-export commonly used Prisma types
+// 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:
+//   definitions.ts:      YearsOfExperience, EntertainmentServiceType, MusicGenreType, ServiceTypes,
+//                        CompetitionType, JudgingType, BracketType
+//   membershipDefinitions.ts: MembershipTier, ReferralTier, CreditTransactionType
+export {
+  $Enums,
+  AISpecialistFormat,
+  AVTechnicianFormat,
+  AgeRange,
+  AmbashadorApplicationStatus,
+  AudioVisualSupportSubType,
+  AuditAction,
+  AuditCategory,
+  AuditSeverity,
+  BalloonArtFormat,
+  BalloonsFormat,
+  BartenderFormat,
+  BashAssociationType,
+  BashAvailabilityWindow,
+  BashEventDressTags,
+  BashEventSource,
+  BashEventType,
+  BashEventVibeTags,
+  BashFeedReportReason,
+  BashStatus,
+  BeverageCartFormat,
+  BirthdayCityResourceSuggestionStatus,
+  BirthdayCityResourceType,
+  BirthdayDealSuggestionStatus,
+  BirthdayFreebieCategory,
+  BirthdayFreebieExpirationType,
+  BirthdayFreebieSector,
+  BirthdayFreebieSource,
+  BirthdayOfferExpirationType,
+  BirthdayOfferQualityTier,
+  BirthdayOfferSourceType,
+  BookkeepersFormat,
+  CPAsFormat,
+  CateringFormat,
+  CelebrityAppearanceFormat,
+  CenterpiecesFormat,
+  ChairsFormat,
+  ClaimRequestStatus,
+  CleaningSubType,
+  ClubAdminRole,
+  ClubMemberStatus,
+  ConnectionStatus,
+  ConsentType,
+  ConsultantFormat,
+  CreditSourceType,
+  CreditTransactionStatus,
+  CrewHandFormat,
+  CustomSignageFormat,
+  DJLightingFormat,
+  DanceFloorFormat,
+  DayOfWeek,
+  DecorAndDesignSubType,
+  DecoratorFormat,
+  DeepCleaningFormat,
+  DessertBarFormat,
+  DiscountScope,
+  DiscountSourceType,
+  DroneShotsFormat,
+  Education,
+  EmceeFormat,
+  EntityType,
+  EventFormat,
+  EventManagerFormat,
+  EventPlannerFormat,
+  EventPlanningAndManagementSubType,
+  EventServiceType,
+  EventTemplateCategory,
+  ExhibitorBookingStatus,
+  FinancingSubType,
+  FloralFormat,
+  FoodAndBeverageSubType,
+  FoodCartStandFormat,
+  FoodTruckFormat,
+  FurnitureStylingFormat,
+  Gender,
+  GeneratorsFormat,
+  GoProWearerFormat,
+  GraphicDesignerFormat,
+  GreeterFormat,
+  GroupMemberStatus,
+  GroupVisibility,
+  GuestRegistrationFormat,
+  GuestShuttleFormat,
+  InfluencerFormat,
+  InteriorDesignerFormat,
+  InvestmentType,
+  InvestorFormat,
+  LawyersFormat,
+  LightCleaningFormat,
+  LightingFormat,
+  LightingTechFormat,
+  LimoFormat,
+  LinensFormat,
+  LongTermLoanFormat,
+  MediaEditorFormat,
+  MediaProductionAndCreativeSubType,
+  MediaType,
+  NotificationActionType,
+  NotificationPriority,
+  NotificationType,
+  Occupation,
+  OfferClaimStatus,
+  OfferDiscountType,
+  OrganizationType,
+  OtherSubType,
+  PASystemFormat,
+  ParkingManagementFormat,
+  ParticipantStatus,
+  PartyBusFormat,
+  PendingGiftStatus,
+  PhotoBoothFormat,
+  PhotographerFormat,
+  PredictionSource,
+  PredictionType,
+  PricingModel,
+  PricingType,
+  Privacy,
+  PrivateChefFormat,
+  PrizePaymentMethod,
+  PrizePaymentStatus,
+  PrizeType,
+  ProjectorSetupFormat,
+  PromoterFormat,
+  PromotionAndMarketingSubType,
+  RecurrenceEndsType,
+  RecurringFrequency,
+  RedemptionMethod,
+  RentalEquipmentSubType,
+  ReportStatus,
+  ReportingFormat,
+  RewardReportStatus,
+  ScoutTier,
+  SecurityFormat,
+  ServiceAddonCatalogKind,
+  ServiceAddonRequestStatus,
+  ServiceAddonStatus,
+  ServiceAnalyticsEvent,
+  ServiceBookingFeeType,
+  ServiceBookingRateOption,
+  ServiceBookingStatus,
+  ServiceBookingType,
+  ServiceCancellationPolicy,
+  ServiceCategoryRequestStatus,
+  ServiceCondition,
+  ServiceIncludeResponse,
+  ServiceIncludeStatus,
+  ServicePreference,
+  ServiceRatePricingType,
+  ServiceRateType,
+  ServiceStatus,
+  ServiceSubscriptionStatus,
+  Sex,
+  ShortTermLoanFormat,
+  SocialMediaPlatform,
+  SoundEngineerFormat,
+  SpecialOfferType,
+  SponsorBookingStatus,
+  SponsorTier,
+  SponsorType,
+  StaffingSubType,
+  StageTechFormat,
+  StagingFormat,
+  TableStylingFormat,
+  TablesFormat,
+  TaskStatus,
+  TentsFormat,
+  ThankYouCardsFormat,
+  TicketStatus,
+  TransferRequestStatus,
+  TransportationSubType,
+  UserIntent,
+  UserRole,
+  UserStatus,
+  UserSubscriptionStatus,
+  ValetFormat,
+  ValetServiceFormat,
+  VendedProductType,
+  VendorBidStatus,
+  VendorBookingStatus,
+  VendorServiceType,
+  VenuePricingPlan,
+  VideographerFormat,
+  VirtualAssistantFormat,
+  VisibilityPreference,
+  VolunteerServiceStatus,
+  VoteType,
+  VoucherStatus,
+} from "@prisma/client";
+
+// Re-export Prisma model types (type-only, no runtime value)
 export type {
-  Service,
-  Organization,
-  User,
+  AmountOfGuests,
+  AssociatedBash,
+  AssociatedService,
   BashEvent,
+  BashEventPromoCode,
   BashFeedPost,
-  BashAssociationType,
-  Privacy,
-} from '@prisma/client';
+  BlockedUser,
+  CompetitionParticipant,
+  Contact,
+  CustomBashEventType,
+  DocumentID,
+  EventTask,
+  Exhibitor,
+  GoogleReview,
+  Invitation,
+  Link,
+  Media,
+  Organization,
+  Recurrence,
+  Service,
+  ServiceAddon,
+  ServiceBooking,
+  ServiceRate,
+  SocialMediaProfile,
+  Sponsor,
+  StripeAccount,
+  TargetAudience,
+  TaskInvitation,
+  Ticket,
+  TicketTier,
+  User,
+  UserPreferences,
+  UserSubscription,
+  Vendor,
+} from "@prisma/client";
 
 export * from "./utils/addressUtils.js";
 export * from "./utils/apiUtils.js";
@@ -22,6 +244,18 @@ export * from "./utils/awsS3Utils.js";
 export * from "./utils/bashPointsPaymentUtils.js";
 export * from "./utils/contentFilterUtils.js";
 export * from "./utils/dateTimeUtils.js";
+export {
+  getIanaTimezoneFromUsStateCode,
+  isValidIanaTimezone,
+  getIanaTimezoneFromCoordinates,
+  getIanaTimezoneFromLocationStringHints,
+  inferEventTimezoneIana,
+  resolveEventTimezoneIanaForDisplay,
+} from "./utils/eventTimezoneIana.js";
+export type {
+  InferEventTimezoneArgs,
+  ResolveEventTimezoneForDisplayArgs,
+} from "./utils/eventTimezoneIana.js";
 export * from "./utils/displayDateUtils.js";
 export * from "./utils/discountEngine/bestPriceResolver.js";
 export * from "./utils/discountEngine/eligibilityValidator.js";

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

@@ -0,0 +1,92 @@
+import {
+  getIanaTimezoneFromCoordinates,
+  inferEventTimezoneIana,
+  resolveEventTimezoneIanaForDisplay,
+} from "../eventTimezoneIana.js";
+
+describe("eventTimezoneIana", () => {
+  describe("getIanaTimezoneFromCoordinates", () => {
+    it("returns Pacific for San Francisco", () => {
+      expect(getIanaTimezoneFromCoordinates(37.7749, -122.4194)).toBe(
+        "America/Los_Angeles"
+      );
+    });
+
+    it("returns Mountain for Salt Lake City area", () => {
+      expect(getIanaTimezoneFromCoordinates(39.7392, -111.0)).toBe(
+        "America/Denver"
+      );
+    });
+
+    it("returns Central for Chicago", () => {
+      expect(getIanaTimezoneFromCoordinates(41.8781, -87.6298)).toBe(
+        "America/Chicago"
+      );
+    });
+
+    it("returns Eastern for New York", () => {
+      expect(getIanaTimezoneFromCoordinates(40.7128, -74.006)).toBe(
+        "America/New_York"
+      );
+    });
+
+    it("returns Phoenix for Tempe AZ", () => {
+      expect(getIanaTimezoneFromCoordinates(33.4484, -111.94)).toBe(
+        "America/Phoenix"
+      );
+    });
+
+    it("returns null when coordinates are missing", () => {
+      expect(getIanaTimezoneFromCoordinates(null, -122)).toBeNull();
+      expect(getIanaTimezoneFromCoordinates(40, undefined)).toBeNull();
+    });
+
+    it("returns null for Null Island (0, 0)", () => {
+      expect(getIanaTimezoneFromCoordinates(0, 0)).toBeNull();
+    });
+  });
+
+  describe("inferEventTimezoneIana", () => {
+    it("uses US state when coordinates are missing", () => {
+      expect(
+        inferEventTimezoneIana({
+          state: "UT",
+          country: "USA",
+        })
+      ).toBe("America/Denver");
+      expect(
+        inferEventTimezoneIana({
+          state: "AZ",
+          country: "USA",
+        })
+      ).toBe("America/Phoenix");
+    });
+
+    it("falls back to UTC when nothing matches", () => {
+      expect(inferEventTimezoneIana({})).toBe("UTC");
+    });
+  });
+
+  describe("resolveEventTimezoneIanaForDisplay", () => {
+    it("prefers valid stored timezone", () => {
+      expect(
+        resolveEventTimezoneIanaForDisplay({
+          timezone: "America/Los_Angeles",
+          state: "UT",
+          country: "USA",
+        })
+      ).toBe("America/Los_Angeles");
+    });
+
+    it("infers from city/state when timezone is missing", () => {
+      expect(
+        resolveEventTimezoneIanaForDisplay({
+          timezone: null,
+          city: "Ogden",
+          state: "UT",
+          country: "United States",
+        })
+      ).toBe("America/Denver");
+    });
+  });
+});

package/src/utils/eventTimezoneIana.ts

@@ -0,0 +1,331 @@
+import { DateTime } from "luxon";
+
+/** Primary IANA zone for each US state + DC (contiguous conventions; AZ/HI/AK use canonical zones). */
+const US_STATE_CODE_TO_IANA: Record<string, string> = {
+  AL: "America/Chicago",
+  AK: "America/Anchorage",
+  AZ: "America/Phoenix",
+  AR: "America/Chicago",
+  CA: "America/Los_Angeles",
+  CO: "America/Denver",
+  CT: "America/New_York",
+  DE: "America/New_York",
+  DC: "America/New_York",
+  FL: "America/New_York",
+  GA: "America/New_York",
+  HI: "Pacific/Honolulu",
+  ID: "America/Boise",
+  IL: "America/Chicago",
+  IN: "America/Indiana/Indianapolis",
+  IA: "America/Chicago",
+  KS: "America/Chicago",
+  KY: "America/New_York",
+  LA: "America/Chicago",
+  ME: "America/New_York",
+  MD: "America/New_York",
+  MA: "America/New_York",
+  MI: "America/Detroit",
+  MN: "America/Chicago",
+  MS: "America/Chicago",
+  MO: "America/Chicago",
+  MT: "America/Denver",
+  NE: "America/Chicago",
+  NV: "America/Los_Angeles",
+  NH: "America/New_York",
+  NJ: "America/New_York",
+  NM: "America/Denver",
+  NY: "America/New_York",
+  NC: "America/New_York",
+  ND: "America/Chicago",
+  OH: "America/New_York",
+  OK: "America/Chicago",
+  OR: "America/Los_Angeles",
+  PA: "America/New_York",
+  RI: "America/New_York",
+  SC: "America/New_York",
+  SD: "America/Chicago",
+  TN: "America/Chicago",
+  TX: "America/Chicago",
+  UT: "America/Denver",
+  VT: "America/New_York",
+  VA: "America/New_York",
+  WA: "America/Los_Angeles",
+  WV: "America/New_York",
+  WI: "America/Chicago",
+  WY: "America/Denver",
+};
+
+function isUsCountry(country: string | null | undefined): boolean {
+  if (!country?.trim()) return true;
+  const c = country.trim().toLowerCase();
+  return (
+    c === "us" ||
+    c === "usa" ||
+    c === "united states" ||
+    c === "united states of america"
+  );
+}
+
+/**
+ * Maps a US state code (e.g. "UT") to IANA when country is US/unknown.
+ * Returns null if state is missing or not a 2-letter US code.
+ */
+export function getIanaTimezoneFromUsStateCode(
+  state: string | null | undefined,
+  country: string | null | undefined
+): string | null {
+  if (!state?.trim()) return null;
+  const code = state.trim().toUpperCase();
+  if (code.length !== 2) return null;
+  if (!isUsCountry(country)) return null;
+  return US_STATE_CODE_TO_IANA[code] ?? null;
+}
+
+export function isValidIanaTimezone(timezone: string | null | undefined): boolean {
+  const t = timezone?.trim();
+  if (!t) return false;
+  return DateTime.now().setZone(t).isValid;
+}
+
+/**
+ * Longitude/latitude → IANA for common regions. Returns null when coords are missing
+ * or no region matches (caller should fall back to address hints or UTC).
+ */
+export function getIanaTimezoneFromCoordinates(
+  latitude: number | null | undefined,
+  longitude: number | null | undefined
+): string | null {
+  if (
+    latitude === null ||
+    latitude === undefined ||
+    longitude === null ||
+    longitude === undefined
+  ) {
+    return null;
+  }
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+    return null;
+  }
+
+  // Null Island / indeterminate — do not guess a zone from (0, 0).
+  if (latitude === 0 && longitude === 0) {
+    return null;
+  }
+
+  // Hawaii first
+  if (
+    longitude >= -160 &&
+    longitude <= -154 &&
+    latitude >= 18.9 &&
+    latitude <= 22.5
+  ) {
+    return "Pacific/Honolulu";
+  }
+
+  // Alaska / Aleutian
+  if (longitude >= -180 && longitude <= -140) {
+    if (longitude <= -169.5) {
+      return "America/Adak";
+    }
+    return "America/Anchorage";
+  }
+
+  // Continental US — fixed west-to-east bands (avoids misclassifying Mountain vs Central)
+  if (latitude >= 18.9 && latitude <= 71.5388) {
+    if (longitude <= -114) {
+      return "America/Los_Angeles";
+    }
+    if (longitude > -114 && longitude <= -102) {
+      if (
+        latitude >= 31.3 &&
+        latitude <= 37.0 &&
+        longitude >= -114.8 &&
+        longitude <= -109.0
+      ) {
+        return "America/Phoenix";
+      }
+      return "America/Denver";
+    }
+    if (longitude > -102 && longitude <= -87) {
+      return "America/Chicago";
+    }
+    if (longitude > -87 && longitude <= -67) {
+      return "America/New_York";
+    }
+  }
+
+  // Europe / Africa (coarse)
+  if (longitude >= -10 && longitude <= 40) {
+    if (longitude >= -1 && longitude <= 1) {
+      return "Europe/London";
+    }
+    if (longitude >= 1 && longitude <= 3) {
+      return "Europe/Paris";
+    }
+    if (longitude >= 13 && longitude <= 15) {
+      return "Europe/Berlin";
+    }
+    if (longitude >= 20 && longitude <= 30) {
+      return "Europe/Helsinki";
+    }
+  } else if (longitude >= 100 && longitude <= 180) {
+    if (longitude >= 139 && longitude <= 141) {
+      return "Asia/Tokyo";
+    }
+    if (longitude >= 116 && longitude <= 118) {
+      return "Asia/Shanghai";
+    }
+    if (longitude >= 150 && longitude <= 155) {
+      return "Australia/Sydney";
+    }
+    if (longitude >= 115 && longitude <= 120) {
+      return "Australia/Perth";
+    }
+  } else if (longitude >= -80 && longitude <= -30) {
+    if (latitude !== null && latitude !== undefined && latitude >= 45) {
+      if (longitude >= -80 && longitude <= -74) {
+        return "America/Toronto";
+      }
+      if (longitude >= -110 && longitude <= -100) {
+        return "America/Winnipeg";
+      }
+      if (longitude >= -125 && longitude <= -115) {
+        return "America/Vancouver";
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Substring hints for free-text location (pipe-delimited or legacy). Avoids single-letter
+ * state codes like "ut" that false-positive inside unrelated words.
+ */
+export function getIanaTimezoneFromLocationStringHints(
+  location: string | null | undefined
+): string | null {
+  if (!location?.trim()) return null;
+  const locationLower = location.toLowerCase();
+
+  if (
+    locationLower.includes("new jersey") ||
+    /\bnj\b/.test(locationLower) ||
+    locationLower.includes("new york") ||
+    /\bny\b/.test(locationLower) ||
+    locationLower.includes("massachusetts") ||
+    /\bma\b/.test(locationLower) ||
+    locationLower.includes("florida") ||
+    /\bfl\b/.test(locationLower) ||
+    locationLower.includes("georgia") ||
+    /\bga\b/.test(locationLower) ||
+    locationLower.includes("keansburg")
+  ) {
+    return "America/New_York";
+  }
+
+  if (
+    locationLower.includes("california") ||
+    locationLower.includes(", ca") ||
+    locationLower.endsWith(" ca") ||
+    locationLower.includes("washington") ||
+    locationLower.includes(", wa") ||
+    locationLower.endsWith(" wa") ||
+    locationLower.includes("oregon") ||
+    locationLower.includes("nevada") ||
+    /\bnv\b/.test(locationLower)
+  ) {
+    return "America/Los_Angeles";
+  }
+
+  if (
+    locationLower.includes("texas") ||
+    /\btx\b/.test(locationLower) ||
+    locationLower.includes("illinois") ||
+    /\bil\b/.test(locationLower) ||
+    locationLower.includes("chicago")
+  ) {
+    return "America/Chicago";
+  }
+
+  if (locationLower.includes("arizona") || /\baz\b/.test(locationLower)) {
+    return "America/Phoenix";
+  }
+
+  if (
+    locationLower.includes("colorado") ||
+    locationLower.includes(", co") ||
+    locationLower.endsWith(" co") ||
+    locationLower.includes("utah") ||
+    locationLower.includes(", ut") ||
+    locationLower.includes(" ut,") ||
+    locationLower.endsWith(" ut")
+  ) {
+    return "America/Denver";
+  }
+
+  if (locationLower.includes("london") || locationLower.includes("uk")) {
+    return "Europe/London";
+  }
+  if (locationLower.includes("paris") || locationLower.includes("france")) {
+    return "Europe/Paris";
+  }
+  if (locationLower.includes("tokyo") || locationLower.includes("japan")) {
+    return "Asia/Tokyo";
+  }
+
+  return null;
+}
+
+export type InferEventTimezoneArgs = {
+  location?: string | null;
+  latitude?: number | null;
+  longitude?: number | null;
+  city?: string | null;
+  state?: string | null;
+  country?: string | null;
+};
+
+/**
+ * Infer IANA from coordinates, then US state, then location/city string hints.
+ * Never uses the viewer's device timezone. Falls back to UTC.
+ */
+export function inferEventTimezoneIana(args: InferEventTimezoneArgs): string {
+  const fromCoords = getIanaTimezoneFromCoordinates(
+    args.latitude,
+    args.longitude
+  );
+  if (fromCoords) return fromCoords;
+
+  const fromState = getIanaTimezoneFromUsStateCode(args.state, args.country);
+  if (fromState) return fromState;
+
+  const fromLoc = getIanaTimezoneFromLocationStringHints(args.location);
+  if (fromLoc) return fromLoc;
+
+  const cityLine = [args.city, args.state, args.country]
+    .filter((p): p is string => !!p?.trim())
+    .join(", ");
+  const fromCityLine = getIanaTimezoneFromLocationStringHints(cityLine);
+  if (fromCityLine) return fromCityLine;
+
+  return "UTC";
+}
+
+export type ResolveEventTimezoneForDisplayArgs = InferEventTimezoneArgs & {
+  timezone?: string | null;
+};
+
+/**
+ * For public surfaces (e.g. BashCard): prefer a valid stored IANA, then infer from geography.
+ * Never uses the viewer's device timezone.
+ */
+export function resolveEventTimezoneIanaForDisplay(
+  args: ResolveEventTimezoneForDisplayArgs
+): string {
+  const stored = args.timezone?.trim();
+  if (stored && isValidIanaTimezone(stored)) {
+    return stored;
+  }
+  return inferEventTimezoneIana(args);
+}