@bash-app/bash-common 30.247.0 → 30.253.0

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

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "@jest/globals";
+import { DateTime } from "luxon";
+import { ticketListToString, ticketListStrToTicketList } from "../ticketListUtils.js";
+import type { NumberOfTicketsForDate } from "../../definitions.js";
+
+describe("ticketListUtils", () => {
+  const isoDate = "2024-07-04T18:00:00.000Z";
+
+  test("round-trips ticket list through base64 encoding", () => {
+    const ticketList = new Map<string, NumberOfTicketsForDate[]>([
+      [
+        "tier-abc",
+        [
+          { numberOfTickets: 2, ticketDateTime: isoDate },
+          { numberOfTickets: 1, ticketDateTime: isoDate },
+        ],
+      ],
+      ["tier-xyz", [{ numberOfTickets: 3, ticketDateTime: isoDate }]],
+    ]);
+
+    const encoded = ticketListToString(ticketList);
+    expect(encoded).not.toContain("+");
+    expect(encoded).not.toContain("/");
+
+    const decoded = ticketListStrToTicketList(encoded);
+    expect(decoded.size).toBe(2);
+    expect(decoded.get("tier-abc")).toHaveLength(2);
+    expect(decoded.get("tier-abc")![0].numberOfTickets).toBe(2);
+    expect(decoded.get("tier-xyz")![0].numberOfTickets).toBe(3);
+  });
+
+  test("omits tiers with zero tickets", () => {
+    const ticketList = new Map<string, NumberOfTicketsForDate[]>([
+      ["tier-empty", [{ numberOfTickets: 0, ticketDateTime: isoDate }]],
+      ["tier-live", [{ numberOfTickets: 1, ticketDateTime: isoDate }]],
+    ]);
+    const decoded = ticketListStrToTicketList(ticketListToString(ticketList));
+    expect(decoded.has("tier-empty")).toBe(false);
+    expect(decoded.get("tier-live")).toHaveLength(1);
+  });
+
+  test("decodes legacy plain strings for backward compatibility", () => {
+    const plain = `tier1__2;;${DateTime.fromISO(isoDate).toISO()}~~`;
+    const decoded = ticketListStrToTicketList(plain);
+    expect(decoded.get("tier1")![0].numberOfTickets).toBe(2);
+  });
+});

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

@@ -0,0 +1,12 @@
+import { describe, expect, test } from "@jest/globals";
+import { createAllTrueObject } from "../typeUtils.js";
+
+describe("createAllTrueObject", () => {
+  test("maps every key to true", () => {
+    expect(createAllTrueObject(["a", "b", "c"])).toEqual({ a: true, b: true, c: true });
+  });
+
+  test("returns empty object for empty key list", () => {
+    expect(createAllTrueObject([])).toEqual({});
+  });
+});

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

@@ -0,0 +1,87 @@
+/**
+ * Tests for service subscription tier mappings.
+ */
+
+import { ServiceTypes, MembershipTier } from "@prisma/client";
+import { describe, expect, test } from "@jest/globals";
+import {
+  SERVICE_TIER_TO_SERVICES_LIST,
+  SERVICE_TIER_FROM_SERVICE_TYPE,
+  USER_SUBSCRIPTION_TYPES,
+  ServiceSubscriptionTier,
+} from "../userSubscriptionUtils.js";
+
+describe("userSubscriptionUtils", () => {
+  describe("SERVICE_TIER_TO_SERVICES_LIST", () => {
+    test("Free and Ally tiers include event and entertainment services", () => {
+      expect(SERVICE_TIER_TO_SERVICES_LIST.Free).toEqual([
+        ServiceTypes.EventServices,
+        ServiceTypes.EntertainmentServices,
+      ]);
+      expect(SERVICE_TIER_TO_SERVICES_LIST.Ally).toEqual([
+        ServiceTypes.EventServices,
+        ServiceTypes.EntertainmentServices,
+      ]);
+    });
+
+    test("Partner and Patron tiers map to vendor and venue service groups", () => {
+      expect(SERVICE_TIER_TO_SERVICES_LIST.Partner).toEqual([
+        ServiceTypes.Vendors,
+        ServiceTypes.Exhibitors,
+        ServiceTypes.Sponsors,
+      ]);
+      expect(SERVICE_TIER_TO_SERVICES_LIST.Patron).toEqual([
+        ServiceTypes.Venues,
+        ServiceTypes.Organizations,
+      ]);
+    });
+  });
+
+  describe("SERVICE_TIER_FROM_SERVICE_TYPE", () => {
+    test("maps all service types listed in tier config", () => {
+      const configuredTypes = Object.values(SERVICE_TIER_TO_SERVICES_LIST).flat();
+      for (const serviceType of configuredTypes) {
+        expect(SERVICE_TIER_FROM_SERVICE_TYPE[serviceType]).toBeDefined();
+      }
+    });
+
+    test("defaults EventServices and EntertainmentServices to Free", () => {
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.EventServices]).toBe(
+        ServiceSubscriptionTier.Free
+      );
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.EntertainmentServices]).toBe(
+        ServiceSubscriptionTier.Free
+      );
+    });
+
+    test("maps vendor-related types to Partner", () => {
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Vendors]).toBe(ServiceSubscriptionTier.Partner);
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Exhibitors]).toBe(
+        ServiceSubscriptionTier.Partner
+      );
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Sponsors]).toBe(ServiceSubscriptionTier.Partner);
+    });
+
+    test("maps venue-related types to Patron", () => {
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Venues]).toBe(ServiceSubscriptionTier.Patron);
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Organizations]).toBe(
+        ServiceSubscriptionTier.Patron
+      );
+    });
+  });
+
+  describe("USER_SUBSCRIPTION_TYPES", () => {
+    test("Basic tier is free and typed as MembershipTier.Basic", () => {
+      expect(USER_SUBSCRIPTION_TYPES.Basic).toEqual({
+        name: "Basic",
+        description: "Basic",
+        price: 0,
+        type: MembershipTier.Basic,
+      });
+    });
+
+    test("only Basic tier is currently defined", () => {
+      expect(Object.keys(USER_SUBSCRIPTION_TYPES)).toEqual(["Basic"]);
+    });
+  });
+});

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

@@ -0,0 +1,41 @@
+import { Gender } from "@prisma/client";
+import { describe, expect, test } from "@jest/globals";
+import { getDisplayGender, type GenderDisplayUser } from "../userUtils.js";
+
+describe("getDisplayGender", () => {
+  test("returns trimmed genderIdentity when present", () => {
+    const user: GenderDisplayUser = {
+      gender: Gender.Male,
+      genderIdentity: "  Non-binary  ",
+    };
+    expect(getDisplayGender(user)).toBe("Non-binary");
+  });
+
+  test("genderIdentity wins over gender enum", () => {
+    const user: GenderDisplayUser = {
+      gender: Gender.Female,
+      genderIdentity: "Genderfluid",
+    };
+    expect(getDisplayGender(user)).toBe("Genderfluid");
+  });
+
+  test("returns gender enum when genderIdentity is absent", () => {
+    expect(getDisplayGender({ gender: Gender.Male })).toBe(Gender.Male);
+    expect(getDisplayGender({ gender: Gender.Female })).toBe(Gender.Female);
+  });
+
+  test("returns null when genderIdentity is blank whitespace", () => {
+    expect(getDisplayGender({ genderIdentity: "   ", gender: Gender.Male })).toBe(
+      Gender.Male
+    );
+  });
+
+  test("returns null when neither field is set", () => {
+    expect(getDisplayGender({})).toBeNull();
+    expect(getDisplayGender({ gender: null, genderIdentity: null })).toBeNull();
+  });
+
+  test("returns null when genderIdentity is empty and gender is null", () => {
+    expect(getDisplayGender({ genderIdentity: "", gender: null })).toBeNull();
+  });
+});

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

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "@jest/globals";
+import { formatVenueType, formatVenueTypes } from "../venueTypeFormatter.js";
+
+describe("venueTypeFormatter", () => {
+  describe("formatVenueType", () => {
+    test("inserts spaces before capital letters", () => {
+      expect(formatVenueType("OutdoorSpace")).toBe("Outdoor Space");
+      expect(formatVenueType("WeddingVenue")).toBe("Wedding Venue");
+    });
+
+    test("returns empty string for falsy input", () => {
+      expect(formatVenueType("")).toBe("");
+    });
+  });
+
+  describe("formatVenueTypes", () => {
+    test("formats up to maxDisplay types", () => {
+      expect(formatVenueTypes(["Restaurant", "Bar"], 2)).toBe("Restaurant, Bar");
+    });
+
+    test("appends +N more when truncated", () => {
+      expect(formatVenueTypes(["Restaurant", "Bar", "Nightclub", "Rooftop"], 2)).toBe(
+        "Restaurant, Bar +2 more"
+      );
+    });
+
+    test("returns empty string for empty array", () => {
+      expect(formatVenueTypes([])).toBe("");
+    });
+  });
+});

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

@@ -0,0 +1,66 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  isPositiveInt,
+  isPositiveFloat,
+  isPrice,
+  isUrlInputtingProtocol,
+  isUrl,
+} from "../regexUtils.js";
+
+describe("regexUtils", () => {
+  describe("isPositiveInt", () => {
+    test("accepts digits and empty string", () => {
+      expect(isPositiveInt("123")).toBe(true);
+      expect(isPositiveInt("")).toBe(true);
+    });
+
+    test("rejects non-digit characters", () => {
+      expect(isPositiveInt("12a")).toBe(false);
+      expect(isPositiveInt("-1")).toBe(false);
+    });
+  });
+
+  describe("isPositiveFloat", () => {
+    test("accepts decimal numbers", () => {
+      expect(isPositiveFloat("12.5")).toBe(true);
+      expect(isPositiveFloat("0.")).toBe(true);
+    });
+
+    test("rejects letters", () => {
+      expect(isPositiveFloat("1.2.3")).toBe(false);
+    });
+  });
+
+  describe("isPrice", () => {
+    test("allows up to two decimal places", () => {
+      expect(isPrice("19.99")).toBe(true);
+      expect(isPrice("100")).toBe(true);
+    });
+
+    test("rejects more than two decimal places", () => {
+      expect(isPrice("1.999")).toBe(false);
+    });
+  });
+
+  describe("isUrlInputtingProtocol", () => {
+    test("matches partial protocol typing", () => {
+      expect(isUrlInputtingProtocol("https://")).toBe(true);
+      expect(isUrlInputtingProtocol("htt")).toBe(true);
+    });
+
+    test("rejects random text", () => {
+      expect(isUrlInputtingProtocol("example.com")).toBe(false);
+    });
+  });
+
+  describe("isUrl", () => {
+    test("accepts http(s) URLs and bare domains", () => {
+      expect(isUrl("https://bash.events")).toBe(true);
+      expect(isUrl("bash.events")).toBe(true);
+    });
+
+    test("rejects strings with spaces", () => {
+      expect(isUrl("not a url")).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "@jest/globals";
+import { serviceFromDb, serviceToDb } from "../serviceDBUtils.js";
+
+describe("serviceDBUtils", () => {
+  test("serviceFromDb returns the same reference (identity transform)", () => {
+    const service = { id: "svc-1", serviceName: "Test" } as any;
+    expect(serviceFromDb(service)).toBe(service);
+  });
+
+  test("serviceFromDb passes through null and undefined", () => {
+    expect(serviceFromDb(null)).toBeNull();
+    expect(serviceFromDb(undefined)).toBeUndefined();
+  });
+
+  test("serviceToDb returns the same partial payload", () => {
+    const partial = { tagline: "Hello" };
+    expect(serviceToDb(partial)).toBe(partial);
+  });
+});

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

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  compareFeaturedServices,
+  MIN_FEATURED_SERVICES_FOR_SECTION,
+} from "../serviceFeaturedSortUtils.js";
+
+describe("serviceFeaturedSortUtils", () => {
+  const now = new Date("2024-06-15T12:00:00Z");
+  const cmp = compareFeaturedServices(now);
+
+  test("ranks paid features above auto-featured and unfeatured", () => {
+    const paid = {
+      isFeaturedService: true,
+      featuredServiceUntil: new Date("2025-01-01"),
+      featuredAt: new Date("2024-01-01"),
+      featuredReason: "Paid" as const,
+      createdAt: new Date("2023-01-01"),
+    };
+    const auto = {
+      isFeaturedService: true,
+      featuredServiceUntil: new Date("2025-01-01"),
+      featuredAt: new Date("2024-02-01"),
+      featuredReason: "AutoNewService" as const,
+      createdAt: new Date("2024-05-01"),
+    };
+    const plain = {
+      isFeaturedService: false,
+      createdAt: new Date("2024-06-01"),
+    };
+    expect(cmp(paid, auto)).toBeLessThan(0);
+    expect(cmp(auto, plain)).toBeLessThan(0);
+  });
+
+  test("sorts paid tier FIFO by featuredAt ascending", () => {
+    const earlier = {
+      isFeaturedService: true,
+      featuredServiceUntil: new Date("2025-01-01"),
+      featuredAt: new Date("2024-01-01"),
+      featuredReason: "Admin" as const,
+      createdAt: new Date("2023-01-01"),
+    };
+    const later = {
+      ...earlier,
+      featuredAt: new Date("2024-03-01"),
+    };
+    expect(cmp(earlier, later)).toBeLessThan(0);
+  });
+
+  test("treats expired featuredUntil as unfeatured tier", () => {
+    const expired = {
+      isFeaturedService: true,
+      featuredServiceUntil: new Date("2024-01-01"),
+      featuredAt: new Date("2023-01-01"),
+      featuredReason: "Paid" as const,
+      createdAt: new Date("2024-06-01"),
+    };
+    const active = {
+      isFeaturedService: false,
+      createdAt: new Date("2024-05-01"),
+    };
+    expect(cmp(expired, active)).toBeGreaterThan(0);
+  });
+
+  test("exports homepage carousel floor constant", () => {
+    expect(MIN_FEATURED_SERVICES_FOR_SECTION).toBe(3);
+  });
+});

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

@@ -0,0 +1,190 @@
+import { describe, expect, test } from "@jest/globals";
+import { ServiceSubscriptionStatus, ServiceTypes } from "@prisma/client";
+import {
+  serviceSubscriptionIsActive,
+  serviceGetSpecificType,
+  serviceDetailUrl,
+  serviceWizardUrl,
+  partnerServiceProfileWizardPaymentMethodUrl,
+  venueWizardLoyaltyBuilderUrl,
+  serviceCheckoutUrl,
+  serviceTypeToField,
+  aiServiceInfoToInfoString,
+  aiServiceInfoToExampleString,
+  buildAIFieldsString,
+  serviceRelevantData,
+  serviceExcludeIds,
+  serviceExcludeOwners,
+  serviceGetInfoAI,
+  getVendorSalesLabel,
+  SERVICE_CANCELLATION_POLICY_DATA,
+  PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_MAJOR_STEP,
+  VENUE_WIZARD_LOYALTY_MAJOR_STEP,
+} from "../serviceUtils.js";
+
+describe("serviceUtils", () => {
+  describe("serviceSubscriptionIsActive", () => {
+    test("returns true for Normal and Trialing", () => {
+      expect(serviceSubscriptionIsActive(ServiceSubscriptionStatus.Normal)).toBe(true);
+      expect(serviceSubscriptionIsActive(ServiceSubscriptionStatus.Trialing)).toBe(true);
+    });
+
+    test("returns false for canceled statuses", () => {
+      expect(serviceSubscriptionIsActive(ServiceSubscriptionStatus.None)).toBe(false);
+    });
+  });
+
+  describe("serviceGetSpecificType", () => {
+    test("maps venue service to venueId", () => {
+      expect(
+        serviceGetSpecificType({
+          id: "svc-1",
+          serviceType: ServiceTypes.Venues,
+          venueId: "venue-99",
+        } as any)
+      ).toEqual({
+        serviceId: "svc-1",
+        serviceType: ServiceTypes.Venues,
+        specificFieldName: "venue",
+        specificId: "venue-99",
+      });
+    });
+
+    test("returns null when serviceType is missing", () => {
+      expect(serviceGetSpecificType({ id: "svc-1" } as any)).toBeNull();
+    });
+  });
+
+  describe("URL builders", () => {
+    test("serviceDetailUrl", () => {
+      expect(serviceDetailUrl("s1", "Venues", "v1")).toBe("/services/s1/Venues/v1");
+    });
+
+    test("serviceWizardUrl includes step indices", () => {
+      expect(serviceWizardUrl("s1", "Vendors", "v1", 2, 1)).toBe(
+        "/wz/services/s1/Vendors/v1/2/1"
+      );
+    });
+
+    test("partnerServiceProfileWizardPaymentMethodUrl uses payment step constants", () => {
+      expect(partnerServiceProfileWizardPaymentMethodUrl("s1", "Vendors", "v1")).toBe(
+        `/wz/services/s1/Vendors/v1/${PARTNER_SERVICE_PROFILE_WIZARD_PAYMENT_METHOD_MAJOR_STEP}/3`
+      );
+    });
+
+    test("venueWizardLoyaltyBuilderUrl uses loyalty major step", () => {
+      expect(venueWizardLoyaltyBuilderUrl("s1", "Venues", "v1")).toBe(
+        `/wz/services/s1/Venues/v1/${VENUE_WIZARD_LOYALTY_MAJOR_STEP}/0`
+      );
+    });
+
+    test("serviceCheckoutUrl", () => {
+      expect(serviceCheckoutUrl("s1", "Venues", "v1")).toBe("/checkout/services/s1/Venues/v1");
+    });
+  });
+
+  describe("serviceTypeToField", () => {
+    test("maps enum to specific relation key", () => {
+      expect(serviceTypeToField(ServiceTypes.Vendors)).toBe("vendor");
+      expect(serviceTypeToField(ServiceTypes.EntertainmentServices)).toBe("entertainmentService");
+    });
+  });
+
+  describe("AI string helpers", () => {
+    const info = {
+      description: "Venue name",
+      example: "The Loft",
+      type: "string" as const,
+      isArray: false,
+    };
+
+    test("aiServiceInfoToInfoString", () => {
+      expect(aiServiceInfoToInfoString("serviceName", info)).toBe(
+        "serviceName: Venue name - string"
+      );
+    });
+
+    test("aiServiceInfoToExampleString marks arrays", () => {
+      expect(
+        aiServiceInfoToExampleString("tags", { ...info, isArray: true, example: '["A"]' })
+      ).toBe('tags: ["A"] - string[]');
+    });
+
+    test("buildAIFieldsString formats values and missing keys", () => {
+      const out = buildAIFieldsString(
+        { capacity: 150, vibe: null },
+        {
+          capacity: { description: "cap", example: "100", type: "integer", isArray: false },
+          vibe: { description: "vibe", example: "Chill", type: "string", isArray: false },
+        }
+      );
+      expect(out).toContain("capacity: 150");
+      expect(out).toContain("vibe: No vibe provided");
+    });
+  });
+
+  describe("serviceRelevantData", () => {
+    test("strips ids, owners, rates, dates, and misc fields", () => {
+      const result = serviceRelevantData({
+        id: "svc-1",
+        ownerId: "u1",
+        creatorId: "u2",
+        serviceName: "Hidden",
+        serviceType: ServiceTypes.Venues,
+        createdAt: new Date(),
+        owner: { id: "u1" },
+        tagline: "Keep me",
+      } as any);
+      expect(result).toEqual({ tagline: "Keep me" });
+    });
+  });
+
+  describe("serviceExclude helpers", () => {
+    test("serviceExcludeIds removes foreign keys and ids", () => {
+      const result = serviceExcludeIds({
+        id: "svc-1",
+        venueId: "v1",
+        tagline: "Stay",
+      } as any);
+      expect(result).toEqual({ tagline: "Stay" });
+    });
+
+    test("serviceExcludeOwners removes nested owner/creator", () => {
+      const result = serviceExcludeOwners({
+        owner: { id: "u1" },
+        creator: { id: "u2" },
+        description: "Keep",
+      } as any);
+      expect(result).toEqual({ description: "Keep" });
+    });
+  });
+
+  describe("serviceGetInfoAI", () => {
+    test("returns field metadata for venue services", () => {
+      const info = serviceGetInfoAI(ServiceTypes.Venues);
+      expect(info).toBeDefined();
+      expect(Object.keys(info).length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("getVendorSalesLabel", () => {
+    test("returns Products for vendors and Merch for others", () => {
+      expect(getVendorSalesLabel(ServiceTypes.Vendors)).toBe("Products");
+      expect(getVendorSalesLabel(ServiceTypes.EntertainmentServices)).toBe("Merch");
+    });
+  });
+
+  describe("SERVICE_CANCELLATION_POLICY_DATA", () => {
+    test("generates guest-facing copy for Flexible policy", () => {
+      const policy = SERVICE_CANCELLATION_POLICY_DATA.Flexible;
+      expect(policy.description).toContain("Guests may cancel");
+      expect(policy.refundPolicy).toHaveLength(2);
+    });
+
+    test("generates vendor copy for VendorFlexible", () => {
+      const policy = SERVICE_CANCELLATION_POLICY_DATA.VendorFlexible;
+      expect(policy.description).toContain("the vendor");
+      expect(policy.description).toContain("verified booking");
+    });
+  });
+});

package/src/utils/service/serviceFeaturedSortUtils.ts

@@ -39,7 +39,11 @@ function isActiveFeatured(s: FeaturedServiceSortable, now: Date): boolean {
  * and are treated as "legacy featured" sitting just below auto-features).
  */
 function featuredTier(s: FeaturedServiceSortable, now: Date): number {
-  if (!isActiveFeatured(s, now)) return 3;
+  if (!isActiveFeatured(s, now)) {
+    // Expired paid feature still has isFeaturedService set; rank below never-featured.
+    if (s.isFeaturedService) return 4;
+    return 3;
+  }
   if (s.featuredReason && PAID_TIER_REASONS.has(s.featuredReason)) return 0;
   if (s.featuredReason === "AutoNewService") return 1;
   return 2;

package/src/utils/ticketListUtils.ts

@@ -110,14 +110,21 @@ export function ticketListStrToTicketList(
 ): Map<string, NumberOfTicketsForDate[]> {
   const ticketList: Map<string, NumberOfTicketsForDate[]> = new Map();
 
-  // Decode the Base64 URL-safe string first
+  // Legacy plain strings use tier delimiters; encoded payloads are base64-only.
   let decodedStr: string;
-  try {
-    decodedStr = decodeBase64UrlSafe(ticketListStr);
-  } catch (error) {
-    console.error("Failed to decode ticketListStr:", error);
-    // If decoding fails, try using the string as-is (for backward compatibility)
+  if (
+    ticketListStr.includes(
+      URL_PARAMS_TICKET_TIER_ID_NUMBER_OF_TICKETS_DATE_DELIM
+    )
+  ) {
     decodedStr = ticketListStr;
+  } else {
+    try {
+      decodedStr = decodeBase64UrlSafe(ticketListStr);
+    } catch (error) {
+      console.error("Failed to decode ticketListStr:", error);
+      decodedStr = ticketListStr;
+    }
   }
 
   // [ticketTierId]__~~[numberOfTickets];;[date]~~[numberOfTickets];;[date]~~...,...