whale-code 6.4.0

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

@@ -0,0 +1,327 @@
+// ============================================================================
+// UNIFIED RPC FUNCTIONS — same functions used by Swift app
+// PO:       create_purchase_order_atomic, update_po_status, receive_po_items
+// Transfer: create_inventory_transfer, approve_inventory_transfer,
+//           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 receiveItems = args.items
+                ? args.items
+                : (po.items || [])
+                    .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`,
+                }
+            };
+        }
+        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` };
+    }
+}
+/** 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 };
+        }
+    }
+    return result || { success: false, error: "Empty RPC response" };
+}

package/dist/server/handlers/transcription.d.ts

@@ -0,0 +1,17 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export interface TranscribeResult {
+    success: boolean;
+    transcript?: string;
+    language?: string;
+    duration?: number;
+    error?: string;
+}
+/**
+ * Transcribe audio using OpenAI Whisper API.
+ *
+ * @param sb - Supabase client (service role) for credential lookup
+ * @param storeId - Store ID to resolve OpenAI API key
+ * @param audioBase64 - Base64-encoded audio data
+ * @param mediaType - MIME type (e.g. "audio/mpeg", "audio/wav")
+ */
+export declare function handleTranscribe(sb: SupabaseClient, storeId: string, audioBase64: string, mediaType: string): Promise<TranscribeResult>;

package/dist/server/handlers/transcription.js

@@ -0,0 +1,121 @@
+// server/handlers/transcription.ts — Audio transcription via OpenAI Whisper
+const WHISPER_URL = "https://api.openai.com/v1/audio/transcriptions";
+const WHISPER_MODEL = "whisper-1";
+/** Map media types to file extensions for the Whisper API */
+const MEDIA_TYPE_EXTENSIONS = {
+    "audio/mpeg": "mp3",
+    "audio/wav": "wav",
+    "audio/aiff": "aiff",
+    "audio/aac": "aac",
+    "audio/ogg": "ogg",
+    "audio/flac": "flac",
+    "audio/mp4": "m4a",
+    "audio/webm": "webm",
+};
+/**
+ * Transcribe audio using OpenAI Whisper API.
+ *
+ * @param sb - Supabase client (service role) for credential lookup
+ * @param storeId - Store ID to resolve OpenAI API key
+ * @param audioBase64 - Base64-encoded audio data
+ * @param mediaType - MIME type (e.g. "audio/mpeg", "audio/wav")
+ */
+export async function handleTranscribe(sb, storeId, audioBase64, mediaType) {
+    // Resolve OpenAI API key
+    let apiKey = null;
+    try {
+        const { data, error } = await sb.rpc("decrypt_secret", {
+            p_name: "OPENAI_API_KEY",
+            p_store_id: storeId,
+        });
+        if (!error && data)
+            apiKey = data;
+    }
+    catch {
+        // key not found
+    }
+    if (!apiKey) {
+        return {
+            success: false,
+            error: "OpenAI API key not configured. Add OPENAI_API_KEY to your tool secrets for audio transcription.",
+        };
+    }
+    // Decode base64 to buffer
+    const audioBuffer = Buffer.from(audioBase64, "base64");
+    // Determine file extension from media type
+    const ext = MEDIA_TYPE_EXTENSIONS[mediaType] || "mp3";
+    const filename = `audio.${ext}`;
+    // Build multipart form data for Whisper API
+    const blob = new Blob([audioBuffer], { type: mediaType });
+    const formData = new FormData();
+    formData.append("file", blob, filename);
+    formData.append("model", WHISPER_MODEL);
+    formData.append("response_format", "verbose_json");
+    try {
+        const response = await fetch(WHISPER_URL, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const errText = await response.text();
+            return {
+                success: false,
+                error: `Whisper API error ${response.status}: ${errText}`,
+            };
+        }
+        const data = await response.json();
+        // Format transcript with timestamps if segments available
+        let transcript;
+        if (data.segments && data.segments.length > 0) {
+            const lines = data.segments.map((seg) => {
+                const start = formatTimestamp(seg.start);
+                return `[${start}] ${seg.text.trim()}`;
+            });
+            transcript = lines.join("\n");
+        }
+        else {
+            transcript = data.text || "";
+        }
+        // Add metadata header
+        const durationStr = data.duration ? formatDuration(data.duration) : "unknown";
+        const langStr = data.language || "unknown";
+        const header = `Audio transcript (${durationStr}, ${langStr})`;
+        return {
+            success: true,
+            transcript: `${header}\n\n${transcript}`,
+            language: data.language,
+            duration: data.duration,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Transcription failed: ${err.message}`,
+        };
+    }
+}
+/** Format seconds to MM:SS or HH:MM:SS */
+function formatTimestamp(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = Math.floor(seconds % 60);
+    if (h > 0) {
+        return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+    }
+    return `${m}:${String(s).padStart(2, "0")}`;
+}
+/** Format total duration */
+function formatDuration(seconds) {
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    const m = Math.floor(seconds / 60);
+    const s = Math.round(seconds % 60);
+    if (m < 60)
+        return `${m}:${String(s).padStart(2, "0")}`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return `${h}:${String(rm).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}

package/dist/server/handlers/video-gen.d.ts

@@ -0,0 +1,6 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare function handleVideoGen(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}>;