@bash-app/bash-common 30.215.0 → 30.217.0

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

@@ -0,0 +1,170 @@
+import { ServiceCancellationPolicy } from "@prisma/client";
+import {
+  hoursUntilEventStart,
+  cancellationRuleThresholdHours,
+  resolveCancellationRefundFraction,
+  getMatchingCancellationRefundRule,
+} from "../cancellationPolicyRefundResolver";
+import type { ServiceCancellationRefundPolicy } from "../serviceUtils";
+
+// Fixed reference for "now"
+const NOW = new Date("2025-06-01T12:00:00.000Z");
+
+// ---------------------------------------------------------------------------
+// cancellationRuleThresholdHours
+// ---------------------------------------------------------------------------
+
+describe("cancellationRuleThresholdHours", () => {
+  it("converts days to hours", () => {
+    const rule: ServiceCancellationRefundPolicy = { days: 7, refundPercentage: 100 };
+    expect(cancellationRuleThresholdHours(rule)).toBe(168);
+  });
+  it("returns hours directly", () => {
+    const rule: ServiceCancellationRefundPolicy = { hours: 24, refundPercentage: 50 };
+    expect(cancellationRuleThresholdHours(rule)).toBe(24);
+  });
+  it("returns 0 when neither days nor hours is set", () => {
+    const rule = { refundPercentage: 100 } as ServiceCancellationRefundPolicy;
+    expect(cancellationRuleThresholdHours(rule)).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// hoursUntilEventStart
+// ---------------------------------------------------------------------------
+
+describe("hoursUntilEventStart", () => {
+  it("returns 0 when event has already started", () => {
+    const past = new Date(NOW.getTime() - 1000);
+    expect(hoursUntilEventStart(past, NOW)).toBe(0);
+  });
+  it("returns 0 for a current-moment event", () => {
+    expect(hoursUntilEventStart(NOW, NOW)).toBe(0);
+  });
+  it("returns correct hours for 48-hour future event", () => {
+    const future = new Date(NOW.getTime() + 48 * 60 * 60 * 1000);
+    expect(hoursUntilEventStart(future, NOW)).toBe(48);
+  });
+  it("returns fractional hours", () => {
+    const future = new Date(NOW.getTime() + 1.5 * 60 * 60 * 1000);
+    expect(hoursUntilEventStart(future, NOW)).toBeCloseTo(1.5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveCancellationRefundFraction
+// ---------------------------------------------------------------------------
+
+describe("resolveCancellationRefundFraction", () => {
+  it("returns 0 for null policy", () => {
+    expect(
+      resolveCancellationRefundFraction(null, { eventStart: new Date(NOW.getTime() + 48 * 3600_000), now: NOW })
+    ).toBe(0);
+  });
+  it("returns 0 for None policy", () => {
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.None, { eventStart: new Date(NOW.getTime() + 48 * 3600_000), now: NOW })
+    ).toBe(0);
+  });
+  it("returns 0 when event has already started", () => {
+    const past = new Date(NOW.getTime() - 1000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.VeryFlexible, { eventStart: past, now: NOW })
+    ).toBe(0);
+  });
+
+  // VeryFlexible: 100% refund if >= 24 hours out
+  it("returns 1 for VeryFlexible policy >= 24h before start", () => {
+    const future48h = new Date(NOW.getTime() + 48 * 3600_000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.VeryFlexible, { eventStart: future48h, now: NOW })
+    ).toBe(1);
+  });
+  it("returns 0 for VeryFlexible policy < 24h before start", () => {
+    const future12h = new Date(NOW.getTime() + 12 * 3600_000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.VeryFlexible, { eventStart: future12h, now: NOW })
+    ).toBe(0);
+  });
+
+  // Flexible: 100% if >= 7 days, 50% if >= 24h
+  it("returns 1 for Flexible policy >= 7 days before start", () => {
+    const future8Days = new Date(NOW.getTime() + 8 * 24 * 3600_000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.Flexible, { eventStart: future8Days, now: NOW })
+    ).toBe(1);
+  });
+  it("returns 0.5 for Flexible policy >= 24h but < 7 days before start", () => {
+    const future3Days = new Date(NOW.getTime() + 3 * 24 * 3600_000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.Flexible, { eventStart: future3Days, now: NOW })
+    ).toBe(0.5);
+  });
+  it("returns 0 for Flexible policy < 24h before start", () => {
+    const future12h = new Date(NOW.getTime() + 12 * 3600_000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.Flexible, { eventStart: future12h, now: NOW })
+    ).toBe(0);
+  });
+
+  // Standard30Day: 100% if >= 30 days, 50% if >= 7 days
+  it("returns 1 for Standard30Day policy >= 30 days before start", () => {
+    const future31Days = new Date(NOW.getTime() + 31 * 24 * 3600_000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.Standard30Day, { eventStart: future31Days, now: NOW })
+    ).toBe(1);
+  });
+  it("returns 0.5 for Standard30Day policy between 7 and 30 days before start", () => {
+    const future10Days = new Date(NOW.getTime() + 10 * 24 * 3600_000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.Standard30Day, { eventStart: future10Days, now: NOW })
+    ).toBe(0.5);
+  });
+  it("returns 0 for Standard30Day policy < 7 days before start", () => {
+    const future2Days = new Date(NOW.getTime() + 2 * 24 * 3600_000);
+    expect(
+      resolveCancellationRefundFraction(ServiceCancellationPolicy.Standard30Day, { eventStart: future2Days, now: NOW })
+    ).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getMatchingCancellationRefundRule
+// ---------------------------------------------------------------------------
+
+describe("getMatchingCancellationRefundRule", () => {
+  it("returns null for null policy", () => {
+    expect(
+      getMatchingCancellationRefundRule(null, { eventStart: new Date(NOW.getTime() + 48 * 3600_000), now: NOW })
+    ).toBeNull();
+  });
+  it("returns null for None policy", () => {
+    expect(
+      getMatchingCancellationRefundRule(ServiceCancellationPolicy.None, { eventStart: new Date(NOW.getTime() + 48 * 3600_000), now: NOW })
+    ).toBeNull();
+  });
+  it("returns null when event has already started", () => {
+    const past = new Date(NOW.getTime() - 1000);
+    expect(
+      getMatchingCancellationRefundRule(ServiceCancellationPolicy.Flexible, { eventStart: past, now: NOW })
+    ).toBeNull();
+  });
+  it("returns the 100% rule for VeryFlexible >= 24h", () => {
+    const future48h = new Date(NOW.getTime() + 48 * 3600_000);
+    const rule = getMatchingCancellationRefundRule(ServiceCancellationPolicy.VeryFlexible, { eventStart: future48h, now: NOW });
+    expect(rule).not.toBeNull();
+    expect(rule!.refundPercentage).toBe(100);
+  });
+  it("returns the 100% rule for Flexible >= 7 days", () => {
+    const future8Days = new Date(NOW.getTime() + 8 * 24 * 3600_000);
+    const rule = getMatchingCancellationRefundRule(ServiceCancellationPolicy.Flexible, { eventStart: future8Days, now: NOW });
+    expect(rule!.refundPercentage).toBe(100);
+    expect(rule!.days).toBe(7);
+  });
+  it("returns the 50% rule for Flexible 24h-7days window", () => {
+    const future3Days = new Date(NOW.getTime() + 3 * 24 * 3600_000);
+    const rule = getMatchingCancellationRefundRule(ServiceCancellationPolicy.Flexible, { eventStart: future3Days, now: NOW });
+    expect(rule!.refundPercentage).toBe(50);
+    expect(rule!.hours).toBe(24);
+  });
+});

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

@@ -0,0 +1,273 @@
+import {
+  serviceBookingIsRequest,
+  serviceBookingIsConfirmed,
+  serviceBookingIsPaid,
+  serviceBookingIsRefunded,
+  serviceBookingAllowPromisePay,
+  serviceBookingIsCanceled,
+  serviceBookingIsApproved,
+  serviceBookingIsDeclined,
+  serviceBookingIsPending,
+  serviceBookingHasApprovalDecision,
+  serviceBookingCanBePaid,
+  serviceBookingCanBeRefunded,
+  serviceBookingCanHaveApprovalDecision,
+  serviceBookingCanBeCanceled,
+  serviceBookingCanBeConfirmed,
+} from "../serviceBookingStatusUtils";
+import type { ServiceBookingExt } from "../../../extendedSchemas";
+
+// Minimal booking factory — only supply the fields each predicate inspects
+function makeBooking(overrides: Partial<ServiceBookingExt> = {}): ServiceBookingExt {
+  return {
+    id: "b1",
+    status: "Pending",
+    bookingType: "Instant",
+    allowPromiseToPay: false,
+    checkout: null,
+    ...overrides,
+  } as unknown as ServiceBookingExt;
+}
+
+// ---------------------------------------------------------------------------
+// Simple predicates
+// ---------------------------------------------------------------------------
+
+describe("serviceBookingIsRequest", () => {
+  it("returns true when bookingType is Request", () => {
+    expect(serviceBookingIsRequest(makeBooking({ bookingType: "Request" }))).toBe(true);
+  });
+  it("returns false when bookingType is Instant", () => {
+    expect(serviceBookingIsRequest(makeBooking({ bookingType: "Instant" }))).toBe(false);
+  });
+});
+
+describe("serviceBookingIsConfirmed", () => {
+  it("returns true for Confirmed status", () => {
+    expect(serviceBookingIsConfirmed(makeBooking({ status: "Confirmed" }))).toBe(true);
+  });
+  it("returns false for non-Confirmed statuses", () => {
+    for (const status of ["Pending", "Approved", "Rejected", "Canceled"]) {
+      expect(serviceBookingIsConfirmed(makeBooking({ status } as Partial<ServiceBookingExt>))).toBe(false);
+    }
+  });
+});
+
+describe("serviceBookingIsPaid", () => {
+  it("returns true when checkout.paidOn is set", () => {
+    expect(serviceBookingIsPaid(makeBooking({ checkout: { paidOn: new Date() } } as Partial<ServiceBookingExt>))).toBe(true);
+  });
+  it("returns false when checkout is null", () => {
+    expect(serviceBookingIsPaid(makeBooking({ checkout: null }))).toBe(false);
+  });
+  it("returns false when paidOn is null", () => {
+    expect(serviceBookingIsPaid(makeBooking({ checkout: { paidOn: null } } as Partial<ServiceBookingExt>))).toBe(false);
+  });
+});
+
+describe("serviceBookingIsRefunded", () => {
+  it("returns true when checkout.refundedOn is set", () => {
+    expect(serviceBookingIsRefunded(makeBooking({ checkout: { refundedOn: new Date() } } as Partial<ServiceBookingExt>))).toBe(true);
+  });
+  it("returns false when checkout is null", () => {
+    expect(serviceBookingIsRefunded(makeBooking({ checkout: null }))).toBe(false);
+  });
+  it("returns false when refundedOn is null", () => {
+    expect(serviceBookingIsRefunded(makeBooking({ checkout: { refundedOn: null } } as Partial<ServiceBookingExt>))).toBe(false);
+  });
+});
+
+describe("serviceBookingAllowPromisePay", () => {
+  it("returns true when allowPromiseToPay is true", () => {
+    expect(serviceBookingAllowPromisePay(makeBooking({ allowPromiseToPay: true }))).toBe(true);
+  });
+  it("returns false when allowPromiseToPay is false", () => {
+    expect(serviceBookingAllowPromisePay(makeBooking({ allowPromiseToPay: false }))).toBe(false);
+  });
+});
+
+describe("serviceBookingIsCanceled", () => {
+  it("returns true for Canceled status", () => {
+    expect(serviceBookingIsCanceled(makeBooking({ status: "Canceled" }))).toBe(true);
+  });
+  it("returns false for other statuses", () => {
+    expect(serviceBookingIsCanceled(makeBooking({ status: "Pending" }))).toBe(false);
+  });
+});
+
+describe("serviceBookingIsApproved", () => {
+  it("returns true for Approved status", () => {
+    expect(serviceBookingIsApproved(makeBooking({ status: "Approved" }))).toBe(true);
+  });
+  it("returns false for Rejected", () => {
+    expect(serviceBookingIsApproved(makeBooking({ status: "Rejected" }))).toBe(false);
+  });
+});
+
+describe("serviceBookingIsDeclined", () => {
+  it("returns true for Rejected status", () => {
+    expect(serviceBookingIsDeclined(makeBooking({ status: "Rejected" }))).toBe(true);
+  });
+  it("returns false for Approved", () => {
+    expect(serviceBookingIsDeclined(makeBooking({ status: "Approved" }))).toBe(false);
+  });
+});
+
+describe("serviceBookingIsPending", () => {
+  it("returns true for Pending status", () => {
+    expect(serviceBookingIsPending(makeBooking({ status: "Pending" }))).toBe(true);
+  });
+  it("returns false for Approved", () => {
+    expect(serviceBookingIsPending(makeBooking({ status: "Approved" }))).toBe(false);
+  });
+});
+
+describe("serviceBookingHasApprovalDecision", () => {
+  it("returns true when Rejected", () => {
+    expect(serviceBookingHasApprovalDecision(makeBooking({ status: "Rejected" }))).toBe(true);
+  });
+  it("returns true when Approved", () => {
+    expect(serviceBookingHasApprovalDecision(makeBooking({ status: "Approved" }))).toBe(true);
+  });
+  it("returns false when Pending", () => {
+    expect(serviceBookingHasApprovalDecision(makeBooking({ status: "Pending" }))).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Compound predicates — canBePaid
+// ---------------------------------------------------------------------------
+
+describe("serviceBookingCanBePaid", () => {
+  it("returns valid for an Approved, unpaid, non-canceled booking", () => {
+    expect(serviceBookingCanBePaid(makeBooking({ status: "Approved" }))).toEqual({ valid: true });
+  });
+  it("blocks payment for a Canceled booking", () => {
+    const result = serviceBookingCanBePaid(makeBooking({ status: "Canceled" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/canceled/i);
+  });
+  it("blocks payment when already paid", () => {
+    const result = serviceBookingCanBePaid(
+      makeBooking({ status: "Approved", checkout: { paidOn: new Date() } } as Partial<ServiceBookingExt>)
+    );
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/already been paid/i);
+  });
+  it("blocks payment for a Rejected booking", () => {
+    const result = serviceBookingCanBePaid(makeBooking({ status: "Rejected" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/declined/i);
+  });
+  it("blocks payment for a Pending Request", () => {
+    const result = serviceBookingCanBePaid(makeBooking({ status: "Pending", bookingType: "Request" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/pending booking request/i);
+  });
+  it("allows payment for a Pending non-Request booking", () => {
+    expect(serviceBookingCanBePaid(makeBooking({ status: "Pending", bookingType: "Instant" }))).toEqual({ valid: true });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// canBeRefunded
+// ---------------------------------------------------------------------------
+
+describe("serviceBookingCanBeRefunded", () => {
+  const paidBooking = makeBooking({
+    status: "Approved",
+    checkout: { paidOn: new Date() },
+  } as Partial<ServiceBookingExt>);
+
+  it("returns valid for a paid, non-canceled, non-refunded booking", () => {
+    expect(serviceBookingCanBeRefunded(paidBooking)).toEqual({ valid: true });
+  });
+  it("blocks refund for a Canceled booking", () => {
+    const result = serviceBookingCanBeRefunded(makeBooking({ status: "Canceled" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/already canceled/i);
+  });
+  it("blocks refund for an already refunded booking", () => {
+    const result = serviceBookingCanBeRefunded(
+      makeBooking({ checkout: { paidOn: new Date(), refundedOn: new Date() } } as Partial<ServiceBookingExt>)
+    );
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/already refunded/i);
+  });
+  it("blocks refund for an unpaid booking", () => {
+    const result = serviceBookingCanBeRefunded(makeBooking({ checkout: null }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/not been paid/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// canHaveApprovalDecision
+// ---------------------------------------------------------------------------
+
+describe("serviceBookingCanHaveApprovalDecision", () => {
+  it("returns valid for a Pending Request that is not canceled or confirmed", () => {
+    const booking = makeBooking({ bookingType: "Request", status: "Pending" });
+    expect(serviceBookingCanHaveApprovalDecision(booking)).toEqual({ valid: true });
+  });
+  it("blocks non-Request bookings", () => {
+    const result = serviceBookingCanHaveApprovalDecision(makeBooking({ bookingType: "Instant" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/booking requests/i);
+  });
+  it("blocks Canceled requests", () => {
+    const result = serviceBookingCanHaveApprovalDecision(makeBooking({ bookingType: "Request", status: "Canceled" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/canceled/i);
+  });
+  it("blocks Confirmed requests", () => {
+    const result = serviceBookingCanHaveApprovalDecision(makeBooking({ bookingType: "Request", status: "Confirmed" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/confirmed/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// canBeCanceled
+// ---------------------------------------------------------------------------
+
+describe("serviceBookingCanBeCanceled", () => {
+  const service = {} as any;
+
+  it("returns valid for an active Pending booking", () => {
+    expect(serviceBookingCanBeCanceled(service, makeBooking({ status: "Pending" }))).toEqual({ valid: true });
+  });
+  it("blocks canceling an already Canceled booking", () => {
+    const result = serviceBookingCanBeCanceled(service, makeBooking({ status: "Canceled" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/may not be canceled/i);
+  });
+  it("blocks canceling a refunded booking", () => {
+    const result = serviceBookingCanBeCanceled(
+      service,
+      makeBooking({ checkout: { refundedOn: new Date() } } as Partial<ServiceBookingExt>)
+    );
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/refunded/i);
+  });
+  it("blocks canceling a Rejected booking", () => {
+    const result = serviceBookingCanBeCanceled(service, makeBooking({ status: "Rejected" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/declined/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// canBeConfirmed
+// ---------------------------------------------------------------------------
+
+describe("serviceBookingCanBeConfirmed", () => {
+  it("returns valid for an Approved booking", () => {
+    expect(serviceBookingCanBeConfirmed(makeBooking({ status: "Approved" }))).toEqual({ valid: true });
+  });
+  it("blocks confirming a Canceled booking", () => {
+    const result = serviceBookingCanBeConfirmed(makeBooking({ status: "Canceled" }));
+    expect(result.valid).toBe(false);
+    expect(result.errorMessage).toMatch(/canceled/i);
+  });
+});