@instockng/api-client 1.0.6 → 1.0.8

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

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