@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/DashboardHealthAction.ts

@@ -1,52 +1,30 @@
+import process from 'node:process'
 import { Action } from '@stacksjs/actions'
+import { checkApplicationHealth } from '@stacksjs/router'
 
 export default new Action({
-  name: 'Dashboard Health',
-  description: 'Fetch system health status for dashboard',
+  name: 'DashboardHealthAction',
+  description: 'Runs the native application dependency probes and returns runtime telemetry.',
   method: 'GET',
+  apiResponse: true,
 
   async handle() {
-    // Mock data for development - replace with actual service checks when fully configured
-    const services = [
-      {
-        name: 'API',
-        status: 'healthy',
-        latency: '12ms',
-        uptime: '99.9%',
-      },
-      {
-        name: 'Database',
-        status: 'healthy',
-        latency: '8ms',
-        uptime: '99.9%',
-      },
-      {
-        name: 'Storage',
-        status: 'healthy',
-        latency: '5ms',
-        uptime: '99.9%',
-      },
-      {
-        name: 'Cache',
-        status: 'healthy',
-        latency: '2ms',
-        uptime: '99.9%',
-      },
-      {
-        name: 'Queue',
-        status: 'healthy',
-        latency: '5ms',
-        uptime: '99.9%',
-      },
-      {
-        name: 'Notifications',
-        status: 'healthy',
-        latency: '15ms',
-        uptime: '99.8%',
-      },
-    ]
+    const startedAt = performance.now()
+    const health = await checkApplicationHealth()
+    const memory = process.memoryUsage()
 
-    // Return the services directly - the router will handle JSON serialization
-    return { services }
+    return {
+      ...health,
+      durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
+      runtime: {
+        bunVersion: process.versions.bun || '',
+        nodeVersion: process.versions.node || '',
+        platform: process.platform,
+        architecture: process.arch,
+        uptimeSeconds: Math.max(0, Math.floor(process.uptime())),
+        residentMemoryBytes: memory.rss,
+        heapUsedBytes: memory.heapUsed,
+      },
+    }
   },
 })

package/app/Actions/Dashboard/DashboardHomeAction.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { summarizeHttpRequests } from './DashboardHomeAction'
+import { orderActivityStatus, serializeHealthCheck, summarizeHttpRequests } from './DashboardHomeAction'
 
 describe('dashboard HTTP metrics', () => {
   it('summarizes captured requests without fake values', () => {
@@ -14,6 +14,28 @@ describe('dashboard HTTP metrics', () => {
   })
 
   it('returns explicit empty-state metrics', () => {
-    expect(summarizeHttpRequests(0, []).map(metric => metric.value)).toEqual(['0', '0ms', '100%', '0%'])
+    expect(summarizeHttpRequests(0, []).map(metric => metric.value)).toEqual(['0', '0ms', 'N/A', 'N/A'])
+  })
+
+  it('serializes only probed service health', () => {
+    expect(serializeHealthCheck('database', { ok: true, ms: 3 })).toEqual({
+      name: 'Database',
+      status: 'healthy',
+      latency: '3ms',
+      detail: '',
+    })
+    expect(serializeHealthCheck('cache', { ok: false, ms: 1500, message: 'timeout' })).toEqual({
+      name: 'Cache',
+      status: 'critical',
+      latency: '1500ms',
+      detail: 'timeout',
+    })
+  })
+
+  it('marks unsuccessful order states as warnings', () => {
+    expect(orderActivityStatus('CANCELED')).toBe('warning')
+    expect(orderActivityStatus('cancelled')).toBe('warning')
+    expect(orderActivityStatus('failed')).toBe('warning')
+    expect(orderActivityStatus('preparing')).toBe('success')
   })
 })

package/app/Actions/Dashboard/DashboardHomeAction.ts

@@ -1,5 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { Order, Post, Product, Request, User } from '@stacksjs/orm'
+import { checkApplicationHealth, type ApplicationHealthCheck } from '@stacksjs/router'
+import { formatRelative, safeGet } from '../../../resources/functions/dashboard/data'
 
 interface HttpRequestSample {
   duration: number
@@ -16,105 +18,116 @@ export function summarizeHttpRequests(total: number, requests: HttpRequestSample
   return [
     { title: 'HTTP Requests', value: total.toLocaleString(), detail: 'All captured requests', icon: 'i-hugeicons-global' },
     { title: 'Average Response', value: `${averageDuration}ms`, detail: `Latest ${requests.length.toLocaleString()} requests`, icon: 'i-hugeicons-clock-01' },
-    { title: 'Success Rate', value: requests.length > 0 ? `${((successful / requests.length) * 100).toFixed(1)}%` : '100%', detail: '2xx and 3xx responses', icon: 'i-hugeicons-checkmark-circle-02' },
-    { title: 'Error Rate', value: requests.length > 0 ? `${((failed / requests.length) * 100).toFixed(1)}%` : '0%', detail: '4xx and 5xx responses', icon: 'i-hugeicons-alert-02' },
+    { title: 'Success Rate', value: requests.length > 0 ? `${((successful / requests.length) * 100).toFixed(1)}%` : 'N/A', detail: '2xx and 3xx responses', icon: 'i-hugeicons-checkmark-circle-02' },
+    { title: 'Error Rate', value: requests.length > 0 ? `${((failed / requests.length) * 100).toFixed(1)}%` : 'N/A', detail: '4xx and 5xx responses', icon: 'i-hugeicons-alert-02' },
   ]
 }
 
+export function serializeHealthCheck(name: string, check: ApplicationHealthCheck) {
+  return {
+    name: name.charAt(0).toUpperCase() + name.slice(1),
+    status: check.ok ? 'healthy' : 'critical',
+    latency: `${check.ms}ms`,
+    detail: check.message || '',
+  }
+}
+
+export function orderActivityStatus(status: unknown): 'success' | 'warning' {
+  const normalized = String(status || '').toLowerCase()
+  return normalized.startsWith('cancel') || normalized === 'failed' || normalized === 'refunded'
+    ? 'warning'
+    : 'success'
+}
+
+function issue(source: string, result: PromiseSettledResult<unknown>) {
+  return result.status === 'rejected'
+    ? {
+        source,
+        message: result.reason instanceof Error ? result.reason.message : 'Query failed.',
+      }
+    : null
+}
+
 export default new Action({
   name: 'DashboardHomeAction',
   description: 'Returns home dashboard data including stats, quick links, services, and recent activity.',
   method: 'GET',
 
   async handle() {
-    let userCount = 0
-    let productCount = 0
-    let orderCount = 0
-    let postCount = 0
-    let totalRevenue = 0
-    let recentOrderRows: any[] = []
-    let recentUserRows: any[] = []
-    let databaseStatus = 'offline'
-    let httpMetrics = summarizeHttpRequests(0, [])
-
-    try {
-      const results = await Promise.all([
-        User.count(),
-        Product.count(),
-        Order.count(),
-        Post.count(),
-        Order.orderBy('created_at', 'desc').limit(5).get(),
-        User.orderBy('created_at', 'desc').limit(3).get(),
-      ])
+    const modelResults = await Promise.allSettled([
+      User.count(),
+      Product.count(),
+      Order.count(),
+      Post.count(),
+      Order.sum('totalAmount'),
+      Order.orderBy('created_at', 'desc').limit(5).get(),
+      User.orderBy('created_at', 'desc').limit(5).get(),
+      Request.count(),
+      Request.orderBy('created_at', 'desc').limit(1000).get(),
+    ])
+    const health = await checkApplicationHealth()
 
-      userCount = results[0]
-      productCount = results[1]
-      orderCount = results[2]
-      postCount = results[3]
-      recentOrderRows = results[4]
-      recentUserRows = results[5]
+    const [
+      userCount,
+      productCount,
+      orderCount,
+      postCount,
+      totalRevenue,
+      recentOrders,
+      recentUsers,
+      requestCount,
+      recentRequests,
+    ] = modelResults
 
-      // Calculate total revenue from all orders
-      const allOrders = await Order.all()
-      totalRevenue = allOrders.reduce((sum, o) => sum + (Number(o.get('total_amount')) || 0), 0)
-      databaseStatus = 'healthy'
-    }
-    catch {
-      // A new project may not have run its migrations yet.
-    }
+    const stats = [
+      { label: 'Total Users', value: userCount.status === 'fulfilled' ? String(userCount.value) : 'Unavailable', color: 'blue' },
+      { label: 'Products', value: productCount.status === 'fulfilled' ? String(productCount.value) : 'Unavailable', color: 'green' },
+      { label: 'Revenue', value: totalRevenue.status === 'fulfilled' ? `$${Number(totalRevenue.value || 0).toLocaleString()}` : 'Unavailable', color: 'orange' },
+      { label: 'Orders', value: orderCount.status === 'fulfilled' ? String(orderCount.value) : 'Unavailable', color: 'red' },
+    ]
 
-    try {
-      const [requestCount, recentRequests] = await Promise.all([
-        Request.count(),
-        Request.orderBy('created_at', 'desc').limit(1000).get(),
-      ])
-      httpMetrics = summarizeHttpRequests(requestCount, recentRequests.map(request => ({
+    const httpMetrics = requestCount.status === 'fulfilled' && recentRequests.status === 'fulfilled'
+      ? summarizeHttpRequests(requestCount.value, recentRequests.value.map(request => ({
         duration: Number(request.get('duration_ms')) || 0,
         status: Number(request.get('status_code')) || 500,
       })))
-    }
-    catch {
-      // Request capture is optional, so its empty state is valid.
-    }
+      : summarizeHttpRequests(0, [])
 
-    const stats = [
-      { label: 'Total Users', value: String(userCount), color: 'blue' },
-      { label: 'Products', value: String(productCount), color: 'green' },
-      { label: 'Revenue', value: `$${totalRevenue.toLocaleString()}`, color: 'orange' },
-      { label: 'Orders', value: String(orderCount), color: 'red' },
-    ]
-
-    const quickLinks = [
-      { title: 'Blog', description: 'Manage posts and content', page: 'posts' },
-      { title: 'Commerce', description: 'View sales and orders', page: 'commerce-dashboard' },
-      { title: 'Cloud', description: 'Infrastructure settings', page: 'cloud' },
-      { title: 'Settings', description: 'Configure your app', page: 'settings' },
-    ]
+    const services = Object.entries(health.checks).map(([name, check]) => serializeHealthCheck(name, check))
 
-    const services = [
-      { name: 'Database', status: databaseStatus, latency: 'N/A' },
-      { name: 'Cache', status: 'configured', latency: 'N/A' },
-      { name: 'Queue', status: 'configured', latency: 'N/A' },
-      { name: 'Storage', status: 'configured', latency: 'N/A' },
-      { name: 'Email', status: 'configured', latency: 'N/A' },
-    ]
-
-    // Build activities from real data
     const activities = [
-      ...recentOrderRows.map((o: any) => ({
+      ...(recentOrders.status === 'fulfilled' ? recentOrders.value : []).map((order: any) => ({
         type: 'order',
-        message: `Order #${o.get('id')} - $${o.get('total_amount')} (${o.get('status')})`,
-        time: 'Recently',
+        message: `Order #${order.get('id')} - $${order.get('total_amount')} (${order.get('status')})`,
+        time: formatRelative(safeGet(order, 'created_at')),
+        timestamp: String(safeGet(order, 'created_at', '')),
         user: 'Commerce',
+        status: orderActivityStatus(order.get('status')),
       })),
-      ...recentUserRows.map((u: any) => ({
+      ...(recentUsers.status === 'fulfilled' ? recentUsers.value : []).map((user: any) => ({
         type: 'user',
-        message: `User ${u.get('name')} registered`,
-        time: 'Recently',
+        message: `User ${user.get('name') || `#${user.get('id')}`} registered`,
+        time: formatRelative(safeGet(user, 'created_at')),
+        timestamp: String(safeGet(user, 'created_at', '')),
         user: 'System',
+        status: 'success',
       })),
-    ].slice(0, 5)
+    ]
+      .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+      .slice(0, 5)
+      .map(activity => ({
+        type: activity.type,
+        message: activity.message,
+        time: activity.time,
+        user: activity.user,
+        status: activity.status,
+      }))
+
+    const sources = ['Users', 'Products', 'Orders', 'Posts', 'Revenue', 'Recent orders', 'Recent users', 'Request count', 'Recent requests']
+    const issues = modelResults
+      .map((result, index) => issue(sources[index], result))
+      .filter((entry): entry is { source: string, message: string } => entry !== null)
 
-    return { stats, httpMetrics, quickLinks, services, activities }
+    return { stats, httpMetrics, services, activities, issues }
   },
 })

package/app/Actions/Dashboard/DashboardLegacyActions.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'bun:test'
+import { activityStatus } from './DashboardActivityAction'
+import { formatDashboardStat } from './DashboardStatsAction'
+
+describe('legacy dashboard API projections', () => {
+  it('formats persisted totals without inventing trends', () => {
+    expect(formatDashboardStat(
+      { title: 'Users', icon: 'users', iconBg: 'primary' },
+      { status: 'fulfilled', value: 1234 },
+    )).toEqual({
+      title: 'Users',
+      icon: 'users',
+      iconBg: 'primary',
+      value: '1,234',
+      trend: 0,
+      trendLabel: 'Current total',
+    })
+  })
+
+  it('marks an unavailable model explicitly', () => {
+    expect(formatDashboardStat(
+      { title: 'Orders', icon: 'orders', iconBg: 'success' },
+      { status: 'rejected', reason: new Error('missing table') },
+    ).value).toBe('Unavailable')
+  })
+
+  it('derives activity severity from persisted event types', () => {
+    expect(activityStatus('order.completed')).toBe('success')
+    expect(activityStatus('login.failed')).toBe('warning')
+    expect(activityStatus('product.deleted')).toBe('warning')
+  })
+})

package/app/Actions/Dashboard/DashboardStatsAction.ts

@@ -1,48 +1,70 @@
 import { Action } from '@stacksjs/actions'
+import { Customer, Order, Post, User } from '@stacksjs/orm'
+
+interface DashboardStatDefinition {
+  title: string
+  icon: string
+  iconBg: string
+  count: () => Promise<number>
+}
+
+export function formatDashboardStat(
+  definition: Omit<DashboardStatDefinition, 'count'>,
+  result: PromiseSettledResult<number>,
+) {
+  return {
+    ...definition,
+    value: result.status === 'fulfilled' ? result.value.toLocaleString() : 'Unavailable',
+    trend: 0,
+    trendLabel: result.status === 'fulfilled' ? 'Current total' : 'Model unavailable',
+  }
+}
 
 export default new Action({
   name: 'Dashboard Stats',
-  description: 'Fetch dashboard statistics for overview cards',
+  description: 'Fetch persisted dashboard statistics for overview cards',
   method: 'GET',
 
   async handle() {
-    // Mock data for development - replace with actual ORM queries when database is set up
-    const stats = [
+    const definitions: DashboardStatDefinition[] = [
       {
         title: 'Total Users',
-        value: '1,234',
-        trend: 12,
-        trendLabel: 'vs last period',
         icon: 'i-hugeicons-user-group',
         iconBg: 'primary',
+        count: () => User.count(),
       },
       {
         title: 'Active Orders',
-        value: '567',
-        trend: 8,
-        trendLabel: 'vs last period',
         icon: 'i-hugeicons-shopping-cart-02',
         iconBg: 'success',
+        count: () => Order.where('status', '!=', 'cancelled').count(),
       },
       {
         title: 'Blog Posts',
-        value: '89',
-        trend: -3,
-        trendLabel: 'vs last period',
         icon: 'i-hugeicons-document-validation',
         iconBg: 'info',
+        count: () => Post.count(),
       },
       {
         title: 'Customers',
-        value: '2,345',
-        trend: 15,
-        trendLabel: 'vs last period',
         icon: 'i-hugeicons-user-multiple',
         iconBg: 'warning',
+        count: () => Customer.count(),
       },
     ]
 
-    // Return the stats directly - the router will handle JSON serialization
-    return { stats }
+    const results = await Promise.allSettled(definitions.map(definition => definition.count()))
+    const stats = definitions.map((definition, index) => {
+      const { count: _count, ...metadata } = definition
+      return formatDashboardStat(metadata, results[index])
+    })
+    const issues = results.flatMap((result, index) => result.status === 'rejected'
+      ? [{
+          source: definitions[index].title,
+          message: result.reason instanceof Error ? result.reason.message : 'Model query failed.',
+        }]
+      : [])
+
+    return { stats, issues }
   },
 })

package/app/Actions/Dashboard/Data/ActivityIndexAction.ts

@@ -1,28 +1,47 @@
 import { Action } from '@stacksjs/actions'
 import { Activity } from '@stacksjs/orm'
+import { safeGet } from '../../../../resources/functions/dashboard/data'
+import { dateValue, daysAgoIso, numberValue, textValue } from './data-records'
 
 export default new Action({
   name: 'ActivityIndexAction',
-  description: 'Returns recent activity data for the dashboard.',
+  description: 'Returns a safe projection of recent activity for the dashboard.',
   method: 'GET',
+  apiResponse: true,
   async handle() {
-    const filters = ['All', 'Creates', 'Updates', 'Deletes', 'Schema', 'Exports']
-
     try {
-      const allActivities = await Activity.orderByDesc('id').limit(50).get()
-
-      const activities = allActivities.map(r => ({
-        action: String(r.get('action') || r.get('description') || ''),
-        table: String(r.get('table_name') || r.get('subject_type') || ''),
-        user: String(r.get('user') || r.get('causer_id') || 'system'),
-        time: String(r.get('created_at') || ''),
-        type: String(r.get('type') || 'update'),
+      const rows = await Activity.orderByDesc('created_at').limit(100).get()
+      const activities = rows.map(row => ({
+        id: numberValue(safeGet(row, 'id', 0)),
+        type: textValue(safeGet(row, 'type')),
+        description: textValue(safeGet(row, 'description')),
+        subjectType: textValue(safeGet(row, 'subject_type', safeGet(row, 'subjectType'))),
+        subjectId: numberValue(safeGet(row, 'subject_id', safeGet(row, 'subjectId', 0))),
+        causer: textValue(safeGet(row, 'causer'), 'System'),
+        createdAt: dateValue(safeGet(row, 'created_at', safeGet(row, 'createdAt'))),
       }))
 
-      return { activities, filters }
+      const [total, last24Hours, last7Days] = await Promise.all([
+        Activity.count(),
+        Activity.where('created_at', '>=', daysAgoIso(1)).count(),
+        Activity.where('created_at', '>=', daysAgoIso(7)).count(),
+      ])
+
+      return {
+        activities,
+        stats: {
+          total,
+          last24Hours,
+          last7Days,
+        },
+      }
     }
-    catch {
-      return { activities: [], filters }
+    catch (error) {
+      return {
+        activities: [],
+        stats: { total: 0, last24Hours: 0, last7Days: 0 },
+        error: error instanceof Error ? error.message : 'Activity could not be loaded.',
+      }
     }
   },
 })

package/app/Actions/Dashboard/Data/SubscriberIndexAction.ts

@@ -1,47 +1,47 @@
 import { Action } from '@stacksjs/actions'
 import { Subscriber } from '@stacksjs/orm'
+import { safeGet } from '../../../../resources/functions/dashboard/data'
+import { dateValue, daysAgoIso, numberValue, textValue } from './data-records'
 
 export default new Action({
   name: 'SubscriberIndexAction',
-  description: 'Returns subscriber data for the dashboard.',
+  description: 'Returns subscribers and native subscription statistics for the dashboard.',
   method: 'GET',
+  apiResponse: true,
   async handle() {
-    const plans = ['All Plans', 'Basic', 'Pro', 'Enterprise']
-    const planTypes = ['Basic', 'Pro', 'Enterprise']
-    const sources = ['Website', 'API', 'Referral']
-
     try {
-      const allSubscribers = await Subscriber.orderBy('created_at', 'desc').get()
-      const totalSubscribers = await Subscriber.count()
-
-      const subscribers = allSubscribers.map((s, idx) => ({
-        email: String(s.get('email') || 'N/A'),
-        name: String(s.get('name') || 'Subscriber'),
-        plan: planTypes[idx % planTypes.length],
-        status: 'active',
-        subscribed: s.get('created_at') ? String(s.get('created_at')).split('T')[0] : 'N/A',
-        source: sources[idx % sources.length],
+      const rows = await Subscriber.orderByDesc('created_at').limit(100).get()
+      const subscribers = rows.map(row => ({
+        id: numberValue(safeGet(row, 'id', 0)),
+        email: textValue(safeGet(row, 'email')),
+        status: textValue(safeGet(row, 'status'), 'pending'),
+        source: textValue(safeGet(row, 'source'), 'unknown'),
+        unsubscribedAt: dateValue(safeGet(row, 'unsubscribed_at', safeGet(row, 'unsubscribedAt'))),
+        createdAt: dateValue(safeGet(row, 'created_at', safeGet(row, 'createdAt'))),
       }))
 
-      const stats = [
-        { label: 'Total Subscribers', value: String(totalSubscribers) },
-        { label: 'Active', value: String(totalSubscribers) },
-        { label: 'New This Month', value: String(Math.min(totalSubscribers, 5)) },
-        { label: 'Churn Rate', value: '0%' },
-      ]
+      const [total, subscribed, unsubscribed, newThisMonth] = await Promise.all([
+        Subscriber.count(),
+        Subscriber.where('status', 'subscribed').count(),
+        Subscriber.where('status', 'unsubscribed').count(),
+        Subscriber.where('created_at', '>=', daysAgoIso(30)).count(),
+      ])
 
-      return { subscribers, stats, plans }
+      return {
+        subscribers,
+        stats: {
+          total,
+          subscribed,
+          unsubscribed,
+          newThisMonth,
+        },
+      }
     }
-    catch {
+    catch (error) {
       return {
         subscribers: [],
-        stats: [
-          { label: 'Total Subscribers', value: '0' },
-          { label: 'Active', value: '0' },
-          { label: 'New This Month', value: '0' },
-          { label: 'Churn Rate', value: '0%' },
-        ],
-        plans,
+        stats: { total: 0, subscribed: 0, unsubscribed: 0, newThisMonth: 0 },
+        error: error instanceof Error ? error.message : 'Subscribers could not be loaded.',
       }
     }
   },

package/app/Actions/Dashboard/Data/TeamIndexAction.ts

@@ -1,42 +1,48 @@
 import { Action } from '@stacksjs/actions'
 import { Team } from '@stacksjs/orm'
+import { safeGet } from '../../../../resources/functions/dashboard/data'
+import { dateValue, daysAgoIso, numberValue, textValue } from './data-records'
 
 export default new Action({
   name: 'TeamIndexAction',
-  description: 'Returns team data for the dashboard.',
+  description: 'Returns teams and native team statistics for the dashboard.',
   method: 'GET',
+  apiResponse: true,
   async handle() {
     try {
-      const allTeams = await Team.all()
-      const totalTeams = await Team.count()
-
-      const teams = allTeams.map(t => ({
-        name: String(t.get('name') || 'Team'),
-        members: Number(t.get('members_count') || 0),
-        projects: Number(t.get('projects_count') || 0),
-        status: 'active',
-        lead: String(t.get('lead') || 'Team Lead'),
+      const rows = await Team.orderByDesc('created_at').limit(100).get()
+      const teams = rows.map(row => ({
+        id: numberValue(safeGet(row, 'id', 0)),
+        name: textValue(safeGet(row, 'name'), 'Unnamed team'),
+        description: textValue(safeGet(row, 'description')),
+        memberCount: numberValue(safeGet(row, 'member_count', safeGet(row, 'memberCount', 0))),
+        status: textValue(safeGet(row, 'status'), 'inactive'),
+        createdAt: dateValue(safeGet(row, 'created_at', safeGet(row, 'createdAt'))),
+        updatedAt: dateValue(safeGet(row, 'updated_at', safeGet(row, 'updatedAt'))),
       }))
 
-      const totalMembers = teams.reduce((sum, t) => sum + t.members, 0)
-      const totalProjects = teams.reduce((sum, t) => sum + t.projects, 0)
-
-      const stats = [
-        { label: 'Total Teams', value: String(totalTeams) },
-        { label: 'Total Members', value: String(totalMembers) },
-        { label: 'Active Projects', value: String(totalProjects) },
-      ]
+      const [total, active, members, newThisMonth] = await Promise.all([
+        Team.count(),
+        Team.where('status', 'active').count(),
+        Team.sum('memberCount'),
+        Team.where('created_at', '>=', daysAgoIso(30)).count(),
+      ])
 
-      return { teams, stats }
+      return {
+        teams,
+        stats: {
+          total,
+          active,
+          members,
+          newThisMonth,
+        },
+      }
     }
-    catch {
+    catch (error) {
       return {
         teams: [],
-        stats: [
-          { label: 'Total Teams', value: '0' },
-          { label: 'Total Members', value: '0' },
-          { label: 'Active Projects', value: '0' },
-        ],
+        stats: { total: 0, active: 0, members: 0, newThisMonth: 0 },
+        error: error instanceof Error ? error.message : 'Teams could not be loaded.',
       }
     }
   },