@stacksjs/defaults 0.70.229 → 0.70.230

package/app/Actions/Dashboard/Analytics/MarketingAnalyticsAction.ts

@@ -1,81 +1,63 @@
+import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
-import { log } from '@stacksjs/logging'
+import { Campaign } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import {
+  analyticsCurrency,
+  analyticsIdentifier,
+  analyticsOptionalNumber,
+  analyticsString,
+  analyticsTimestamp,
+} from './analytics-record'
+import { buildCampaignAnalytics } from './campaign-analytics'
+import { normalizeAnalyticsRange } from './request-analytics'
 
 export default new Action({
   name: 'MarketingAnalyticsAction',
-  description: 'Returns marketing analytics data from ts-analytics campaign and referrer stats.',
+  description: 'Returns campaign delivery, engagement, channel, and currency-safe spend analytics.',
   method: 'GET',
-  async handle() {
-    try {
-      const { AnalyticsQueryAPI, AnalyticsStore } = await import('@ts-analytics/tracking/analytics')
-      const store = new AnalyticsStore({ tableName: 'analytics' })
-
-      const now = new Date()
-      const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000)
-      const dateRange = { start: thirtyDaysAgo, end: now }
-      const period = AnalyticsQueryAPI.determinePeriod(dateRange)
-      const periodStart = AnalyticsStore.getPeriodStart(now, period)
-
-      const campaignStatsCmd = store.getCampaignStatsCommand('default', period, periodStart)
-      const campaignResult = (campaignStatsCmd as unknown as { Items?: unknown[] })?.Items ?? []
-
-      const campaignItems = campaignResult as any[]
-
-      const totalVisitors = campaignItems.reduce((sum: number, c: any) => sum + (c.visitors || 0), 0)
-      const totalConversions = campaignItems.reduce((sum: number, c: any) => sum + (c.conversions || 0), 0)
-      const totalRevenue = campaignItems.reduce((sum: number, c: any) => sum + (c.revenue || 0), 0)
-
-      const stats = [
-        { label: 'Campaign Visitors', value: totalVisitors.toLocaleString(), change: '' },
-        { label: 'Conversions', value: totalConversions.toLocaleString(), change: '' },
-        { label: 'Revenue', value: `$${totalRevenue.toLocaleString()}`, change: '' },
-        { label: 'Avg Conversion Rate', value: totalVisitors > 0 ? `${((totalConversions / totalVisitors) * 100).toFixed(1)}%` : '0%', change: '' },
-      ]
-
-      const campaigns = campaignItems
-        .sort((a: any, b: any) => (b.revenue || 0) - (a.revenue || 0))
-        .slice(0, 10)
-        .map((c: any) => ({
-          name: [c.utmSource, c.utmCampaign].filter(Boolean).join(' - ') || 'Unknown',
-          spend: '-',
-          leads: c.visitors || 0,
-          cpl: '-',
-          revenue: `$${(c.revenue || 0).toLocaleString()}`,
-          roi: '-',
-        }))
+  apiResponse: true,
 
-      const channelMap: Record<string, { visitors: number, conversions: number }> = {}
-      for (const c of campaignItems) {
-        const channel = c.utmMedium || c.utmSource || 'Other'
-        if (!channelMap[channel]) {
-          channelMap[channel] = { visitors: 0, conversions: 0 }
-        }
-        channelMap[channel].visitors += c.visitors || 0
-        channelMap[channel].conversions += c.conversions || 0
-      }
-
-      const channels = Object.entries(channelMap)
-        .sort(([, a], [, b]) => b.visitors - a.visitors)
-        .map(([channel, data]) => ({
-          channel,
-          spend: '-',
-          leads: data.visitors,
-          conversion: data.visitors > 0 ? `${((data.conversions / data.visitors) * 100).toFixed(1)}%` : '0%',
-        }))
-
-      return {
-        stats,
-        campaigns,
-        channels,
-        attribution: [],
-      }
+  async handle(request: RequestInstance) {
+    let range
+    try {
+      range = normalizeAnalyticsRange(request.get('range'))
+    }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'The analytics query is invalid.',
+      }, 422)
+    }
+    try {
+      const campaigns = await Campaign.orderByDesc('id').limit(10_000).get()
+
+      return buildCampaignAnalytics(
+        campaigns.map((campaign) => {
+          const id = analyticsIdentifier(campaign.get('id'), 'Campaign')
+          const source = `Campaign ${id}`
+          return {
+            id,
+            name: analyticsString(campaign.get('name'), source, 'name'),
+            type: analyticsString(campaign.get('type'), source, 'type'),
+            status: analyticsString(campaign.get('status'), source, 'status'),
+            audienceSize: analyticsOptionalNumber(campaign.get('audience_size'), source, 'audience_size', { min: 0, integer: true }),
+            sentCount: analyticsOptionalNumber(campaign.get('sent_count'), source, 'sent_count', { min: 0, integer: true }),
+            openRate: analyticsOptionalNumber(campaign.get('open_rate'), source, 'open_rate', { min: 0, max: 100 }),
+            clickRate: analyticsOptionalNumber(campaign.get('click_rate'), source, 'click_rate', { min: 0, max: 100 }),
+            conversionRate: analyticsOptionalNumber(campaign.get('conversion_rate'), source, 'conversion_rate', { min: 0, max: 100 }),
+            budget: analyticsOptionalNumber(campaign.get('budget'), source, 'budget', { min: 0 }),
+            spent: analyticsOptionalNumber(campaign.get('spent'), source, 'spent', { min: 0 }),
+            currency: analyticsCurrency(campaign.get('currency'), source),
+            createdAt: analyticsTimestamp(campaign.get('created_at'), source),
+          }
+        }),
+        range,
+      )
     }
     catch (error) {
-      // The analytics integration is optional: without
-      // @ts-analytics/tracking installed the dashboard renders empty
-      // rather than erroring. Log so a broken install is still visible.
-      log.debug('[MarketingAnalyticsAction] analytics unavailable:', error)
-      return { stats: [], campaigns: [], channels: [], attribution: [] }
+      return response.json({
+        message: error instanceof Error ? error.message : 'Campaign analytics records could not be read.',
+      }, 503)
     }
   },
 })

package/app/Actions/Dashboard/Analytics/PageAnalyticsAction.ts

@@ -1,50 +1,2 @@
-import { Action } from '@stacksjs/actions'
-import { log } from '@stacksjs/logging'
-
-export default new Action({
-  name: 'PageAnalyticsAction',
-  description: 'Returns page analytics data from ts-analytics.',
-  method: 'GET',
-  async handle() {
-    try {
-      const { AnalyticsQueryAPI, AnalyticsStore } = await import('@ts-analytics/tracking/analytics')
-      const store = new AnalyticsStore({ tableName: 'analytics' })
-
-      const now = new Date()
-      const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000)
-      const dateRange = { start: thirtyDaysAgo, end: now }
-      const period = AnalyticsQueryAPI.determinePeriod(dateRange)
-      const periodStart = AnalyticsStore.getPeriodStart(now, period)
-
-      const topPagesCmd = store.getTopPagesCommand('default', period, periodStart, 20)
-      const topPagesResult = (topPagesCmd as unknown as { Items?: unknown[] })?.Items ?? []
-
-      const pageItems = topPagesResult as any[]
-
-      const pages = pageItems.map((p: any) => {
-        const avgTimeMs = p.avgTimeOnPage || 0
-        const minutes = Math.floor(avgTimeMs / 60000)
-        const seconds = Math.floor((avgTimeMs % 60000) / 1000)
-        const bounceRate = p.bounces && p.entries ? ((p.bounces / p.entries) * 100).toFixed(1) : '0'
-
-        return {
-          path: p.path || p.name || '/',
-          title: p.title || p.path || p.name || '/',
-          views: p.pageViews || p.value || 0,
-          uniqueViews: p.uniqueVisitors || Math.round((p.pageViews || p.value || 0) * 0.75),
-          avgTime: avgTimeMs > 0 ? `${minutes}m ${seconds}s` : '-',
-          bounceRate: `${bounceRate}%`,
-        }
-      })
-
-      return { pages }
-    }
-    catch (error) {
-      // The analytics integration is optional: without
-      // @ts-analytics/tracking installed the dashboard renders empty
-      // rather than erroring. Log so a broken install is still visible.
-      log.debug('[PageAnalyticsAction] analytics unavailable:', error)
-      return { pages: [] }
-    }
-  },
-})
+// Preserve the legacy route while keeping one canonical request-analytics contract.
+export { default } from './WebAnalyticsAction'

package/app/Actions/Dashboard/Analytics/ReferrerAnalyticsAction.ts

@@ -1,77 +1,2 @@
-import { Action } from '@stacksjs/actions'
-import { log } from '@stacksjs/logging'
-
-export default new Action({
-  name: 'ReferrerAnalyticsAction',
-  description: 'Returns referrer analytics data from ts-analytics.',
-  method: 'GET',
-  async handle() {
-    try {
-      const { AnalyticsQueryAPI, AnalyticsStore } = await import('@ts-analytics/tracking/analytics')
-      const store = new AnalyticsStore({ tableName: 'analytics' })
-
-      const now = new Date()
-      const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000)
-      const dateRange = { start: thirtyDaysAgo, end: now }
-      const period = AnalyticsQueryAPI.determinePeriod(dateRange)
-      const periodStart = AnalyticsStore.getPeriodStart(now, period)
-      const startPeriod = AnalyticsStore.getPeriodStart(thirtyDaysAgo, period)
-
-      const statsCmd = store.getAggregatedStatsCommand('default', period, startPeriod, periodStart)
-      const statsResult = (statsCmd as unknown as { Items?: unknown[] })?.Items ?? []
-      const rawStats = statsResult as any[]
-
-      // Query referrer stats via key pattern prefix scan
-      // Referrer stats are stored with SK prefix REFSTATS#
-      const totalVisitors = rawStats.reduce((sum: number, s: any) => sum + (s.uniqueVisitors || 0), 0)
-
-      // Use the aggregated stats summary to get the dashboard queries which include referrer data
-      const queryApi = new AnalyticsQueryAPI(store)
-      // eslint-disable-next-line pickier/no-unused-vars
-      const queries = queryApi.generateDashboardQueries({
-        siteId: 'default',
-        dateRange,
-        topLimit: 20,
-      })
-
-      // The top pages query uses the GSI, referrer stats need to be queried via prefix
-      // Since there's no dedicated getReferrerStatsCommand, we query using key patterns
-      const refPrefix = `REFSTATS#${period.toUpperCase()}#${periodStart}`
-      const refCmd = {
-        command: 'Query' as const,
-        input: {
-          TableName: 'analytics',
-          KeyConditionExpression: 'pk = :pk AND begins_with(sk, :skPrefix)',
-          ExpressionAttributeValues: {
-            ':pk': { S: `SITE#default` },
-            ':skPrefix': { S: refPrefix },
-          },
-        },
-      }
-
-      const refResult = (refCmd as unknown as { Items?: unknown[] })?.Items ?? []
-      const refItems = refResult as any[]
-
-      const referrers = AnalyticsQueryAPI.processTopReferrers(
-        refItems as Parameters<typeof AnalyticsQueryAPI.processTopReferrers>[0],
-        totalVisitors,
-      )
-
-      return {
-        referrers: referrers.map(r => ({
-          name: r.name,
-          visitors: r.value,
-          sessions: Math.round(r.value * 1.5),
-          bounceRate: `${(r.percentage > 50 ? 40 : 25).toFixed(1)}%`,
-        })),
-      }
-    }
-    catch (error) {
-      // The analytics integration is optional: without
-      // @ts-analytics/tracking installed the dashboard renders empty
-      // rather than erroring. Log so a broken install is still visible.
-      log.debug('[ReferrerAnalyticsAction] analytics unavailable:', error)
-      return { referrers: [] }
-    }
-  },
-})
+// Preserve the legacy route while keeping one canonical request-analytics contract.
+export { default } from './WebAnalyticsAction'

package/app/Actions/Dashboard/Analytics/SalesAnalyticsAction.ts

@@ -1,73 +1,101 @@
+import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
+import { Category, Order, OrderItem, Payment, Product } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import {
+  analyticsCurrency,
+  analyticsIdentifier,
+  analyticsNumber,
+  analyticsOptionalNumber,
+  analyticsOptionalString,
+  analyticsString,
+  analyticsTimestamp,
+} from './analytics-record'
+import { normalizeAnalyticsRange } from './request-analytics'
+import { buildSalesAnalytics } from './sales-analytics'
 
 export default new Action({
   name: 'SalesAnalyticsAction',
-  description: 'Returns sales analytics data from the Order model.',
+  description: 'Returns currency-safe sales analytics from orders, payments, order items, products, and categories.',
   method: 'GET',
-  async handle() {
-    try {
-      const { Order } = await import('@stacksjs/orm')
-
-      const allOrders = await Order.all()
-      const orderCount = allOrders.length
-      const totalSales = allOrders.reduce((sum: number, o: any) => sum + (o.total_amount || 0), 0)
-      // eslint-disable-next-line pickier/no-unused-vars
-      const avgOrderValue = orderCount > 0 ? totalSales / orderCount : 0
-
-      const cancelledOrders = allOrders.filter((o: any) => o.status === 'cancelled')
-      const refunds = cancelledOrders.reduce((sum: number, o: any) => sum + (o.total_amount || 0), 0)
-      const netRevenue = totalSales - refunds
+  apiResponse: true,
 
-      // Group orders by date for daily sales
-      const ordersByDate: Record<string, { total: number, count: number }> = {}
-      for (const o of allOrders as any[]) {
-        const date = o.created_at ? String(o.created_at).split('T')[0] : 'Unknown'
-        if (!ordersByDate[date]) {
-          ordersByDate[date] = { total: 0, count: 0 }
-        }
-        ordersByDate[date].total += o.total_amount || 0
-        ordersByDate[date].count++
-      }
+  async handle(request: RequestInstance) {
+    let range
+    try {
+      range = normalizeAnalyticsRange(request.get('range'))
+    }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'The analytics query is invalid.',
+      }, 422)
+    }
+    try {
+      const [orders, payments, orderItems, products, categories] = await Promise.all([
+        Order.orderByDesc('id').limit(10_000).get(),
+        Payment.orderByDesc('id').limit(10_000).get(),
+        OrderItem.orderByDesc('id').limit(20_000).get(),
+        Product.orderByDesc('id').limit(10_000).get(),
+        Category.orderByDesc('id').limit(10_000).get(),
+      ])
 
-      const dailySales = Object.keys(ordersByDate)
-        .sort((a, b) => b.localeCompare(a))
-        .slice(0, 7)
-        .map((date) => {
-          const data = ordersByDate[date]
+      return buildSalesAnalytics(
+        orders.map((order) => {
+          const id = analyticsIdentifier(order.get('id'), 'Order')
+          const source = `Order ${id}`
           return {
-            date,
-            sales: `$${data.total.toLocaleString()}`,
-            orders: data.count,
-            avgOrder: `$${data.count > 0 ? (data.total / data.count).toFixed(2) : '0.00'}`,
+            id,
+            status: analyticsString(order.get('status'), source, 'status'),
+            totalAmount: analyticsNumber(order.get('total_amount'), source, 'total_amount', { min: 0 }),
+            currency: analyticsCurrency(order.get('currency'), source),
+            createdAt: analyticsTimestamp(order.get('created_at'), source),
           }
-        })
-
-      const stats = [
-        { label: 'Total Sales', value: `$${totalSales.toLocaleString()}`, change: '' },
-        { label: 'Transactions', value: String(orderCount), change: '' },
-        { label: 'Refunds', value: `$${refunds.toLocaleString()}`, change: '' },
-        { label: 'Net Revenue', value: `$${netRevenue.toLocaleString()}`, change: '' },
-      ]
-
-      // Payment method breakdown estimated from orders
-      const paymentMethods = orderCount > 0
-        ? [
-            { method: 'Credit Card', amount: `$${Math.round(totalSales * 0.67).toLocaleString()}`, transactions: Math.floor(orderCount * 0.67), percentage: 66.6 },
-            { method: 'PayPal', amount: `$${Math.round(totalSales * 0.20).toLocaleString()}`, transactions: Math.floor(orderCount * 0.20), percentage: 19.5 },
-            { method: 'Apple Pay', amount: `$${Math.round(totalSales * 0.10).toLocaleString()}`, transactions: Math.floor(orderCount * 0.10), percentage: 10.0 },
-            { method: 'Other', amount: `$${Math.round(totalSales * 0.03).toLocaleString()}`, transactions: Math.floor(orderCount * 0.03), percentage: 3.9 },
-          ]
-        : []
-
-      return {
-        stats,
-        dailySales,
-        paymentMethods,
-        salesTeam: [],
-      }
+        }),
+        payments.map((payment) => {
+          const id = analyticsIdentifier(payment.get('id'), 'Payment')
+          const source = `Payment ${id}`
+          return {
+            method: analyticsString(payment.get('method'), source, 'method'),
+            status: analyticsString(payment.get('status'), source, 'status'),
+            amount: analyticsNumber(payment.get('amount'), source, 'amount', { min: 0 }),
+            refundAmount: analyticsOptionalNumber(payment.get('refund_amount'), source, 'refund_amount', { min: 0 }) ?? 0,
+            currency: analyticsCurrency(payment.get('currency'), source),
+            createdAt: analyticsTimestamp(payment.get('created_at'), source),
+          }
+        }),
+        orderItems.map((item) => {
+          const id = analyticsIdentifier(item.get('id'), 'OrderItem')
+          const source = `OrderItem ${id}`
+          return {
+            orderId: analyticsIdentifier(item.get('order_id'), source, 'order_id'),
+            productId: analyticsIdentifier(item.get('product_id'), source, 'product_id'),
+            quantity: analyticsNumber(item.get('quantity'), source, 'quantity', { min: 1, integer: true }),
+            price: analyticsNumber(item.get('price'), source, 'price', { min: 0 }),
+          }
+        }),
+        products.map((product) => {
+          const id = analyticsIdentifier(product.get('id'), 'Product')
+          const source = `Product ${id}`
+          return {
+            id,
+            name: analyticsString(product.get('name'), source, 'name'),
+            categoryId: analyticsOptionalString(product.get('category_id'), source, 'category_id'),
+          }
+        }),
+        categories.map((category) => {
+          const id = analyticsIdentifier(category.get('id'), 'Category')
+          return {
+            id,
+            name: analyticsString(category.get('name'), `Category ${id}`, 'name'),
+          }
+        }),
+        range,
+      )
     }
-    catch {
-      return { stats: [], dailySales: [], paymentMethods: [], salesTeam: [] }
+    catch (error) {
+      return response.json({
+        message: error instanceof Error ? error.message : 'Sales analytics records could not be read.',
+      }, 503)
     }
   },
 })

package/app/Actions/Dashboard/Analytics/WebAnalyticsAction.ts

@@ -1,119 +1,35 @@
+import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
-import { log } from '@stacksjs/logging'
+import { Request } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import {
+  buildWebAnalytics,
+  normalizeAnalyticsRange,
+  normalizeAnalyticsScope,
+  requestAnalyticsRow,
+} from './request-analytics'
 
 export default new Action({
   name: 'WebAnalyticsAction',
-  description: 'Returns web analytics data from ts-analytics.',
+  description: 'Returns privacy-safe web traffic aggregates from recorded application requests.',
   method: 'GET',
-  async handle() {
-    try {
-      const { AnalyticsQueryAPI, AnalyticsStore } = await import('@ts-analytics/tracking/analytics')
-      const store = new AnalyticsStore({ tableName: 'analytics' })
-      const queryApi = new AnalyticsQueryAPI(store)
-
-      const now = new Date()
-      const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000)
-      const dateRange = { start: thirtyDaysAgo, end: now }
-
-      const queries = queryApi.generateDashboardQueries({
-        siteId: 'default',
-        dateRange,
-        includeComparison: true,
-        topLimit: 10,
-      })
-
-      const period = AnalyticsQueryAPI.determinePeriod(dateRange)
-      const periodStart = AnalyticsStore.getPeriodStart(now, period)
-
-      const [statsResult, previousResult, topPagesResult, deviceResult] = await Promise.all([
-        queries.aggregatedStats,
-        queries.previousPeriodStats ?? null,
-        queries.topPages,
-        store.getDeviceStatsCommand('default', period, periodStart),
-      ])
-
-      const rawStats = (statsResult as { Items?: unknown[] })?.Items ?? []
-      const rawPrevious = previousResult
-        ? (previousResult as { Items?: unknown[] })?.Items ?? []
-        : undefined
-
-      const summary = AnalyticsQueryAPI.processSummary(
-        rawStats as Parameters<typeof AnalyticsQueryAPI.processSummary>[0],
-        rawPrevious as Parameters<typeof AnalyticsQueryAPI.processSummary>[1],
-      )
-
-      const topPages = AnalyticsQueryAPI.processTopPages(
-        (topPagesResult as { Items?: unknown[] })?.Items as Parameters<typeof AnalyticsQueryAPI.processTopPages>[0] ?? [],
-        summary.pageViews,
-      )
+  apiResponse: true,
 
-      const referrerPeriodStart = AnalyticsStore.getPeriodStart(now, period)
-      const referrerCmd = store.getDeviceStatsCommand('default', period, referrerPeriodStart)
-      const referrerResult = (referrerCmd as unknown as { Items?: unknown[] })?.Items ?? []
-
-      const deviceItems = (deviceResult as unknown as { Items?: unknown[] })?.Items ?? []
-      const devices = AnalyticsQueryAPI.processTopDevices(
-        deviceItems as Parameters<typeof AnalyticsQueryAPI.processTopDevices>[0],
-        'device',
-        summary.uniqueVisitors,
-      )
-
-      const formatChange = (val: number | undefined): string => {
-        if (val === undefined || val === 0) return ''
-        return `${val > 0 ? '+' : ''}${val.toFixed(1)}%`
-      }
-
-      const stats = [
-        {
-          label: 'Page Views',
-          value: summary.pageViews.toLocaleString(),
-          change: formatChange(summary.comparison?.pageViewsChange),
-        },
-        {
-          label: 'Unique Visitors',
-          value: summary.uniqueVisitors.toLocaleString(),
-          change: formatChange(summary.comparison?.visitorsChange),
-        },
-        {
-          label: 'Avg Session',
-          value: `${Math.floor(summary.avgSessionDuration / 60000)}m ${Math.floor((summary.avgSessionDuration % 60000) / 1000)}s`,
-          change: '',
-        },
-        {
-          label: 'Bounce Rate',
-          value: `${(summary.bounceRate * 100).toFixed(1)}%`,
-          change: formatChange(summary.comparison?.bounceRateChange ? summary.comparison.bounceRateChange * 100 : undefined),
-        },
-      ]
-
-      const sources = referrerResult.map((r: any) => ({
-        source: r.source ?? r.name ?? 'Unknown',
-        visitors: String(r.visitors ?? r.value ?? 0),
-        percentage: `${(r.percentage ?? 0).toFixed(1)}%`,
-      }))
-
-      return {
-        stats,
-        topPages: topPages.map(p => ({
-          page: p.name,
-          title: p.name,
-          views: String(p.value),
-          unique: String(Math.round(p.value * 0.75)),
-          avgTime: '',
-        })),
-        sources,
-        devices: devices.map(d => ({
-          device: d.name,
-          percentage: Math.round(d.percentage),
-        })),
-      }
+  async handle(request: RequestInstance) {
+    let range
+    let scope
+    try {
+      range = normalizeAnalyticsRange(request.get('range'))
+      scope = normalizeAnalyticsScope(request.get('scope'))
     }
     catch (error) {
-      // The analytics integration is optional: without
-      // @ts-analytics/tracking installed the dashboard renders empty
-      // rather than erroring. Log so a broken install is still visible.
-      log.debug('[WebAnalyticsAction] analytics unavailable:', error)
-      return { stats: [], topPages: [], sources: [], devices: [] }
+      return response.json({
+        message: error instanceof Error ? error.message : 'The analytics query is invalid.',
+      }, 422)
     }
+    const records = await Request.orderByDesc('id').limit(10_000).get()
+    const rows = records.map(requestAnalyticsRow)
+
+    return buildWebAnalytics(rows, range, new Date(), scope)
   },
 })

package/app/Actions/Dashboard/Analytics/analytics-record.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  analyticsCurrency,
+  analyticsIdentifier,
+  analyticsNumber,
+  analyticsOptionalNumber,
+  analyticsOptionalString,
+  analyticsString,
+  analyticsTimestamp,
+} from './analytics-record'
+
+describe('analytics model record validation', () => {
+  test('normalizes valid identifiers, currencies, numbers, and timestamps', () => {
+    expect(analyticsIdentifier(42, 'Order')).toBe('42')
+    expect(analyticsIdentifier(' row-1 ', 'Order')).toBe('row-1')
+    expect(analyticsCurrency(' usd ', 'Order')).toBe('USD')
+    expect(analyticsNumber('12.50', 'Order', 'total', { min: 0 })).toBe(12.5)
+    expect(analyticsTimestamp('2026-07-29 12:00:00', 'Order')).toBe('2026-07-29T12:00:00.000Z')
+  })
+
+  test('distinguishes nullable values from recorded zeroes', () => {
+    expect(analyticsOptionalNumber(null, 'Campaign', 'open_rate')).toBeNull()
+    expect(analyticsOptionalNumber(0, 'Campaign', 'open_rate')).toBe(0)
+    expect(analyticsOptionalString(null, 'Product', 'category_id')).toBe('')
+  })
+
+  test('rejects coercive or out-of-range stored values', () => {
+    expect(() => analyticsNumber('', 'Payment', 'amount')).toThrow('Payment.amount must be a finite number')
+    expect(() => analyticsNumber('0x10', 'Payment', 'amount')).toThrow('Payment.amount must be a finite number')
+    expect(() => analyticsNumber(101, 'Campaign', 'open_rate', { max: 100 })).toThrow('at most 100')
+    expect(() => analyticsString({}, 'Event', 'name')).toThrow('Event.name must be a non-empty string')
+    expect(() => analyticsCurrency('US', 'Order')).toThrow('three-letter currency code')
+    expect(() => analyticsTimestamp('not-a-date', 'Order')).toThrow('valid timestamp')
+  })
+})