@stacksjs/defaults 0.70.58 → 0.70.60

package/app/Actions/Dashboard/Content/PostIndexAction.ts

@@ -0,0 +1,102 @@
+import { Action } from '@stacksjs/actions'
+import { Post, Category, Tag } from '@stacksjs/orm'
+
+// Mock data used when the ORM is unavailable or has no posts (e.g. dev
+// dashboard with no DB seeded). Shape matches the `BlogPost` interface in
+// storage/framework/defaults/views/dashboard/content/posts/index.stx so
+// the page can hydrate directly from this response.
+const mockPosts = [
+  { id: 1, title: '10 Tips for Better Code Quality', excerpt: 'Improve your code quality with these essential tips.', slug: '10-tips-for-better-code-quality', category: 'Tutorials', tags: ['Coding', 'Best Practices'], author: 'Jane Doe', views: 12450, comments: 78, published: '2023-12-01', status: 'Published', featured: true, poster: 'https://picsum.photos/seed/1/280/160' },
+  { id: 2, title: 'The Future of JavaScript Frameworks', excerpt: 'Exploring what\'s next for JS frameworks.', slug: 'future-of-javascript-frameworks', category: 'Technology', tags: ['JavaScript', 'Frameworks'], author: 'John Smith', views: 9870, comments: 124, published: '2023-11-28', status: 'Published', featured: true, poster: 'https://picsum.photos/seed/2/280/160' },
+  { id: 3, title: 'Getting Started with Vue 3', excerpt: 'A comprehensive guide to Vue 3 composition API.', slug: 'getting-started-with-vue-3', category: 'Tutorials', tags: ['Vue', 'JavaScript'], author: 'Jane Doe', views: 8760, comments: 45, published: '2023-11-25', status: 'Published', featured: false, poster: 'https://picsum.photos/seed/3/280/160' },
+  { id: 4, title: 'Review: Latest MacBook Pro', excerpt: 'In-depth review for developers.', slug: 'review-latest-macbook-pro', category: 'Reviews', tags: ['Hardware', 'Apple'], author: 'Michael Brown', views: 7650, comments: 92, published: '2023-11-20', status: 'Published', featured: false, poster: 'https://picsum.photos/seed/4/280/160' },
+  { id: 5, title: 'Understanding Web Accessibility', excerpt: 'Why accessibility matters and how to implement it.', slug: 'understanding-web-accessibility', category: 'Tutorials', tags: ['Accessibility', 'UX'], author: 'Emily Davis', views: 6540, comments: 31, published: '2023-11-15', status: 'Published', featured: false, poster: 'https://picsum.photos/seed/5/280/160' },
+  { id: 6, title: 'Introduction to TypeScript', excerpt: 'Learn the basics of TypeScript.', slug: 'introduction-to-typescript', category: 'Tutorials', tags: ['TypeScript', 'JavaScript'], author: 'Jane Doe', views: 0, comments: 0, published: '', status: 'Draft', featured: false, poster: 'https://picsum.photos/seed/6/280/160' },
+  { id: 7, title: 'Building a REST API with Node.js', excerpt: 'Step-by-step guide to building REST APIs.', slug: 'building-rest-api-nodejs', category: 'Tutorials', tags: ['Node.js', 'API'], author: 'John Smith', views: 0, comments: 0, published: '', status: 'Draft', featured: false, poster: 'https://picsum.photos/seed/7/280/160' },
+  { id: 8, title: 'The Impact of AI on Software Development', excerpt: 'How AI is changing software development.', slug: 'ai-impact-software-development', category: 'Technology', tags: ['AI', 'Future Tech'], author: 'Michael Brown', views: 5430, comments: 67, published: '2023-11-10', status: 'Published', featured: false, poster: 'https://picsum.photos/seed/8/280/160' },
+]
+
+const mockCategories = [
+  { id: 1, name: 'Tutorials', slug: 'tutorials' },
+  { id: 2, name: 'Technology', slug: 'technology' },
+  { id: 3, name: 'Reviews', slug: 'reviews' },
+]
+
+const mockTags = [
+  { id: 1, name: 'Coding', slug: 'coding' },
+  { id: 2, name: 'JavaScript', slug: 'javascript' },
+  { id: 3, name: 'Vue', slug: 'vue' },
+  { id: 4, name: 'TypeScript', slug: 'typescript' },
+]
+
+function counts(posts: Array<{ status: string }>) {
+  return {
+    publishedCount: posts.filter(p => p.status.toLowerCase() === 'published').length,
+    draftCount: posts.filter(p => p.status.toLowerCase() === 'draft').length,
+    scheduledCount: posts.filter(p => p.status.toLowerCase() === 'scheduled').length,
+  }
+}
+
+export default new Action({
+  name: 'PostIndexAction',
+  description: 'Returns posts data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    try {
+      const [allPosts, allCategories, allTags] = await Promise.all([
+        Post.orderBy('created_at', 'desc').get(),
+        Category.all(),
+        Tag.all(),
+      ])
+
+      // Empty result from a real ORM still falls through to mock data so
+      // the dev dashboard always has something to render.
+      if (!allPosts || allPosts.length === 0) {
+        return {
+          posts: mockPosts,
+          categories: mockCategories,
+          tags: mockTags,
+          ...counts(mockPosts),
+        }
+      }
+
+      const posts = allPosts.map((p, idx) => ({
+        id: Number(p.get('id') || idx + 1),
+        title: String(p.get('title') || ''),
+        excerpt: String(p.get('excerpt') || ''),
+        slug: String(p.get('slug') || ''),
+        category: String(p.get('category') || ''),
+        tags: Array.isArray(p.get('tags')) ? p.get('tags') as string[] : [],
+        author: String(p.get('author') || ''),
+        views: Number(p.get('views') || 0),
+        comments: Number(p.get('comments') || 0),
+        published: String(p.get('published_at') || p.get('published') || p.get('created_at') || ''),
+        status: String(p.get('status') || 'Draft'),
+        featured: Boolean(p.get('featured')),
+        poster: String(p.get('poster') || ''),
+      }))
+
+      const categories = allCategories.map(c => ({
+        id: Number(c.get('id')),
+        name: String(c.get('name') || ''),
+        slug: String(c.get('slug') || ''),
+      }))
+
+      const tags = allTags.map(t => ({
+        id: Number(t.get('id')),
+        name: String(t.get('name') || ''),
+        slug: String(t.get('slug') || ''),
+      }))
+
+      return { posts, categories, tags, ...counts(posts) }
+    }
+    catch {
+      return {
+        posts: mockPosts,
+        categories: mockCategories,
+        tags: mockTags,
+        ...counts(mockPosts),
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Content/SeoIndexAction.ts

@@ -0,0 +1,17 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'SeoIndexAction',
+  description: 'Returns SEO data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    return {
+      seoData: {
+        title: 'Stacks - Build better web applications',
+        description: 'A modern full-stack framework for building web applications with TypeScript.',
+        keywords: ['stacks', 'typescript', 'framework', 'web development'],
+        ogImage: '/images/og-image.png',
+      },
+    }
+  },
+})

package/app/Actions/Dashboard/Content/TagIndexAction.ts

@@ -0,0 +1,23 @@
+import { Action } from '@stacksjs/actions'
+import { Tag } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'TagIndexAction',
+  description: 'Returns tags data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    try {
+      const allTags = await Tag.all()
+
+      const tags = allTags.map(t => ({
+        name: String(t.get('name') || ''),
+        count: Number(t.get('count') || t.get('post_count') || 0),
+      }))
+
+      return { tags }
+    }
+    catch {
+      return { tags: [] }
+    }
+  },
+})

package/app/Actions/Dashboard/CreateDnsRecords.ts

@@ -0,0 +1,11 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'CreateDnsRecords',
+  description: 'Creates a new DNS record.',
+  apiResponse: true,
+
+  async handle() {
+    //
+  },
+})

package/app/Actions/Dashboard/CreateMailbox.ts

@@ -0,0 +1,11 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'CreateMailbox',
+  description: 'Creates a new mailbox.',
+  apiResponse: true,
+
+  async handle() {
+    //
+  },
+})

package/app/Actions/Dashboard/DashboardActivityAction.ts

@@ -0,0 +1,58 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'Dashboard Activity',
+  description: 'Fetch recent activity for dashboard',
+  method: 'GET',
+
+  async handle() {
+    // Mock data for development - replace with actual ORM queries when database is set up
+    const activity = [
+      {
+        id: 1,
+        type: 'deployment',
+        title: 'Deployment completed successfully',
+        time: '5 minutes ago',
+        status: 'success' as const,
+      },
+      {
+        id: 2,
+        type: 'commerce',
+        title: 'New order #1234 received',
+        time: '15 minutes ago',
+        status: 'success' as const,
+      },
+      {
+        id: 3,
+        type: 'blog',
+        title: 'Blog post "Getting Started" published',
+        time: '30 minutes ago',
+        status: 'success' as const,
+      },
+      {
+        id: 4,
+        type: 'error',
+        title: 'Error: Connection timeout in payments',
+        time: '45 minutes ago',
+        status: 'warning' as const,
+      },
+      {
+        id: 5,
+        type: 'deployment',
+        title: 'Staging deployment started',
+        time: '1 hour ago',
+        status: 'success' as const,
+      },
+      {
+        id: 6,
+        type: 'commerce',
+        title: 'New order #1233 received',
+        time: '2 hours ago',
+        status: 'success' as const,
+      },
+    ]
+
+    // Return the activity directly - the router will handle JSON serialization
+    return { activity }
+  },
+})

package/app/Actions/Dashboard/DashboardHealthAction.ts

@@ -0,0 +1,52 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'Dashboard Health',
+  description: 'Fetch system health status for dashboard',
+  method: 'GET',
+
+  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%',
+      },
+    ]
+
+    // Return the services directly - the router will handle JSON serialization
+    return { services }
+  },
+})

package/app/Actions/Dashboard/DashboardHomeAction.ts

@@ -0,0 +1,83 @@
+import { Action } from '@stacksjs/actions'
+import { User, Product, Order, Post } from '@stacksjs/orm'
+
+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[] = []
+
+    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(),
+      ])
+
+      userCount = results[0]
+      productCount = results[1]
+      orderCount = results[2]
+      postCount = results[3]
+      recentOrderRows = results[4]
+      recentUserRows = results[5]
+
+      // Calculate total revenue from all orders
+      const allOrders = await Order.all()
+      totalRevenue = allOrders.reduce((sum, o) => sum + (Number(o.get('total_amount')) || 0), 0)
+    }
+    catch {
+      // Database may not exist yet - use fallback values
+    }
+
+    const stats = [
+      { label: 'Total Users', value: String(userCount), trend: '+12%', up: true, color: 'blue' },
+      { label: 'Products', value: String(productCount), trend: '+8%', up: true, color: 'green' },
+      { label: 'Revenue', value: `$${totalRevenue.toLocaleString()}`, trend: '+23%', up: true, color: 'orange' },
+      { label: 'Orders', value: String(orderCount), trend: '+5%', up: true, 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 = [
+      { name: 'Database', status: userCount > 0 ? 'healthy' : 'offline', latency: userCount > 0 ? '12ms' : 'N/A' },
+      { name: 'Cache', status: 'healthy', latency: '2ms' },
+      { name: 'Queue', status: 'healthy', latency: '45ms' },
+      { name: 'Storage', status: 'healthy', latency: '8ms' },
+      { name: 'Email', status: 'warning', latency: '234ms' },
+    ]
+
+    // Build activities from real data
+    const activities = [
+      ...recentOrderRows.map((o: any) => ({
+        type: 'order',
+        message: `Order #${o.get('id')} - $${o.get('total_amount')} (${o.get('status')})`,
+        time: 'Recently',
+        user: 'Commerce',
+      })),
+      ...recentUserRows.map((u: any) => ({
+        type: 'user',
+        message: `User ${u.get('name')} registered`,
+        time: 'Recently',
+        user: 'System',
+      })),
+    ].slice(0, 5)
+
+    return { stats, quickLinks, services, activities }
+  },
+})

package/app/Actions/Dashboard/DashboardStatsAction.ts

@@ -0,0 +1,48 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'Dashboard Stats',
+  description: 'Fetch 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 = [
+      {
+        title: 'Total Users',
+        value: '1,234',
+        trend: 12,
+        trendLabel: 'vs last period',
+        icon: 'i-hugeicons-user-group',
+        iconBg: 'primary',
+      },
+      {
+        title: 'Active Orders',
+        value: '567',
+        trend: 8,
+        trendLabel: 'vs last period',
+        icon: 'i-hugeicons-shopping-cart-02',
+        iconBg: 'success',
+      },
+      {
+        title: 'Blog Posts',
+        value: '89',
+        trend: -3,
+        trendLabel: 'vs last period',
+        icon: 'i-hugeicons-document-validation',
+        iconBg: 'info',
+      },
+      {
+        title: 'Customers',
+        value: '2,345',
+        trend: 15,
+        trendLabel: 'vs last period',
+        icon: 'i-hugeicons-user-multiple',
+        iconBg: 'warning',
+      },
+    ]
+
+    // Return the stats directly - the router will handle JSON serialization
+    return { stats }
+  },
+})

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

@@ -0,0 +1,65 @@
+import { Action } from '@stacksjs/actions'
+
+// TODO: create a PersonalAccessToken model and use ORM queries instead of raw SQL
+export default new Action({
+  name: 'AccessTokenIndexAction',
+  description: 'Returns access token data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    let tokens: Array<{ name: string, token: string, lastUsed: string, created: string, scopes: string[], status: string }> = []
+
+    let stats = [
+      { label: 'Active Tokens', value: '0' },
+      { label: 'API Calls (24h)', value: '-' },
+      { label: 'Rate Limit', value: '1000/min' },
+      { label: 'Expired', value: '0' },
+    ]
+
+    const scopes = [
+      { name: 'read', description: 'Read access to resources' },
+      { name: 'write', description: 'Write access to resources' },
+      { name: 'delete', description: 'Delete access to resources' },
+      { name: 'deploy', description: 'Deploy applications' },
+      { name: 'admin', description: 'Full administrative access' },
+    ]
+
+    try {
+      const { Database } = await import('bun:sqlite')
+      const { resolve } = await import('node:path')
+      const db = new Database(resolve(process.cwd(), 'database/stacks.sqlite'), { readonly: true })
+      const rows = db.query('SELECT * FROM personal_access_tokens ORDER BY id DESC LIMIT 50').all() as Array<Record<string, unknown>>
+
+      if (rows.length > 0) {
+        tokens = rows.map((r) => {
+          const tokenStr = r.token ? `${String(r.token).substring(0, 8)}........${String(r.token).substring(String(r.token).length - 4)}` : '........'
+          let abilities: string[] = []
+          try { abilities = JSON.parse(String(r.abilities || '[]')) }
+          catch { abilities = ['read'] }
+          return {
+            name: String(r.name || ''),
+            token: tokenStr,
+            lastUsed: String(r.last_used_at || '-'),
+            created: String(r.created_at || ''),
+            scopes: abilities,
+            status: r.expires_at && new Date(String(r.expires_at)) < new Date() ? 'expired' : 'active',
+          }
+        })
+        const activeCount = tokens.filter(t => t.status === 'active').length
+        const expiredCount = tokens.filter(t => t.status === 'expired').length
+        stats = [
+          { label: 'Active Tokens', value: String(activeCount) },
+          { label: 'API Calls (24h)', value: '-' },
+          { label: 'Rate Limit', value: '1000/min' },
+          { label: 'Expired', value: String(expiredCount) },
+        ]
+      }
+
+      db.close()
+    }
+    catch {
+      // keep fallback data
+    }
+
+    return { tokens, stats, scopes }
+  },
+})

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

@@ -0,0 +1,28 @@
+import { Action } from '@stacksjs/actions'
+import { Activity } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'ActivityIndexAction',
+  description: 'Returns recent activity data for the dashboard.',
+  method: 'GET',
+  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'),
+      }))
+
+      return { activities, filters }
+    }
+    catch {
+      return { activities: [], filters }
+    }
+  },
+})

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

@@ -0,0 +1,67 @@
+import { Action } from '@stacksjs/actions'
+import { User, Order, Product, Post } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'DataDashboardAction',
+  description: 'Returns database overview and statistics for the data dashboard.',
+  method: 'GET',
+  async handle() {
+    try {
+      const [userCount, orderCount, productCount, postCount] = await Promise.all([
+        User.count(),
+        Order.count(),
+        Product.count(),
+        Post.count(),
+      ])
+
+      const totalRecords = userCount + orderCount + productCount + postCount
+
+      const tables = [
+        { name: 'users', rows: String(userCount), size: '-', lastModified: '-' },
+        { name: 'orders', rows: String(orderCount), size: '-', lastModified: '-' },
+        { name: 'products', rows: String(productCount), size: '-', lastModified: '-' },
+        { name: 'posts', rows: String(postCount), size: '-', lastModified: '-' },
+      ]
+
+      let dbSize = '-'
+      try {
+        const { statSync } = await import('node:fs')
+        const { resolve } = await import('node:path')
+        const dbPath = resolve(process.cwd(), 'database/stacks.sqlite')
+        const fileStats = statSync(dbPath)
+        const mb = (fileStats.size / (1024 * 1024)).toFixed(1)
+        dbSize = `${mb} MB`
+      }
+      catch {
+        // ignore
+      }
+
+      const stats = [
+        { label: 'Total Records', value: totalRecords.toLocaleString(), change: '' },
+        { label: 'Database Size', value: dbSize, change: '' },
+        { label: 'Tables', value: String(tables.length), change: '' },
+        { label: 'Query Rate', value: '-', change: '' },
+      ]
+
+      const recentQueries = [
+        { query: 'SELECT * FROM users WHERE...', time: '-', source: 'API' },
+        { query: 'INSERT INTO orders...', time: '-', source: 'Queue' },
+        { query: 'UPDATE posts SET...', time: '-', source: 'Web' },
+      ]
+
+      return { stats, tables, recentQueries }
+    }
+    catch {
+      return {
+        stats: [
+          { label: 'Total Records', value: '0', change: '' },
+          { label: 'Database Size', value: '-', change: '' },
+          { label: 'Tables', value: '0', change: '' },
+          { label: 'Query Rate', value: '-', change: '' },
+        ],
+        tables: [],
+        recentQueries: [],
+      }
+    }
+  },
+})

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

@@ -0,0 +1,48 @@
+import { Action } from '@stacksjs/actions'
+import { Subscriber } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'SubscriberIndexAction',
+  description: 'Returns subscriber data for the dashboard.',
+  method: 'GET',
+  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 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%' },
+      ]
+
+      return { subscribers, stats, plans }
+    }
+    catch {
+      return {
+        subscribers: [],
+        stats: [
+          { label: 'Total Subscribers', value: '0' },
+          { label: 'Active', value: '0' },
+          { label: 'New This Month', value: '0' },
+          { label: 'Churn Rate', value: '0%' },
+        ],
+        plans,
+      }
+    }
+  },
+})

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

@@ -0,0 +1,43 @@
+import { Action } from '@stacksjs/actions'
+import { Team } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'TeamIndexAction',
+  description: 'Returns team data for the dashboard.',
+  method: 'GET',
+  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 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) },
+      ]
+
+      return { teams, stats }
+    }
+    catch {
+      return {
+        teams: [],
+        stats: [
+          { label: 'Total Teams', value: '0' },
+          { label: 'Total Members', value: '0' },
+          { label: 'Active Projects', value: '0' },
+        ],
+      }
+    }
+  },
+})