@instockng/api-client 1.0.6 → 1.0.8

package/dist/apps/backend/src/routes/admin/orders.js

@@ -0,0 +1,552 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { createOrderSchema, updateOrderSchema, updateOrderStatusSchema } from '../../validators/order';
+import { getPrismaClient } from '../../lib/prisma';
+import { getPaginationParams, createPaginatedResponse } from '../../lib/utils';
+import { adjustInventory } from '../../lib/inventory';
+import { OrderStatus } from '@prisma/client';
+import { formatOrderResponse } from '../../lib/order-response';
+import { markOrderAsProspect } from '../../lib/order-recovery';
+import { ORDER_INCLUDE_FULL } from '../../lib/cart-helpers';
+import { captureException } from '../../lib/sentry';
+const app = new Hono()
+    .post('/', zValidator('json', createOrderSchema), async (c) => {
+    try {
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        // Validate brand exists and is active
+        const brand = await prisma.brand.findFirst({
+            where: { slug: input.brandSlug, deletedAt: null },
+        });
+        if (!brand) {
+            return c.json({ error: { code: 'INVALID_BRAND', message: 'Brand not found or inactive' } }, 404);
+        }
+        // Validate all variants exist and are active
+        const variants = await prisma.productVariant.findMany({
+            where: {
+                sku: { in: input.items.map((item) => item.sku) },
+                isActive: true,
+                deletedAt: null,
+            },
+            include: {
+                product: true,
+            },
+        });
+        if (variants.length !== input.items.length) {
+            return c.json({ error: { code: 'INVALID_VARIANT', message: 'One or more SKUs not found or inactive' } }, 404);
+        }
+        // Group items by product to calculate quantity discounts at product level
+        const itemsByProduct = new Map();
+        for (const item of input.items) {
+            const variant = variants.find((v) => v.sku === item.sku);
+            if (!variant)
+                throw new Error('Variant not found');
+            const productId = variant.product.id;
+            if (!itemsByProduct.has(productId)) {
+                itemsByProduct.set(productId, []);
+            }
+            itemsByProduct.get(productId).push(item);
+        }
+        // Calculate total price with product-level quantity discounts
+        let subtotal = 0;
+        const orderItems = input.items.map((item) => {
+            const variant = variants.find((v) => v.sku === item.sku);
+            if (!variant)
+                throw new Error('Variant not found');
+            const basePrice = Number(variant.price);
+            let discountPercent = 0;
+            // Calculate total quantity for this product across all variants
+            const productItems = itemsByProduct.get(variant.product.id) || [];
+            const totalProductQuantity = productItems.reduce((sum, i) => sum + i.quantity, 0);
+            // Check if product has quantity discounts and apply based on total product quantity
+            if (variant.product.quantityDiscounts && typeof variant.product.quantityDiscounts === 'object') {
+                const discounts = variant.product.quantityDiscounts;
+                // Find the highest quantity tier that applies to total product quantity
+                const applicableDiscounts = Object.entries(discounts)
+                    .filter(([qty]) => totalProductQuantity >= parseInt(qty))
+                    .sort(([a], [b]) => parseInt(b) - parseInt(a)); // Sort descending
+                if (applicableDiscounts.length > 0) {
+                    discountPercent = applicableDiscounts[0][1];
+                }
+            }
+            // Apply discount to this variant's price
+            const discountedPrice = Math.round(basePrice * (1 - discountPercent / 100));
+            const itemTotal = discountedPrice * item.quantity;
+            subtotal += itemTotal;
+            return {
+                variantId: variant.id,
+                quantity: item.quantity,
+                priceAtPurchase: discountedPrice,
+            };
+        });
+        // Apply discount if provided
+        const discount = input.discount || 0;
+        const totalPrice = Math.max(0, subtotal + input.deliveryCharge - discount);
+        // Create order
+        const order = await prisma.order.create({
+            data: {
+                brandId: brand.id,
+                firstName: input.firstName,
+                lastName: input.lastName,
+                email: input.email,
+                phone: input.phone,
+                address: input.address,
+                city: input.city,
+                deliveryZoneId: input.deliveryZoneId,
+                deliveryCharge: input.deliveryCharge,
+                totalPrice,
+                paymentMethod: input.paymentMethod,
+                paystackReference: input.paystackReference,
+                status: 'pending',
+                items: {
+                    create: orderItems,
+                },
+            },
+            include: ORDER_INCLUDE_FULL
+        });
+        // Queue confirmation email
+        try {
+            const { enqueueOrderNotification } = await import('../../notifications/producers/order-notification');
+            await enqueueOrderNotification(c.env, 'order_confirmation', order.id);
+        }
+        catch (error) {
+            console.error('Failed to queue WhatsApp confirmation:', error);
+            // Don't fail the order creation if queuing fails
+        }
+        return c.json(formatOrderResponse(order), 201);
+    }
+    catch (error) {
+        console.error('Error creating order:', error);
+        // CRITICAL: Admin order creation failures
+        captureException(error instanceof Error ? error : new Error(String(error)), {
+            level: 'fatal',
+            tags: {
+                error_code: 'ADMIN_ORDER_CREATE_ERROR',
+                endpoint: 'POST /admin/orders',
+            },
+            honoContext: c,
+        });
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+}).get('/', async (c) => {
+    try {
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const query = c.req.query();
+        const { page, limit, skip } = getPaginationParams({
+            page: query.page ? parseInt(query.page) : undefined,
+            limit: query.limit ? parseInt(query.limit) : undefined,
+        });
+        const where = { deletedAt: null };
+        if (query.brandId)
+            where.brandId = query.brandId;
+        if (query.status)
+            where.status = query.status;
+        if (query.paymentMethod)
+            where.paymentMethod = query.paymentMethod;
+        if (query.search) {
+            where.OR = [
+                { orderNumber: isNaN(parseInt(query.search)) ? undefined : parseInt(query.search) },
+                { phone: { contains: query.search } },
+                { firstName: { contains: query.search, mode: 'insensitive' } },
+                { lastName: { contains: query.search, mode: 'insensitive' } },
+                { address: { contains: query.search, mode: 'insensitive' } },
+            ].filter((item) => Object.values(item).some((v) => v !== undefined));
+        }
+        if (query.startDate)
+            where.createdAt = { ...where.createdAt, gte: new Date(query.startDate) };
+        if (query.endDate)
+            where.createdAt = { ...where.createdAt, lte: new Date(query.endDate) };
+        const [orders, total] = await Promise.all([
+            prisma.order.findMany({
+                where,
+                include: ORDER_INCLUDE_FULL,
+                skip,
+                take: limit,
+                orderBy: { createdAt: 'desc' },
+            }),
+            prisma.order.count({ where }),
+        ]);
+        return c.json(createPaginatedResponse(orders.map(formatOrderResponse), total, page, limit));
+    }
+    catch (error) {
+        console.error('List orders error:', error);
+        return c.json({
+            error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve orders' },
+        }, 500);
+    }
+}).get('/:id', zValidator('param', z.object({ id: z.string().uuid() })), async (c) => {
+    try {
+        const { id } = c.req.valid('param');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const order = await prisma.order.findFirst({
+            where: { id, deletedAt: null },
+            include: ORDER_INCLUDE_FULL,
+        });
+        if (!order) {
+            return c.json({
+                error: { code: 'ORDER_NOT_FOUND', message: 'Order not found' },
+            }, 404);
+        }
+        return c.json(formatOrderResponse(order));
+    }
+    catch (error) {
+        return c.json({
+            error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve order' },
+        }, 500);
+    }
+}).patch('/:id', zValidator('param', z.object({ id: z.string().uuid() })), zValidator('json', updateOrderSchema), async (c) => {
+    try {
+        const { id } = c.req.valid('param');
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const order = await prisma.order.findFirst({
+            where: { id, deletedAt: null },
+            include: { brand: true },
+        });
+        if (!order) {
+            return c.json({
+                error: { code: 'ORDER_NOT_FOUND', message: 'Order not found' },
+            }, 404);
+        }
+        // Handle items update if provided
+        if (input.items) {
+            // Delete existing items and create new ones
+            await prisma.orderItem.deleteMany({
+                where: { orderId: id },
+            });
+            // Fetch variants by SKU
+            const variants = await prisma.productVariant.findMany({
+                where: {
+                    sku: { in: input.items.map((item) => item.sku) },
+                    isActive: true,
+                    deletedAt: null,
+                },
+                include: {
+                    product: {
+                        include: {
+                            brand: true,
+                        },
+                    },
+                },
+            });
+            if (variants.length !== input.items.length) {
+                return c.json({
+                    error: { code: 'INVALID_VARIANT', message: 'One or more SKUs not found or inactive' },
+                }, 404);
+            }
+            // Create order items with quantity discount calculation
+            const orderItemsData = input.items.map((item) => {
+                const variant = variants.find((v) => v.sku === item.sku);
+                const product = variant.product;
+                // Apply quantity discount if available
+                let finalPrice = Number(variant.price);
+                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 = Math.round(Number(variant.price) * (1 - discountPercent / 100));
+                    }
+                }
+                return {
+                    orderId: id,
+                    variantId: variant.id,
+                    quantity: item.quantity,
+                    priceAtPurchase: finalPrice,
+                };
+            });
+            await prisma.orderItem.createMany({
+                data: orderItemsData,
+            });
+            // Calculate subtotal with quantity discounts
+            const subtotal = orderItemsData.reduce((sum, item) => {
+                return sum + Number(item.priceAtPurchase) * item.quantity;
+            }, 0);
+            const deliveryCharge = input.deliveryCharge ?? Number(order.deliveryCharge);
+            const discount = input.discount ?? 0;
+            const totalPrice = Math.max(0, subtotal + deliveryCharge - discount);
+            // Update order with new total and other fields
+            const updatedOrder = await prisma.order.update({
+                where: { id },
+                data: {
+                    firstName: input.firstName ?? order.firstName,
+                    lastName: input.lastName ?? order.lastName,
+                    email: input.email ?? order.email,
+                    phone: input.phone ?? order.phone,
+                    address: input.address ?? order.address,
+                    city: input.city ?? order.city,
+                    deliveryCharge,
+                    paymentMethod: (input.paymentMethod ?? order.paymentMethod),
+                    paystackReference: input.paystackReference ?? order.paystackReference,
+                    totalPrice,
+                },
+                include: ORDER_INCLUDE_FULL
+            });
+            return c.json(updatedOrder);
+        }
+        // Update order without changing items (just customer info, delivery, payment method, etc.)
+        const deliveryCharge = input.deliveryCharge ?? Number(order.deliveryCharge);
+        // If discount changed, recalculate total
+        let totalPrice = Number(order.totalPrice);
+        if (input.discount !== undefined || input.deliveryCharge !== undefined) {
+            // Get current items to recalculate
+            const currentItems = await prisma.orderItem.findMany({
+                where: { orderId: id },
+            });
+            const subtotal = currentItems.reduce((sum, item) => {
+                return sum + Number(item.priceAtPurchase) * item.quantity;
+            }, 0);
+            const discount = input.discount ?? 0;
+            totalPrice = Math.max(0, subtotal + deliveryCharge - discount);
+        }
+        const updatedOrder = await prisma.order.update({
+            where: { id },
+            data: {
+                firstName: input.firstName,
+                lastName: input.lastName,
+                email: input.email,
+                phone: input.phone,
+                address: input.address,
+                city: input.city,
+                deliveryCharge: input.deliveryCharge,
+                paymentMethod: input.paymentMethod,
+                paystackReference: input.paystackReference,
+                totalPrice,
+            },
+            include: ORDER_INCLUDE_FULL
+        });
+        return c.json(formatOrderResponse(updatedOrder));
+    }
+    catch (error) {
+        return c.json({
+            error: { code: 'INTERNAL_ERROR', message: error?.message || 'Failed to update order' },
+        }, 500);
+    }
+}).patch('/:id/status', zValidator('param', z.object({ id: z.string().uuid() })), zValidator('json', updateOrderStatusSchema), async (c) => {
+    try {
+        const { id } = c.req.valid('param');
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const order = await prisma.order.findFirst({
+            where: { id, deletedAt: null },
+            include: {
+                items: true,
+                brand: true,
+            },
+        });
+        if (!order) {
+            return c.json({
+                error: { code: 'ORDER_NOT_FOUND', message: 'Order not found' },
+            }, 404);
+        }
+        // Track inventory adjustment transitions to prevent duplicate adjustments
+        const previousStatus = order.status;
+        const newStatus = input.status;
+        // Statuses where inventory has been deducted
+        const inventoryDeductedStatuses = ['shipped', 'delivered'];
+        const inventoryRestoredStatuses = ['pending', 'cancelled', 'returned'];
+        const wasInventoryDeducted = inventoryDeductedStatuses.includes(previousStatus);
+        const shouldRestoreInventory = wasInventoryDeducted && inventoryRestoredStatuses.includes(newStatus);
+        const shouldDeductInventory = newStatus === 'shipped' && !inventoryDeductedStatuses.includes(previousStatus);
+        // Restore inventory if transitioning from shipped/delivered to pending/cancelled/returned
+        if (shouldRestoreInventory) {
+            await prisma.$transaction(async (tx) => {
+                // Get all order items with warehouses
+                const orderItemsWithWarehouses = await tx.orderItem.findMany({
+                    where: {
+                        orderId: id,
+                        warehouseId: { not: null }
+                    },
+                    include: {
+                        variant: true,
+                    },
+                });
+                for (const orderItem of orderItemsWithWarehouses) {
+                    if (orderItem.variant && orderItem.variant.trackInventory && orderItem.warehouseId) {
+                        // Credit inventory back (positive quantity)
+                        await adjustInventory(tx, {
+                            variantId: orderItem.variantId,
+                            warehouseId: orderItem.warehouseId,
+                            quantity: orderItem.quantity, // Positive to add back
+                            type: 'adjustment',
+                            reason: `Order #${order.orderNumber} status changed from ${previousStatus} to ${newStatus} - inventory restored`,
+                            orderId: order.id,
+                            userId: c.get('dbUser')?.id,
+                        });
+                    }
+                }
+            });
+        }
+        // If status is "shipped", require warehouse selection and decrement inventory
+        if (newStatus === 'shipped' && previousStatus !== 'shipped') {
+            if (!input.warehouses || input.warehouses.length === 0) {
+                return c.json({
+                    error: { code: 'WAREHOUSE_REQUIRED', message: 'Warehouse selection required when shipping order' },
+                }, 400);
+            }
+            // Validate all order items have warehouse assigned
+            const orderItemIds = order.items.map((item) => item.id);
+            const providedItemIds = input.warehouses.map((w) => w.orderItemId);
+            if (orderItemIds.some((id) => !providedItemIds.includes(id))) {
+                return c.json({
+                    error: { code: 'INCOMPLETE_WAREHOUSE_ASSIGNMENT', message: 'All order items must have warehouse assigned' },
+                }, 400);
+            }
+            // Update warehouse assignments and decrement inventory (only if transitioning TO shipped)
+            await prisma.$transaction(async (tx) => {
+                for (const warehouseAssignment of input.warehouses) {
+                    const orderItem = order.items.find((item) => item.id === warehouseAssignment.orderItemId);
+                    if (!orderItem)
+                        continue;
+                    // Update order item with warehouse
+                    await tx.orderItem.update({
+                        where: { id: orderItem.id },
+                        data: { warehouseId: warehouseAssignment.warehouseId },
+                    });
+                    // Only adjust inventory if this is a NEW transition to shipped status
+                    if (shouldDeductInventory) {
+                        // Check if variant tracks inventory
+                        const variant = await tx.productVariant.findUnique({
+                            where: { id: orderItem.variantId },
+                        });
+                        if (variant && variant.trackInventory) {
+                            // Decrement inventory
+                            await adjustInventory(tx, {
+                                variantId: orderItem.variantId,
+                                warehouseId: warehouseAssignment.warehouseId,
+                                quantity: -orderItem.quantity,
+                                type: 'sale',
+                                reason: `Order #${order.orderNumber} shipped - inventory deducted`,
+                                orderId: order.id,
+                                userId: c.get('dbUser')?.id,
+                            });
+                        }
+                    }
+                }
+                // Update order status
+                await tx.order.update({
+                    where: { id },
+                    data: { status: input.status },
+                });
+            });
+            try {
+                const { enqueueOrderNotification } = await import('../../notifications/producers/order-notification');
+                await enqueueOrderNotification(c.env, 'order_shipped', order.id);
+            }
+            catch (error) {
+                console.error('Failed to queue order shipped notification:', error);
+            }
+        }
+        else if (newStatus === OrderStatus.prospect && previousStatus !== OrderStatus.prospect) {
+            // Handle prospect status with reason
+            if (!input.prospectReason) {
+                return c.json({
+                    error: { code: 'PROSPECT_REASON_REQUIRED', message: 'Prospect reason is required when setting status to prospect' },
+                }, 400);
+            }
+            // Use the markOrderAsProspect function to handle all the logic
+            await markOrderAsProspect(prisma, id, input.prospectReason, input.prospectNote || '', c.get('dbUser')?.id);
+            // Queue the first prospect recovery email immediately
+            // (manual contact already attempted, so no delay needed)
+            try {
+                const { enqueueProspectRecoveryNotification } = await import('../../notifications/producers/prospect-recovery-notification');
+                await enqueueProspectRecoveryNotification(c.env, 'prospect_recovery_reminder', id, 1);
+            }
+            catch (error) {
+                console.error('Failed to queue prospect recovery email:', error);
+                // Don't fail the status update if queuing fails
+            }
+        }
+        else {
+            // For other status updates, just update the status
+            await prisma.order.update({
+                where: { id },
+                data: {
+                    status: input.status,
+                    cancellationReason: input.cancellationReason,
+                },
+            });
+            try {
+                let messageType = null;
+                if (newStatus === 'delivered' && previousStatus !== 'delivered') {
+                    messageType = 'order_delivered';
+                }
+                else if ((newStatus === 'cancelled' && previousStatus !== 'cancelled') || (newStatus === 'returned' && previousStatus !== 'returned')) {
+                    messageType = 'order_cancelled';
+                }
+                if (messageType) {
+                    try {
+                        const { enqueueOrderNotification } = await import('../../notifications/producers/order-notification');
+                        await enqueueOrderNotification(c.env, messageType, order.id);
+                    }
+                    catch (error) {
+                        console.error('Failed to queue order status update notification:', error);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Failed to queue order status update notification:', error);
+            }
+            // Queue Meta CAPI ConfirmedPurchase event when order is delivered & paid
+            if (newStatus === 'delivered' && previousStatus !== 'delivered') {
+                try {
+                    const { enqueueConfirmedPurchaseEvent } = await import('../../notifications/producers/meta-capi-producer');
+                    // Fetch full order details with items for the CAPI event
+                    const fullOrder = await prisma.order.findFirst({
+                        where: { id, deletedAt: null },
+                        include: ORDER_INCLUDE_FULL,
+                    });
+                    if (fullOrder) {
+                        await enqueueConfirmedPurchaseEvent(c.env, fullOrder);
+                    }
+                }
+                catch (error) {
+                    console.error('Failed to queue Meta CAPI ConfirmedPurchase event:', error);
+                    // Don't fail the status update if CAPI queuing fails
+                }
+            }
+        }
+        // Fetch updated order to return
+        const updatedOrder = await prisma.order.findFirst({
+            where: { id, deletedAt: null },
+            include: ORDER_INCLUDE_FULL,
+        });
+        return c.json(formatOrderResponse(updatedOrder));
+    }
+    catch (error) {
+        // CRITICAL: Order status updates include inventory adjustments
+        captureException(error instanceof Error ? error : new Error(String(error)), {
+            level: 'fatal',
+            tags: {
+                error_code: 'ORDER_STATUS_UPDATE_ERROR',
+                endpoint: 'PATCH /admin/orders/:id/status',
+            },
+            extra: {
+                orderId: c.req.param('id'),
+            },
+            honoContext: c,
+        });
+        return c.json({
+            error: { code: 'INTERNAL_ERROR', message: 'Failed to update order status' },
+        }, 500);
+    }
+}).delete('/:id', zValidator('param', z.object({ id: z.string().uuid() })), async (c) => {
+    try {
+        const { id } = c.req.valid('param');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        await prisma.order.delete({
+            where: { id },
+        });
+        return c.status(204);
+    }
+    catch (error) {
+        return c.json({
+            error: { code: 'INTERNAL_ERROR', message: 'Failed to delete order' },
+        }, 500);
+    }
+});
+export default app;