@instockng/api-client 1.0.6 → 1.0.8

package/dist/apps/backend/src/http-app.d.ts

@@ -0,0 +1,40 @@
+/**
+ * HTTP application setup
+ * This module is lazy-loaded only when handling HTTP requests
+ */
+import publicOrders from './routes/public/orders';
+import publicProducts from './routes/public/products';
+import publicCarts from './routes/public/carts';
+import publicDeliveryZones from './routes/public/delivery-zones';
+import publicBrands from './routes/public/brands';
+import adminOrders from './routes/admin/orders';
+import adminBrands from './routes/admin/brands';
+import adminProducts from './routes/admin/products';
+import adminVariants from './routes/admin/variants';
+import adminWarehouses from './routes/admin/warehouses';
+import adminInventory from './routes/admin/inventory';
+import adminCustomers from './routes/admin/customers';
+import adminStats from './routes/admin/stats';
+import adminAbandonedCarts from './routes/admin/abandoned-carts';
+import adminDiscountCodes from './routes/admin/discount-codes';
+import adminDeliveryZones from './routes/admin/delivery-zones';
+export type CartsRPC = typeof publicCarts;
+export type OrdersRPC = typeof publicOrders;
+export type ProductsRPC = typeof publicProducts;
+export type DeliveryZonesRPC = typeof publicDeliveryZones;
+export type BrandsRPC = typeof publicBrands;
+export type AdminOrdersRPC = typeof adminOrders;
+export type AdminBrandsRPC = typeof adminBrands;
+export type AdminProductsRPC = typeof adminProducts;
+export type AdminVariantsRPC = typeof adminVariants;
+export type AdminWarehousesRPC = typeof adminWarehouses;
+export type AdminInventoryRPC = typeof adminInventory;
+export type AdminCustomersRPC = typeof adminCustomers;
+export type AdminStatsRPC = typeof adminStats;
+export type AdminAbandonedCartsRPC = typeof adminAbandonedCarts;
+export type AdminDiscountCodesRPC = typeof adminDiscountCodes;
+export type AdminDeliveryZonesRPC = typeof adminDeliveryZones;
+/**
+ * Create the HTTP application with all routes and middleware
+ */
+export declare function createHttpApp(): import("@hono/zod-openapi").OpenAPIHono<import("./types").AppContext, {}, "/">;

package/dist/apps/backend/src/http-app.js

@@ -0,0 +1,134 @@
+/**
+ * HTTP application setup
+ * This module is lazy-loaded only when handling HTTP requests
+ */
+import { Hono } from 'hono';
+import { corsMiddleware } from './middleware/cors';
+import { clerkAuthMiddleware } from './middleware/clerk-auth';
+import { createOpenAPIApp, openapiConfig } from './lib/openapi';
+import { swaggerUI } from '@hono/swagger-ui';
+import { HTTPException } from 'hono/http-exception';
+import { captureException, captureMessage } from './lib/sentry';
+// Public routes
+import publicOrders from './routes/public/orders';
+import publicProducts from './routes/public/products';
+import publicCarts from './routes/public/carts';
+import publicDeliveryZones from './routes/public/delivery-zones';
+import publicBrands from './routes/public/brands';
+// Admin routes
+import adminOrders from './routes/admin/orders';
+import adminBrands from './routes/admin/brands';
+import adminProducts from './routes/admin/products';
+import adminVariants from './routes/admin/variants';
+import adminWarehouses from './routes/admin/warehouses';
+import adminInventory from './routes/admin/inventory';
+import adminCustomers from './routes/admin/customers';
+import adminStats from './routes/admin/stats';
+import adminAbandonedCarts from './routes/admin/abandoned-carts';
+import adminDiscountCodes from './routes/admin/discount-codes';
+import adminDeliveryZones from './routes/admin/delivery-zones';
+/**
+ * Create the HTTP application with all routes and middleware
+ */
+export function createHttpApp() {
+    const app = createOpenAPIApp();
+    // Global CORS middleware
+    app.use('*', corsMiddleware);
+    // Health check
+    app.get('/', (c) => {
+        return c.json({
+            name: 'OMS API',
+            version: '1.0.0',
+            status: 'healthy',
+        });
+    });
+    app.get('/health', (c) => {
+        return c.json({ status: 'ok' });
+    });
+    // OpenAPI documentation
+    app.doc('/openapi.json', openapiConfig);
+    // Swagger UI
+    app.get('/docs', swaggerUI({ url: '/openapi.json' }));
+    // Admin API routes (Clerk auth protected)
+    // Note: Must be mounted BEFORE public routes to match /v1/admin/* before /v1/*
+    const adminApp = new Hono();
+    adminApp.use('*', clerkAuthMiddleware);
+    adminApp
+        .route('/orders', adminOrders)
+        .route('/brands', adminBrands)
+        .route('/products', adminProducts)
+        .route('/variants', adminVariants)
+        .route('/warehouses', adminWarehouses)
+        .route('/inventory', adminInventory)
+        .route('/customers', adminCustomers)
+        .route('/stats', adminStats)
+        .route('/abandoned-carts', adminAbandonedCarts)
+        .route('/discount-codes', adminDiscountCodes)
+        .route('/delivery-zones', adminDeliveryZones);
+    app.route('/v1/admin', adminApp);
+    // Public API routes (CORS protected, no API key needed)
+    // UUID-based resources (orders, carts) are self-authenticating
+    // Rate limiting and CORS provide abuse protection
+    const publicApi = createOpenAPIApp();
+    publicApi.route('/orders', publicOrders);
+    publicApi.route('/products', publicProducts);
+    publicApi.route('/carts', publicCarts);
+    publicApi.route('/delivery-zones', publicDeliveryZones);
+    publicApi.route('/brands', publicBrands);
+    app.route('/v1', publicApi);
+    // 404 handler
+    app.notFound((c) => {
+        return c.json({
+            error: {
+                code: 'NOT_FOUND',
+                message: 'The requested endpoint does not exist',
+            },
+        }, 404);
+    });
+    // Error handler
+    app.onError((err, c) => {
+        if (err instanceof HTTPException && err.status === 400) {
+            // Track validation errors with sampling
+            captureMessage('Malformed JSON in request body', {
+                level: 'warning',
+                tags: {
+                    error_code: 'BAD_REQUEST',
+                    route: c.req.path,
+                    method: c.req.method,
+                },
+                extra: {
+                    url: c.req.url,
+                },
+                sampleRate: 0.1, // 10% sampling
+            });
+            return c.json({
+                error: {
+                    code: 'BAD_REQUEST',
+                    message: 'Malformed JSON in request body',
+                },
+            }, 400);
+        }
+        // Capture unhandled errors - these are critical
+        console.error('Unhandled error:', err);
+        captureException(err, {
+            level: 'error',
+            tags: {
+                error_code: 'INTERNAL_ERROR',
+                route: c.req.path,
+                method: c.req.method,
+            },
+            extra: {
+                url: c.req.url,
+                error_message: err instanceof Error ? err.message : String(err),
+            },
+            honoContext: c,
+        });
+        return c.json({
+            error: {
+                code: 'INTERNAL_ERROR',
+                message: 'An unexpected error occurred',
+            },
+        }, 500);
+    });
+    return app;
+}

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '@prisma/client';
+export type BrandDBResponse = Prisma.BrandGetPayload<{}>;
+export declare function formatBrandResponse(brand: BrandDBResponse): {
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    siteUrl: string;
+    domain: string;
+    metaPixelId: string | null;
+};

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

@@ -0,0 +1,8 @@
+export function formatBrandResponse(brand) {
+    return {
+        ...brand,
+        createdAt: brand.createdAt.toISOString(),
+        updatedAt: brand.updatedAt.toISOString(),
+        deletedAt: brand.deletedAt ? brand.deletedAt.toISOString() : null,
+    };
+}

package/dist/apps/backend/src/lib/cart-helpers.d.ts

@@ -0,0 +1,282 @@
+import { PrismaClient } from '@prisma/client';
+/**
+ * Standard include pattern for cart queries with all necessary relations
+ */
+export declare const CART_INCLUDE_FULL: {
+    readonly brand: true;
+    readonly deliveryZone: true;
+    readonly recoveryDiscountCode: true;
+    readonly items: {
+        readonly include: {
+            readonly variant: {
+                readonly include: {
+                    readonly product: true;
+                };
+            };
+        };
+    };
+};
+/**
+ * Include pattern for cart item queries that need the parent cart
+ */
+export declare const CART_ITEM_WITH_CART_INCLUDE: {
+    readonly cart: {
+        readonly include: {
+            readonly brand: true;
+        };
+    };
+};
+/**
+ * Include pattern for order creation with discount code
+ */
+export declare const ORDER_INCLUDE_FULL: {
+    readonly brand: true;
+    readonly deliveryZone: {
+        readonly include: {
+            readonly state: true;
+        };
+    };
+    readonly items: {
+        readonly include: {
+            readonly variant: {
+                readonly include: {
+                    readonly product: true;
+                };
+            };
+            readonly warehouse: true;
+        };
+    };
+};
+type CartWithRelations = Awaited<ReturnType<typeof getCartWithRelations>>;
+declare function getCartWithRelations(prisma: PrismaClient, cartId: string): Promise<{
+    brand: {
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+    };
+    deliveryZone: {
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+        brandId: string | null;
+        stateId: string;
+        deliveryCost: import("@prisma/client/runtime/library").Decimal;
+        freeShippingThreshold: import("@prisma/client/runtime/library").Decimal | null;
+        allowCOD: boolean;
+        allowOnline: boolean;
+        waybillOnly: boolean;
+        estimatedDays: number | null;
+        noteTitle: string | null;
+        noteContent: string | null;
+        isActive: boolean;
+    };
+    recoveryDiscountCode: {
+        id: string;
+        type: string;
+        value: import("@prisma/client/runtime/library").Decimal;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+        brandId: string | null;
+        isActive: boolean;
+        code: string;
+        minPurchase: import("@prisma/client/runtime/library").Decimal | null;
+        maxDiscount: import("@prisma/client/runtime/library").Decimal | null;
+        usageLimit: number | null;
+        usageCount: number;
+        perCustomerLimit: number | null;
+        validFrom: Date;
+        validUntil: Date | null;
+        isAutoApply: boolean;
+        description: string | null;
+        category: string;
+        createdBy: string | null;
+    };
+    items: ({
+        variant: {
+            product: {
+                id: string;
+                name: string;
+                slug: string;
+                createdAt: Date;
+                updatedAt: Date;
+                deletedAt: Date | null;
+                brandId: string;
+                isActive: boolean;
+                description: string | null;
+                thumbnailUrl: string | null;
+                quantityDiscounts: import("@prisma/client/runtime/library").JsonValue | null;
+            };
+        } & {
+            id: string;
+            name: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            isActive: boolean;
+            thumbnailUrl: string | null;
+            productId: string;
+            sku: string;
+            price: import("@prisma/client/runtime/library").Decimal;
+            trackInventory: boolean;
+            lowStockThreshold: number | null;
+        };
+    } & {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        variantId: string;
+        quantity: number;
+        cartId: string;
+    })[];
+} & {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    brandId: string;
+    customerPhone: string | null;
+    customerFirstName: string | null;
+    customerLastName: string | null;
+    expiresAt: Date;
+    deliveryZoneId: string | null;
+    deliveryZoneLockedAt: Date | null;
+    availablePaymentMethods: import("@prisma/client").$Enums.PaymentMethod[];
+    recoveryAttempts: number;
+    lastRecoveryAttemptAt: Date | null;
+    recoveryDiscountCodeId: string | null;
+    convertedToOrderId: string | null;
+    wasRecovered: boolean;
+    appliedDiscountCodeId: string | null;
+    customerEmail: string | null;
+}>;
+/**
+ * Validate cart exists and is not expired
+ */
+export declare function validateCart(prisma: PrismaClient, cartId: string): Promise<{
+    cart: CartWithRelations | null;
+    error?: {
+        code: string;
+        message: string;
+        status: number;
+    };
+}>;
+/**
+ * Build cart response with pricing calculations
+ */
+export declare function buildCartResponse(prisma: PrismaClient, cart: NonNullable<CartWithRelations>): Promise<{
+    id: string;
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    customerPhone: string;
+    customerEmail: string;
+    customerFirstName: string;
+    customerLastName: string;
+    availablePaymentMethods: import("@prisma/client").$Enums.PaymentMethod[];
+    deliveryZone: {
+        id: string;
+        name: string;
+    };
+    recoveryAttempts: number;
+    lastRecoveryAttemptAt: Date;
+    recoveryDiscountCode: {
+        id: string;
+        type: string;
+        value: import("@prisma/client/runtime/library").Decimal;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+        brandId: string | null;
+        isActive: boolean;
+        code: string;
+        minPurchase: import("@prisma/client/runtime/library").Decimal | null;
+        maxDiscount: import("@prisma/client/runtime/library").Decimal | null;
+        usageLimit: number | null;
+        usageCount: number;
+        perCustomerLimit: number | null;
+        validFrom: Date;
+        validUntil: Date | null;
+        isAutoApply: boolean;
+        description: string | null;
+        category: string;
+        createdBy: string | null;
+    };
+    items: {
+        id: string;
+        variant: {
+            price: number;
+            product: {
+                id: string;
+                name: string;
+                slug: string;
+                createdAt: Date;
+                updatedAt: Date;
+                deletedAt: Date | null;
+                brandId: string;
+                isActive: boolean;
+                description: string | null;
+                thumbnailUrl: string | null;
+                quantityDiscounts: import("@prisma/client/runtime/library").JsonValue | null;
+            };
+            id: string;
+            name: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            isActive: boolean;
+            thumbnailUrl: string | null;
+            productId: string;
+            sku: string;
+            trackInventory: boolean;
+            lowStockThreshold: number | null;
+        };
+        quantity: number;
+        basePrice: number;
+        discountPercent: number;
+        finalPrice: number;
+        subtotal: number;
+    }[];
+    pricing: {
+        subtotal: number;
+        deliveryCharge: number;
+        discount: import("./cart-response").DiscountInfo;
+        total: number;
+    };
+    createdAt: string;
+    updatedAt: string;
+    expiresAt: string;
+    convertedToOrderId: string;
+    wasRecovered: boolean;
+    recoveryUrl: string;
+}>;
+/**
+ * Generate ETag from date
+ */
+export declare function etagFrom(date: Date): string;
+/**
+ * Derive payment methods from delivery zone
+ */
+export declare function paymentFromZone(zone: {
+    allowCOD: boolean;
+    allowOnline: boolean;
+    waybillOnly: boolean;
+}): ('cod' | 'online')[];
+export {};

package/dist/apps/backend/src/lib/cart-helpers.js

@@ -0,0 +1,121 @@
+import { buildCartResponseWithPricing } from './cart-response';
+import { captureMessage, getSampleRate } from './sentry';
+/**
+ * Standard include pattern for cart queries with all necessary relations
+ */
+export const CART_INCLUDE_FULL = {
+    brand: true,
+    deliveryZone: true,
+    recoveryDiscountCode: true,
+    items: {
+        include: {
+            variant: {
+                include: {
+                    product: true,
+                },
+            },
+        },
+    },
+};
+/**
+ * Include pattern for cart item queries that need the parent cart
+ */
+export const CART_ITEM_WITH_CART_INCLUDE = {
+    cart: {
+        include: {
+            brand: true
+        }
+    },
+};
+/**
+ * Include pattern for order creation with discount code
+ */
+export const ORDER_INCLUDE_FULL = {
+    brand: true,
+    deliveryZone: { include: { state: true } },
+    items: {
+        include: {
+            variant: {
+                include: {
+                    product: true,
+                },
+            },
+            warehouse: true,
+        },
+    },
+};
+async function getCartWithRelations(prisma, cartId) {
+    return await prisma.cart.findUnique({
+        where: { id: cartId },
+        include: CART_INCLUDE_FULL,
+    });
+}
+/**
+ * Validate cart exists and is not expired
+ */
+export async function validateCart(prisma, cartId) {
+    const cart = await getCartWithRelations(prisma, cartId);
+    if (!cart) {
+        // Track cart not found errors with sampling
+        captureMessage('Cart not found', {
+            level: 'info',
+            tags: {
+                error_code: 'CART_NOT_FOUND',
+            },
+            extra: {
+                cartId,
+            },
+            sampleRate: getSampleRate('CART_NOT_FOUND'), // 5% sampling
+        });
+        return {
+            cart: null,
+            error: { code: 'CART_NOT_FOUND', message: 'Cart not found', status: 404 }
+        };
+    }
+    if (cart.expiresAt < new Date()) {
+        // Track cart expiration with sampling
+        const daysSinceExpiry = Math.floor((new Date().getTime() - cart.expiresAt.getTime()) / (1000 * 60 * 60 * 24));
+        captureMessage('Cart expired', {
+            level: 'info',
+            tags: {
+                error_code: 'CART_EXPIRED',
+                brand: cart.brand?.slug || 'unknown',
+            },
+            extra: {
+                cartId,
+                expiresAt: cart.expiresAt.toISOString(),
+                daysSinceExpiry,
+                lastUpdated: cart.updatedAt.toISOString(),
+            },
+            sampleRate: getSampleRate('CART_EXPIRED'), // 10% sampling
+        });
+        return {
+            cart: null,
+            error: { code: 'CART_EXPIRED', message: 'Cart has expired', status: 410 }
+        };
+    }
+    return { cart };
+}
+/**
+ * Build cart response with pricing calculations
+ */
+export async function buildCartResponse(prisma, cart) {
+    return await buildCartResponseWithPricing(prisma, cart);
+}
+/**
+ * Generate ETag from date
+ */
+export function etagFrom(date) {
+    return `W/"${date.getTime()}"`;
+}
+/**
+ * Derive payment methods from delivery zone
+ */
+export function paymentFromZone(zone) {
+    const out = [];
+    if (zone.allowOnline)
+        out.push('online');
+    if (zone.allowCOD && !zone.waybillOnly)
+        out.push('cod');
+    return out;
+}

package/dist/apps/backend/src/lib/cart-recovery.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Abandoned cart recovery scheduler
+ * Handles automatic sending of recovery WhatsApp messages at different intervals
+ */
+import type { PrismaClient } from '@prisma/client';
+import type { CartWithItemsAndBrand } from './cart-response';
+/**
+ * Recovery schedule configuration
+ */
+export declare const RECOVERY_SCHEDULE: {
+    attemptNumber: number;
+    hoursAfterAbandonment: number;
+    discountPercent: number;
+}[];
+/**
+ * Find carts eligible for recovery message at specific attempt
+ */
+export declare function findCartsForRecovery(prisma: PrismaClient, attemptNumber: number): Promise<any[]>;
+/**
+ * Prepares a cart for a recovery attempt.
+ * This is the key atomic operation that:
+ * 1. Updates the recovery attempt number to prevent duplicate messages
+ * 2. Creates/updates the recovery discount code
+ * 3. Applies the discount to the cart
+ * This should be called *before* queueing any notifications.
+ */
+export declare function prepareCartForRecoveryAttempt(prisma: PrismaClient, cart: CartWithItemsAndBrand, attemptNumber: number): Promise<{
+    success: boolean;
+    cartWithDiscount?: CartWithItemsAndBrand;
+}>;