@instockng/api-client 1.0.9 → 1.0.10

package/dist/apps/backend/src/routes/public/carts.js

@@ -1,778 +0,0 @@
-import { Hono } from 'hono';
-import { zValidator } from '@hono/zod-validator';
-import { z } from 'zod';
-import { getPrismaClient } from '../../lib/prisma';
-import { calculateCartCost } from '../../lib/pricing';
-import { buildCartResponseWithPricing } from '../../lib/cart-response';
-import { toPricingItems } from '../../lib/cart-response';
-import { validateCart, buildCartResponse, etagFrom, paymentFromZone, CART_INCLUDE_FULL, CART_ITEM_WITH_CART_INCLUDE, ORDER_INCLUDE_FULL, } from '../../lib/cart-helpers';
-import { round, toNumber } from '../../lib/utils';
-import { formatOrderResponse } from '../../lib/order-response';
-import { captureMessage, captureException, getSampleRate } from '../../lib/sentry';
-const app = new Hono()
-    // CREATE CART
-    .post('/', zValidator('json', z.object({
-    brandSlug: z.string(),
-})), async (c) => {
-    const input = c.req.valid('json');
-    try {
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        // Look up brand by slug
-        const brand = await prisma.brand.findFirst({
-            where: { slug: input.brandSlug, deletedAt: null },
-        });
-        if (!brand) {
-            // Track brand not found with sampling - could indicate broken links
-            captureMessage('Brand not found during cart creation', {
-                level: 'info',
-                tags: {
-                    error_code: 'BRAND_NOT_FOUND',
-                    endpoint: 'POST /carts',
-                },
-                extra: {
-                    brandSlug: input.brandSlug,
-                },
-                sampleRate: 0.1, // 10% sampling
-            });
-            return c.json({ error: { code: 'BRAND_NOT_FOUND', message: 'Brand not found' } }, 404);
-        }
-        // Create cart that expires in 7 days
-        const cart = await prisma.cart.create({
-            data: {
-                brandId: brand.id,
-                expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
-                availablePaymentMethods: ['cod', 'online'],
-            },
-            include: CART_INCLUDE_FULL,
-        });
-        const responseCart = await buildCartResponseWithPricing(prisma, cart);
-        return c.json(responseCart, 201);
-    }
-    catch (error) {
-        console.error('Error creating cart:', error);
-        // Capture cart creation errors - could be database issues
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_code: 'CART_CREATE_ERROR',
-                endpoint: 'POST /carts',
-            },
-            extra: {
-                brandSlug: input.brandSlug,
-                errorMessage: error?.message,
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-})
-    // GET CART
-    .get('/:id', zValidator('param', z.object({ id: z.string().uuid() })), async (c) => {
-    try {
-        const { id: cartId } = c.req.valid('param');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        // Validate cart exists and is not expired
-        const { cart, error } = await validateCart(prisma, cartId);
-        if (error) {
-            return c.json({ error: { code: error.code, message: error.message } }, error.status);
-        }
-        const responseCart = await buildCartResponse(prisma, cart);
-        c.header('ETag', etagFrom(cart.updatedAt));
-        return c.json(responseCart, 200);
-    }
-    catch (error) {
-        console.error('Error fetching cart:', error);
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_code: 'CART_FETCH_ERROR',
-                endpoint: 'GET /carts/:id',
-            },
-            extra: {
-                cartId: c.req.param('id'),
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-})
-    // UPDATE CART
-    .patch('/:id', zValidator('param', z.object({ id: z.string().uuid() })), zValidator('json', z.object({
-    customerPhone: z.string().optional().nullable(),
-    customerEmail: z.string().email().optional().nullable(),
-    customerFirstName: z.string().optional().nullable(),
-    customerLastName: z.string().optional().nullable(),
-    deliveryZoneId: z.string().uuid().optional().nullable(),
-    ifUnmodifiedSince: z.string().datetime().optional(),
-})), async (c) => {
-    try {
-        const { id: cartId } = c.req.valid('param');
-        const input = c.req.valid('json');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        // Validate cart exists and is not expired
-        const { cart, error } = await validateCart(prisma, cartId);
-        if (error) {
-            return c.json({ error: { code: error.code, message: error.message } }, error.status);
-        }
-        // Handle concurrency check
-        const ifMatch = c.req.header('if-match');
-        const bodyIfUnmodified = input.ifUnmodifiedSince ? new Date(input.ifUnmodifiedSince) : undefined;
-        if (ifMatch && ifMatch !== etagFrom(cart.updatedAt)) {
-            return c.json({ error: { code: 'PRECONDITION_FAILED', message: 'Cart has changed' } }, 412);
-        }
-        if (bodyIfUnmodified && cart.updatedAt.getTime() !== bodyIfUnmodified.getTime()) {
-            return c.json({ error: { code: 'PRECONDITION_FAILED', message: 'Cart has changed' } }, 412);
-        }
-        // Build update data
-        const updateData = {
-            customerPhone: input.customerPhone,
-            customerEmail: input.customerEmail,
-            customerFirstName: input.customerFirstName,
-            customerLastName: input.customerLastName,
-        };
-        // Handle delivery zone change
-        if (input.deliveryZoneId !== undefined) {
-            if (!input.deliveryZoneId) {
-                // Unsetting zone
-                updateData.deliveryZoneId = null;
-                updateData.deliveryZoneLockedAt = null;
-                updateData.availablePaymentMethods = ['cod', 'online'];
-            }
-            else {
-                // Setting zone
-                const zone = await prisma.deliveryZone.findFirst({
-                    where: { id: input.deliveryZoneId, isActive: true, deletedAt: null },
-                });
-                if (!zone) {
-                    return c.json({ error: { code: 'INVALID_DELIVERY_ZONE', message: 'Zone not available' } }, 400);
-                }
-                updateData.deliveryZoneId = zone.id;
-                updateData.deliveryZoneLockedAt = new Date();
-                updateData.availablePaymentMethods = paymentFromZone(zone);
-            }
-        }
-        const updatedCart = await prisma.cart.update({
-            where: { id: cartId },
-            data: updateData,
-            include: CART_INCLUDE_FULL,
-        });
-        const responseCart = await buildCartResponse(prisma, updatedCart);
-        c.header('ETag', etagFrom(updatedCart.updatedAt));
-        return c.json(responseCart, 200);
-    }
-    catch (error) {
-        console.error('Error updating cart:', error);
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_code: 'CART_UPDATE_ERROR',
-                endpoint: 'PATCH /carts/:id',
-            },
-            extra: {
-                cartId: c.req.param('id'),
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-})
-    // APPLY DISCOUNT CODE
-    .post('/:id/apply-discount', zValidator('param', z.object({ id: z.string().uuid() })), zValidator('json', z.object({ code: z.string() })), async (c) => {
-    try {
-        const { id: cartId } = c.req.valid('param');
-        const { code } = c.req.valid('json');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        // Validate cart exists and is not expired
-        const { cart, error } = await validateCart(prisma, cartId);
-        if (error) {
-            return c.json({ error: { code: error.code, message: error.message } }, error.status);
-        }
-        const now = new Date();
-        const discount = await prisma.discountCode.findFirst({
-            where: {
-                code,
-                deletedAt: null,
-                isActive: true,
-                validFrom: { lte: now },
-                AND: [
-                    { OR: [{ validUntil: null }, { validUntil: { gt: now } }] },
-                    { OR: [{ brandId: null }, { brandId: cart.brandId }] },
-                ],
-            },
-        });
-        if (!discount) {
-            // Track invalid discount code attempts
-            captureMessage('Invalid or expired discount code', {
-                level: 'info',
-                tags: {
-                    error_code: 'INVALID_DISCOUNT_CODE',
-                    brand: cart.brand?.slug || 'unknown',
-                },
-                extra: {
-                    code,
-                    cartId,
-                    brandId: cart.brandId,
-                },
-                sampleRate: getSampleRate('INVALID_DISCOUNT_CODE'), // 20% sampling
-            });
-            return c.json({ error: { code: 'INVALID_DISCOUNT_CODE', message: 'Invalid or expired discount code' } }, 400);
-        }
-        // Check minimum purchase
-        const pricing = calculateCartCost(toPricingItems(cart));
-        if (discount.minPurchase) {
-            const minPurchase = toNumber(discount.minPurchase);
-            if (pricing.subtotal < minPurchase) {
-                // Track minimum purchase not met
-                captureMessage('Minimum purchase not met for discount code', {
-                    level: 'info',
-                    tags: {
-                        error_code: 'MIN_PURCHASE_NOT_MET',
-                        brand: cart.brand?.slug || 'unknown',
-                    },
-                    extra: {
-                        code,
-                        cartId,
-                        minPurchase,
-                        currentSubtotal: pricing.subtotal,
-                        shortfall: minPurchase - pricing.subtotal,
-                    },
-                    sampleRate: getSampleRate('MIN_PURCHASE_NOT_MET'), // 15% sampling
-                });
-                return c.json({ error: { code: 'MIN_PURCHASE_NOT_MET', message: `Minimum purchase of ₦${minPurchase.toLocaleString('en-NG', { minimumFractionDigits: 2 })} required` } }, 400);
-            }
-        }
-        // Attach discount to cart
-        const updated = await prisma.cart.update({
-            where: { id: cartId },
-            data: { appliedDiscountCodeId: discount.id },
-            include: CART_INCLUDE_FULL,
-        });
-        const responseCart = await buildCartResponse(prisma, updated);
-        return c.json(responseCart, 200);
-    }
-    catch (error) {
-        console.error('Error applying discount to cart:', error);
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_code: 'DISCOUNT_APPLY_ERROR',
-                endpoint: 'POST /carts/:id/apply-discount',
-            },
-            extra: {
-                cartId: c.req.param('id'),
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-})
-    // REMOVE DISCOUNT CODE
-    .post('/:id/remove-discount', zValidator('param', z.object({ id: z.string().uuid() })), async (c) => {
-    try {
-        const { id: cartId } = c.req.valid('param');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        // Validate cart exists and is not expired
-        const { error } = await validateCart(prisma, cartId);
-        if (error) {
-            return c.json({ error: { code: error.code, message: error.message } }, error.status);
-        }
-        const updated = await prisma.cart.update({
-            where: { id: cartId },
-            data: { appliedDiscountCodeId: null },
-            include: CART_INCLUDE_FULL,
-        });
-        const responseCart = await buildCartResponse(prisma, updated);
-        return c.json(responseCart, 200);
-    }
-    catch (error) {
-        console.error('Error removing discount from cart:', error);
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_code: 'DISCOUNT_REMOVE_ERROR',
-                endpoint: 'POST /carts/:id/remove-discount',
-            },
-            extra: {
-                cartId: c.req.param('id'),
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-})
-    // ADD CART ITEM
-    .post('/:id/items', zValidator('param', z.object({ id: z.string().uuid() })), zValidator('json', z.object({
-    sku: z.string(),
-    quantity: z.number().int().positive(),
-    fbc: z.string().optional(), // Facebook Click ID for attribution
-    fbp: z.string().optional(), // Facebook Browser ID for attribution
-})), async (c) => {
-    try {
-        const { id: cartId } = c.req.valid('param');
-        const input = c.req.valid('json');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        // Validate cart exists and is not expired
-        const { cart, error } = await validateCart(prisma, cartId);
-        if (error) {
-            return c.json({ error: { code: error.code, message: error.message } }, error.status);
-        }
-        // Find variant by SKU for this brand
-        const variant = await prisma.productVariant.findFirst({
-            where: {
-                sku: input.sku,
-                product: { brandId: cart.brandId },
-                isActive: true,
-                deletedAt: null,
-            },
-            include: {
-                product: true,
-            },
-        });
-        if (!variant) {
-            return c.json({ error: { code: 'VARIANT_NOT_FOUND', message: 'Product variant not found' } }, 404);
-        }
-        // Upsert cart item (add new or update quantity)
-        const existingItem = await prisma.cartItem.findUnique({
-            where: {
-                cartId_variantId: {
-                    cartId,
-                    variantId: variant.id,
-                },
-            },
-        });
-        let cartItem;
-        if (existingItem) {
-            // Update quantity
-            cartItem = await prisma.cartItem.update({
-                where: { id: existingItem.id },
-                data: { quantity: existingItem.quantity + input.quantity },
-                include: {
-                    variant: {
-                        include: {
-                            product: true,
-                        },
-                    },
-                },
-            });
-        }
-        else {
-            // Create new item
-            cartItem = await prisma.cartItem.create({
-                data: {
-                    cartId,
-                    variantId: variant.id,
-                    quantity: input.quantity,
-                },
-                include: {
-                    variant: {
-                        include: {
-                            product: true,
-                        },
-                    },
-                },
-            });
-        }
-        // Fetch updated cart for pricing
-        const updatedCart = await prisma.cart.findUnique({
-            where: { id: cartId },
-            include: CART_INCLUDE_FULL,
-        });
-        // Queue Meta CAPI AddToCart event
-        try {
-            const { enqueueAddToCartEvent } = await import('../../notifications/producers/meta-capi-producer');
-            await enqueueAddToCartEvent(c.env, {
-                cartId,
-                itemId: cartItem.id,
-                pixelId: updatedCart.brand.metaPixelId,
-                brandSiteUrl: updatedCart.brand.siteUrl,
-                productName: variant.product.name,
-                productSlug: variant.product.slug,
-                sku: variant.sku,
-                price: Number(variant.price),
-                quantity: input.quantity,
-                customerEmail: updatedCart.customerEmail,
-                customerPhone: updatedCart.customerPhone,
-                clientIpAddress: c.req.header('cf-connecting-ip'),
-                clientUserAgent: c.req.header('user-agent'),
-                fbc: input.fbc,
-                fbp: input.fbp,
-            });
-        }
-        catch (error) {
-            console.error('Failed to queue Meta CAPI AddToCart event:', error);
-            // Don't fail the request if CAPI queuing fails
-        }
-        const responseCart = await buildCartResponse(prisma, updatedCart);
-        return c.json(responseCart, 200);
-    }
-    catch (error) {
-        console.error('Error adding cart item:', error);
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_code: 'CART_ITEM_ADD_ERROR',
-                endpoint: 'POST /carts/:id/items',
-            },
-            extra: {
-                cartId: c.req.param('id'),
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-})
-    // UPDATE CART ITEM
-    .patch('/:id/items/:itemId', zValidator('param', z.object({
-    id: z.string().uuid(),
-    itemId: z.string().uuid(),
-})), zValidator('json', z.object({
-    quantity: z.number().int().positive(),
-})), async (c) => {
-    try {
-        const { id: cartId, itemId } = c.req.valid('param');
-        const input = c.req.valid('json');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        const cartItem = await prisma.cartItem.findUnique({
-            where: { id: itemId },
-            include: CART_ITEM_WITH_CART_INCLUDE,
-        });
-        if (!cartItem || cartItem.cartId !== cartId) {
-            return c.json({ error: { code: 'CART_ITEM_NOT_FOUND', message: 'Cart item not found' } }, 404);
-        }
-        if (cartItem.cart.expiresAt < new Date()) {
-            return c.json({ error: { code: 'CART_EXPIRED', message: 'Cart has expired' } }, 410);
-        }
-        // Update quantity
-        await prisma.cartItem.update({
-            where: { id: itemId },
-            data: { quantity: input.quantity },
-        });
-        // Fetch updated cart for pricing
-        const updatedCart = await prisma.cart.findUnique({
-            where: { id: cartId },
-            include: CART_INCLUDE_FULL,
-        });
-        const responseCart = await buildCartResponse(prisma, updatedCart);
-        return c.json(responseCart, 200);
-    }
-    catch (error) {
-        console.error('Error updating cart item:', error);
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_code: 'CART_ITEM_UPDATE_ERROR',
-                endpoint: 'PATCH /carts/:id/items/:itemId',
-            },
-            extra: {
-                cartId: c.req.param('id'),
-                itemId: c.req.param('itemId'),
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-})
-    // DELETE CART ITEM
-    .delete('/:id/items/:itemId', zValidator('param', z.object({
-    id: z.string().uuid(),
-    itemId: z.string().uuid(),
-})), async (c) => {
-    try {
-        const { id: cartId, itemId } = c.req.valid('param');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        const cartItem = await prisma.cartItem.findUnique({
-            where: { id: itemId },
-            include: CART_ITEM_WITH_CART_INCLUDE,
-        });
-        if (!cartItem || cartItem.cartId !== cartId) {
-            return c.json({ error: { code: 'CART_ITEM_NOT_FOUND', message: 'Cart item not found' } }, 404);
-        }
-        if (cartItem.cart.expiresAt < new Date()) {
-            return c.json({ error: { code: 'CART_EXPIRED', message: 'Cart has expired' } }, 410);
-        }
-        // Delete item
-        await prisma.cartItem.delete({
-            where: { id: itemId },
-        });
-        // Fetch updated cart for pricing
-        const updatedCart = await prisma.cart.findUnique({
-            where: { id: cartId },
-            include: CART_INCLUDE_FULL,
-        });
-        if (!updatedCart) {
-            return c.json({ error: { code: 'CART_NOT_FOUND', message: 'Cart not found' } }, 404);
-        }
-        const responseCart = await buildCartResponse(prisma, updatedCart);
-        return c.json(responseCart, 200);
-    }
-    catch (error) {
-        console.error('Error removing cart item:', error);
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_code: 'CART_ITEM_DELETE_ERROR',
-                endpoint: 'DELETE /carts/:id/items/:itemId',
-            },
-            extra: {
-                cartId: c.req.param('id'),
-                itemId: c.req.param('itemId'),
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-})
-    // CHECKOUT CART
-    .post('/:id/checkout', zValidator('param', z.object({ id: z.uuid() })), zValidator('json', z.object({
-    firstName: z.string().min(1),
-    lastName: z.string().min(1),
-    email: z.email().optional(),
-    phone: z.string().optional(),
-    address: z.string().min(1),
-    city: z.string().min(1),
-    deliveryZoneId: z.uuid(),
-    paymentMethod: z.enum(['cod', 'online']),
-    paystackReference: z.string().optional(),
-    ifUnmodifiedSince: z.string().datetime().optional(),
-    fbc: z.string().optional(), // Facebook Click ID for attribution
-    fbp: z.string().optional(), // Facebook Browser ID for attribution
-})), async (c) => {
-    try {
-        const { id: cartId } = c.req.valid('param');
-        const input = c.req.valid('json');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        const cart = await prisma.cart.findUnique({
-            where: { id: cartId },
-            include: CART_INCLUDE_FULL,
-        });
-        if (!cart) {
-            return c.json({ error: { code: 'CART_NOT_FOUND', message: 'Cart not found' } }, 404);
-        }
-        if (cart.expiresAt < new Date()) {
-            return c.json({ error: { code: 'CART_EXPIRED', message: 'Cart has expired' } }, 410);
-        }
-        if (cart.items.length === 0) {
-            return c.json({ error: { code: 'CART_EMPTY', message: 'Cart is empty' } }, 400);
-        }
-        // Queue Meta CAPI InitiateCheckout event
-        try {
-            const { enqueueInitiateCheckoutEvent } = await import('../../notifications/producers/meta-capi-producer');
-            const pricing = calculateCartCost(toPricingItems(cart));
-            const itemCount = cart.items.reduce((sum, item) => sum + item.quantity, 0);
-            await enqueueInitiateCheckoutEvent(c.env, {
-                cartId,
-                pixelId: cart.brand.metaPixelId,
-                brandSiteUrl: cart.brand.siteUrl,
-                cartTotal: pricing.total,
-                itemCount,
-                customerEmail: input.email || cart.customerEmail,
-                customerPhone: input.phone || cart.customerPhone,
-                clientIpAddress: c.req.header('cf-connecting-ip'),
-                clientUserAgent: c.req.header('user-agent'),
-                fbc: input.fbc,
-                fbp: input.fbp,
-            });
-        }
-        catch (error) {
-            console.error('Failed to queue Meta CAPI InitiateCheckout event:', error);
-            // Don't fail the checkout if CAPI queuing fails
-        }
-        // Concurrency check
-        const ifMatch = c.req.header('if-match');
-        if (ifMatch && ifMatch !== etagFrom(cart.updatedAt)) {
-            return c.json({ error: { code: 'PRECONDITION_FAILED', message: 'Cart has changed' } }, 412);
-        }
-        if (input.ifUnmodifiedSince && new Date(input.ifUnmodifiedSince).getTime() !== cart.updatedAt.getTime()) {
-            return c.json({ error: { code: 'PRECONDITION_FAILED', message: 'Cart has changed' } }, 412);
-        }
-        // Validate and load delivery zone
-        if (!input.deliveryZoneId) {
-            return c.json({ error: { code: 'MISSING_DELIVERY_ZONE', message: 'Select a delivery zone' } }, 400);
-        }
-        const zone = await prisma.deliveryZone.findFirst({
-            where: { id: input.deliveryZoneId, isActive: true, deletedAt: null },
-            include: { state: true },
-        });
-        if (!zone) {
-            return c.json({ error: { code: 'INVALID_DELIVERY_ZONE', message: 'Zone not available' } }, 400);
-        }
-        // Validate payment method against cart's available methods
-        if (!cart.availablePaymentMethods.includes(input.paymentMethod)) {
-            return c.json({ error: { code: 'PAYMENT_METHOD_NOT_AVAILABLE', message: 'Payment not available for selection' } }, 400);
-        }
-        // Calculate pricing with quantity discounts
-        const pricing = calculateCartCost(toPricingItems(cart));
-        // Compute delivery charge with free shipping threshold
-        const threshold = zone.freeShippingThreshold ? Number(zone.freeShippingThreshold) : null;
-        const base = Number(zone.deliveryCost);
-        const deliveryCharge = threshold !== null && pricing.subtotal >= threshold ? 0 : base;
-        const estimatedDays = zone.estimatedDays ?? null;
-        // Use the discount code already applied to the cart (if any)
-        let discountCodeRecord = null;
-        let discountAmount = 0;
-        let isRecoveredCart = false;
-        if (cart.appliedDiscountCodeId) {
-            discountCodeRecord = await prisma.discountCode.findUnique({
-                where: { id: cart.appliedDiscountCodeId },
-            });
-            // Validate discount is still active and valid
-            if (discountCodeRecord && discountCodeRecord.isActive) {
-                const now = new Date();
-                const isValid = (!discountCodeRecord.validFrom || discountCodeRecord.validFrom <= now) &&
-                    (!discountCodeRecord.validUntil || discountCodeRecord.validUntil > now) &&
-                    (!discountCodeRecord.brandId || discountCodeRecord.brandId === cart.brandId);
-                if (isValid) {
-                    // Calculate discount amount
-                    if (discountCodeRecord.type === 'percentage') {
-                        discountAmount = round(pricing.subtotal * (toNumber(discountCodeRecord.value) / 100));
-                        // Apply max discount cap if exists
-                        if (discountCodeRecord.maxDiscount) {
-                            const maxDiscountNum = toNumber(discountCodeRecord.maxDiscount);
-                            if (discountAmount > maxDiscountNum) {
-                                discountAmount = maxDiscountNum;
-                            }
-                        }
-                    }
-                    else if (discountCodeRecord.type === 'fixed') {
-                        discountAmount = Math.min(toNumber(discountCodeRecord.value), pricing.subtotal);
-                    }
-                    // Check if this is a recovery code
-                    if (discountCodeRecord.category === 'recovery') {
-                        isRecoveredCart = true;
-                    }
-                }
-                else {
-                    // Discount is no longer valid, ignore it
-                    discountCodeRecord = null;
-                }
-            }
-            else {
-                discountCodeRecord = null;
-            }
-        }
-        // Consider cart recovered if it's at least 1 hour old (when first recovery attempt is sent)
-        const oneHourMs = 60 * 60 * 1000;
-        if (!isRecoveredCart && Date.now() - new Date(cart.createdAt).getTime() >= oneHourMs) {
-            isRecoveredCart = true;
-        }
-        // Calculate final total
-        const finalTotal = round(Math.max(0, pricing.subtotal + deliveryCharge - discountAmount));
-        // Build order items
-        const orderItems = cart.items.map((item) => {
-            const variant = item.variant;
-            const product = variant.product;
-            let finalPrice = toNumber(variant.price);
-            // Apply quantity discount if available
-            if (product.quantityDiscounts && typeof product.quantityDiscounts === 'object') {
-                const discounts = product.quantityDiscounts;
-                const applicableQuantities = Object.keys(discounts)
-                    .map(Number)
-                    .filter((qty) => item.quantity >= qty)
-                    .sort((a, b) => b - a);
-                if (applicableQuantities.length > 0) {
-                    const discountPercent = discounts[applicableQuantities[0].toString()];
-                    finalPrice = round(toNumber(variant.price) * (1 - discountPercent / 100));
-                }
-            }
-            return {
-                variantId: variant.id,
-                quantity: item.quantity,
-                priceAtPurchase: finalPrice,
-            };
-        });
-        // Create order in transaction with conversion tracking
-        const result = await prisma.$transaction(async (tx) => {
-            // Create order
-            const order = await tx.order.create({
-                data: {
-                    brandId: cart.brandId,
-                    firstName: input.firstName,
-                    lastName: input.lastName,
-                    phone: (input.phone || cart.customerPhone), // Use checkout phone or fallback to cart phone
-                    email: input.email || cart.customerEmail, // Use checkout email or fallback to cart email
-                    address: input.address,
-                    city: input.city,
-                    deliveryZoneId: zone.id,
-                    deliveryCharge,
-                    estimatedDays,
-                    totalPrice: finalTotal,
-                    discountCodeId: discountCodeRecord?.id,
-                    discountAmount: discountAmount > 0 ? discountAmount : null,
-                    paymentMethod: input.paymentMethod,
-                    paystackReference: input.paystackReference,
-                    status: 'pending',
-                    items: {
-                        create: orderItems,
-                    },
-                },
-                include: ORDER_INCLUDE_FULL,
-            });
-            // If discount code was used, create usage log and increment count
-            if (discountCodeRecord && discountAmount > 0) {
-                await tx.discountCodeUsage.create({
-                    data: {
-                        discountCodeId: discountCodeRecord.id,
-                        orderId: order.id,
-                        customerPhone: input.phone || cart.customerPhone || '',
-                        discountAmount,
-                        originalAmount: pricing.subtotal,
-                    },
-                });
-                await tx.discountCode.update({
-                    where: { id: discountCodeRecord.id },
-                    data: { usageCount: { increment: 1 } },
-                });
-            }
-            // Track conversion: Update cart with order ID and recovery status
-            await tx.cart.update({
-                where: { id: cartId },
-                data: {
-                    convertedToOrderId: order.id,
-                    wasRecovered: isRecoveredCart,
-                },
-            });
-            return order;
-        });
-        // Queue order confirmation notification
-        try {
-            const { enqueueOrderNotification } = await import('../../notifications/producers/order-notification');
-            await enqueueOrderNotification(c.env, 'order_confirmation', result.id);
-        }
-        catch (error) {
-            console.error('Failed to queue order confirmation notification:', error);
-            // Don't fail the checkout if notification fails
-        }
-        // Queue Meta CAPI Purchase event
-        try {
-            const { enqueuePurchaseEvent } = await import('../../notifications/producers/meta-capi-producer');
-            await enqueuePurchaseEvent(c.env, result, {
-                clientIpAddress: c.req.header('cf-connecting-ip'),
-                clientUserAgent: c.req.header('user-agent'),
-                fbc: input.fbc,
-                fbp: input.fbp,
-            });
-        }
-        catch (error) {
-            console.error('Failed to queue Meta CAPI Purchase event:', error);
-            // Don't fail the checkout if CAPI queuing fails
-        }
-        return c.json(formatOrderResponse(result), 201);
-    }
-    catch (error) {
-        console.error('Error checking out cart:', error);
-        // CRITICAL: Checkout failures directly impact revenue
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'fatal', // Highest severity - revenue impacting
-            tags: {
-                error_code: 'CHECKOUT_ERROR',
-                endpoint: 'POST /carts/:id/checkout',
-            },
-            extra: {
-                cartId: c.req.param('id'),
-            },
-            honoContext: c,
-        });
-        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
-    }
-});
-export default app;