@tallyui/pos 0.1.0

package/src/order/order-builder.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect } from 'vitest';
+import { firstValueFrom } from 'rxjs';
+import { createOrderBuilder } from './order-builder';
+import type { ProductTraits } from '@tallyui/core';
+import type { TaxContext } from '../tax/types';
+
+const traits: ProductTraits = {
+  getId: (doc) => doc.id,
+  getName: (doc) => doc.name,
+  getSku: (doc) => doc.sku ?? '',
+  getPrice: (doc) => String(doc.price),
+  getRegularPrice: (doc) => String(doc.price),
+  getSalePrice: () => undefined,
+  isOnSale: () => false,
+  getImageUrl: (doc) => doc.imageUrl,
+  getImageUrls: (doc) => doc.imageUrl ? [doc.imageUrl] : [],
+  getDescription: () => undefined,
+  getStockStatus: () => 'instock',
+  getStockQuantity: () => null,
+  hasVariants: () => false,
+  getType: () => 'simple',
+  getBarcode: () => undefined,
+  getCategoryNames: () => [],
+};
+
+const taxContext: TaxContext = {
+  getTaxRate: () => 0.1,
+  pricesIncludeTax: false,
+};
+
+const productDoc = { id: 'p1', name: 'Espresso', sku: 'ESP-001', price: 4.50 };
+const productDoc2 = { id: 'p2', name: 'Latte', sku: 'LAT-001', price: 5.00 };
+
+describe('OrderBuilder', () => {
+  it('starts with an empty draft order', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    const order = await firstValueFrom(builder.order$);
+    expect(order.status).toBe('draft');
+    expect(order.lineItems).toHaveLength(0);
+    expect(order.subtotal).toBe(0);
+    expect(order.total).toBe(0);
+  });
+
+  it('adds a product as a line item', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(1);
+    expect(order.lineItems[0].name).toBe('Espresso');
+    expect(order.lineItems[0].price).toBe(4.50);
+    expect(order.lineItems[0].quantity).toBe(1);
+    expect(order.lineItems[0].taxRate).toBe(0.1);
+  });
+
+  it('increments quantity when adding same product twice', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits);
+    builder.addProduct(productDoc, traits);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(1);
+    expect(order.lineItems[0].quantity).toBe(2);
+  });
+
+  it('treats different products as separate line items', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits);
+    builder.addProduct(productDoc2, traits);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(2);
+  });
+
+  it('calculates line totals with tax (exclusive)', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits);
+
+    const order = await firstValueFrom(builder.order$);
+    const line = order.lineItems[0];
+    expect(line.taxAmount).toBeCloseTo(0.45);
+    expect(line.lineTotal).toBeCloseTo(4.95);
+  });
+
+  it('calculates order totals', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits);
+    builder.addProduct(productDoc2, traits);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.subtotal).toBeCloseTo(9.50);
+    expect(order.taxTotal).toBeCloseTo(0.95);
+    expect(order.total).toBeCloseTo(10.45);
+    expect(order.balanceDue).toBeCloseTo(10.45);
+  });
+
+  it('updates line item quantity', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    const lineId = builder.addProduct(productDoc, traits);
+    builder.updateQuantity(lineId, 3);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems[0].quantity).toBe(3);
+    expect(order.subtotal).toBeCloseTo(13.50);
+  });
+
+  it('removes a line item', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    const lineId = builder.addProduct(productDoc, traits);
+    builder.addProduct(productDoc2, traits);
+    builder.removeItem(lineId);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(1);
+    expect(order.lineItems[0].name).toBe('Latte');
+  });
+
+  it('sets and clears customer', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.setCustomer({ id: 'c1', name: 'Alice', email: 'alice@example.com' });
+
+    let order = await firstValueFrom(builder.order$);
+    expect(order.customer?.name).toBe('Alice');
+
+    builder.setCustomer(null);
+    order = await firstValueFrom(builder.order$);
+    expect(order.customer).toBeNull();
+  });
+
+  it('sets note', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.setNote('Extra hot');
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.note).toBe('Extra hot');
+  });
+
+  it('clears the order', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits);
+    builder.setNote('Test');
+    builder.clear();
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(0);
+    expect(order.note).toBe('');
+    expect(order.subtotal).toBe(0);
+  });
+
+  it('handles tax-inclusive pricing', async () => {
+    const inclTax: TaxContext = { getTaxRate: () => 0.1, pricesIncludeTax: true };
+    const builder = createOrderBuilder({ currency: 'USD', taxContext: inclTax });
+    builder.addProduct(productDoc, traits);
+
+    const order = await firstValueFrom(builder.order$);
+    const line = order.lineItems[0];
+    expect(line.taxAmount).toBeCloseTo(0.41, 1);
+    expect(line.lineTotal).toBeCloseTo(4.50);
+    expect(order.subtotal).toBeCloseTo(4.09, 1);
+    expect(order.total).toBeCloseTo(4.50);
+  });
+
+  it('adds product with specific quantity', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits, { quantity: 5 });
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems[0].quantity).toBe(5);
+  });
+
+  it('removes line item when quantity set to 0', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    const lineId = builder.addProduct(productDoc, traits);
+    builder.updateQuantity(lineId, 0);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(0);
+    expect(order.subtotal).toBe(0);
+  });
+
+  it('removes line item when quantity set to negative', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    const lineId = builder.addProduct(productDoc, traits);
+    builder.updateQuantity(lineId, -1);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(0);
+  });
+
+  it('getSnapshot() matches order$ emission', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits);
+
+    const fromObservable = await firstValueFrom(builder.order$);
+    const fromSnapshot = builder.getSnapshot();
+    expect(fromSnapshot.id).toBe(fromObservable.id);
+    expect(fromSnapshot.lineItems).toEqual(fromObservable.lineItems);
+    expect(fromSnapshot.total).toBe(fromObservable.total);
+  });
+
+  it('clear() resets payments, customer, and discounts', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    const lineId = builder.addProduct(productDoc, traits);
+    builder.setCustomer({ id: 'c1', name: 'Alice' });
+    builder.addPayment({ method: 'cash', amount: 5 });
+    builder.applyLineDiscount(lineId, { type: 'fixed', value: 1 });
+    builder.applyOrderDiscount({ type: 'percentage', value: 10 });
+    builder.clear();
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(0);
+    expect(order.payments).toHaveLength(0);
+    expect(order.discounts).toHaveLength(0);
+    expect(order.customer).toBeNull();
+    expect(order.note).toBe('');
+  });
+
+  it('handles product with undefined price gracefully', async () => {
+    const noPriceTraits = { ...traits, getPrice: () => undefined };
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct({ id: 'p1', name: 'Free Item' }, noPriceTraits);
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems[0].price).toBe(0);
+    expect(order.total).toBe(0);
+  });
+
+  it('adds same product with different variantIds as separate lines', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits, { variantId: 'small' });
+    builder.addProduct(productDoc, traits, { variantId: 'large' });
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(2);
+  });
+
+  it('merges same product+variant on second add', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct(productDoc, traits, { variantId: 'small' });
+    builder.addProduct(productDoc, traits, { variantId: 'small' });
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.lineItems).toHaveLength(1);
+    expect(order.lineItems[0].quantity).toBe(2);
+  });
+});

package/src/order/order-builder.ts

@@ -0,0 +1,273 @@
+import { BehaviorSubject, type Observable } from 'rxjs';
+import type { ProductTraits } from '@tallyui/core';
+import type { TaxContext } from '../tax/types';
+import { calculateTax } from '../tax/calculate';
+import type {
+  Order,
+  LineItem,
+  Discount,
+  AppliedDiscount,
+  Payment,
+  CustomerSummary,
+} from './types';
+
+let nextId = 0;
+function uid(): string {
+  return `${Date.now()}-${++nextId}`;
+}
+
+export interface OrderBuilderOptions {
+  currency: string;
+  taxContext: TaxContext;
+  id?: string;
+}
+
+export interface OrderBuilder {
+  order$: Observable<Order>;
+  addProduct(doc: any, traits: ProductTraits, options?: { variantId?: string; quantity?: number }): string;
+  updateQuantity(lineId: string, quantity: number): void;
+  removeItem(lineId: string): void;
+  applyLineDiscount(lineId: string, discount: Discount): void;
+  applyOrderDiscount(discount: Discount): void;
+  removeDiscount(discountId: string): void;
+  addPayment(payment: Omit<Payment, 'id'>): string;
+  removePayment(paymentId: string): void;
+  setCustomer(customer: CustomerSummary | null): void;
+  setNote(note: string): void;
+  clear(): void;
+  getSnapshot(): Order;
+}
+
+export function createOrderBuilder(options: OrderBuilderOptions): OrderBuilder {
+  const { currency, taxContext } = options;
+  const orderId = options.id ?? uid();
+
+  let lineItems: LineItem[] = [];
+  let orderDiscounts: AppliedDiscount[] = [];
+  let payments: Payment[] = [];
+  let customer: CustomerSummary | null = null;
+  let note = '';
+  const now = new Date().toISOString();
+
+  const subject = new BehaviorSubject<Order>(buildOrder());
+
+  function recalculateLine(line: LineItem): LineItem {
+    const gross = line.price * line.quantity;
+
+    // Recompute discount amounts from current gross
+    const recalcedDiscounts = line.discounts.map((d) => ({
+      ...d,
+      amount: computeDiscountAmount(d, gross),
+    }));
+
+    const discountAmount = recalcedDiscounts.reduce((sum, d) => sum + d.amount, 0);
+    const afterDiscount = gross - discountAmount;
+    const tax = calculateTax(afterDiscount, line.taxRate, taxContext.pricesIncludeTax);
+
+    return {
+      ...line,
+      discounts: recalcedDiscounts,
+      discountAmount,
+      taxAmount: tax.taxAmount,
+      lineTotal: taxContext.pricesIncludeTax ? afterDiscount : afterDiscount + tax.taxAmount,
+    };
+  }
+
+  function computeDiscountAmount(discount: Discount, base: number): number {
+    if (discount.type === 'percentage') {
+      return Math.round((base * discount.value) / 100 * 100) / 100;
+    }
+    return Math.min(discount.value, base);
+  }
+
+  function buildOrder(): Order {
+    const subtotalLines = lineItems.reduce((sum, li) => {
+      const lineGross = li.price * li.quantity - li.discountAmount;
+      if (taxContext.pricesIncludeTax) {
+        const tax = calculateTax(lineGross, li.taxRate, true);
+        return sum + tax.priceExclTax;
+      }
+      return sum + lineGross;
+    }, 0);
+
+    const subtotal = Math.round(subtotalLines * 100) / 100;
+
+    const recalcedOrderDiscounts = orderDiscounts.map((d) => ({
+      ...d,
+      amount: computeDiscountAmount(d, subtotal),
+    }));
+
+    const discountTotal =
+      lineItems.reduce((sum, li) => sum + li.discountAmount, 0) +
+      recalcedOrderDiscounts.reduce((sum, d) => sum + d.amount, 0);
+
+    const taxTotal = lineItems.reduce((sum, li) => sum + li.taxAmount, 0);
+
+    const total = lineItems.reduce((sum, li) => sum + li.lineTotal, 0) -
+      recalcedOrderDiscounts.reduce((sum, d) => sum + d.amount, 0);
+
+    const roundedTotal = Math.round(total * 100) / 100;
+    const paidAmount = payments.reduce((sum, p) => sum + p.amount, 0);
+    const balanceDue = Math.max(0, Math.round((roundedTotal - paidAmount) * 100) / 100);
+    const changeDue = Math.max(0, Math.round((paidAmount - roundedTotal) * 100) / 100);
+
+    return {
+      id: orderId,
+      status: 'draft',
+      lineItems: [...lineItems],
+      discounts: recalcedOrderDiscounts,
+      payments: [...payments],
+      customer,
+      note,
+      subtotal,
+      discountTotal: Math.round(discountTotal * 100) / 100,
+      taxTotal: Math.round(taxTotal * 100) / 100,
+      total: roundedTotal,
+      balanceDue,
+      changeDue,
+      currency,
+      createdAt: now,
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  function emit() {
+    subject.next(buildOrder());
+  }
+
+  return {
+    order$: subject.asObservable(),
+
+    addProduct(doc, traits, opts) {
+      const productId = traits.getId(doc);
+      const variantId = opts?.variantId;
+      const quantity = opts?.quantity ?? 1;
+
+      const existing = lineItems.find(
+        (li) => li.productId === productId && li.variantId === variantId,
+      );
+
+      if (existing) {
+        existing.quantity += quantity;
+        lineItems = lineItems.map((li) =>
+          li.id === existing.id ? recalculateLine(existing) : li,
+        );
+        emit();
+        return existing.id;
+      }
+
+      const priceStr = traits.getPrice(doc);
+      const price = priceStr ? parseFloat(priceStr) : 0;
+      const taxRate = taxContext.getTaxRate();
+
+      const lineId = uid();
+      const line: LineItem = {
+        id: lineId,
+        productId,
+        variantId,
+        name: traits.getName(doc),
+        sku: traits.getSku(doc) ?? '',
+        imageUrl: traits.getImageUrl(doc),
+        price,
+        quantity,
+        taxRate,
+        taxAmount: 0,
+        discounts: [],
+        discountAmount: 0,
+        lineTotal: 0,
+      };
+
+      lineItems = [...lineItems, recalculateLine(line)];
+      emit();
+      return lineId;
+    },
+
+    updateQuantity(lineId, quantity) {
+      if (quantity <= 0) {
+        // Treat zero/negative as removal
+        lineItems = lineItems.filter((li) => li.id !== lineId);
+      } else {
+        lineItems = lineItems.map((li) =>
+          li.id === lineId ? recalculateLine({ ...li, quantity }) : li,
+        );
+      }
+      emit();
+    },
+
+    removeItem(lineId) {
+      lineItems = lineItems.filter((li) => li.id !== lineId);
+      emit();
+    },
+
+    applyLineDiscount(lineId, discount) {
+      lineItems = lineItems.map((li) => {
+        if (li.id !== lineId) return li;
+        const base = li.price * li.quantity;
+        const applied: AppliedDiscount = {
+          ...discount,
+          id: uid(),
+          amount: computeDiscountAmount(discount, base),
+        };
+        return recalculateLine({ ...li, discounts: [...li.discounts, applied] });
+      });
+      emit();
+    },
+
+    applyOrderDiscount(discount) {
+      const applied: AppliedDiscount = {
+        ...discount,
+        id: uid(),
+        amount: 0,
+      };
+      orderDiscounts = [...orderDiscounts, applied];
+      emit();
+    },
+
+    removeDiscount(discountId) {
+      orderDiscounts = orderDiscounts.filter((d) => d.id !== discountId);
+      lineItems = lineItems.map((li) => {
+        const filtered = li.discounts.filter((d) => d.id !== discountId);
+        if (filtered.length !== li.discounts.length) {
+          return recalculateLine({ ...li, discounts: filtered });
+        }
+        return li;
+      });
+      emit();
+    },
+
+    addPayment(payment) {
+      const id = uid();
+      payments = [...payments, { ...payment, id }];
+      emit();
+      return id;
+    },
+
+    removePayment(paymentId) {
+      payments = payments.filter((p) => p.id !== paymentId);
+      emit();
+    },
+
+    setCustomer(c) {
+      customer = c;
+      emit();
+    },
+
+    setNote(n) {
+      note = n;
+      emit();
+    },
+
+    clear() {
+      lineItems = [];
+      orderDiscounts = [];
+      payments = [];
+      customer = null;
+      note = '';
+      emit();
+    },
+
+    getSnapshot() {
+      return subject.getValue();
+    },
+  };
+}