whale-code 6.5.10 → 6.6.0

package/dist/server/handlers/__tests__/workflow-cache.test.js

@@ -1,237 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { randomUUID } from "node:crypto";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE } from "../__test-utils__/test-db.js";
-
-// ============================================================================
-// Real Supabase client
-// ============================================================================
-
-const sb = getTestClient();
-
-// ============================================================================
-// In-Memory Cache (mirrors workflow-steps.ts logic)
-// ============================================================================
-
-const VERSION_CACHE_MAX_SIZE = 500;
-const VERSION_CACHE_TTL_MS = 30_000;
-function createVersionedStepsCache() {
-  const cache = new Map();
-  function set(key, value) {
-    if (cache.has(key)) {
-      cache.delete(key);
-    }
-    cache.set(key, value);
-    if (cache.size > VERSION_CACHE_MAX_SIZE) {
-      const excess = cache.size - VERSION_CACHE_MAX_SIZE;
-      let removed = 0;
-      for (const k of cache.keys()) {
-        if (removed >= excess) break;
-        cache.delete(k);
-        removed++;
-      }
-    }
-  }
-  function get(key) {
-    const entry = cache.get(key);
-    if (!entry) return undefined;
-    if (Date.now() > entry.expiresAt) {
-      cache.delete(key);
-      return undefined;
-    }
-    return entry;
-  }
-  function clear() {
-    cache.clear();
-  }
-  return {
-    set,
-    get,
-    clear,
-    _cache: cache
-  };
-}
-async function loadVersionedSteps(cache, runId) {
-  const cached = cache.get(runId);
-  if (cached) return cached.data;
-
-  // Real DB query
-  const {
-    data: runData,
-    error: runError
-  } = await sb.from("workflow_runs").select("version_id").eq("id", runId).single();
-  if (runError || !runData?.version_id) {
-    cache.set(runId, {
-      data: null,
-      expiresAt: Date.now() + VERSION_CACHE_TTL_MS
-    });
-    return null;
-  }
-  const {
-    data: versionData,
-    error: versionError
-  } = await sb.from("workflow_versions").select("steps").eq("id", runData.version_id).single();
-  if (versionError) {
-    cache.set(runId, {
-      data: null,
-      expiresAt: Date.now() + VERSION_CACHE_TTL_MS
-    });
-    return null;
-  }
-  const result = versionData?.steps && Array.isArray(versionData.steps) ? versionData.steps : null;
-  cache.set(runId, {
-    data: result,
-    expiresAt: Date.now() + VERSION_CACHE_TTL_MS
-  });
-  return result;
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("Versioned Steps Cache", () => {
-  let cache;
-  let workflowId;
-  let versionId;
-  let runId;
-  beforeEach(async () => {
-    cache = createVersionedStepsCache();
-    workflowId = randomUUID();
-    versionId = randomUUID();
-    runId = randomUUID();
-
-    // Seed workflow first (workflow_versions.workflow_id FK)
-    await seedTracked("workflows", [{
-      id: workflowId,
-      store_id: TEST_STORE,
-      name: `${randomUUID().slice(0, 8)}_test_workflow`,
-      status: "active",
-      trigger_type: "manual"
-    }]);
-
-    // Seed real data (workflow_versions has no store_id, uses workflow_id instead)
-    await seedTracked("workflow_versions", [{
-      id: versionId,
-      workflow_id: workflowId,
-      version: 1,
-      name: "v1",
-      trigger_type: "manual",
-      steps: [{
-        step_key: "start",
-        step_config: {
-          type: "code"
-        },
-        on_success: "end"
-      }, {
-        step_key: "end",
-        step_config: {
-          type: "code"
-        }
-      }]
-    }]);
-    await seedTracked("workflow_runs", [{
-      id: runId,
-      workflow_id: workflowId,
-      version_id: versionId,
-      status: "running",
-      store_id: TEST_STORE,
-      trigger_type: "manual"
-    }]);
-  });
-  afterEach(async () => {
-    await cleanup();
-  });
-  it("returns same data on repeated calls within TTL", async () => {
-    const first = await loadVersionedSteps(cache, runId);
-    const second = await loadVersionedSteps(cache, runId);
-    expect(first).toEqual(second);
-    expect(first).toHaveLength(2);
-    expect(first[0].step_key).toBe("start");
-
-    // Both should reference the same cached data (same object identity)
-    expect(first).toBe(second);
-  });
-  it("clears all entries on clear()", async () => {
-    // Populate cache
-    await loadVersionedSteps(cache, runId);
-    expect(cache._cache.size).toBe(1);
-
-    // Clear
-    cache.clear();
-    expect(cache._cache.size).toBe(0);
-
-    // Next call should re-fetch from DB
-    const result = await loadVersionedSteps(cache, runId);
-    expect(result).toHaveLength(2);
-    expect(cache._cache.size).toBe(1);
-  });
-  it("cache entries expire after TTL", async () => {
-    // Manually insert with an already-expired TTL
-    cache.set(runId, {
-      data: [{
-        step_key: "stale",
-        step_config: {}
-      }],
-      expiresAt: Date.now() - 1000 // Already expired
-    });
-
-    // get() should return undefined for expired entries
-    const expired = cache.get(runId);
-    expect(expired).toBeUndefined();
-
-    // loadVersionedSteps should re-fetch from DB since cache is expired
-    const fresh = await loadVersionedSteps(cache, runId);
-    expect(fresh).toHaveLength(2);
-    expect(fresh[0].step_key).toBe("start");
-  });
-  it("evicts oldest entries when cache exceeds max size", () => {
-    // Fill cache to the max + 1
-    for (let i = 0; i <= VERSION_CACHE_MAX_SIZE; i++) {
-      cache.set(`run_${i}`, {
-        data: null,
-        expiresAt: Date.now() + 60_000
-      });
-    }
-
-    // Size should be capped at VERSION_CACHE_MAX_SIZE
-    expect(cache._cache.size).toBe(VERSION_CACHE_MAX_SIZE);
-
-    // The first entry (run_0) should have been evicted
-    expect(cache.get("run_0")).toBeUndefined();
-
-    // The last entry should still be present
-    expect(cache.get(`run_${VERSION_CACHE_MAX_SIZE}`)).toBeDefined();
-  });
-  it("returns null for runs without a version_id", async () => {
-    const runNoVersion = randomUUID();
-    await seedTracked("workflow_runs", [{
-      id: runNoVersion,
-      workflow_id: workflowId,
-      status: "running",
-      store_id: TEST_STORE,
-      trigger_type: "manual"
-      // No version_id
-    }]);
-    const result = await loadVersionedSteps(cache, runNoVersion);
-    expect(result).toBeNull();
-
-    // Should still be cached (caches null result)
-    expect(cache._cache.size).toBeGreaterThanOrEqual(1);
-    const cached = cache.get(runNoVersion);
-    expect(cached).toBeDefined();
-    expect(cached.data).toBeNull();
-  });
-});
-
-// ============================================================================
-// Test clearStepCache export from workflow-steps.ts
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("clearStepCache export", () => {
-  it("clearStepCache is exported and callable", async () => {
-    const mod = await import("../workflow-steps.js");
-    expect(typeof mod.clearStepCache).toBe("function");
-    // Should not throw when called
-    expect(() => mod.clearStepCache()).not.toThrow();
-  });
-});

package/dist/server/handlers/analytics-errors-edge.test.js

@@ -1,173 +0,0 @@
-// analytics-errors-edge.test.ts — Date range filtering, RPC error propagation, empty data, unknown action
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, cleanup, TEST_STORE } from "./__test-utils__/test-db.js";
-import { handleAnalytics } from "./analytics.js";
-const sb = getTestClient();
-
-/** Helper: spy on sb.rpc to intercept specific RPC calls */
-function stubRpc(rpcName, returnValue, error) {
-  const originalRpc = sb.rpc.bind(sb);
-  const current = vi.mocked(sb.rpc);
-  // If already spied, chain on to existing mock
-  if (current && typeof current.mockImplementation === "function") {
-    const prev = current.getMockImplementation();
-    current.mockImplementation((fn, params) => {
-      if (fn === rpcName) {
-        if (error) return Promise.resolve({
-          data: null,
-          error
-        });
-        return Promise.resolve({
-          data: returnValue,
-          error: null
-        });
-      }
-      if (prev) return prev(fn, params);
-      return originalRpc(fn, params);
-    });
-  } else {
-    vi.spyOn(sb, "rpc").mockImplementation((fn, params) => {
-      if (fn === rpcName) {
-        if (error) return Promise.resolve({
-          data: null,
-          error
-        });
-        return Promise.resolve({
-          data: returnValue,
-          error: null
-        });
-      }
-      return originalRpc(fn, params);
-    });
-  }
-}
-
-/** Stub multiple RPCs at once */
-function stubRpcs(stubs) {
-  const originalRpc = sb.rpc.bind(sb);
-  vi.spyOn(sb, "rpc").mockImplementation((fn, params) => {
-    if (fn in stubs) {
-      const s = stubs[fn];
-      if (s.error) return Promise.resolve({
-        data: null,
-        error: s.error
-      });
-      return Promise.resolve({
-        data: s.data ?? null,
-        error: null
-      });
-    }
-    return originalRpc(fn, params);
-  });
-}
-describe.skipIf(!HAS_TEST_DB)("handleAnalytics — errors & edge cases", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await cleanup();
-  });
-
-  // ========================================================================
-  // DATE RANGE FILTERING
-  // ========================================================================
-
-  describe("date range filtering", () => {
-    it("accepts explicit start_date and end_date", async () => {
-      stubRpc("get_sales_analytics", {
-        total_revenue: 1000
-      });
-      const result = await handleAnalytics(sb, {
-        action: "summary",
-        start_date: "2026-01-01",
-        end_date: "2026-01-31"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-    });
-    it("computes date range from period shorthand", async () => {
-      stubRpc("get_sales_analytics", {
-        total_revenue: 500
-      });
-      const result = await handleAnalytics(sb, {
-        action: "summary",
-        period: "last_7"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-    });
-  });
-
-  // ========================================================================
-  // RPC ERROR PROPAGATION
-  // ========================================================================
-
-  describe("RPC error propagation", () => {
-    it("propagates RPC error on category analytics", async () => {
-      stubRpc("get_category_performance", null, {
-        message: "function timeout"
-      });
-      const result = await handleAnalytics(sb, {
-        action: "by_category"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("function timeout");
-    });
-    it("propagates RPC error on product velocity", async () => {
-      stubRpc("get_product_velocity", null, {
-        message: "permission denied"
-      });
-      const result = await handleAnalytics(sb, {
-        action: "product_sales"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("permission denied");
-    });
-    it("propagates RPC error on employee analytics", async () => {
-      stubRpc("employee_analytics", null, {
-        message: "rate limit exceeded"
-      });
-      const result = await handleAnalytics(sb, {
-        action: "employee"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("rate limit exceeded");
-    });
-  });
-
-  // ========================================================================
-  // EMPTY DATA
-  // ========================================================================
-
-  describe("empty data handling", () => {
-    it("handles empty sales data gracefully", async () => {
-      // No v_daily_sales rows for this store — real DB returns empty
-      const result = await handleAnalytics(sb, {
-        action: "detailed"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-    });
-    it("handles empty category performance", async () => {
-      stubRpc("get_category_performance", []);
-      const result = await handleAnalytics(sb, {
-        action: "by_category"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(result.data.categories).toHaveLength(0);
-    });
-  });
-
-  // ========================================================================
-  // UNKNOWN ACTION
-  // ========================================================================
-
-  describe("unknown action", () => {
-    it("returns error for unrecognized action", async () => {
-      const result = await handleAnalytics(sb, {
-        action: "crystal_ball"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Unknown analytics action");
-    });
-  });
-});

package/dist/server/handlers/analytics.test.js

@@ -1,280 +0,0 @@
-// analytics.test.ts — Tests for handleAnalytics handler (summary, by_location, detailed, by_category, product_sales, employee)
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, cleanup, TEST_STORE } from "./__test-utils__/test-db.js";
-import { handleAnalytics } from "./analytics.js";
-const sb = getTestClient();
-
-/** Helper: spy on sb.rpc to intercept specific RPC calls */
-function stubRpc(rpcName, returnValue, error) {
-  const originalRpc = sb.rpc.bind(sb);
-  const current = vi.mocked(sb.rpc);
-  // If already spied, chain on to existing mock
-  if (current && typeof current.mockImplementation === "function") {
-    const prev = current.getMockImplementation();
-    current.mockImplementation((fn, params) => {
-      if (fn === rpcName) {
-        if (error) return Promise.resolve({
-          data: null,
-          error
-        });
-        return Promise.resolve({
-          data: returnValue,
-          error: null
-        });
-      }
-      if (prev) return prev(fn, params);
-      return originalRpc(fn, params);
-    });
-  } else {
-    vi.spyOn(sb, "rpc").mockImplementation((fn, params) => {
-      if (fn === rpcName) {
-        if (error) return Promise.resolve({
-          data: null,
-          error
-        });
-        return Promise.resolve({
-          data: returnValue,
-          error: null
-        });
-      }
-      return originalRpc(fn, params);
-    });
-  }
-}
-
-/** Stub multiple RPCs at once */
-function stubRpcs(stubs) {
-  const originalRpc = sb.rpc.bind(sb);
-  vi.spyOn(sb, "rpc").mockImplementation((fn, params) => {
-    if (fn in stubs) {
-      const s = stubs[fn];
-      if (s.error) return Promise.resolve({
-        data: null,
-        error: s.error
-      });
-      return Promise.resolve({
-        data: s.data ?? null,
-        error: null
-      });
-    }
-    return originalRpc(fn, params);
-  });
-}
-describe.skipIf(!HAS_TEST_DB)("handleAnalytics", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await cleanup();
-  });
-
-  // ========================================================================
-  // SUMMARY
-  // ========================================================================
-
-  describe("action: summary", () => {
-    it("returns sales summary via RPC", async () => {
-      stubRpc("get_sales_analytics", {
-        total_revenue: 50000,
-        total_orders: 250,
-        avg_order_value: 200
-      });
-      const result = await handleAnalytics(sb, {
-        action: "summary"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(result.data).toBeDefined();
-      expect(result.data.total_revenue).toBe(50000);
-    });
-    it("returns error when RPC fails", async () => {
-      stubRpc("get_sales_analytics", null, {
-        message: "Analytics service unavailable"
-      });
-      const result = await handleAnalytics(sb, {
-        action: "summary"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe("Analytics service unavailable");
-    });
-  });
-
-  // ========================================================================
-  // BY LOCATION
-  // ========================================================================
-
-  describe("action: by_location", () => {
-    it("returns revenue grouped by location", async () => {
-      // v_daily_sales is a VIEW — stub the from() chain instead of seeding
-      const originalFrom = sb.from.bind(sb);
-      vi.spyOn(sb, "from").mockImplementation(table => {
-        if (table === "v_daily_sales") {
-          const mockResult = Promise.resolve({
-            data: [{
-              location_id: "l1",
-              sale_date: "2026-01-15",
-              net_sales: 1000,
-              order_count: 10
-            }, {
-              location_id: "l1",
-              sale_date: "2026-01-16",
-              net_sales: 1500,
-              order_count: 12
-            }, {
-              location_id: "l2",
-              sale_date: "2026-01-15",
-              net_sales: 800,
-              order_count: 8
-            }],
-            error: null
-          });
-          const chainEnd = {
-            limit: () => mockResult,
-            then: mockResult.then.bind(mockResult)
-          };
-          return {
-            select: () => ({
-              eq: () => ({
-                gte: () => ({
-                  lte: () => chainEnd
-                })
-              })
-            })
-          };
-        }
-        return originalFrom(table);
-      });
-      const result = await handleAnalytics(sb, {
-        action: "by_location"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(Array.isArray(result.data)).toBe(true);
-    });
-  });
-
-  // ========================================================================
-  // DETAILED
-  // ========================================================================
-
-  describe("action: detailed", () => {
-    it("returns daily sales rows", async () => {
-      // v_daily_sales is a VIEW — stub the from() chain instead of seeding
-      const originalFrom = sb.from.bind(sb);
-      vi.spyOn(sb, "from").mockImplementation(table => {
-        if (table === "v_daily_sales") {
-          const mockResult = Promise.resolve({
-            data: [{
-              sale_date: "2026-01-15",
-              net_sales: 2000,
-              order_count: 15
-            }, {
-              sale_date: "2026-01-16",
-              net_sales: 2500,
-              order_count: 20
-            }],
-            error: null
-          });
-          const chainEnd = {
-            limit: () => mockResult,
-            then: mockResult.then.bind(mockResult)
-          };
-          return {
-            select: () => ({
-              eq: () => ({
-                gte: () => ({
-                  lte: () => ({
-                    order: () => chainEnd
-                  })
-                })
-              })
-            })
-          };
-        }
-        return originalFrom(table);
-      });
-      const result = await handleAnalytics(sb, {
-        action: "detailed"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(Array.isArray(result.data)).toBe(true);
-    });
-  });
-
-  // ========================================================================
-  // BY CATEGORY
-  // ========================================================================
-
-  describe("action: by_category", () => {
-    it("returns category performance via RPC", async () => {
-      stubRpc("get_category_performance", [{
-        category_id: "cat-1",
-        category_name: "Edibles",
-        order_count: 50,
-        total_revenue: 5000,
-        revenue_share: 0.45
-      }, {
-        category_id: "cat-2",
-        category_name: "Flower",
-        order_count: 80,
-        total_revenue: 6000,
-        revenue_share: 0.55
-      }]);
-      const result = await handleAnalytics(sb, {
-        action: "by_category"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(result.data.categories).toHaveLength(2);
-      expect(result.data.days).toBe(30); // default
-    });
-    it("uses custom days_back", async () => {
-      stubRpc("get_category_performance", []);
-      const result = await handleAnalytics(sb, {
-        action: "by_category",
-        days_back: 7
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(result.data.days).toBe(7);
-    });
-  });
-
-  // ========================================================================
-  // PRODUCT SALES
-  // ========================================================================
-
-  describe("action: product_sales", () => {
-    it("returns product velocity data", async () => {
-      stubRpc("get_product_velocity", [{
-        product_id: "p1",
-        product_name: "Widget",
-        units_sold: 100,
-        revenue: 5000,
-        daily_velocity: 3.3
-      }]);
-      const result = await handleAnalytics(sb, {
-        action: "product_sales"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-      expect(result.data.products).toHaveLength(1);
-      expect(result.data.products[0].name).toBe("Widget");
-    });
-  });
-
-  // ========================================================================
-  // EMPLOYEE
-  // ========================================================================
-
-  describe("action: employee", () => {
-    it("returns employee analytics via RPC", async () => {
-      stubRpc("employee_analytics", [{
-        employee_name: "Alice",
-        total_sales: 15000,
-        order_count: 75
-      }]);
-      const result = await handleAnalytics(sb, {
-        action: "employee"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-    });
-  });
-});

package/dist/server/handlers/api-docs-examples-ext.d.ts

@@ -1,9 +0,0 @@
-import type { ExampleSet } from "./api-docs-examples.js";
-export declare const ordersExamples: ExampleSet;
-export declare const customersExamples: ExampleSet;
-export declare const inventoryExamples: ExampleSet;
-export declare const analyticsExamples: ExampleSet;
-export declare const locationsExamples: ExampleSet;
-export declare const storefrontExamples: ExampleSet;
-export declare const coaExamples: ExampleSet;
-export declare const portalExamples: ExampleSet;