@instockng/api-client 1.0.6 → 1.0.8

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

@@ -0,0 +1,30 @@
+import { PrismaClient } from '@prisma/client';
+import { PrismaNeon } from '@prisma/adapter-neon';
+import { neonConfig } from '@neondatabase/serverless';
+// Configure Neon for WebSocket connections globally (required for Cloudflare Workers)
+// @ts-ignore-next-line
+neonConfig.webSocketConstructor = WebSocket;
+/**
+ * Creates a new Prisma client for each request.
+ *
+ * IMPORTANT: In Cloudflare Workers, we CANNOT use a singleton pattern because
+ * I/O objects (like database connections) cannot be shared across different requests.
+ * Each request must create its own Prisma instance.
+ */
+export function getPrismaClient(databaseUrl) {
+    if (!databaseUrl) {
+        throw new Error('DATABASE_URL is required but not provided');
+    }
+    // Prisma 6.6.0+ changed the Driver Adapters API
+    // The adapter now takes connectionString directly, not a Pool
+    const adapter = new PrismaNeon({ connectionString: databaseUrl });
+    // Create a new Prisma Client for this request
+    const prisma = new PrismaClient({
+        adapter,
+        log: process.env.NODE_ENV === 'development' ? ['error', 'warn'] : ['error'],
+    });
+    return prisma;
+}
+// Note: Prisma v6 removed $use middleware API
+// Soft delete logic is now handled directly in queries (where: { deletedAt: null })
+// For soft deletes, use: prisma.model.update({ where: { id }, data: { deletedAt: new Date() } })

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

@@ -0,0 +1,82 @@
+import { Prisma } from '@prisma/client';
+export declare const PRODUCT_INCLUDE_FULL: {
+    brand: boolean;
+    variants: {
+        where: {
+            deletedAt: any;
+        };
+    };
+};
+export declare const PRODUCT_INCLUDE_FULL_PUBLIC: {
+    brand: boolean;
+    variants: {
+        where: {
+            isActive: boolean;
+            deletedAt: any;
+        };
+    };
+};
+export type ProductDBResponse = Prisma.ProductGetPayload<{
+    include: {
+        brand: true;
+        variants: true;
+    };
+}>;
+export type ProductVariantDBResponse = Prisma.ProductVariantGetPayload<{
+    include: {
+        product: false;
+    };
+}>;
+export declare function formatProductResponse(product: ProductDBResponse): {
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    variants: {
+        createdAt: string;
+        updatedAt: string;
+        price: number;
+        deletedAt: string;
+        id: string;
+        name: string | null;
+        isActive: boolean;
+        thumbnailUrl: string | null;
+        productId: string;
+        sku: string;
+        trackInventory: boolean;
+        lowStockThreshold: number | null;
+    }[];
+    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;
+};
+export declare function formatProductVariantResponse(variant: ProductVariantDBResponse): {
+    createdAt: string;
+    updatedAt: string;
+    price: number;
+    deletedAt: string;
+    id: string;
+    name: string | null;
+    isActive: boolean;
+    thumbnailUrl: string | null;
+    productId: string;
+    sku: string;
+    trackInventory: boolean;
+    lowStockThreshold: number | null;
+};

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

@@ -0,0 +1,29 @@
+import { formatBrandResponse } from './brand-response';
+export const PRODUCT_INCLUDE_FULL = {
+    brand: true,
+    variants: {
+        where: { deletedAt: null },
+    },
+};
+export const PRODUCT_INCLUDE_FULL_PUBLIC = {
+    brand: true,
+    variants: {
+        where: { isActive: true, deletedAt: null },
+    },
+};
+export function formatProductResponse(product) {
+    return {
+        ...product,
+        brand: formatBrandResponse(product.brand),
+        variants: product.variants.map(formatProductVariantResponse),
+    };
+}
+export function formatProductVariantResponse(variant) {
+    return {
+        ...variant,
+        createdAt: variant.createdAt.toISOString(),
+        updatedAt: variant.updatedAt.toISOString(),
+        price: parseFloat(variant.price.toString()),
+        deletedAt: variant.deletedAt ? variant.deletedAt.toISOString() : null,
+    };
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Sentry error tracking for Cloudflare Workers
+ *
+ * This module provides utilities for capturing errors, exceptions, and messages
+ * with proper context and sampling rates.
+ *
+ * Sentry is initialized via withSentry() wrapper in index.ts
+ */
+import type { Context } from 'hono';
+/**
+ * Capture an exception with request context
+ */
+export declare function captureException(error: Error | unknown, context?: {
+    level?: 'fatal' | 'error' | 'warning';
+    tags?: Record<string, string>;
+    extra?: Record<string, any>;
+    fingerprint?: string[];
+    honoContext?: Context<any>;
+}): void;
+/**
+ * Capture a message with context (for non-exception events)
+ */
+export declare function captureMessage(message: string, context?: {
+    level?: 'fatal' | 'error' | 'warning' | 'info' | 'debug';
+    tags?: Record<string, string>;
+    extra?: Record<string, any>;
+    sampleRate?: number;
+}): void;
+/**
+ * Add breadcrumb for tracing event flow
+ */
+export declare function addBreadcrumb(message: string, data?: Record<string, any>, category?: string): void;
+/**
+ * Wrap a function with Sentry error capturing
+ */
+export declare function withSentry<T extends (...args: any[]) => any>(fn: T, context?: {
+    tags?: Record<string, string>;
+    extra?: Record<string, any>;
+}): T;
+/**
+ * Helper to determine if an error should be tracked in Sentry
+ * based on its characteristics (e.g., status code, error code)
+ */
+export declare function shouldTrackError(statusCode: number, errorCode?: string): boolean;
+/**
+ * Get sample rate for different error types
+ */
+export declare function getSampleRate(errorCode: string): number;

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

@@ -0,0 +1,180 @@
+/**
+ * Sentry error tracking for Cloudflare Workers
+ *
+ * This module provides utilities for capturing errors, exceptions, and messages
+ * with proper context and sampling rates.
+ *
+ * Sentry is initialized via withSentry() wrapper in index.ts
+ */
+import * as Sentry from '@sentry/cloudflare';
+/**
+ * Capture an exception with request context
+ */
+export function captureException(error, context) {
+    Sentry.withScope((scope) => {
+        // Set severity level
+        if (context?.level) {
+            scope.setLevel(context.level);
+        }
+        // Add tags for filtering/grouping
+        if (context?.tags) {
+            Object.entries(context.tags).forEach(([key, value]) => {
+                scope.setTag(key, value);
+            });
+        }
+        // Add extra context data
+        if (context?.extra) {
+            Object.entries(context.extra).forEach(([key, value]) => {
+                scope.setExtra(key, value);
+            });
+        }
+        // Custom fingerprint for grouping
+        if (context?.fingerprint) {
+            scope.setFingerprint(context.fingerprint);
+        }
+        // Add request context from Hono if available
+        if (context?.honoContext) {
+            const c = context.honoContext;
+            const req = c.req;
+            // Set request context
+            scope.setContext('request', {
+                url: req.url,
+                method: req.method,
+                headers: sanitizeHeaders(req.header()),
+            });
+            // Add user context if authenticated
+            const user = c.get('user');
+            if (user) {
+                scope.setUser({
+                    id: user.id,
+                    email: user.email,
+                    username: user.name,
+                });
+            }
+            // Add brand context if available
+            const brandSlug = req.param('brandSlug') || req.query('brandSlug');
+            if (brandSlug) {
+                scope.setTag('brand', brandSlug);
+            }
+        }
+        // Capture the exception
+        Sentry.captureException(error);
+    });
+}
+/**
+ * Capture a message with context (for non-exception events)
+ */
+export function captureMessage(message, context) {
+    // Apply sampling if specified
+    if (context?.sampleRate !== undefined && Math.random() > context.sampleRate) {
+        return; // Skip this capture based on sample rate
+    }
+    Sentry.withScope((scope) => {
+        if (context?.level) {
+            scope.setLevel(context.level);
+        }
+        if (context?.tags) {
+            Object.entries(context.tags).forEach(([key, value]) => {
+                scope.setTag(key, value);
+            });
+        }
+        if (context?.extra) {
+            Object.entries(context.extra).forEach(([key, value]) => {
+                scope.setExtra(key, value);
+            });
+        }
+        Sentry.captureMessage(message, context?.level || 'info');
+    });
+}
+/**
+ * Add breadcrumb for tracing event flow
+ */
+export function addBreadcrumb(message, data, category) {
+    Sentry.addBreadcrumb({
+        message,
+        data,
+        category: category || 'default',
+        level: 'info',
+    });
+}
+/**
+ * Wrap a function with Sentry error capturing
+ */
+export function withSentry(fn, context) {
+    return ((...args) => {
+        try {
+            const result = fn(...args);
+            // Handle async functions
+            if (result instanceof Promise) {
+                return result.catch((error) => {
+                    captureException(error, context);
+                    throw error;
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            captureException(error, context);
+            throw error;
+        }
+    });
+}
+/**
+ * Sanitize headers to remove sensitive data
+ */
+function sanitizeHeaders(headers) {
+    const sanitized = {};
+    const sensitiveHeaders = ['authorization', 'cookie', 'x-api-key'];
+    Object.entries(headers).forEach(([key, value]) => {
+        if (sensitiveHeaders.includes(key.toLowerCase())) {
+            sanitized[key] = '[REDACTED]';
+        }
+        else {
+            sanitized[key] = value;
+        }
+    });
+    return sanitized;
+}
+/**
+ * Helper to determine if an error should be tracked in Sentry
+ * based on its characteristics (e.g., status code, error code)
+ */
+export function shouldTrackError(statusCode, errorCode) {
+    // Always track 500 errors
+    if (statusCode >= 500) {
+        return true;
+    }
+    // Don't track expected client errors
+    const expectedErrors = ['UNAUTHORIZED', 'NOT_FOUND'];
+    if (errorCode && expectedErrors.includes(errorCode)) {
+        return false;
+    }
+    // Track other 4xx errors with sampling
+    return statusCode >= 400;
+}
+/**
+ * Get sample rate for different error types
+ */
+export function getSampleRate(errorCode) {
+    const sampleRates = {
+        // High-volume, expected errors - low sample rate
+        CART_EXPIRED: 0.1,
+        NOT_FOUND: 0.05,
+        CART_NOT_FOUND: 0.05,
+        ORDER_NOT_FOUND: 0.05,
+        VARIANT_NOT_FOUND: 0.05,
+        // Medium-volume errors - moderate sample rate
+        INVALID_DISCOUNT_CODE: 0.2,
+        MIN_PURCHASE_NOT_MET: 0.15,
+        PAYMENT_METHOD_NOT_AVAILABLE: 0.25,
+        INVALID_DELIVERY_ZONE: 0.3,
+        PRECONDITION_FAILED: 0.5,
+        // Low-volume errors - higher sample rate
+        BAD_REQUEST: 0.1,
+        CODE_EXISTS: 1.0,
+        STATE_EXISTS: 1.0,
+        // Default for unknown errors
+        DEFAULT: 1.0,
+    };
+    return sampleRates[errorCode] ?? sampleRates.DEFAULT;
+}

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

@@ -0,0 +1,32 @@
+import { Decimal } from '@prisma/client/runtime/library';
+export { WHATSAPP_HELP_NUMBER, WHATSAPP_HELP_NUMBER_FORMATTED, WHATSAPP_HELP_LINK } from '@oms/shared';
+/**
+ * Convert Decimal to number for JSON responses
+ */
+export declare function toNumber(value: number | Decimal): number;
+/**
+ * Round to 2 decimal places (for monetary values in Naira)
+ */
+export declare function round(value: number): number;
+export declare function formatCurrency(amount: number | string | Decimal | null | undefined): string;
+export declare function formatDate(date: Date | string): string;
+export interface PaginationParams {
+    page?: number;
+    limit?: number;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+}
+export declare function getPaginationParams(params: PaginationParams): {
+    page: number;
+    limit: number;
+    skip: number;
+};
+export declare function createPaginatedResponse<T>(data: T[], total: number, page: number, limit: number): PaginatedResponse<T>;
+export declare function generateSlug(text: string): string;

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

@@ -0,0 +1,63 @@
+// Re-export shared constants
+export { WHATSAPP_HELP_NUMBER, WHATSAPP_HELP_NUMBER_FORMATTED, WHATSAPP_HELP_LINK } from '@oms/shared';
+/**
+ * Convert Decimal to number for JSON responses
+ */
+export function toNumber(value) {
+    if (typeof value === 'number')
+        return value;
+    return parseFloat(value.toString());
+}
+/**
+ * Round to 2 decimal places (for monetary values in Naira)
+ */
+export function round(value) {
+    return Math.round(value * 100) / 100;
+}
+export function formatCurrency(amount) {
+    if (amount === null || amount === undefined) {
+        return '₦0.00';
+    }
+    const numericAmount = typeof amount === 'string' ? parseFloat(amount) : toNumber(amount) ?? 0;
+    if (isNaN(numericAmount)) {
+        return '₦0.00';
+    }
+    return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'NGN',
+    }).format(numericAmount);
+}
+export function formatDate(date) {
+    const d = typeof date === 'string' ? new Date(date) : date;
+    return d.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+    });
+}
+export function getPaginationParams(params) {
+    const page = Math.max(1, params.page || 1);
+    const limit = Math.min(100, Math.max(1, params.limit || 20));
+    const skip = (page - 1) * limit;
+    return { page, limit, skip };
+}
+export function createPaginatedResponse(data, total, page, limit) {
+    return {
+        data,
+        pagination: {
+            page,
+            limit,
+            total,
+            totalPages: Math.ceil(total / limit),
+        },
+    };
+}
+// Generate a URL-friendly slug from a string
+export function generateSlug(text) {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, '') // Remove non-word chars (except spaces and hyphens)
+        .replace(/[\s_-]+/g, '-') // Replace spaces, underscores, and multiple hyphens with single hyphen
+        .replace(/^-+|-+$/g, ''); // Remove leading/trailing hyphens
+}

package/dist/apps/backend/src/middleware/clerk-auth.d.ts

@@ -0,0 +1,8 @@
+import { Context, Next } from 'hono';
+export declare function clerkAuthMiddleware(c: Context, next: Next): Promise<Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 401, "json">>;

package/dist/apps/backend/src/middleware/clerk-auth.js

@@ -0,0 +1,89 @@
+import { verifyClerkToken, extractBearerToken } from '../lib/clerk';
+import { getPrismaClient } from '../lib/prisma';
+export async function clerkAuthMiddleware(c, next) {
+    const authHeader = c.req.header('Authorization');
+    const token = extractBearerToken(authHeader);
+    console.log('Authenticating request with token');
+    if (!token) {
+        return c.json({
+            success: false,
+            error: {
+                code: 'UNAUTHORIZED',
+                message: 'Missing authentication token',
+            },
+        }, 401);
+    }
+    const clerkUser = await verifyClerkToken(token, c.env.CLERK_PUBLISHABLE_KEY);
+    console.log(clerkUser);
+    if (!clerkUser) {
+        return c.json({
+            success: false,
+            error: {
+                code: 'UNAUTHORIZED',
+                message: 'Invalid authentication token',
+            },
+        }, 401);
+    }
+    // Ensure user exists in database (auto-provisioning)
+    const prisma = getPrismaClient(c.env.DATABASE_URL);
+    // First check if user exists
+    let dbUser = await prisma.user.findUnique({
+        where: { clerkId: clerkUser.id },
+    });
+    // If user doesn't exist, fetch their details from Clerk API and create them
+    if (!dbUser) {
+        console.log('User not found in database, fetching details from Clerk API');
+        try {
+            const userResponse = await fetch(`https://api.clerk.com/v1/users/${clerkUser.id}`, {
+                headers: {
+                    Authorization: `Bearer ${c.env.CLERK_SECRET_KEY}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (userResponse.ok) {
+                const userData = await userResponse.json();
+                console.log('Fetched user data from Clerk API');
+                const email = userData.email_addresses?.[0]?.email_address || userData.primary_email_address || `${clerkUser.id}@unknown.clerk`;
+                const name = userData.first_name && userData.last_name
+                    ? `${userData.first_name} ${userData.last_name}`.trim()
+                    : userData.first_name || userData.last_name || null;
+                dbUser = await prisma.user.create({
+                    data: {
+                        clerkId: clerkUser.id,
+                        email,
+                        name,
+                        role: 'admin',
+                    },
+                });
+            }
+            else {
+                console.error('Failed to fetch user from Clerk API:', userResponse.status);
+                // Create user with minimal info
+                dbUser = await prisma.user.create({
+                    data: {
+                        clerkId: clerkUser.id,
+                        email: `${clerkUser.id}@unknown.clerk`,
+                        name: null,
+                        role: 'admin',
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.error('Error fetching user from Clerk API:', error);
+            // Create user with minimal info
+            dbUser = await prisma.user.create({
+                data: {
+                    clerkId: clerkUser.id,
+                    email: `${clerkUser.id}@unknown.clerk`,
+                    name: null,
+                    role: 'admin',
+                },
+            });
+        }
+    }
+    // Store both Clerk user and database user in context for later use
+    c.set('user', clerkUser);
+    c.set('dbUser', dbUser);
+    await next();
+}

package/dist/apps/backend/src/middleware/cors.d.ts

@@ -0,0 +1,8 @@
+import { HonoRequest, Next } from 'hono';
+import { Env } from '../types';
+export declare function corsMiddleware(c: {
+    env: Env;
+    req: HonoRequest;
+    header: (name: string, value: string) => void;
+    body: (body: any, status: number) => Response;
+}, next: Next): Promise<Response>;

package/dist/apps/backend/src/middleware/cors.js

@@ -0,0 +1,11 @@
+export async function corsMiddleware(c, next) {
+    c.header('Access-Control-Allow-Origin', '*');
+    c.header('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+    c.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key');
+    c.header('Access-Control-Allow-Credentials', 'true');
+    // Handle preflight requests
+    if (c.req.method === 'OPTIONS') {
+        return c.body(null, 204);
+    }
+    await next();
+}

package/dist/apps/backend/src/notifications/producers/meta-capi-producer.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Meta Conversions API Event Producer
+ *
+ * Queues Meta CAPI events for processing by the queue consumer.
+ */
+import { Env } from '../../types';
+import { OrderDBResponse } from '../../lib/order-response';
+/**
+ * Queue an AddToCart event
+ */
+export declare function enqueueAddToCartEvent(env: Env, data: {
+    cartId: string;
+    itemId: string;
+    pixelId: string | null;
+    brandSiteUrl: string;
+    productName: string;
+    productSlug: string;
+    sku: string;
+    price: number;
+    quantity: number;
+    customerEmail?: string | null;
+    customerPhone?: string | null;
+    clientIpAddress?: string;
+    clientUserAgent?: string;
+    fbc?: string;
+    fbp?: string;
+}): Promise<void>;
+/**
+ * Queue an InitiateCheckout event
+ */
+export declare function enqueueInitiateCheckoutEvent(env: Env, data: {
+    cartId: string;
+    pixelId: string | null;
+    brandSiteUrl: string;
+    cartTotal: number;
+    itemCount: number;
+    customerEmail?: string | null;
+    customerPhone?: string | null;
+    clientIpAddress?: string;
+    clientUserAgent?: string;
+    fbc?: string;
+    fbp?: string;
+}): Promise<void>;
+/**
+ * Queue a Purchase event from an order
+ *
+ * For orders with multiple products, uses the brand's homepage
+ * since there's no single product page to reference.
+ */
+export declare function enqueuePurchaseEvent(env: Env, order: OrderDBResponse, options?: {
+    clientIpAddress?: string;
+    clientUserAgent?: string;
+    fbc?: string;
+    fbp?: string;
+}): Promise<void>;
+/**
+ * Queue a ConfirmedPurchase event when order is delivered & paid
+ *
+ * This event tracks successful order completion (delivered + paid),
+ * which is a higher value conversion signal than initial purchase.
+ */
+export declare function enqueueConfirmedPurchaseEvent(env: Env, order: OrderDBResponse): Promise<void>;