@bash-app/bash-common 30.246.0 → 30.253.0

package/src/definitions.ts

@@ -1,5 +1,4 @@
 import {
-    AgePolicy,
     BashEventType,
     BracketType,
     CompetitionType,
@@ -18,6 +17,7 @@ import {
     User,
 } from "@prisma/client";
 import type {
+    AgePolicy as AgePolicyEnum,
     BashPassTier,
     BashEventDressTags,
     BashEventVibeTags,
@@ -28,6 +28,7 @@ import type {
 } from "@prisma/client";
 import {
   CheckoutExt,
+  PublicTeaserUser,
   PublicUser,
   ServiceBookingExt,
   type UserExt,
@@ -79,6 +80,15 @@ export const GovIdRetentionPolicy = {
 
 export type GovIdRetentionPolicy = GovIdRetentionPolicyEnum;
 
+/** Mirrors Prisma `AgePolicy` — `@prisma/client` browser bundle omits runtime enum exports. */
+export const AgePolicy = {
+  AllAges: "AllAges",
+  EighteenPlus: "EighteenPlus",
+  TwentyOnePlus: "TwentyOnePlus",
+} as const satisfies Record<AgePolicyEnum, AgePolicyEnum>;
+
+export type AgePolicy = AgePolicyEnum;
+
 export const PASSWORD_MIN_LENGTH = 8 as const;
 export const PASSWORD_REQUIREMENTS_REGEX = new RegExp(
   String.raw`^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&^#])[A-Za-z\d@$!%*?&^#]{${PASSWORD_MIN_LENGTH},}$`
@@ -708,7 +718,7 @@ export interface LoginSession {
 }
 
 export interface AttendeeOfBashEvent {
-  user: PublicUser;
+  user: PublicUser | PublicTeaserUser;
   tickets: Ticket[];
 }
 
@@ -1114,7 +1124,6 @@ export const YearsOfExperienceToString: { [key in YearsOfExperienceEnum]: string
 
 // Export Prisma enums for use in frontend
 export {
-    AgePolicy,
     BracketType,
     CompetitionType,
     EntertainmentServiceType,
@@ -1481,24 +1490,25 @@ const WHOLE_WORD_BASH_LABEL_PLURAL: ReadonlyMap<string, string> = new Map([
 ]);
 
 function pluralizeBashEventSingularLabel(label: string): string {
-  const manual = BASH_EVENT_SINGULAR_LABEL_TO_PLURAL_SECTION.get(label);
+  const t = label.trim();
+  const manual = BASH_EVENT_SINGULAR_LABEL_TO_PLURAL_SECTION.get(t);
   if (manual) return manual;
 
-  const wholeWord = WHOLE_WORD_BASH_LABEL_PLURAL.get(label);
+  const wholeWord = WHOLE_WORD_BASH_LABEL_PLURAL.get(t);
   if (wholeWord) return wholeWord;
 
-  if (label === "Party") return "Parties";
-  if (label.endsWith(" Party")) {
-    return `${label.slice(0, -" Party".length)} Parties`;
+  if (t === "Party") return "Parties";
+  if (t.endsWith(" Party")) {
+    return `${t.slice(0, -" Party".length)} Parties`;
   }
-  if (label.endsWith("-Party")) {
-    return `${label.slice(0, -"-Party".length)}-Parties`;
+  if (t.endsWith("-Party")) {
+    return `${t.slice(0, -"-Party".length)}-Parties`;
   }
-  if (label.endsWith(" Party)")) {
-    return `${label.replace(/ Party\)$/, " Parties)")}`;
+  if (t.endsWith(" Party)")) {
+    return `${t.replace(/ Party\)$/, " Parties)")}`;
   }
-  if (label.endsWith(" Rave")) {
-    return `${label.slice(0, -" Rave".length)} Raves`;
+  if (t.endsWith(" Rave")) {
+    return `${t.slice(0, -" Rave".length)} Raves`;
   }
 
   const replacements: ReadonlyArray<[suffix: string, plural: string]> = [
@@ -1535,8 +1545,8 @@ function pluralizeBashEventSingularLabel(label: string): string {
   ];
 
   for (const [suffix, plural] of replacements) {
-    if (label.endsWith(suffix)) {
-      return `${label.slice(0, -suffix.length)}${plural}`;
+    if (t.endsWith(suffix)) {
+      return `${t.slice(0, -suffix.length)}${plural}`;
     }
   }
 
@@ -1547,32 +1557,85 @@ function pluralizeBashEventSingularLabel(label: string): string {
   //   - a future enum value not yet covered above
   // For all of these, returning the label verbatim is correct. Appending
   // " bashes" produces "Raves bashes" / "Comedy bashes", which reads wrong.
-  return label;
+  return t;
 }
 
 const BASH_EVENT_TYPE_ENUM_VALUES: ReadonlySet<string> = new Set(
   Object.values(BashEventType) as string[]
 );
 
+function resolveCanonicalBashEventTypeKey(raw: string): string | undefined {
+  const t = raw.trim();
+  if (!t) return undefined;
+  if (BASH_EVENT_TYPE_ENUM_VALUES.has(t)) return t;
+  const lower = t.toLowerCase();
+  for (const v of BASH_EVENT_TYPE_ENUM_VALUES) {
+    if (v.toLowerCase() === lower) return v;
+  }
+  return undefined;
+}
+
+/**
+ * When the row key matches a `BashEventTypeToString` value (e.g. "House Party")
+ * but not the Prisma enum literal (`HouseParty`), still pluralize like the enum.
+ */
+function resolveBashEventEnumKeyFromSingularLabel(raw: string): string | undefined {
+  const t = raw.trim();
+  if (!t) return undefined;
+  const lower = t.toLowerCase();
+  for (const enumKey of BASH_EVENT_TYPE_ENUM_VALUES) {
+    const k = enumKey as BashEventType;
+    const label = BashEventTypeToString[k];
+    if (label === t || label.toLowerCase() === lower) return enumKey;
+  }
+  return undefined;
+}
+
+/**
+ * Stable row key for homepage/category grouping when `eventType` may be stored
+ * as a Prisma enum literal (e.g. `HouseParty`) or as the singular UI label
+ * (`House Party`).
+ */
+export function canonicalBashEventRowKey(raw: string): string {
+  const trimmed = raw.trim();
+  if (!trimmed) return trimmed;
+  const enumKey =
+    resolveCanonicalBashEventTypeKey(trimmed) ??
+    resolveBashEventEnumKeyFromSingularLabel(trimmed);
+  if (enumKey != null) return enumKey;
+  return trimmed;
+}
+
 /**
  * Heading shown on the home page row and the `/category/...` page for a bash
  * `eventType` / section key. Uses plural-friendly copy for Prisma
  * `BashEventType` values; keeps synthetic rows and membership tier rows clear.
  */
 export function bashSectionTitleForBashType(bashType: string): string {
-  const synthetic = SYNTHETIC_BASH_SECTION_TITLE[bashType];
+  const raw = bashType.trim();
+  const lower = raw.toLowerCase();
+
+  const synthetic = SYNTHETIC_BASH_SECTION_TITLE[raw];
   if (synthetic != null) return synthetic;
+  if (/\bEvents$/i.test(raw)) return raw;
 
-  if (/\bEvents$/i.test(bashType)) {
-    return bashType;
+  for (const enumKey of BASH_EVENT_TYPE_ENUM_VALUES) {
+    const singular = BashEventTypeToString[enumKey as BashEventType];
+    const pluralHeading = pluralizeBashEventSingularLabel(singular);
+    if (pluralHeading.toLowerCase() === lower) {
+      return pluralHeading;
+    }
   }
 
-  if (BASH_EVENT_TYPE_ENUM_VALUES.has(bashType)) {
-    const singular = BashEventTypeToString[bashType as BashEventType];
+  const enumKey =
+    resolveCanonicalBashEventTypeKey(raw) ??
+    resolveBashEventEnumKeyFromSingularLabel(raw);
+  if (enumKey != null) {
+    const singular = BashEventTypeToString[enumKey as BashEventType];
     return pluralizeBashEventSingularLabel(singular);
   }
 
-  const spaced = insertSpacesInCamelCase(bashType);
+  const spaced = insertSpacesInCamelCase(raw);
   return pluralizeBashEventSingularLabel(spaced);
 }
 

package/src/extendedSchemas.ts

@@ -199,6 +199,25 @@ export const FRONT_END_USER_DATA_TO_SELECT = {
   },
 } satisfies Prisma.UserSelect;
 
+/**
+ * Minimal `User` fields for public teaser surfaces (event detail avatars, checkout rows,
+ * non-privileged attendee rosters). Omits `email` and other account-level PII.
+ */
+export const PUBLIC_TEASER_USER_DATA_TO_SELECT = {
+  id: true,
+  username: true,
+  givenName: true,
+  familyName: true,
+  image: true,
+  imageUpdatedAt: true,
+  uploadedImage: true,
+  uploadedImageUpdatedAt: true,
+} satisfies Prisma.UserSelect;
+
+export type PublicTeaserUser = Prisma.UserGetPayload<{
+  select: typeof PUBLIC_TEASER_USER_DATA_TO_SELECT;
+}>;
+
 export const PRIVATE_USER_ACCOUNT_TO_SELECT = {
   ...FRONT_END_USER_DATA_TO_SELECT,
   /** Self session only — preferred payment rail (Stripe vs Square). */
@@ -213,6 +232,8 @@ export const PRIVATE_USER_ACCOUNT_TO_SELECT = {
   zipCode: true,
   country: true,
   phone: true,
+  /** SMS verification — self account only. */
+  phoneVerifiedAt: true,
   membershipExpiresAt: true,
   bashPassStripeSubscriptionId: true,
   bashPassCurrentPeriodEnd: true,
@@ -1287,7 +1308,8 @@ export type TicketFlexible = Ticket & {
 };
 
 export interface CheckoutExt extends Checkout {
-  owner: PublicUser;
+  /** Full owner row for hosts/organizers; teaser row (no email) for other authenticated viewers. */
+  owner: PublicUser | PublicTeaserUser;
   tickets: Ticket[];
 }
 
@@ -1302,6 +1324,18 @@ export const CHECKOUT_DATA_TO_INCLUDE = {
   },
 } satisfies Prisma.CheckoutInclude;
 
+/** Checkout list for non-privileged viewers — buyer email omitted on `owner`. */
+export const CHECKOUT_DATA_TO_INCLUDE_TEASER_OWNER = {
+  owner: {
+    select: PUBLIC_TEASER_USER_DATA_TO_SELECT,
+  },
+  tickets: {
+    select: {
+      ownerId: true,
+    },
+  },
+} satisfies Prisma.CheckoutInclude;
+
 export interface ReviewExt extends Review {
   comments?: BashComment[];
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./definitions.js";
+export * from "./sms/smsTemplates.js";
 export * from "./legalTemplates.js";
 export * from "./utmAttribution.js";
 export * from "./venueLoyaltyRedemption.js";

package/src/sms/smsTemplates.ts

@@ -0,0 +1,20 @@
+/**
+ * System SMS template keys — bodies are rendered in the API (URLs, env).
+ * Consumers use these keys for type-safe `sendTemplatedSms` calls.
+ */
+export const SMS_TEMPLATE_KEYS = [
+  "EVENT_REMINDER_1H",
+  "EVENT_VENUE_CHANGED",
+  "EVENT_WAITLIST_APPROVED",
+  "TICKET_CONFIRMED",
+] as const;
+
+export type SmsTemplateKey = (typeof SMS_TEMPLATE_KEYS)[number];
+
+/** Typed context per template (API maps these to final message strings). */
+export type SmsTemplateContext = {
+  EVENT_REMINDER_1H: { eventTitle: string; shortUrl: string };
+  EVENT_VENUE_CHANGED: { eventTitle: string; shortUrl: string };
+  EVENT_WAITLIST_APPROVED: { eventTitle: string; shortUrl: string };
+  TICKET_CONFIRMED: { eventTitle: string; ticketCount: number; ticketsUrl?: string };
+};

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

@@ -0,0 +1,176 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  addressHasEnoughDataForGeolocation,
+  addressValuesToDatabaseAddressString,
+  databaseAddressStringToAddressValues,
+  formatLocalityForCardDisplay,
+  databaseAddressStringToOneLineString,
+  databaseAddressStringToDisplayString,
+  addressToDisplayString,
+  extractAddressComponents,
+} from "../addressUtils.js";
+
+describe("addressUtils", () => {
+  describe("addressHasEnoughDataForGeolocation", () => {
+    test("returns true when place, city, and state are set", () => {
+      expect(
+        addressHasEnoughDataForGeolocation({
+          place: "Madison Square Garden",
+          city: "New York",
+          state: "NY",
+        } as any)
+      ).toBe(true);
+    });
+
+    test("returns true when street, city, and state are set", () => {
+      expect(
+        addressHasEnoughDataForGeolocation({
+          street: "4 Pennsylvania Plaza",
+          city: "New York",
+          state: "NY",
+        } as any)
+      ).toBe(true);
+    });
+
+    test("returns false when city or state is missing", () => {
+      expect(
+        addressHasEnoughDataForGeolocation({ place: "Venue", city: "NYC", state: "" } as any)
+      ).toBe(false);
+    });
+  });
+
+  describe("addressValuesToDatabaseAddressString", () => {
+    test("joins fields with pipe delimiter", () => {
+      expect(
+        addressValuesToDatabaseAddressString({
+          place: "The Loft",
+          street: "123 Main St",
+          city: "Brooklyn",
+          state: "NY",
+          zipCode: "11201",
+          country: "USA",
+        })
+      ).toBe("The Loft|123 Main St|Brooklyn|NY|11201|USA");
+    });
+  });
+
+  describe("databaseAddressStringToAddressValues", () => {
+    test("parses pipe-delimited strings", () => {
+      expect(databaseAddressStringToAddressValues("Venue|1 Ave|NYC|NY|10001|USA")).toEqual({
+        place: "Venue",
+        street: "1 Ave",
+        city: "NYC",
+        state: "NY",
+        zipCode: "10001",
+        country: "USA",
+      });
+    });
+
+    test("parses legacy bullet-delimited 5-part strings", () => {
+      expect(
+        databaseAddressStringToAddressValues("123 Main St • Brooklyn • NY • 11201 • USA")
+      ).toEqual({
+        place: "",
+        street: "123 Main St",
+        city: "Brooklyn",
+        state: "NY",
+        zipCode: "11201",
+        country: "USA",
+      });
+    });
+
+    test("treats undelimited string as place-only", () => {
+      expect(databaseAddressStringToAddressValues("Central Park")).toEqual({
+        place: "Central Park",
+        street: "",
+        city: "",
+        state: "",
+        zipCode: "",
+        country: "",
+      });
+    });
+
+    test("returns empty address for null/undefined", () => {
+      expect(databaseAddressStringToAddressValues(null)).toEqual({
+        place: "",
+        street: "",
+        city: "",
+        state: "",
+        zipCode: "",
+        country: "",
+      });
+    });
+  });
+
+  describe("formatLocalityForCardDisplay", () => {
+    test("joins city, state, and country", () => {
+      expect(formatLocalityForCardDisplay("Brooklyn", "NY", "USA")).toBe("Brooklyn, NY, USA");
+    });
+
+    test("skips empty parts", () => {
+      expect(formatLocalityForCardDisplay("Austin", null, "USA")).toBe("Austin, USA");
+    });
+  });
+
+  describe("databaseAddressStringToOneLineString", () => {
+    test("formats full pipe-delimited address", () => {
+      const db = addressValuesToDatabaseAddressString({
+        place: "Rooftop Bar",
+        street: "99 King St",
+        city: "Seattle",
+        state: "WA",
+        zipCode: "98101",
+        country: "USA",
+      });
+      expect(databaseAddressStringToOneLineString(db)).toBe(
+        "Rooftop Bar, 99 King St, Seattle, WA 98101"
+      );
+    });
+
+    test("returns place-only for undelimited strings", () => {
+      expect(databaseAddressStringToOneLineString("Secret Warehouse")).toBe("Secret Warehouse");
+    });
+  });
+
+  describe("addressToDisplayString", () => {
+    test("builds comma-separated line with zip", () => {
+      expect(
+        addressToDisplayString({
+          place: "Studio",
+          street: "5th Ave",
+          city: "NYC",
+          state: "NY",
+          zipCode: "10003",
+          country: "USA",
+        })
+      ).toBe("Studio, 5th Ave, NYC, NY 10003");
+    });
+  });
+
+  describe("extractAddressComponents", () => {
+    test("maps Google place components to IAddress", () => {
+      expect(
+        extractAddressComponents({
+          place_id: "place-123",
+          name: "Bash HQ",
+          address_components: [
+            { types: ["street_number"], long_name: "100", short_name: "100" },
+            { types: ["route"], long_name: "Broadway", short_name: "Broadway" },
+            { types: ["locality"], long_name: "New York", short_name: "New York" },
+            { types: ["administrative_area_level_1"], long_name: "New York", short_name: "NY" },
+            { types: ["postal_code"], long_name: "10005", short_name: "10005" },
+            { types: ["country"], long_name: "United States", short_name: "US" },
+          ],
+        })
+      ).toEqual({
+        googlePlaceId: "place-123",
+        place: "Bash HQ",
+        street: "100 Broadway",
+        city: "New York",
+        state: "NY",
+        zipCode: "10005",
+        country: "United States",
+      });
+    });
+  });
+});

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

@@ -0,0 +1,219 @@
+/**
+ * Tests for shared contact/user helpers and environment detection.
+ */
+
+import { describe, expect, test, beforeEach, afterEach } from "@jest/globals";
+import {
+  getUserName,
+  getUserImage,
+  isContactAndNotUser,
+  getContactOrUserEmail,
+  getUserIdAndNotContactId,
+  getBashEventDetailUrlParamsFromBashEvent,
+  isProduction,
+} from "../apiUtils.js";
+
+describe("apiUtils", () => {
+  describe("isContactAndNotUser", () => {
+    test("returns true when contactOwnerId is set", () => {
+      expect(isContactAndNotUser({ contactOwnerId: "owner-1", fullName: "Jane" })).toBe(true);
+    });
+
+    test("returns false for user-shaped objects", () => {
+      expect(isContactAndNotUser({ id: "user-1", email: "jane@example.com" })).toBe(false);
+    });
+  });
+
+  describe("getUserName", () => {
+    test("returns empty string for undefined", () => {
+      expect(getUserName(undefined)).toBe("");
+    });
+
+    test("returns contact fullName when present", () => {
+      expect(
+        getUserName({ contactOwnerId: "owner-1", fullName: "Jane Contact", contactEmail: "j@x.com" })
+      ).toBe("Jane Contact");
+    });
+
+    test("falls back to contactEmail for contacts without fullName", () => {
+      expect(getUserName({ contactOwnerId: "owner-1", contactEmail: "j@x.com" })).toBe("j@x.com");
+    });
+
+    test("combines givenName and familyName for users", () => {
+      expect(getUserName({ givenName: "Jane", familyName: "Doe", email: "j@x.com" })).toBe("Jane Doe");
+    });
+
+    test("falls back to email when name parts missing", () => {
+      expect(getUserName({ email: "solo@example.com" })).toBe("solo@example.com");
+    });
+  });
+
+  describe("getUserImage", () => {
+    const noProfilePicture = "/noProfilePicture.svg";
+
+    test("returns empty string for undefined", () => {
+      expect(getUserImage(undefined)).toBe("");
+    });
+
+    test("returns placeholder for contacts", () => {
+      expect(getUserImage({ contactOwnerId: "owner-1", fullName: "Jane" })).toBe(noProfilePicture);
+    });
+
+    test("returns uploaded image when only upload exists", () => {
+      expect(getUserImage({ uploadedImage: "https://cdn.example/upload.jpg" })).toBe(
+        "https://cdn.example/upload.jpg"
+      );
+    });
+
+    test("returns google image when only google image exists", () => {
+      expect(getUserImage({ image: "https://lh3.google.com/photo.jpg" })).toBe(
+        "https://lh3.google.com/photo.jpg"
+      );
+    });
+
+    test("treats whitespace-only image URLs as missing", () => {
+      expect(getUserImage({ uploadedImage: "   ", image: "https://google.com/p.jpg" })).toBe(
+        "https://google.com/p.jpg"
+      );
+    });
+
+    test("prefers most recently updated image when both exist", () => {
+      const older = new Date("2024-01-01");
+      const newer = new Date("2024-06-01");
+      expect(
+        getUserImage({
+          uploadedImage: "https://cdn.example/upload.jpg",
+          uploadedImageUpdatedAt: newer,
+          image: "https://lh3.google.com/photo.jpg",
+          imageUpdatedAt: older,
+        })
+      ).toBe("https://cdn.example/upload.jpg");
+      expect(
+        getUserImage({
+          uploadedImage: "https://cdn.example/upload.jpg",
+          uploadedImageUpdatedAt: older,
+          image: "https://lh3.google.com/photo.jpg",
+          imageUpdatedAt: newer,
+        })
+      ).toBe("https://lh3.google.com/photo.jpg");
+    });
+
+    test("falls back to uploadedImage when both exist without timestamps", () => {
+      expect(
+        getUserImage({
+          uploadedImage: "https://cdn.example/upload.jpg",
+          image: "https://lh3.google.com/photo.jpg",
+        })
+      ).toBe("https://cdn.example/upload.jpg");
+    });
+
+    test("returns placeholder when user has no images", () => {
+      expect(getUserImage({ email: "j@x.com" })).toBe(noProfilePicture);
+    });
+  });
+
+  describe("getContactOrUserEmail", () => {
+    test("returns contactEmail for contacts", () => {
+      expect(getContactOrUserEmail({ contactOwnerId: "o1", contactEmail: "c@x.com" })).toBe("c@x.com");
+    });
+
+    test("returns email for users", () => {
+      expect(getContactOrUserEmail({ id: "u1", email: "u@x.com" })).toBe("u@x.com");
+    });
+  });
+
+  describe("getUserIdAndNotContactId", () => {
+    test("returns null for contacts", () => {
+      expect(getUserIdAndNotContactId({ contactOwnerId: "o1" })).toBeNull();
+    });
+
+    test("returns user id for users", () => {
+      expect(getUserIdAndNotContactId({ id: "user-42" })).toBe("user-42");
+    });
+  });
+
+  describe("getBashEventDetailUrlParamsFromBashEvent", () => {
+    test("returns empty string for undefined event", () => {
+      expect(getBashEventDetailUrlParamsFromBashEvent(undefined)).toBe("");
+    });
+
+    test("returns empty string when title/desc/cover are absent", () => {
+      expect(
+        getBashEventDetailUrlParamsFromBashEvent({
+          title: "",
+          description: null,
+          coverPhoto: null,
+        } as any)
+      ).toBe("");
+    });
+
+    test("truncates long descriptions before building params", () => {
+      const longDesc = "abcdefghijklmnop";
+      const result = getBashEventDetailUrlParamsFromBashEvent(
+        { title: "Party", description: longDesc, coverPhoto: null } as any,
+        "cover.jpg"
+      );
+      expect(result).toBe("");
+    });
+  });
+
+  describe("isProduction", () => {
+    const envKeys = ["NODE_ENV", "ENVIRONMENT", "BASH_ENV"] as const;
+    const saved: Partial<Record<(typeof envKeys)[number], string | undefined>> = {};
+
+    beforeEach(() => {
+      for (const key of envKeys) {
+        saved[key] = process.env[key];
+      }
+    });
+
+    afterEach(() => {
+      for (const key of envKeys) {
+        if (saved[key] === undefined) {
+          delete process.env[key];
+        } else {
+          process.env[key] = saved[key];
+        }
+      }
+    });
+
+    test("returns false when ENVIRONMENT contains qa", () => {
+      process.env.NODE_ENV = "production";
+      process.env.ENVIRONMENT = "qa-staging";
+      expect(isProduction()).toBe(false);
+    });
+
+    test("returns false when BASH_ENV contains qa", () => {
+      process.env.NODE_ENV = "production";
+      process.env.BASH_ENV = "QA";
+      expect(isProduction()).toBe(false);
+    });
+
+    test("returns true only when NODE_ENV is production and env is explicitly production", () => {
+      process.env.NODE_ENV = "production";
+      process.env.ENVIRONMENT = "production";
+      delete process.env.BASH_ENV;
+      expect(isProduction()).toBe(true);
+    });
+
+    test("returns true when BASH_ENV is production", () => {
+      process.env.NODE_ENV = "production";
+      delete process.env.ENVIRONMENT;
+      process.env.BASH_ENV = "production";
+      expect(isProduction()).toBe(true);
+    });
+
+    test("returns false in development even with production env vars", () => {
+      process.env.NODE_ENV = "development";
+      process.env.ENVIRONMENT = "production";
+      expect(isProduction()).toBe(false);
+    });
+
+    test("returns false when NODE_ENV is production but env vars are unset", () => {
+      process.env.NODE_ENV = "production";
+      delete process.env.ENVIRONMENT;
+      delete process.env.BASH_ENV;
+      expect(isProduction()).toBe(false);
+    });
+  });
+});