@bash-app/bash-common 30.370.0 → 30.372.0

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

@@ -1,9 +1,16 @@
 import {
   apiTransformAddOnsToAddonInputs,
+  apiTransformPackagesToPackageInputs,
+  servicePriceToBookToApiPackages,
   serviceBookingParamsToLuxon,
 } from "../apiServiceBookingApiUtils";
-import type { ApiServiceAddonParams, ApiServiceBookingParams } from "../../../definitions";
-import type { ServiceAddonExt } from "../../../extendedSchemas";
+import type {
+  ApiServiceAddonParams,
+  ApiServiceBookingParams,
+  ApiServicePackageParams,
+} from "../../../definitions";
+import type { ServiceAddonExt, ServicePackageExt } from "../../../extendedSchemas";
+import type { FrontendServiceGetPriceToBookResult } from "../frontendServiceBookingUtils";
 
 // ---------------------------------------------------------------------------
 // apiTransformAddOnsToAddonInputs
@@ -65,6 +72,99 @@ describe("apiTransformAddOnsToAddonInputs", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// apiTransformPackagesToPackageInputs
+// ---------------------------------------------------------------------------
+
+function makePackageExt(id: string, name = "Package"): ServicePackageExt {
+  return {
+    id,
+    name,
+    description: "",
+    priceCents: 5000,
+    serviceAddons: [],
+  } as unknown as ServicePackageExt;
+}
+
+function makePackageParam(
+  packageId: string,
+  qty = 1
+): ApiServicePackageParams {
+  return { packageId, chosenQuantity: qty };
+}
+
+describe("apiTransformPackagesToPackageInputs", () => {
+  it("returns empty array when no packages are provided", () => {
+    expect(apiTransformPackagesToPackageInputs([], [])).toEqual([]);
+  });
+
+  it("maps package params to their matching ServicePackageExt", () => {
+    const servicePackages = [makePackageExt("p1"), makePackageExt("p2")];
+    const packagesApi = [makePackageParam("p1", 2)];
+
+    const result = apiTransformPackagesToPackageInputs(
+      packagesApi,
+      servicePackages
+    );
+
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("p1");
+    expect(result[0].chosenQuantity).toBe(2);
+  });
+
+  it("merges package params over the ServicePackageExt fields (params win)", () => {
+    const servicePackages = [makePackageExt("p1")];
+    const packagesApi = [
+      { packageId: "p1", chosenQuantity: 5, extra: "field" } as any,
+    ];
+
+    const result = apiTransformPackagesToPackageInputs(
+      packagesApi,
+      servicePackages
+    );
+    expect(result[0].chosenQuantity).toBe(5);
+  });
+
+  it("throws when a packageId does not match any ServicePackageExt", () => {
+    const servicePackages = [makePackageExt("p1")];
+    const packagesApi = [makePackageParam("ghost-id")];
+
+    expect(() =>
+      apiTransformPackagesToPackageInputs(packagesApi, servicePackages)
+    ).toThrow(/Failed to match package with id: ghost-id/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// servicePriceToBookToApiPackages
+// ---------------------------------------------------------------------------
+
+describe("servicePriceToBookToApiPackages", () => {
+  it("returns empty array when priceToBook has no packages", () => {
+    const priceToBook = {
+      packages: [],
+    } as unknown as FrontendServiceGetPriceToBookResult;
+
+    expect(servicePriceToBookToApiPackages(priceToBook)).toEqual([]);
+  });
+
+  it("maps priceToBook packages to ApiServicePackageParams", () => {
+    const priceToBook = {
+      packages: [
+        { packageId: "p1", chosenQuantity: 2, costPQCents: 5000 },
+        { packageId: "p2", chosenQuantity: 1, costPQCents: 8000 },
+      ],
+    } as unknown as FrontendServiceGetPriceToBookResult;
+
+    const result = servicePriceToBookToApiPackages(priceToBook);
+
+    expect(result).toEqual([
+      { packageId: "p1", chosenQuantity: 2 },
+      { packageId: "p2", chosenQuantity: 1 },
+    ]);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // serviceBookingParamsToLuxon
 // ---------------------------------------------------------------------------

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

@@ -0,0 +1,217 @@
+import { DateTime } from "luxon";
+
+import {
+  frontendServiceGetPriceToBook,
+  frontendServiceGetPriceToBookFees,
+  ServicePackageInput,
+} from "../frontendServiceBookingUtils";
+import type { ServiceAttendeeOption } from "../attendeeOptionUtils";
+import type { ServiceRatesAssociationExt } from "../../../extendedSchemas";
+import type { LuxonDateRange } from "../../luxonUtils";
+
+function makeRange(startISO: string, endISO: string): LuxonDateRange {
+  return {
+    start: DateTime.fromISO(startISO, { zone: "utc" }),
+    end: DateTime.fromISO(endISO, { zone: "utc" }),
+  };
+}
+
+function makeFlatRateAssociation(
+  flatRateCents = 20000
+): ServiceRatesAssociationExt {
+  return {
+    serviceId: "svc-1",
+    serviceGeneralRates: {
+      flatRateCents,
+      hourlyRateCents: null,
+      dailyRateCents: null,
+      minimumTimeBlockHours: null,
+      cleaningFeePerBookingCents: 0,
+    },
+    serviceSpecialRates: [],
+    serviceDailyRates: [],
+  } as unknown as ServiceRatesAssociationExt;
+}
+
+function makeTimeBasedAssociation(
+  hourlyRateCents = 5000
+): ServiceRatesAssociationExt {
+  return {
+    serviceId: "svc-1",
+    serviceGeneralRates: {
+      flatRateCents: null,
+      hourlyRateCents,
+      dailyRateCents: null,
+      minimumTimeBlockHours: null,
+      cleaningFeePerBookingCents: 0,
+    },
+    serviceSpecialRates: [],
+    serviceDailyRates: [],
+  } as unknown as ServiceRatesAssociationExt;
+}
+
+function makePackageInput(
+  overrides: Partial<ServicePackageInput> = {}
+): ServicePackageInput {
+  return {
+    id: "pkg-1",
+    name: "Gold DJ Package",
+    description: "",
+    priceCents: 10000,
+    serviceAddons: [],
+    chosenQuantity: 1,
+    ...overrides,
+  } as unknown as ServicePackageInput;
+}
+
+const ATTENDEE_OPTION = null as unknown as ServiceAttendeeOption;
+const RANGE_2H = makeRange("2025-07-01T09:00:00Z", "2025-07-01T11:00:00Z");
+
+describe("frontendServiceGetPriceToBookFees — packages", () => {
+  it("returns an empty packages array and adds nothing to the subtotal when no packages are given", () => {
+    const result = frontendServiceGetPriceToBookFees(
+      makeFlatRateAssociation(20000),
+      {
+        daysToBookParams: [{ dateTimeRange: RANGE_2H, fees: [], addOns: [] }],
+        selectedAttendeeOption: ATTENDEE_OPTION,
+        additionalFees: [],
+        addOns: [],
+        timezone: "UTC",
+      }
+    );
+
+    expect(result.packages).toEqual([]);
+    expect(result.subtotalBeforeTaxesCents).toBe(20000);
+  });
+
+  it("folds a single package's cost into the subtotal", () => {
+    const result = frontendServiceGetPriceToBookFees(
+      makeFlatRateAssociation(20000),
+      {
+        daysToBookParams: [{ dateTimeRange: RANGE_2H, fees: [], addOns: [] }],
+        selectedAttendeeOption: ATTENDEE_OPTION,
+        additionalFees: [],
+        addOns: [],
+        packages: [makePackageInput({ priceCents: 15000, chosenQuantity: 1 })],
+        timezone: "UTC",
+      }
+    );
+
+    expect(result.packages).toHaveLength(1);
+    expect(result.packages[0]).toMatchObject({
+      packageId: "pkg-1",
+      chosenQuantity: 1,
+      costPQCents: 15000,
+    });
+    expect(result.subtotalBeforeTaxesCents).toBe(20000 + 15000);
+  });
+
+  it("multiplies a package's cost by chosenQuantity", () => {
+    const result = frontendServiceGetPriceToBookFees(
+      makeFlatRateAssociation(20000),
+      {
+        daysToBookParams: [{ dateTimeRange: RANGE_2H, fees: [], addOns: [] }],
+        selectedAttendeeOption: ATTENDEE_OPTION,
+        additionalFees: [],
+        addOns: [],
+        packages: [makePackageInput({ priceCents: 15000, chosenQuantity: 3 })],
+        timezone: "UTC",
+      }
+    );
+
+    expect(result.packages[0].chosenQuantity).toBe(3);
+    expect(result.subtotalBeforeTaxesCents).toBe(20000 + 15000 * 3);
+  });
+
+  it("sums multiple distinct packages into the subtotal", () => {
+    const result = frontendServiceGetPriceToBookFees(
+      makeFlatRateAssociation(20000),
+      {
+        daysToBookParams: [{ dateTimeRange: RANGE_2H, fees: [], addOns: [] }],
+        selectedAttendeeOption: ATTENDEE_OPTION,
+        additionalFees: [],
+        addOns: [],
+        packages: [
+          makePackageInput({
+            id: "pkg-1",
+            priceCents: 15000,
+            chosenQuantity: 1,
+          }),
+          makePackageInput({
+            id: "pkg-2",
+            priceCents: 8000,
+            chosenQuantity: 2,
+          }),
+        ],
+        timezone: "UTC",
+      }
+    );
+
+    expect(result.packages).toHaveLength(2);
+    expect(result.subtotalBeforeTaxesCents).toBe(20000 + 15000 + 8000 * 2);
+  });
+
+  it("defaults chosenQuantity to 0 when not provided", () => {
+    const result = frontendServiceGetPriceToBookFees(
+      makeFlatRateAssociation(20000),
+      {
+        daysToBookParams: [{ dateTimeRange: RANGE_2H, fees: [], addOns: [] }],
+        selectedAttendeeOption: ATTENDEE_OPTION,
+        additionalFees: [],
+        addOns: [],
+        packages: [
+          makePackageInput({ priceCents: 15000, chosenQuantity: undefined }),
+        ],
+        timezone: "UTC",
+      }
+    );
+
+    expect(result.packages[0].chosenQuantity).toBe(0);
+    expect(result.subtotalBeforeTaxesCents).toBe(20000);
+  });
+
+  it("applies package pricing on top of time-based (hourly) bookings too", () => {
+    const result = frontendServiceGetPriceToBookFees(
+      makeTimeBasedAssociation(5000),
+      {
+        daysToBookParams: [{ dateTimeRange: RANGE_2H, fees: [], addOns: [] }],
+        selectedAttendeeOption: ATTENDEE_OPTION,
+        additionalFees: [],
+        addOns: [],
+        packages: [makePackageInput({ priceCents: 12000, chosenQuantity: 1 })],
+        timezone: "UTC",
+      }
+    );
+
+    // 2 hours @ $50/hr = $100 in day totals, plus the $120 package.
+    expect(result.daysTotalBeforeTaxesCents).toBe(10000);
+    expect(result.subtotalBeforeTaxesCents).toBe(10000 + 12000);
+  });
+});
+
+describe("frontendServiceGetPriceToBook — packages", () => {
+  it("passes packages through to frontendServiceGetPriceToBookFees", () => {
+    const result = frontendServiceGetPriceToBook(makeFlatRateAssociation(20000), {
+      addOns: [],
+      packages: [makePackageInput({ priceCents: 5000, chosenQuantity: 2 })],
+      selectedAttendeeOption: ATTENDEE_OPTION,
+      bookingDateTimeRanges: [RANGE_2H],
+      timezone: "UTC",
+    });
+
+    expect(result.packages).toHaveLength(1);
+    expect(result.subtotalBeforeTaxesCents).toBe(20000 + 5000 * 2);
+  });
+
+  it("defaults to an empty packages array when packages is omitted", () => {
+    const result = frontendServiceGetPriceToBook(makeFlatRateAssociation(20000), {
+      addOns: [],
+      selectedAttendeeOption: ATTENDEE_OPTION,
+      bookingDateTimeRanges: [RANGE_2H],
+      timezone: "UTC",
+    });
+
+    expect(result.packages).toEqual([]);
+    expect(result.subtotalBeforeTaxesCents).toBe(20000);
+  });
+});

package/src/utils/service/apiServiceBookingApiUtils.ts

@@ -5,6 +5,7 @@ import {
   ApiServiceBookedDayParams,
   ApiServiceBookedDayParamsLuxon,
   ApiServiceBookingParams,
+  ApiServicePackageParams,
   ApiServicePriceToBookResult,
 } from "../../definitions.js";
 import {
@@ -13,8 +14,10 @@ import {
   ServiceBookingDayExt,
   ServiceBookingExt,
   ServiceBookingFeeExt,
+  ServiceBookingPackageExt,
   ServiceBookingPriceBreakdownExt,
   ServiceExt,
+  ServicePackageExt,
 } from "../../extendedSchemas.js";
 import { dateTimeFromString, dateTimeRangeFromDates } from "../luxonUtils.js";
 import { serviceAttendeeOptions } from "./attendeeOptionUtils.js";
@@ -22,6 +25,7 @@ import {
   FrontendServiceBookingDayInfo,
   FrontendServiceGetPriceToBookResult,
   ServiceAddonInput,
+  ServicePackageInput,
 } from "./frontendServiceBookingUtils.js";
 import {
   ServiceBookingPriceBreakdownBaseT,
@@ -79,6 +83,31 @@ export function apiTransformAddOnsToAddonInputs<
   });
 }
 
+export function apiTransformPackagesToPackageInputs<
+  PackageParams_t extends ApiServicePackageParams
+>(
+  packagesApi: PackageParams_t[],
+  servicePackages: ServicePackageExt[]
+): ServicePackageInput[] {
+  // Create a Map for faster lookup by packageId
+  const packageMap = new Map<string, ServicePackageExt>(
+    servicePackages.map((pkg) => [pkg.id, pkg])
+  );
+
+  return packagesApi.map((packageApi) => {
+    const matchedPackage = packageMap.get(packageApi.packageId);
+    if (!matchedPackage) {
+      throw new Error(
+        `Failed to match package with id: ${packageApi.packageId}`
+      );
+    }
+    return {
+      ...matchedPackage,
+      ...packageApi,
+    } as ServicePackageInput;
+  });
+}
+
 export function apiTransformBookedDays(
   priceToBook: ApiServicePriceToBookResult
 ): Partial<ServiceBookingDayExt>[] {
@@ -108,6 +137,8 @@ export function apiTransformBookedDays(
       startDate: day.dateTimeRange.start.toJSDate(),
       endDate: day.dateTimeRange.end.toJSDate(),
       addOns: addOns,
+      // Packages are booking-level bundles (see servicePriceToBookToApiBookingBase),
+      // not tied to a specific day, so this stays empty here.
       packages: [],
       fees: day.fees as ServiceBookingFeeExt[],
       priceBreakdown: priceBreakdown,
@@ -164,6 +195,7 @@ export function serviceGetPriceToBookFromBooking(
     flatRateCents: booking.flatRateCents,
     additionalFees: booking.additionalFees,
     addOns: booking.addOns,
+    packages: booking.packages,
     daysTotalBeforeTaxesCents: booking.daysTotalATBCents,
     subtotalBeforeTaxesCents: booking.subtotalATBCents,
     totalBeforeTaxesCents: booking.totalATBCents,
@@ -234,6 +266,18 @@ export function servicePriceToBookToApiDays(
 
   return bookedDays;
 }
+
+export function servicePriceToBookToApiPackages(
+  priceToBook: FrontendServiceGetPriceToBookResult
+): ApiServicePackageParams[] {
+  return priceToBook.packages.map(
+    (pkg): ApiServicePackageParams => ({
+      packageId: pkg.packageId,
+      chosenQuantity: pkg.chosenQuantity,
+    })
+  );
+}
+
 export interface ServicePriceToBookToApiBookingBaseArgs {
   bookingType: ServiceBookingType;
   status: ServiceBookingStatus;
@@ -260,6 +304,14 @@ export function servicePriceToBookToApiBookingBase({
       costPQCents: addOn.costPQCents,
     })
   );
+  const packages = priceToBook.packages.map(
+    (pkg): Partial<ServiceBookingPackageExt> => ({
+      packageId: pkg.packageId,
+      package: pkg.package,
+      chosenQuantity: pkg.chosenQuantity,
+      costPQCents: pkg.costPQCents,
+    })
+  );
 
   return {
     bookingType: bookingType,
@@ -273,7 +325,7 @@ export function servicePriceToBookToApiBookingBase({
     subtotalATBCents: priceToBook.subtotalBeforeTaxesCents,
     totalATBCents: priceToBook.totalBeforeTaxesCents,
     addOns: addOns as ServiceBookingAddOnExt[],
-    packages: [],
+    packages: packages as ServiceBookingPackageExt[],
     allowPromiseToPay: allowPromiseToPay,
     isFreeGuest: isFreeGuest,
     // Phase 3 — providers opt in per-booking when they want BP-paid tickets

package/src/utils/service/frontendServiceBookingUtils.ts

@@ -10,6 +10,7 @@ import {
   ServiceBookingFeeExt,
   ServiceBookingPriceBreakdownExt,
   ServiceDailyRatesExt,
+  ServicePackageExt,
   ServiceRatesAssociationExt,
   ServiceSpecialRatesExt,
 } from "../../extendedSchemas.js";
@@ -31,16 +32,20 @@ import {
   ServiceBookingFeeBase,
   ServiceBookingPriceBreakdownBaseT,
   ServiceBookingAddOnBase,
+  ServiceBookingPackageBase,
 } from "./serviceBookingTypes.js";
 import {
   calculateStripeProcessingFeeCents,
   convertDollarsToCents,
 } from "../paymentUtils.js";
-
 export interface ServiceAddonInput extends ServiceAddon {
   chosenQuantity?: number;
 }
 
+export interface ServicePackageInput extends ServicePackageExt {
+  chosenQuantity?: number;
+}
+
 export interface FrontendServiceBookingDayInfoParams {
   dateTimeRange: LuxonDateRange;
   fees: ServiceBookingFeeBase[];
@@ -70,6 +75,7 @@ export interface FrontendServiceGetPriceToBookResult {
   flatRateCents?: number; //only valid on flatRate
 
   addOns: ServiceBookingAddOnBase[]; //for bookings that do not bill by the time. e.g. flat rate bookings. For time based bookings, addOns are part of the day
+  packages: ServiceBookingPackageBase[]; //booking-level bundled packages, independent of hourly/daily/flat rate option
 
   daysTotalBeforeTaxesCents: number;
   subtotalBeforeTaxesCents: number; //sum of all daysTotalBeforeTaxesCents, plus addOns/packages
@@ -197,6 +203,7 @@ export interface FrontendServiceGetPriceToBookFeesParams {
 
   additionalFees: ServiceBookingFeeBase[];
   addOns: ServiceAddonInput[]; //used for bookings that do not bill by the time. e.g. flat rate bookings
+  packages?: ServicePackageInput[]; //booking-level bundled packages, additive regardless of rate option
 
   // overlappingBusinessHours: LuxonDateRange[] | null;
   timezone: string | null | undefined;
@@ -208,6 +215,7 @@ export function frontendServiceGetPriceToBookFees(
     daysToBookParams,
     selectedAttendeeOption,
     addOns,
+    packages = [],
     additionalFees,
     // overlappingBusinessHours,
     timezone,
@@ -240,6 +248,19 @@ export function frontendServiceGetPriceToBookFees(
         })
       : [];
 
+  // Packages are booking-level bundled line items (e.g. "Gold DJ Package") and apply
+  // on top of the booking regardless of hourly/daily/flat rate option.
+  const usedPackages: ServiceBookingPackageBase[] = packages.map(
+    (pkg): ServiceBookingPackageBase => {
+      return {
+        package: pkg,
+        packageId: pkg.id,
+        chosenQuantity: pkg.chosenQuantity ?? 0,
+        costPQCents: pkg.priceCents,
+      };
+    }
+  );
+
   const bookingDayResults: FrontendServiceBookingDayInfo[] =
     frontendServiceGetBookingDayInfo({
       rateOption: rateOption,
@@ -286,7 +307,13 @@ export function frontendServiceGetPriceToBookFees(
     0
   );
 
-  const subtotalBeforeTaxesCents = daysTotalBeforeTaxesCents + addOnsTotalCents;
+  const packagesTotalCents = usedPackages.reduce(
+    (sofar, pkg) => sofar + pkg.costPQCents * pkg.chosenQuantity,
+    0
+  );
+
+  const subtotalBeforeTaxesCents =
+    daysTotalBeforeTaxesCents + addOnsTotalCents + packagesTotalCents;
 
   if (!hasCustomProcessingFee) {
     // Same pass-through formula as bash ticket/donation checkout (STRIPE_PROCESSING_FEE).
@@ -319,6 +346,7 @@ export function frontendServiceGetPriceToBookFees(
     totalWithFees: totalBeforeTaxesCents, // Same as totalBeforeTaxesCents
     additionalFees: allAdditionalFees,
     addOns: usedAddons,
+    packages: usedPackages,
     minimumTimeBlockHours: minimumTimeBlockHours,
     rateOption: rateOption,
     flatRateCents:
@@ -330,6 +358,7 @@ export function frontendServiceGetPriceToBookFees(
 
 export interface FrontendServiceGetPriceToBookParams {
   addOns: ServiceAddonInput[];
+  packages?: ServicePackageInput[];
 
   selectedAttendeeOption: ServiceAttendeeOption;
 
@@ -343,6 +372,7 @@ export function frontendServiceGetPriceToBook(
   serviceRatesAssociation: ServiceRatesAssociationExt | null | undefined,
   {
     addOns,
+    packages = [],
     selectedAttendeeOption,
     bookingDateTimeRanges, //list of dateTime ranges to book
     // overlappingBusinessHours,
@@ -380,6 +410,7 @@ export function frontendServiceGetPriceToBook(
     selectedAttendeeOption: selectedAttendeeOption,
     additionalFees: [],
     addOns: addOns,
+    packages: packages,
     timezone: timezone,
   });
 }

package/src/utils/service/serviceBookingTypes.ts

@@ -2,6 +2,7 @@ import { ServiceBookingType, ServiceBookingStatus } from "@prisma/client";
 import {
   ServiceBookingAddOnExt,
   ServiceBookingFeeExt,
+  ServiceBookingPackageExt,
   ServiceBookingPriceBreakdownExt,
   ServiceBookingDayExt,
   ServiceDailyRatesExt,
@@ -21,7 +22,7 @@ export type ServiceBookingAddOnBase = Omit<
   | "serviceBooking"
 >;
 export type ServiceBookingPackageBase = Omit<
-  ServiceBookingAddOnExt,
+  ServiceBookingPackageExt,
   | "id"
   | "serviceBookingDayId"
   | "serviceBookingDay"