@instockng/api-client 1.0.6 → 1.0.8

package/dist/apps/backend/src/lib/order-recovery.js

@@ -0,0 +1,378 @@
+import { OrderStatus, ProspectReason, NoteType } from '@prisma/client';
+import { subHours, addHours } from 'date-fns';
+import { generateDiscountCode } from './discount';
+import { ORDER_INCLUDE_FULL } from './cart-helpers';
+// Recovery schedule configuration
+// Note: First email sent immediately after marking as prospect (since manual contact already attempted)
+export const PROSPECT_RECOVERY_SCHEDULE = [
+    {
+        attempt: 1,
+        delayHours: 0, // Immediate - manual contact already attempted
+        discountPercentage: 0,
+        template: 'ProspectRecoveryReminder',
+        subject: 'We tried reaching you about your order'
+    },
+    {
+        attempt: 2,
+        delayHours: 8,
+        discountPercentage: 5,
+        template: 'ProspectRecovery',
+        subject: 'Your order is waiting - 5% discount inside'
+    },
+    {
+        attempt: 3,
+        delayHours: 24, // Next day
+        discountPercentage: 10,
+        template: 'ProspectRecovery',
+        subject: 'Still interested? Save 10% today'
+    },
+    {
+        attempt: 4,
+        delayHours: 48, // Day 2
+        discountPercentage: 15,
+        template: 'ProspectRecoveryFinal',
+        subject: 'Final chance - 15% off expires soon'
+    }
+];
+// Auto-cancel after 72 hours
+export const AUTO_CANCEL_HOURS = 72;
+/**
+ * Find prospect orders ready for recovery attempt
+ */
+export async function findProspectOrdersForRecovery(prisma, attemptNumber) {
+    const schedule = PROSPECT_RECOVERY_SCHEDULE[attemptNumber - 1];
+    if (!schedule) {
+        throw new Error(`Invalid recovery attempt number: ${attemptNumber}`);
+    }
+    const windowStart = subHours(new Date(), schedule.delayHours);
+    const windowEnd = subHours(windowStart, 1); // 1 hour window
+    return prisma.order.findMany({
+        where: {
+            status: OrderStatus.prospect,
+            recoveryAttempts: attemptNumber - 1,
+            prospectSince: {
+                gte: windowEnd,
+                lt: windowStart
+            },
+            deletedAt: null,
+        },
+        include: {
+            items: {
+                include: {
+                    variant: {
+                        include: {
+                            product: true
+                        }
+                    }
+                }
+            },
+            brand: true,
+            recoveryDiscountCode: true,
+            deliveryZone: true
+        }
+    });
+}
+/**
+ * Prepare order for recovery attempt (atomic operation)
+ */
+export async function prepareOrderForRecoveryAttempt(prisma, orderId, attemptNumber, brandId) {
+    const schedule = PROSPECT_RECOVERY_SCHEDULE[attemptNumber - 1];
+    if (!schedule) {
+        throw new Error(`Invalid recovery attempt number: ${attemptNumber}`);
+    }
+    return prisma.$transaction(async (tx) => {
+        // Update recovery attempts atomically
+        const updateResult = await tx.order.updateMany({
+            where: {
+                id: orderId,
+                status: OrderStatus.prospect,
+                recoveryAttempts: attemptNumber - 1
+            },
+            data: {
+                recoveryAttempts: attemptNumber,
+                lastRecoveryAttemptAt: new Date()
+            }
+        });
+        // If no rows updated, order was already claimed by another process
+        if (updateResult.count === 0) {
+            return null;
+        }
+        // Handle discount code creation/update
+        if (schedule.discountPercentage > 0) {
+            const order = await tx.order.findUnique({
+                where: { id: orderId },
+                include: { recoveryDiscountCode: true }
+            });
+            if (!order)
+                return null;
+            let discountCodeId = order.recoveryDiscountCodeId;
+            if (!discountCodeId) {
+                // Create new recovery discount code
+                const code = generateDiscountCode();
+                const discount = await tx.discountCode.create({
+                    data: {
+                        code,
+                        brandId,
+                        type: 'percentage',
+                        value: schedule.discountPercentage,
+                        usageLimit: 1,
+                        category: 'recovery',
+                        description: `Order recovery discount - ${schedule.discountPercentage}% off`,
+                        validFrom: new Date(),
+                        validUntil: addHours(new Date(), 72), // Valid for 72 hours
+                        isActive: true
+                    }
+                });
+                discountCodeId = discount.id;
+                // Link discount to order
+                await tx.order.update({
+                    where: { id: orderId },
+                    data: { recoveryDiscountCodeId: discountCodeId }
+                });
+            }
+            else if (order.recoveryDiscountCode) {
+                // Update existing discount if percentage increased
+                const currentPercentage = order.recoveryDiscountCode.value.toNumber();
+                if (schedule.discountPercentage > currentPercentage) {
+                    await tx.discountCode.update({
+                        where: { id: discountCodeId },
+                        data: {
+                            value: schedule.discountPercentage.toString(),
+                            description: `Order recovery discount - ${schedule.discountPercentage}% off`,
+                            validUntil: addHours(new Date(), 72) // Extend validity
+                        }
+                    });
+                }
+            }
+        }
+        // Return the prepared order
+        return tx.order.findUnique({
+            where: { id: orderId },
+            include: {
+                items: {
+                    include: {
+                        variant: {
+                            include: {
+                                product: true
+                            }
+                        }
+                    }
+                },
+                brand: true,
+                recoveryDiscountCode: true,
+                deliveryZone: true,
+                notes: {
+                    orderBy: { createdAt: 'desc' },
+                    take: 5
+                }
+            }
+        });
+    });
+}
+/**
+ * Convert prospect order back to pending when customer confirms
+ */
+export async function confirmProspectOrder(prisma, orderId, userActionToken) {
+    return prisma.$transaction(async (tx) => {
+        // Validate order and token
+        const order = await tx.order.findFirst({
+            where: {
+                id: orderId,
+                userActionToken,
+                status: OrderStatus.prospect
+            },
+            include: {
+                recoveryDiscountCode: true
+            }
+        });
+        if (!order) {
+            throw new Error('Invalid order or token');
+        }
+        // Apply recovery discount if exists and not already applied
+        let updateData = {
+            status: OrderStatus.pending,
+            wasRecovered: true
+        };
+        if (order.recoveryDiscountCodeId && !order.discountCodeId) {
+            const discountAmount = order.totalPrice
+                .mul(order.recoveryDiscountCode.value)
+                .div(100);
+            updateData.discountCodeId = order.recoveryDiscountCodeId;
+            updateData.discountAmount = discountAmount;
+        }
+        // Update order status
+        await tx.order.update({
+            where: { id: orderId },
+            data: updateData
+        });
+        // Add confirmation note
+        await tx.orderNote.create({
+            data: {
+                orderId,
+                type: NoteType.status_change,
+                note: `Order recovered by customer via email link. Status changed from prospect to pending.`,
+                metadata: {
+                    recoveryAttempt: order.recoveryAttempts,
+                    discountApplied: order.recoveryDiscountCode?.value.toNumber()
+                }
+            }
+        });
+        // Return the full order with all relations
+        return tx.order.findUnique({
+            where: { id: orderId },
+            include: ORDER_INCLUDE_FULL
+        });
+    });
+}
+/**
+ * Auto-cancel prospect orders that have exceeded the time limit
+ */
+export async function autoCancelProspectOrders(prisma) {
+    const cutoffTime = subHours(new Date(), AUTO_CANCEL_HOURS);
+    const ordersToCancel = await prisma.order.findMany({
+        where: {
+            status: OrderStatus.prospect,
+            prospectSince: {
+                lte: cutoffTime
+            }
+        },
+        select: {
+            id: true,
+            orderNumber: true
+        }
+    });
+    const results = await Promise.all(ordersToCancel.map(async (order) => {
+        try {
+            await prisma.$transaction(async (tx) => {
+                // Update order status
+                await tx.order.update({
+                    where: { id: order.id },
+                    data: {
+                        status: OrderStatus.cancelled,
+                        cancellationReason: 'No response to confirmation attempts after 72 hours'
+                    }
+                });
+                // Add cancellation note
+                await tx.orderNote.create({
+                    data: {
+                        orderId: order.id,
+                        type: NoteType.status_change,
+                        note: 'Order auto-cancelled after 72 hours with no customer response',
+                        metadata: {
+                            autoCancelled: true,
+                            prospectDuration: AUTO_CANCEL_HOURS
+                        }
+                    }
+                });
+            });
+            return { orderId: order.id, success: true };
+        }
+        catch (error) {
+            console.error(`Failed to auto-cancel order ${order.id}:`, error);
+            return { orderId: order.id, success: false, error };
+        }
+    }));
+    return {
+        processed: results.length,
+        succeeded: results.filter(r => r.success).length,
+        failed: results.filter(r => !r.success).length
+    };
+}
+/**
+ * Get recovery statistics for dashboard
+ */
+export async function getProspectRecoveryStats(prisma, brandId) {
+    const whereClause = brandId ? { brandId } : {};
+    const [totalProspects, recovered, cancelled, stillProspect] = await Promise.all([
+        prisma.order.count({
+            where: {
+                ...whereClause,
+                prospectSince: { not: null }
+            }
+        }),
+        prisma.order.count({
+            where: {
+                ...whereClause,
+                wasRecovered: true
+            }
+        }),
+        prisma.order.count({
+            where: {
+                ...whereClause,
+                prospectSince: { not: null },
+                status: OrderStatus.cancelled
+            }
+        }),
+        prisma.order.count({
+            where: {
+                ...whereClause,
+                status: OrderStatus.prospect
+            }
+        })
+    ]);
+    const recoveryRate = totalProspects > 0
+        ? ((recovered / totalProspects) * 100).toFixed(2)
+        : '0.00';
+    const revenueRecovered = await prisma.order.aggregate({
+        where: {
+            ...whereClause,
+            wasRecovered: true,
+            status: {
+                in: [OrderStatus.shipped, OrderStatus.delivered]
+            }
+        },
+        _sum: {
+            totalPrice: true
+        }
+    });
+    return {
+        totalProspects,
+        recovered,
+        cancelled,
+        stillProspect,
+        recoveryRate: `${recoveryRate}%`,
+        revenueRecovered: revenueRecovered._sum.totalPrice?.toNumber() || 0
+    };
+}
+/**
+ * Mark order as prospect with reason
+ */
+export async function markOrderAsProspect(prisma, orderId, reason, notes, userId) {
+    return prisma.$transaction(async (tx) => {
+        // Update order status
+        const order = await tx.order.update({
+            where: { id: orderId },
+            data: {
+                status: OrderStatus.prospect,
+                prospectSince: new Date(),
+                prospectReason: reason,
+                recoveryAttempts: 1, // First email sent immediately
+                lastRecoveryAttemptAt: new Date()
+            }
+        });
+        // Create prospect reason note
+        const reasonLabels = {
+            [ProspectReason.no_answer]: 'No answer',
+            [ProspectReason.thinking]: 'Thinking about it',
+            [ProspectReason.price_concern]: 'Concerned about price',
+            [ProspectReason.will_call_back]: 'Will call back',
+            [ProspectReason.unclear_commitment]: 'Unclear commitment',
+            [ProspectReason.payment_issue]: 'Payment issue',
+            [ProspectReason.other]: 'Other'
+        };
+        await tx.orderNote.create({
+            data: {
+                orderId,
+                type: NoteType.prospect_reason,
+                note: `Order set to prospect. Reason: ${reasonLabels[reason]}${notes ? ` - ${notes}` : ''}`,
+                createdBy: userId,
+                metadata: {
+                    previousStatus: OrderStatus.pending,
+                    prospectReason: reason,
+                    customNote: notes
+                }
+            }
+        });
+        return order;
+    });
+}

package/dist/apps/backend/src/lib/order-response.d.ts

@@ -0,0 +1,138 @@
+import { Prisma } from '@prisma/client';
+export type OrderDBResponse = Prisma.OrderGetPayload<{
+    include: {
+        brand: true;
+        deliveryZone: {
+            include: {
+                state: true;
+            };
+        };
+        items: {
+            include: {
+                variant: {
+                    include: {
+                        product: true;
+                    };
+                };
+                warehouse: true;
+            };
+        };
+    };
+}>;
+export type OrderResponse = ReturnType<typeof formatOrderResponse>;
+export declare function formatOrderResponse(order: OrderDBResponse): {
+    subtotal: number;
+    deliveryCharge: number;
+    totalPrice: number;
+    discountAmount: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+    prospectSince: string;
+    lastRecoveryAttemptAt: string;
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    deliveryZone: {
+        deliveryCost: number;
+        freeShippingThreshold: number;
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        state: {
+            createdAt: string;
+            updatedAt: string;
+            deletedAt: string;
+            id: string;
+            name: string;
+            isActive: boolean;
+        };
+        id: string;
+        name: string;
+        brandId: string | null;
+        stateId: string;
+        allowCOD: boolean;
+        allowOnline: boolean;
+        waybillOnly: boolean;
+        estimatedDays: number | null;
+        noteTitle: string | null;
+        noteContent: string | null;
+        isActive: boolean;
+    };
+    items: {
+        priceAtPurchase: number;
+        variant: {
+            price: number;
+            createdAt: string;
+            updatedAt: string;
+            deletedAt: string;
+            product: {
+                createdAt: string;
+                updatedAt: string;
+                deletedAt: string;
+                id: string;
+                name: string;
+                slug: string;
+                brandId: string;
+                isActive: boolean;
+                description: string | null;
+                thumbnailUrl: string | null;
+                quantityDiscounts: Prisma.JsonValue | null;
+            };
+            id: string;
+            name: string | null;
+            isActive: boolean;
+            thumbnailUrl: string | null;
+            productId: string;
+            sku: string;
+            trackInventory: boolean;
+            lowStockThreshold: number | null;
+        };
+        warehouse: {
+            createdAt: string;
+            updatedAt: string;
+            deletedAt: string;
+            id: string;
+            name: string;
+            isActive: boolean;
+            address: string | null;
+            city: string | null;
+            state: string | null;
+        };
+        id: string;
+        orderId: string;
+        variantId: string;
+        warehouseId: string | null;
+        quantity: number;
+    }[];
+    email: string | null;
+    id: string;
+    brandId: string;
+    deliveryZoneId: string;
+    recoveryAttempts: number;
+    recoveryDiscountCodeId: string | null;
+    wasRecovered: boolean;
+    estimatedDays: number | null;
+    orderNumber: number;
+    firstName: string;
+    lastName: string;
+    phone: string;
+    address: string;
+    city: string;
+    discountCodeId: string | null;
+    paymentMethod: import("@prisma/client").$Enums.PaymentMethod;
+    paystackReference: string | null;
+    status: import("@prisma/client").$Enums.OrderStatus;
+    cancellationReason: string | null;
+    prospectReason: import("@prisma/client").$Enums.ProspectReason | null;
+    userActionToken: string;
+};

package/dist/apps/backend/src/lib/order-response.js

@@ -0,0 +1,61 @@
+import { toNumber } from './utils';
+export function formatOrderResponse(order) {
+    const subtotal = order.items.reduce((sum, item) => sum + (item.quantity * parseFloat(item.priceAtPurchase.toString())), 0);
+    return {
+        ...order,
+        subtotal,
+        deliveryCharge: toNumber(order.deliveryCharge),
+        totalPrice: toNumber(order.totalPrice),
+        discountAmount: order.discountAmount ? toNumber(order.discountAmount) : null,
+        createdAt: order.createdAt.toISOString(),
+        updatedAt: order.updatedAt.toISOString(),
+        deletedAt: order.deletedAt ? order.deletedAt.toISOString() : null,
+        prospectSince: order.prospectSince ? order.prospectSince.toISOString() : null,
+        lastRecoveryAttemptAt: order.lastRecoveryAttemptAt ? order.lastRecoveryAttemptAt.toISOString() : null,
+        brand: {
+            ...order.brand,
+            createdAt: order.brand.createdAt.toISOString(),
+            updatedAt: order.brand.updatedAt.toISOString(),
+            deletedAt: order.brand.deletedAt ? order.brand.deletedAt.toISOString() : null,
+        },
+        deliveryZone: {
+            ...order.deliveryZone,
+            deliveryCost: toNumber(order.deliveryZone.deliveryCost),
+            freeShippingThreshold: order.deliveryZone.freeShippingThreshold
+                ? toNumber(order.deliveryZone.freeShippingThreshold)
+                : null,
+            createdAt: order.deliveryZone.createdAt.toISOString(),
+            updatedAt: order.deliveryZone.updatedAt.toISOString(),
+            deletedAt: order.deliveryZone.deletedAt ? order.deliveryZone.deletedAt.toISOString() : null,
+            state: {
+                ...order.deliveryZone.state,
+                createdAt: order.deliveryZone.state.createdAt.toISOString(),
+                updatedAt: order.deliveryZone.state.updatedAt.toISOString(),
+                deletedAt: order.deliveryZone.state.deletedAt ? order.deliveryZone.state.deletedAt.toISOString() : null,
+            },
+        },
+        items: order.items.map((item) => ({
+            ...item,
+            priceAtPurchase: toNumber(item.priceAtPurchase),
+            variant: {
+                ...item.variant,
+                price: toNumber(item.variant.price),
+                createdAt: item.variant.createdAt.toISOString(),
+                updatedAt: item.variant.updatedAt.toISOString(),
+                deletedAt: item.variant.deletedAt ? item.variant.deletedAt.toISOString() : null,
+                product: {
+                    ...item.variant.product,
+                    createdAt: item.variant.product.createdAt.toISOString(),
+                    updatedAt: item.variant.product.updatedAt.toISOString(),
+                    deletedAt: item.variant.product.deletedAt ? item.variant.product.deletedAt.toISOString() : null,
+                },
+            },
+            warehouse: item.warehouse ? {
+                ...item.warehouse,
+                createdAt: item.warehouse.createdAt.toISOString(),
+                updatedAt: item.warehouse.updatedAt.toISOString(),
+                deletedAt: item.warehouse.deletedAt ? item.warehouse.deletedAt.toISOString() : null,
+            } : null,
+        })),
+    };
+}

package/dist/apps/backend/src/lib/pricing.d.ts

@@ -0,0 +1,39 @@
+import { Decimal } from '@prisma/client/runtime/library';
+export interface PriceCalculation {
+    basePrice: number;
+    discountPercent: number;
+    finalPrice: number;
+    subtotal: number;
+}
+/**
+ * Calculate discounted price for a product based on total quantity across all variants
+ */
+export declare function calculatePriceWithDiscount(basePrice: number | Decimal, quantity: number, totalProductQuantity: number, quantityDiscounts?: Record<string, number> | null): PriceCalculation;
+/**
+ * Calculate total cost for a collection of cart items
+ */
+export interface CartItemForCalculation {
+    variantId: string;
+    quantity: number;
+    variant: {
+        price: number | Decimal;
+        product: {
+            id: string;
+            quantityDiscounts?: Record<string, number> | null;
+        };
+    };
+}
+export interface CartCostCalculation {
+    items: Array<{
+        variantId: string;
+        quantity: number;
+        basePrice: number;
+        discountPercent: number;
+        finalPrice: number;
+        subtotal: number;
+    }>;
+    subtotal: number;
+    deliveryCharge: number;
+    total: number;
+}
+export declare function calculateCartCost(items: CartItemForCalculation[], deliveryCharge?: number | Decimal): CartCostCalculation;

package/dist/apps/backend/src/lib/pricing.js

@@ -0,0 +1,62 @@
+import { round, toNumber } from './utils';
+/**
+ * Calculate discounted price for a product based on total quantity across all variants
+ */
+export function calculatePriceWithDiscount(basePrice, quantity, totalProductQuantity, quantityDiscounts) {
+    let discountPercent = 0;
+    const basePriceNum = toNumber(basePrice);
+    // Check if product has quantity discounts and apply based on total product quantity
+    if (quantityDiscounts && typeof quantityDiscounts === 'object') {
+        // Find the highest quantity tier that applies to total product quantity
+        const applicableDiscounts = Object.entries(quantityDiscounts)
+            .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 finalPrice = round(basePriceNum * (1 - discountPercent / 100));
+    const subtotal = round(finalPrice * quantity);
+    return {
+        basePrice: basePriceNum,
+        discountPercent,
+        finalPrice,
+        subtotal,
+    };
+}
+export function calculateCartCost(items, deliveryCharge = 0) {
+    // Group items by product to calculate quantity discounts at product level
+    const itemsByProduct = new Map();
+    for (const item of items) {
+        const productId = item.variant.product.id;
+        if (!itemsByProduct.has(productId)) {
+            itemsByProduct.set(productId, []);
+        }
+        itemsByProduct.get(productId).push(item);
+    }
+    // Calculate prices for each item
+    let subtotal = 0;
+    const calculatedItems = items.map((item) => {
+        const basePrice = item.variant.price;
+        const productId = item.variant.product.id;
+        // Calculate total quantity for this product across all variants
+        const productItems = itemsByProduct.get(productId) || [];
+        const totalProductQuantity = productItems.reduce((sum, i) => sum + i.quantity, 0);
+        // Calculate price with discount
+        const calculation = calculatePriceWithDiscount(basePrice, item.quantity, totalProductQuantity, item.variant.product.quantityDiscounts);
+        subtotal += calculation.subtotal;
+        return {
+            variantId: item.variantId,
+            quantity: item.quantity,
+            ...calculation,
+        };
+    });
+    const deliveryChargeNum = toNumber(deliveryCharge);
+    return {
+        items: calculatedItems,
+        subtotal: round(subtotal),
+        deliveryCharge: deliveryChargeNum,
+        total: round(subtotal + deliveryChargeNum),
+    };
+}

package/dist/apps/backend/src/lib/prisma.d.ts

@@ -0,0 +1,9 @@
+import { PrismaClient } from '@prisma/client';
+/**
+ * Creates a new Prisma client for each request.
+ *
+ * IMPORTANT: In Cloudflare Workers, we CANNOT use a singleton pattern because
+ * I/O objects (like database connections) cannot be shared across different requests.
+ * Each request must create its own Prisma instance.
+ */
+export declare function getPrismaClient(databaseUrl: string): PrismaClient;