whale-code 6.5.10 → 6.6.0

package/dist/server/handlers/meta-ads-update.test.js

@@ -1,117 +0,0 @@
-// meta-ads-update.test.ts — Tests for handleMetaAds update operations
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE, RUN_PREFIX } from "./__test-utils__/test-db.js";
-import { randomUUID } from "node:crypto";
-const originalFetch = globalThis.fetch;
-const mockFetch = vi.fn((...args) => originalFetch(...args));
-import { handleMetaAds } from "./meta-ads.js";
-const sb = getTestClient();
-describe.skipIf(!HAS_TEST_DB)("handleMetaAds — update operations", () => {
-  beforeEach(async () => {
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
-    mockFetch.mockImplementation((...args) => originalFetch(...args));
-    globalThis.fetch = mockFetch;
-    await sb.from("meta_ads").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_ad_sets").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_campaigns").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_integrations").delete().eq("store_id", TEST_STORE).then(() => {});
-  });
-  afterEach(async () => {
-    globalThis.fetch = originalFetch;
-    vi.restoreAllMocks();
-    await cleanup();
-    await sb.from("meta_ads").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_ad_sets").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_campaigns").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("meta_integrations").delete().eq("store_id", TEST_STORE).then(() => {});
-  });
-
-  // ========================================================================
-  // UPDATE_CAMPAIGN
-  // ========================================================================
-
-  describe("action: update_campaign", () => {
-    it("updates campaign fields", async () => {
-      const [camp] = await seedTracked("meta_campaigns", [{
-        id: randomUUID(),
-        store_id: TEST_STORE,
-        meta_campaign_id: `local_${RUN_PREFIX}_updcamp`,
-        meta_account_id: "draft",
-        name: `${RUN_PREFIX} Old Name`,
-        objective: "OUTCOME_AWARENESS",
-        status: "DRAFT"
-      }]);
-      const result = await handleMetaAds(sb, {
-        action: "update_campaign",
-        campaign_id: camp.id,
-        name: `${RUN_PREFIX} Updated Name`,
-        status: "ACTIVE"
-      }, TEST_STORE);
-      expect(result.success).toBe(true);
-    });
-    it("returns error when campaign_id is missing", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "update_campaign",
-        name: "Updated"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("campaign_id required");
-    });
-    it("returns error when no fields to update", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "update_campaign",
-        campaign_id: randomUUID()
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("No fields to update");
-    });
-  });
-
-  // ========================================================================
-  // UPDATE_AD_SET
-  // ========================================================================
-
-  describe("action: update_ad_set", () => {
-    it("returns error when ad_set_id is missing", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "update_ad_set",
-        name: "Updated"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("ad_set_id required");
-    });
-    it("returns error when no fields to update", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "update_ad_set",
-        ad_set_id: randomUUID()
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("No fields to update");
-    });
-  });
-
-  // ========================================================================
-  // UPDATE_AD
-  // ========================================================================
-
-  describe("action: update_ad", () => {
-    it("returns error when ad_id is missing", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "update_ad",
-        name: "Updated"
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("ad_id required");
-    });
-    it("returns error when no fields to update", async () => {
-      const result = await handleMetaAds(sb, {
-        action: "update_ad",
-        ad_id: randomUUID()
-      }, TEST_STORE);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("No fields to update");
-    });
-  });
-});

package/dist/server/handlers/nodes-channels.test.js

@@ -1,413 +0,0 @@
-// nodes-channels.test.ts — Tests for channel and message routes in handleNodeRoutes
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE, RUN_PREFIX } from "./__test-utils__/test-db.js";
-vi.mock("./billing.js", () => ({
-  checkPlanLimits: vi.fn().mockResolvedValue({
-    allowed: true
-  }),
-  incrementUsage: vi.fn().mockResolvedValue(undefined)
-}));
-vi.mock("node:crypto", async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    createHash: vi.fn().mockReturnValue({
-      update: vi.fn().mockReturnValue({
-        digest: vi.fn().mockReturnValue("mocked-hash-abc123")
-      })
-    }),
-    randomBytes: vi.fn().mockReturnValue({
-      toString: vi.fn().mockReturnValue("mocked-api-key-hex-string-64chars-long-enough-for-testing-12345678")
-    }),
-    randomUUID: vi.fn().mockReturnValue("a0a0a0a0-0001-0002-0003-000000000001")
-  };
-});
-import { handleNodeRoutes, clearNodeAuthCache } from "./nodes.js";
-import { checkPlanLimits } from "./billing.js";
-const sb = getTestClient();
-const USER_ID = "562fd6cb-ef83-4eca-b999-ffeac2293ee7";
-const NODE_ID = "a0a0a0a0-0001-0002-0003-000000000001";
-const CHANNEL_ID = "b0b0b0b0-0001-0002-0003-000000000001";
-function makeNode(overrides = {}) {
-  return {
-    id: NODE_ID,
-    store_id: TEST_STORE,
-    name: `${RUN_PREFIX} Test Node`,
-    api_key_hash: "mocked-hash-abc123",
-    status: "online",
-    capabilities: ["chat", "voice"],
-    hardware: {
-      cpu: "arm64"
-    },
-    version: "1.0.0",
-    ip_address: null,
-    last_heartbeat: "2026-01-01T00:00:00Z",
-    created_at: "2026-01-01T00:00:00Z",
-    ...overrides
-  };
-}
-function makeChannel(overrides = {}) {
-  return {
-    id: CHANNEL_ID,
-    store_id: TEST_STORE,
-    node_id: NODE_ID,
-    type: "sms",
-    name: `${RUN_PREFIX} SMS Channel`,
-    status: "active",
-    config: {},
-    agent_id: null,
-    stats: {},
-    error_message: null,
-    created_at: "2026-01-01T00:00:00Z",
-    updated_at: "2026-01-01T00:00:00Z",
-    ...overrides
-  };
-}
-function makeAuth(overrides = {}) {
-  return {
-    userId: USER_ID,
-    isServiceRole: false,
-    rawToken: "user-jwt-token",
-    ...overrides
-  };
-}
-function makeNodeAuth(overrides = {}) {
-  return {
-    userId: undefined,
-    isServiceRole: false,
-    rawToken: "node-api-key-raw",
-    ...overrides
-  };
-}
-describe.skipIf(!HAS_TEST_DB)("handleNodeRoutes (channels/messages)", () => {
-  async function cleanTables() {
-    await sb.from("channel_messages").delete().eq("channel_id", CHANNEL_ID).then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-  }
-  beforeEach(async () => {
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
-    clearNodeAuthCache();
-    await cleanTables();
-    const {
-      data: s
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (s?.owner_user_id) await sb.from("platform_users").update({
-      auth_id: USER_ID
-    }).eq("id", s.owner_user_id);
-  });
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await cleanup();
-    await cleanTables();
-    const {
-      data: s
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (s?.owner_user_id) await sb.from("platform_users").update({
-      auth_id: null
-    }).eq("id", s.owner_user_id);
-  });
-  describe("POST /channels", () => {
-    it("registers a channel on a node", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("store_plans", [{
-        store_id: TEST_STORE,
-        plan: "pro",
-        limits: {
-          channels_per_node: 5
-        }
-      }]);
-      const result = await handleNodeRoutes("/channels", "POST", {
-        store_id: TEST_STORE,
-        node_id: NODE_ID,
-        type: "sms",
-        name: `${RUN_PREFIX} SMS`
-      }, sb, makeAuth());
-      expect(result.status).toBe(201);
-      expect(result.body.success).toBe(true);
-      expect(result.body.channel).toBeDefined();
-    });
-    it("returns 400 when body is missing", async () => {
-      const result = await handleNodeRoutes("/channels", "POST", null, sb, makeAuth());
-      expect(result.status).toBe(400);
-    });
-    it("returns 400 when required fields are missing", async () => {
-      const result = await handleNodeRoutes("/channels", "POST", {
-        store_id: TEST_STORE,
-        node_id: NODE_ID
-      }, sb, makeAuth());
-      expect(result.status).toBe(400);
-      expect(result.body.error).toContain("type, and name required");
-    });
-    it("returns 404 when node not found in store", async () => {
-      const result = await handleNodeRoutes("/channels", "POST", {
-        store_id: TEST_STORE,
-        node_id: "nonexistent",
-        type: "sms",
-        name: "SMS"
-      }, sb, makeAuth());
-      expect(result.status).toBe(404);
-      expect(result.body.error).toContain("Node not found");
-    });
-    it("returns 429 when channel limit reached", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("store_plans", [{
-        store_id: TEST_STORE,
-        plan: "free",
-        limits: {
-          channels_per_node: 1
-        }
-      }]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes("/channels", "POST", {
-        store_id: TEST_STORE,
-        node_id: NODE_ID,
-        type: "email",
-        name: `${RUN_PREFIX} Email`
-      }, sb, makeAuth());
-      expect(result.status).toBe(429);
-      expect(result.body.error).toContain("Channel limit reached");
-    });
-  });
-  describe("GET|POST /channels/list", () => {
-    it("lists channels for a store", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes("/channels/list", "GET", null, sb, makeAuth(), new URLSearchParams({
-        store_id: TEST_STORE
-      }));
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(Array.isArray(result.body.channels)).toBe(true);
-    });
-    it("returns 400 when store_id is missing", async () => {
-      const result = await handleNodeRoutes("/channels/list", "GET", null, sb, makeAuth());
-      expect(result.status).toBe(400);
-      expect(result.body.error).toContain("store_id required");
-    });
-    it("works with POST body for store_id", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes("/channels/list", "POST", {
-        store_id: TEST_STORE
-      }, sb, makeAuth());
-      expect(result.status).toBe(200);
-    });
-  });
-  describe("PATCH /channels/:id", () => {
-    it("updates channel agent assignment", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}`, "POST", {
-        _method: "PATCH",
-        agent_id: "a0a0a0a0-a0a0-a0a0-a0a0-a0a0a0a00001"
-      }, sb, makeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-    });
-    it("updates channel config", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}`, "PUT", {
-        _method: "PATCH",
-        config: {
-          webhook_url: "https://example.com"
-        }
-      }, sb, makeAuth());
-      expect(result.status).toBe(200);
-    });
-    it("updates channel name and status", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}`, "POST", {
-        _method: "PATCH",
-        name: `${RUN_PREFIX} New Name`,
-        status: "inactive"
-      }, sb, makeAuth());
-      expect(result.status).toBe(200);
-    });
-  });
-  describe("POST /channels/:id/messages", () => {
-    it("ingests an inbound message", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "phone-123",
-        content: "Hello!",
-        content_type: "text"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(201);
-      expect(result.body.success).toBe(true);
-    });
-    it("returns 400 when body is missing", async () => {
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", null, sb, makeNodeAuth());
-      expect(result.status).toBe(400);
-    });
-    it("returns 401 for invalid node API key", async () => {
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "x",
-        content: "hi"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(401);
-    });
-    it("allows service role access", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "admin",
-        content: "test"
-      }, sb, {
-        userId: undefined,
-        isServiceRole: true,
-        rawToken: "service-key"
-      });
-      expect(result.status).toBe(201);
-    });
-    it("returns 404 when channel not found", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "x",
-        content: "hi"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(404);
-    });
-    it("returns 429 when message plan limit exceeded", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      checkPlanLimits.mockResolvedValueOnce({
-        allowed: false,
-        reason: "Monthly message limit reached"
-      });
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        direction: "inbound",
-        sender_id: "x",
-        content: "hi"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(429);
-      expect(result.body.error).toContain("limit reached");
-    });
-    it("defaults direction to inbound", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        sender_id: "phone-123",
-        content: "Hello"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(201);
-    });
-    it("defaults sender_id to 'unknown'", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "POST", {
-        content: "Hello"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(201);
-    });
-  });
-  describe("GET /channels/:id/messages", () => {
-    it("retrieves messages for a channel", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      await seedTracked("channel_messages", [{
-        id: "d0d0d0d0-0001-0001-0001-000000000001",
-        store_id: TEST_STORE,
-        channel_id: CHANNEL_ID,
-        direction: "inbound",
-        sender_id: "x",
-        content: "hi",
-        created_at: "2026-01-01"
-      }]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(Array.isArray(result.body.messages)).toBe(true);
-    });
-    it("returns 401 for invalid node key", async () => {
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth());
-      expect(result.status).toBe(401);
-    });
-    it("returns 404 when channel not found", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth());
-      expect(result.status).toBe(404);
-    });
-    it("filters by direction via query params", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth(), new URLSearchParams({
-        direction: "outbound"
-      }));
-      expect(result.status).toBe(200);
-    });
-    it("filters undelivered outbound messages", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages`, "GET", null, sb, makeNodeAuth(), new URLSearchParams({
-        undelivered: "true"
-      }));
-      expect(result.status).toBe(200);
-    });
-  });
-  describe("PATCH /channels/:id/messages/:msgId", () => {
-    it("marks message as delivered", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const msgId = "c0c0c0c0-0001-0001-0001-000000000001";
-      await seedTracked("channel_messages", [{
-        id: msgId,
-        store_id: TEST_STORE,
-        channel_id: CHANNEL_ID,
-        direction: "outbound",
-        sender_id: "bot",
-        content: "msg",
-        delivered_at: null
-      }]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages/${msgId}`, "POST", {
-        _method: "PATCH"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(result.body.delivered).toBe(msgId);
-    });
-    it("returns 401 for invalid node key", async () => {
-      const msgId = "c0c0c0c0-0001-0001-0001-000000000002";
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages/${msgId}`, "POST", {
-        _method: "PATCH"
-      }, sb, makeNodeAuth());
-      expect(result.status).toBe(401);
-    });
-  });
-  describe("POST /channels/:id/messages/:msgId/delivered", () => {
-    it("marks message as delivered via simple endpoint", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("channels", [makeChannel()]);
-      const msgId = "c0c0c0c0-0001-0001-0001-000000000003";
-      await seedTracked("channel_messages", [{
-        id: msgId,
-        store_id: TEST_STORE,
-        channel_id: CHANNEL_ID,
-        direction: "outbound",
-        sender_id: "bot",
-        content: "msg",
-        delivered_at: null
-      }]);
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages/${msgId}/delivered`, "POST", null, sb, makeNodeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(result.body.delivered).toBe(msgId);
-    });
-    it("returns 401 for invalid node key", async () => {
-      const msgId = "c0c0c0c0-0001-0001-0001-000000000004";
-      const result = await handleNodeRoutes(`/channels/${CHANNEL_ID}/messages/${msgId}/delivered`, "POST", null, sb, makeNodeAuth());
-      expect(result.status).toBe(401);
-    });
-  });
-});

package/dist/server/handlers/nodes-events.test.js

@@ -1,131 +0,0 @@
-// nodes-events.test.ts — Tests for handleNodeRoutes GET /nodes/:id/events
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE, RUN_PREFIX } from "./__test-utils__/test-db.js";
-// ---------------------------------------------------------------------------
-// Mock dependencies
-// ---------------------------------------------------------------------------
-
-vi.mock("./billing.js", () => ({
-  checkPlanLimits: vi.fn().mockResolvedValue({
-    allowed: true
-  }),
-  incrementUsage: vi.fn().mockResolvedValue(undefined)
-}));
-vi.mock("node:crypto", async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    createHash: vi.fn().mockReturnValue({
-      update: vi.fn().mockReturnValue({
-        digest: vi.fn().mockReturnValue("mocked-hash-abc123")
-      })
-    }),
-    randomBytes: vi.fn().mockReturnValue({
-      toString: vi.fn().mockReturnValue("mocked-api-key-hex-string-64chars-long-enough-for-testing-12345678")
-    }),
-    randomUUID: vi.fn().mockReturnValue("a0a0a0a0-0001-0002-0003-000000000001")
-  };
-});
-import { handleNodeRoutes, clearNodeAuthCache } from "./nodes.js";
-const sb = getTestClient();
-const USER_ID = "562fd6cb-ef83-4eca-b999-ffeac2293ee7";
-const NODE_ID = "a0a0a0a0-0001-0002-0003-000000000001";
-const CHANNEL_ID = "b0b0b0b0-0001-0002-0003-000000000001";
-
-// ---------------------------------------------------------------------------
-// Test data helpers
-// ---------------------------------------------------------------------------
-
-function makeNode(overrides = {}) {
-  return {
-    id: NODE_ID,
-    store_id: TEST_STORE,
-    name: `${RUN_PREFIX} Test Node`,
-    api_key_hash: "mocked-hash-abc123",
-    status: "online",
-    capabilities: ["chat", "voice"],
-    hardware: {
-      cpu: "arm64"
-    },
-    version: "1.0.0",
-    ip_address: null,
-    last_heartbeat: "2026-01-01T00:00:00Z",
-    created_at: "2026-01-01T00:00:00Z",
-    ...overrides
-  };
-}
-function makeAuth(overrides = {}) {
-  return {
-    userId: USER_ID,
-    isServiceRole: false,
-    rawToken: "user-jwt-token",
-    ...overrides
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests — Node events
-// ---------------------------------------------------------------------------
-
-describe.skipIf(!HAS_TEST_DB)("handleNodeRoutes — node events", () => {
-  beforeEach(async () => {
-    vi.restoreAllMocks();
-    vi.clearAllMocks();
-    clearNodeAuthCache();
-    await sb.from("channel_messages").delete().eq("channel_id", CHANNEL_ID).then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-    const {
-      data: storeRow
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (storeRow?.owner_user_id) {
-      await sb.from("platform_users").update({
-        auth_id: USER_ID
-      }).eq("id", storeRow.owner_user_id);
-    }
-  });
-  afterEach(async () => {
-    vi.restoreAllMocks();
-    await cleanup();
-    await sb.from("channel_messages").delete().eq("channel_id", CHANNEL_ID).then(() => {});
-    await sb.from("channels").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("node_events").delete().eq("node_id", NODE_ID).then(() => {});
-    await sb.from("nodes").delete().eq("store_id", TEST_STORE).then(() => {});
-    await sb.from("store_plans").delete().eq("store_id", TEST_STORE).then(() => {});
-    const {
-      data: storeRow
-    } = await sb.from("stores").select("owner_user_id").eq("id", TEST_STORE).single();
-    if (storeRow?.owner_user_id) {
-      await sb.from("platform_users").update({
-        auth_id: null
-      }).eq("id", storeRow.owner_user_id);
-    }
-  });
-  describe("GET /nodes/:id/events", () => {
-    it("returns events for a node", async () => {
-      await seedTracked("nodes", [makeNode()]);
-      await seedTracked("node_events", [{
-        id: "e0e0e0e0-0001-0001-0001-000000000001",
-        store_id: TEST_STORE,
-        node_id: NODE_ID,
-        event_type: "registered",
-        details: {},
-        created_at: "2026-01-01"
-      }, {
-        id: "e0e0e0e0-0001-0001-0001-000000000002",
-        store_id: TEST_STORE,
-        node_id: NODE_ID,
-        event_type: "heartbeat",
-        details: {},
-        created_at: "2026-01-02"
-      }]);
-      const result = await handleNodeRoutes(`/nodes/${NODE_ID}/events`, "GET", null, sb, makeAuth());
-      expect(result.status).toBe(200);
-      expect(result.body.success).toBe(true);
-      expect(Array.isArray(result.body.events)).toBe(true);
-    });
-  });
-});