@instockng/api-client 1.0.6 → 1.0.7

package/dist/apps/backend/src/routes/public/products.js

@@ -0,0 +1,133 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+import { getPrismaClient } from '../../lib/prisma';
+import { getTotalInventoryForVariant } from '../../lib/inventory';
+import { formatProductResponse, PRODUCT_INCLUDE_FULL_PUBLIC } from '../../lib/product-response';
+const app = new Hono()
+    // GET single product by slug with variants (including availability)
+    .get('/product/:slug', zValidator('param', z.object({
+    slug: z.string(),
+})), async (c) => {
+    try {
+        const { slug } = c.req.valid('param');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        // Fetch product and its active variants
+        const product = await prisma.product.findFirst({
+            where: {
+                slug,
+                isActive: true,
+                deletedAt: null,
+            },
+            include: PRODUCT_INCLUDE_FULL_PUBLIC,
+        });
+        if (!product) {
+            return c.json({
+                error: { code: 'PRODUCT_NOT_FOUND', message: 'Product not found' },
+            }, 404);
+        }
+        // Attach availability info for each variant
+        const variantsWithAvailability = [];
+        for (const variant of product.variants) {
+            if (!variant.trackInventory) {
+                variantsWithAvailability.push({
+                    ...variant,
+                    availability: {
+                        available: true,
+                        trackInventory: false,
+                        totalInventory: null,
+                    },
+                });
+            }
+            else {
+                const totalInventory = await getTotalInventoryForVariant(prisma, variant.id);
+                variantsWithAvailability.push({
+                    ...variant,
+                    availability: {
+                        available: totalInventory > 0,
+                        trackInventory: true,
+                        totalInventory,
+                    },
+                });
+            }
+        }
+        const data = {
+            ...product,
+            variants: variantsWithAvailability,
+        };
+        return c.json(formatProductResponse(data), 200);
+    }
+    catch (error) {
+        console.error('Get product error:', error);
+        return c.json({
+            error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve product' },
+        }, 500);
+    }
+})
+    // GET products by brand with variants (including availability)
+    .get('/:brandId', zValidator('param', z.object({
+    brandId: z.uuid(),
+})), async (c) => {
+    try {
+        const { brandId } = c.req.valid('param');
+        const prisma = getPrismaClient(c.env.DATABASE_URL);
+        // Validate brand exists
+        const brand = await prisma.brand.findFirst({
+            where: { id: brandId, deletedAt: null },
+        });
+        if (!brand) {
+            return c.json({
+                error: { code: 'BRAND_NOT_FOUND', message: 'Brand not found' },
+            }, 404);
+        }
+        // Fetch products and their active variants for the brand
+        const products = await prisma.product.findMany({
+            where: {
+                brandId,
+                isActive: true,
+                deletedAt: null,
+            },
+            include: PRODUCT_INCLUDE_FULL_PUBLIC,
+        });
+        // Attach availability info for each variant
+        const data = [];
+        for (const product of products) {
+            const variantsWithAvailability = [];
+            for (const variant of product.variants) {
+                if (!variant.trackInventory) {
+                    variantsWithAvailability.push({
+                        ...variant,
+                        availability: {
+                            available: true,
+                            trackInventory: false,
+                            totalInventory: null,
+                        },
+                    });
+                }
+                else {
+                    const totalInventory = await getTotalInventoryForVariant(prisma, variant.id);
+                    variantsWithAvailability.push({
+                        ...variant,
+                        availability: {
+                            available: totalInventory > 0,
+                            trackInventory: true,
+                            totalInventory,
+                        },
+                    });
+                }
+            }
+            data.push({
+                ...product,
+                variants: variantsWithAvailability,
+            });
+        }
+        return c.json(data.map(formatProductResponse), 200);
+    }
+    catch (error) {
+        console.error('Get products with variants error:', error);
+        return c.json({
+            error: { code: 'INTERNAL_ERROR', message: 'Failed to retrieve products' },
+        }, 500);
+    }
+});
+export default app;

package/dist/apps/backend/src/types/index.d.ts

@@ -0,0 +1,42 @@
+export interface Env {
+    DATABASE_URL: string;
+    CLERK_PUBLISHABLE_KEY: string;
+    CLERK_SECRET_KEY: string;
+    API_KEY: string;
+    TWILIO_ACCOUNT_SID?: string;
+    TWILIO_AUTH_TOKEN?: string;
+    TWILIO_WHATSAPP_FROM?: string;
+    WHATSAPP_TEMPLATE_ORDER_CONFIRMATION?: string;
+    WHATSAPP_TEMPLATE_ORDER_SHIPPED?: string;
+    WHATSAPP_TEMPLATE_ORDER_DELIVERED?: string;
+    WHATSAPP_TEMPLATE_ORDER_CANCELLED?: string;
+    WHATSAPP_TEMPLATE_CART_RECOVERY?: string;
+    RESEND_API_KEY?: string;
+    EMAIL_FROM?: string;
+    META_CAPI_ACCESS_TOKEN?: string;
+    FRONTEND_URL: string;
+    ALLOWED_ORIGINS: string;
+    ENVIRONMENT: string;
+    WHATSAPP_QUEUE?: Queue;
+    EMAIL_QUEUE?: Queue;
+    META_CAPI_QUEUE?: Queue;
+}
+export interface AppContext {
+    Bindings: Env;
+    Variables: {
+        user?: {
+            id: string;
+            email: string;
+            name?: string;
+        };
+        dbUser?: {
+            id: string;
+            clerkId: string;
+            email: string;
+            name: string | null;
+            role: string;
+            createdAt: Date;
+            deletedAt: Date | null;
+        };
+    };
+}

package/dist/apps/backend/src/types/index.js

@@ -0,0 +1,2 @@
+/// <reference types="@cloudflare/workers-types" />
+export {};

package/dist/apps/backend/src/validators/brand.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const createBrandSchema: z.ZodObject<{
+    name: z.ZodString;
+    logoUrl: z.ZodOptional<z.ZodURL>;
+    siteUrl: z.ZodURL;
+    domain: z.ZodString;
+    metaPixelId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateBrandInput = z.infer<typeof createBrandSchema>;
+export declare const updateBrandSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    logoUrl: z.ZodOptional<z.ZodURL>;
+    siteUrl: z.ZodOptional<z.ZodURL>;
+    domain: z.ZodOptional<z.ZodString>;
+    metaPixelId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UpdateBrandInput = z.infer<typeof updateBrandSchema>;

package/dist/apps/backend/src/validators/brand.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const createBrandSchema = z.object({
+    name: z.string().min(1),
+    logoUrl: z.url().optional(),
+    siteUrl: z.url(),
+    domain: z.string().min(1),
+    metaPixelId: z.string().optional(),
+});
+export const updateBrandSchema = z.object({
+    name: z.string().min(1).optional(),
+    logoUrl: z.url().optional(),
+    siteUrl: z.url().optional(),
+    domain: z.string().min(1).optional(),
+    metaPixelId: z.string().optional(),
+});

package/dist/apps/backend/src/validators/delivery-zone.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const createStateSchema: z.ZodObject<{
+    name: z.ZodString;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateStateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createDeliveryZoneSchema: z.ZodObject<{
+    stateId: z.ZodUUID;
+    brandId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+    name: z.ZodString;
+    deliveryCost: z.ZodNumber;
+    freeShippingThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    allowCOD: z.ZodOptional<z.ZodBoolean>;
+    allowOnline: z.ZodOptional<z.ZodBoolean>;
+    waybillOnly: z.ZodOptional<z.ZodBoolean>;
+    estimatedDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateDeliveryZoneSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    deliveryCost: z.ZodOptional<z.ZodNumber>;
+    freeShippingThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    allowCOD: z.ZodOptional<z.ZodBoolean>;
+    allowOnline: z.ZodOptional<z.ZodBoolean>;
+    waybillOnly: z.ZodOptional<z.ZodBoolean>;
+    estimatedDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/apps/backend/src/validators/delivery-zone.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export const createStateSchema = z.object({
+    name: z.string().min(1),
+    isActive: z.boolean().optional(),
+});
+export const updateStateSchema = z.object({
+    name: z.string().min(1).optional(),
+    isActive: z.boolean().optional(),
+});
+export const createDeliveryZoneSchema = z
+    .object({
+    stateId: z.uuid(),
+    brandId: z.uuid().nullable().optional(),
+    name: z.string().min(1),
+    deliveryCost: z.number().nonnegative(),
+    freeShippingThreshold: z.number().nonnegative().nullable().optional(),
+    allowCOD: z.boolean().optional(),
+    allowOnline: z.boolean().optional(),
+    waybillOnly: z.boolean().optional(),
+    estimatedDays: z.number().int().positive().nullable().optional(),
+    isActive: z.boolean().optional(),
+})
+    .refine((data) => {
+    // If waybillOnly is true, allowCOD must be false
+    if (data.waybillOnly && data.allowCOD !== false) {
+        return false;
+    }
+    return true;
+}, {
+    message: 'When waybillOnly is true, allowCOD must be false',
+});
+export const updateDeliveryZoneSchema = z
+    .object({
+    name: z.string().min(1).optional(),
+    deliveryCost: z.number().nonnegative().optional(),
+    freeShippingThreshold: z.number().nonnegative().nullable().optional(),
+    allowCOD: z.boolean().optional(),
+    allowOnline: z.boolean().optional(),
+    waybillOnly: z.boolean().optional(),
+    estimatedDays: z.number().int().positive().nullable().optional(),
+    isActive: z.boolean().optional(),
+})
+    .refine((data) => {
+    // If waybillOnly is being set to true, allowCOD must be false
+    if (data.waybillOnly && data.allowCOD !== false && data.allowCOD !== undefined) {
+        return false;
+    }
+    return true;
+}, {
+    message: 'When waybillOnly is true, allowCOD must be false',
+});

package/dist/apps/backend/src/validators/discount-code.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+export declare const createDiscountCodeSchema: z.ZodObject<{
+    code: z.ZodString;
+    brandId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodEnum<{
+        fixed: "fixed";
+        percentage: "percentage";
+    }>;
+    value: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodDefault<z.ZodEnum<{
+        recovery: "recovery";
+        manual: "manual";
+        influencer: "influencer";
+        seasonal: "seasonal";
+        referral: "referral";
+    }>>;
+    minPurchase: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxDiscount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    usageLimit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    perCustomerLimit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    validFrom: z.ZodOptional<z.ZodString>;
+    validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    isAutoApply: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateDiscountCodeSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        fixed: "fixed";
+        percentage: "percentage";
+    }>>;
+    value: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    category: z.ZodOptional<z.ZodEnum<{
+        recovery: "recovery";
+        manual: "manual";
+        influencer: "influencer";
+        seasonal: "seasonal";
+        referral: "referral";
+    }>>;
+    minPurchase: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxDiscount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    usageLimit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    perCustomerLimit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    validFrom: z.ZodOptional<z.ZodString>;
+    validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    isAutoApply: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const bulkGenerateCodesSchema: z.ZodObject<{
+    prefix: z.ZodString;
+    count: z.ZodNumber;
+    brandId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodEnum<{
+        fixed: "fixed";
+        percentage: "percentage";
+    }>;
+    value: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodDefault<z.ZodEnum<{
+        recovery: "recovery";
+        manual: "manual";
+        influencer: "influencer";
+        seasonal: "seasonal";
+        referral: "referral";
+    }>>;
+    minPurchase: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    maxDiscount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    perCustomerLimit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    validFrom: z.ZodOptional<z.ZodString>;
+    validUntil: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/apps/backend/src/validators/discount-code.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+// Create discount code schema
+export const createDiscountCodeSchema = z.object({
+    code: z.string().min(1).max(50).regex(/^[A-Z0-9-]+$/, 'Code must contain only uppercase letters, numbers, and hyphens'),
+    brandId: z.string().uuid().nullable().optional(),
+    type: z.enum(['percentage', 'fixed']),
+    value: z.number().positive(), // Percentage (e.g., 10.00 for 10%) or fixed amount in Naira
+    description: z.string().min(1).max(500).optional(),
+    category: z.enum(['manual', 'recovery', 'influencer', 'seasonal', 'referral']).default('manual'),
+    minPurchase: z.number().nonnegative().nullable().optional(), // Minimum purchase in Naira
+    maxDiscount: z.number().positive().nullable().optional(), // Max discount in Naira
+    usageLimit: z.number().int().positive().nullable().optional(),
+    perCustomerLimit: z.number().int().positive().nullable().optional(),
+    validFrom: z.string().datetime().optional(),
+    validUntil: z.string().datetime().nullable().optional(),
+    isActive: z.boolean().default(true),
+    isAutoApply: z.boolean().default(false),
+});
+// Update discount code schema (all fields optional)
+export const updateDiscountCodeSchema = z.object({
+    code: z.string().min(1).max(50).regex(/^[A-Z0-9-]+$/).optional(),
+    type: z.enum(['percentage', 'fixed']).optional(),
+    value: z.number().positive().optional(), // Percentage or fixed amount in Naira
+    description: z.string().min(1).max(500).nullable().optional(),
+    category: z.enum(['manual', 'recovery', 'influencer', 'seasonal', 'referral']).optional(),
+    minPurchase: z.number().nonnegative().nullable().optional(), // Minimum purchase in Naira
+    maxDiscount: z.number().positive().nullable().optional(), // Max discount in Naira
+    usageLimit: z.number().int().positive().nullable().optional(),
+    perCustomerLimit: z.number().int().positive().nullable().optional(),
+    validFrom: z.string().datetime().optional(),
+    validUntil: z.string().datetime().nullable().optional(),
+    isActive: z.boolean().optional(),
+    isAutoApply: z.boolean().optional(),
+});
+// Bulk generate discount codes schema
+export const bulkGenerateCodesSchema = z.object({
+    prefix: z.string().min(1).max(20).regex(/^[A-Z0-9-]+$/),
+    count: z.number().int().positive().max(1000), // Max 1000 codes at once
+    brandId: z.string().uuid().nullable().optional(),
+    type: z.enum(['percentage', 'fixed']),
+    value: z.number().positive(), // Percentage or fixed amount in Naira
+    description: z.string().min(1).max(500).optional(),
+    category: z.enum(['manual', 'recovery', 'influencer', 'seasonal', 'referral']).default('manual'),
+    minPurchase: z.number().nonnegative().nullable().optional(), // Minimum purchase in Naira
+    maxDiscount: z.number().positive().nullable().optional(), // Max discount in Naira
+    perCustomerLimit: z.number().int().positive().nullable().optional(),
+    validFrom: z.string().datetime().optional(),
+    validUntil: z.string().datetime().nullable().optional(),
+    isActive: z.boolean().default(true),
+});

package/dist/apps/backend/src/validators/inventory.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const adjustInventorySchema: z.ZodObject<{
+    variantId: z.ZodUUID;
+    warehouseId: z.ZodUUID;
+    quantity: z.ZodNumber;
+    type: z.ZodEnum<{
+        restock: "restock";
+        adjustment: "adjustment";
+        damaged: "damaged";
+        initial: "initial";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const transferInventorySchema: z.ZodObject<{
+    variantId: z.ZodUUID;
+    fromWarehouseId: z.ZodUUID;
+    toWarehouseId: z.ZodUUID;
+    quantity: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/apps/backend/src/validators/inventory.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const adjustInventorySchema = z.object({
+    variantId: z.uuid(),
+    warehouseId: z.uuid(),
+    quantity: z.number().int(),
+    type: z.enum(['restock', 'adjustment', 'damaged', 'initial']),
+    reason: z.string().optional(),
+});
+export const transferInventorySchema = z.object({
+    variantId: z.uuid(),
+    fromWarehouseId: z.uuid(),
+    toWarehouseId: z.uuid(),
+    quantity: z.number().int().positive(),
+    reason: z.string().optional(),
+});

package/dist/apps/backend/src/validators/order.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+export declare const createOrderSchema: z.ZodObject<{
+    brandSlug: z.ZodString;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    phone: z.ZodString;
+    address: z.ZodString;
+    city: z.ZodString;
+    deliveryZoneId: z.ZodString;
+    deliveryCharge: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+        sku: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>;
+    discount: z.ZodOptional<z.ZodNumber>;
+    paymentMethod: () => z.ZodOptional<z.ZodString>;
+    paystackReference: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const updateOrderSchema: z.ZodObject<{
+    brandSlug: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    deliveryZoneId: z.ZodOptional<z.ZodString>;
+    deliveryCharge: z.ZodOptional<z.ZodNumber>;
+    discount: z.ZodOptional<z.ZodNumber>;
+    paymentMethod: z.ZodOptional<z.ZodString>;
+    paystackReference: z.ZodOptional<z.ZodString>;
+    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sku: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const updateOrderStatusSchema: z.ZodObject<{
+    status: z.ZodString;
+    cancellationReason: z.ZodOptional<z.ZodString>;
+    prospectReason: z.ZodOptional<z.ZodString>;
+    prospectNote: z.ZodOptional<z.ZodString>;
+    warehouses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        orderItemId: z.ZodUUID;
+        warehouseId: z.ZodUUID;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const orderFiltersSchema: z.ZodObject<{
+    brandId: z.ZodOptional<z.ZodUUID>;
+    status: z.ZodOptional<z.ZodString>;
+    paymentMethod: z.ZodOptional<z.ZodString>;
+    warehouseId: z.ZodOptional<z.ZodUUID>;
+    search: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;

package/dist/apps/backend/src/validators/order.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+// Order creation schema (public API)
+export const createOrderSchema = z.object({
+    brandSlug: z.string().min(1),
+    firstName: z.string().min(1),
+    lastName: z.string().min(1),
+    phone: z.string().min(1),
+    address: z.string().min(1),
+    city: z.string().min(1),
+    deliveryZoneId: z.string().uuid(),
+    deliveryCharge: z.number().nonnegative(),
+    items: z.array(z.object({
+        sku: z.string().min(1),
+        quantity: z.number().int().positive(),
+    })).min(1),
+    discount: z.number().nonnegative().optional(),
+    paymentMethod: z.string().optional,
+    paystackReference: z.string().optional(),
+});
+// Update order schema (admin API)
+export const updateOrderSchema = z.object({
+    brandSlug: z.string().min(1).optional(),
+    firstName: z.string().min(1).optional(),
+    lastName: z.string().min(1).optional(),
+    phone: z.string().min(1).optional(),
+    address: z.string().min(1).optional(),
+    city: z.string().min(1).optional(),
+    deliveryZoneId: z.string().uuid().optional(),
+    deliveryCharge: z.number().nonnegative().optional(),
+    discount: z.number().nonnegative().optional(),
+    paymentMethod: z.string().optional(),
+    paystackReference: z.string().optional(),
+    items: z.array(z.object({
+        sku: z.string().min(1),
+        quantity: z.number().int().positive(),
+    })).optional(),
+});
+// Update order status schema
+export const updateOrderStatusSchema = z.object({
+    status: z.string(),
+    cancellationReason: z.string().optional(),
+    prospectReason: z.string().optional(),
+    prospectNote: z.string().optional(),
+    warehouses: z.array(z.object({
+        orderItemId: z.uuid(),
+        warehouseId: z.uuid(),
+    })).optional(), // Required when status is 'shipped'
+});
+// Order filter schema
+export const orderFiltersSchema = z.object({
+    brandId: z.uuid().optional(),
+    status: z.string().optional(),
+    paymentMethod: z.string().optional(),
+    warehouseId: z.uuid().optional(),
+    search: z.string().optional(), // Search by order number, customer name, phone
+    startDate: z.string().optional(),
+    endDate: z.string().optional(),
+    page: z.number().int().positive().optional(),
+    limit: z.number().int().positive().max(100).optional(),
+});

package/dist/apps/backend/src/validators/product.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const createProductSchema: z.ZodObject<{
+    brandId: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    thumbnailUrl: z.ZodOptional<z.ZodString>;
+    quantityDiscounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateProductSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    thumbnailUrl: z.ZodOptional<z.ZodString>;
+    quantityDiscounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/apps/backend/src/validators/product.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+const quantityDiscountsSchema = z.record(z.string().regex(/^\d+$/, 'Quantity must be a number'), z.number().int().min(0).max(100, 'Discount must be between 0 and 100')).optional();
+export const createProductSchema = z.object({
+    brandId: z.string().uuid(),
+    name: z.string().min(1),
+    slug: z.string().min(1).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'Slug must be lowercase letters, numbers, and hyphens only'),
+    description: z.string().optional(),
+    thumbnailUrl: z.string().url().optional(),
+    quantityDiscounts: quantityDiscountsSchema,
+    isActive: z.boolean().optional(),
+});
+export const updateProductSchema = z.object({
+    name: z.string().min(1).optional(),
+    slug: z.string().min(1).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'Slug must be lowercase letters, numbers, and hyphens only').optional(),
+    description: z.string().optional(),
+    thumbnailUrl: z.string().url().optional(),
+    quantityDiscounts: quantityDiscountsSchema,
+    isActive: z.boolean().optional(),
+});

package/dist/apps/backend/src/validators/variant.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const createVariantSchema: z.ZodObject<{
+    sku: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    thumbnailUrl: z.ZodOptional<z.ZodURL>;
+    price: z.ZodNumber;
+    trackInventory: z.ZodOptional<z.ZodBoolean>;
+    lowStockThreshold: z.ZodOptional<z.ZodNumber>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateVariantSchema: z.ZodObject<{
+    sku: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    thumbnailUrl: z.ZodOptional<z.ZodString>;
+    price: z.ZodOptional<z.ZodNumber>;
+    trackInventory: z.ZodOptional<z.ZodBoolean>;
+    lowStockThreshold: z.ZodOptional<z.ZodNumber>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;

package/dist/apps/backend/src/validators/variant.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const createVariantSchema = z.object({
+    sku: z.string().min(1),
+    name: z.string().optional(),
+    thumbnailUrl: z.url().optional(),
+    price: z.number().positive(), // Price in Naira
+    trackInventory: z.boolean().optional(),
+    lowStockThreshold: z.number().int().nonnegative().optional(),
+    isActive: z.boolean().optional(),
+});
+export const updateVariantSchema = z.object({
+    sku: z.string().min(1).optional(),
+    name: z.string().optional(),
+    thumbnailUrl: z.string().url().optional(),
+    price: z.number().positive().optional(), // Price in Naira
+    trackInventory: z.boolean().optional(),
+    lowStockThreshold: z.number().int().nonnegative().optional(),
+    isActive: z.boolean().optional(),
+});