whale-code 6.4.0

package/dist/server/handlers/__test-utils__/mock-supabase.js

@@ -0,0 +1,393 @@
+// __test-utils__/mock-supabase.ts — Reusable mock Supabase client for handler tests
+//
+// Provides an in-memory Supabase client mock with chainable query builder methods
+// that mirror the real SupabaseClient interface used by all handlers.
+import { vi } from "vitest";
+// ---------------------------------------------------------------------------
+// In-memory stores
+// ---------------------------------------------------------------------------
+/** Per-table row arrays keyed by table name */
+let tableData = {};
+/** Per-RPC function response stubs keyed by RPC name */
+let rpcResponses = {};
+/** Per-table forced errors (simulates DB failures) */
+let tableErrors = {};
+// ---------------------------------------------------------------------------
+// Public helpers
+// ---------------------------------------------------------------------------
+/** Pre-populate a table with rows for the current test */
+export function setTableData(table, rows) {
+    tableData[table] = [...rows];
+}
+/** Pre-configure the return value for an RPC call */
+export function setRpcResponse(name, data, error) {
+    rpcResponses[name] = { data: data ?? null, error: error ?? null };
+}
+/** Force a table to return an error on any operation */
+export function setTableError(table, message, code) {
+    tableErrors[table] = { message, code };
+}
+/** Reset all in-memory state between tests */
+export function resetMock() {
+    tableData = {};
+    rpcResponses = {};
+    tableErrors = {};
+}
+/** Get current in-memory rows for a table (for post-operation assertions) */
+export function getTableData(table) {
+    return tableData[table] || [];
+}
+function defaultState(table) {
+    return {
+        table,
+        selectColumns: "*",
+        filters: [],
+        orderCol: null,
+        orderAsc: true,
+        limitCount: 1000,
+        rangeFrom: null,
+        rangeTo: null,
+        isSingle: false,
+        isMaybeSingle: false,
+        isInsert: false,
+        isUpdate: false,
+        isDelete: false,
+        insertPayload: null,
+        updatePayload: null,
+        countMode: false,
+        headMode: false,
+    };
+}
+function applyFilters(rows, filters) {
+    let result = rows;
+    for (const fn of filters) {
+        result = result.filter((r) => fn(r));
+    }
+    return result;
+}
+/** Convert SQL LIKE/ILIKE pattern to regex */
+function likeToRegex(pattern, caseInsensitive) {
+    // Escape regex special chars except % and _
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, (ch) => {
+        if (ch === "%" || ch === "_")
+            return ch;
+        return `\\${ch}`;
+    });
+    const regexStr = "^" + escaped.replace(/%/g, ".*").replace(/_/g, ".") + "$";
+    return new RegExp(regexStr, caseInsensitive ? "i" : "");
+}
+function buildQueryBuilder(state) {
+    const builder = {};
+    // select -----------------------------------------------------------------
+    builder.select = vi.fn((columns, opts) => {
+        state.selectColumns = columns || "*";
+        if (opts?.count)
+            state.countMode = true;
+        if (opts?.head)
+            state.headMode = true;
+        return builder;
+    });
+    // insert -----------------------------------------------------------------
+    builder.insert = vi.fn((payload) => {
+        state.isInsert = true;
+        state.insertPayload = payload;
+        return builder;
+    });
+    // update -----------------------------------------------------------------
+    builder.update = vi.fn((payload) => {
+        state.isUpdate = true;
+        state.updatePayload = payload;
+        return builder;
+    });
+    // delete -----------------------------------------------------------------
+    builder.delete = vi.fn(() => {
+        state.isDelete = true;
+        return builder;
+    });
+    // upsert -----------------------------------------------------------------
+    builder.upsert = vi.fn((payload, _opts) => {
+        state.isInsert = true;
+        state.insertPayload = payload;
+        return builder;
+    });
+    // filters ----------------------------------------------------------------
+    builder.eq = vi.fn((col, val) => {
+        state.filters.push((r) => r[col] === val);
+        return builder;
+    });
+    builder.neq = vi.fn((col, val) => {
+        state.filters.push((r) => r[col] !== val);
+        return builder;
+    });
+    builder.gt = vi.fn((col, val) => {
+        state.filters.push((r) => r[col] > val);
+        return builder;
+    });
+    builder.gte = vi.fn((col, val) => {
+        state.filters.push((r) => r[col] >= val);
+        return builder;
+    });
+    builder.lt = vi.fn((col, val) => {
+        state.filters.push((r) => r[col] < val);
+        return builder;
+    });
+    builder.lte = vi.fn((col, val) => {
+        state.filters.push((r) => r[col] <= val);
+        return builder;
+    });
+    builder.in = vi.fn((col, vals) => {
+        state.filters.push((r) => vals.includes(r[col]));
+        return builder;
+    });
+    builder.not = vi.fn((col, op, val) => {
+        state.filters.push((r) => {
+            switch (op) {
+                case "eq": return r[col] !== val;
+                case "is": return r[col] !== val;
+                case "in": return !(val || []).includes(r[col]);
+                case "like": return !likeToRegex(val, false).test(String(r[col] ?? ""));
+                case "ilike": return !likeToRegex(val, true).test(String(r[col] ?? ""));
+                default: return true;
+            }
+        });
+        return builder;
+    });
+    builder.ilike = vi.fn((col, pattern) => {
+        const re = likeToRegex(pattern, true);
+        state.filters.push((r) => re.test(String(r[col] ?? "")));
+        return builder;
+    });
+    builder.like = vi.fn((col, pattern) => {
+        const re = likeToRegex(pattern, false);
+        state.filters.push((r) => re.test(String(r[col] ?? "")));
+        return builder;
+    });
+    builder.or = vi.fn((expr) => {
+        // Parse simple PostgREST or-expressions like "status.eq.active,status.eq.draft"
+        const clauses = expr.split(",").map((c) => c.trim());
+        const parsedFilters = [];
+        for (const clause of clauses) {
+            const parts = clause.split(".");
+            if (parts.length >= 3) {
+                const col = parts[0];
+                const op = parts[1];
+                const val = parts.slice(2).join(".");
+                switch (op) {
+                    case "eq":
+                        parsedFilters.push((r) => String(r[col]) === val);
+                        break;
+                    case "neq":
+                        parsedFilters.push((r) => String(r[col]) !== val);
+                        break;
+                    case "ilike":
+                        parsedFilters.push((r) => likeToRegex(val, true).test(String(r[col] ?? "")));
+                        break;
+                    case "like":
+                        parsedFilters.push((r) => likeToRegex(val, false).test(String(r[col] ?? "")));
+                        break;
+                    case "is":
+                        parsedFilters.push((r) => {
+                            if (val === "null")
+                                return r[col] === null || r[col] === undefined;
+                            return false;
+                        });
+                        break;
+                    default:
+                        // Unknown op — pass through
+                        parsedFilters.push(() => true);
+                }
+            }
+        }
+        if (parsedFilters.length > 0) {
+            state.filters.push((r) => parsedFilters.some((fn) => fn(r)));
+        }
+        return builder;
+    });
+    builder.is = vi.fn((col, val) => {
+        state.filters.push((r) => {
+            if (val === null)
+                return r[col] === null || r[col] === undefined;
+            return r[col] === val;
+        });
+        return builder;
+    });
+    builder.contains = vi.fn((col, val) => {
+        state.filters.push((r) => {
+            const v = r[col];
+            if (Array.isArray(v) && Array.isArray(val)) {
+                return val.every((item) => v.includes(item));
+            }
+            return false;
+        });
+        return builder;
+    });
+    builder.containedBy = vi.fn((col, val) => {
+        state.filters.push((r) => {
+            const v = r[col];
+            if (Array.isArray(v) && Array.isArray(val)) {
+                return v.every((item) => val.includes(item));
+            }
+            return false;
+        });
+        return builder;
+    });
+    builder.textSearch = vi.fn((_col, _query, _opts) => {
+        // Simplified: no-op (full-text search not easily mockable)
+        return builder;
+    });
+    // ordering / limits ------------------------------------------------------
+    builder.order = vi.fn((_col, _opts) => {
+        state.orderCol = _col;
+        state.orderAsc = _opts?.ascending ?? true;
+        return builder;
+    });
+    builder.limit = vi.fn((n) => {
+        state.limitCount = n;
+        return builder;
+    });
+    builder.range = vi.fn((from, to) => {
+        state.rangeFrom = from;
+        state.rangeTo = to;
+        return builder;
+    });
+    // terminal modifiers -----------------------------------------------------
+    builder.single = vi.fn(() => {
+        state.isSingle = true;
+        return resolve(state);
+    });
+    builder.maybeSingle = vi.fn(() => {
+        state.isMaybeSingle = true;
+        return resolve(state);
+    });
+    // csv export mock --------------------------------------------------------
+    builder.csv = vi.fn(() => {
+        const rows = tableData[state.table] || [];
+        const filtered = applyFilters(rows, state.filters);
+        if (filtered.length === 0)
+            return { data: "", error: null };
+        const keys = Object.keys(filtered[0]);
+        const header = keys.join(",");
+        const lines = filtered.map((r) => keys.map((k) => String(r[k] ?? "")).join(","));
+        return { data: [header, ...lines].join("\n"), error: null };
+    });
+    // Make the builder thenable so `await sb.from(...).select(...)...` works
+    // When no terminal modifier (.single/.maybeSingle) is called, the query
+    // resolves on await.
+    builder.then = (onFulfilled, onRejected) => {
+        const result = resolve(state);
+        return Promise.resolve(result).then(onFulfilled, onRejected);
+    };
+    return builder;
+}
+/** Resolve the query against the in-memory store */
+function resolve(state) {
+    // Check for forced table errors
+    const tableError = tableErrors[state.table];
+    if (tableError) {
+        return { data: null, error: tableError };
+    }
+    const rows = tableData[state.table] || [];
+    // INSERT
+    if (state.isInsert) {
+        const payload = state.insertPayload;
+        const newRows = Array.isArray(payload) ? payload : [payload];
+        // Assign ids if missing
+        const withIds = newRows.map((r, i) => ({
+            id: `mock-id-${Date.now()}-${i}`,
+            created_at: new Date().toISOString(),
+            ...r,
+        }));
+        if (!tableData[state.table])
+            tableData[state.table] = [];
+        tableData[state.table].push(...withIds);
+        if (state.isSingle) {
+            return { data: withIds[0], error: null };
+        }
+        return { data: withIds, error: null };
+    }
+    // UPDATE
+    if (state.isUpdate) {
+        const matching = applyFilters(rows, state.filters);
+        const updated = matching.map((r) => ({ ...r, ...state.updatePayload }));
+        // Replace in store
+        tableData[state.table] = rows.map((r) => {
+            const upd = updated.find((u) => u.id === r.id);
+            return upd || r;
+        });
+        if (state.isSingle || state.isMaybeSingle) {
+            return { data: updated[0] || null, error: null };
+        }
+        return { data: updated, error: null, count: updated.length };
+    }
+    // DELETE
+    if (state.isDelete) {
+        const before = rows.length;
+        const remaining = rows.filter((r) => !state.filters.every((fn) => fn(r)));
+        tableData[state.table] = remaining;
+        const deletedCount = before - remaining.length;
+        return { data: null, error: null, count: deletedCount };
+    }
+    // SELECT
+    let filtered = applyFilters(rows, state.filters);
+    if (state.orderCol) {
+        const col = state.orderCol;
+        const asc = state.orderAsc;
+        filtered.sort((a, b) => {
+            if (a[col] < b[col])
+                return asc ? -1 : 1;
+            if (a[col] > b[col])
+                return asc ? 1 : -1;
+            return 0;
+        });
+    }
+    // Apply range before limit
+    if (state.rangeFrom !== null && state.rangeTo !== null) {
+        filtered = filtered.slice(state.rangeFrom, state.rangeTo + 1);
+    }
+    else {
+        filtered = filtered.slice(0, state.limitCount);
+    }
+    if (state.countMode && state.headMode) {
+        return { data: null, error: null, count: filtered.length };
+    }
+    if (state.isSingle) {
+        return { data: filtered[0] || null, error: filtered.length === 0 ? { message: "Row not found" } : null };
+    }
+    if (state.isMaybeSingle) {
+        return { data: filtered[0] || null, error: null };
+    }
+    return { data: filtered, error: null, count: filtered.length };
+}
+// ---------------------------------------------------------------------------
+// Main factory
+// ---------------------------------------------------------------------------
+export function createMockSupabase() {
+    const client = {
+        from: vi.fn((table) => {
+            const state = defaultState(table);
+            return buildQueryBuilder(state);
+        }),
+        rpc: vi.fn((name, params) => {
+            const resp = rpcResponses[name];
+            if (resp)
+                return Promise.resolve(resp);
+            // Default: success with null data
+            return Promise.resolve({ data: null, error: null });
+        }),
+        storage: {
+            from: vi.fn((_bucket) => ({
+                upload: vi.fn((_path, _file, _opts) => Promise.resolve({ data: { path: _path }, error: null })),
+                getPublicUrl: vi.fn((path) => ({
+                    data: { publicUrl: `https://mock-storage.test/${path}` },
+                })),
+                remove: vi.fn((_paths) => Promise.resolve({ data: _paths.map((p) => ({ name: p })), error: null })),
+                list: vi.fn((_prefix) => Promise.resolve({ data: [], error: null })),
+            })),
+        },
+        auth: {
+            getUser: vi.fn(() => Promise.resolve({ data: { user: null }, error: null })),
+            getSession: vi.fn(() => Promise.resolve({ data: { session: null }, error: null })),
+        },
+    };
+    return client;
+}

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

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

package/dist/server/handlers/analytics.js

@@ -0,0 +1,266 @@
+export async function handleAnalytics(sb, args, storeId) {
+    const sid = storeId;
+    const locationId = args.location_id;
+    const daysBack = args.days_back;
+    // Resolve date range from period/days_back/custom dates
+    // Use store timezone (default: America/New_York) to avoid UTC date mismatch
+    const tz = args.timezone || "America/New_York";
+    const localDate = (d) => d.toLocaleDateString("en-CA", { timeZone: tz }); // YYYY-MM-DD
+    const getDateRange = () => {
+        const end = args.end_date || localDate(new Date());
+        if (args.start_date)
+            return { start: args.start_date, end };
+        if (args.days_back) {
+            const d = new Date();
+            d.setDate(d.getDate() - args.days_back);
+            return { start: localDate(d), end };
+        }
+        const periodDays = {
+            today: 0, yesterday: 1, last_7: 7, last_30: 30, last_90: 90,
+            last_180: 180, last_365: 365, all_time: 3650
+        };
+        const days = periodDays[args.period] ?? 30;
+        const d = new Date();
+        d.setDate(d.getDate() - days);
+        return { start: localDate(d), end };
+    };
+    const { start: startDate, end: endDate } = getDateRange();
+    switch (args.action) {
+        case "summary": {
+            const params = { p_store_id: sid, p_start_date: startDate, p_end_date: endDate };
+            if (locationId)
+                params.p_location_id = locationId;
+            const { data, error } = await sb.rpc("get_sales_analytics", params);
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        case "by_location": {
+            let q = sb.from("v_daily_sales").select("*").eq("store_id", sid)
+                .gte("sale_date", startDate).lte("sale_date", endDate);
+            if (locationId)
+                q = q.eq("location_id", locationId);
+            const { data, error } = await q.limit(500);
+            if (error)
+                return { success: false, error: error.message };
+            const byLoc = {};
+            for (const row of data || []) {
+                const lid = row.location_id;
+                if (!byLoc[lid])
+                    byLoc[lid] = { location_id: lid, revenue: 0, orders: 0 };
+                byLoc[lid].revenue += row.net_sales || row.total_sales || 0;
+                byLoc[lid].orders += row.order_count || 0;
+            }
+            return { success: true, data: Object.values(byLoc) };
+        }
+        case "detailed": {
+            let q = sb.from("v_daily_sales").select("*").eq("store_id", sid)
+                .gte("sale_date", startDate).lte("sale_date", endDate).order("sale_date", { ascending: false });
+            if (locationId)
+                q = q.eq("location_id", locationId);
+            const { data, error } = await q.limit(args.limit || 500);
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        case "employee": {
+            const { data, error } = await sb.rpc("employee_analytics", { p_store_id: sid });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        case "discover": {
+            const { data, error } = await sb.rpc("get_analytics_summary", { p_store_id: sid });
+            if (error)
+                return { success: false, error: error.message };
+            // Cap to last 90 days to stay under 30K response limit
+            const rows = Array.isArray(data) ? data.slice(-90) : data;
+            return { success: true, data: rows, _note: Array.isArray(data) && data.length > 90 ? `Showing last 90 of ${data.length} days. Use analytics.detailed with date_from/date_to for specific ranges.` : undefined };
+        }
+        // ---- Category & Product Sales (NEW) ----
+        case "by_category": {
+            const days = daysBack || 30;
+            const { data, error } = await sb.rpc("get_category_performance", {
+                p_store_id: sid,
+                p_location_id: locationId || null,
+                p_days: days
+            });
+            if (error)
+                return { success: false, error: error.message };
+            const categories = (data || []).map((row) => ({
+                categoryId: row.category_id,
+                categoryName: row.category_name,
+                orderCount: row.order_count,
+                totalGrams: row.total_grams,
+                totalRevenue: row.total_revenue,
+                avgPricePerGram: row.avg_price_per_gram,
+                revenueShare: row.revenue_share
+            }));
+            return {
+                success: true,
+                data: {
+                    days,
+                    locationId: locationId || "all",
+                    categories,
+                    totalRevenue: categories.reduce((s, c) => s + parseFloat(c.totalRevenue || 0), 0)
+                }
+            };
+        }
+        case "category_velocity": {
+            const days = daysBack || 30;
+            const categoryName = args.category_name;
+            const { data, error } = await sb.rpc("get_inventory_velocity", {
+                p_store_id: sid,
+                p_location_id: locationId || null,
+                p_category_name: categoryName || null,
+                p_days: days
+            });
+            if (error)
+                return { success: false, error: error.message };
+            const results = (data || []).map((row) => ({
+                locationId: row.location_id,
+                locationName: row.location_name,
+                locationType: row.location_type,
+                categoryId: row.category_id,
+                categoryName: row.category_name,
+                currentStock: row.current_stock,
+                totalSold: row.sold_in_period,
+                dailyVelocity: row.daily_velocity,
+                daysOfStock: row.days_of_stock,
+                stockAlert: row.status
+            }));
+            return { success: true, data: { days, categoryFilter: categoryName || "all", results } };
+        }
+        case "product_sales": {
+            const days = daysBack || 30;
+            const categoryId = args.category_id;
+            const productId = args.product_id;
+            const limit = args.limit || 50;
+            const { data, error } = await sb.rpc("get_product_velocity", {
+                p_store_id: sid,
+                p_days: days,
+                p_location_id: locationId || null,
+                p_category_id: categoryId || null,
+                p_product_id: productId || null,
+                p_limit: limit
+            });
+            if (error)
+                return { success: false, error: error.message };
+            const products = (data || []).map((row) => ({
+                productId: row.product_id,
+                name: row.product_name,
+                sku: row.product_sku,
+                category: row.category_name,
+                locationId: row.location_id,
+                locationName: row.location_name,
+                totalQty: row.units_sold,
+                totalRevenue: row.revenue,
+                orderCount: row.order_count,
+                velocityPerDay: row.daily_velocity,
+                revenuePerDay: row.daily_revenue,
+                currentStock: row.current_stock,
+                daysOfStock: row.days_of_stock,
+                avgPrice: row.avg_unit_price,
+                stockAlert: row.stock_status
+            }));
+            return {
+                success: true,
+                data: {
+                    days,
+                    filters: { categoryId, locationId, productId },
+                    products,
+                    totalUnits: products.reduce((s, p) => s + parseFloat(p.totalQty || 0), 0),
+                    totalRevenue: products.reduce((s, p) => s + parseFloat(p.totalRevenue || 0), 0)
+                }
+            };
+        }
+        // ---- Intelligence Actions ----
+        case "customers":
+        case "customer_intelligence": {
+            const { data, error } = await sb.rpc("get_customer_intelligence", { p_store_id: sid });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        case "products":
+        case "product_intelligence": {
+            const { data, error } = await sb.rpc("get_product_intelligence", { p_store_id: sid });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        case "inventory_intelligence": {
+            const { data, error } = await sb.rpc("get_inventory_intelligence", { p_store_id: sid });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        case "marketing":
+        case "marketing_intelligence": {
+            const { data, error } = await sb.rpc("get_marketing_intelligence", {
+                p_store_id: sid, p_start_date: startDate, p_end_date: endDate
+            });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        case "fraud":
+        case "fraud_detection": {
+            let q = sb.from("v_fraud_detection").select("*").order("risk_score", { ascending: false }).limit(100);
+            q = q.eq("store_id", sid);
+            if (args.risk_level)
+                q = q.eq("risk_level", args.risk_level);
+            const { data, error } = await q;
+            if (error)
+                return { success: false, error: error.message };
+            return {
+                success: true,
+                data: {
+                    totalOrders: data?.length || 0,
+                    highRisk: data?.filter((o) => o.risk_level === "high").length || 0,
+                    mediumRisk: data?.filter((o) => o.risk_level === "medium").length || 0,
+                    avgRiskScore: data?.length ? Math.round(data.reduce((s, o) => s + o.risk_score, 0) / data.length) : 0,
+                    orders: data
+                }
+            };
+        }
+        case "employee_performance": {
+            let q = sb.from("v_employee_performance").select("*").order("total_revenue", { ascending: false });
+            q = q.eq("store_id", sid);
+            const { data, error } = await q.limit(200);
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        case "behavior":
+        case "behavioral_analytics": {
+            let q = sb.from("v_behavioral_analytics").select("*")
+                .gte("visit_date", startDate).lte("visit_date", endDate);
+            q = q.eq("store_id", sid);
+            const { data, error } = await q.limit(500);
+            if (error)
+                return { success: false, error: error.message };
+            const totals = (data || []).reduce((acc, row) => ({
+                sessions: acc.sessions + (row.sessions || 0),
+                pageViews: acc.pageViews + (row.page_views || 0),
+                rageClicks: acc.rageClicks + (row.total_rage_clicks || 0),
+                uxIssues: acc.uxIssues + (row.sessions_with_ux_issues || 0)
+            }), { sessions: 0, pageViews: 0, rageClicks: 0, uxIssues: 0 });
+            return {
+                success: true,
+                data: {
+                    summary: {
+                        ...totals,
+                        avgPagesPerSession: totals.sessions ? Math.round((totals.pageViews / totals.sessions) * 100) / 100 : 0,
+                        uxIssueRate: totals.sessions ? Math.round((totals.uxIssues / totals.sessions) * 10000) / 100 : 0
+                    }
+                }
+            };
+        }
+        case "full":
+        case "business_intelligence": {
+            // Compose from individual intelligence RPCs (no single get_business_intelligence RPC)
+            const [sales, customers, products, inventory] = await Promise.all([
+                sb.rpc("get_sales_analytics", { p_store_id: sid, p_start_date: startDate, p_end_date: endDate }),
+                sb.rpc("get_customer_intelligence", { p_store_id: sid }),
+                sb.rpc("get_product_intelligence", { p_store_id: sid }),
+                sb.rpc("get_inventory_intelligence", { p_store_id: sid }),
+            ]);
+            return {
+                success: true,
+                data: {
+                    sales: sales.error ? { error: sales.error.message } : sales.data,
+                    customers: customers.error ? { error: customers.error.message } : customers.data,
+                    products: products.error ? { error: products.error.message } : products.data,
+                    inventory: inventory.error ? { error: inventory.error.message } : inventory.data,
+                }
+            };
+        }
+        default:
+            return { success: false, error: `Unknown analytics action: ${args.action}. Available: summary, by_location, detailed, by_category, category_velocity, product_sales, discover, employee, customers, products, inventory_intelligence, marketing, fraud, employee_performance, behavior, full` };
+    }
+}

package/dist/server/handlers/api-keys.d.ts

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