@bash-app/bash-common 30.331.0 → 30.334.0

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

@@ -0,0 +1,110 @@
+import {
+  canTransitionCoatCheckStatus,
+  clampCoatCheckPurchaseQty,
+  coatCheckScanOutcomeForStatus,
+  encodeCoatCheckQrPayload,
+  parseCoatCheckQrPayload,
+  remainingCoatCheckSlots,
+} from "../coatCheckUtils";
+
+describe("coatCheckUtils", () => {
+  describe("encode/parse QR payload", () => {
+    it("round-trips claim QR fields", () => {
+      const raw = encodeCoatCheckQrPayload({
+        eventId: "evt1",
+        entitlementId: "ent1",
+        qrToken: "tok-abc",
+      });
+      const parsed = parseCoatCheckQrPayload(raw);
+      expect(parsed).toMatchObject({
+        type: "coat_check",
+        eventId: "evt1",
+        entitlementId: "ent1",
+        qrToken: "tok-abc",
+      });
+      expect(typeof parsed?.timestamp).toBe("number");
+    });
+
+    it("rejects ticket-style payloads", () => {
+      expect(
+        parseCoatCheckQrPayload(
+          JSON.stringify({ eventId: "e", ticketId: "t", qrToken: "x" })
+        )
+      ).toBeNull();
+    });
+
+    it("rejects invalid JSON", () => {
+      expect(parseCoatCheckQrPayload("not-json")).toBeNull();
+    });
+  });
+
+  describe("state machine", () => {
+    it("allows Paid → CheckedIn → Claimed", () => {
+      expect(canTransitionCoatCheckStatus("Paid", "CheckedIn")).toBe(true);
+      expect(canTransitionCoatCheckStatus("CheckedIn", "Claimed")).toBe(true);
+    });
+
+    it("rejects illegal transitions", () => {
+      expect(canTransitionCoatCheckStatus("Paid", "Claimed")).toBe(false);
+      expect(canTransitionCoatCheckStatus("Claimed", "CheckedIn")).toBe(false);
+      expect(canTransitionCoatCheckStatus("CheckedIn", "Paid")).toBe(false);
+      expect(canTransitionCoatCheckStatus("Paid", "Paid")).toBe(false);
+    });
+
+    it("allows refund/cancel from Paid or CheckedIn", () => {
+      expect(canTransitionCoatCheckStatus("Paid", "Refunded")).toBe(true);
+      expect(canTransitionCoatCheckStatus("CheckedIn", "Cancelled")).toBe(true);
+      expect(canTransitionCoatCheckStatus("Claimed", "Refunded")).toBe(false);
+    });
+
+    it("maps status to scan outcomes", () => {
+      expect(coatCheckScanOutcomeForStatus("Paid")).toBe("ready_for_dropoff");
+      expect(coatCheckScanOutcomeForStatus("CheckedIn")).toBe("ready_for_claim");
+      expect(coatCheckScanOutcomeForStatus("Claimed")).toBe("already_claimed");
+      expect(coatCheckScanOutcomeForStatus("Refunded")).toBe(
+        "cancelled_or_refunded"
+      );
+    });
+  });
+
+  describe("inventory helpers", () => {
+    it("treats null capacity as unlimited remaining", () => {
+      expect(
+        remainingCoatCheckSlots({ capacity: null, occupiedCount: 50 })
+      ).toBeNull();
+    });
+
+    it("computes remaining slots", () => {
+      expect(
+        remainingCoatCheckSlots({ capacity: 100, occupiedCount: 40 })
+      ).toBe(60);
+      expect(
+        remainingCoatCheckSlots({ capacity: 10, occupiedCount: 12 })
+      ).toBe(0);
+    });
+
+    it("clamps purchase qty by max and remaining", () => {
+      expect(
+        clampCoatCheckPurchaseQty({
+          requested: 5,
+          maxPerPurchase: 2,
+          remainingSlots: 10,
+        })
+      ).toBe(2);
+      expect(
+        clampCoatCheckPurchaseQty({
+          requested: 5,
+          maxPerPurchase: 10,
+          remainingSlots: 1,
+        })
+      ).toBe(1);
+      expect(
+        clampCoatCheckPurchaseQty({
+          requested: -3,
+          maxPerPurchase: 2,
+          remainingSlots: null,
+        })
+      ).toBe(0);
+    });
+  });
+});

package/src/utils/coatCheckUtils.ts

@@ -0,0 +1,134 @@
+import {
+  COAT_CHECK_ENTITLEMENT_STATUSES,
+  COAT_CHECK_QR_TYPE,
+  COAT_CHECK_SCAN_OUTCOMES,
+  COAT_CHECK_SLOT_OCCUPYING_STATUSES,
+  type CoatCheckEntitlementStatusName,
+  type CoatCheckScanOutcome,
+} from "../definitions.js";
+
+export type CoatCheckQrPayload = {
+  type: typeof COAT_CHECK_QR_TYPE;
+  eventId: string;
+  entitlementId: string;
+  qrToken: string;
+  timestamp: number;
+};
+
+export function encodeCoatCheckQrPayload(args: {
+  eventId: string;
+  entitlementId: string;
+  qrToken: string;
+}): string {
+  const payload: CoatCheckQrPayload = {
+    type: COAT_CHECK_QR_TYPE,
+    eventId: args.eventId,
+    entitlementId: args.entitlementId,
+    qrToken: args.qrToken,
+    timestamp: Date.now(),
+  };
+  return JSON.stringify(payload);
+}
+
+export function parseCoatCheckQrPayload(
+  raw: string
+): CoatCheckQrPayload | null {
+  try {
+    const parsed = JSON.parse(raw) as Partial<CoatCheckQrPayload>;
+    if (
+      parsed?.type !== COAT_CHECK_QR_TYPE ||
+      typeof parsed.eventId !== "string" ||
+      typeof parsed.entitlementId !== "string" ||
+      typeof parsed.qrToken !== "string"
+    ) {
+      return null;
+    }
+    return {
+      type: COAT_CHECK_QR_TYPE,
+      eventId: parsed.eventId,
+      entitlementId: parsed.entitlementId,
+      qrToken: parsed.qrToken,
+      timestamp:
+        typeof parsed.timestamp === "number" ? parsed.timestamp : Date.now(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function coatCheckScanOutcomeForStatus(
+  status: CoatCheckEntitlementStatusName
+): CoatCheckScanOutcome {
+  switch (status) {
+    case "Paid":
+      return "ready_for_dropoff";
+    case "CheckedIn":
+      return "ready_for_claim";
+    case "Claimed":
+      return "already_claimed";
+    case "Refunded":
+    case "Cancelled":
+      return "cancelled_or_refunded";
+    default:
+      return "invalid_or_expired";
+  }
+}
+
+export function canTransitionCoatCheckStatus(
+  from: CoatCheckEntitlementStatusName,
+  to: CoatCheckEntitlementStatusName
+): boolean {
+  if (from === to) return false;
+  if (from === "Paid" && to === "CheckedIn") return true;
+  if (from === "CheckedIn" && to === "Claimed") return true;
+  if (
+    (from === "Paid" || from === "CheckedIn") &&
+    (to === "Refunded" || to === "Cancelled")
+  ) {
+    return true;
+  }
+  return false;
+}
+
+export function isCoatCheckSlotOccupyingStatus(
+  status: string
+): status is CoatCheckEntitlementStatusName {
+  return (COAT_CHECK_SLOT_OCCUPYING_STATUSES as readonly string[]).includes(
+    status
+  );
+}
+
+export function isCoatCheckEntitlementStatus(
+  status: string
+): status is CoatCheckEntitlementStatusName {
+  return (COAT_CHECK_ENTITLEMENT_STATUSES as readonly string[]).includes(status);
+}
+
+export function assertCoatCheckScanOutcome(
+  outcome: string
+): outcome is CoatCheckScanOutcome {
+  return (COAT_CHECK_SCAN_OUTCOMES as readonly string[]).includes(outcome);
+}
+
+/** Remaining slots; null capacity = unlimited (Infinity for math). */
+export function remainingCoatCheckSlots(args: {
+  capacity: number | null | undefined;
+  occupiedCount: number;
+}): number | null {
+  if (args.capacity == null) return null;
+  return Math.max(0, args.capacity - args.occupiedCount);
+}
+
+export function clampCoatCheckPurchaseQty(args: {
+  requested: number;
+  maxPerPurchase: number;
+  remainingSlots: number | null;
+}): number {
+  const maxPer = Math.max(1, args.maxPerPurchase || 1);
+  let qty = Math.max(0, Math.floor(args.requested));
+  qty = Math.min(qty, maxPer);
+  if (args.remainingSlots != null) {
+    qty = Math.min(qty, args.remainingSlots);
+  }
+  return qty;
+}

package/src/utils/slugUtils.ts

@@ -53,10 +53,9 @@ export function getPublicBashDetailPath(
 }
 
 /**
- * Public, shareable Memories recap path for a bash — nested under the bash
- * detail path so it inherits the same id/slug parsing (`/bash/{id}-{slug}/memories`).
- * No-login-required by design: the whole point of Memories is that a shared
- * link works for people who aren't signed in yet.
+ * Path to Your Memories (private vault) for a bash — nested under bash detail
+ * (`/bash/{id}-{slug}/memories`). Requires sign-in + eligibility; not a public
+ * unauthenticated recap page.
  */
 export function getPublicBashMemoriesPath(
   bashEventId: string,