@instockng/api-client 1.0.8 → 1.0.10

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

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

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

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

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

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

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