@bash-app/bash-common 30.383.0 → 30.386.0

package/src/__tests__/accessScreening.test.ts

@@ -1,4 +1,59 @@
-import { accessScreeningBlocksAttendeeActions } from "../accessScreening.js";
+import {
+  accessScreeningApplies,
+  accessScreeningBlocksAttendeeActions,
+  accessScreeningBlocksAttendeeActionsForEvent,
+  eventNeedsAccessRequestQueue,
+} from "../accessScreening.js";
+
+describe("accessScreeningApplies", () => {
+  it("is on only when screening is on and Application is not", () => {
+    expect(
+      accessScreeningApplies({ accessScreeningEnabled: true })
+    ).toBe(true);
+    expect(
+      accessScreeningApplies({
+        accessScreeningEnabled: true,
+        applicationEnabled: true,
+      })
+    ).toBe(false);
+    expect(
+      accessScreeningApplies({
+        accessScreeningEnabled: true,
+        ticketTiers: [{ requiresApplication: true }],
+      })
+    ).toBe(false);
+    expect(
+      accessScreeningApplies({ accessScreeningEnabled: false })
+    ).toBe(false);
+  });
+});
+
+describe("eventNeedsAccessRequestQueue", () => {
+  it("shows the ticketed queue for screening or Application, not RSVP Application", () => {
+    expect(
+      eventNeedsAccessRequestQueue({ accessScreeningEnabled: true })
+    ).toBe(true);
+    expect(
+      eventNeedsAccessRequestQueue({
+        entryMode: "Ticketed",
+        applicationEnabled: true,
+      })
+    ).toBe(true);
+    expect(
+      eventNeedsAccessRequestQueue({
+        entryMode: "Rsvp",
+        applicationEnabled: true,
+        accessScreeningEnabled: true,
+      })
+    ).toBe(false);
+    expect(
+      eventNeedsAccessRequestQueue({
+        entryMode: "Rsvp",
+        accessScreeningEnabled: true,
+      })
+    ).toBe(true);
+  });
+});
 
 describe("accessScreeningBlocksAttendeeActions", () => {
   it("does not block when screening is off", () => {
@@ -26,4 +81,17 @@ describe("accessScreeningBlocksAttendeeActions", () => {
   it("does not block ticket holders", () => {
     expect(accessScreeningBlocksAttendeeActions(true, "None", true)).toBe(false);
   });
+
+  it("does not block guests when Application supersedes leftover screening", () => {
+    expect(
+      accessScreeningBlocksAttendeeActionsForEvent(
+        {
+          accessScreeningEnabled: true,
+          applicationEnabled: true,
+        },
+        "None",
+        false
+      )
+    ).toBe(false);
+  });
 });

package/src/__tests__/applicationFunnel.test.ts

@@ -0,0 +1,197 @@
+import {
+  applicationBlocksTierPurchase,
+  applicationsAreClosed,
+  evaluateApplicationFunnel,
+  eventHasApplication,
+  missingRequiredQuestionIds,
+  questionsForApplicationSurface,
+  rsvpApplicationEnabled,
+  selectedTiersRequireApplication,
+  visibleApplicationQuestions,
+} from "../applicationFunnel.js";
+
+const yesNo = {
+  id: "age",
+  type: "YesNo" as const,
+  required: true,
+  mismatchAction: "AutoDeny" as const,
+  acceptableOptions: ["Yes"],
+};
+
+describe("applicationFunnel", () => {
+  it("auto-denies a disallowed Yes/No answer", () => {
+    const result = evaluateApplicationFunnel(
+      [yesNo],
+      [{ questionId: "age", answer: "No" }]
+    );
+    expect(result.outcome).toBe("auto_deny");
+    expect(result.autoDenyQuestionIds).toEqual(["age"]);
+  });
+
+  it("flags a mismatch without auto-deny", () => {
+    const result = evaluateApplicationFunnel(
+      [
+        {
+          id: "single",
+          type: "SingleChoice",
+          mismatchAction: "FlagForReview",
+          acceptableOptions: ["Friend"],
+        },
+      ],
+      [{ questionId: "single", answer: "Other" }]
+    );
+    expect(result.outcome).toBe("flag");
+    expect(result.flaggedQuestionIds).toEqual(["single"]);
+  });
+
+  it("passes when the choice is acceptable", () => {
+    const result = evaluateApplicationFunnel(
+      [yesNo],
+      [{ questionId: "age", answer: "Yes" }]
+    );
+    expect(result.outcome).toBe("pass");
+  });
+
+  it("ignores free text for auto-deny", () => {
+    const result = evaluateApplicationFunnel(
+      [
+        {
+          id: "why",
+          type: "LongText",
+          mismatchAction: "AutoDeny",
+          acceptableOptions: ["never"],
+        },
+      ],
+      [{ questionId: "why", answer: "because" }]
+    );
+    expect(result.outcome).toBe("pass");
+  });
+
+  it("treats multi-choice as a mismatch when any selected option is not acceptable", () => {
+    const result = evaluateApplicationFunnel(
+      [
+        {
+          id: "dates",
+          type: "MultiChoice",
+          mismatchAction: "AutoDeny",
+          acceptableOptions: ["Women", "Men"],
+        },
+      ],
+      [{ questionId: "dates", answer: "Women, Aliens" }]
+    );
+    expect(result.outcome).toBe("auto_deny");
+  });
+
+  it("does not funnel when mismatchAction is None", () => {
+    const result = evaluateApplicationFunnel(
+      [
+        {
+          id: "song",
+          type: "SingleChoice",
+          mismatchAction: "None",
+          acceptableOptions: ["A"],
+        },
+      ],
+      [{ questionId: "song", answer: "B" }]
+    );
+    expect(result.outcome).toBe("pass");
+  });
+
+  it("lists missing required answers", () => {
+    expect(
+      missingRequiredQuestionIds(
+        [yesNo, { id: "opt", type: "ShortText", required: false }],
+        []
+      )
+    ).toEqual(["age"]);
+  });
+
+  it("filters questions to a ticket tier plus event-wide rows", () => {
+    const rows = [
+      { id: "all", ticketTierId: null },
+      { id: "ga", ticketTierId: "tier-ga" },
+      { id: "vip", ticketTierId: "tier-vip" },
+    ];
+    expect(questionsForApplicationSurface(rows, "tier-ga").map((q) => q.id)).toEqual(
+      ["all", "ga"]
+    );
+    expect(questionsForApplicationSurface(rows, null).map((q) => q.id)).toEqual([
+      "all",
+    ]);
+  });
+
+  it("detects event and RSVP application flags", () => {
+    expect(eventHasApplication({ applicationEnabled: false, ticketTiers: [] })).toBe(
+      false
+    );
+    expect(
+      eventHasApplication({
+        applicationEnabled: false,
+        ticketTiers: [{ requiresApplication: true }],
+      })
+    ).toBe(true);
+    expect(rsvpApplicationEnabled({ entryMode: "Rsvp", applicationEnabled: true })).toBe(
+      true
+    );
+    expect(
+      rsvpApplicationEnabled({ entryMode: "Ticketed", applicationEnabled: true })
+    ).toBe(false);
+  });
+
+  it("blocks purchase on application tiers until approved", () => {
+    expect(
+      applicationBlocksTierPurchase({ requiresApplication: true }, "Pending", false)
+    ).toBe(true);
+    expect(
+      applicationBlocksTierPurchase({ requiresApplication: true }, "Approved", false)
+    ).toBe(false);
+    expect(
+      applicationBlocksTierPurchase({ requiresApplication: true }, "Pending", true)
+    ).toBe(false);
+    expect(
+      applicationBlocksTierPurchase({ requiresApplication: false }, null, false)
+    ).toBe(false);
+    expect(
+      selectedTiersRequireApplication([
+        { requiresApplication: false },
+        { requiresApplication: true },
+      ])
+    ).toBe(true);
+  });
+
+  it("treats a past deadline as closed", () => {
+    expect(applicationsAreClosed("2020-01-01T00:00:00.000Z")).toBe(true);
+    expect(applicationsAreClosed(null)).toBe(false);
+    expect(applicationsAreClosed("not-a-date")).toBe(false);
+  });
+
+  it("hides conditional follow-ups until the parent matches", () => {
+    const parent = {
+      id: "plus",
+      type: "YesNo" as const,
+      required: true,
+    };
+    const child = {
+      id: "who",
+      type: "ShortText" as const,
+      required: true,
+      parentQuestionId: "plus",
+      showWhenAnswer: "Yes",
+    };
+    expect(
+      visibleApplicationQuestions([parent, child], [
+        { questionId: "plus", answer: "No" },
+      ]).map((q) => q.id)
+    ).toEqual(["plus"]);
+    expect(
+      missingRequiredQuestionIds([parent, child], [
+        { questionId: "plus", answer: "No" },
+      ])
+    ).toEqual([]);
+    expect(
+      visibleApplicationQuestions([parent, child], [
+        { questionId: "plus", answer: "Yes" },
+      ]).map((q) => q.id)
+    ).toEqual(["plus", "who"]);
+  });
+});

package/src/__tests__/definitionsHelpers.test.ts

@@ -3,6 +3,8 @@ import {
   createEmptyFilterFields,
   removeDataFromResult,
   canonicalBashEventRowKey,
+  homepageBashEventRowKey,
+  isUnsetBashEventType,
   PASSWORD_REQUIREMENTS_REGEX,
   PASSWORD_MIN_LENGTH,
   EMPTY_FILTER_FIELDS,
@@ -64,6 +66,28 @@ describe("definitions helpers", () => {
     });
   });
 
+  describe("homepageBashEventRowKey", () => {
+    test("maps blank and unset types to Other", () => {
+      expect(homepageBashEventRowKey("")).toBe("Other");
+      expect(homepageBashEventRowKey("   ")).toBe("Other");
+      expect(homepageBashEventRowKey(null)).toBe("Other");
+      expect(homepageBashEventRowKey(undefined)).toBe("Other");
+    });
+
+    test("keeps known types canonical", () => {
+      expect(homepageBashEventRowKey("House Party")).toBe("HouseParty");
+      expect(homepageBashEventRowKey("Other")).toBe("Other");
+    });
+  });
+
+  describe("isUnsetBashEventType", () => {
+    test("treats blank and Other as unset", () => {
+      expect(isUnsetBashEventType("")).toBe(true);
+      expect(isUnsetBashEventType("Other")).toBe(true);
+      expect(isUnsetBashEventType("Party")).toBe(false);
+    });
+  });
+
   describe("PASSWORD_REQUIREMENTS_REGEX", () => {
     test("requires min length and mixed character classes", () => {
       expect(PASSWORD_MIN_LENGTH).toBe(8);

package/src/__tests__/fundingMeter.test.ts

@@ -0,0 +1,143 @@
+import {
+  computeFundingMeterProgress,
+  contributionCountsAsCollected,
+  contributionCountsAsOpenPledge,
+} from "../fundingMeter.js";
+
+describe("fundingMeter progress math", () => {
+  const line = {
+    id: "ins",
+    name: "Insurance",
+    category: "Other",
+    totalAllocatedCents: 50000,
+    includeOnFundingMeter: true,
+  };
+
+  it("counts host-entered and Stripe Paid toward collected, not pledges", () => {
+    const progress = computeFundingMeterProgress({
+      showFundingMeter: true,
+      fundingAllowCommitments: true,
+      fundingShowPledgesOnMeter: false,
+      hostStripeConnected: true,
+      lines: [line],
+      contributions: [
+        {
+          budgetId: "ins",
+          amountCents: 10000,
+          kind: "Cash",
+          status: "Paid",
+          source: "Stripe",
+          displayName: "Alex",
+          note: null,
+        },
+        {
+          budgetId: "ins",
+          amountCents: 5000,
+          kind: "InKind",
+          status: "Fulfilled",
+          source: "HostEntered",
+          displayName: "Pearl Milk Tea",
+          note: "gift cards",
+        },
+        {
+          budgetId: "ins",
+          amountCents: 20000,
+          kind: "Cash",
+          status: "Pledged",
+          source: "PublicPledge",
+          displayName: "Sam",
+          note: null,
+        },
+      ],
+    });
+
+    expect(progress.collectedCents).toBe(15000);
+    expect(progress.pledgedCents).toBe(20000);
+    expect(progress.percentFunded).toBe(30);
+    expect(progress.lines[0].remainingCents).toBe(35000);
+    expect(progress.unallocatedCents).toBe(0);
+  });
+
+  it("keeps unallocated gifts out of percent funded and line remaining", () => {
+    const progress = computeFundingMeterProgress({
+      showFundingMeter: true,
+      fundingAllowCommitments: true,
+      fundingShowPledgesOnMeter: false,
+      hostStripeConnected: false,
+      lines: [line],
+      contributions: [
+        {
+          budgetId: null,
+          amountCents: 40000,
+          kind: "Cash",
+          status: "Paid",
+          source: "Stripe",
+          displayName: "Mystery",
+          note: null,
+        },
+      ],
+    });
+
+    expect(progress.collectedCents).toBe(0);
+    expect(progress.percentFunded).toBe(0);
+    expect(progress.unallocatedCents).toBe(40000);
+    expect(progress.lines[0].remainingCents).toBe(50000);
+  });
+
+  it("ignores declined and cancelled rows", () => {
+    expect(
+      contributionCountsAsCollected({
+        budgetId: "ins",
+        amountCents: 1000,
+        kind: "Cash",
+        status: "Cancelled",
+        source: "HostEntered",
+        displayName: "x",
+        note: null,
+      })
+    ).toBe(false);
+    expect(
+      contributionCountsAsOpenPledge({
+        budgetId: "ins",
+        amountCents: 1000,
+        kind: "Cash",
+        status: "Declined",
+        source: "PublicPledge",
+        displayName: "x",
+        note: null,
+      })
+    ).toBe(false);
+  });
+
+  it("excludes lines with includeOnFundingMeter false from the goal", () => {
+    const progress = computeFundingMeterProgress({
+      showFundingMeter: true,
+      fundingAllowCommitments: true,
+      fundingShowPledgesOnMeter: true,
+      hostStripeConnected: true,
+      lines: [
+        line,
+        {
+          id: "hidden",
+          name: "Internal",
+          category: null,
+          totalAllocatedCents: 99999,
+          includeOnFundingMeter: false,
+        },
+      ],
+      contributions: [
+        {
+          budgetId: "hidden",
+          amountCents: 99999,
+          kind: "Cash",
+          status: "Paid",
+          source: "HostEntered",
+          displayName: "Host",
+          note: null,
+        },
+      ],
+    });
+    expect(progress.goalCents).toBe(50000);
+    expect(progress.collectedCents).toBe(0);
+  });
+});

package/src/__tests__/giveaway.test.ts

@@ -0,0 +1,111 @@
+import {
+  buildGiveawayAttendeeIdFromTicket,
+  giveawayActiveDistributedCount,
+  giveawayQualifyCopy,
+  giveawayRemainingCopy,
+  matchesCompetitionParticipant,
+  resolveGiveawayAttendeeFromScan,
+  ticketCountsAsCheckedIn,
+  ticketCountsAsGiveawayTicket,
+} from "../giveaway.js";
+
+describe("giveaway attendee identity", () => {
+  it("resolves ticket QR to ticket:{ticketId} for this event", () => {
+    const resolved = resolveGiveawayAttendeeFromScan(
+      "evt-1",
+      JSON.stringify({ eventId: "evt-1", ticketId: "t-9", userId: "u-2" })
+    );
+    expect(resolved).toEqual({
+      attendeeId: buildGiveawayAttendeeIdFromTicket("t-9"),
+      ticketId: "t-9",
+      userId: "u-2",
+    });
+  });
+
+  it("rejects a scan for a different event", () => {
+    expect(
+      resolveGiveawayAttendeeFromScan(
+        "evt-1",
+        JSON.stringify({ eventId: "evt-other", ticketId: "t-9" })
+      )
+    ).toBeNull();
+  });
+});
+
+describe("giveaway copy", () => {
+  it("uses Enter the contest wording for CompetitionParticipants", () => {
+    expect(
+      giveawayQualifyCopy({
+        eligibility: "CompetitionParticipants",
+        competitionName: "5K",
+      })
+    ).toBe("Enter 5K to qualify");
+    expect(
+      giveawayQualifyCopy({ eligibility: "CompetitionParticipants" })
+    ).toBe("Enter the contest to qualify");
+  });
+
+  it("covers the rest of the eligibility matrix", () => {
+    expect(giveawayQualifyCopy({ eligibility: "AnyoneGoing" })).toBe(
+      "Anyone going to this bash can qualify"
+    );
+    expect(giveawayQualifyCopy({ eligibility: "TicketHolders" })).toBe(
+      "Ticket holders qualify"
+    );
+    expect(giveawayQualifyCopy({ eligibility: "CheckedIn" })).toBe(
+      "Checked-in attendees qualify"
+    );
+    expect(
+      giveawayQualifyCopy({
+        eligibility: "SideQuestCompleters",
+        sideQuestTitle: "Find the booth",
+      })
+    ).toBe("Complete Find the booth to qualify");
+    expect(giveawayQualifyCopy({ eligibility: "SideQuestCompleters" })).toBe(
+      "Complete the side quest to qualify"
+    );
+  });
+
+  it("shows All distributed when remaining is 0", () => {
+    expect(giveawayRemainingCopy(0)).toBe("All distributed");
+    expect(giveawayRemainingCopy(43)).toBe("43 remaining");
+  });
+});
+
+describe("eligibility helpers", () => {
+  it("treats Pending tickets as ticket holders but not checked in", () => {
+    expect(ticketCountsAsGiveawayTicket("Pending")).toBe(true);
+    expect(ticketCountsAsCheckedIn({ status: "Pending", checkedInAt: null })).toBe(
+      false
+    );
+    expect(
+      ticketCountsAsCheckedIn({ status: "Pending", checkedInAt: new Date() })
+    ).toBe(true);
+  });
+
+  it("matches email-only competition participants", () => {
+    expect(
+      matchesCompetitionParticipant({
+        userId: "acct-1",
+        email: "Sam@Example.com",
+        participants: [
+          { status: "ACCEPTED", userId: null, email: "sam@example.com" },
+        ],
+      })
+    ).toBe(true);
+    expect(
+      matchesCompetitionParticipant({
+        userId: "acct-1",
+        email: "other@example.com",
+        participants: [
+          { status: "ACCEPTED", userId: null, email: "sam@example.com" },
+        ],
+      })
+    ).toBe(false);
+  });
+
+  it("treats quantityTotal - remaining as active inventory, not history", () => {
+    expect(giveawayActiveDistributedCount(100, 43)).toBe(57);
+    expect(giveawayActiveDistributedCount(100, 100)).toBe(0);
+  });
+});