@final-commerce/command-frame 0.10.0-staging.1 → 0.10.0-staging.3

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

@@ -2,14 +2,6 @@ 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);
-    // 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 held = await mockHoldBooking(params);
-    if (!held.success || !held.booking) {
-        return { success: false, reason: held.reason, timestamp: new Date().toISOString() };
-    }
-    const booking = held.booking;
     // An unknown product used to be sold as "Booking" at zero. The host refuses it, and a mock that
     // quietly sells something no catalogue contains teaches a screen a case that cannot happen.
     const product = MOCK_PRODUCTS.find(({ _id }) => _id === params.productId);
@@ -27,6 +19,18 @@ export const mockAddBookingToCart = async (params) => {
             timestamp: new Date().toISOString(),
         };
     }
+    // Same refusal and text as the host (kaching add-booking-to-cart).
+    if (product.notSoldInPos || variant?.notSoldInPos) {
+        return { success: false, reason: `${product.name} is not sold in POS`, timestamp: new Date().toISOString() };
+    }
+    // One call, two effects — the window is claimed AND the service is in the cart. Like the host, the
+    // claim comes after the product checks and before the line; its refusal propagates: a cart line for
+    // a window somebody else took is worse than no line at all.
+    const held = await mockHoldBooking(params);
+    if (!held.success || !held.booking) {
+        return { success: false, reason: held.reason, timestamp: new Date().toISOString() };
+    }
+    const booking = held.booking;
     const price = variant?.price ?? product.minPrice ?? 0;
     const reservation = {
         internalId: `res_${booking.id}`,

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

@@ -79,6 +79,10 @@ export const mockAddProductToCart = async (params) => {
         }
         compositeLine = line;
     }
+    // Same refusal and text as the host (kaching add-product-to-cart).
+    if (product.notSoldInPos || variant.notSoldInPos) {
+        throw new Error(`${product.name} is not sold in POS`);
+    }
     // A measured variant carries a resolved unit; the host does the same. What the unit can
     // express is its precision — 1.5 of a kilogram is a sale, 1.5 of a piece is a typo.
     const unit = variant.unitId ? resolveUnit(variant.unitId) : undefined;
@@ -182,6 +186,10 @@ export function compositePicksRefusal(composite, picks) {
         if (!composite.parts.length)
             return 'This composite has no parts on this till yet';
         const blocking = composite.parts.find((part) => part.min > 0 && !part.items.some((item) => !item.unavailable || item.unavailable === 'by_date'));
+        // FT-151: a part blocked by the sold-out mark says so, as the host does.
+        const marked = blocking?.items.find((item) => item.unavailable === 'marked_sold_out');
+        if (marked)
+            return `${marked.name}: marked sold out`;
         return blocking
             ? `${blocking.name ?? 'Choose'}: nothing can be picked at this outlet`
             : 'This composite is unavailable: a part it needs has nothing to pick';
@@ -199,6 +207,8 @@ export function compositePicksRefusal(composite, picks) {
             return `${item.name}: choose a date and time`;
         if (item.unavailable === 'fully_booked')
             return `${item.name} is fully booked at that time`;
+        if (item.unavailable === 'marked_sold_out')
+            return `${item.name}: marked sold out`;
         if (item.unavailable)
             return `${item.name} is not available`;
         const choice = item.choices.find((candidate) => candidate.variantId === pick.variantId);

package/dist/actions/get-products/mock.js

@@ -15,6 +15,19 @@ export const mockGetProducts = async (params) => {
     if (!JSON.stringify(query).includes('productType')) {
         products = products.filter((p) => p.productType !== 'booking');
     }
+    // Same as the host: `true` = flagged, `false` = not flagged (missing counts).
+    for (const flag of ['notSoldInPos', 'notSoldOnline']) {
+        if (typeof query[flag] === 'boolean')
+            products = products.filter((p) => !!p[flag] === query[flag]);
+    }
+    if (!params?.includeUnlisted) {
+        // Same as the host: flagged variants are stripped, a product left with none is dropped.
+        if (query.notSoldInPos === undefined)
+            products = products.filter((p) => !p.notSoldInPos);
+        products = products
+            .filter((p) => !p.variants.length || p.variants.some((v) => !v.notSoldInPos))
+            .map((p) => ({ ...p, variants: p.variants.filter((v) => !v.notSoldInPos) }));
+    }
     if (query.searchValue) {
         const search = String(query.searchValue).toLowerCase();
         products = products.filter((p) => p.name.toLowerCase().includes(search) || p.sku?.toLowerCase().includes(search));

package/dist/actions/get-products/types.d.ts

@@ -42,8 +42,24 @@ export interface GetProductsParams {
         };
         supplier?: string;
         externalId?: string;
+        /**
+         * Product-level flag filter. `true` = only products flagged `notSoldInPos`; `false` = only
+         * products NOT flagged (a missing field counts as not flagged). Naming it switches off the
+         * default `notSoldInPos` exclusion, so `true` works without `includeUnlisted`.
+         */
+        notSoldInPos?: boolean;
+        /** Product-level flag filter: `true` = flagged `notSoldOnline`; `false` = sold online (missing counts). */
+        notSoldOnline?: boolean;
         [key: string]: any;
     };
+    /**
+     * Products flagged `notSoldInPos` are left out unless this is `true` (default `false`) or the
+     * query names `notSoldInPos`. They still cannot be sold: `addProductToCart` / `addBookingToCart`
+     * refuse a product or a variant flagged `notSoldInPos`. Without it, flagged variants are also
+     * stripped from `variants[]` and a product whose every variant is flagged is left out — whatever
+     * `query.notSoldInPos` says.
+     */
+    includeUnlisted?: boolean;
     /** Defaults to 0. */
     offset?: number;
     /** Defaults to 100. */

package/dist/actions/resume-parked-order/mock.d.ts

@@ -1,2 +1,2 @@
-import { ResumeParkedOrder } from "./types";
+import { ResumeParkedOrder } from './types';
 export declare const mockResumeParkedOrder: ResumeParkedOrder;

package/dist/actions/resume-parked-order/mock.js

@@ -1,11 +1,11 @@
-import { MOCK_PARKED_ORDERS, MOCK_CART, resetMockCart, mockPublishEvent } from "../../demo/database";
+import { MOCK_PARKED_ORDERS, MOCK_CART, MOCK_PRODUCTS, resetMockCart, mockPublishEvent } from '../../demo/database';
 export const mockResumeParkedOrder = async (params) => {
-    console.log("[Mock] resumeParkedOrder called", params);
+    console.log('[Mock] resumeParkedOrder called', params);
     const orderId = params?.orderId;
     let orderToResume = null;
     let index = -1;
     if (orderId) {
-        index = MOCK_PARKED_ORDERS.findIndex(o => o._id === orderId);
+        index = MOCK_PARKED_ORDERS.findIndex((o) => o._id === orderId);
         if (index !== -1)
             orderToResume = MOCK_PARKED_ORDERS[index];
     }
@@ -17,8 +17,14 @@ export const mockResumeParkedOrder = async (params) => {
         }
     }
     if (!orderToResume) {
-        throw new Error("Parked order not found");
+        throw new Error('Parked order not found');
     }
+    // Same refusal and text as the host, before anything is restored: the parked order stays.
+    const notSoldNames = orderToResume.lineItems
+        .filter((li) => MOCK_PRODUCTS.some((p) => p.variants.some((v) => v._id === li.variantId && (p.notSoldInPos || v.notSoldInPos))))
+        .map((li) => li.name);
+    if (notSoldNames.length)
+        throw new Error(`${notSoldNames.join(', ')} is not sold in POS`);
     // Restore to MOCK_CART
     // Logic to convert Order back to Cart (simplified)
     resetMockCart();
@@ -26,7 +32,7 @@ export const mockResumeParkedOrder = async (params) => {
     MOCK_CART.customer = orderToResume.customer; // Cast if needed
     // MOCK_CART.products = orderToResume.lineItems... (Mapping needed)
     // For Mock demo, we'll do a best effort mapping
-    MOCK_CART.products = orderToResume.lineItems.map(li => ({
+    MOCK_CART.products = orderToResume.lineItems.map((li) => ({
         id: li.productId,
         name: li.name,
         quantity: li.quantity,
@@ -36,8 +42,8 @@ export const mockResumeParkedOrder = async (params) => {
         sku: li.sku,
         images: [li.image],
         stock: 100,
-        taxTableId: "",
-        attributes: li.attributes
+        taxTableId: '',
+        attributes: li.attributes,
     }));
     MOCK_CART.subtotal = orderToResume.summary.subtotalAfterFees;
     MOCK_CART.total = orderToResume.summary.total;
@@ -46,11 +52,11 @@ export const mockResumeParkedOrder = async (params) => {
     // Remove from parked
     MOCK_PARKED_ORDERS.splice(index, 1);
     // Refresh the restored cart and the order lists.
-    mockPublishEvent("cart", "parked-order-resumed", { orderId });
-    mockPublishEvent("orders", "parked-order-resumed", { orderId });
+    mockPublishEvent('cart', 'parked-order-resumed', { orderId });
+    mockPublishEvent('orders', 'parked-order-resumed', { orderId });
     return {
         success: true,
         order: orderToResume,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/update-cart-item-quantity/mock.js

@@ -1,4 +1,4 @@
-import { MOCK_CART, mockPublishEvent } from '../../demo/database';
+import { MOCK_CART, MOCK_PRODUCTS, mockPublishEvent } from '../../demo/database';
 import { extendPrice, isValidQuantity } from '@final-commerce/common';
 export const mockUpdateCartItemQuantity = (params) => {
     console.log('[Mock] updateCartItemQuantity called', params);
@@ -44,6 +44,12 @@ export const mockUpdateCartItemQuantity = (params) => {
             timestamp: new Date().toISOString(),
         });
     }
+    // Same refusal and text as the host: raising a line not sold in POS (lowering always works).
+    const source = MOCK_PRODUCTS.find((p) => p.variants.some((v) => v._id === product.variantId));
+    const variant = source?.variants.find((v) => v._id === product.variantId);
+    if (quantity > previousQuantity && (source?.notSoldInPos || variant?.notSoldInPos)) {
+        throw new Error(`${source?.name} is not sold in POS`);
+    }
     // Update quantity
     product.quantity = quantity;
     // Difference of the two ROUNDED extensions — rounding the delta itself would let the

package/package.json

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