@bash-app/bash-common 30.246.0 → 30.253.0

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]~~...,...