@instockng/api-client 1.0.3 → 1.0.5

package/dist/apps/backend/src/lib/cart-recovery.js

@@ -0,0 +1,147 @@
+/**
+ * Abandoned cart recovery scheduler
+ * Handles automatic sending of recovery WhatsApp messages at different intervals
+ */
+import { getRecoveryDiscountPercentage, generateDiscountCode } from './discount';
+/**
+ * Recovery schedule configuration
+ */
+export const RECOVERY_SCHEDULE = [
+    { attemptNumber: 1, hoursAfterAbandonment: 1, discountPercent: 0 },
+    { attemptNumber: 2, hoursAfterAbandonment: 24, discountPercent: 5 },
+    { attemptNumber: 3, hoursAfterAbandonment: 72, discountPercent: 10 },
+];
+/**
+ * Find carts eligible for recovery message at specific attempt
+ */
+export async function findCartsForRecovery(prisma, attemptNumber) {
+    const schedule = RECOVERY_SCHEDULE.find((s) => s.attemptNumber === attemptNumber);
+    if (!schedule)
+        return [];
+    const now = new Date();
+    const cutoffTime = new Date(now.getTime() - schedule.hoursAfterAbandonment * 60 * 60 * 1000);
+    // Buffer window: send messages for carts abandoned between cutoffTime and cutoffTime - 1 hour
+    const bufferTime = new Date(cutoffTime.getTime() - 60 * 60 * 1000);
+    // Don't message anyone who has received a recovery attempt in the last 22 hours
+    const lastAttemptCutoff = new Date(now.getTime() - 22 * 60 * 60 * 1000);
+    const carts = await prisma.cart.findMany({
+        where: {
+            OR: [{ customerPhone: { not: null } }, { customerEmail: { not: null } }],
+            updatedAt: {
+                gte: bufferTime,
+                lte: cutoffTime,
+            },
+            AND: [
+                {
+                    OR: [
+                        { lastRecoveryAttemptAt: null },
+                        { lastRecoveryAttemptAt: { lte: lastAttemptCutoff } },
+                    ],
+                },
+            ],
+            expiresAt: { gt: now },
+            items: { some: {} },
+            recoveryAttempts: attemptNumber - 1, // Only send to carts at this attempt
+            convertedToOrderId: null, // Not already converted
+        },
+        include: {
+            brand: true,
+            items: {
+                include: {
+                    variant: {
+                        include: {
+                            product: true,
+                        },
+                    },
+                },
+            },
+        },
+    });
+    return carts;
+}
+/**
+ * Prepares a cart for a recovery attempt.
+ * This is the key atomic operation that:
+ * 1. Updates the recovery attempt number to prevent duplicate messages
+ * 2. Creates/updates the recovery discount code
+ * 3. Applies the discount to the cart
+ * This should be called *before* queueing any notifications.
+ */
+export async function prepareCartForRecoveryAttempt(prisma, cart, attemptNumber) {
+    // 1. Atomically update the attempt number to "claim" this cart for processing
+    const updateResult = await prisma.cart.updateMany({
+        where: { id: cart.id, recoveryAttempts: attemptNumber - 1 },
+        data: { recoveryAttempts: attemptNumber, lastRecoveryAttemptAt: new Date() },
+    });
+    // If the update failed, it means another process already handled this cart.
+    if (updateResult.count === 0) {
+        console.log(`[RECOVERY] Cart ${cart.id} already processed for attempt ${attemptNumber}. Skipping.`);
+        return { success: false };
+    }
+    // 2. Create or update the discount code for this recovery attempt, if applicable
+    const discountPercent = getRecoveryDiscountPercentage(attemptNumber);
+    if (discountPercent > 0) {
+        let recoveryCode = null;
+        if (cart.recoveryDiscountCodeId) {
+            recoveryCode = await prisma.discountCode.findUnique({ where: { id: cart.recoveryDiscountCodeId } });
+            if (!recoveryCode) {
+                cart.recoveryDiscountCodeId = null; // Stale ID, will create a new one
+            }
+            else {
+                const currentValue = parseFloat(recoveryCode.value.toString());
+                // If the existing code is not a percentage or has a lower value, update it
+                if (recoveryCode.type !== 'percentage' || currentValue < discountPercent) {
+                    recoveryCode = await prisma.discountCode.update({
+                        where: { id: recoveryCode.id },
+                        data: {
+                            type: 'percentage',
+                            value: discountPercent,
+                            category: 'recovery',
+                            isActive: true,
+                            description: `Cart recovery ${discountPercent}%`,
+                        },
+                    });
+                }
+            }
+        }
+        // If no valid recovery code exists, create one
+        if (!cart.recoveryDiscountCodeId) {
+            const codeStr = generateDiscountCode();
+            recoveryCode = await prisma.discountCode.create({
+                data: {
+                    code: codeStr,
+                    brandId: cart.brandId,
+                    type: 'percentage',
+                    value: discountPercent,
+                    category: 'recovery',
+                    isActive: true,
+                    description: `Cart recovery ${discountPercent}%`,
+                },
+            });
+            await prisma.cart.update({ where: { id: cart.id }, data: { recoveryDiscountCodeId: recoveryCode.id } });
+        }
+        // 3. Apply the recovery discount to the cart so it's ready for the customer
+        await prisma.cart.update({ where: { id: cart.id }, data: { appliedDiscountCodeId: recoveryCode.id } });
+    }
+    else {
+        // No discount for this attempt, ensure no discount is applied
+        await prisma.cart.update({ where: { id: cart.id }, data: { appliedDiscountCodeId: null } });
+    }
+    // 4. Return the fully updated cart for the producer to use
+    const updatedCart = (await prisma.cart.findUnique({
+        where: { id: cart.id },
+        include: {
+            brand: true,
+            items: {
+                include: {
+                    variant: {
+                        include: {
+                            product: true,
+                        },
+                    },
+                },
+            },
+        },
+    }));
+    return { success: true, cartWithDiscount: updatedCart };
+}

package/dist/apps/backend/src/lib/cart-response.d.ts

@@ -0,0 +1,121 @@
+import { Prisma, PrismaClient } from '@prisma/client';
+export type DiscountInfo = {
+    code: string;
+    type: 'percentage' | 'fixed';
+    value: number;
+    amount: number;
+    description: string | null;
+};
+export type CartWithItemsAndBrand = Prisma.CartGetPayload<{
+    include: {
+        recoveryDiscountCode: true;
+        deliveryZone: true;
+        brand: true;
+        items: {
+            include: {
+                variant: {
+                    include: {
+                        product: true;
+                    };
+                };
+            };
+        };
+    };
+}>;
+export type CartResponse = Awaited<ReturnType<typeof buildCartResponseWithPricing>>;
+export declare function toPricingItems(cart: CartWithItemsAndBrand): import('./pricing').CartItemForCalculation[];
+export declare function buildCartResponseWithPricing(prisma: PrismaClient, cart: CartWithItemsAndBrand): Promise<{
+    id: string;
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        name: string;
+        id: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    customerPhone: string;
+    customerEmail: string;
+    customerFirstName: string;
+    customerLastName: string;
+    availablePaymentMethods: import("@prisma/client").$Enums.PaymentMethod[];
+    deliveryZone: {
+        id: string;
+        name: string;
+    };
+    recoveryAttempts: number;
+    lastRecoveryAttemptAt: Date;
+    recoveryDiscountCode: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+        brandId: string | null;
+        isActive: boolean;
+        code: string;
+        type: string;
+        value: Prisma.Decimal;
+        minPurchase: Prisma.Decimal | null;
+        maxDiscount: Prisma.Decimal | null;
+        usageLimit: number | null;
+        usageCount: number;
+        perCustomerLimit: number | null;
+        validFrom: Date;
+        validUntil: Date | null;
+        isAutoApply: boolean;
+        description: string | null;
+        category: string;
+        createdBy: string | null;
+    };
+    items: {
+        id: string;
+        variant: {
+            price: number;
+            product: {
+                name: string;
+                id: string;
+                slug: string;
+                createdAt: Date;
+                updatedAt: Date;
+                deletedAt: Date | null;
+                brandId: string;
+                isActive: boolean;
+                description: string | null;
+                thumbnailUrl: string | null;
+                quantityDiscounts: Prisma.JsonValue | null;
+            };
+            name: string | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            isActive: boolean;
+            thumbnailUrl: string | null;
+            productId: string;
+            sku: string;
+            trackInventory: boolean;
+            lowStockThreshold: number | null;
+        };
+        quantity: number;
+        basePrice: number;
+        discountPercent: number;
+        finalPrice: number;
+        subtotal: number;
+    }[];
+    pricing: {
+        subtotal: number;
+        deliveryCharge: number;
+        discount: DiscountInfo;
+        total: number;
+    };
+    createdAt: string;
+    updatedAt: string;
+    expiresAt: string;
+    convertedToOrderId: string;
+    wasRecovered: boolean;
+    recoveryUrl: string;
+}>;

package/dist/apps/backend/src/lib/cart-response.js

@@ -0,0 +1,150 @@
+import { calculateCartCost } from './pricing';
+function toNumber(value) {
+    if (typeof value === 'number')
+        return value;
+    return parseFloat(value.toString());
+}
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+export function toPricingItems(cart) {
+    return cart.items.map((item) => {
+        const rawQtyDiscounts = item.variant.product.quantityDiscounts;
+        let quantityDiscounts = null;
+        if (rawQtyDiscounts && typeof rawQtyDiscounts === 'object' && !Array.isArray(rawQtyDiscounts)) {
+            quantityDiscounts = rawQtyDiscounts;
+        }
+        return {
+            variantId: item.variantId,
+            quantity: item.quantity,
+            variant: {
+                price: item.variant.price,
+                product: {
+                    id: item.variant.product.id,
+                    quantityDiscounts,
+                },
+            },
+        };
+    });
+}
+async function computePricingWithZone(prisma, cart) {
+    const subtotalOnly = calculateCartCost(toPricingItems(cart)).subtotal;
+    let deliveryCharge = 0;
+    let estimatedDays = null;
+    if (cart.deliveryZoneId) {
+        const zone = await prisma.deliveryZone.findFirst({
+            where: { id: cart.deliveryZoneId, isActive: true, deletedAt: null },
+        });
+        if (zone) {
+            const threshold = zone.freeShippingThreshold ? Number(zone.freeShippingThreshold) : null;
+            const base = Number(zone.deliveryCost);
+            deliveryCharge = threshold !== null && subtotalOnly >= threshold ? 0 : base;
+            estimatedDays = zone.estimatedDays ?? null;
+        }
+    }
+    const pricing = calculateCartCost(toPricingItems(cart), deliveryCharge);
+    return { pricing, estimatedDays };
+}
+async function computeAppliedDiscount(prisma, cart, subtotal) {
+    if (!cart.appliedDiscountCodeId)
+        return { discountAmount: 0, discountInfo: null };
+    const discountCode = await prisma.discountCode.findUnique({ where: { id: cart.appliedDiscountCodeId } });
+    if (!discountCode || !discountCode.isActive) {
+        return { discountAmount: 0, discountInfo: null };
+    }
+    const now = new Date();
+    if (discountCode.validFrom && discountCode.validFrom > now)
+        return { discountAmount: 0, discountInfo: null };
+    if (discountCode.validUntil && discountCode.validUntil <= now)
+        return { discountAmount: 0, discountInfo: null };
+    if (discountCode.brandId && discountCode.brandId !== cart.brandId)
+        return { discountAmount: 0, discountInfo: null };
+    let discountAmount = 0;
+    if (discountCode.type === 'percentage') {
+        discountAmount = round(subtotal * (toNumber(discountCode.value) / 100));
+        if (discountCode.maxDiscount) {
+            const maxDiscountNum = toNumber(discountCode.maxDiscount);
+            if (discountAmount > maxDiscountNum)
+                discountAmount = maxDiscountNum;
+        }
+    }
+    else {
+        discountAmount = Math.min(toNumber(discountCode.value), subtotal);
+    }
+    const discountType = discountCode.type === 'percentage' ? 'percentage' : 'fixed';
+    const discountInfo = {
+        code: discountCode.code,
+        type: discountType,
+        value: toNumber(discountCode.value),
+        amount: discountAmount,
+        description: discountCode.description,
+    };
+    return { discountAmount, discountInfo };
+}
+function formatCartResponse(cart, pricing) {
+    const pricingMap = new Map(pricing.items.map((p) => [p.variantId, p]));
+    const { id, brand, customerPhone, customerEmail, customerFirstName, customerLastName, availablePaymentMethods, deliveryZone, recoveryAttempts, lastRecoveryAttemptAt, recoveryDiscountCode, convertedToOrderId, wasRecovered, expiresAt } = cart;
+    return {
+        id,
+        brand: {
+            ...brand,
+            createdAt: brand.createdAt.toISOString(),
+            updatedAt: brand.updatedAt.toISOString(),
+            deletedAt: brand.deletedAt?.toISOString() ?? null,
+        },
+        customerPhone,
+        customerEmail,
+        customerFirstName,
+        customerLastName,
+        availablePaymentMethods,
+        deliveryZone: deliveryZone ? {
+            id: deliveryZone.id,
+            name: deliveryZone.name,
+        } : null,
+        // recovery
+        recoveryAttempts,
+        lastRecoveryAttemptAt,
+        recoveryDiscountCode,
+        items: cart.items.map((item) => {
+            const itemPricing = pricingMap.get(item.variantId);
+            const ip = itemPricing;
+            return {
+                id: item.id,
+                variant: {
+                    ...item.variant,
+                    price: toNumber(item.variant.price),
+                    product: item.variant.product,
+                },
+                quantity: item.quantity,
+                basePrice: ip ? ip.basePrice : 0,
+                discountPercent: ip ? ip.discountPercent : 0,
+                finalPrice: ip ? ip.finalPrice : 0,
+                subtotal: ip ? ip.subtotal : 0,
+            };
+        }),
+        pricing: {
+            subtotal: pricing.subtotal,
+            deliveryCharge: pricing.deliveryCharge,
+            discount: pricing.discount ?? null,
+            total: pricing.total,
+        },
+        createdAt: cart.createdAt.toISOString(),
+        updatedAt: cart.updatedAt.toISOString(),
+        expiresAt: expiresAt?.toISOString() ?? null,
+        convertedToOrderId,
+        wasRecovered,
+        recoveryUrl: `${cart.brand.siteUrl}?cartId=${id}`
+    };
+}
+export async function buildCartResponseWithPricing(prisma, cart) {
+    const { pricing } = await computePricingWithZone(prisma, cart);
+    const { discountAmount, discountInfo } = await computeAppliedDiscount(prisma, cart, pricing.subtotal);
+    const finalSubtotal = round(Math.max(0, pricing.subtotal - discountAmount));
+    const pricingWithDiscount = {
+        ...pricing,
+        discount: discountInfo,
+        finalSubtotal,
+        total: round(Math.max(0, finalSubtotal + pricing.deliveryCharge)),
+    };
+    return formatCartResponse(cart, pricingWithDiscount);
+}

package/dist/apps/backend/src/lib/clerk.d.ts

@@ -0,0 +1,18 @@
+export interface ClerkUser {
+    id: string;
+    email: string;
+    name?: string;
+}
+export interface ClerkUserData {
+    id: string;
+    first_name?: string;
+    last_name?: string;
+    email_addresses?: Array<{
+        email_address: string;
+        id: string;
+    }>;
+    primary_email_address_id?: string;
+    primary_email_address?: string;
+}
+export declare function verifyClerkToken(token: string, publishableKey: string): Promise<ClerkUser | null>;
+export declare function extractBearerToken(authHeader?: string): string | null;

package/dist/apps/backend/src/lib/clerk.js

@@ -0,0 +1,167 @@
+// In-memory cache for JWKS (in production, consider using Workers KV or Durable Objects)
+let jwksCache = null;
+const JWKS_CACHE_TTL = 3600000; // 1 hour in milliseconds
+// Decode base64url (used in JWT)
+function base64UrlDecode(str) {
+    // Replace URL-safe characters
+    let base64 = str.replace(/-/g, '+').replace(/_/g, '/');
+    // Pad with '=' to make length multiple of 4
+    while (base64.length % 4 !== 0) {
+        base64 += '=';
+    }
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+// Decode base64url to string
+function base64UrlDecodeString(str) {
+    const bytes = base64UrlDecode(str);
+    return new TextDecoder().decode(bytes);
+}
+// Fetch Clerk's JWKS
+async function fetchJWKS(publishableKey) {
+    // Check cache first
+    if (jwksCache && Date.now() - jwksCache.timestamp < JWKS_CACHE_TTL) {
+        console.log('Using cached JWKS with', jwksCache.keys.length, 'keys');
+        return jwksCache.keys;
+    }
+    try {
+        // Decode the publishable key to get the frontend API domain
+        // Format: pk_test_<base64> or pk_live_<base64>
+        const parts = publishableKey.split('_');
+        if (parts.length < 3) {
+            console.error('Invalid publishable key format');
+            return [];
+        }
+        const base64Part = parts.slice(2).join('_');
+        const decoded = atob(base64Part);
+        // The decoded value should be the domain (e.g., "climbing-oyster-86.clerk.accounts.dev$")
+        // Remove trailing $ if present
+        const domain = decoded.replace(/\$+$/, '');
+        console.log('Decoded Clerk domain:', domain);
+        // Clerk JWKS endpoint format: https://<frontend-api>/.well-known/jwks.json
+        const jwksUrl = `https://${domain}/.well-known/jwks.json`;
+        console.log('Fetching JWKS from:', jwksUrl);
+        const response = await fetch(jwksUrl);
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error('Failed to fetch JWKS:', response.status, errorText);
+            return [];
+        }
+        const jwks = await response.json();
+        console.log('Successfully fetched', jwks.keys?.length || 0, 'JWKS keys');
+        // Log the key IDs for debugging
+        if (jwks.keys) {
+            console.log('Available key IDs:', jwks.keys.map(k => k.kid).join(', '));
+        }
+        // Update cache
+        jwksCache = {
+            keys: jwks.keys,
+            timestamp: Date.now(),
+        };
+        return jwks.keys;
+    }
+    catch (error) {
+        console.error('Error fetching JWKS:', error);
+        return [];
+    }
+}
+// Convert base64url-encoded RSA components to CryptoKey
+async function importRSAKey(jwk) {
+    try {
+        const keyData = {
+            kty: jwk.kty,
+            n: jwk.n,
+            e: jwk.e,
+            alg: jwk.alg,
+            ext: true,
+            key_ops: ['verify'],
+        };
+        return await crypto.subtle.importKey('jwk', keyData, {
+            name: 'RSASSA-PKCS1-v1_5',
+            hash: 'SHA-256',
+        }, false, ['verify']);
+    }
+    catch (error) {
+        console.error('Error importing RSA key:', error);
+        return null;
+    }
+}
+// Verify JWT signature
+async function verifySignature(token, publicKey) {
+    try {
+        const parts = token.split('.');
+        const signature = base64UrlDecode(parts[2]);
+        const data = new TextEncoder().encode(`${parts[0]}.${parts[1]}`);
+        return await crypto.subtle.verify('RSASSA-PKCS1-v1_5', publicKey, signature, data);
+    }
+    catch (error) {
+        console.error('Error verifying signature:', error);
+        return false;
+    }
+}
+// Verify JWT token using Clerk's JWKS
+export async function verifyClerkToken(token, publishableKey) {
+    try {
+        // Parse JWT to get header and payload
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            console.error('Invalid JWT format');
+            return null;
+        }
+        const header = JSON.parse(base64UrlDecodeString(parts[0]));
+        const payload = JSON.parse(base64UrlDecodeString(parts[1]));
+        console.log('JWT Header kid:', header.kid);
+        console.log('JWT Payload sub:', payload.sub);
+        // Check if token is expired
+        if (payload.exp && payload.exp < Math.floor(Date.now() / 1000)) {
+            console.error('Token expired');
+            return null;
+        }
+        // Verify required claims
+        if (!payload.sub) {
+            console.error('Missing sub claim');
+            return null;
+        }
+        // Fetch JWKS and find the matching key
+        const jwks = await fetchJWKS(publishableKey);
+        console.log('Looking for kid:', header.kid, 'in', jwks.length, 'keys');
+        const jwk = jwks.find((key) => key.kid === header.kid);
+        if (!jwk) {
+            console.error('No matching JWK found for kid:', header.kid);
+            console.error('Available kids:', jwks.map(k => k.kid).join(', '));
+            return null;
+        }
+        // Import the public key
+        const publicKey = await importRSAKey(jwk);
+        if (!publicKey) {
+            console.error('Failed to import public key');
+            return null;
+        }
+        // Verify the signature
+        const isValid = await verifySignature(token, publicKey);
+        if (!isValid) {
+            console.error('Invalid signature');
+            return null;
+        }
+        // Token is valid, return user info
+        return {
+            id: payload.sub,
+            email: payload.email || payload.primary_email_address_id || '',
+            name: payload.name || payload.first_name || payload.given_name || '',
+        };
+    }
+    catch (error) {
+        console.error('Clerk token verification failed:', error);
+        return null;
+    }
+}
+export function extractBearerToken(authHeader) {
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return null;
+    }
+    return authHeader.substring(7);
+}

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

@@ -0,0 +1,62 @@
+import type { Prisma } from '@prisma/client';
+export type DeliveryZoneDBResponse = Prisma.DeliveryZoneGetPayload<{
+    include: {
+        brand: true;
+        state: true;
+    };
+}>;
+export type StateDBResponse = Prisma.StateGetPayload<{
+    include?: {
+        deliveryZones?: true;
+    };
+}>;
+export declare function formatStateResponse(state: StateDBResponse & {
+    deliveryZones?: any[];
+}): {
+    zonesCount: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+    name: string;
+    id: string;
+    isActive: boolean;
+    deliveryZones?: any[];
+};
+export declare function formatDeliveryZoneResponse(deliveryZone: DeliveryZoneDBResponse): {
+    deliveryCost: number;
+    freeShippingThreshold: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        name: string;
+        id: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    stateName: string;
+    brandName: string;
+    state: {
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        deletedAt: Date | null;
+        isActive: boolean;
+    };
+    name: string;
+    id: string;
+    brandId: string | null;
+    stateId: string;
+    allowCOD: boolean;
+    allowOnline: boolean;
+    waybillOnly: boolean;
+    estimatedDays: number | null;
+    isActive: boolean;
+};

package/dist/apps/backend/src/lib/delivery-zone-response.js

@@ -0,0 +1,24 @@
+import { formatBrandResponse } from "./brand-response";
+import { toNumber } from "./utils";
+export function formatStateResponse(state) {
+    return {
+        ...state,
+        zonesCount: state.deliveryZones?.length || 0,
+        createdAt: state.createdAt.toISOString(),
+        updatedAt: state.updatedAt.toISOString(),
+        deletedAt: state.deletedAt ? state.deletedAt.toISOString() : null,
+    };
+}
+export function formatDeliveryZoneResponse(deliveryZone) {
+    return {
+        ...deliveryZone,
+        deliveryCost: toNumber(deliveryZone.deliveryCost),
+        freeShippingThreshold: deliveryZone.freeShippingThreshold ? toNumber(deliveryZone.freeShippingThreshold) : null,
+        createdAt: deliveryZone.createdAt.toISOString(),
+        updatedAt: deliveryZone.updatedAt.toISOString(),
+        deletedAt: deliveryZone.deletedAt ? deliveryZone.deletedAt.toISOString() : null,
+        brand: deliveryZone.brand ? formatBrandResponse(deliveryZone.brand) : null,
+        stateName: deliveryZone.state?.name || '',
+        brandName: deliveryZone.brand?.name || null,
+    };
+}