@rovela-ai/sdk 0.3.34 → 0.4.1

package/dist/core/db/queries.js

@@ -1,1932 +0,0 @@
-/**
- * @rovela/sdk/core/db/queries
- *
- * Type-safe query helpers for e-commerce stores
- * Each store has its own database (via Neon branches) - no tenant filtering needed
- */
-import { eq, and, or, desc, asc, ilike, sql, inArray, isNull, isNotNull } from 'drizzle-orm';
-import { getDb } from './client';
-import * as schema from './schema';
-/**
- * Find products with filtering, sorting, and pagination
- */
-export async function findProducts(options = {}) {
-    const db = getDb();
-    const conditions = [];
-    if (options.categoryId) {
-        conditions.push(eq(schema.products.categoryId, options.categoryId));
-    }
-    if (options.status) {
-        conditions.push(eq(schema.products.status, options.status));
-    }
-    if (options.search) {
-        conditions.push(ilike(schema.products.name, `%${options.search}%`));
-    }
-    if (options.outOfStock) {
-        conditions.push(buildOutOfStockCondition());
-    }
-    if (options.onSale) {
-        conditions.push(sql `${schema.products.comparePrice} IS NOT NULL AND ${schema.products.comparePrice} > ${schema.products.price}`);
-    }
-    if (options.tags && options.tags.length > 0) {
-        // JSONB array-overlap check: `tags ?| array['t1','t2']` returns true when
-        // ANY tag in the column matches ANY of the provided tags. Powered by the
-        // default GIN index on jsonb columns when present.
-        conditions.push(sql `${schema.products.tags} ?| ${options.tags}`);
-    }
-    // Determine sort order
-    let orderBy;
-    switch (options.sort) {
-        case 'price-asc':
-            orderBy = asc(schema.products.price);
-            break;
-        case 'price-desc':
-            orderBy = desc(schema.products.price);
-            break;
-        case 'name':
-            orderBy = asc(schema.products.name);
-            break;
-        case 'newest':
-        default:
-            orderBy = desc(schema.products.createdAt);
-    }
-    const query = db
-        .select()
-        .from(schema.products)
-        .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(orderBy);
-    if (options.limit) {
-        query.limit(options.limit);
-    }
-    if (options.offset) {
-        query.offset(options.offset);
-    }
-    return query;
-}
-/**
- * Find a single product by slug
- */
-export async function findProductBySlug(slug) {
-    const db = getDb();
-    const result = await db
-        .select()
-        .from(schema.products)
-        .where(eq(schema.products.slug, slug))
-        .limit(1);
-    return result[0] || null;
-}
-/**
- * Find a single product by ID
- */
-export async function findProductById(id) {
-    const db = getDb();
-    const result = await db
-        .select()
-        .from(schema.products)
-        .where(eq(schema.products.id, id))
-        .limit(1);
-    return result[0] || null;
-}
-/**
- * Get product variants for a product
- */
-export async function findProductVariants(productId) {
-    const db = getDb();
-    return db
-        .select()
-        .from(schema.productVariants)
-        .where(eq(schema.productVariants.productId, productId));
-}
-/**
- * Count total products matching filters
- */
-export async function countProducts(options = {}) {
-    const db = getDb();
-    const conditions = [];
-    if (options.categoryId) {
-        conditions.push(eq(schema.products.categoryId, options.categoryId));
-    }
-    if (options.status) {
-        conditions.push(eq(schema.products.status, options.status));
-    }
-    if (options.search) {
-        conditions.push(ilike(schema.products.name, `%${options.search}%`));
-    }
-    if (options.outOfStock) {
-        conditions.push(buildOutOfStockCondition());
-    }
-    const result = await db
-        .select({ count: sql `count(*)` })
-        .from(schema.products)
-        .where(conditions.length > 0 ? and(...conditions) : undefined);
-    return Number(result[0]?.count || 0);
-}
-/**
- * Build the SQL condition for "effectively out of stock":
- *   - non-variant products: trackInventory=true AND inventory <= 0
- *   - variant products:     no variant exists with inventory > 0
- *
- * Reused by both `findProducts` (the OOS chip filter) and the OOS metric card.
- * The variant subquery uses `product_variants_product_id_idx` (already in schema)
- * so it's an index lookup, not a scan.
- */
-function buildOutOfStockCondition() {
-    return or(and(eq(schema.products.hasVariants, false), eq(schema.products.trackInventory, true), sql `${schema.products.inventory} <= 0`), and(eq(schema.products.hasVariants, true), sql `NOT EXISTS (
-        SELECT 1 FROM ${schema.productVariants} pv
-        WHERE pv.product_id = ${schema.products.id} AND pv.inventory > 0
-      )`));
-}
-// =============================================================================
-// Product Metrics & Inventory Aggregation (admin product list page)
-// =============================================================================
-/**
- * For products with `hasVariants=true`, the parent `products.inventory` column
- * is unused — inventory lives on `product_variants`. This helper returns a
- * Map of `productId → effectiveInventory` for an arbitrary set of variant
- * product IDs. The page-list handler calls this for the products it just
- * returned and merges the sums into each row before responding to the client.
- *
- * Empty input → empty map. Single SQL query, GROUP BY product_id.
- */
-export async function getInventoryByProductIds(productIds) {
-    if (productIds.length === 0)
-        return new Map();
-    const db = getDb();
-    const rows = await db
-        .select({
-        productId: schema.productVariants.productId,
-        total: sql `COALESCE(SUM(${schema.productVariants.inventory}), 0)`,
-    })
-        .from(schema.productVariants)
-        .where(inArray(schema.productVariants.productId, productIds))
-        .groupBy(schema.productVariants.productId);
-    const result = new Map();
-    for (const r of rows) {
-        result.set(r.productId, Number(r.total) || 0);
-    }
-    return result;
-}
-/**
- * Count of products in `status='active'`. Drives the "Active products"
- * metric card on the admin product list page.
- */
-export async function getActiveProductCount() {
-    const db = getDb();
-    const result = await db
-        .select({ count: sql `count(*)` })
-        .from(schema.products)
-        .where(eq(schema.products.status, 'active'));
-    return Number(result[0]?.count || 0);
-}
-/**
- * Count of *active* products that are effectively out of stock. Excludes
- * drafts / archived (they're irrelevant noise on the product list view).
- *
- * Uses the same OOS condition as the chip filter (single source of truth).
- */
-export async function getOutOfStockProductCount() {
-    const db = getDb();
-    const result = await db
-        .select({ count: sql `count(*)` })
-        .from(schema.products)
-        .where(and(eq(schema.products.status, 'active'), buildOutOfStockCondition()));
-    return Number(result[0]?.count || 0);
-}
-/**
- * Best-selling product over the last `days` window, by units sold.
- *
- * Counts only orders that actually moved revenue: `paid`, `shipped`,
- * `delivered`. Excludes pending (might fail), cancelled, refunded, and
- * return_requested (not yet finalized).
- *
- * Returns null when no qualifying orders exist in the window — the UI
- * renders an empty state rather than a broken card.
- */
-export async function getBestSellerProduct(days = 30) {
-    const db = getDb();
-    const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
-    const rows = await db
-        .select({
-        id: schema.products.id,
-        name: schema.products.name,
-        unitsSold: sql `SUM(${schema.orderItems.quantity})`,
-        revenue: sql `SUM(${schema.orderItems.quantity} * ${schema.orderItems.price})`,
-    })
-        .from(schema.orderItems)
-        .innerJoin(schema.orders, eq(schema.orders.id, schema.orderItems.orderId))
-        .innerJoin(schema.products, eq(schema.products.id, schema.orderItems.productId))
-        .where(and(inArray(schema.orders.status, ['paid', 'shipped', 'delivered']), sql `${schema.orders.createdAt} >= ${since}`))
-        .groupBy(schema.products.id, schema.products.name)
-        .orderBy(desc(sql `SUM(${schema.orderItems.quantity})`))
-        .limit(1);
-    const row = rows[0];
-    if (!row)
-        return null;
-    return {
-        id: row.id,
-        name: row.name,
-        unitsSold: Number(row.unitsSold) || 0,
-        revenue: String(row.revenue ?? '0'),
-    };
-}
-/**
- * Best-selling products in the last N days, capped to `limit`.
- *
- * Same SQL shape as `getBestSellerProduct` (paid+shipped+delivered window,
- * ordered by units sold desc) but returns up to `limit` rows. Used by the
- * Best Sellers homepage section card. Returns an empty array when no
- * qualifying orders exist — callers MUST hide their UI when length === 0
- * (don't render an empty rail).
- *
- * `order_items_product_id_idx` covers the JOIN; cost is the same as the
- * existing single-row helper.
- */
-export async function getBestSellers(days = 30, limit = 8) {
-    const db = getDb();
-    const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
-    const rows = await db
-        .select({
-        id: schema.products.id,
-        slug: schema.products.slug,
-        name: schema.products.name,
-        price: schema.products.price,
-        comparePrice: schema.products.comparePrice,
-        images: schema.products.images,
-        unitsSold: sql `SUM(${schema.orderItems.quantity})`,
-    })
-        .from(schema.orderItems)
-        .innerJoin(schema.orders, eq(schema.orders.id, schema.orderItems.orderId))
-        .innerJoin(schema.products, eq(schema.products.id, schema.orderItems.productId))
-        .where(and(inArray(schema.orders.status, ['paid', 'shipped', 'delivered']), eq(schema.products.status, 'active'), sql `${schema.orders.createdAt} >= ${since}`))
-        .groupBy(schema.products.id, schema.products.slug, schema.products.name, schema.products.price, schema.products.comparePrice, schema.products.images)
-        .orderBy(desc(sql `SUM(${schema.orderItems.quantity})`))
-        .limit(limit);
-    return rows.map((row) => ({
-        id: row.id,
-        slug: row.slug,
-        name: row.name,
-        price: row.price,
-        comparePrice: row.comparePrice,
-        images: (row.images ?? []),
-        unitsSold: Number(row.unitsSold) || 0,
-    }));
-}
-/**
- * Most-popular products by distinct buyer count (last N days), capped.
- *
- * Different from best sellers — best sellers is units sold (revenue lens);
- * this is buyer reach (how many distinct customers bought it). Used by the
- * Most Popular homepage section card. Same JOIN path; same status window.
- *
- * Excludes guest orders (`customer_id IS NULL`) so we count real distinct
- * buyers, not anonymous sessions. Returns empty array when no data — UI
- * must hide.
- */
-export async function getMostPopularProducts(days = 30, limit = 8) {
-    const db = getDb();
-    const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
-    const rows = await db
-        .select({
-        id: schema.products.id,
-        slug: schema.products.slug,
-        name: schema.products.name,
-        price: schema.products.price,
-        comparePrice: schema.products.comparePrice,
-        images: schema.products.images,
-        buyerCount: sql `COUNT(DISTINCT ${schema.orders.customerId})`,
-    })
-        .from(schema.orderItems)
-        .innerJoin(schema.orders, eq(schema.orders.id, schema.orderItems.orderId))
-        .innerJoin(schema.products, eq(schema.products.id, schema.orderItems.productId))
-        .where(and(inArray(schema.orders.status, ['paid', 'shipped', 'delivered']), eq(schema.products.status, 'active'), isNotNull(schema.orders.customerId), sql `${schema.orders.createdAt} >= ${since}`))
-        .groupBy(schema.products.id, schema.products.slug, schema.products.name, schema.products.price, schema.products.comparePrice, schema.products.images)
-        .orderBy(desc(sql `COUNT(DISTINCT ${schema.orders.customerId})`))
-        .limit(limit);
-    return rows.map((row) => ({
-        id: row.id,
-        slug: row.slug,
-        name: row.name,
-        price: row.price,
-        comparePrice: row.comparePrice,
-        images: (row.images ?? []),
-        buyerCount: Number(row.buyerCount) || 0,
-    }));
-}
-/**
- * Distinct-buyer count for a single product within the last N hours.
- *
- * Powers the "X people bought this in the last 24h" social-proof card on
- * PDPs. Server-only — caller MUST cache via Server Component + ISR
- * (`revalidate: 300`); calling this per page view is a perf trap.
- *
- * Returns 0 when no qualifying orders exist. UI gates on a `minThreshold`
- * (default 5) — never render "1 person bought this" (awkward + reads as
- * dead store).
- */
-export async function getProductRecentBuyerCount(productId, hours = 24) {
-    const db = getDb();
-    const since = new Date(Date.now() - hours * 60 * 60 * 1000);
-    const rows = await db
-        .select({
-        count: sql `COUNT(DISTINCT ${schema.orders.customerId})`,
-    })
-        .from(schema.orderItems)
-        .innerJoin(schema.orders, eq(schema.orders.id, schema.orderItems.orderId))
-        .where(and(eq(schema.orderItems.productId, productId), inArray(schema.orders.status, ['paid', 'shipped', 'delivered']), isNotNull(schema.orders.customerId), sql `${schema.orders.createdAt} >= ${since}`));
-    return Number(rows[0]?.count ?? 0);
-}
-/**
- * Check whether a customer has purchased a specific product.
- *
- * Powers the verified-purchase badge on the C2 reviews card. Returns true
- * iff the customer has at least one paid+shipped+delivered order containing
- * the product (variant-agnostic — buying any variant counts).
- *
- * Uses EXISTS for short-circuit evaluation; cheap even on large order
- * histories. Index `order_items_product_id_idx` covers the inner lookup;
- * `orders_customer_id_idx` covers the join.
- */
-export async function hasCustomerPurchasedProduct(customerId, productId) {
-    const db = getDb();
-    const rows = await db
-        .select({
-        hit: sql `1`,
-    })
-        .from(schema.orderItems)
-        .innerJoin(schema.orders, eq(schema.orders.id, schema.orderItems.orderId))
-        .where(and(eq(schema.orderItems.productId, productId), eq(schema.orders.customerId, customerId), inArray(schema.orders.status, ['paid', 'shipped', 'delivered'])))
-        .limit(1);
-    return rows.length > 0;
-}
-// =============================================================================
-// Categories
-// =============================================================================
-/**
- * Find all categories
- */
-export async function findCategories() {
-    const db = getDb();
-    return db
-        .select()
-        .from(schema.categories)
-        .orderBy(asc(schema.categories.order), asc(schema.categories.name));
-}
-/**
- * Find a category by slug
- */
-export async function findCategoryBySlug(slug) {
-    const db = getDb();
-    const result = await db
-        .select()
-        .from(schema.categories)
-        .where(eq(schema.categories.slug, slug))
-        .limit(1);
-    return result[0] || null;
-}
-/**
- * Find orders with filtering and pagination
- */
-export async function findOrders(options = {}) {
-    const db = getDb();
-    const conditions = [];
-    if (options.status) {
-        conditions.push(eq(schema.orders.status, options.status));
-    }
-    if (options.customerId) {
-        conditions.push(eq(schema.orders.customerId, options.customerId));
-    }
-    const query = db
-        .select()
-        .from(schema.orders)
-        .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(desc(schema.orders.createdAt));
-    if (options.limit) {
-        query.limit(options.limit);
-    }
-    if (options.offset) {
-        query.offset(options.offset);
-    }
-    return query;
-}
-/**
- * Find order by ID with items (includes product images)
- */
-export async function findOrderById(id) {
-    const db = getDb();
-    const order = await db
-        .select()
-        .from(schema.orders)
-        .where(eq(schema.orders.id, id))
-        .limit(1);
-    if (!order[0])
-        return null;
-    // Join order_items with products to get images
-    const itemsWithProducts = await db
-        .select({
-        id: schema.orderItems.id,
-        orderId: schema.orderItems.orderId,
-        productId: schema.orderItems.productId,
-        variantId: schema.orderItems.variantId,
-        name: schema.orderItems.name,
-        price: schema.orderItems.price,
-        quantity: schema.orderItems.quantity,
-        attributes: schema.orderItems.attributes,
-        createdAt: schema.orderItems.createdAt,
-        // Get product images (JSONB array)
-        productImages: schema.products.images,
-    })
-        .from(schema.orderItems)
-        .leftJoin(schema.products, eq(schema.orderItems.productId, schema.products.id))
-        .where(eq(schema.orderItems.orderId, id));
-    // Map items to include the first product image
-    const items = itemsWithProducts.map((item) => {
-        const images = item.productImages;
-        return {
-            id: item.id,
-            orderId: item.orderId,
-            productId: item.productId,
-            variantId: item.variantId,
-            name: item.name,
-            price: item.price,
-            quantity: item.quantity,
-            attributes: item.attributes,
-            createdAt: item.createdAt,
-            // Add first image from product
-            image: images && images.length > 0 ? images[0] : null,
-        };
-    });
-    return {
-        ...order[0],
-        items,
-    };
-}
-/**
- * Get order items for an order
- */
-export async function findOrderItems(orderId) {
-    const db = getDb();
-    return db
-        .select()
-        .from(schema.orderItems)
-        .where(eq(schema.orderItems.orderId, orderId));
-}
-// =============================================================================
-// Customers
-// =============================================================================
-/**
- * Find customer by email
- */
-export async function findCustomerByEmail(email) {
-    const db = getDb();
-    const result = await db
-        .select()
-        .from(schema.customers)
-        .where(eq(schema.customers.email, email.toLowerCase()))
-        .limit(1);
-    return result[0] || null;
-}
-/**
- * Find customer by ID
- */
-export async function findCustomerById(id) {
-    const db = getDb();
-    const result = await db
-        .select()
-        .from(schema.customers)
-        .where(eq(schema.customers.id, id))
-        .limit(1);
-    return result[0] || null;
-}
-/**
- * Find all customers with pagination
- */
-export async function findCustomers(options = {}) {
-    const db = getDb();
-    const conditions = [];
-    if (options.search) {
-        conditions.push(ilike(schema.customers.email, `%${options.search}%`));
-    }
-    const query = db
-        .select()
-        .from(schema.customers)
-        .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(desc(schema.customers.createdAt));
-    if (options.limit) {
-        query.limit(options.limit);
-    }
-    if (options.offset) {
-        query.offset(options.offset);
-    }
-    return query;
-}
-// =============================================================================
-// Store Admins
-// =============================================================================
-/**
- * Find admin by email
- */
-export async function findAdminByEmail(email) {
-    const db = getDb();
-    const result = await db
-        .select()
-        .from(schema.storeAdmins)
-        .where(eq(schema.storeAdmins.email, email.toLowerCase()))
-        .limit(1);
-    return result[0] || null;
-}
-// =============================================================================
-// Admin Stats
-// =============================================================================
-/**
- * Get store statistics for admin dashboard
- */
-export async function getStoreStats() {
-    const db = getDb();
-    const [productCount, orderCount, customerCount, revenue] = await Promise.all([
-        // Total products
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.products)
-            .where(eq(schema.products.status, 'active')),
-        // Total orders — same status filter as revenue so the two metrics tell
-        // the same story. Counting cancelled/refunded/pending here would inflate
-        // the number relative to revenue and confuse merchants.
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.orders)
-            .where(inArray(schema.orders.status, ['paid', 'shipped', 'delivered'])),
-        // Total customers
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.customers),
-        // Total revenue (paid orders only)
-        db
-            .select({ total: sql `COALESCE(SUM(total), 0)` })
-            .from(schema.orders)
-            .where(inArray(schema.orders.status, ['paid', 'shipped', 'delivered'])),
-    ]);
-    return {
-        products: Number(productCount[0]?.count || 0),
-        orders: Number(orderCount[0]?.count || 0),
-        customers: Number(customerCount[0]?.count || 0),
-        revenue: Number(revenue[0]?.total || 0),
-    };
-}
-// =============================================================================
-// Period-scoped store stats (for time-window selector)
-// =============================================================================
-/**
- * Same shape as `getStoreStats()` but scoped to a window of `days` ago to now.
- * Powers the "Today / 7d / 30d / 90d" selector on the admin dashboard. Both
- * Orders and Revenue use the same status filter (paid + shipped + delivered)
- * so they tell the same story.
- *
- * Note: `products` and `customers` here mean *new* products created in the
- * window and *new* customers registered in the window — this is what makes
- * the period-vs-prior-period delta meaningful. For the absolute "how many
- * active products do I have" use `getStoreStats()`.
- */
-export async function getStoreStatsForPeriod(startDate, endDate) {
-    const db = getDb();
-    const [orderRow, revenueRow, productRow, customerRow] = await Promise.all([
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.orders)
-            .where(and(inArray(schema.orders.status, ['paid', 'shipped', 'delivered']), sql `${schema.orders.createdAt} >= ${startDate.toISOString()}`, sql `${schema.orders.createdAt} < ${endDate.toISOString()}`)),
-        db
-            .select({ total: sql `COALESCE(SUM(total), 0)` })
-            .from(schema.orders)
-            .where(and(inArray(schema.orders.status, ['paid', 'shipped', 'delivered']), sql `${schema.orders.createdAt} >= ${startDate.toISOString()}`, sql `${schema.orders.createdAt} < ${endDate.toISOString()}`)),
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.products)
-            .where(and(eq(schema.products.status, 'active'), sql `${schema.products.createdAt} >= ${startDate.toISOString()}`, sql `${schema.products.createdAt} < ${endDate.toISOString()}`)),
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.customers)
-            .where(and(sql `${schema.customers.createdAt} >= ${startDate.toISOString()}`, sql `${schema.customers.createdAt} < ${endDate.toISOString()}`)),
-    ]);
-    return {
-        orders: Number(orderRow[0]?.count || 0),
-        revenue: Number(revenueRow[0]?.total || 0),
-        newProducts: Number(productRow[0]?.count || 0),
-        newCustomers: Number(customerRow[0]?.count || 0),
-    };
-}
-/**
- * Count of refunded orders in the window. Used to compute refund rate.
- */
-export async function getRefundedOrdersCount(startDate, endDate) {
-    const db = getDb();
-    const result = await db
-        .select({ count: sql `count(*)` })
-        .from(schema.orders)
-        .where(and(eq(schema.orders.status, 'refunded'), sql `${schema.orders.createdAt} >= ${startDate.toISOString()}`, sql `${schema.orders.createdAt} < ${endDate.toISOString()}`));
-    return Number(result[0]?.count || 0);
-}
-/**
- * Count of all orders in the window (any status, used as the denominator
- * for refund rate so the rate isn't artificially inflated by excluding
- * pending/cancelled). Cancelled orders DO count here — they represent
- * customer behavior even if they don't represent revenue.
- */
-async function getTotalOrdersInPeriod(startDate, endDate) {
-    const db = getDb();
-    const result = await db
-        .select({ count: sql `count(*)` })
-        .from(schema.orders)
-        .where(and(sql `${schema.orders.createdAt} >= ${startDate.toISOString()}`, sql `${schema.orders.createdAt} < ${endDate.toISOString()}`));
-    return Number(result[0]?.count || 0);
-}
-function pctDelta(current, previous) {
-    if (previous === 0)
-        return null;
-    return (current - previous) / previous;
-}
-/**
- * Build the full dashboard summary in a single round-trip. Runs eight
- * parallel queries (current period + previous period × four metrics) and
- * computes derived ratios + deltas in-process. Total wall-clock ~30–50ms
- * on a warm Neon connection.
- */
-export async function getDashboardSummary(periodDays = 30) {
-    // Anchor windows to UTC midnight so day boundaries are stable.
-    const now = new Date();
-    const todayUtc = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
-    // `endDate` is the start of tomorrow (exclusive upper bound) so today's
-    // orders are included.
-    const endDate = new Date(todayUtc);
-    endDate.setUTCDate(endDate.getUTCDate() + 1);
-    const currentStart = new Date(todayUtc);
-    currentStart.setUTCDate(currentStart.getUTCDate() - (periodDays - 1));
-    const previousEnd = new Date(currentStart);
-    const previousStart = new Date(currentStart);
-    previousStart.setUTCDate(previousStart.getUTCDate() - periodDays);
-    const [currentStats, previousStats, currentTotalOrders, previousTotalOrders, currentRefunded, previousRefunded, bestSeller,] = await Promise.all([
-        getStoreStatsForPeriod(currentStart, endDate),
-        getStoreStatsForPeriod(previousStart, previousEnd),
-        getTotalOrdersInPeriod(currentStart, endDate),
-        getTotalOrdersInPeriod(previousStart, previousEnd),
-        getRefundedOrdersCount(currentStart, endDate),
-        getRefundedOrdersCount(previousStart, previousEnd),
-        getBestSellerProduct(periodDays),
-    ]);
-    const currentAov = currentStats.orders > 0 ? currentStats.revenue / currentStats.orders : 0;
-    const previousAov = previousStats.orders > 0 ? previousStats.revenue / previousStats.orders : 0;
-    const currentRefundRate = currentTotalOrders > 0 ? currentRefunded / currentTotalOrders : 0;
-    const previousRefundRate = previousTotalOrders > 0 ? previousRefunded / previousTotalOrders : 0;
-    return {
-        periodDays,
-        current: {
-            revenue: currentStats.revenue,
-            orders: currentStats.orders,
-            newCustomers: currentStats.newCustomers,
-            newProducts: currentStats.newProducts,
-            aov: currentAov,
-            refundRate: currentRefundRate,
-            bestSeller,
-        },
-        previous: {
-            revenue: previousStats.revenue,
-            orders: previousStats.orders,
-            newCustomers: previousStats.newCustomers,
-            newProducts: previousStats.newProducts,
-            aov: previousAov,
-            refundRate: previousRefundRate,
-        },
-        deltas: {
-            revenue: pctDelta(currentStats.revenue, previousStats.revenue),
-            orders: pctDelta(currentStats.orders, previousStats.orders),
-            aov: pctDelta(currentAov, previousAov),
-            refundRate: pctDelta(currentRefundRate, previousRefundRate),
-            customers: pctDelta(currentStats.newCustomers, previousStats.newCustomers),
-        },
-    };
-}
-/**
- * Get low stock products (inventory < threshold)
- */
-export async function getLowStockProducts(threshold = 10) {
-    const db = getDb();
-    // Get products with variants that have low stock
-    const lowStockVariants = await db
-        .select({
-        product: schema.products,
-        variant: schema.productVariants,
-    })
-        .from(schema.productVariants)
-        .innerJoin(schema.products, eq(schema.productVariants.productId, schema.products.id))
-        .where(and(eq(schema.products.status, 'active'), sql `${schema.productVariants.inventory} < ${threshold}`))
-        .orderBy(asc(schema.productVariants.inventory));
-    return lowStockVariants;
-}
-/**
- * Get recent orders
- */
-export async function getRecentOrders(limit = 5) {
-    const db = getDb();
-    return db
-        .select()
-        .from(schema.orders)
-        .orderBy(desc(schema.orders.createdAt))
-        .limit(limit);
-}
-// =============================================================================
-// Order Mutations (for checkout module)
-// =============================================================================
-/**
- * Create a new order
- */
-export async function createOrder(data) {
-    const db = getDb();
-    const [order] = await db
-        .insert(schema.orders)
-        .values(data)
-        .returning();
-    return order;
-}
-/**
- * Create order items for an order
- */
-export async function createOrderItems(items) {
-    const db = getDb();
-    if (items.length === 0) {
-        return [];
-    }
-    return db.insert(schema.orderItems).values(items).returning();
-}
-/**
- * Update order status
- */
-export async function updateOrderStatus(orderId, status) {
-    const db = getDb();
-    const [order] = await db
-        .update(schema.orders)
-        .set({ status, updatedAt: new Date() })
-        .where(eq(schema.orders.id, orderId))
-        .returning();
-    return order || null;
-}
-/**
- * Update order shipping information (for Shippo integration)
- */
-export async function updateOrderShipping(orderId, shippingData) {
-    const db = getDb();
-    const [order] = await db
-        .update(schema.orders)
-        .set({
-        ...shippingData,
-        updatedAt: new Date(),
-    })
-        .where(eq(schema.orders.id, orderId))
-        .returning();
-    return order || null;
-}
-/**
- * Find order by Stripe Payment Intent ID
- * Used for idempotency in webhook handling
- */
-export async function findOrderByPaymentIntent(paymentIntentId) {
-    const db = getDb();
-    const [order] = await db
-        .select()
-        .from(schema.orders)
-        .where(eq(schema.orders.stripePaymentIntentId, paymentIntentId))
-        .limit(1);
-    return order || null;
-}
-/**
- * Update order refund amount (for partial refund tracking)
- * Adds the refund amount to the existing refund total
- */
-export async function updateOrderRefundAmount(orderId, refundAmountCents) {
-    const db = getDb();
-    const refundAmountDecimal = (refundAmountCents / 100).toFixed(2);
-    const [order] = await db
-        .update(schema.orders)
-        .set({
-        refundAmount: sql `COALESCE(${schema.orders.refundAmount}, 0) + ${refundAmountDecimal}`,
-        updatedAt: new Date(),
-    })
-        .where(eq(schema.orders.id, orderId))
-        .returning();
-    return order || null;
-}
-/**
- * Update order receipt information (for Stripe receipt URL)
- */
-export async function updateOrderReceipt(orderId, receiptData) {
-    const db = getDb();
-    const [order] = await db
-        .update(schema.orders)
-        .set({
-        ...receiptData,
-        updatedAt: new Date(),
-    })
-        .where(eq(schema.orders.id, orderId))
-        .returning();
-    return order || null;
-}
-/**
- * Update order with return request
- * Sets status to 'return_requested' and stores the return reason
- */
-export async function updateOrderReturnRequest(orderId, returnReason) {
-    const db = getDb();
-    const [order] = await db
-        .update(schema.orders)
-        .set({
-        status: 'return_requested',
-        returnReason,
-        updatedAt: new Date(),
-    })
-        .where(eq(schema.orders.id, orderId))
-        .returning();
-    return order || null;
-}
-/**
- * Clear order return request
- * Sets status back to 'delivered' and clears the return reason
- */
-export async function clearOrderReturnRequest(orderId) {
-    const db = getDb();
-    const [order] = await db
-        .update(schema.orders)
-        .set({
-        status: 'delivered',
-        returnReason: null,
-        updatedAt: new Date(),
-    })
-        .where(eq(schema.orders.id, orderId))
-        .returning();
-    return order || null;
-}
-// =============================================================================
-// Product CRUD (for admin module)
-// =============================================================================
-/**
- * Create a new product
- */
-export async function createProduct(data) {
-    const db = getDb();
-    const [product] = await db
-        .insert(schema.products)
-        .values(data)
-        .returning();
-    return product;
-}
-/**
- * Update a product by ID
- */
-export async function updateProduct(id, data) {
-    const db = getDb();
-    const [product] = await db
-        .update(schema.products)
-        .set({ ...data, updatedAt: new Date() })
-        .where(eq(schema.products.id, id))
-        .returning();
-    return product || null;
-}
-/**
- * Archive a product by ID (soft delete).
- * Sets status to 'archived' instead of deleting to preserve order history.
- * Use hardDeleteProduct() for permanent deletion if needed.
- */
-export async function deleteProduct(id) {
-    const result = await updateProduct(id, { status: 'archived' });
-    return result !== null;
-}
-/**
- * Permanently delete a product by ID.
- * WARNING: This will fail if there are order_items referencing this product.
- * Use deleteProduct() (soft delete) for most cases.
- */
-export async function hardDeleteProduct(id) {
-    const db = getDb();
-    const result = await db
-        .delete(schema.products)
-        .where(eq(schema.products.id, id))
-        .returning({ id: schema.products.id });
-    return result.length > 0;
-}
-// =============================================================================
-// Product Variant CRUD (for admin module)
-// =============================================================================
-/**
- * Create a new product variant
- */
-export async function createProductVariant(data) {
-    const db = getDb();
-    const [variant] = await db
-        .insert(schema.productVariants)
-        .values(data)
-        .returning();
-    return variant;
-}
-/**
- * Update a product variant by ID
- */
-export async function updateProductVariant(id, data) {
-    const db = getDb();
-    const [variant] = await db
-        .update(schema.productVariants)
-        .set(data)
-        .where(eq(schema.productVariants.id, id))
-        .returning();
-    return variant || null;
-}
-/**
- * Delete a product variant by ID
- */
-export async function deleteProductVariant(id) {
-    const db = getDb();
-    const result = await db
-        .delete(schema.productVariants)
-        .where(eq(schema.productVariants.id, id))
-        .returning({ id: schema.productVariants.id });
-    return result.length > 0;
-}
-/**
- * Update variant inventory
- */
-export async function updateVariantInventory(id, inventory) {
-    const db = getDb();
-    await db
-        .update(schema.productVariants)
-        .set({ inventory })
-        .where(eq(schema.productVariants.id, id));
-}
-/**
- * Find a variant by ID
- */
-export async function findVariantById(id) {
-    const db = getDb();
-    const [variant] = await db
-        .select()
-        .from(schema.productVariants)
-        .where(eq(schema.productVariants.id, id))
-        .limit(1);
-    return variant || null;
-}
-// =============================================================================
-// Category CRUD (for admin module)
-// =============================================================================
-/**
- * Find a category by ID
- */
-export async function findCategoryById(id) {
-    const db = getDb();
-    const [category] = await db
-        .select()
-        .from(schema.categories)
-        .where(eq(schema.categories.id, id))
-        .limit(1);
-    return category || null;
-}
-/**
- * Create a new category
- */
-export async function createCategory(data) {
-    const db = getDb();
-    const [category] = await db
-        .insert(schema.categories)
-        .values(data)
-        .returning();
-    return category;
-}
-/**
- * Update a category by ID
- */
-export async function updateCategory(id, data) {
-    const db = getDb();
-    const [category] = await db
-        .update(schema.categories)
-        .set(data)
-        .where(eq(schema.categories.id, id))
-        .returning();
-    return category || null;
-}
-/**
- * Delete a category by ID
- */
-export async function deleteCategory(id) {
-    const db = getDb();
-    const result = await db
-        .delete(schema.categories)
-        .where(eq(schema.categories.id, id))
-        .returning({ id: schema.categories.id });
-    return result.length > 0;
-}
-/**
- * Count categories
- */
-export async function countCategories() {
-    const db = getDb();
-    const result = await db
-        .select({ count: sql `count(*)` })
-        .from(schema.categories);
-    return Number(result[0]?.count || 0);
-}
-// =============================================================================
-// Customer Queries (for admin module)
-// =============================================================================
-/**
- * Count customers with optional search
- */
-export async function countCustomers(options = {}) {
-    const db = getDb();
-    const conditions = [];
-    if (options.search) {
-        conditions.push(ilike(schema.customers.email, `%${options.search}%`));
-    }
-    const result = await db
-        .select({ count: sql `count(*)` })
-        .from(schema.customers)
-        .where(conditions.length > 0 ? and(...conditions) : undefined);
-    return Number(result[0]?.count || 0);
-}
-/**
- * Find orders for a specific customer
- */
-export async function findCustomerOrders(customerId) {
-    const db = getDb();
-    return db
-        .select()
-        .from(schema.orders)
-        .where(eq(schema.orders.customerId, customerId))
-        .orderBy(desc(schema.orders.createdAt));
-}
-/**
- * Claim guest orders by email when a customer registers.
- * Updates all orders with matching email and null customerId to the new customer.
- *
- * @param email - Email address (will be lowercased)
- * @param customerId - New customer ID to assign
- * @returns Number of orders claimed
- */
-export async function claimGuestOrders(email, customerId) {
-    const db = getDb();
-    const result = await db
-        .update(schema.orders)
-        .set({ customerId, updatedAt: new Date() })
-        .where(and(eq(schema.orders.email, email.toLowerCase().trim()), isNull(schema.orders.customerId)))
-        .returning({ id: schema.orders.id });
-    return result.length;
-}
-/**
- * Delete (anonymize) a customer by ID.
- *
- * This is a SOFT DELETE that anonymizes customer data instead of removing the record.
- * This approach:
- * - Preserves order history integrity (orders reference customerId)
- * - Complies with GDPR "right to erasure" through anonymization
- * - Prevents login by invalidating passwordHash
- * - Keeps the record for audit trail purposes
- *
- * Related tokens (verification, password reset) are auto-deleted via CASCADE.
- *
- * @param id - Customer UUID
- * @returns true if customer was found and anonymized, false if not found
- */
-export async function deleteCustomer(id) {
-    const db = getDb();
-    // Anonymize customer data instead of hard delete
-    const result = await db
-        .update(schema.customers)
-        .set({
-        email: `deleted_${Date.now()}@anonymized.local`,
-        name: null,
-        passwordHash: 'DELETED', // Prevents login
-        emailVerified: null,
-        stripeCustomerId: null,
-    })
-        .where(eq(schema.customers.id, id))
-        .returning({ id: schema.customers.id });
-    return result.length > 0;
-}
-// =============================================================================
-// Order Queries (for admin module)
-// =============================================================================
-/**
- * Count orders with optional status filter
- */
-export async function countOrders(options = {}) {
-    const db = getDb();
-    const conditions = [];
-    if (options.status) {
-        conditions.push(eq(schema.orders.status, options.status));
-    }
-    const result = await db
-        .select({ count: sql `count(*)` })
-        .from(schema.orders)
-        .where(conditions.length > 0 ? and(...conditions) : undefined);
-    return Number(result[0]?.count || 0);
-}
-/**
- * Get revenue by period (for analytics).
- *
- * Returns one row per calendar day in the window, **including days with zero
- * revenue**. The SQL GROUP BY only emits rows where orders exist, which made
- * the chart skip empty days and look discontinuous (e.g., a Friday-only seller
- * showed 5 floating points instead of 30). Fill happens in-process, so the
- * chart can render a continuous line without the consumer thinking about it.
- *
- * Date format is `YYYY-MM-DD` in UTC (matches Postgres `DATE()` output).
- */
-export async function getRevenueByPeriod(days) {
-    const db = getDb();
-    // Normalize to UTC midnight so the day boundaries match Postgres DATE()
-    // and our in-process fill loop produces stable keys.
-    const now = new Date();
-    const todayUtc = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
-    const startDate = new Date(todayUtc);
-    startDate.setUTCDate(startDate.getUTCDate() - days);
-    const result = await db
-        .select({
-        date: sql `DATE(${schema.orders.createdAt})`,
-        revenue: sql `COALESCE(SUM(${schema.orders.total}), 0)`,
-    })
-        .from(schema.orders)
-        .where(and(inArray(schema.orders.status, ['paid', 'shipped', 'delivered']), sql `${schema.orders.createdAt} >= ${startDate.toISOString()}`))
-        .groupBy(sql `DATE(${schema.orders.createdAt})`)
-        .orderBy(sql `DATE(${schema.orders.createdAt})`);
-    // Index actual revenue rows by date for O(1) lookup during fill.
-    const revenueByDate = new Map();
-    for (const row of result) {
-        revenueByDate.set(String(row.date), Number(row.revenue));
-    }
-    // Walk every day from startDate through today and emit a row for each —
-    // empty days get revenue=0 so the chart renders a continuous line.
-    const filled = [];
-    const cursor = new Date(startDate);
-    while (cursor <= todayUtc) {
-        const key = cursor.toISOString().slice(0, 10);
-        filled.push({ date: key, revenue: revenueByDate.get(key) ?? 0 });
-        cursor.setUTCDate(cursor.getUTCDate() + 1);
-    }
-    return filled;
-}
-/**
- * Get orders by status count (for analytics)
- */
-export async function getOrdersByStatus() {
-    const db = getDb();
-    const result = await db
-        .select({
-        status: schema.orders.status,
-        count: sql `count(*)`,
-    })
-        .from(schema.orders)
-        .groupBy(schema.orders.status);
-    return result.map((r) => ({
-        status: r.status,
-        count: Number(r.count),
-    }));
-}
-/**
- * Find store settings.
- * Returns null if no settings exist (first time access).
- * Each store has only one settings row.
- */
-export async function findSettings() {
-    const db = getDb();
-    const [settings] = await db
-        .select()
-        .from(schema.storeSettings)
-        .limit(1);
-    if (!settings)
-        return null;
-    return {
-        storeName: settings.storeName,
-        storeEmail: settings.storeEmail,
-        logoUrl: settings.logoUrl,
-        storeCurrency: settings.storeCurrency,
-        storeTimezone: settings.storeTimezone,
-        taxIncludedInPrices: settings.taxIncludedInPrices,
-        shippingEnabled: settings.shippingEnabled,
-        freeShippingThreshold: settings.freeShippingThreshold
-            ? Number(settings.freeShippingThreshold)
-            : null,
-        shippingCountries: settings.shippingCountries,
-        // Auth configuration
-        guestCheckout: settings.guestCheckout,
-        customerAccounts: settings.customerAccounts,
-        // Shippo fields
-        shippingMode: settings.shippingMode,
-        shippoApiKey: settings.shippoApiKey,
-        shippoTestMode: settings.shippoTestMode,
-        shippoFromAddress: settings.shippoFromAddress,
-        shippoDefaultParcel: settings.shippoDefaultParcel,
-        // Discount/promotion configuration
-        promotionCodesEnabled: settings.promotionCodesEnabled,
-        // Cookie consent banner (R021)
-        cookieBannerEnabled: settings.cookieBannerEnabled,
-    };
-}
-/**
- * Upsert (create or update) store settings.
- * Each store has only one settings row.
- */
-export async function upsertSettings(data) {
-    const db = getDb();
-    // Check if settings exist
-    const existing = await db
-        .select({ id: schema.storeSettings.id })
-        .from(schema.storeSettings)
-        .limit(1);
-    const values = {
-        storeName: data.storeName ?? undefined,
-        storeEmail: data.storeEmail ?? undefined,
-        logoUrl: data.logoUrl ?? undefined,
-        storeCurrency: data.storeCurrency ?? undefined,
-        storeTimezone: data.storeTimezone ?? undefined,
-        taxIncludedInPrices: data.taxIncludedInPrices ?? undefined,
-        shippingEnabled: data.shippingEnabled ?? undefined,
-        freeShippingThreshold: data.freeShippingThreshold !== null && data.freeShippingThreshold !== undefined
-            ? String(data.freeShippingThreshold)
-            : undefined,
-        shippingCountries: data.shippingCountries ?? undefined,
-        // Auth configuration
-        guestCheckout: data.guestCheckout ?? undefined,
-        customerAccounts: data.customerAccounts ?? undefined,
-        // Shippo carrier integration
-        shippingMode: data.shippingMode ?? undefined,
-        shippoApiKey: data.shippoApiKey ?? undefined,
-        shippoTestMode: data.shippoTestMode ?? undefined,
-        shippoFromAddress: data.shippoFromAddress ?? undefined,
-        shippoDefaultParcel: data.shippoDefaultParcel ?? undefined,
-        // Discount/promotion configuration
-        promotionCodesEnabled: data.promotionCodesEnabled ?? undefined,
-        // Cookie consent banner (R021)
-        cookieBannerEnabled: data.cookieBannerEnabled ?? undefined,
-        updatedAt: new Date(),
-    };
-    let result;
-    if (existing.length > 0) {
-        // Update existing
-        [result] = await db
-            .update(schema.storeSettings)
-            .set(values)
-            .where(eq(schema.storeSettings.id, existing[0].id))
-            .returning();
-    }
-    else {
-        // Insert new
-        [result] = await db
-            .insert(schema.storeSettings)
-            .values(values)
-            .returning();
-    }
-    return {
-        storeName: result.storeName,
-        storeEmail: result.storeEmail,
-        logoUrl: result.logoUrl,
-        storeCurrency: result.storeCurrency,
-        storeTimezone: result.storeTimezone,
-        taxIncludedInPrices: result.taxIncludedInPrices,
-        shippingEnabled: result.shippingEnabled,
-        freeShippingThreshold: result.freeShippingThreshold
-            ? Number(result.freeShippingThreshold)
-            : null,
-        shippingCountries: result.shippingCountries,
-        // Auth configuration
-        guestCheckout: result.guestCheckout,
-        customerAccounts: result.customerAccounts,
-        // Shippo fields
-        shippingMode: result.shippingMode,
-        shippoApiKey: result.shippoApiKey,
-        shippoTestMode: result.shippoTestMode,
-        shippoFromAddress: result.shippoFromAddress,
-        shippoDefaultParcel: result.shippoDefaultParcel,
-        // Discount/promotion configuration
-        promotionCodesEnabled: result.promotionCodesEnabled,
-        // Cookie consent banner (R021)
-        cookieBannerEnabled: result.cookieBannerEnabled,
-    };
-}
-/**
- * Find all shipping carriers
- */
-export async function findShippingCarriers() {
-    const db = getDb();
-    const carriers = await db
-        .select()
-        .from(schema.shippingCarriers)
-        .orderBy(asc(schema.shippingCarriers.sortOrder), asc(schema.shippingCarriers.name));
-    return carriers.map((carrier) => ({
-        id: carrier.id,
-        name: carrier.name,
-        code: carrier.code,
-        description: carrier.description,
-        isActive: carrier.isActive,
-        sortOrder: carrier.sortOrder,
-        createdAt: carrier.createdAt,
-        updatedAt: carrier.updatedAt,
-    }));
-}
-/**
- * Find active shipping carriers only
- */
-export async function findActiveShippingCarriers() {
-    const db = getDb();
-    const carriers = await db
-        .select()
-        .from(schema.shippingCarriers)
-        .where(eq(schema.shippingCarriers.isActive, true))
-        .orderBy(asc(schema.shippingCarriers.sortOrder), asc(schema.shippingCarriers.name));
-    return carriers.map((carrier) => ({
-        id: carrier.id,
-        name: carrier.name,
-        code: carrier.code,
-        description: carrier.description,
-        isActive: carrier.isActive,
-        sortOrder: carrier.sortOrder,
-        createdAt: carrier.createdAt,
-        updatedAt: carrier.updatedAt,
-    }));
-}
-/**
- * Find a shipping carrier by ID
- */
-export async function findShippingCarrierById(id) {
-    const db = getDb();
-    const [carrier] = await db
-        .select()
-        .from(schema.shippingCarriers)
-        .where(eq(schema.shippingCarriers.id, id))
-        .limit(1);
-    if (!carrier)
-        return null;
-    return {
-        id: carrier.id,
-        name: carrier.name,
-        code: carrier.code,
-        description: carrier.description,
-        isActive: carrier.isActive,
-        sortOrder: carrier.sortOrder,
-        createdAt: carrier.createdAt,
-        updatedAt: carrier.updatedAt,
-    };
-}
-/**
- * Create a new shipping carrier
- */
-export async function createShippingCarrier(data) {
-    const db = getDb();
-    const [carrier] = await db
-        .insert(schema.shippingCarriers)
-        .values({
-        name: data.name,
-        code: data.code,
-        description: data.description || null,
-        isActive: data.isActive ?? true,
-        sortOrder: data.sortOrder ?? 0,
-    })
-        .returning();
-    return carrier;
-}
-/**
- * Update a shipping carrier
- */
-export async function updateShippingCarrier(id, data) {
-    const db = getDb();
-    const [carrier] = await db
-        .update(schema.shippingCarriers)
-        .set({ ...data, updatedAt: new Date() })
-        .where(eq(schema.shippingCarriers.id, id))
-        .returning();
-    return carrier || null;
-}
-/**
- * Delete a shipping carrier (cascades to zones and rates)
- */
-export async function deleteShippingCarrier(id) {
-    const db = getDb();
-    const result = await db
-        .delete(schema.shippingCarriers)
-        .where(eq(schema.shippingCarriers.id, id))
-        .returning({ id: schema.shippingCarriers.id });
-    return result.length > 0;
-}
-/**
- * Find all carriers with their zones and rates (full hierarchy for admin UI)
- */
-export async function findCarriersWithZonesAndRates() {
-    const carriers = await findShippingCarriers();
-    const zones = await findShippingZones();
-    // Group zones by carrier
-    const zonesByCarrier = new Map();
-    for (const zone of zones) {
-        if (!zone.carrierId)
-            continue;
-        const existing = zonesByCarrier.get(zone.carrierId) || [];
-        existing.push(zone);
-        zonesByCarrier.set(zone.carrierId, existing);
-    }
-    return carriers.map((carrier) => ({
-        ...carrier,
-        zones: zonesByCarrier.get(carrier.id) || [],
-    }));
-}
-/**
- * Find all shipping zones with their rates and carrier info
- */
-export async function findShippingZones() {
-    const db = getDb();
-    // Get all zones with carrier info via join
-    const zonesWithCarriers = await db
-        .select({
-        zone: schema.shippingZones,
-        carrier: {
-            id: schema.shippingCarriers.id,
-            name: schema.shippingCarriers.name,
-            code: schema.shippingCarriers.code,
-        },
-    })
-        .from(schema.shippingZones)
-        .leftJoin(schema.shippingCarriers, eq(schema.shippingZones.carrierId, schema.shippingCarriers.id))
-        .orderBy(asc(schema.shippingZones.sortOrder), asc(schema.shippingZones.name));
-    // Get all rates
-    const rates = await db
-        .select()
-        .from(schema.shippingRates)
-        .orderBy(asc(schema.shippingRates.sortOrder), asc(schema.shippingRates.name));
-    // Group rates by zone
-    const ratesByZone = new Map();
-    for (const rate of rates) {
-        const existing = ratesByZone.get(rate.zoneId) || [];
-        existing.push(rate);
-        ratesByZone.set(rate.zoneId, existing);
-    }
-    // Combine zones with their rates and carrier info
-    return zonesWithCarriers.map(({ zone, carrier }) => ({
-        id: zone.id,
-        carrierId: zone.carrierId,
-        carrier: carrier ? {
-            id: carrier.id,
-            name: carrier.name,
-            code: carrier.code,
-        } : undefined,
-        name: zone.name,
-        countries: zone.countries || [],
-        isActive: zone.isActive,
-        sortOrder: zone.sortOrder,
-        createdAt: zone.createdAt,
-        updatedAt: zone.updatedAt,
-        rates: (ratesByZone.get(zone.id) || []).map((rate) => ({
-            id: rate.id,
-            name: rate.name,
-            description: rate.description,
-            price: Number(rate.price),
-            minOrderAmount: rate.minOrderAmount ? Number(rate.minOrderAmount) : null,
-            maxOrderAmount: rate.maxOrderAmount ? Number(rate.maxOrderAmount) : null,
-            estimatedDays: rate.estimatedDays,
-            isActive: rate.isActive,
-            sortOrder: rate.sortOrder,
-        })),
-    }));
-}
-/**
- * Find active shipping zones only
- */
-export async function findActiveShippingZones() {
-    const allZones = await findShippingZones();
-    return allZones.filter((zone) => zone.isActive);
-}
-/**
- * Find a shipping zone by ID
- */
-export async function findShippingZoneById(id) {
-    const zones = await findShippingZones();
-    return zones.find((z) => z.id === id) || null;
-}
-/**
- * Create a new shipping zone under a carrier
- */
-export async function createShippingZone(data) {
-    const db = getDb();
-    const [zone] = await db
-        .insert(schema.shippingZones)
-        .values({
-        carrierId: data.carrierId,
-        name: data.name,
-        countries: data.countries,
-        isActive: data.isActive ?? true,
-        sortOrder: data.sortOrder ?? 0,
-    })
-        .returning();
-    return zone;
-}
-/**
- * Update a shipping zone
- */
-export async function updateShippingZone(id, data) {
-    const db = getDb();
-    const [zone] = await db
-        .update(schema.shippingZones)
-        .set({ ...data, updatedAt: new Date() })
-        .where(eq(schema.shippingZones.id, id))
-        .returning();
-    return zone || null;
-}
-/**
- * Delete a shipping zone (cascades to rates)
- */
-export async function deleteShippingZone(id) {
-    const db = getDb();
-    const result = await db
-        .delete(schema.shippingZones)
-        .where(eq(schema.shippingZones.id, id))
-        .returning({ id: schema.shippingZones.id });
-    return result.length > 0;
-}
-/**
- * Create a shipping rate for a zone
- */
-export async function createShippingRate(data) {
-    const db = getDb();
-    const [rate] = await db
-        .insert(schema.shippingRates)
-        .values({
-        zoneId: data.zoneId,
-        name: data.name,
-        description: data.description || null,
-        price: String(data.price),
-        minOrderAmount: data.minOrderAmount !== undefined ? String(data.minOrderAmount) : null,
-        maxOrderAmount: data.maxOrderAmount !== undefined ? String(data.maxOrderAmount) : null,
-        estimatedDays: data.estimatedDays || null,
-        isActive: data.isActive ?? true,
-        sortOrder: data.sortOrder ?? 0,
-    })
-        .returning();
-    return rate;
-}
-/**
- * Update a shipping rate
- */
-export async function updateShippingRate(id, data) {
-    const db = getDb();
-    const updateData = {};
-    if (data.name !== undefined)
-        updateData.name = data.name;
-    if (data.description !== undefined)
-        updateData.description = data.description;
-    if (data.price !== undefined)
-        updateData.price = String(data.price);
-    if (data.minOrderAmount !== undefined)
-        updateData.minOrderAmount = data.minOrderAmount !== null ? String(data.minOrderAmount) : null;
-    if (data.maxOrderAmount !== undefined)
-        updateData.maxOrderAmount = data.maxOrderAmount !== null ? String(data.maxOrderAmount) : null;
-    if (data.estimatedDays !== undefined)
-        updateData.estimatedDays = data.estimatedDays;
-    if (data.isActive !== undefined)
-        updateData.isActive = data.isActive;
-    if (data.sortOrder !== undefined)
-        updateData.sortOrder = data.sortOrder;
-    const [rate] = await db
-        .update(schema.shippingRates)
-        .set(updateData)
-        .where(eq(schema.shippingRates.id, id))
-        .returning();
-    return rate || null;
-}
-/**
- * Delete a shipping rate
- */
-export async function deleteShippingRate(id) {
-    const db = getDb();
-    const result = await db
-        .delete(schema.shippingRates)
-        .where(eq(schema.shippingRates.id, id))
-        .returning({ id: schema.shippingRates.id });
-    return result.length > 0;
-}
-/**
- * Find shipping rates applicable to a specific country and order amount.
- * Used during checkout to determine which shipping options to show.
- *
- * @param country - ISO country code (e.g., 'US', 'CA')
- * @param orderAmount - Order subtotal in dollars
- * @returns Array of applicable shipping rates with carrier info
- */
-export async function findShippingRatesForCountry(country, orderAmount) {
-    const zones = await findActiveShippingZones();
-    const applicableRates = [];
-    for (const zone of zones) {
-        // Skip zones without a carrier (shouldn't happen, but defensive)
-        if (!zone.carrier)
-            continue;
-        // Check if zone covers this country
-        // '*' means all countries (international catch-all)
-        const coversCountry = zone.countries.includes('*') || zone.countries.includes(country.toUpperCase());
-        if (!coversCountry)
-            continue;
-        // Get active rates that match the order amount
-        for (const rate of zone.rates) {
-            if (!rate.isActive)
-                continue;
-            // Check min/max order amount constraints
-            if (rate.minOrderAmount !== null && orderAmount < rate.minOrderAmount)
-                continue;
-            if (rate.maxOrderAmount !== null && orderAmount > rate.maxOrderAmount)
-                continue;
-            applicableRates.push({
-                id: rate.id,
-                carrierId: zone.carrierId,
-                carrierName: zone.carrier.name,
-                carrierCode: zone.carrier.code,
-                zoneName: zone.name,
-                name: rate.name,
-                description: rate.description,
-                price: rate.price,
-                estimatedDays: rate.estimatedDays,
-            });
-        }
-    }
-    return applicableRates;
-}
-/**
- * Find shipping options for checkout grouped by carrier.
- * This is the main function used by the pre-checkout flow.
- *
- * @param country - ISO country code (e.g., 'US', 'CA')
- * @param orderAmount - Order subtotal in dollars
- * @returns Shipping options grouped by carrier
- */
-export async function findShippingOptionsForCountry(country, orderAmount) {
-    const rates = await findShippingRatesForCountry(country, orderAmount);
-    // Group by carrier
-    const carrierMap = new Map();
-    for (const rate of rates) {
-        let group = carrierMap.get(rate.carrierId);
-        if (!group) {
-            group = {
-                carrier: {
-                    id: rate.carrierId,
-                    name: rate.carrierName,
-                    code: rate.carrierCode,
-                },
-                options: [],
-            };
-            carrierMap.set(rate.carrierId, group);
-        }
-        group.options.push({
-            id: rate.id,
-            carrierId: rate.carrierId,
-            carrierName: rate.carrierName,
-            carrierCode: rate.carrierCode,
-            name: rate.name,
-            description: rate.description ?? undefined,
-            price: rate.price,
-            estimatedDays: rate.estimatedDays ?? undefined,
-            source: 'manual',
-        });
-    }
-    // Convert to array and sort by carrier name
-    return Array.from(carrierMap.values()).sort((a, b) => a.carrier.name.localeCompare(b.carrier.name));
-}
-/**
- * Find all tax zones ordered by priority (sortOrder ascending)
- */
-export async function findTaxZones() {
-    const db = getDb();
-    const zones = await db
-        .select()
-        .from(schema.taxZones)
-        .orderBy(asc(schema.taxZones.sortOrder), asc(schema.taxZones.name));
-    return zones.map((zone) => ({
-        id: zone.id,
-        name: zone.name,
-        countries: zone.countries || [],
-        states: zone.states || [],
-        taxRate: Number(zone.taxRate),
-        isActive: zone.isActive,
-        sortOrder: zone.sortOrder,
-        createdAt: zone.createdAt,
-        updatedAt: zone.updatedAt,
-    }));
-}
-/**
- * Find only active tax zones
- */
-export async function findActiveTaxZones() {
-    const allZones = await findTaxZones();
-    return allZones.filter((zone) => zone.isActive);
-}
-/**
- * Find a tax zone by ID
- */
-export async function findTaxZoneById(id) {
-    const zones = await findTaxZones();
-    return zones.find((z) => z.id === id) || null;
-}
-/**
- * Create a new tax zone
- */
-export async function createTaxZone(data) {
-    const db = getDb();
-    const [zone] = await db
-        .insert(schema.taxZones)
-        .values({
-        name: data.name,
-        countries: data.countries.map((c) => c.toUpperCase()),
-        states: (data.states || []).map((s) => s.toUpperCase()),
-        taxRate: String(data.taxRate),
-        isActive: data.isActive ?? true,
-        sortOrder: data.sortOrder ?? 0,
-    })
-        .returning();
-    return zone;
-}
-/**
- * Update a tax zone
- */
-export async function updateTaxZone(id, data) {
-    const db = getDb();
-    const updateData = { updatedAt: new Date() };
-    if (data.name !== undefined)
-        updateData.name = data.name;
-    if (data.countries !== undefined)
-        updateData.countries = data.countries.map((c) => c.toUpperCase());
-    if (data.states !== undefined)
-        updateData.states = data.states.map((s) => s.toUpperCase());
-    if (data.taxRate !== undefined)
-        updateData.taxRate = String(data.taxRate);
-    if (data.isActive !== undefined)
-        updateData.isActive = data.isActive;
-    if (data.sortOrder !== undefined)
-        updateData.sortOrder = data.sortOrder;
-    const [zone] = await db
-        .update(schema.taxZones)
-        .set(updateData)
-        .where(eq(schema.taxZones.id, id))
-        .returning();
-    return zone || null;
-}
-/**
- * Delete a tax zone
- */
-export async function deleteTaxZone(id) {
-    const db = getDb();
-    const result = await db
-        .delete(schema.taxZones)
-        .where(eq(schema.taxZones.id, id))
-        .returning({ id: schema.taxZones.id });
-    return result.length > 0;
-}
-/**
- * Find the applicable tax rate for a given address.
- * Returns the first matching zone based on priority (sortOrder).
- *
- * Matching logic:
- * 1. For US addresses: Match country='US' AND state matches (if zone has states)
- * 2. For non-US addresses: Match country only
- * 3. Wildcard '*' in countries matches any country
- *
- * @param country - ISO-2 country code (e.g., 'US', 'FR')
- * @param state - State/province code for US (e.g., 'CA', 'NY')
- * @returns Tax rate info or null if no matching zone
- */
-export async function findTaxRateForAddress(country, state) {
-    const zones = await findActiveTaxZones();
-    const upperCountry = country.toUpperCase();
-    const upperState = state?.toUpperCase() || '';
-    for (const zone of zones) {
-        // Check if zone covers this country
-        const hasWildcard = zone.countries.includes('*');
-        const hasCountry = zone.countries.includes(upperCountry);
-        if (!hasWildcard && !hasCountry)
-            continue;
-        // For US addresses: If zone has specific states, require state match
-        if (upperCountry === 'US' && zone.states.length > 0) {
-            if (!upperState || !zone.states.includes(upperState)) {
-                continue; // Zone requires specific US states that don't match
-            }
-        }
-        // Found a matching zone
-        return {
-            zoneId: zone.id,
-            zoneName: zone.name,
-            taxRate: zone.taxRate,
-        };
-    }
-    return null; // No matching tax zone
-}
-/**
- * Runtime self-heal for the `onboarding` column. Stores generated before this
- * column shipped don't have it; this idempotent migration adds it on first
- * call and caches success in-process so subsequent calls are no-ops.
- *
- * Same pattern as the analytics JSONB self-heal documented in CLAUDE.md §27.
- * No fleet rollout needed — the column appears on each store's first hit
- * to the setup-guide endpoint or the writeback hooks.
- */
-let onboardingColumnEnsured = false;
-export async function ensureOnboardingColumn() {
-    if (onboardingColumnEnsured)
-        return;
-    const db = getDb();
-    try {
-        await db.execute(sql `
-      ALTER TABLE store_settings
-      ADD COLUMN IF NOT EXISTS onboarding jsonb NOT NULL DEFAULT '{}'::jsonb
-    `);
-        onboardingColumnEnsured = true;
-    }
-    catch (err) {
-        // Don't poison the cache on transient failures — try again next call.
-        console.error('[ensureOnboardingColumn] migration failed:', err);
-        throw err;
-    }
-}
-/**
- * Read the onboarding JSONB. Returns `{}` when the row is missing or the
- * column hasn't been initialized yet (legacy stores). Always safe to call.
- */
-export async function getOnboardingState() {
-    await ensureOnboardingColumn();
-    const db = getDb();
-    const rows = await db
-        .select({ onboarding: schema.storeSettings.onboarding })
-        .from(schema.storeSettings)
-        .limit(1);
-    return (rows[0]?.onboarding ?? {});
-}
-/**
- * Set or clear a single key on the onboarding JSONB. Uses `jsonb_set` so it
- * never clobbers other keys written by parallel requests. Safe to call
- * fire-and-forget from mutating API routes (products POST/PUT, settings PUT).
- */
-export async function setOnboardingFlag(key, value) {
-    await ensureOnboardingColumn();
-    const db = getDb();
-    // jsonb_set with create_missing=true so the column starts at '{}' and
-    // gradually accretes keys. We JSON-stringify the value first so that
-    // booleans, numbers, strings, and null all round-trip with their proper
-    // JSONB types. Earlier versions used `to_jsonb(value::text)::jsonb`
-    // which incorrectly produced JSONB string `"true"` for boolean true —
-    // breaking strict-equality reads in the GET handler so the setup-guide
-    // tasks never marked complete.
-    const jsonValue = JSON.stringify(value);
-    await db.execute(sql `
-    UPDATE store_settings
-    SET onboarding = jsonb_set(
-      COALESCE(onboarding, '{}'::jsonb),
-      ${sql.raw(`'{${String(key)}}'`)},
-      ${jsonValue}::jsonb,
-      true
-    )
-  `);
-}
-/**
- * Aggregated signal counts used by the setup-guide GET handler. One round-trip
- * via Promise.all instead of four sequential queries.
- */
-export async function getSetupGuideSignals() {
-    await ensureOnboardingColumn();
-    const db = getDb();
-    const [products, shipping, tax, admins, settings] = await Promise.all([
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.products),
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.shippingZones)
-            .where(eq(schema.shippingZones.isActive, true)),
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.taxZones)
-            .where(eq(schema.taxZones.isActive, true)),
-        db
-            .select({ count: sql `count(*)` })
-            .from(schema.storeAdmins),
-        db
-            .select({
-            logoUrl: schema.storeSettings.logoUrl,
-            // `analytics` is self-healed by the pixel cards (see CLAUDE.md §27);
-            // we read it via raw SQL so the SDK works on stores where the
-            // column doesn't exist yet — the COALESCE keeps that path safe.
-            analytics: sql `COALESCE(
-          (SELECT analytics FROM store_settings LIMIT 1),
-          '{}'::jsonb
-        )`,
-            onboarding: schema.storeSettings.onboarding,
-        })
-            .from(schema.storeSettings)
-            .limit(1),
-    ]);
-    return {
-        productCount: Number(products[0]?.count || 0),
-        shippingZonesCount: Number(shipping[0]?.count || 0),
-        taxZonesCount: Number(tax[0]?.count || 0),
-        adminCount: Number(admins[0]?.count || 0),
-        storeSettings: settings[0]
-            ? {
-                logoUrl: settings[0].logoUrl ?? null,
-                analytics: settings[0].analytics ?? {},
-                onboarding: settings[0].onboarding ?? {},
-            }
-            : null,
-    };
-}
-//# sourceMappingURL=queries.js.map