@instockng/api-client 1.0.3 → 1.0.4

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

@@ -0,0 +1,631 @@
+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';
+const app = new Hono()
+    // CREATE CART
+    .post('/', zValidator('json', z.object({
+    brandSlug: z.string(),
+})), async (c) => {
+    try {
+        const input = c.req.valid('json');
+        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) {
+            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);
+        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);
+        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);
+        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) {
+            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) {
+                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);
+        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);
+        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);
+        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);
+        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);
+        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);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+});
+export default app;

package/dist/apps/backend/src/routes/public/delivery-zones.d.ts

@@ -0,0 +1,35 @@
+import { AppContext } from '../../types';
+declare const app: import("hono/hono-base").HonoBase<AppContext, {
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                id: string;
+                name: string;
+                zones: {
+                    id: string;
+                    name: string;
+                    deliveryCost: number;
+                    freeShippingThreshold: number;
+                    allowCOD: boolean;
+                    allowOnline: boolean;
+                    waybillOnly: boolean;
+                    estimatedDays: number;
+                }[];
+            }[];
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {};
+            output: {
+                error: {
+                    code: string;
+                    message: any;
+                };
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+}, "/">;
+export default app;