@instockng/api-client 1.0.3 → 1.0.4

package/dist/apps/backend/src/routes/admin/discount-codes.js

@@ -0,0 +1,418 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { getPrismaClient } from '../../lib/prisma';
+import { createDiscountCodeSchema, updateDiscountCodeSchema, bulkGenerateCodesSchema, } from '../../validators/discount-code';
+import { generateDiscountCode } from '../../lib/discount';
+import { formatDiscountCodeResponse } from '../../lib/discount-code-response';
+const app = new Hono()
+    // List discount codes
+    .get('/', async (c) => {
+    try {
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const page = parseInt(c.req.query('page') || '1');
+        const limit = parseInt(c.req.query('limit') || '20');
+        const category = c.req.query('category');
+        const brandId = c.req.query('brandId');
+        const isActive = c.req.query('isActive');
+        const search = c.req.query('search');
+        const where = {
+            deletedAt: null,
+        };
+        if (category && category !== 'all') {
+            where.category = category;
+        }
+        if (brandId) {
+            where.brandId = brandId;
+        }
+        if (isActive !== undefined) {
+            where.isActive = isActive === 'true';
+        }
+        if (search) {
+            where.OR = [
+                { code: { contains: search, mode: 'insensitive' } },
+                { description: { contains: search, mode: 'insensitive' } },
+            ];
+        }
+        const [codes, total] = await Promise.all([
+            prisma.discountCode.findMany({
+                where,
+                include: {
+                    brand: true,
+                    _count: {
+                        select: {
+                            usageLog: true,
+                        },
+                    },
+                },
+                orderBy: { createdAt: 'desc' },
+                skip: (page - 1) * limit,
+                take: limit,
+            }),
+            prisma.discountCode.count({ where }),
+        ]);
+        const enhancedCodes = codes.map(formatDiscountCodeResponse);
+        return c.json({
+            data: enhancedCodes,
+            pagination: {
+                page,
+                limit,
+                total,
+                totalPages: Math.ceil(total / limit),
+            },
+        });
+    }
+    catch (error) {
+        console.error('Error fetching discount codes:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Get single discount code
+    .get('/:id', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const code = await prisma.discountCode.findFirst({
+            where: { id, deletedAt: null },
+            include: {
+                brand: true,
+                _count: {
+                    select: {
+                        usageLog: true,
+                        orders: true,
+                    },
+                },
+            },
+        });
+        if (!code) {
+            return c.json({ error: { code: 'NOT_FOUND', message: 'Discount code not found' } }, 404);
+        }
+        return c.json({
+            ...formatDiscountCodeResponse(code),
+            _count: code._count ? {
+                usageLog: code._count.usageLog,
+                orders: code._count.orders,
+            } : null,
+        });
+    }
+    catch (error) {
+        console.error('Error fetching discount code:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Create discount code
+    .post('/', zValidator('json', createDiscountCodeSchema), async (c) => {
+    try {
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const user = c.get('user');
+        // Check if code already exists
+        const existing = await prisma.discountCode.findUnique({
+            where: { code: input.code },
+        });
+        if (existing) {
+            return c.json({ error: { code: 'CODE_EXISTS', message: 'Discount code already exists' } }, 400);
+        }
+        // If brandId provided, verify it exists
+        if (input.brandId) {
+            const brand = await prisma.brand.findFirst({
+                where: { id: input.brandId, deletedAt: null },
+            });
+            if (!brand) {
+                return c.json({ error: { code: 'BRAND_NOT_FOUND', message: 'Brand not found' } }, 404);
+            }
+        }
+        // Create the discount code
+        const discountCode = await prisma.discountCode.create({
+            data: {
+                code: input.code,
+                brandId: input.brandId ?? null,
+                type: input.type,
+                value: input.value,
+                description: input.description,
+                category: input.category ?? 'manual',
+                minPurchase: input.minPurchase ?? null,
+                maxDiscount: input.maxDiscount ?? null,
+                usageLimit: input.usageLimit ?? null,
+                perCustomerLimit: input.perCustomerLimit ?? null,
+                validFrom: input.validFrom ? new Date(input.validFrom) : new Date(),
+                validUntil: input.validUntil ? new Date(input.validUntil) : null,
+                isActive: input.isActive ?? true,
+                isAutoApply: input.isAutoApply ?? false,
+                createdBy: user?.id,
+            },
+            include: {
+                brand: true,
+            },
+        });
+        return c.json(formatDiscountCodeResponse(discountCode), 201);
+    }
+    catch (error) {
+        console.error('Error creating discount code:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Update discount code
+    .patch('/:id', zValidator('json', updateDiscountCodeSchema), async (c) => {
+    try {
+        const id = c.req.param('id');
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const existing = await prisma.discountCode.findFirst({
+            where: { id, deletedAt: null },
+        });
+        if (!existing) {
+            return c.json({ error: { code: 'NOT_FOUND', message: 'Discount code not found' } }, 404);
+        }
+        // If updating code, check for duplicates
+        if (input.code && input.code !== existing.code) {
+            const duplicate = await prisma.discountCode.findUnique({
+                where: { code: input.code },
+            });
+            if (duplicate) {
+                return c.json({ error: { code: 'CODE_EXISTS', message: 'Discount code already exists' } }, 400);
+            }
+        }
+        const updateData = {};
+        if (input.code !== undefined)
+            updateData.code = input.code;
+        if (input.type !== undefined)
+            updateData.type = input.type;
+        if (input.value !== undefined)
+            updateData.value = input.value;
+        if (input.description !== undefined)
+            updateData.description = input.description;
+        if (input.category !== undefined)
+            updateData.category = input.category;
+        if (input.minPurchase !== undefined)
+            updateData.minPurchase = input.minPurchase;
+        if (input.maxDiscount !== undefined)
+            updateData.maxDiscount = input.maxDiscount;
+        if (input.usageLimit !== undefined)
+            updateData.usageLimit = input.usageLimit;
+        if (input.perCustomerLimit !== undefined)
+            updateData.perCustomerLimit = input.perCustomerLimit;
+        if (input.validFrom !== undefined)
+            updateData.validFrom = new Date(input.validFrom);
+        if (input.validUntil !== undefined)
+            updateData.validUntil = input.validUntil ? new Date(input.validUntil) : null;
+        if (input.isActive !== undefined)
+            updateData.isActive = input.isActive;
+        if (input.isAutoApply !== undefined)
+            updateData.isAutoApply = input.isAutoApply;
+        const discountCode = await prisma.discountCode.update({
+            where: { id },
+            data: updateData,
+            include: {
+                brand: true,
+            },
+        });
+        return c.json(formatDiscountCodeResponse(discountCode));
+    }
+    catch (error) {
+        console.error('Error updating discount code:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Delete discount code (soft delete)
+    .delete('/:id', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const existing = await prisma.discountCode.findFirst({
+            where: { id, deletedAt: null },
+        });
+        if (!existing) {
+            return c.json({ error: { code: 'NOT_FOUND', message: 'Discount code not found' } }, 404);
+        }
+        await prisma.discountCode.update({
+            where: { id },
+            data: { deletedAt: new Date() },
+        });
+        return c.status(204);
+    }
+    catch (error) {
+        console.error('Error deleting discount code:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Get discount code analytics
+    .get('/:id/analytics', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const code = await prisma.discountCode.findFirst({
+            where: { id, deletedAt: null },
+            include: {
+                brand: true,
+                usageLog: {
+                    include: {
+                        order: true,
+                    },
+                    orderBy: {
+                        createdAt: 'desc',
+                    },
+                },
+            },
+        });
+        if (!code) {
+            return c.json({ error: { code: 'NOT_FOUND', message: 'Discount code not found' } }, 404);
+        }
+        // Calculate analytics
+        const totalUses = code.usageLog.length;
+        const totalDiscountGiven = code.usageLog.reduce((sum, log) => sum + log.discountAmount.toNumber(), 0);
+        const totalRevenue = code.usageLog.reduce((sum, log) => sum + log.order.totalPrice.toNumber(), 0);
+        const averageOrderValue = totalUses > 0 ? totalRevenue / totalUses : 0;
+        const averageDiscount = totalUses > 0 ? totalDiscountGiven / totalUses : 0;
+        // Unique customers
+        const uniqueCustomers = new Set(code.usageLog.map((log) => log.customerPhone)).size;
+        // Usage by date (last 30 days)
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+        const usageByDate = code.usageLog
+            .filter((log) => log.createdAt >= thirtyDaysAgo)
+            .reduce((acc, log) => {
+            const date = log.createdAt.toISOString().split('T')[0];
+            if (!acc[date]) {
+                acc[date] = { date, uses: 0, revenue: 0, discount: 0 };
+            }
+            acc[date].uses++;
+            acc[date].revenue += log.order.totalPrice;
+            acc[date].discount += log.discountAmount;
+            return acc;
+        }, {});
+        const usageByDateArray = Object.values(usageByDate).sort((a, b) => a.date.localeCompare(b.date));
+        // Top customers
+        const customerStats = code.usageLog.reduce((acc, log) => {
+            if (!acc[log.customerPhone]) {
+                acc[log.customerPhone] = { phone: log.customerPhone, uses: 0, revenue: 0, discount: 0 };
+            }
+            acc[log.customerPhone].uses++;
+            acc[log.customerPhone].revenue += log.order.totalPrice;
+            acc[log.customerPhone].discount += log.discountAmount;
+            return acc;
+        }, {});
+        const topCustomers = Object.values(customerStats)
+            .sort((a, b) => b.revenue - a.revenue)
+            .slice(0, 10);
+        // Recent usages with order details
+        const recentUsages = code.usageLog.slice(0, 20).map((log) => ({
+            id: log.id,
+            orderId: log.orderId,
+            customerPhone: log.customerPhone,
+            usedAt: log.createdAt,
+            discountAmount: log.discountAmount,
+            orderTotal: log.order.totalPrice,
+            order: {
+                id: log.order.id,
+                phone: log.order.phone,
+            },
+        }));
+        return c.json({
+            ...formatDiscountCodeResponse(code),
+            totalUses,
+            usagePercentage: code.usageLimit ? (totalUses / code.usageLimit) * 100 : null,
+            totalDiscountGiven,
+            totalRevenue,
+            averageOrderValue,
+            averageDiscount,
+            uniqueCustomers,
+            usageByDate: usageByDateArray,
+            topCustomers,
+            recentUsages,
+        });
+    }
+    catch (error) {
+        console.error('Error fetching discount code analytics:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Bulk generate discount codes
+    .post('/bulk-generate', zValidator('json', bulkGenerateCodesSchema), async (c) => {
+    try {
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const user = c.get('user');
+        const codes = [];
+        const codeRecords = [];
+        // Generate unique codes
+        for (let i = 0; i < input.count; i++) {
+            let code;
+            let attempts = 0;
+            const maxAttempts = 10;
+            do {
+                const randomPart = generateDiscountCode().replace('CART', '');
+                code = `${input.prefix}${randomPart}`;
+                attempts++;
+                if (attempts >= maxAttempts) {
+                    return c.json({ error: { code: 'GENERATION_FAILED', message: 'Failed to generate unique codes' } }, 500);
+                }
+            } while (codes.includes(code) || await prisma.discountCode.findUnique({ where: { code } }));
+            codes.push(code);
+            codeRecords.push({
+                code,
+                brandId: input.brandId ?? null,
+                type: input.type,
+                value: input.value,
+                description: input.description ?? `Bulk generated - ${input.prefix}`,
+                category: input.category ?? 'manual',
+                minPurchase: input.minPurchase ?? null,
+                maxDiscount: input.maxDiscount ?? null,
+                usageLimit: 1, // Each bulk code can only be used once by default
+                perCustomerLimit: input.perCustomerLimit ?? 1,
+                validFrom: input.validFrom ? new Date(input.validFrom) : new Date(),
+                validUntil: input.validUntil ? new Date(input.validUntil) : null,
+                isActive: input.isActive ?? true,
+                isAutoApply: false,
+                createdBy: user?.id,
+            });
+        }
+        // Create all codes in a transaction
+        await prisma.discountCode.createMany({
+            data: codeRecords,
+        });
+        return c.json({
+            codes,
+            count: codes.length,
+        }, 201);
+    }
+    catch (error) {
+        console.error('Error bulk generating codes:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+})
+    // Get overall discount code stats
+    .get('/stats/overview', async (c) => {
+    try {
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const [totalCodes, activeCodes, totalUsage, totalDiscountGiven, totalRevenue,] = await Promise.all([
+            prisma.discountCode.count({ where: { deletedAt: null } }),
+            prisma.discountCode.count({ where: { deletedAt: null, isActive: true } }),
+            prisma.discountCodeUsage.count(),
+            prisma.discountCodeUsage.aggregate({
+                _sum: { discountAmount: true },
+            }),
+            prisma.discountCodeUsage.aggregate({
+                _sum: { originalAmount: true },
+            }),
+        ]);
+        // Category breakdown
+        const codesByCategory = await prisma.discountCode.groupBy({
+            by: ['category'],
+            where: { deletedAt: null },
+            _count: true,
+        });
+        return c.json({
+            totalCodes,
+            activeCodes,
+            totalUsage,
+            totalDiscountGiven: totalDiscountGiven._sum.discountAmount || 0,
+            totalRevenue: totalRevenue._sum.originalAmount || 0,
+            codesByCategory,
+        });
+    }
+    catch (error) {
+        console.error('Error fetching discount code stats:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: error.message } }, 500);
+    }
+});
+export default app;

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

@@ -0,0 +1,273 @@
+import { AppContext } from '../../types';
+declare const app: import("hono/hono-base").HonoBase<AppContext, {
+    "/": {
+        $get: {
+            input: {};
+            output: {
+                variantId: string;
+                warehouseId: string;
+                sku: string;
+                productName: string;
+                name: string;
+                brandName: string;
+                warehouseName: string;
+                inventoryCount: number;
+                lowStockThreshold: number;
+                isLowStock: boolean;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: {
+                    code: string;
+                    message: string;
+                };
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+} & {
+    "/adjust": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        } | {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    "/transfer": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        } | {
+            input: {};
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    "/transactions": {
+        $get: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    type: import("@prisma/client").$Enums.InventoryTransactionType;
+                    quantity: number;
+                    balanceAfter: number;
+                    reason: string;
+                    orderId: string;
+                    orderNumber: number;
+                    userId: string;
+                    metadata: string | number | boolean | {
+                        [x: string]: string | number | boolean | /*elided*/ any | {
+                            [x: number]: string | number | boolean | /*elided*/ any | /*elided*/ any;
+                            length: number;
+                            toString: never;
+                            toLocaleString: never;
+                            pop: never;
+                            push: never;
+                            concat: never;
+                            join: never;
+                            reverse: never;
+                            shift: never;
+                            slice: never;
+                            sort: never;
+                            splice: never;
+                            unshift: never;
+                            indexOf: never;
+                            lastIndexOf: never;
+                            every: never;
+                            some: never;
+                            forEach: never;
+                            map: never;
+                            filter: never;
+                            reduce: never;
+                            reduceRight: never;
+                            find: never;
+                            findIndex: never;
+                            fill: never;
+                            copyWithin: never;
+                            entries: never;
+                            keys: never;
+                            values: never;
+                            includes: never;
+                            flatMap: never;
+                            flat: never;
+                            [Symbol.iterator]: never;
+                            readonly [Symbol.unscopables]: {
+                                [x: number]: boolean;
+                                length?: boolean;
+                                toString?: boolean;
+                                toLocaleString?: boolean;
+                                pop?: boolean;
+                                push?: boolean;
+                                concat?: boolean;
+                                join?: boolean;
+                                reverse?: boolean;
+                                shift?: boolean;
+                                slice?: boolean;
+                                sort?: boolean;
+                                splice?: boolean;
+                                unshift?: boolean;
+                                indexOf?: boolean;
+                                lastIndexOf?: boolean;
+                                every?: boolean;
+                                some?: boolean;
+                                forEach?: boolean;
+                                map?: boolean;
+                                filter?: boolean;
+                                reduce?: boolean;
+                                reduceRight?: boolean;
+                                find?: boolean;
+                                findIndex?: boolean;
+                                fill?: boolean;
+                                copyWithin?: boolean;
+                                entries?: boolean;
+                                keys?: boolean;
+                                values?: boolean;
+                                includes?: boolean;
+                                flatMap?: boolean;
+                                flat?: boolean;
+                            };
+                        };
+                    } | {
+                        [x: number]: string | number | boolean | {
+                            [x: string]: string | number | boolean | /*elided*/ any | /*elided*/ any;
+                        } | /*elided*/ any;
+                        length: number;
+                        toString: never;
+                        toLocaleString: never;
+                        pop: never;
+                        push: never;
+                        concat: never;
+                        join: never;
+                        reverse: never;
+                        shift: never;
+                        slice: never;
+                        sort: never;
+                        splice: never;
+                        unshift: never;
+                        indexOf: never;
+                        lastIndexOf: never;
+                        every: never;
+                        some: never;
+                        forEach: never;
+                        map: never;
+                        filter: never;
+                        reduce: never;
+                        reduceRight: never;
+                        find: never;
+                        findIndex: never;
+                        fill: never;
+                        copyWithin: never;
+                        entries: never;
+                        keys: never;
+                        values: never;
+                        includes: never;
+                        flatMap: never;
+                        flat: never;
+                        [Symbol.iterator]: never;
+                        readonly [Symbol.unscopables]: {
+                            [x: number]: boolean;
+                            length?: boolean;
+                            toString?: boolean;
+                            toLocaleString?: boolean;
+                            pop?: boolean;
+                            push?: boolean;
+                            concat?: boolean;
+                            join?: boolean;
+                            reverse?: boolean;
+                            shift?: boolean;
+                            slice?: boolean;
+                            sort?: boolean;
+                            splice?: boolean;
+                            unshift?: boolean;
+                            indexOf?: boolean;
+                            lastIndexOf?: boolean;
+                            every?: boolean;
+                            some?: boolean;
+                            forEach?: boolean;
+                            map?: boolean;
+                            filter?: boolean;
+                            reduce?: boolean;
+                            reduceRight?: boolean;
+                            find?: boolean;
+                            findIndex?: boolean;
+                            fill?: boolean;
+                            copyWithin?: boolean;
+                            entries?: boolean;
+                            keys?: boolean;
+                            values?: boolean;
+                            includes?: boolean;
+                            flatMap?: boolean;
+                            flat?: boolean;
+                        };
+                    };
+                    createdAt: string;
+                    variant: {
+                        id: string;
+                        sku: string;
+                        name: string;
+                        productName: string;
+                        brandName: string;
+                    };
+                    warehouse: {
+                        id: string;
+                        name: string;
+                    };
+                }[];
+                pagination: {
+                    page: number;
+                    limit: number;
+                    total: number;
+                    totalPages: number;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: {
+                    code: string;
+                    message: string;
+                };
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+} & {
+    "/low-stock": {
+        $get: {
+            input: {};
+            output: never;
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: {
+                    code: string;
+                    message: string;
+                };
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+}, "/">;
+export default app;