whale-code 6.5.11 → 6.6.0

package/dist/server/handlers/__tests__/e2e/email-pipeline-send.e2e.test.js

@@ -1,214 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { randomUUID } from "node:crypto";
-import { HAS_TEST_DB, RUN_PREFIX } from "../../__test-utils__/test-db.js";
-
-// ============================================================================
-// In-memory stores for email pipeline
-// ============================================================================
-
-let emailRecords = [];
-let emailThreads = [];
-let emailSettings = [];
-const mockResendApi = {
-  send: vi.fn()
-};
-
-// ============================================================================
-// Email Pipeline Helpers
-// ============================================================================
-
-function detectThread(recipient, subject, storeId) {
-  const baseSubject = subject.replace(/^(Re:|Fwd:)\s*/gi, "").trim();
-  const thread = emailThreads.find(t => t.store_id === storeId && t.recipient === recipient && t.base_subject === baseSubject);
-  return thread ? thread.id : null;
-}
-function sendEmail(params) {
-  const storeSettings = emailSettings.find(s => s.store_id === params.store_id) ?? {};
-  const isTestMode = storeSettings.test_mode === true;
-  const testRedirectAddress = storeSettings.test_redirect_email;
-  const effectiveTo = isTestMode && testRedirectAddress ? testRedirectAddress : params.to;
-  const providerId = `msg_${RUN_PREFIX}_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-  mockResendApi.send.mockReturnValueOnce({
-    id: providerId,
-    status: "sent"
-  });
-  mockResendApi.send({
-    from: params.from_address,
-    to: effectiveTo,
-    subject: params.subject,
-    html: params.html_body
-  });
-  const baseSubject = params.subject.replace(/^(Re:|Fwd:)\s*/gi, "").trim();
-  let threadId = detectThread(params.to, params.subject, params.store_id);
-  if (!threadId) {
-    threadId = randomUUID();
-    emailThreads.push({
-      id: threadId,
-      store_id: params.store_id,
-      recipient: params.to,
-      base_subject: baseSubject,
-      message_count: 0
-    });
-  }
-  const thread = emailThreads.find(t => t.id === threadId);
-  if (thread) {
-    thread.message_count += 1;
-  }
-  const emailId = randomUUID();
-  emailRecords.push({
-    id: emailId,
-    store_id: params.store_id,
-    recipient: params.to,
-    effective_recipient: effectiveTo,
-    from_address: params.from_address,
-    subject: params.subject,
-    status: "sent",
-    provider_id: providerId,
-    thread_id: threadId,
-    tags: params.tags ? JSON.stringify(params.tags) : null,
-    is_test_mode: isTestMode
-  });
-  return {
-    emailId,
-    providerId
-  };
-}
-function processResendWebhook(event) {
-  const statusMap = {
-    "email.delivered": "delivered",
-    "email.bounced": "bounced",
-    "email.complained": "complained"
-  };
-  const newStatus = statusMap[event.type];
-  if (!newStatus) {
-    return {
-      updated: false
-    };
-  }
-  const record = emailRecords.find(r => r.provider_id === event.data.email_id);
-  if (!record) {
-    return {
-      updated: false
-    };
-  }
-  record.status = newStatus;
-  record.status_updated_at = event.data.created_at;
-  if (event.type === "email.bounced") {
-    record.bounce_type = event.data.bounce_type ?? "hard";
-  }
-  return {
-    updated: true
-  };
-}
-
-// ============================================================================
-// E2E Tests: Email Pipeline — send & webhooks
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("Email Pipeline E2E — send & webhooks", () => {
-  const emailStoreId = `${RUN_PREFIX}_store_email`;
-  beforeEach(() => {
-    vi.clearAllMocks();
-    emailRecords = [];
-    emailThreads = [];
-    emailSettings = [];
-    emailSettings.push({
-      id: randomUUID(),
-      store_id: emailStoreId,
-      test_mode: false,
-      test_redirect_email: "dev@internal.example.com",
-      domain: "mail.example.com",
-      from_name: "Test Store",
-      from_email: "noreply@mail.example.com"
-    });
-  });
-  afterEach(() => {});
-  it("sends an email via edge function and creates email_records entry", () => {
-    const {
-      emailId,
-      providerId
-    } = sendEmail({
-      to: `${RUN_PREFIX}_customer@example.com`,
-      subject: `${RUN_PREFIX}_Your order is ready`,
-      html_body: "<p>Order #123 is ready for pickup.</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    expect(emailId).toBeDefined();
-    expect(providerId).toBeDefined();
-    expect(mockResendApi.send).toHaveBeenCalledWith(expect.objectContaining({
-      to: `${RUN_PREFIX}_customer@example.com`,
-      subject: `${RUN_PREFIX}_Your order is ready`
-    }));
-    const records = emailRecords.filter(r => r.id === emailId);
-    expect(records).toHaveLength(1);
-    expect(records[0].status).toBe("sent");
-    expect(records[0].recipient).toBe(`${RUN_PREFIX}_customer@example.com`);
-    expect(records[0].provider_id).toBe(providerId);
-  });
-  it("updates status to delivered when Resend webhook fires", () => {
-    const {
-      providerId
-    } = sendEmail({
-      to: `${RUN_PREFIX}_user@example.com`,
-      subject: `${RUN_PREFIX}_Welcome`,
-      html_body: "<p>Welcome!</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    const result = processResendWebhook({
-      type: "email.delivered",
-      data: {
-        email_id: providerId,
-        to: `${RUN_PREFIX}_user@example.com`,
-        created_at: new Date().toISOString()
-      }
-    });
-    expect(result.updated).toBe(true);
-    const records = emailRecords.filter(r => r.provider_id === providerId);
-    expect(records[0].status).toBe("delivered");
-    expect(records[0].status_updated_at).toBeDefined();
-  });
-  it("handles bounce and complaint webhooks correctly", () => {
-    const {
-      providerId: bouncedId
-    } = sendEmail({
-      to: `${RUN_PREFIX}_invalid@example.com`,
-      subject: `${RUN_PREFIX}_Test bounce`,
-      html_body: "<p>Test</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    const {
-      providerId: complainedId
-    } = sendEmail({
-      to: `${RUN_PREFIX}_annoyed@example.com`,
-      subject: `${RUN_PREFIX}_Test complaint`,
-      html_body: "<p>Spam?</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    processResendWebhook({
-      type: "email.bounced",
-      data: {
-        email_id: bouncedId,
-        to: `${RUN_PREFIX}_invalid@example.com`,
-        created_at: new Date().toISOString(),
-        bounce_type: "hard"
-      }
-    });
-    processResendWebhook({
-      type: "email.complained",
-      data: {
-        email_id: complainedId,
-        to: `${RUN_PREFIX}_annoyed@example.com`,
-        created_at: new Date().toISOString()
-      }
-    });
-    const bouncedRecord = emailRecords.find(r => r.provider_id === bouncedId);
-    expect(bouncedRecord.status).toBe("bounced");
-    expect(bouncedRecord.bounce_type).toBe("hard");
-    const complainedRecord = emailRecords.find(r => r.provider_id === complainedId);
-    expect(complainedRecord.status).toBe("complained");
-  });
-});

package/dist/server/handlers/__tests__/e2e/email-pipeline-threads.e2e.test.js

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { randomUUID } from "node:crypto";
-import { HAS_TEST_DB, RUN_PREFIX } from "../../__test-utils__/test-db.js";
-
-// ============================================================================
-// In-memory stores for email pipeline
-// ============================================================================
-
-let emailRecords = [];
-let emailThreads = [];
-let emailSettings = [];
-const mockResendApi = {
-  send: vi.fn()
-};
-
-// ============================================================================
-// Email Pipeline Helpers
-// ============================================================================
-
-function detectThread(recipient, subject, storeId) {
-  const baseSubject = subject.replace(/^(Re:|Fwd:)\s*/gi, "").trim();
-  const thread = emailThreads.find(t => t.store_id === storeId && t.recipient === recipient && t.base_subject === baseSubject);
-  return thread ? thread.id : null;
-}
-function sendEmail(params) {
-  const storeSettings = emailSettings.find(s => s.store_id === params.store_id) ?? {};
-  const isTestMode = storeSettings.test_mode === true;
-  const testRedirectAddress = storeSettings.test_redirect_email;
-  const effectiveTo = isTestMode && testRedirectAddress ? testRedirectAddress : params.to;
-  const providerId = `msg_${RUN_PREFIX}_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-  mockResendApi.send.mockReturnValueOnce({
-    id: providerId,
-    status: "sent"
-  });
-  mockResendApi.send({
-    from: params.from_address,
-    to: effectiveTo,
-    subject: params.subject,
-    html: params.html_body
-  });
-  const baseSubject = params.subject.replace(/^(Re:|Fwd:)\s*/gi, "").trim();
-  let threadId = detectThread(params.to, params.subject, params.store_id);
-  if (!threadId) {
-    threadId = randomUUID();
-    emailThreads.push({
-      id: threadId,
-      store_id: params.store_id,
-      recipient: params.to,
-      base_subject: baseSubject,
-      message_count: 0
-    });
-  }
-  const thread = emailThreads.find(t => t.id === threadId);
-  if (thread) {
-    thread.message_count += 1;
-  }
-  const emailId = randomUUID();
-  emailRecords.push({
-    id: emailId,
-    store_id: params.store_id,
-    recipient: params.to,
-    effective_recipient: effectiveTo,
-    from_address: params.from_address,
-    subject: params.subject,
-    status: "sent",
-    provider_id: providerId,
-    thread_id: threadId,
-    tags: params.tags ? JSON.stringify(params.tags) : null,
-    is_test_mode: isTestMode
-  });
-  return {
-    emailId,
-    providerId
-  };
-}
-
-// ============================================================================
-// E2E Tests: Email Pipeline — test mode & threading
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("Email Pipeline E2E — test mode & threads", () => {
-  const emailStoreId = `${RUN_PREFIX}_store_email`;
-  beforeEach(() => {
-    vi.clearAllMocks();
-    emailRecords = [];
-    emailThreads = [];
-    emailSettings = [];
-    emailSettings.push({
-      id: randomUUID(),
-      store_id: emailStoreId,
-      test_mode: false,
-      test_redirect_email: "dev@internal.example.com",
-      domain: "mail.example.com",
-      from_name: "Test Store",
-      from_email: "noreply@mail.example.com"
-    });
-  });
-  afterEach(() => {});
-  it("redirects emails to test address when test mode is enabled", () => {
-    const settings = emailSettings.find(s => s.store_id === emailStoreId);
-    if (settings) settings.test_mode = true;
-    const {
-      emailId
-    } = sendEmail({
-      to: `${RUN_PREFIX}_real-customer@example.com`,
-      subject: `${RUN_PREFIX}_Order confirmation`,
-      html_body: "<p>Your order is confirmed.</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    expect(mockResendApi.send).toHaveBeenCalledWith(expect.objectContaining({
-      to: "dev@internal.example.com"
-    }));
-    const record = emailRecords.find(r => r.id === emailId);
-    expect(record.recipient).toBe(`${RUN_PREFIX}_real-customer@example.com`);
-    expect(record.effective_recipient).toBe("dev@internal.example.com");
-    expect(record.is_test_mode).toBe(true);
-  });
-  it("detects email threads by base subject and recipient", () => {
-    const recipient = `${RUN_PREFIX}_support@customer.com`;
-    const {
-      emailId: firstId
-    } = sendEmail({
-      to: recipient,
-      subject: `${RUN_PREFIX}_Order question`,
-      html_body: "<p>I have a question about my order.</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    const {
-      emailId: replyId
-    } = sendEmail({
-      to: recipient,
-      subject: `Re: ${RUN_PREFIX}_Order question`,
-      html_body: "<p>Thanks for your response.</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    const firstRecord = emailRecords.find(r => r.id === firstId);
-    const replyRecord = emailRecords.find(r => r.id === replyId);
-    expect(firstRecord.thread_id).toBe(replyRecord.thread_id);
-    const thread = emailThreads.find(t => t.id === firstRecord.thread_id);
-    expect(thread.message_count).toBe(2);
-    expect(thread.base_subject).toBe(`${RUN_PREFIX}_Order question`);
-  });
-  it("creates separate threads for different recipients with same subject", () => {
-    const aliceEmail = `${RUN_PREFIX}_alice@example.com`;
-    const bobEmail = `${RUN_PREFIX}_bob@example.com`;
-    const subject = `${RUN_PREFIX}_Welcome`;
-    sendEmail({
-      to: aliceEmail,
-      subject,
-      html_body: "<p>Welcome Alice!</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    sendEmail({
-      to: bobEmail,
-      subject,
-      html_body: "<p>Welcome Bob!</p>",
-      store_id: emailStoreId,
-      from_address: "noreply@mail.example.com"
-    });
-    const threads = emailThreads.filter(t => t.store_id === emailStoreId && t.base_subject === `${RUN_PREFIX}_Welcome`);
-    expect(threads).toHaveLength(2);
-    expect(threads[0].recipient).not.toBe(threads[1].recipient);
-  });
-});

package/dist/server/handlers/__tests__/e2e/error-logging-pipeline-dedup.e2e.test.js

@@ -1,229 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { randomUUID } from "node:crypto";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, TEST_STORE, RUN_PREFIX } from "../../__test-utils__/test-db.js";
-
-// ============================================================================
-// Real Supabase client
-// ============================================================================
-
-const sb = getTestClient();
-
-// ============================================================================
-// Error Logging Helpers — real DB with correct schema
-// ============================================================================
-
-function generateFingerprint(message, source, stackTop) {
-  const raw = `${message}|${source}|${stackTop}`;
-  let hash = 0;
-  for (let i = 0; i < raw.length; i++) {
-    const chr = raw.charCodeAt(i);
-    hash = (hash << 5) - hash + chr;
-    hash |= 0;
-  }
-  return `fp_${RUN_PREFIX}_${Math.abs(hash).toString(16).padStart(8, "0")}`;
-}
-
-/**
- * In-memory rate-limit tracker per test run.
- */
-const rateBuckets = new Map();
-function resetRateBuckets() {
-  rateBuckets.clear();
-}
-async function logError(error) {
-  const stackLines = error.stack.split("\n");
-  const stackTop = stackLines[0] ?? "";
-  const fingerprint = generateFingerprint(error.message, error.source, stackTop);
-
-  // Rate limiting check (in-memory)
-  const bucketKey = `${error.store_id}:${fingerprint}`;
-  const bucket = rateBuckets.get(bucketKey);
-  const now = Date.now();
-  const windowMs = 60000;
-  if (bucket) {
-    if (now - bucket.windowStart < windowMs && bucket.count >= 10) {
-      return {
-        eventId: null,
-        deduplicated: true
-      };
-    }
-    if (now - bucket.windowStart >= windowMs) {
-      rateBuckets.set(bucketKey, {
-        count: 1,
-        windowStart: now
-      });
-    } else {
-      bucket.count += 1;
-    }
-  } else {
-    rateBuckets.set(bucketKey, {
-      count: 1,
-      windowStart: now
-    });
-  }
-
-  // Create error event in real DB (using correct column names)
-  const eventId = randomUUID();
-  await seedTracked("error_events", [{
-    id: eventId,
-    fingerprint,
-    error_type: "runtime",
-    error_message: error.message,
-    source_file: error.source,
-    stack_trace: error.stack,
-    platform: "typescript",
-    environment: "production",
-    service_name: error.service_name,
-    severity: error.severity,
-    store_id: error.store_id === TEST_STORE ? error.store_id : null,
-    extra: error.metadata ?? {},
-    tags: {
-      test_store_id: error.store_id
-    }
-  }]);
-
-  // Auto-aggregate into error_groups (in-memory tracking since error_groups
-  // uses fingerprint as PK and has array columns store_ids, platforms, services)
-  inMemoryErrorGroups_aggregate(fingerprint, error);
-  return {
-    eventId,
-    deduplicated: false
-  };
-}
-
-// ============================================================================
-// In-memory error group aggregation
-// ============================================================================
-
-let inMemoryErrorGroups = [];
-function inMemoryErrorGroups_aggregate(fingerprint, error) {
-  const existing = inMemoryErrorGroups.find(g => g.fingerprint === fingerprint && g.store_id === error.store_id);
-  if (existing) {
-    existing.event_count += 1;
-    existing.last_seen = new Date().toISOString();
-  } else {
-    inMemoryErrorGroups.push({
-      fingerprint,
-      error_message: error.message,
-      source: error.source,
-      store_id: error.store_id,
-      severity: error.severity,
-      event_count: 1,
-      first_seen: new Date().toISOString(),
-      last_seen: new Date().toISOString(),
-      status: "open"
-    });
-  }
-}
-
-// ============================================================================
-// E2E Tests: Error Logging Pipeline — dedup, summary, rate-limiting
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("Error Logging Pipeline E2E — dedup & rate-limiting", () => {
-  const storeA = `${RUN_PREFIX}_store_err_a`;
-  const storeB = `${RUN_PREFIX}_store_err_b`;
-  const storeC = `${RUN_PREFIX}_store_err_c`;
-  beforeEach(() => {
-    resetRateBuckets();
-    inMemoryErrorGroups = [];
-  });
-  afterEach(async () => {
-    await cleanup();
-  });
-  it("generates different fingerprints for different errors", async () => {
-    const err1 = await logError({
-      message: `${RUN_PREFIX}_Error A`,
-      stack: "at funcA (a.ts:1)",
-      source: "service-a",
-      store_id: storeA,
-      service_name: "WhalePos",
-      severity: "error"
-    });
-    const err2 = await logError({
-      message: `${RUN_PREFIX}_Error B`,
-      stack: "at funcB (b.ts:2)",
-      source: "service-b",
-      store_id: storeA,
-      service_name: "WhalePos",
-      severity: "error"
-    });
-    const {
-      data: event1
-    } = await sb.from("error_events").select().eq("id", err1.eventId);
-    const {
-      data: event2
-    } = await sb.from("error_events").select().eq("id", err2.eventId);
-    expect(event1[0].fingerprint).not.toBe(event2[0].fingerprint);
-  });
-  it("returns error summary data queried from in-memory groups", async () => {
-    await logError({
-      message: `${RUN_PREFIX}_Auth failed`,
-      stack: "at auth (auth.ts:5)",
-      source: "auth-service",
-      store_id: storeB,
-      service_name: "WhaleDash",
-      severity: "warning"
-    });
-    await logError({
-      message: `${RUN_PREFIX}_Auth failed`,
-      stack: "at auth (auth.ts:5)",
-      source: "auth-service",
-      store_id: storeB,
-      service_name: "WhaleDash",
-      severity: "warning"
-    });
-    await logError({
-      message: `${RUN_PREFIX}_Payment declined`,
-      stack: "at charge (stripe.ts:88)",
-      source: "payment-service",
-      store_id: storeB,
-      service_name: "WhaleDash",
-      severity: "error"
-    });
-
-    // Query in-memory error groups
-    const data = inMemoryErrorGroups.filter(g => g.store_id === storeB);
-    expect(data).toHaveLength(2);
-    const authGroup = data.find(g => g.error_message === `${RUN_PREFIX}_Auth failed`);
-    expect(authGroup).toBeDefined();
-    expect(authGroup.event_count).toBe(2);
-    const paymentGroup = data.find(g => g.error_message === `${RUN_PREFIX}_Payment declined`);
-    expect(paymentGroup).toBeDefined();
-    expect(paymentGroup.event_count).toBe(1);
-  });
-  it("rate-limits duplicate errors within the same time window", async () => {
-    const sameError = {
-      message: `${RUN_PREFIX}_Rate limit test error`,
-      stack: "at rateTest (test.ts:1)",
-      source: "test-service",
-      store_id: storeC,
-      service_name: "WhaleTest",
-      severity: "error"
-    };
-
-    // Log 10 errors (should all succeed)
-    for (let i = 0; i < 10; i++) {
-      const result = await logError(sameError);
-      expect(result.deduplicated).toBe(false);
-      expect(result.eventId).toBeDefined();
-    }
-
-    // 11th error should be deduplicated
-    const result11 = await logError(sameError);
-    expect(result11.deduplicated).toBe(true);
-    expect(result11.eventId).toBeNull();
-
-    // Verify only 10 events were recorded in real DB
-    const fingerprint = generateFingerprint(sameError.message, sameError.source, sameError.stack.split("\n")[0]);
-    const {
-      data: events
-    } = await sb.from("error_events").select().eq("fingerprint", fingerprint);
-    expect(events).toHaveLength(10);
-
-    // In-memory error group count should be 10 (not 11)
-    const groups = inMemoryErrorGroups.filter(g => g.store_id === storeC);
-    expect(groups).toHaveLength(1);
-    expect(groups[0].event_count).toBe(10);
-  });
-});