whale-code 6.5.10 → 6.6.0

package/dist/node/adapters/__tests__/webchat-outbound.test.js

@@ -1,178 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import http from "node:http";
-import { WebchatAdapter } from "../webchat.js";
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function request(port, method, path, body, headers) {
-  return new Promise((resolve, reject) => {
-    const req = http.request({
-      hostname: "127.0.0.1",
-      port,
-      method,
-      path,
-      headers: {
-        "Content-Type": "application/json",
-        ...headers
-      }
-    }, res => {
-      let data = "";
-      res.on("data", chunk => data += chunk);
-      res.on("end", () => resolve({
-        status: res.statusCode || 500,
-        body: data,
-        headers: res.headers
-      }));
-    });
-    req.on("error", reject);
-    if (body) req.write(body);
-    req.end();
-  });
-}
-let testPort;
-let adapter;
-beforeEach(async () => {
-  testPort = 30000 + Math.floor(Math.random() * 30000);
-  adapter = new WebchatAdapter("test-webchat", {
-    port: testPort
-  });
-  await adapter.start();
-  for (let i = 0; i < 20; i++) {
-    try {
-      await request(testPort, "GET", "/health");
-      break;
-    } catch {
-      await new Promise(r => setTimeout(r, 50));
-    }
-  }
-});
-afterEach(async () => {
-  await adapter.stop();
-  await new Promise(r => setTimeout(r, 50));
-});
-
-// ============================================================================
-// sendMessage + GET /messages (outbound queue)
-// ============================================================================
-
-describe("WebchatAdapter — sendMessage + message polling", () => {
-  it("queues outbound messages for polling", async () => {
-    const msg = {
-      id: "out-1",
-      content: "Bot response",
-      sender_id: "bot",
-      metadata: {
-        session_id: "sess-123"
-      }
-    };
-    const result = await adapter.sendMessage(msg);
-    expect(result).toBe(true);
-    expect(adapter.getStats().messages_out).toBe(1);
-    const res = await request(testPort, "GET", "/messages?session_id=sess-123");
-    expect(res.status).toBe(200);
-    const data = JSON.parse(res.body);
-    expect(data.messages).toHaveLength(1);
-    expect(data.messages[0].content).toBe("Bot response");
-  });
-  it("clears queue after polling", async () => {
-    await adapter.sendMessage({
-      id: "out-1",
-      content: "Response",
-      sender_id: "bot",
-      metadata: {
-        session_id: "sess-456"
-      }
-    });
-    await request(testPort, "GET", "/messages?session_id=sess-456");
-    const res = await request(testPort, "GET", "/messages?session_id=sess-456");
-    const data = JSON.parse(res.body);
-    expect(data.messages).toHaveLength(0);
-  });
-  it("returns empty array for unknown session", async () => {
-    const res = await request(testPort, "GET", "/messages?session_id=unknown");
-    const data = JSON.parse(res.body);
-    expect(data.messages).toHaveLength(0);
-  });
-  it("requires session_id for polling", async () => {
-    const res = await request(testPort, "GET", "/messages");
-    expect(res.status).toBe(400);
-    const data = JSON.parse(res.body);
-    expect(data.error).toContain("session_id required");
-  });
-  it("uses conversation_id as fallback session", async () => {
-    await adapter.sendMessage({
-      id: "out-1",
-      content: "Fallback",
-      sender_id: "bot",
-      conversation_id: "conv-789"
-    });
-    const res = await request(testPort, "GET", "/messages?session_id=conv-789");
-    const data = JSON.parse(res.body);
-    expect(data.messages).toHaveLength(1);
-  });
-});
-
-// ============================================================================
-// 404 for unknown routes
-// ============================================================================
-
-describe("WebchatAdapter — unknown routes", () => {
-  it("returns 404 for unknown routes", async () => {
-    const res = await request(testPort, "GET", "/unknown");
-    expect(res.status).toBe(404);
-  });
-  it("returns 404 for POST to unknown path", async () => {
-    const res = await request(testPort, "POST", "/unknown");
-    expect(res.status).toBe(404);
-  });
-});
-
-// ============================================================================
-// stop
-// ============================================================================
-
-describe("WebchatAdapter — stop", () => {
-  it("sets running to false after stop", async () => {
-    await adapter.stop();
-    expect(adapter.isRunning()).toBe(false);
-  });
-  it("does not start if already running", async () => {
-    await adapter.start();
-    expect(adapter.isRunning()).toBe(true);
-  });
-});
-
-// ============================================================================
-// Configuration
-// ============================================================================
-
-describe("WebchatAdapter — configuration", () => {
-  it("uses default port 3100 when not specified", () => {
-    const a = new WebchatAdapter("default-port");
-    expect(a.type).toBe("webchat");
-  });
-  it("accepts custom allowed_origins", () => {
-    const a = new WebchatAdapter("cors-test", {
-      allowed_origins: ["https://mysite.com"]
-    });
-    expect(a.type).toBe("webchat");
-  });
-  it("accepts custom max_message_length", async () => {
-    const customAdapter = new WebchatAdapter("custom-len", {
-      port: testPort + 1,
-      max_message_length: 100
-    });
-    await customAdapter.start();
-    await new Promise(r => setTimeout(r, 100));
-    const handler = vi.fn(async _msg => {});
-    customAdapter.setMessageHandler(handler);
-    await request(testPort + 1, "POST", "/message", JSON.stringify({
-      content: "x".repeat(200),
-      session_id: "s1"
-    }));
-    const receivedContent = handler.mock.calls[0][0].content;
-    expect(receivedContent.length).toBe(100);
-    await customAdapter.stop();
-  });
-});

package/dist/node/adapters/__tests__/whatsapp-inbound.test.js

@@ -1,200 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { EventEmitter } from "node:events";
-
-// ---------------------------------------------------------------------------
-// Mock node:http — we never want a real server
-// ---------------------------------------------------------------------------
-const {
-  mockCreateServer,
-  mockServer
-} = vi.hoisted(() => {
-  const {
-    EventEmitter
-  } = require("node:events");
-  const mockServer = Object.assign(new EventEmitter(), {
-    listen: vi.fn((_port, cb) => {
-      cb?.();
-    }),
-    close: vi.fn(cb => {
-      cb?.();
-    }),
-    address: vi.fn(() => ({
-      port: 3100
-    }))
-  });
-  const mockCreateServer = vi.fn(() => mockServer);
-  return {
-    mockCreateServer,
-    mockServer
-  };
-});
-vi.mock("node:http", () => ({
-  createServer: mockCreateServer
-}));
-
-// Mock global fetch
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-import { WhatsAppAdapter } from "../whatsapp.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function defaultConfig(overrides = {}) {
-  return {
-    phone_number_id: "123456789",
-    access_token: "test-access-token",
-    verify_token: "test-verify-token",
-    webhook_port: 3100,
-    ...overrides
-  };
-}
-function buildWebhookPayload(fromNumber, text, contactName) {
-  return JSON.stringify({
-    entry: [{
-      changes: [{
-        field: "messages",
-        value: {
-          metadata: {
-            phone_number_id: "123456789"
-          },
-          contacts: contactName ? [{
-            wa_id: fromNumber,
-            profile: {
-              name: contactName
-            }
-          }] : [],
-          messages: [{
-            id: "wamid.test123",
-            from: fromNumber,
-            timestamp: "1700000000",
-            type: "text",
-            text: {
-              body: text
-            }
-          }]
-        }
-      }]
-    }]
-  });
-}
-class FakeResponse {
-  statusCode = 200;
-  headers = {};
-  body = "";
-  writeHead(code, headers) {
-    this.statusCode = code;
-    if (headers) this.headers = headers;
-  }
-  end(data) {
-    if (data) this.body = data;
-  }
-}
-function simulateRequest(method, url, body, headers) {
-  const handler = mockCreateServer.mock.calls.at(-1)?.[0];
-  if (!handler) throw new Error("createServer handler not registered");
-  const req = new EventEmitter();
-  req.method = method;
-  req.url = url;
-  req.headers = headers || {};
-  const res = new FakeResponse();
-  handler(req, res);
-  if (body !== undefined) {
-    req.emit("data", Buffer.from(body));
-    req.emit("end");
-  }
-  return {
-    res
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests — inbound filtering, JSON handling, and read receipts
-// ---------------------------------------------------------------------------
-describe("WhatsAppAdapter — inbound filtering & processing", () => {
-  let adapter;
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: async () => "",
-      json: async () => ({})
-    });
-    adapter = new WhatsAppAdapter("test-whatsapp", defaultConfig());
-  });
-  afterEach(async () => {
-    if (adapter.isRunning()) await adapter.stop();
-    vi.useRealTimers();
-  });
-
-  // ====== allowed_numbers filtering ======
-
-  describe("allowed_numbers filtering", () => {
-    it("filters by allowed_numbers when configured", async () => {
-      const a = new WhatsAppAdapter("wa-filter", defaultConfig({
-        allowed_numbers: ["+15559999999"]
-      }));
-      await a.start();
-      const handler = vi.fn().mockResolvedValue(undefined);
-      a.setMessageHandler(handler);
-      const payload = buildWebhookPayload("+15551234567", "Blocked");
-      simulateRequest("POST", "/", payload);
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler).not.toHaveBeenCalled();
-      await a.stop();
-    });
-    it("allows messages from numbers in allowed_numbers list", async () => {
-      const a = new WhatsAppAdapter("wa-allow", defaultConfig({
-        allowed_numbers: ["+15551234567"]
-      }));
-      await a.start();
-      const handler = vi.fn().mockResolvedValue(undefined);
-      a.setMessageHandler(handler);
-      const payload = buildWebhookPayload("+15551234567", "Allowed");
-      simulateRequest("POST", "/", payload);
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler).toHaveBeenCalledTimes(1);
-      await a.stop();
-    });
-  });
-
-  // ====== Invalid JSON ======
-
-  describe("invalid JSON handling", () => {
-    it("gracefully handles invalid JSON in POST body", async () => {
-      await adapter.start();
-      const handler = vi.fn().mockResolvedValue(undefined);
-      adapter.setMessageHandler(handler);
-      simulateRequest("POST", "/", "not valid json{{{");
-      await vi.advanceTimersByTimeAsync(0);
-      expect(handler).not.toHaveBeenCalled();
-    });
-  });
-
-  // ====== Mark as read ======
-
-  describe("marks message as read", () => {
-    it("marks message as read after processing", async () => {
-      await adapter.start();
-      const handler = vi.fn().mockResolvedValue(undefined);
-      adapter.setMessageHandler(handler);
-      const payload = buildWebhookPayload("+15551234567", "Hello");
-      simulateRequest("POST", "/", payload);
-      await vi.advanceTimersByTimeAsync(0);
-
-      // After processing the message, the adapter calls markAsRead via fetch
-      const markReadCalls = mockFetch.mock.calls.filter(call => {
-        try {
-          const body = JSON.parse(call[1]?.body || "{}");
-          return body.status === "read";
-        } catch {
-          return false;
-        }
-      });
-      expect(markReadCalls.length).toBe(1);
-      const readBody = JSON.parse(markReadCalls[0][1].body);
-      expect(readBody.message_id).toBe("wamid.test123");
-    });
-  });
-});

package/dist/node/adapters/__tests__/whatsapp-send.test.js

@@ -1,212 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mock node:http — we never want a real server
-// ---------------------------------------------------------------------------
-const {
-  mockCreateServer,
-  mockServer
-} = vi.hoisted(() => {
-  const {
-    EventEmitter
-  } = require("node:events");
-  const mockServer = Object.assign(new EventEmitter(), {
-    listen: vi.fn((_port, cb) => {
-      cb?.();
-    }),
-    close: vi.fn(cb => {
-      cb?.();
-    }),
-    address: vi.fn(() => ({
-      port: 3100
-    }))
-  });
-  const mockCreateServer = vi.fn(() => mockServer);
-  return {
-    mockCreateServer,
-    mockServer
-  };
-});
-vi.mock("node:http", () => ({
-  createServer: mockCreateServer
-}));
-
-// Mock global fetch
-const mockFetch = vi.fn();
-vi.stubGlobal("fetch", mockFetch);
-import { WhatsAppAdapter } from "../whatsapp.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function defaultConfig(overrides = {}) {
-  return {
-    phone_number_id: "123456789",
-    access_token: "test-access-token",
-    verify_token: "test-verify-token",
-    webhook_port: 3100,
-    ...overrides
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("WhatsAppAdapter — sendMessage & errors", () => {
-  let adapter;
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      text: async () => "",
-      json: async () => ({})
-    });
-    adapter = new WhatsAppAdapter("test-whatsapp", defaultConfig());
-  });
-  afterEach(async () => {
-    if (adapter.isRunning()) await adapter.stop();
-    vi.useRealTimers();
-  });
-
-  // ====== Unsupported methods ======
-
-  describe("unsupported HTTP methods", () => {
-    it("responds 405 for non-GET/POST requests", async () => {
-      await adapter.start();
-      const handler = mockCreateServer.mock.calls.at(-1)?.[0];
-      if (!handler) throw new Error("createServer handler not registered");
-      const {
-        EventEmitter
-      } = require("node:events");
-      const req = new EventEmitter();
-      req.method = "PUT";
-      req.url = "/";
-      req.headers = {};
-      const res = {
-        statusCode: 200,
-        headers: {},
-        body: "",
-        writeHead(code, h) {
-          this.statusCode = code;
-          if (h) this.headers = h;
-        },
-        end(d) {
-          if (d) this.body = d;
-        }
-      };
-      handler(req, res);
-      req.emit("data", Buffer.from(""));
-      req.emit("end");
-      expect(res.statusCode).toBe(405);
-    });
-  });
-
-  // ====== sendMessage ======
-
-  describe("sendMessage", () => {
-    it("sends a message via Graph API and returns true on success", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      const result = await adapter.sendMessage({
-        id: "msg-1",
-        content: "Reply text",
-        sender_id: "+15551234567",
-        metadata: {
-          from_number: "+15551234567"
-        }
-      });
-      expect(result).toBe(true);
-      expect(adapter.getStats().messages_out).toBe(1);
-      const [url, opts] = mockFetch.mock.calls[0];
-      expect(url).toContain("123456789/messages");
-      expect(opts.headers.Authorization).toBe("Bearer test-access-token");
-      const body = JSON.parse(opts.body);
-      expect(body.to).toBe("+15551234567");
-      expect(body.text.body).toBe("Reply text");
-    });
-    it("returns false when API responds non-ok", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 400,
-        text: async () => "bad request"
-      });
-      const result = await adapter.sendMessage({
-        id: "msg-2",
-        content: "Fail",
-        sender_id: "+15551234567"
-      });
-      expect(result).toBe(false);
-      expect(adapter.getStats().errors).toBe(1);
-    });
-    it("returns false on network error", async () => {
-      mockFetch.mockRejectedValueOnce(new Error("Network down"));
-      const result = await adapter.sendMessage({
-        id: "msg-3",
-        content: "Fail",
-        sender_id: "+15551234567"
-      });
-      expect(result).toBe(false);
-      expect(adapter.getStats().errors).toBe(1);
-    });
-    it("returns false when no recipient available", async () => {
-      const result = await adapter.sendMessage({
-        id: "msg-4",
-        content: "Fail",
-        sender_id: ""
-      });
-      expect(result).toBe(false);
-    });
-    it("uses sender_id as fallback when metadata.from_number is absent", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      await adapter.sendMessage({
-        id: "msg-5",
-        content: "Hello",
-        sender_id: "+15559876543"
-      });
-      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-      expect(body.to).toBe("+15559876543");
-    });
-  });
-
-  // ====== Server error / restart ======
-
-  describe("server error handling", () => {
-    it("increments error count on server error", async () => {
-      await adapter.start();
-      mockServer.emit("error", new Error("EADDRINUSE"));
-      expect(adapter.getStats().errors).toBe(1);
-    });
-    it("schedules restart after server error while running", async () => {
-      await adapter.start();
-      mockServer.emit("error", new Error("EADDRINUSE"));
-      vi.advanceTimersByTime(2000);
-      expect(mockCreateServer).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  // ====== Stats ======
-
-  describe("stats tracking", () => {
-    it("getStats returns a copy", () => {
-      const s1 = adapter.getStats();
-      const s2 = adapter.getStats();
-      expect(s1).not.toBe(s2);
-      expect(s1).toEqual(s2);
-    });
-    it("tracks last_message_at on successful send", async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true
-      });
-      await adapter.sendMessage({
-        id: "m",
-        content: "hi",
-        sender_id: "+1"
-      });
-      expect(adapter.getStats().last_message_at).toBeDefined();
-    });
-  });
-});