@instockng/api-client 1.0.3 → 1.0.4

package/dist/apps/backend/src/routes/admin/abandoned-carts.js

@@ -0,0 +1,194 @@
+import { Hono } from 'hono';
+import { getPrismaClient } from '../../lib/prisma';
+import { calculateCartCost } from '../../lib/pricing';
+import { buildCartResponseWithPricing, toPricingItems } from '../../lib/cart-response';
+import { CART_INCLUDE_FULL } from '../../lib/cart-helpers';
+const app = new Hono()
+    // Note: Abandoned cart utility functions are not used here
+    // because they rely on a shared prisma instance which doesn't work in Workers
+    // We'll inline the logic in each endpoint instead
+    // List abandoned carts
+    .get('/', async (c) => {
+    try {
+        const brandId = c.req.query('brandId');
+        const hoursInactive = parseInt(c.req.query('hoursInactive') || '24');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const cutoffTime = new Date(Date.now() - hoursInactive * 60 * 60 * 1000);
+        const whereClause = {
+            customerPhone: { not: null },
+            updatedAt: { lt: cutoffTime },
+            expiresAt: { gt: new Date() },
+            items: { some: {} },
+        };
+        if (brandId) {
+            whereClause.brandId = brandId;
+        }
+        const carts = await prisma.cart.findMany({
+            where: whereClause,
+            include: {
+                brand: true,
+                recoveryDiscountCode: true,
+                deliveryZone: true,
+                items: {
+                    include: {
+                        variant: {
+                            include: {
+                                product: true,
+                            },
+                        },
+                    },
+                },
+            },
+            orderBy: {
+                updatedAt: 'asc',
+            },
+        });
+        // Calculate pricing for each cart
+        const cartsWithPricing = await Promise.all(carts.map((cart) => buildCartResponseWithPricing(prisma, cart)));
+        return c.json({
+            carts: cartsWithPricing,
+            total: cartsWithPricing.length,
+        });
+    }
+    catch (error) {
+        console.error('Error fetching abandoned carts:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Get abandoned cart statistics
+    .get('/stats', async (c) => {
+    try {
+        const brandId = c.req.query('brandId');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const now = new Date();
+        const last24Hours = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+        const last7Days = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+        const whereClause = {
+            expiresAt: { gt: now },
+            items: { some: {} },
+        };
+        if (brandId) {
+            whereClause.brandId = brandId;
+        }
+        const totalAbandoned = await prisma.cart.count({
+            where: {
+                ...whereClause,
+                customerPhone: { not: null },
+                updatedAt: { lt: last24Hours },
+            },
+        });
+        const abandonedLast7Days = await prisma.cart.count({
+            where: {
+                ...whereClause,
+                customerPhone: { not: null },
+                updatedAt: { lt: last24Hours, gt: last7Days },
+            },
+        });
+        const activeCarts = await prisma.cart.count({
+            where: {
+                ...whereClause,
+                updatedAt: { gte: last24Hours },
+            },
+        });
+        const abandonedCarts = await prisma.cart.findMany({
+            where: {
+                ...whereClause,
+                customerPhone: { not: null },
+                updatedAt: { lt: last24Hours },
+            },
+            include: CART_INCLUDE_FULL,
+        });
+        let totalValue = 0;
+        for (const cart of abandonedCarts) {
+            const pricing = calculateCartCost(toPricingItems(cart));
+            totalValue += pricing.subtotal;
+        }
+        // Calculate recovery metrics
+        const recoveredCarts = await prisma.cart.count({
+            where: {
+                ...whereClause,
+                convertedToOrderId: { not: null },
+                wasRecovered: true,
+            },
+        });
+        const recoveredCartsWithOrders = await prisma.cart.findMany({
+            where: {
+                ...whereClause,
+                convertedToOrderId: { not: null },
+                wasRecovered: true,
+            },
+            include: {
+                convertedOrder: true,
+            },
+        });
+        let revenueRecovered = 0;
+        let totalDiscountGiven = 0;
+        for (const cart of recoveredCartsWithOrders) {
+            if (cart.convertedOrder) {
+                revenueRecovered += parseFloat(cart.convertedOrder.totalPrice.toString());
+                // Estimate discount given (5%, 10%, or 15% based on recoveryAttempts)
+                const discountPercent = cart.recoveryAttempts === 1 ? 5 : cart.recoveryAttempts === 2 ? 10 : cart.recoveryAttempts === 3 ? 15 : 0;
+                const subtotal = parseFloat(cart.convertedOrder.totalPrice.toString()) + parseFloat(cart.convertedOrder.deliveryCharge.toString());
+                totalDiscountGiven += Math.round((subtotal / (1 - discountPercent / 100)) * (discountPercent / 100));
+            }
+        }
+        return c.json({
+            totalAbandoned,
+            abandonedLast7Days,
+            activeCarts,
+            totalValue,
+            averageValue: totalAbandoned > 0 ? Math.round(totalValue / totalAbandoned) : 0,
+            // Recovery metrics
+            totalRecovered: recoveredCarts,
+            recoveryRate: totalAbandoned > 0 ? Math.round((recoveredCarts / totalAbandoned) * 100) : 0,
+            revenueRecovered: Math.round(revenueRecovered),
+            totalDiscountGiven: Math.round(totalDiscountGiven),
+        });
+    }
+    catch (error) {
+        console.error('Error fetching abandoned cart stats:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Clean up expired carts
+    .post('/cleanup', async (c) => {
+    try {
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const result = await prisma.cart.deleteMany({
+            where: {
+                expiresAt: {
+                    lt: new Date(),
+                },
+            },
+        });
+        return c.json({
+            deletedCount: result.count,
+            message: `Cleaned up ${result.count} expired carts`,
+        });
+    }
+    catch (error) {
+        console.error('Error cleaning up expired carts:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Get specific cart details
+    .get('/:id', async (c) => {
+    try {
+        const cartId = c.req.param('id');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const cart = await prisma.cart.findUnique({
+            where: { id: cartId },
+            include: CART_INCLUDE_FULL,
+        });
+        if (!cart) {
+            return c.json({ error: { code: 'CART_NOT_FOUND', message: 'Cart not found' } }, 404);
+        }
+        const formattedCart = await buildCartResponseWithPricing(prisma, cart);
+        return c.json(formattedCart);
+    }
+    catch (error) {
+        console.error('Error fetching cart details:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+});
+export default app;

package/dist/apps/backend/src/routes/admin/brands.d.ts

@@ -0,0 +1,175 @@
+import { AppContext } from '../../types';
+declare const app: import("hono/hono-base").HonoBase<AppContext, {
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                name: string;
+                id: string;
+                slug: string;
+                logoUrl: string | null;
+                siteUrl: string;
+                domain: string;
+                metaPixelId: string | null;
+                createdAt: string;
+                updatedAt: string;
+                deletedAt: string;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: {
+                    code: string;
+                    message: string;
+                };
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+} & {
+    "/:id": {
+        $get: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: {
+                    code: string;
+                    message: string;
+                };
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                name: string;
+                id: string;
+                slug: string;
+                logoUrl: string | null;
+                siteUrl: string;
+                domain: string;
+                metaPixelId: string | null;
+                createdAt: string;
+                updatedAt: string;
+                deletedAt: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: {
+                    code: string;
+                    message: string;
+                };
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+} & {
+    "/": {
+        $post: {
+            input: {};
+            output: {
+                name: string;
+                id: string;
+                slug: string;
+                logoUrl: string | null;
+                siteUrl: string;
+                domain: string;
+                metaPixelId: string | null;
+                createdAt: string;
+                updatedAt: string;
+                deletedAt: string;
+            };
+            outputFormat: "json";
+            status: 201;
+        } | {
+            input: {};
+            output: {
+                error: {
+                    code: string;
+                    message: string;
+                };
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+} & {
+    "/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                name: string;
+                id: string;
+                slug: string;
+                logoUrl: string | null;
+                siteUrl: string;
+                domain: string;
+                metaPixelId: string | null;
+                createdAt: string;
+                updatedAt: string;
+                deletedAt: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: {
+                    code: string;
+                    message: string;
+                };
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+} & {
+    "/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+}, "/">;
+export default app;

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

@@ -0,0 +1,118 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { createBrandSchema, updateBrandSchema } from '../../validators/brand';
+import { getPrismaClient } from '../../lib/prisma';
+import { generateSlug } from '../../lib/utils';
+const app = new Hono()
+    // List all brands
+    .get('/', async (c) => {
+    try {
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const brands = await prisma.brand.findMany({
+            where: { deletedAt: null },
+            orderBy: { name: 'asc' },
+        });
+        return c.json(brands);
+    }
+    catch (error) {
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve brands' } }, 500);
+    }
+})
+    // Get brand by ID
+    .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 brand = await prisma.brand.findFirst({
+            where: { id },
+        });
+        if (!brand) {
+            return c.json({
+                error: { code: 'BRAND_NOT_FOUND', message: 'Brand not found' },
+            }, 404);
+        }
+        return c.json(brand);
+    }
+    catch (error) {
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve brand' } }, 500);
+    }
+})
+    // Create brand
+    .post('/', zValidator('json', createBrandSchema), async (c) => {
+    try {
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        // Generate slug from name
+        let slug = generateSlug(input.name);
+        // Ensure slug is unique by appending number if needed
+        let slugExists = await prisma.brand.findUnique({ where: { slug } });
+        let counter = 1;
+        while (slugExists) {
+            slug = `${generateSlug(input.name)}-${counter}`;
+            slugExists = await prisma.brand.findUnique({ where: { slug } });
+            counter++;
+        }
+        const brand = await prisma.brand.create({
+            data: {
+                ...input,
+                slug,
+            },
+        });
+        return c.json(brand, 201);
+    }
+    catch (error) {
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to create brand' } }, 500);
+    }
+})
+    // Update brand
+    .patch('/:id', zValidator('param', z.object({ id: z.string().uuid() })), zValidator('json', updateBrandSchema), async (c) => {
+    try {
+        const { id } = c.req.valid('param');
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        // If name is being updated, regenerate slug
+        let updateData = { ...input };
+        if (input.name) {
+            let slug = generateSlug(input.name);
+            // Ensure slug is unique (excluding current brand)
+            let slugExists = await prisma.brand.findFirst({
+                where: { slug, id: { not: id } },
+            });
+            let counter = 1;
+            while (slugExists) {
+                slug = `${generateSlug(input.name)}-${counter}`;
+                slugExists = await prisma.brand.findFirst({
+                    where: { slug, id: { not: id } },
+                });
+                counter++;
+            }
+            updateData.slug = slug;
+        }
+        const brand = await prisma.brand.update({
+            where: { id },
+            data: updateData,
+        });
+        return c.json(brand);
+    }
+    catch (error) {
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to update brand' } }, 500);
+    }
+})
+    // Soft delete brand
+    .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);
+        // Soft delete by setting deletedAt timestamp
+        await prisma.brand.update({
+            where: { id },
+            data: { deletedAt: new Date() },
+        });
+        return c.status(204);
+    }
+    catch (error) {
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to delete brand' } }, 500);
+    }
+});
+export default app;