@instockng/api-client 1.0.11 → 1.0.12

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

@@ -1,199 +0,0 @@
-import { Hono } from 'hono';
-import { adjustInventorySchema, transferInventorySchema } from '../../validators/inventory';
-import { getPrismaClient } from '../../lib/prisma';
-import { getPaginationParams, createPaginatedResponse } from '../../lib/utils';
-import { adjustInventory, transferInventory, getLowStockVariants } from '../../lib/inventory';
-import { captureException } from '../../lib/sentry';
-const app = new Hono()
-    // Get inventory overview
-    .get('/', async (c) => {
-    try {
-        const brandId = c.req.query('brandId');
-        const warehouseId = c.req.query('warehouseId');
-        const productId = c.req.query('productId');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        const where = {};
-        if (warehouseId)
-            where.warehouseId = warehouseId;
-        if (productId)
-            where.variant = { productId };
-        const inventories = await prisma.warehouseInventory.findMany({
-            where,
-            include: {
-                variant: {
-                    include: {
-                        product: {
-                            include: {
-                                brand: true,
-                            },
-                        },
-                    },
-                },
-                warehouse: true,
-            },
-        });
-        // Filter by brandId if provided
-        const filteredInventories = brandId
-            ? inventories.filter((inv) => inv.variant.product.brandId === brandId)
-            : inventories;
-        return c.json(filteredInventories.map((inv) => ({
-            variantId: inv.variantId,
-            warehouseId: inv.warehouseId,
-            sku: inv.variant.sku,
-            productName: inv.variant.product.name,
-            name: inv.variant.name,
-            brandName: inv.variant.product.brand.name,
-            warehouseName: inv.warehouse.name,
-            inventoryCount: inv.inventoryCount,
-            lowStockThreshold: inv.variant.lowStockThreshold,
-            isLowStock: inv.variant.lowStockThreshold
-                ? inv.inventoryCount < inv.variant.lowStockThreshold
-                : false,
-        })));
-    }
-    catch (error) {
-        return c.json({
-            error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve inventory' },
-        }, 500);
-    }
-})
-    // Adjust inventory
-    .post('/adjust', async (c) => {
-    try {
-        const body = await c.req.json();
-        const input = adjustInventorySchema.parse(body);
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        const dbUser = c.get('dbUser');
-        await adjustInventory(prisma, {
-            variantId: input.variantId,
-            warehouseId: input.warehouseId,
-            quantity: input.quantity,
-            type: input.type,
-            reason: input.reason,
-            userId: dbUser?.id,
-        });
-        return c.status(204);
-    }
-    catch (error) {
-        // CRITICAL: Inventory adjustments affect stock availability
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'fatal',
-            tags: {
-                error_code: 'INVENTORY_ADJUST_ERROR',
-                endpoint: 'POST /admin/inventory/adjust',
-            },
-            honoContext: c,
-        });
-        return c.json({
-            error: { code: 'INTERNAL_ERROR', message: error instanceof Error ? error.message : 'Failed to adjust inventory' },
-        }, 500);
-    }
-})
-    // Transfer inventory
-    .post('/transfer', async (c) => {
-    try {
-        const body = await c.req.json();
-        const input = transferInventorySchema.parse(body);
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        const dbUser = c.get('dbUser');
-        await transferInventory(prisma, {
-            variantId: input.variantId,
-            fromWarehouseId: input.fromWarehouseId,
-            toWarehouseId: input.toWarehouseId,
-            quantity: input.quantity,
-            reason: input.reason,
-            userId: dbUser?.id,
-        });
-        return c.status(204);
-    }
-    catch (error) {
-        return c.json({
-            error: { code: 'INTERNAL_ERROR', message: error instanceof Error ? error.message : 'Failed to transfer inventory' },
-        }, 500);
-    }
-})
-    // Get inventory transaction history
-    .get('/transactions', async (c) => {
-    try {
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        const query = c.req.query();
-        const { page, limit, skip } = getPaginationParams({
-            page: query.page ? parseInt(query.page) : undefined,
-            limit: query.limit ? parseInt(query.limit) : undefined,
-        });
-        const where = {};
-        if (query.variantId)
-            where.variantId = query.variantId;
-        if (query.warehouseId)
-            where.warehouseId = query.warehouseId;
-        if (query.type)
-            where.type = query.type;
-        if (query.startDate)
-            where.createdAt = { ...where.createdAt, gte: new Date(query.startDate) };
-        if (query.endDate)
-            where.createdAt = { ...where.createdAt, lte: new Date(query.endDate) };
-        const [transactions, total] = await Promise.all([
-            prisma.inventoryTransaction.findMany({
-                where,
-                include: {
-                    variant: {
-                        include: {
-                            product: {
-                                include: { brand: true },
-                            },
-                        },
-                    },
-                    warehouse: true,
-                    order: true,
-                },
-                skip,
-                take: limit,
-                orderBy: { createdAt: 'desc' },
-            }),
-            prisma.inventoryTransaction.count({ where }),
-        ]);
-        return c.json(createPaginatedResponse(transactions.map((tx) => ({
-            id: tx.id,
-            type: tx.type,
-            quantity: tx.quantity,
-            balanceAfter: tx.balanceAfter,
-            reason: tx.reason,
-            orderId: tx.orderId,
-            orderNumber: tx.order?.orderNumber,
-            userId: tx.userId,
-            metadata: tx.metadata,
-            createdAt: tx.createdAt,
-            variant: {
-                id: tx.variant.id,
-                sku: tx.variant.sku,
-                name: tx.variant.name,
-                productName: tx.variant.product.name,
-                brandName: tx.variant.product.brand.name,
-            },
-            warehouse: {
-                id: tx.warehouse.id,
-                name: tx.warehouse.name,
-            },
-        })), total, page, limit));
-    }
-    catch (error) {
-        return c.json({
-            error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve inventory transactions' },
-        }, 500);
-    }
-})
-    // Get low stock alerts
-    .get('/low-stock', async (c) => {
-    try {
-        const brandId = c.req.query('brandId');
-        const prisma = getPrismaClient(c.env.DATABASE_URL);
-        const lowStockVariants = await getLowStockVariants(prisma, brandId);
-        return c.json(lowStockVariants);
-    }
-    catch (error) {
-        return c.json({
-            error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve low stock alerts' },
-        }, 500);
-    }
-});
-export default app;