feat(order): support weight-based products

Products like fish are sold per weighing (4.2 ons, 5.6 ons), which the
order line could not represent: quantity is INTEGER and prices are always
computed as quantity * unit_price.

Model one weighing as one order line. quantity stays INTEGER and keeps
meaning "how many items"; the measured amount goes into a new nullable
order_items.weight, and the line is priced weight * unit_price. Two
weighings of the same product are two lines, never merged into one.

Keeping quantity integral avoids float comparisons in void, refund and
split bill, where accumulated rounding error would silently misbehave —
"1.4 + 1.4 + 1.4" is not 4.2 in float64, which would leave a fully paid
split-bill item marked unpaid.

BillableQuantity() is now the single place that decides between weight
and count; every price and cost calculation goes through it. Missing one
would bill a 4.2 ons fish as a single ons — wrong money, no error.

Two database constraints back the design: a weighed line always carries a
positive weight, and its quantity is pinned to 1. The latter also makes
void all-or-nothing for weighed lines, so the row-splitting branch can
never produce a zero-weight remainder row.

Also wires product.unit_id through the API, which was previously not
settable at all, and corrects the misleading comment on the request's
unit_price field — that value has never been used; price always comes
from the database.

Design notes and the audit of every price multiplication site are in
docs/rfc-weight-based-products.md.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

internal/repository/analytics_repository.go

@@ -461,6 +461,7 @@ func (r *AnalyticsRepositoryImpl) GetProductAnalytics(ctx context.Context, organ
 			c.name as category_name,
 			c.order as category_order,
 			COALESCE(SUM(oi.quantity), 0) as quantity_sold,
+			COALESCE(SUM(oi.weight), 0) as weight_sold,
 			COALESCE(SUM(oi.total_price), 0) as revenue,
 			CASE 
 				WHEN SUM(oi.quantity) > 0 THEN COALESCE(SUM(oi.total_price), 0) / SUM(oi.quantity)
@@ -1167,9 +1168,9 @@ func (r *AnalyticsRepositoryImpl) getPurchaseOrderRawMaterialTotal(ctx context.C
 }
 
 type purchasingTotals struct {
-	Total        float64
-	RawMaterial  float64
-	Expense      float64
+	Total       float64
+	RawMaterial float64
+	Expense     float64
 }
 
 func (r *AnalyticsRepositoryImpl) getPurchaseOrderTotals(ctx context.Context, organizationID uuid.UUID, dateFrom, dateTo time.Time) (purchasingTotals, error) {

internal/repository/order_item_repository.go

@@ -50,6 +50,7 @@ func (r *OrderItemRepositoryImpl) GetByOrderID(ctx context.Context, orderID uuid
 	err := r.db.WithContext(ctx).
 		Preload("Product").
 		Preload("ProductVariant").
+		Preload("Unit").
 		Where("order_id = ?", orderID).
 		Find(&orderItems).Error
 	return orderItems, err
@@ -109,8 +110,12 @@ func (r *OrderItemRepositoryImpl) VoidOrderItem(ctx context.Context, id uuid.UUI
 		return err
 	}
 
-	if voidQuantity >= orderItem.Quantity {
-		voidedAmount := float64(voidQuantity) * orderItem.UnitPrice
+	// A weighed line is one weighing, so it is voided whole — never split into a
+	// remainder row. chk_order_items_weight_single_line pins its quantity to 1, which
+	// already sends it down this branch; the explicit check keeps that guarantee
+	// visible and independent of the comparison below.
+	if orderItem.IsWeighed() || voidQuantity >= orderItem.Quantity {
+		voidedAmount := entities.RoundMoney(orderItem.BillableQuantityFor(voidQuantity) * orderItem.UnitPrice)
 
 		updates := map[string]interface{}{
 			"refund_quantity":       voidQuantity,
@@ -128,16 +133,18 @@ func (r *OrderItemRepositoryImpl) VoidOrderItem(ctx context.Context, id uuid.UUI
 			Updates(updates).Error
 	}
 
+	// Only unit-priced lines reach here: weighed lines were voided whole above.
 	voidedOrderItem := entities.OrderItem{
 		OrderID:             orderItem.OrderID,
 		ProductID:           orderItem.ProductID,
 		ProductVariantID:    orderItem.ProductVariantID,
 		Quantity:            voidQuantity,
+		UnitID:              orderItem.UnitID,
 		UnitPrice:           orderItem.UnitPrice,
-		TotalPrice:          float64(voidQuantity) * orderItem.UnitPrice,
+		TotalPrice:          entities.RoundMoney(float64(voidQuantity) * orderItem.UnitPrice),
 		UnitCost:            orderItem.UnitCost,
-		TotalCost:           float64(voidQuantity) * orderItem.UnitCost,
-		RefundAmount:        float64(voidQuantity) * orderItem.UnitPrice,
+		TotalCost:           entities.RoundMoney(float64(voidQuantity) * orderItem.UnitCost),
+		RefundAmount:        entities.RoundMoney(float64(voidQuantity) * orderItem.UnitPrice),
 		RefundQuantity:      voidQuantity,
 		IsPartiallyRefunded: false,
 		IsFullyRefunded:     true,
@@ -155,8 +162,8 @@ func (r *OrderItemRepositoryImpl) VoidOrderItem(ctx context.Context, id uuid.UUI
 	}
 
 	remainingQuantity := orderItem.Quantity - voidQuantity
-	remainingTotalPrice := float64(remainingQuantity) * orderItem.UnitPrice
-	remainingTotalCost := float64(remainingQuantity) * orderItem.UnitCost
+	remainingTotalPrice := entities.RoundMoney(float64(remainingQuantity) * orderItem.UnitPrice)
+	remainingTotalCost := entities.RoundMoney(float64(remainingQuantity) * orderItem.UnitCost)
 
 	updates := map[string]interface{}{
 		"quantity":    remainingQuantity,

internal/repository/order_repository.go

@@ -63,6 +63,7 @@ func (r *OrderRepositoryImpl) GetWithRelations(ctx context.Context, id uuid.UUID
 		Preload("OrderItems.Product.Category").
 		Preload("OrderItems.Product.ProductOutletPrices").
 		Preload("OrderItems.ProductVariant").
+		Preload("OrderItems.Unit").
 		Preload("Payments").
 		Preload("Payments.PaymentMethod").
 		Preload("Payments.PaymentOrderItems").
@@ -144,6 +145,7 @@ func (r *OrderRepositoryImpl) List(ctx context.Context, filters map[string]inter
 		Preload("OrderItems.Product.Category").
 		Preload("OrderItems.Product.ProductOutletPrices").
 		Preload("OrderItems.ProductVariant").
+		Preload("OrderItems.Unit").
 		Preload("Payments").
 		Preload("Payments.PaymentMethod").
 		Preload("Payments.PaymentOrderItems").
@@ -162,6 +164,7 @@ func (r *OrderRepositoryImpl) ListBySessionID(ctx context.Context, sessionID str
 		Preload("OrderItems.Product.Category").
 		Preload("OrderItems.Product.ProductOutletPrices").
 		Preload("OrderItems.ProductVariant").
+		Preload("OrderItems.Unit").
 		Preload("Payments").
 		Preload("Payments.PaymentMethod").
 		Preload("Payments.PaymentOrderItems").