@instockng/api-client 1.0.9 → 1.0.10

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

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