@instockng/api-client 1.0.8 → 1.0.10

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

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

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