@instockng/api-client 1.0.6 → 1.0.8

package/dist/apps/backend/src/routes/admin/delivery-zones.js

@@ -0,0 +1,300 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { getPrismaClient } from '../../lib/prisma';
+import { createStateSchema, updateStateSchema, createDeliveryZoneSchema, updateDeliveryZoneSchema, } from '../../validators/delivery-zone';
+import { formatStateResponse } from '../../lib/delivery-zone-response';
+import { formatDeliveryZoneResponse } from '../../lib/delivery-zone-response';
+const app = new Hono()
+    // List all states
+    .get('/states', async (c) => {
+    try {
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const states = await prisma.state.findMany({
+            where: { deletedAt: null },
+            include: {
+                deliveryZones: {
+                    where: { deletedAt: null },
+                    orderBy: { name: 'asc' },
+                    include: {
+                        brand: true,
+                        state: true,
+                    },
+                },
+            },
+            orderBy: { name: 'asc' },
+        });
+        return c.json(states.map((s) => ({
+            ...formatStateResponse(s),
+            deliveryZones: s.deliveryZones.map(formatDeliveryZoneResponse),
+        })));
+    }
+    catch (error) {
+        console.error('Error fetching states:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to fetch states' } }, 500);
+    }
+})
+    // Create state
+    .post('/states', zValidator('json', createStateSchema), async (c) => {
+    try {
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        // Check if state name already exists
+        const existing = await prisma.state.findFirst({
+            where: { name: input.name, deletedAt: null },
+        });
+        if (existing) {
+            return c.json({ error: { code: 'STATE_EXISTS', message: 'State with this name already exists' } }, 400);
+        }
+        const state = await prisma.state.create({
+            data: {
+                name: input.name,
+                isActive: input.isActive ?? true,
+            },
+        });
+        return c.json(formatStateResponse(state), 201);
+    }
+    catch (error) {
+        console.error('Error creating state:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to create state' } }, 500);
+    }
+})
+    // Update state
+    .patch('/states/:id', zValidator('json', updateStateSchema), async (c) => {
+    try {
+        const stateId = c.req.param('id');
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const state = await prisma.state.findFirst({
+            where: { id: stateId, deletedAt: null },
+        });
+        if (!state) {
+            return c.json({ error: { code: 'STATE_NOT_FOUND', message: 'State not found' } }, 404);
+        }
+        // Check for name conflicts if name is being updated
+        if (input.name && input.name !== state.name) {
+            const existing = await prisma.state.findFirst({
+                where: { name: input.name, deletedAt: null, id: { not: stateId } },
+            });
+            if (existing) {
+                return c.json({ error: { code: 'STATE_EXISTS', message: 'State with this name already exists' } }, 400);
+            }
+        }
+        const updated = await prisma.state.update({
+            where: { id: stateId },
+            data: {
+                name: input.name,
+                isActive: input.isActive,
+            },
+        });
+        return c.json(formatStateResponse(updated));
+    }
+    catch (error) {
+        console.error('Error updating state:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to update state' } }, 500);
+    }
+})
+    // Soft delete state
+    .delete('/states/:id', async (c) => {
+    try {
+        const stateId = c.req.param('id');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const state = await prisma.state.findFirst({
+            where: { id: stateId, deletedAt: null },
+        });
+        if (!state) {
+            return c.json({ error: { code: 'STATE_NOT_FOUND', message: 'State not found' } }, 404);
+        }
+        // Soft delete zones in this state as well
+        await prisma.$transaction([
+            prisma.deliveryZone.updateMany({
+                where: { stateId, deletedAt: null },
+                data: { deletedAt: new Date() },
+            }),
+            prisma.state.update({
+                where: { id: stateId },
+                data: { deletedAt: new Date() },
+            }),
+        ]);
+        return c.status(204);
+    }
+    catch (error) {
+        console.error('Error deleting state:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to delete state' } }, 500);
+    }
+})
+    // ============ DELIVERY ZONES ============
+    // List delivery zones with optional filters
+    .get('/zones', async (c) => {
+    try {
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const stateId = c.req.query('stateId');
+        const brandId = c.req.query('brandId');
+        const zones = await prisma.deliveryZone.findMany({
+            where: {
+                deletedAt: null,
+                ...(stateId && { stateId }),
+                ...(brandId && { brandId }),
+            },
+            include: {
+                state: true,
+                brand: true,
+            },
+            orderBy: [{ state: { name: 'asc' } }, { name: 'asc' }],
+        });
+        return c.json(zones.map(formatDeliveryZoneResponse));
+    }
+    catch (error) {
+        console.error('Error fetching delivery zones:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to fetch delivery zones' } }, 500);
+    }
+})
+    // Create delivery zone
+    .post('/zones', zValidator('json', createDeliveryZoneSchema), async (c) => {
+    try {
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        // Validate state exists
+        const state = await prisma.state.findFirst({
+            where: { id: input.stateId, deletedAt: null },
+        });
+        if (!state) {
+            return c.json({ error: { code: 'STATE_NOT_FOUND', message: 'State not found' } }, 404);
+        }
+        // Validate brand if provided
+        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);
+            }
+        }
+        // Check for duplicate zone name in this state
+        const existing = await prisma.deliveryZone.findFirst({
+            where: {
+                stateId: input.stateId,
+                brandId: input.brandId ?? null,
+                name: input.name,
+                deletedAt: null,
+            },
+        });
+        if (existing) {
+            return c.json({ error: { code: 'ZONE_EXISTS', message: 'Zone with this name already exists in this state' } }, 400);
+        }
+        // Enforce waybillOnly => allowCOD = false
+        const allowCOD = input.waybillOnly ? false : (input.allowCOD ?? true);
+        const zone = await prisma.deliveryZone.create({
+            data: {
+                stateId: input.stateId,
+                brandId: input.brandId ?? null,
+                name: input.name,
+                deliveryCost: input.deliveryCost,
+                freeShippingThreshold: input.freeShippingThreshold ?? null,
+                allowCOD,
+                allowOnline: input.allowOnline ?? true,
+                waybillOnly: input.waybillOnly ?? false,
+                estimatedDays: input.estimatedDays ?? null,
+                isActive: input.isActive ?? true,
+            },
+            include: {
+                state: true,
+                brand: true,
+            },
+        });
+        return c.json(formatDeliveryZoneResponse(zone), 201);
+    }
+    catch (error) {
+        console.error('Error creating delivery zone:', error);
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to create delivery zone' } }, 500);
+    }
+})
+    // Update delivery zone
+    .patch('/zones/:id', zValidator('json', updateDeliveryZoneSchema), async (c) => {
+    try {
+        const zoneId = c.req.param('id');
+        const input = c.req.valid('json');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const zone = await prisma.deliveryZone.findFirst({
+            where: { id: zoneId, deletedAt: null },
+        });
+        if (!zone) {
+            return c.json({ error: { code: 'ZONE_NOT_FOUND', message: 'Delivery zone not found' } }, 404);
+        }
+        // Check for name conflicts if name is being updated
+        if (input.name && input.name !== zone.name) {
+            const existing = await prisma.deliveryZone.findFirst({
+                where: {
+                    stateId: zone.stateId,
+                    brandId: zone.brandId,
+                    name: input.name,
+                    deletedAt: null,
+                    id: { not: zoneId },
+                },
+            });
+            if (existing) {
+                return c.json({ error: { code: 'ZONE_EXISTS', message: 'Zone with this name already exists in this state' } }, 400);
+            }
+        }
+        // Build update data
+        const updateData = {};
+        if (input.name !== undefined)
+            updateData.name = input.name;
+        if (input.deliveryCost !== undefined)
+            updateData.deliveryCost = input.deliveryCost;
+        if (input.freeShippingThreshold !== undefined)
+            updateData.freeShippingThreshold = input.freeShippingThreshold;
+        if (input.allowOnline !== undefined)
+            updateData.allowOnline = input.allowOnline;
+        if (input.estimatedDays !== undefined)
+            updateData.estimatedDays = input.estimatedDays;
+        if (input.isActive !== undefined)
+            updateData.isActive = input.isActive;
+        // Handle waybillOnly and allowCOD together
+        if (input.waybillOnly !== undefined) {
+            updateData.waybillOnly = input.waybillOnly;
+            if (input.waybillOnly) {
+                updateData.allowCOD = false;
+            }
+            else if (input.allowCOD !== undefined) {
+                updateData.allowCOD = input.allowCOD;
+            }
+        }
+        else if (input.allowCOD !== undefined) {
+            updateData.allowCOD = input.allowCOD;
+        }
+        const updated = await prisma.deliveryZone.update({
+            where: { id: zoneId },
+            data: updateData,
+            include: {
+                state: true,
+                brand: true,
+            },
+        });
+        return c.json(formatDeliveryZoneResponse(updated));
+    }
+    catch (error) {
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to update delivery zone' } }, 500);
+    }
+})
+    // Soft delete delivery zone
+    .delete('/zones/:id', async (c) => {
+    try {
+        const zoneId = c.req.param('id');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        const zone = await prisma.deliveryZone.findFirst({
+            where: { id: zoneId, deletedAt: null },
+        });
+        if (!zone) {
+            return c.json({ error: { code: 'ZONE_NOT_FOUND', message: 'Delivery zone not found' } }, 404);
+        }
+        await prisma.deliveryZone.update({
+            where: { id: zoneId },
+            data: { deletedAt: new Date() },
+        });
+        return c.status(204);
+    }
+    catch (error) {
+        return c.json({ error: { code: 'INTERNAL_ERROR', message: 'Failed to delete delivery zone' } }, 500);
+    }
+});
+export default app;