whale-code 6.5.4 → 6.5.6

package/dist/server/handlers/supply-chain.js

@@ -5,341 +5,561 @@
 //           mark_transfer_in_transit, complete_inventory_transfer,
 //           cancel_inventory_transfer
 // ============================================================================
+
 export async function handlePurchaseOrders(sb, args, storeId) {
-    const sid = storeId;
-    switch (args.action) {
-        case "list": {
-            let q = sb.from("purchase_orders").select("*, supplier:suppliers(external_name, external_company), location:locations(name)")
-                .eq("store_id", sid).order("created_at", { ascending: false }).limit(args.limit || 25);
-            if (args.status)
-                q = q.eq("status", args.status);
-            const { data, error } = await q;
-            if (error)
-                return { success: false, error: error.message };
-            // Flatten supplier/location joins for table display
-            const flattened = (data || []).map((row) => {
-                const { supplier, location, ...rest } = row;
-                return { ...rest, supplier_name: supplier?.external_name || supplier?.external_company || "—", location_name: location?.name || "—" };
-            });
-            return { success: true, data: flattened };
-        }
-        case "get": {
-            const { data, error } = await sb.from("purchase_orders")
-                .select("*, items:purchase_order_items(id, product_id, quantity, unit_price, received_quantity, subtotal, product:products(name, sku)), supplier:suppliers(id, external_name, external_company, contact_email, contact_phone)")
-                .eq("id", args.purchase_order_id).eq("store_id", sid).single();
-            if (error)
-                return { success: false, error: error.message };
-            // Flatten items so product names appear as columns (formatter drops nested objects in sub-tables)
-            const po = data;
-            const items = (po.items || []).map((item) => ({
-                id: item.id, product_id: item.product_id,
-                product_name: item.product?.name || "—", product_sku: item.product?.sku || "—",
-                quantity: item.quantity, unit_price: item.unit_price,
-                received: item.received_quantity || 0, subtotal: item.subtotal,
-            }));
-            const { items: _, supplier, ...poFields } = po;
-            return {
-                success: true,
-                data: {
-                    ...poFields,
-                    supplier_name: supplier?.external_name || supplier?.external_company || "—",
-                    supplier_email: supplier?.contact_email || null,
-                    items,
-                }
-            };
-        }
-        case "create": {
-            // create_purchase_order_atomic RPC — SECURITY DEFINER, returns JSONB {success, po_id, po_number}
-            // p_items is TEXT type (JSON string), not JSONB
-            const items = (args.items || []).map(item => ({
-                product_id: item.product_id,
-                quantity: Math.max(Number(item.quantity) || 1, 0),
-                unit_cost: Math.max(Number(item.unit_cost || item.unit_price) || 0, 0),
-            }));
-            const { data: result, error: rpcError } = await sb.rpc("create_purchase_order_atomic", {
-                p_store_id: sid,
-                p_po_type: "inbound",
-                p_supplier_id: args.supplier_id || null,
-                p_location_id: args.location_id || null,
-                p_expected_delivery_date: args.expected_delivery_date || null,
-                p_notes: args.notes || null,
-                p_items: JSON.stringify(items),
-            });
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            const rpcResult = parseRpcResult(result);
-            if (!rpcResult.success)
-                return { success: false, error: rpcResult.error || "PO creation failed" };
-            // Fetch full PO for response — flatten nested joins
-            const { data: fullPo } = await sb.from("purchase_orders")
-                .select("*, items:purchase_order_items(id, product_id, quantity, unit_price, subtotal, product:products(name, sku)), supplier:suppliers(id, external_name, external_company)")
-                .eq("id", rpcResult.po_id).single();
-            if (!fullPo)
-                return { success: true, data: { po_id: rpcResult.po_id, po_number: rpcResult.po_number } };
-            const po = fullPo;
-            const flatItems = (po.items || []).map((item) => ({
-                id: item.id, product_id: item.product_id,
-                product_name: item.product?.name || "—", product_sku: item.product?.sku || "—",
-                quantity: item.quantity, unit_price: item.unit_price, subtotal: item.subtotal,
-            }));
-            const { items: _poItems, supplier, ...poFields } = po;
-            return {
-                success: true,
-                data: {
-                    ...poFields,
-                    supplier_name: supplier?.external_name || supplier?.external_company || "—",
-                    items: flatItems,
-                }
-            };
-        }
-        case "add_items": {
-            // No atomic RPC exists for adding items to an existing PO — direct insert
-            const poId = args.purchase_order_id;
-            if (!poId)
-                return { success: false, error: "purchase_order_id is required" };
-            const items = args.items;
-            if (!items || !Array.isArray(items) || !items.length)
-                return { success: false, error: "items array is required" };
-            const { data: po } = await sb.from("purchase_orders").select("status").eq("id", poId).eq("store_id", sid).single();
-            if (!po)
-                return { success: false, error: "PO not found" };
-            if (po.status === "received")
-                return { success: false, error: "Cannot add items — PO already received" };
-            if (po.status === "cancelled")
-                return { success: false, error: "Cannot add items — PO is cancelled" };
-            const rows = items.map(item => {
-                const qty = Math.max(Number(item.quantity) || 1, 0);
-                const price = Math.max(Number(item.unit_cost || item.unit_price) || 0, 0);
-                return { purchase_order_id: poId, product_id: item.product_id, quantity: qty, unit_price: price, subtotal: qty * price };
-            });
-            const { data, error } = await sb.from("purchase_order_items").insert(rows).select("*, product:products(name, sku)");
-            return error ? { success: false, error: error.message } : { success: true, data };
-        }
-        case "approve":
-        case "mark_ordered": {
-            // PO flow: draft → ordered. "approve" = mark as ordered.
-            // update_po_status RPC — SECURITY DEFINER, returns JSONB {success, old_status, new_status}
-            const { data: result, error: rpcError } = await sb.rpc("update_po_status", {
-                p_po_id: args.purchase_order_id,
-                p_status: "ordered",
-            });
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            const rpcResult = parseRpcResult(result);
-            if (!rpcResult.success)
-                return { success: false, error: rpcResult.error || "Status update failed" };
-            return { success: true, data: { old_status: rpcResult.old_status, new_status: rpcResult.new_status } };
-        }
-        case "receive": {
-            // receive_po_items RPC — SECURITY DEFINER, returns JSONB {success, items_processed}
-            // Params: p_po_id, p_location_id, p_items [{item_id, quantity}]
-            const poId = args.purchase_order_id;
-            const { data: po, error: poErr } = await sb.from("purchase_orders")
-                .select("location_id, items:purchase_order_items(id, quantity, received_quantity)")
-                .eq("id", poId).eq("store_id", sid).single();
-            if (poErr || !po)
-                return { success: false, error: poErr?.message || "PO not found" };
-            // If caller provides specific items use those, otherwise receive all remaining
-            const poItems = po.items || [];
-            let receiveItems;
-            if (args.items) {
-                // Normalize caller-provided items: accept item_id, po_item_id, or product_id
-                const callerItems = args.items;
-                receiveItems = callerItems.map((ci) => {
-                    let itemId = ci.item_id || ci.po_item_id || ci.line_item_id;
-                    // If caller used product_id instead, resolve to PO line item ID
-                    if (!itemId && ci.product_id) {
-                        const match = poItems.find((pi) => pi.id === ci.product_id || pi.product_id === ci.product_id);
-                        if (match)
-                            itemId = match.id;
-                    }
-                    return { item_id: itemId || null, quantity: Number(ci.quantity) || 0 };
-                }).filter((i) => i.item_id && i.quantity > 0);
-                if (!receiveItems.length)
-                    return { success: false, error: "No valid items to receive — provide item_id or product_id matching a PO line item" };
+  const sid = storeId;
+  switch (args.action) {
+    case "list":
+      {
+        let q = sb.from("purchase_orders").select("*, supplier:suppliers(external_name, external_company), location:locations(name)").eq("store_id", sid).order("created_at", {
+          ascending: false
+        }).limit(args.limit || 25);
+        if (args.status) q = q.eq("status", args.status);
+        const {
+          data,
+          error
+        } = await q;
+        if (error) return {
+          success: false,
+          error: error.message
+        };
+        // Flatten supplier/location joins for table display
+        const flattened = (data || []).map(row => {
+          const {
+            supplier,
+            location,
+            ...rest
+          } = row;
+          return {
+            ...rest,
+            supplier_name: supplier?.external_name || supplier?.external_company || "—",
+            location_name: location?.name || "—"
+          };
+        });
+        return {
+          success: true,
+          data: flattened
+        };
+      }
+    case "get":
+      {
+        const {
+          data,
+          error
+        } = await sb.from("purchase_orders").select("*, items:purchase_order_items(id, product_id, quantity, unit_price, received_quantity, subtotal, product:products(name, sku)), supplier:suppliers(id, external_name, external_company, contact_email, contact_phone)").eq("id", args.purchase_order_id).eq("store_id", sid).single();
+        if (error) return {
+          success: false,
+          error: error.message
+        };
+        // Flatten items so product names appear as columns (formatter drops nested objects in sub-tables)
+        const po = data;
+        const items = (po.items || []).map(item => ({
+          id: item.id,
+          product_id: item.product_id,
+          product_name: item.product?.name || "—",
+          product_sku: item.product?.sku || "—",
+          quantity: item.quantity,
+          unit_price: item.unit_price,
+          received: item.received_quantity || 0,
+          subtotal: item.subtotal
+        }));
+        const {
+          items: _,
+          supplier,
+          ...poFields
+        } = po;
+        return {
+          success: true,
+          data: {
+            ...poFields,
+            supplier_name: supplier?.external_name || supplier?.external_company || "—",
+            supplier_email: supplier?.contact_email || null,
+            items
+          }
+        };
+      }
+    case "create":
+      {
+        // create_purchase_order_atomic RPC — SECURITY DEFINER, returns JSONB {success, po_id, po_number}
+        // p_items is TEXT type (JSON string), not JSONB
+        const items = (args.items || []).map(item => ({
+          product_id: item.product_id,
+          quantity: Math.max(Number(item.quantity) || 1, 0),
+          unit_cost: Math.max(Number(item.unit_cost || item.unit_price) || 0, 0)
+        }));
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("create_purchase_order_atomic", {
+          p_store_id: sid,
+          p_po_type: "inbound",
+          p_supplier_id: args.supplier_id || null,
+          p_location_id: args.location_id || null,
+          p_expected_delivery_date: args.expected_delivery_date || null,
+          p_notes: args.notes || null,
+          p_items: JSON.stringify(items)
+        });
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        const rpcResult = parseRpcResult(result);
+        if (!rpcResult.success) return {
+          success: false,
+          error: rpcResult.error || "PO creation failed"
+        };
+
+        // Fetch full PO for response — flatten nested joins
+        const {
+          data: fullPo
+        } = await sb.from("purchase_orders").select("*, items:purchase_order_items(id, product_id, quantity, unit_price, subtotal, product:products(name, sku)), supplier:suppliers(id, external_name, external_company)").eq("id", rpcResult.po_id).single();
+        if (!fullPo) return {
+          success: true,
+          data: {
+            po_id: rpcResult.po_id,
+            po_number: rpcResult.po_number
+          }
+        };
+        const po = fullPo;
+        const flatItems = (po.items || []).map(item => ({
+          id: item.id,
+          product_id: item.product_id,
+          product_name: item.product?.name || "—",
+          product_sku: item.product?.sku || "—",
+          quantity: item.quantity,
+          unit_price: item.unit_price,
+          subtotal: item.subtotal
+        }));
+        const {
+          items: _poItems,
+          supplier,
+          ...poFields
+        } = po;
+        return {
+          success: true,
+          data: {
+            ...poFields,
+            supplier_name: supplier?.external_name || supplier?.external_company || "—",
+            items: flatItems
+          }
+        };
+      }
+    case "add_items":
+      {
+        // No atomic RPC exists for adding items to an existing PO — direct insert
+        const poId = args.purchase_order_id;
+        if (!poId) return {
+          success: false,
+          error: "purchase_order_id is required"
+        };
+        const items = args.items;
+        if (!items || !Array.isArray(items) || !items.length) return {
+          success: false,
+          error: "items array is required"
+        };
+        const {
+          data: po
+        } = await sb.from("purchase_orders").select("status").eq("id", poId).eq("store_id", sid).single();
+        if (!po) return {
+          success: false,
+          error: "PO not found"
+        };
+        if (po.status === "received") return {
+          success: false,
+          error: "Cannot add items — PO already received"
+        };
+        if (po.status === "cancelled") return {
+          success: false,
+          error: "Cannot add items — PO is cancelled"
+        };
+        const rows = items.map(item => {
+          const qty = Math.max(Number(item.quantity) || 1, 0);
+          const price = Math.max(Number(item.unit_cost || item.unit_price) || 0, 0);
+          return {
+            purchase_order_id: poId,
+            product_id: item.product_id,
+            quantity: qty,
+            unit_price: price,
+            subtotal: qty * price
+          };
+        });
+        const {
+          data,
+          error
+        } = await sb.from("purchase_order_items").insert(rows).select("*, product:products(name, sku)");
+        return error ? {
+          success: false,
+          error: error.message
+        } : {
+          success: true,
+          data
+        };
+      }
+    case "approve":
+    case "mark_ordered":
+      {
+        // PO flow: draft → ordered. "approve" = mark as ordered.
+        // update_po_status RPC — SECURITY DEFINER, returns JSONB {success, old_status, new_status}
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("update_po_status", {
+          p_po_id: args.purchase_order_id,
+          p_status: "ordered"
+        });
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        const rpcResult = parseRpcResult(result);
+        if (!rpcResult.success) return {
+          success: false,
+          error: rpcResult.error || "Status update failed"
+        };
+        return {
+          success: true,
+          data: {
+            old_status: rpcResult.old_status,
+            new_status: rpcResult.new_status
+          }
+        };
+      }
+    case "receive":
+      {
+        // receive_po_items RPC — SECURITY DEFINER, returns JSONB {success, items_processed}
+        // Params: p_po_id, p_location_id, p_items [{item_id, quantity}]
+        const poId = args.purchase_order_id;
+        const {
+          data: po,
+          error: poErr
+        } = await sb.from("purchase_orders").select("location_id, items:purchase_order_items(id, quantity, received_quantity)").eq("id", poId).eq("store_id", sid).single();
+        if (poErr || !po) return {
+          success: false,
+          error: poErr?.message || "PO not found"
+        };
+
+        // If caller provides specific items use those, otherwise receive all remaining
+        const poItems = po.items || [];
+        let receiveItems;
+        if (args.items) {
+          // Normalize caller-provided items: accept item_id, po_item_id, or product_id
+          const callerItems = args.items;
+          receiveItems = callerItems.map(ci => {
+            let itemId = ci.item_id || ci.po_item_id || ci.line_item_id;
+            // If caller used product_id instead, resolve to PO line item ID
+            if (!itemId && ci.product_id) {
+              const match = poItems.find(pi => pi.id === ci.product_id || pi.product_id === ci.product_id);
+              if (match) itemId = match.id;
             }
-            else {
-                receiveItems = poItems
-                    .map((item) => ({
-                    item_id: item.id,
-                    quantity: Math.max((item.quantity || 0) - (item.received_quantity || 0), 0),
-                }))
-                    .filter((item) => item.quantity > 0);
-            }
-            if (!receiveItems.length)
-                return { success: false, error: "No items to receive (all fully received)" };
-            const locationId = args.location_id || po.location_id;
-            if (!locationId)
-                return { success: false, error: "No location_id on PO — cannot receive" };
-            const { data: result, error: rpcError } = await sb.rpc("receive_po_items", {
-                p_po_id: poId,
-                p_location_id: locationId,
-                p_items: receiveItems,
-            });
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            const rpcResult = parseRpcResult(result);
-            if (!rpcResult.success)
-                return { success: false, error: rpcResult.error || "PO receive failed" };
             return {
-                success: true,
-                data: {
-                    po_id: poId,
-                    items_processed: rpcResult.items_processed,
-                    message: `Received ${rpcResult.items_processed || 0} item(s) into inventory`,
-                }
+              item_id: itemId || null,
+              quantity: Number(ci.quantity) || 0
             };
+          }).filter(i => i.item_id && i.quantity > 0);
+          if (!receiveItems.length) return {
+            success: false,
+            error: "No valid items to receive — provide item_id or product_id matching a PO line item"
+          };
+        } else {
+          receiveItems = poItems.map(item => ({
+            item_id: item.id,
+            quantity: Math.max((item.quantity || 0) - (item.received_quantity || 0), 0)
+          })).filter(item => item.quantity > 0);
         }
-        case "cancel": {
-            // update_po_status RPC — SECURITY DEFINER, returns JSONB {success, old_status, new_status}
-            const { data: result, error: rpcError } = await sb.rpc("update_po_status", {
-                p_po_id: args.purchase_order_id,
-                p_status: "cancelled",
-            });
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            const rpcResult = parseRpcResult(result);
-            if (!rpcResult.success)
-                return { success: false, error: rpcResult.error || "Cancel failed" };
-            return { success: true, data: { old_status: rpcResult.old_status, new_status: rpcResult.new_status } };
-        }
-        default:
-            return { success: false, error: `Unknown purchase_orders action: ${args.action}. Valid: list, get, create, add_items, approve, mark_ordered, receive, cancel` };
-    }
+        if (!receiveItems.length) return {
+          success: false,
+          error: "No items to receive (all fully received)"
+        };
+        const locationId = args.location_id || po.location_id;
+        if (!locationId) return {
+          success: false,
+          error: "No location_id on PO — cannot receive"
+        };
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("receive_po_items", {
+          p_po_id: poId,
+          p_location_id: locationId,
+          p_items: receiveItems
+        });
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        const rpcResult = parseRpcResult(result);
+        if (!rpcResult.success) return {
+          success: false,
+          error: rpcResult.error || "PO receive failed"
+        };
+        return {
+          success: true,
+          data: {
+            po_id: poId,
+            items_processed: rpcResult.items_processed,
+            message: `Received ${rpcResult.items_processed || 0} item(s) into inventory`
+          }
+        };
+      }
+    case "cancel":
+      {
+        // update_po_status RPC — SECURITY DEFINER, returns JSONB {success, old_status, new_status}
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("update_po_status", {
+          p_po_id: args.purchase_order_id,
+          p_status: "cancelled"
+        });
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        const rpcResult = parseRpcResult(result);
+        if (!rpcResult.success) return {
+          success: false,
+          error: rpcResult.error || "Cancel failed"
+        };
+        return {
+          success: true,
+          data: {
+            old_status: rpcResult.old_status,
+            new_status: rpcResult.new_status
+          }
+        };
+      }
+    default:
+      return {
+        success: false,
+        error: `Unknown purchase_orders action: ${args.action}. Valid: list, get, create, add_items, approve, mark_ordered, receive, cancel`
+      };
+  }
 }
 export async function handleTransfers(sb, args, storeId) {
-    const sid = storeId;
-    switch (args.action) {
-        case "list": {
-            let q = sb.from("inventory_transfers")
-                .select("*, from_location:locations!source_location_id(name), to_location:locations!destination_location_id(name)")
-                .eq("store_id", sid).order("created_at", { ascending: false }).limit(args.limit || 25);
-            if (args.status)
-                q = q.eq("status", args.status);
-            const { data, error } = await q;
-            if (error)
-                return { success: false, error: error.message };
-            // Flatten location joins for table display
-            const flattened = (data || []).map((row) => {
-                const { from_location, to_location, ...rest } = row;
-                return { ...rest, from_location: from_location?.name || "—", to_location: to_location?.name || "—" };
-            });
-            return { success: true, data: flattened };
-        }
-        case "create": {
-            // create_inventory_transfer RPC — SECURITY DEFINER, returns JSONB {success, transfer_id, transfer_number}
-            // p_items is JSONB (pass as object, not string)
-            const sourceLocId = (args.from_location_id || args.source_location_id);
-            const destLocId = (args.to_location_id || args.destination_location_id);
-            const items = (args.items || []).map(i => ({
-                product_id: i.product_id,
-                quantity: i.quantity,
-            }));
-            const params = {
-                p_store_id: sid,
-                p_source_location_id: sourceLocId,
-                p_destination_location_id: destLocId,
-                p_items: items,
-            };
-            if (args.notes)
-                params.p_notes = args.notes;
-            const { data: result, error: rpcError } = await sb.rpc("create_inventory_transfer", params);
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            const rpcResult = parseRpcResult(result);
-            if (!rpcResult.success)
-                return { success: false, error: rpcResult.error || "Transfer creation failed" };
-            return { success: true, data: { transfer_id: rpcResult.transfer_id, transfer_number: rpcResult.transfer_number } };
-        }
-        case "get": {
-            const { data, error } = await sb.from("inventory_transfers")
-                .select("*, items:inventory_transfer_items(id, product_id, quantity, product:products(name, sku)), from_location:locations!source_location_id(id, name), to_location:locations!destination_location_id(id, name)")
-                .eq("id", args.transfer_id).eq("store_id", sid).single();
-            if (error)
-                return { success: false, error: error.message };
-            // Flatten nested joins so items and locations are visible
-            const transfer = data;
-            const items = (transfer.items || []).map((item) => ({
-                id: item.id, product_id: item.product_id,
-                product_name: item.product?.name || "—", product_sku: item.product?.sku || "—",
-                quantity: item.quantity,
-            }));
-            const { items: _, from_location, to_location, ...transferFields } = transfer;
-            return {
-                success: true,
-                data: {
-                    ...transferFields,
-                    from_location_name: from_location?.name || "—",
-                    to_location_name: to_location?.name || "—",
-                    items,
-                }
-            };
-        }
-        case "approve": {
-            // approve_inventory_transfer RPC — SECURITY DEFINER, returns boolean
-            // Validates stock, draft → approved
-            const { data: result, error: rpcError } = await sb.rpc("approve_inventory_transfer", {
-                p_transfer_id: args.transfer_id,
-            });
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            return { success: true, data: { approved: result } };
-        }
-        case "ship":
-        case "mark_in_transit": {
-            // mark_transfer_in_transit RPC — SECURITY DEFINER, returns boolean
-            // Validates stock, creates holds, draft/approved → in_transit
-            const { data: result, error: rpcError } = await sb.rpc("mark_transfer_in_transit", {
-                p_transfer_id: args.transfer_id,
-            });
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            return { success: true, data: { in_transit: result } };
-        }
-        case "receive":
-        case "complete": {
-            // complete_inventory_transfer RPC — SECURITY DEFINER, returns JSONB {success, items_processed}
-            // Deducts source, adds to destination, releases holds
-            const { data: result, error: rpcError } = await sb.rpc("complete_inventory_transfer", {
-                p_transfer_id: args.transfer_id,
-            });
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            const rpcResult = parseRpcResult(result);
-            if (!rpcResult.success)
-                return { success: false, error: rpcResult.error || "Transfer complete failed" };
-            return {
-                success: true,
-                data: {
-                    transfer_id: args.transfer_id,
-                    items_processed: rpcResult.items_processed,
-                    message: `Completed transfer, ${rpcResult.items_processed || 0} item(s) moved to destination`,
-                }
-            };
-        }
-        case "cancel": {
-            // cancel_inventory_transfer RPC — SECURITY DEFINER, returns boolean
-            // Releases holds, any non-final → cancelled
-            const { data: result, error: rpcError } = await sb.rpc("cancel_inventory_transfer", {
-                p_transfer_id: args.transfer_id,
-            });
-            if (rpcError)
-                return { success: false, error: rpcError.message };
-            return { success: true, data: { cancelled: result, message: "Transfer cancelled" } };
-        }
-        default:
-            return { success: false, error: `Unknown transfers action: ${args.action}. Valid: list, get, create, approve, ship, mark_in_transit, receive, complete, cancel` };
-    }
+  const sid = storeId;
+  switch (args.action) {
+    case "list":
+      {
+        let q = sb.from("inventory_transfers").select("*, from_location:locations!source_location_id(name), to_location:locations!destination_location_id(name)").eq("store_id", sid).order("created_at", {
+          ascending: false
+        }).limit(args.limit || 25);
+        if (args.status) q = q.eq("status", args.status);
+        const {
+          data,
+          error
+        } = await q;
+        if (error) return {
+          success: false,
+          error: error.message
+        };
+        // Flatten location joins for table display
+        const flattened = (data || []).map(row => {
+          const {
+            from_location,
+            to_location,
+            ...rest
+          } = row;
+          return {
+            ...rest,
+            from_location: from_location?.name || "—",
+            to_location: to_location?.name || "—"
+          };
+        });
+        return {
+          success: true,
+          data: flattened
+        };
+      }
+    case "create":
+      {
+        // create_inventory_transfer RPC — SECURITY DEFINER, returns JSONB {success, transfer_id, transfer_number}
+        // p_items is JSONB (pass as object, not string)
+        const sourceLocId = args.from_location_id || args.source_location_id;
+        const destLocId = args.to_location_id || args.destination_location_id;
+        const items = (args.items || []).map(i => ({
+          product_id: i.product_id,
+          quantity: i.quantity
+        }));
+        const params = {
+          p_store_id: sid,
+          p_source_location_id: sourceLocId,
+          p_destination_location_id: destLocId,
+          p_items: items
+        };
+        if (args.notes) params.p_notes = args.notes;
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("create_inventory_transfer", params);
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        const rpcResult = parseRpcResult(result);
+        if (!rpcResult.success) return {
+          success: false,
+          error: rpcResult.error || "Transfer creation failed"
+        };
+        return {
+          success: true,
+          data: {
+            transfer_id: rpcResult.transfer_id,
+            transfer_number: rpcResult.transfer_number
+          }
+        };
+      }
+    case "get":
+      {
+        const {
+          data,
+          error
+        } = await sb.from("inventory_transfers").select("*, items:inventory_transfer_items(id, product_id, quantity, product:products(name, sku)), from_location:locations!source_location_id(id, name), to_location:locations!destination_location_id(id, name)").eq("id", args.transfer_id).eq("store_id", sid).single();
+        if (error) return {
+          success: false,
+          error: error.message
+        };
+        // Flatten nested joins so items and locations are visible
+        const transfer = data;
+        const items = (transfer.items || []).map(item => ({
+          id: item.id,
+          product_id: item.product_id,
+          product_name: item.product?.name || "—",
+          product_sku: item.product?.sku || "—",
+          quantity: item.quantity
+        }));
+        const {
+          items: _,
+          from_location,
+          to_location,
+          ...transferFields
+        } = transfer;
+        return {
+          success: true,
+          data: {
+            ...transferFields,
+            from_location_name: from_location?.name || "—",
+            to_location_name: to_location?.name || "—",
+            items
+          }
+        };
+      }
+    case "approve":
+      {
+        // approve_inventory_transfer RPC — SECURITY DEFINER, returns boolean
+        // Validates stock, draft → approved
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("approve_inventory_transfer", {
+          p_transfer_id: args.transfer_id
+        });
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        return {
+          success: true,
+          data: {
+            approved: result
+          }
+        };
+      }
+    case "ship":
+    case "mark_in_transit":
+      {
+        // mark_transfer_in_transit RPC — SECURITY DEFINER, returns boolean
+        // Validates stock, creates holds, draft/approved → in_transit
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("mark_transfer_in_transit", {
+          p_transfer_id: args.transfer_id
+        });
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        return {
+          success: true,
+          data: {
+            in_transit: result
+          }
+        };
+      }
+    case "receive":
+    case "complete":
+      {
+        // complete_inventory_transfer RPC — SECURITY DEFINER, returns JSONB {success, items_processed}
+        // Deducts source, adds to destination, releases holds
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("complete_inventory_transfer", {
+          p_transfer_id: args.transfer_id
+        });
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        const rpcResult = parseRpcResult(result);
+        if (!rpcResult.success) return {
+          success: false,
+          error: rpcResult.error || "Transfer complete failed"
+        };
+        return {
+          success: true,
+          data: {
+            transfer_id: args.transfer_id,
+            items_processed: rpcResult.items_processed,
+            message: `Completed transfer, ${rpcResult.items_processed || 0} item(s) moved to destination`
+          }
+        };
+      }
+    case "cancel":
+      {
+        // cancel_inventory_transfer RPC — SECURITY DEFINER, returns boolean
+        // Releases holds, any non-final → cancelled
+        const {
+          data: result,
+          error: rpcError
+        } = await sb.rpc("cancel_inventory_transfer", {
+          p_transfer_id: args.transfer_id
+        });
+        if (rpcError) return {
+          success: false,
+          error: rpcError.message
+        };
+        return {
+          success: true,
+          data: {
+            cancelled: result,
+            message: "Transfer cancelled"
+          }
+        };
+      }
+    default:
+      return {
+        success: false,
+        error: `Unknown transfers action: ${args.action}. Valid: list, get, create, approve, ship, mark_in_transit, receive, complete, cancel`
+      };
+  }
 }
+
 /** Parse RPC result — handles both raw objects and stringified JSON */
 function parseRpcResult(result) {
-    if (typeof result === "string") {
-        try {
-            return JSON.parse(result);
-        }
-        catch {
-            return { success: false, error: result };
-        }
+  if (typeof result === "string") {
+    try {
+      return JSON.parse(result);
+    } catch {
+      return {
+        success: false,
+        error: result
+      };
     }
-    return result || { success: false, error: "Empty RPC response" };
+  }
+  return result || {
+    success: false,
+    error: "Empty RPC response"
+  };
 }
+//# sourceMappingURL=supply-chain.js.map