whale-code 6.5.6 → 6.5.8

package/dist/server/handlers/__tests__/e2e/storefront-checkout-cart.e2e.test.js

@@ -0,0 +1,255 @@
+import { describe, it, expect, vi, 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();
+
+// ============================================================================
+// Storefront API Helpers — real DB operations
+// ============================================================================
+
+async function authenticateWithApiKey(apiKey) {
+  const {
+    data,
+    error
+  } = await sb.from("api_keys").select().eq("key_hash", apiKey).limit(1);
+  if (error || !data || data.length === 0) {
+    return {
+      storeId: null,
+      error: "Invalid API key"
+    };
+  }
+  const keyRecord = data[0];
+  if (!keyRecord.is_active) {
+    return {
+      storeId: null,
+      error: "API key revoked"
+    };
+  }
+  return {
+    storeId: keyRecord.store_id,
+    error: null
+  };
+}
+async function browseProducts(storeId) {
+  const {
+    data
+  } = await sb.from("products").select().eq("store_id", storeId);
+  return (data ?? []).filter(p => p.status === "published");
+}
+async function addToCart(cartId, productId, quantity) {
+  const {
+    data: existing
+  } = await sb.from("cart_items").select().eq("cart_id", cartId).eq("product_id", productId);
+  if (existing && existing.length > 0) {
+    await sb.from("cart_items").update({
+      quantity: existing[0].quantity + quantity
+    }).eq("id", existing[0].id);
+  } else {
+    const {
+      data: prodData
+    } = await sb.from("products").select("name,cost_price").eq("id", productId).limit(1);
+    const productName = prodData?.[0]?.name ?? "Unknown Product";
+    const unitPrice = prodData?.[0]?.cost_price ?? 0;
+    await seedTracked("cart_items", [{
+      id: randomUUID(),
+      cart_id: cartId,
+      product_id: productId,
+      product_name: productName,
+      unit_price: unitPrice,
+      quantity
+    }]);
+  }
+}
+let orderCounter = 0;
+function nextOrderNumber() {
+  return `${RUN_PREFIX}-SCC-${++orderCounter}-${Date.now()}`;
+}
+async function createOrderFromCart(cartId, storeId) {
+  const {
+    data: cartItems
+  } = await sb.from("cart_items").select().eq("cart_id", cartId);
+  if (!cartItems || cartItems.length === 0) {
+    return {
+      orderId: null,
+      error: "Cart is empty"
+    };
+  }
+  let totalAmount = 0;
+  const resolvedItems = [];
+  for (const item of cartItems) {
+    const {
+      data: prodData
+    } = await sb.from("products").select().eq("id", item.product_id);
+    if (!prodData || prodData.length === 0) continue;
+    const unitPrice = prodData[0].cost_price;
+    const qty = item.quantity;
+    totalAmount += unitPrice * qty;
+    resolvedItems.push({
+      product_id: item.product_id,
+      product_name: prodData[0].name,
+      quantity: qty,
+      unit_price: unitPrice
+    });
+  }
+  const orderId = randomUUID();
+  await seedTracked("orders", [{
+    id: orderId,
+    order_number: nextOrderNumber(),
+    store_id: storeId,
+    status: "pending",
+    total_amount: totalAmount
+  }]);
+  for (const item of resolvedItems) {
+    await seedTracked("order_items", [{
+      id: randomUUID(),
+      order_id: orderId,
+      product_id: item.product_id,
+      product_name: item.product_name,
+      quantity: item.quantity,
+      unit_price: item.unit_price,
+      line_subtotal: item.unit_price * item.quantity,
+      line_total: item.unit_price * item.quantity,
+      store_id: storeId
+    }]);
+  }
+
+  // Clear the cart
+  await sb.from("cart_items").delete().eq("cart_id", cartId);
+  return {
+    orderId,
+    error: null
+  };
+}
+
+// ============================================================================
+// E2E Tests: Storefront Checkout — Auth, Browse, Cart
+// ============================================================================
+
+describe.skipIf(!HAS_TEST_DB)("Storefront Checkout E2E — cart", () => {
+  let apiKeyHash;
+  let cartId;
+  let prod1Id;
+  let prod2Id;
+  let prod3Id;
+  let apiKeyOwnerId;
+  let locationId;
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    apiKeyHash = `sk_live_${RUN_PREFIX}_${randomUUID().slice(0, 8)}`;
+    cartId = randomUUID();
+    prod1Id = randomUUID();
+    prod2Id = randomUUID();
+    prod3Id = randomUUID();
+    apiKeyOwnerId = randomUUID();
+    locationId = randomUUID();
+    await seedTracked("locations", [{
+      id: locationId,
+      store_id: TEST_STORE,
+      name: `${RUN_PREFIX}_Cart Location`,
+      slug: `${RUN_PREFIX}-cart-location`,
+      type: "retail"
+    }]);
+    await seedTracked("platform_users", [{
+      id: apiKeyOwnerId,
+      email: `${RUN_PREFIX}_cart_owner@example.com`
+    }]);
+    await seedTracked("api_keys", [{
+      id: randomUUID(),
+      key_hash: apiKeyHash,
+      store_id: TEST_STORE,
+      is_active: true,
+      owner_user_id: apiKeyOwnerId,
+      name: `${RUN_PREFIX}_Cart Key`,
+      key_prefix: apiKeyHash.slice(0, 10),
+      key_type: "live",
+      scope: ["storefront:read", "storefront:write"]
+    }]);
+    await seedTracked("products", [{
+      id: prod1Id,
+      name: `${RUN_PREFIX}_T-Shirt`,
+      cost_price: 25.00,
+      store_id: TEST_STORE,
+      status: "published"
+    }, {
+      id: prod2Id,
+      name: `${RUN_PREFIX}_Hoodie`,
+      cost_price: 55.00,
+      store_id: TEST_STORE,
+      status: "published"
+    }, {
+      id: prod3Id,
+      name: `${RUN_PREFIX}_Hat`,
+      cost_price: 15.00,
+      store_id: TEST_STORE,
+      status: "draft"
+    }]);
+    await seedTracked("carts", [{
+      id: cartId,
+      store_id: TEST_STORE,
+      location_id: locationId
+    }]);
+  });
+  afterEach(async () => {
+    await cleanup();
+  });
+  it("authenticates with a valid API key and returns the store ID", async () => {
+    const {
+      storeId,
+      error
+    } = await authenticateWithApiKey(apiKeyHash);
+    expect(error).toBeNull();
+    expect(storeId).toBe(TEST_STORE);
+  });
+  it("rejects an invalid API key", async () => {
+    const {
+      storeId,
+      error
+    } = await authenticateWithApiKey("sk_live_invalid_bogus");
+    expect(storeId).toBeNull();
+    expect(error).toBe("Invalid API key");
+  });
+  it("browses only active products for the authenticated store", async () => {
+    const products = await browseProducts(TEST_STORE);
+    const ourProducts = products.filter(p => [prod1Id, prod2Id, prod3Id].includes(p.id));
+    expect(ourProducts).toHaveLength(2);
+    expect(ourProducts.map(p => p.name)).toContain(`${RUN_PREFIX}_T-Shirt`);
+    expect(ourProducts.map(p => p.name)).toContain(`${RUN_PREFIX}_Hoodie`);
+    expect(ourProducts.map(p => p.name)).not.toContain(`${RUN_PREFIX}_Hat`);
+  });
+  it("adds products to cart and creates order with correct total", async () => {
+    await addToCart(cartId, prod1Id, 2); // 2 T-Shirts = 50.00
+    await addToCart(cartId, prod2Id, 1); // 1 Hoodie = 55.00
+
+    const {
+      data: cartItems
+    } = await sb.from("cart_items").select().eq("cart_id", cartId);
+    expect(cartItems).toHaveLength(2);
+    const {
+      orderId,
+      error
+    } = await createOrderFromCart(cartId, TEST_STORE);
+    expect(error).toBeNull();
+    expect(orderId).toBeDefined();
+    const {
+      data: orderData
+    } = await sb.from("orders").select().eq("id", orderId);
+    expect(orderData).toHaveLength(1);
+    expect(orderData[0].total_amount).toBe(105.00);
+    expect(orderData[0].status).toBe("pending");
+    const {
+      data: itemsData
+    } = await sb.from("order_items").select().eq("order_id", orderId);
+    expect(itemsData).toHaveLength(2);
+
+    // Cart should be cleared after order creation
+    const {
+      data: remainingCartItems
+    } = await sb.from("cart_items").select().eq("cart_id", cartId);
+    expect(remainingCartItems).toHaveLength(0);
+  });
+});

package/dist/server/handlers/__tests__/e2e/storefront-checkout-webhook.e2e.test.js

@@ -0,0 +1,231 @@
+import { describe, it, expect, vi, 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();
+
+// ============================================================================
+// Mock Webhook Dispatcher
+// ============================================================================
+
+const mockWebhookDispatcher = {
+  deliver: vi.fn()
+};
+
+// ============================================================================
+// Storefront API Helpers — real DB operations
+// ============================================================================
+
+async function addToCart(cartId, productId, quantity) {
+  const {
+    data: existing
+  } = await sb.from("cart_items").select().eq("cart_id", cartId).eq("product_id", productId);
+  if (existing && existing.length > 0) {
+    await sb.from("cart_items").update({
+      quantity: existing[0].quantity + quantity
+    }).eq("id", existing[0].id);
+  } else {
+    const {
+      data: prodData
+    } = await sb.from("products").select("name,cost_price").eq("id", productId).limit(1);
+    const productName = prodData?.[0]?.name ?? "Unknown Product";
+    const unitPrice = prodData?.[0]?.cost_price ?? 0;
+    await seedTracked("cart_items", [{
+      id: randomUUID(),
+      cart_id: cartId,
+      product_id: productId,
+      product_name: productName,
+      unit_price: unitPrice,
+      quantity
+    }]);
+  }
+}
+let orderCounter = 0;
+function nextOrderNumber() {
+  return `${RUN_PREFIX}-SCW-${++orderCounter}-${Date.now()}`;
+}
+async function createOrderFromCart(cartId, storeId) {
+  const {
+    data: cartItems
+  } = await sb.from("cart_items").select().eq("cart_id", cartId);
+  if (!cartItems || cartItems.length === 0) {
+    return {
+      orderId: null,
+      error: "Cart is empty"
+    };
+  }
+  let totalAmount = 0;
+  const resolvedItems = [];
+  for (const item of cartItems) {
+    const {
+      data: prodData
+    } = await sb.from("products").select().eq("id", item.product_id);
+    if (!prodData || prodData.length === 0) continue;
+    const unitPrice = prodData[0].cost_price;
+    const qty = item.quantity;
+    totalAmount += unitPrice * qty;
+    resolvedItems.push({
+      product_id: item.product_id,
+      product_name: prodData[0].name,
+      quantity: qty,
+      unit_price: unitPrice
+    });
+  }
+  const orderId = randomUUID();
+  await seedTracked("orders", [{
+    id: orderId,
+    order_number: nextOrderNumber(),
+    store_id: storeId,
+    status: "pending",
+    total_amount: totalAmount
+  }]);
+  for (const item of resolvedItems) {
+    await seedTracked("order_items", [{
+      id: randomUUID(),
+      order_id: orderId,
+      product_id: item.product_id,
+      product_name: item.product_name,
+      quantity: item.quantity,
+      unit_price: item.unit_price,
+      line_subtotal: item.unit_price * item.quantity,
+      line_total: item.unit_price * item.quantity,
+      store_id: storeId
+    }]);
+  }
+  await sb.from("cart_items").delete().eq("cart_id", cartId);
+  return {
+    orderId,
+    error: null
+  };
+}
+async function deliverWebhook(storeId, event, payload) {
+  const {
+    data: webhooks
+  } = await sb.from("webhook_endpoints").select().eq("store_id", storeId);
+  const matching = (webhooks ?? []).filter(w => w.is_active && w.slug && w.slug.includes(RUN_PREFIX));
+  for (const webhook of matching) {
+    mockWebhookDispatcher.deliver.mockResolvedValueOnce({
+      status: 200
+    });
+    await mockWebhookDispatcher.deliver({
+      url: `https://example.com/hooks/${webhook.slug}`,
+      event,
+      payload
+    });
+    await seedTracked("error_events", [{
+      id: randomUUID(),
+      error_type: `webhook.${event}`,
+      error_message: "delivered",
+      severity: "info",
+      store_id: storeId,
+      tags: {
+        resource_type: "webhook",
+        resource_id: webhook.id,
+        event,
+        status: "delivered",
+        response_status: 200
+      }
+    }]);
+  }
+  return matching.length;
+}
+
+// ============================================================================
+// E2E Tests: Storefront Checkout — Order Verification + Webhooks
+// ============================================================================
+
+describe.skipIf(!HAS_TEST_DB)("Storefront Checkout E2E — webhooks", () => {
+  let cartId;
+  let prod1Id;
+  let prod2Id;
+  let webhookId;
+  let webhookWorkflowId;
+  let locationId;
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    cartId = randomUUID();
+    prod1Id = randomUUID();
+    prod2Id = randomUUID();
+    webhookId = randomUUID();
+    webhookWorkflowId = randomUUID();
+    locationId = randomUUID();
+    await seedTracked("locations", [{
+      id: locationId,
+      store_id: TEST_STORE,
+      name: `${RUN_PREFIX}_Webhook Location`,
+      slug: `${RUN_PREFIX}-webhook-location`,
+      type: "retail"
+    }]);
+    await seedTracked("products", [{
+      id: prod1Id,
+      name: `${RUN_PREFIX}_T-Shirt`,
+      cost_price: 25.00,
+      store_id: TEST_STORE,
+      status: "published"
+    }, {
+      id: prod2Id,
+      name: `${RUN_PREFIX}_Hoodie`,
+      cost_price: 55.00,
+      store_id: TEST_STORE,
+      status: "published"
+    }]);
+    await seedTracked("workflows", [{
+      id: webhookWorkflowId,
+      name: `${RUN_PREFIX}_Webhook Workflow`,
+      store_id: TEST_STORE,
+      status: "draft"
+    }]);
+    await seedTracked("webhook_endpoints", [{
+      id: webhookId,
+      store_id: TEST_STORE,
+      name: `${RUN_PREFIX}_Storefront Webhook`,
+      slug: `${RUN_PREFIX}-webhook-storefront`,
+      is_active: true,
+      workflow_id: webhookWorkflowId
+    }]);
+    await seedTracked("carts", [{
+      id: cartId,
+      store_id: TEST_STORE,
+      location_id: locationId
+    }]);
+  });
+  afterEach(async () => {
+    await cleanup();
+  });
+  it("verifies order record exists in database after checkout", async () => {
+    await addToCart(cartId, prod1Id, 1);
+    const {
+      orderId
+    } = await createOrderFromCart(cartId, TEST_STORE);
+    const {
+      data: orderData
+    } = await sb.from("orders").select().eq("id", orderId);
+    expect(orderData).toHaveLength(1);
+    expect(orderData[0].store_id).toBe(TEST_STORE);
+  });
+  it("delivers webhook notification on order creation", async () => {
+    await addToCart(cartId, prod2Id, 1);
+    const {
+      orderId
+    } = await createOrderFromCart(cartId, TEST_STORE);
+    const delivered = await deliverWebhook(TEST_STORE, "order.created", {
+      order_id: orderId,
+      total_amount: 55.00
+    });
+    expect(delivered).toBe(1);
+    expect(mockWebhookDispatcher.deliver).toHaveBeenCalledWith(expect.objectContaining({
+      url: `https://example.com/hooks/${RUN_PREFIX}-webhook-storefront`,
+      event: "order.created"
+    }));
+    const {
+      data: deliveries
+    } = await sb.from("error_events").select().eq("error_type", "webhook.order.created");
+    const ourDeliveries = (deliveries ?? []).filter(d => d.tags?.resource_id === webhookId);
+    expect(ourDeliveries).toHaveLength(1);
+    expect(ourDeliveries[0].tags?.status).toBe("delivered");
+  });
+});