@instockng/api-client 1.0.8 → 1.0.10

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

@@ -1,147 +0,0 @@
-/**
- * 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

@@ -1,121 +0,0 @@
-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;
-        id: string;
-        name: 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;
-        type: string;
-        value: Prisma.Decimal;
-        createdAt: Date;
-        updatedAt: Date;
-        deletedAt: Date | null;
-        brandId: string | null;
-        isActive: boolean;
-        code: string;
-        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: {
-                id: string;
-                name: string;
-                slug: string;
-                createdAt: Date;
-                updatedAt: Date;
-                deletedAt: Date | null;
-                brandId: string;
-                isActive: boolean;
-                description: string | null;
-                thumbnailUrl: string | null;
-                quantityDiscounts: Prisma.JsonValue | null;
-            };
-            id: string;
-            name: string | null;
-            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

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

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

@@ -1,190 +0,0 @@
-import { captureException } from './sentry';
-// 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);
-            // Capture JWKS fetch errors
-            captureException(new Error(`Failed to fetch JWKS: ${response.status} ${errorText}`), {
-                level: 'error',
-                tags: {
-                    error_type: 'clerk_jwks_fetch_error',
-                    http_status: response.status.toString(),
-                },
-                extra: {
-                    jwksUrl: jwksUrl,
-                    publishableKey: publishableKey.substring(0, 20) + '...', // Truncate for security
-                },
-            });
-            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);
-        // Capture JWKS exception errors
-        captureException(error instanceof Error ? error : new Error(String(error)), {
-            level: 'error',
-            tags: {
-                error_type: 'clerk_jwks_exception',
-            },
-            extra: {
-                publishableKey: publishableKey.substring(0, 20) + '...', // Truncate for security
-            },
-        });
-        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

@@ -1,64 +0,0 @@
-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;
-    id: string;
-    name: 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;
-        id: string;
-        name: string;
-        slug: string;
-        logoUrl: string | null;
-        siteUrl: string;
-        domain: string;
-        metaPixelId: string | null;
-    };
-    stateName: string;
-    brandName: string;
-    state: {
-        id: string;
-        name: string;
-        createdAt: Date;
-        updatedAt: Date;
-        deletedAt: Date | null;
-        isActive: boolean;
-    };
-    id: string;
-    name: string;
-    brandId: string | null;
-    stateId: string;
-    allowCOD: boolean;
-    allowOnline: boolean;
-    waybillOnly: boolean;
-    estimatedDays: number | null;
-    noteTitle: string | null;
-    noteContent: string | null;
-    isActive: boolean;
-};