whale-code 6.5.10 → 6.6.0

package/dist/server/handlers/__tests__/e2e/inventory-sync.e2e.test.js

@@ -1,228 +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();
-
-// ============================================================================
-// In-memory stores for tables that don't exist or have incompatible schemas
-// ============================================================================
-
-let inMemoryAdjustments = [];
-let inMemoryTransfers = [];
-let inMemoryAlerts = [];
-
-// ============================================================================
-// Inventory Management Helpers
-// ============================================================================
-
-async function getInventory(productId, locationId) {
-  const {
-    data
-  } = await sb.from("inventory").select().eq("product_id", productId).eq("location_id", locationId);
-  if (!data || data.length === 0) {
-    return {
-      quantity: 0,
-      found: false
-    };
-  }
-  return {
-    quantity: Number(data[0].quantity),
-    found: true
-  };
-}
-async function adjustStock(productId, locationId, quantityDelta, reason) {
-  const current = await getInventory(productId, locationId);
-  const newQuantity = current.quantity + quantityDelta;
-  if (newQuantity < 0) {
-    return {
-      success: false,
-      newQuantity: current.quantity,
-      error: `Insufficient stock: have ${current.quantity}, requested adjustment of ${quantityDelta}`
-    };
-  }
-  if (current.found) {
-    await sb.from("inventory").update({
-      quantity: newQuantity,
-      updated_at: new Date().toISOString()
-    }).eq("product_id", productId).eq("location_id", locationId);
-  } else {
-    await seedTracked("inventory", [{
-      id: randomUUID(),
-      product_id: productId,
-      location_id: locationId,
-      store_id: TEST_STORE,
-      quantity: newQuantity
-    }]);
-  }
-  inMemoryAdjustments.push({
-    id: randomUUID(),
-    product_id: productId,
-    location_id: locationId,
-    quantity_delta: quantityDelta,
-    new_quantity: newQuantity,
-    reason
-  });
-  const {
-    data: prodData
-  } = await sb.from("products").select().eq("id", productId);
-  if (prodData && prodData.length > 0) {
-    const lowStockThreshold = prodData[0].low_stock_amount ?? 5;
-    if (newQuantity <= lowStockThreshold && newQuantity > 0) {
-      inMemoryAlerts.push({
-        id: randomUUID(),
-        type: "low_stock",
-        product_id: productId,
-        location_id: locationId,
-        message: `Low stock: ${prodData[0].name} has ${newQuantity} units at location ${locationId}`,
-        severity: "warning",
-        resolved: false
-      });
-    }
-  }
-  return {
-    success: true,
-    newQuantity
-  };
-}
-async function createStockTransfer(productId, fromLocationId, toLocationId, quantity) {
-  const sourceStock = await getInventory(productId, fromLocationId);
-  if (sourceStock.quantity < quantity) {
-    return {
-      success: false,
-      error: `Insufficient stock at source: have ${sourceStock.quantity}, need ${quantity}`
-    };
-  }
-  const transferId = randomUUID();
-  inMemoryTransfers.push({
-    id: transferId,
-    product_id: productId,
-    from_location_id: fromLocationId,
-    to_location_id: toLocationId,
-    quantity,
-    status: "completed"
-  });
-  await adjustStock(productId, fromLocationId, -quantity, `Transfer out: ${transferId}`);
-  await adjustStock(productId, toLocationId, quantity, `Transfer in: ${transferId}`);
-  return {
-    success: true,
-    transferId
-  };
-}
-
-// ============================================================================
-// E2E Tests: Inventory Sync — adjustments & transfers
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("Inventory Sync E2E — adjustments", () => {
-  let prodWidgetId;
-  let prodGadgetId;
-  let locWarehouseId;
-  let locStoreAId;
-  let locStoreBId;
-  beforeEach(async () => {
-    prodWidgetId = randomUUID();
-    prodGadgetId = randomUUID();
-    locWarehouseId = randomUUID();
-    locStoreAId = randomUUID();
-    locStoreBId = randomUUID();
-    inMemoryAdjustments = [];
-    inMemoryTransfers = [];
-    inMemoryAlerts = [];
-    await seedTracked("products", [{
-      id: prodWidgetId,
-      name: `${RUN_PREFIX}_Widget`,
-      sku: `${RUN_PREFIX}_WDG-001`,
-      low_stock_amount: 5,
-      store_id: TEST_STORE
-    }, {
-      id: prodGadgetId,
-      name: `${RUN_PREFIX}_Gadget`,
-      sku: `${RUN_PREFIX}_GDG-001`,
-      low_stock_amount: 10,
-      store_id: TEST_STORE
-    }]);
-    await seedTracked("locations", [{
-      id: locWarehouseId,
-      name: `${RUN_PREFIX}_Main Warehouse`,
-      slug: `${RUN_PREFIX}-main-wh`,
-      type: "warehouse",
-      store_id: TEST_STORE
-    }, {
-      id: locStoreAId,
-      name: `${RUN_PREFIX}_Retail Store A`,
-      slug: `${RUN_PREFIX}-retail-a`,
-      type: "retail",
-      store_id: TEST_STORE
-    }, {
-      id: locStoreBId,
-      name: `${RUN_PREFIX}_Retail Store B`,
-      slug: `${RUN_PREFIX}-retail-b`,
-      type: "retail",
-      store_id: TEST_STORE
-    }]);
-    await seedTracked("inventory", [{
-      id: randomUUID(),
-      product_id: prodWidgetId,
-      location_id: locWarehouseId,
-      store_id: TEST_STORE,
-      quantity: 100
-    }, {
-      id: randomUUID(),
-      product_id: prodWidgetId,
-      location_id: locStoreAId,
-      store_id: TEST_STORE,
-      quantity: 20
-    }, {
-      id: randomUUID(),
-      product_id: prodGadgetId,
-      location_id: locWarehouseId,
-      store_id: TEST_STORE,
-      quantity: 50
-    }]);
-  });
-  afterEach(async () => {
-    await cleanup();
-  });
-  it("adjusts stock at a location and verifies quantity updated", async () => {
-    const result = await adjustStock(prodWidgetId, locWarehouseId, -15, "Sold 15 units");
-    expect(result.success).toBe(true);
-    expect(result.newQuantity).toBe(85);
-    const inventory = await getInventory(prodWidgetId, locWarehouseId);
-    expect(inventory.quantity).toBe(85);
-    const adjustments = inMemoryAdjustments.filter(a => a.product_id === prodWidgetId && a.location_id === locWarehouseId);
-    expect(adjustments.length).toBeGreaterThanOrEqual(1);
-    const ourAdj = adjustments.find(a => a.reason === "Sold 15 units");
-    expect(ourAdj).toBeDefined();
-    expect(ourAdj.quantity_delta).toBe(-15);
-  });
-  it("creates stock at a new location when adjusting stock up", async () => {
-    const result = await adjustStock(prodGadgetId, locStoreBId, 30, "Initial stock");
-    expect(result.success).toBe(true);
-    expect(result.newQuantity).toBe(30);
-    const inventory = await getInventory(prodGadgetId, locStoreBId);
-    expect(inventory.quantity).toBe(30);
-    expect(inventory.found).toBe(true);
-  });
-  it("transfers stock between locations and updates both quantities", async () => {
-    const beforeSource = await getInventory(prodWidgetId, locWarehouseId);
-    const beforeDest = await getInventory(prodWidgetId, locStoreAId);
-    expect(beforeSource.quantity).toBe(100);
-    expect(beforeDest.quantity).toBe(20);
-    const result = await createStockTransfer(prodWidgetId, locWarehouseId, locStoreAId, 25);
-    expect(result.success).toBe(true);
-    expect(result.transferId).toBeDefined();
-    const afterSource = await getInventory(prodWidgetId, locWarehouseId);
-    const afterDest = await getInventory(prodWidgetId, locStoreAId);
-    expect(afterSource.quantity).toBe(75);
-    expect(afterDest.quantity).toBe(45);
-    const transfers = inMemoryTransfers.filter(t => t.id === result.transferId);
-    expect(transfers).toHaveLength(1);
-    expect(transfers[0].status).toBe("completed");
-    expect(transfers[0].quantity).toBe(25);
-  });
-});

package/dist/server/handlers/__tests__/e2e/inventory-sync.part2.e2e.test.js

@@ -1,188 +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();
-
-// ============================================================================
-// In-memory stores
-// ============================================================================
-
-let inMemoryAlerts = [];
-
-// ============================================================================
-// Inventory Management Helpers
-// ============================================================================
-
-async function getInventory(productId, locationId) {
-  const {
-    data
-  } = await sb.from("inventory").select().eq("product_id", productId).eq("location_id", locationId);
-  if (!data || data.length === 0) {
-    return {
-      quantity: 0,
-      found: false
-    };
-  }
-  return {
-    quantity: Number(data[0].quantity),
-    found: true
-  };
-}
-async function adjustStock(productId, locationId, quantityDelta, reason) {
-  const current = await getInventory(productId, locationId);
-  const newQuantity = current.quantity + quantityDelta;
-  if (newQuantity < 0) {
-    return {
-      success: false,
-      newQuantity: current.quantity,
-      error: `Insufficient stock: have ${current.quantity}, requested adjustment of ${quantityDelta}`
-    };
-  }
-  if (current.found) {
-    await sb.from("inventory").update({
-      quantity: newQuantity,
-      updated_at: new Date().toISOString()
-    }).eq("product_id", productId).eq("location_id", locationId);
-  } else {
-    await seedTracked("inventory", [{
-      id: randomUUID(),
-      product_id: productId,
-      location_id: locationId,
-      store_id: TEST_STORE,
-      quantity: newQuantity
-    }]);
-  }
-  const {
-    data: prodData
-  } = await sb.from("products").select().eq("id", productId);
-  if (prodData && prodData.length > 0) {
-    const lowStockThreshold = prodData[0].low_stock_amount ?? 5;
-    if (newQuantity <= lowStockThreshold && newQuantity > 0) {
-      inMemoryAlerts.push({
-        id: randomUUID(),
-        type: "low_stock",
-        product_id: productId,
-        location_id: locationId,
-        message: `Low stock: ${prodData[0].name} has ${newQuantity} units at location ${locationId}`,
-        severity: "warning",
-        resolved: false
-      });
-    }
-  }
-  return {
-    success: true,
-    newQuantity
-  };
-}
-async function createStockTransfer(productId, fromLocationId, toLocationId, quantity) {
-  const sourceStock = await getInventory(productId, fromLocationId);
-  if (sourceStock.quantity < quantity) {
-    return {
-      success: false,
-      error: `Insufficient stock at source: have ${sourceStock.quantity}, need ${quantity}`
-    };
-  }
-  await adjustStock(productId, fromLocationId, -quantity, `Transfer out`);
-  await adjustStock(productId, toLocationId, quantity, `Transfer in`);
-  return {
-    success: true,
-    transferId: randomUUID()
-  };
-}
-
-// ============================================================================
-// E2E Tests: Inventory Sync — alerts & error handling
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("Inventory Sync E2E — alerts & errors", () => {
-  let prodWidgetId;
-  let locWarehouseId;
-  let locStoreAId;
-  let locStoreBId;
-  beforeEach(async () => {
-    prodWidgetId = randomUUID();
-    locWarehouseId = randomUUID();
-    locStoreAId = randomUUID();
-    locStoreBId = randomUUID();
-    inMemoryAlerts = [];
-    await seedTracked("products", [{
-      id: prodWidgetId,
-      name: `${RUN_PREFIX}_Widget`,
-      sku: `${RUN_PREFIX}_WDG-002`,
-      low_stock_amount: 5,
-      store_id: TEST_STORE
-    }]);
-    await seedTracked("locations", [{
-      id: locWarehouseId,
-      name: `${RUN_PREFIX}_Main Warehouse 2`,
-      slug: `${RUN_PREFIX}-main-wh2`,
-      type: "warehouse",
-      store_id: TEST_STORE
-    }, {
-      id: locStoreAId,
-      name: `${RUN_PREFIX}_Retail Store A2`,
-      slug: `${RUN_PREFIX}-retail-a2`,
-      type: "retail",
-      store_id: TEST_STORE
-    }, {
-      id: locStoreBId,
-      name: `${RUN_PREFIX}_Retail Store B2`,
-      slug: `${RUN_PREFIX}-retail-b2`,
-      type: "retail",
-      store_id: TEST_STORE
-    }]);
-    await seedTracked("inventory", [{
-      id: randomUUID(),
-      product_id: prodWidgetId,
-      location_id: locWarehouseId,
-      store_id: TEST_STORE,
-      quantity: 100
-    }, {
-      id: randomUUID(),
-      product_id: prodWidgetId,
-      location_id: locStoreAId,
-      store_id: TEST_STORE,
-      quantity: 20
-    }]);
-  });
-  afterEach(async () => {
-    await cleanup();
-  });
-  it("generates a low stock alert when quantity drops below threshold", async () => {
-    await adjustStock(prodWidgetId, locWarehouseId, -96, "Large batch sale");
-    const inventory = await getInventory(prodWidgetId, locWarehouseId);
-    expect(inventory.quantity).toBe(4);
-    const alerts = inMemoryAlerts.filter(a => a.type === "low_stock" && a.product_id === prodWidgetId && a.location_id === locWarehouseId);
-    expect(alerts.length).toBeGreaterThanOrEqual(1);
-    const ourAlert = alerts.find(a => a.message.includes("4 units"));
-    expect(ourAlert).toBeDefined();
-    expect(ourAlert.severity).toBe("warning");
-    expect(ourAlert.resolved).toBe(false);
-  });
-  it("prevents negative stock and returns an error", async () => {
-    const currentStock = await getInventory(prodWidgetId, locStoreAId);
-    expect(currentStock.quantity).toBe(20);
-    const result = await adjustStock(prodWidgetId, locStoreAId, -25, "Oversell attempt");
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Insufficient stock");
-    expect(result.error).toContain("have 20");
-    expect(result.newQuantity).toBe(20);
-    const afterStock = await getInventory(prodWidgetId, locStoreAId);
-    expect(afterStock.quantity).toBe(20);
-  });
-  it("prevents transfer when source has insufficient stock", async () => {
-    const result = await createStockTransfer(prodWidgetId, locStoreAId, locStoreBId, 50);
-    expect(result.success).toBe(false);
-    expect(result.error).toContain("Insufficient stock at source");
-    expect(result.error).toContain("have 20");
-    const sourceStock = await getInventory(prodWidgetId, locStoreAId);
-    expect(sourceStock.quantity).toBe(20);
-    const destStock = await getInventory(prodWidgetId, locStoreBId);
-    expect(destStock.quantity).toBe(0);
-  });
-});

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

@@ -1,295 +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(),
-    ucrId = randomUUID(),
-    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
-  };
-}
-async function createLocationIfNeeded() {
-  const {
-    data
-  } = await sb.from("locations").select("id").eq("store_id", TEST_STORE).limit(1);
-  if (data && data.length > 0) return data[0].id;
-  const locId = randomUUID();
-  await seedTracked("locations", [{
-    id: locId,
-    store_id: TEST_STORE,
-    name: `${RUN_PREFIX}_Test Location`,
-    slug: `${RUN_PREFIX}-test-location`,
-    type: "retail"
-  }]);
-  return locId;
-}
-async function processPayment(orderId, amount) {
-  mockStripe.charges.create.mockResolvedValueOnce({
-    id: `ch_${RUN_PREFIX}_${Date.now()}`,
-    status: "completed",
-    amount
-  });
-  const chargeResult = await mockStripe.charges.create({
-    amount,
-    currency: "usd",
-    source: "tok_visa"
-  });
-  const locationId = await createLocationIfNeeded();
-  await seedTracked("payment_intents", [{
-    id: randomUUID(),
-    order_id: orderId,
-    amount,
-    status: "completed",
-    payment_method: "card",
-    store_id: TEST_STORE,
-    location_id: locationId,
-    register_id: randomUUID(),
-    session_id: randomUUID(),
-    cart_items: JSON.stringify([]),
-    totals: JSON.stringify({
-      subtotal: amount,
-      tax: 0,
-      total: amount
-    }),
-    idempotency_key: randomUUID()
-  }]);
-  await sb.from("orders").update({
-    status: "completed",
-    payment_status: "paid"
-  }).eq("id", orderId);
-  return chargeResult;
-}
-async function fulfillOrder(orderId) {
-  await sb.from("orders").update({
-    fulfillment_status: "fulfilled",
-    completed_date: new Date().toISOString()
-  }).eq("id", orderId);
-}
-async function sendConfirmationEmail(orderId, customerEmail) {
-  const msgId = `msg_${RUN_PREFIX}_${Date.now()}`;
-  mockEmailService.send.mockResolvedValueOnce({
-    id: msgId,
-    status: "sent"
-  });
-  await mockEmailService.send({
-    to: customerEmail,
-    subject: "Order Confirmed",
-    body: `Your order ${orderId} has been fulfilled.`
-  });
-  await seedTracked("email_sends", [{
-    id: randomUUID(),
-    order_id: orderId,
-    to_email: customerEmail,
-    from_email: `noreply@${RUN_PREFIX}.test`,
-    from_name: `${RUN_PREFIX} Store`,
-    subject: "Order Confirmed",
-    status: "sent",
-    email_type: "transactional",
-    store_id: TEST_STORE
-  }]);
-}
-
-// ============================================================================
-// E2E Tests: Order Lifecycle — fulfillment and full trail
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("Order Lifecycle E2E — fulfillment and data trail", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-  afterEach(async () => {
-    await cleanup();
-  });
-  it("fulfills an order after payment is confirmed", async () => {
-    const customer = await createCustomer();
-    const product = await createProduct();
-    const {
-      orderId,
-      totalAmount
-    } = await placeOrder(customer.id, [{
-      product_id: product.id,
-      product_name: product.name,
-      quantity: 1,
-      unit_price: 29.99
-    }]);
-    await processPayment(orderId, totalAmount);
-    await fulfillOrder(orderId);
-    const {
-      data: orderData
-    } = await sb.from("orders").select().eq("id", orderId);
-    expect(orderData[0].fulfillment_status).toBe("fulfilled");
-    expect(orderData[0].completed_date).toBeDefined();
-  });
-  it("sends confirmation email after fulfillment and records it", async () => {
-    const customer = await createCustomer();
-    const product = await createProduct();
-    const {
-      orderId,
-      totalAmount
-    } = await placeOrder(customer.id, [{
-      product_id: product.id,
-      product_name: product.name,
-      quantity: 1,
-      unit_price: 29.99
-    }]);
-    await processPayment(orderId, totalAmount);
-    await fulfillOrder(orderId);
-    await sendConfirmationEmail(orderId, customer.email);
-    expect(mockEmailService.send).toHaveBeenCalledWith(expect.objectContaining({
-      to: customer.email,
-      subject: "Order Confirmed"
-    }));
-    const {
-      data: emailData
-    } = await sb.from("email_sends").select().eq("order_id", orderId);
-    expect(emailData).toHaveLength(1);
-    expect(emailData[0].to_email).toBe(customer.email);
-    expect(emailData[0].status).toBe("sent");
-  });
-  it("verifies complete data trail across all tables after full lifecycle", async () => {
-    const customer = await createCustomer({
-      first_name: `${RUN_PREFIX}_Full Flow`,
-      last_name: "User",
-      email: `${RUN_PREFIX}_flow@example.com`
-    });
-    const product = await createProduct({
-      name: `${RUN_PREFIX}_Premium Widget`,
-      cost_price: 50.00
-    });
-    const {
-      orderId,
-      totalAmount
-    } = await placeOrder(customer.id, [{
-      product_id: product.id,
-      product_name: product.name,
-      quantity: 3,
-      unit_price: 50.00
-    }]);
-    await processPayment(orderId, totalAmount);
-    await fulfillOrder(orderId);
-    await sendConfirmationEmail(orderId, customer.email);
-
-    // Verify customer relationship
-    const {
-      data: custData
-    } = await sb.from("user_creation_relationships").select().eq("id", customer.id);
-    expect(custData).toHaveLength(1);
-
-    // Verify products table
-    const {
-      data: prodData
-    } = await sb.from("products").select().eq("id", product.id);
-    expect(prodData).toHaveLength(1);
-
-    // Verify orders table
-    const {
-      data: orderData
-    } = await sb.from("orders").select().eq("id", orderId);
-    expect(orderData).toHaveLength(1);
-    expect(orderData[0].status).toBe("completed");
-    expect(orderData[0].total_amount).toBe(150.00);
-
-    // Verify order_items table
-    const {
-      data: itemsData
-    } = await sb.from("order_items").select().eq("order_id", orderId);
-    expect(itemsData).toHaveLength(1);
-    expect(itemsData[0].quantity).toBe(3);
-
-    // Verify payment_intents table
-    const {
-      data: paymentData
-    } = await sb.from("payment_intents").select().eq("order_id", orderId);
-    expect(paymentData).toHaveLength(1);
-
-    // Verify email_sends table
-    const {
-      data: emailData
-    } = await sb.from("email_sends").select().eq("order_id", orderId);
-    expect(emailData).toHaveLength(1);
-  });
-});