whale-code 6.5.11 → 6.6.0

package/dist/server/handlers/__tests__/e2e/order-lifecycle.setup.e2e.test.js

@@ -1,177 +0,0 @@
-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";
-const sb = getTestClient();
-const mockStripe = {
-  charges: {
-    create: vi.fn()
-  }
-};
-const mockEmailService = {
-  send: vi.fn()
-};
-let orderCounter = 0;
-function nextOrderNumber() {
-  return `${RUN_PREFIX}-ORD-${++orderCounter}-${Date.now()}`;
-}
-async function createCustomer(overrides) {
-  const userId = randomUUID();
-  const ucrId = randomUUID();
-  const creationId = randomUUID();
-  await seedTracked("platform_users", [{
-    id: userId,
-    email: overrides?.email ?? `${RUN_PREFIX}_jane@example.com`,
-    first_name: overrides?.first_name ?? `${RUN_PREFIX}_Jane`,
-    last_name: overrides?.last_name ?? "Doe"
-  }]);
-  await seedTracked("creations", [{
-    id: creationId,
-    creation_type: "display",
-    name: `${RUN_PREFIX}_Store Creation`,
-    slug: `${RUN_PREFIX}-store-${creationId.slice(0, 6)}`,
-    store_id: TEST_STORE,
-    status: "draft",
-    react_code: "export default function Creation() { return <div/>; }"
-  }]);
-  await seedTracked("user_creation_relationships", [{
-    id: ucrId,
-    user_id: userId,
-    creation_id: creationId,
-    creation_type: "store",
-    store_id: TEST_STORE,
-    role: "customer",
-    status: "active"
-  }]);
-  return {
-    id: ucrId,
-    user_id: userId,
-    first_name: overrides?.first_name ?? `${RUN_PREFIX}_Jane`,
-    last_name: overrides?.last_name ?? "Doe",
-    email: overrides?.email ?? `${RUN_PREFIX}_jane@example.com`
-  };
-}
-async function createProduct(overrides) {
-  const rows = await seedTracked("products", [{
-    id: randomUUID(),
-    name: overrides?.name ?? `${RUN_PREFIX}_Widget Pro`,
-    cost_price: overrides?.cost_price ?? 29.99,
-    cost_currency: "usd",
-    stock_quantity: overrides?.stock_quantity ?? 100,
-    store_id: TEST_STORE,
-    status: "published",
-    ...overrides
-  }]);
-  return rows[0];
-}
-async function placeOrder(customerId, items) {
-  const totalAmount = items.reduce((sum, i) => sum + i.unit_price * i.quantity, 0);
-  const orderId = randomUUID();
-  await seedTracked("orders", [{
-    id: orderId,
-    order_number: nextOrderNumber(),
-    customer_id: customerId,
-    status: "pending",
-    total_amount: totalAmount,
-    store_id: TEST_STORE
-  }]);
-  for (const item of items) {
-    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: TEST_STORE
-    }]);
-  }
-  return {
-    orderId,
-    totalAmount
-  };
-}
-describe.skipIf(!HAS_TEST_DB)("Order Lifecycle E2E — setup + ordering", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-  afterEach(async () => {
-    await cleanup();
-  });
-  it("creates a customer and persists to the database", async () => {
-    const customer = await createCustomer();
-    expect(customer.id).toBeDefined();
-    expect(customer.first_name).toBe(`${RUN_PREFIX}_Jane`);
-    expect(customer.email).toBe(`${RUN_PREFIX}_jane@example.com`);
-    const {
-      data
-    } = await sb.from("user_creation_relationships").select().eq("id", customer.id);
-    expect(data).toHaveLength(1);
-  });
-  it("adds a product to the catalog with pricing", async () => {
-    const product = await createProduct({
-      name: `${RUN_PREFIX}_Deluxe Widget`,
-      cost_price: 49.99
-    });
-    const {
-      data
-    } = await sb.from("products").select().eq("id", product.id);
-    expect(data).toHaveLength(1);
-    expect(data[0].cost_price).toBe(49.99);
-    expect(data[0].stock_quantity).toBe(100);
-  });
-  it("places an order with multiple items and computes total", async () => {
-    const customer = await createCustomer();
-    const prod1 = await createProduct({
-      name: `${RUN_PREFIX}_Widget A`,
-      cost_price: 10.00
-    });
-    const prod2 = await createProduct({
-      name: `${RUN_PREFIX}_Widget B`,
-      cost_price: 25.00
-    });
-    const {
-      orderId,
-      totalAmount
-    } = await placeOrder(customer.id, [{
-      product_id: prod1.id,
-      product_name: prod1.name,
-      quantity: 2,
-      unit_price: 10.00
-    }, {
-      product_id: prod2.id,
-      product_name: prod2.name,
-      quantity: 1,
-      unit_price: 25.00
-    }]);
-    expect(totalAmount).toBe(45.00);
-    const {
-      data: orderData
-    } = await sb.from("orders").select().eq("id", orderId);
-    expect(orderData).toHaveLength(1);
-    expect(orderData[0].status).toBe("pending");
-    expect(orderData[0].total_amount).toBe(45.00);
-    const {
-      data: itemsData
-    } = await sb.from("order_items").select().eq("order_id", orderId);
-    expect(itemsData).toHaveLength(2);
-  });
-  it("handles order with zero items gracefully", async () => {
-    const customer = await createCustomer();
-    const {
-      orderId,
-      totalAmount
-    } = await placeOrder(customer.id, []);
-    expect(totalAmount).toBe(0);
-    const {
-      data: orderData
-    } = await sb.from("orders").select().eq("id", orderId);
-    expect(orderData).toHaveLength(1);
-    expect(orderData[0].total_amount).toBe(0);
-    const {
-      data: itemsData
-    } = await sb.from("order_items").select().eq("order_id", orderId);
-    expect(itemsData).toHaveLength(0);
-  });
-});

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

@@ -1,255 +0,0 @@
-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

@@ -1,231 +0,0 @@
-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");
-  });
-});