@final-commerce/command-frame 0.7.0-staging.3 → 0.7.0-staging.5

package/dist/actions/add-booking-to-cart/mock.js

@@ -1,8 +1,44 @@
+import { ReservationStatus } from '@final-commerce/common';
+import { MOCK_CART, MOCK_PRODUCTS, mockPublishEvent } from '../../demo/database';
 import { mockHoldBooking } from '../hold-booking/mock';
 export const mockAddBookingToCart = async (params) => {
     console.log('[Mock] addBookingToCart called', params);
-    // Same claim as holdBooking — including its refusal when the window is already taken. The mock
-    // cart is not modelled here; what a booking screen must handle is the refusal, not the line.
+    // One call, two effects — the window is claimed AND the service is in the cart. The claim goes
+    // first and its refusal propagates: a cart line for a window somebody else took is worse than
+    // no line at all.
     const { booking } = await mockHoldBooking(params);
-    return { booking, reservationInternalId: `res_${booking.id}`, timestamp: new Date().toISOString() };
+    const product = MOCK_PRODUCTS.find(({ _id }) => _id === params.productId);
+    const variant = params.variantId
+        ? product?.variants?.find(({ _id }) => _id === params.variantId)
+        : product?.variants?.[0];
+    const price = variant?.price ?? product?.minPrice ?? 0;
+    const reservation = {
+        internalId: `res_${booking.id}`,
+        bookingId: booking.id,
+        productId: params.productId,
+        variantId: variant?._id ?? null,
+        resourceId: params.resourceId,
+        name: product?.name ?? 'Booking',
+        resourceName: booking.resourceName,
+        price,
+        quantity: 1,
+        total: price,
+        taxTableId: product?.taxTable,
+        startAt: booking.startAt,
+        endAt: booking.endAt,
+        bufferEndAt: booking.bufferEndAt,
+        status: ReservationStatus.HELD,
+        expiresAt: booking.expiresAt,
+    };
+    if (!MOCK_CART.reservations)
+        MOCK_CART.reservations = [];
+    MOCK_CART.reservations.push(reservation);
+    MOCK_CART.subtotal += price;
+    MOCK_CART.total += price;
+    MOCK_CART.amountToBeCharged = MOCK_CART.total;
+    MOCK_CART.remainingBalance = MOCK_CART.total;
+    // The cart topic, not the bookings one: a screen that only watches bookings still has to
+    // repaint its cart, and every other cart mutation announces itself the same way.
+    mockPublishEvent('cart', 'reservation-added', { reservation });
+    return { booking, reservationInternalId: reservation.internalId, timestamp: new Date().toISOString() };
 };

package/dist/actions/remove-booking-from-cart/mock.js

@@ -1,11 +1,21 @@
-import { MOCK_BOOKINGS } from '../../demo/database';
+import { MOCK_BOOKINGS, MOCK_CART, mockPublishEvent } from '../../demo/database';
 export const mockRemoveBookingFromCart = async (params) => {
     console.log('[Mock] removeBookingFromCart called', params);
+    const reservations = MOCK_CART.reservations ?? [];
+    const cartIndex = reservations.findIndex(({ internalId }) => internalId === params.reservationInternalId);
+    const [removed] = cartIndex >= 0 ? reservations.splice(cartIndex, 1) : [];
+    if (removed) {
+        const line = removed.total || removed.price * (removed.quantity ?? 1);
+        MOCK_CART.subtotal -= line;
+        MOCK_CART.total -= line;
+        MOCK_CART.amountToBeCharged = MOCK_CART.total;
+        MOCK_CART.remainingBalance = MOCK_CART.total;
+        mockPublishEvent('cart', 'reservation-removed', { reservation: removed });
+    }
     // The hold has to go back, or the mock is a trap: `addBookingToCart` pushes into the very list
     // availability reads, so add → remove → add the same slot used to refuse forever with "that
-    // window has just been taken". The reservation id the mock hands out is `res_<booking.id>`,
-    // which is the only link back to the row.
-    const bookingId = params.reservationInternalId.replace(/^res_/, '');
+    // window has just been taken". The reservation id is `res_<booking.id>`, the link back to the row.
+    const bookingId = removed?.bookingId ?? params.reservationInternalId.replace(/^res_/, '');
     const index = MOCK_BOOKINGS.findIndex(({ id }) => id === bookingId);
     const [released] = index >= 0 ? MOCK_BOOKINGS.splice(index, 1) : [];
     return {

package/dist/demo/database.d.ts

@@ -15,6 +15,10 @@ export interface MockDatabaseConfig {
     products?: CFProduct[];
     orders?: CFActiveOrder[];
     parkedOrders?: CFActiveOrder[];
+    /** Who is scarce: the staff, rooms or machines the dataset's services are booked against. */
+    bookingResources?: CFBookingResource[];
+    /** Windows already taken when the dataset loads, so a calendar does not open empty. */
+    bookings?: CFBooking[];
 }
 export declare const MOCK_COMPANY: CFActiveCompany;
 export declare const MOCK_OUTLET_MAIN: CFActiveOutlet;

package/dist/demo/database.js

@@ -688,6 +688,7 @@ export let MOCK_CART = {
     remainingBalance: 0,
     products: [],
     customSales: [],
+    reservations: [],
     nonRevenueItems: [],
     customer: null,
 };
@@ -708,6 +709,7 @@ export const resetMockCart = () => {
         remainingBalance: 0,
         products: [],
         customSales: [],
+        reservations: [],
         nonRevenueItems: [],
         customer: null,
     };
@@ -752,6 +754,12 @@ export function setMockDatabase(config) {
     if (config.parkedOrders !== undefined) {
         MOCK_PARKED_ORDERS.splice(0, MOCK_PARKED_ORDERS.length, ...config.parkedOrders);
     }
+    if (config.bookingResources !== undefined) {
+        MOCK_BOOKING_RESOURCES.splice(0, MOCK_BOOKING_RESOURCES.length, ...config.bookingResources);
+    }
+    if (config.bookings !== undefined) {
+        MOCK_BOOKINGS.splice(0, MOCK_BOOKINGS.length, ...config.bookings);
+    }
     if (MOCK_OUTLETS.length > 0) {
         Object.assign(MOCK_OUTLET_MAIN, MOCK_OUTLETS[0]);
         if (MOCK_OUTLET_MAIN.id === undefined && MOCK_OUTLET_MAIN._id !== undefined) {
@@ -888,6 +896,30 @@ export const createOrderFromCart = (paymentType, amount, processor = 'cash') =>
         billing: MOCK_CART.customer?.billing || null,
         shipping: MOCK_CART.customer?.shipping || null,
         lineItems,
+        // A paid booking is a sale: it belongs on the order (and thus the receipt),
+        // in its own array rather than among the line items, and CONFIRMED — payment
+        // is what turns a held window into a kept appointment.
+        reservations: (MOCK_CART.reservations ?? []).map((reservation) => ({
+            internalId: reservation.internalId,
+            bookingId: reservation.bookingId,
+            productId: reservation.productId,
+            variantId: reservation.variantId,
+            resourceId: reservation.resourceId,
+            name: reservation.name,
+            resourceName: reservation.resourceName,
+            price: reservation.price,
+            quantity: reservation.quantity,
+            total: reservation.total,
+            taxTableId: reservation.taxTableId,
+            startAt: reservation.startAt,
+            endAt: reservation.endAt,
+            bufferEndAt: reservation.bufferEndAt,
+            // The mock computes no tax anywhere — line items ship `taxes: []` too.
+            taxes: [],
+            // `expiresAt` deliberately does not come along: a paid booking has no
+            // clock left to run out, which is what CONFIRMED means.
+            status: ReservationStatus.CONFIRMED,
+        })),
         customSales: [],
         balance: 0,
         user: employeeUser,
@@ -935,9 +967,11 @@ const SLOT_MINUTES = 30;
 const BUFFER_MINUTES = 5;
 const OPEN_HOUR = 9;
 const CLOSE_HOUR = 18;
+// Rooms, not people: a resource is whatever is scarce, and a room is the case that
+// reads the same in every vertical a dataset might describe.
 export const MOCK_BOOKING_RESOURCES = [
-    { id: 'res_marco', name: 'Marco', kind: BookingResourceKind.STAFF },
-    { id: 'res_jessica', name: 'Jessica', kind: BookingResourceKind.STAFF },
+    { id: 'res_room_1', name: 'Room 1', kind: BookingResourceKind.ROOM },
+    { id: 'res_room_2', name: 'Room 2', kind: BookingResourceKind.ROOM },
 ];
 const at = (dayOffset, hour, minute = 0) => {
     const date = new Date();
@@ -958,9 +992,9 @@ const booking = (id, resourceId, start, status, customerName) => ({
     customerName,
 });
 export const MOCK_BOOKINGS = [
-    booking('bk_1', 'res_marco', at(0, 10), ReservationStatus.CONFIRMED, 'Alex Green'),
-    booking('bk_2', 'res_jessica', at(0, 11, 30), ReservationStatus.CONFIRMED, 'Dana White'),
-    booking('bk_3', 'res_marco', at(1, 9, 30), ReservationStatus.CONFIRMED, 'Sam Blue'),
+    booking('bk_1', 'res_room_1', at(0, 10), ReservationStatus.CONFIRMED, 'Alex Green'),
+    booking('bk_2', 'res_room_2', at(0, 11, 30), ReservationStatus.CONFIRMED, 'Dana White'),
+    booking('bk_3', 'res_room_1', at(1, 9, 30), ReservationStatus.CONFIRMED, 'Sam Blue'),
 ];
 /** Live = confirmed, or held and not yet expired. An expired hold occupies nothing. */
 export const mockLiveBookings = () => MOCK_BOOKINGS.filter(({ status, expiresAt }) => status === ReservationStatus.CONFIRMED ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@final-commerce/command-frame",
-  "version": "0.7.0-staging.3",
+  "version": "0.7.0-staging.5",
   "description": "Commands Frame library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,7 +57,7 @@
     "ignoreBranchesMissingTickets": true
   },
   "dependencies": {
-    "@final-commerce/common": "2.3.0-staging.3"
+    "@final-commerce/common": "2.3.0-staging.4"
   },
   "devDependencies": {
     "@commitlint/cli": "^19.0.0",