@stacksjs/defaults 0.70.229 → 0.70.230

package/app/Actions/Dashboard/Search/GlobalSearchAction.ts

@@ -1,26 +1,250 @@
 import { Action } from '@stacksjs/actions'
+import { env } from '@stacksjs/env'
+import { readdirSync } from 'node:fs'
+import { basename, extname, join } from 'node:path'
+import process from 'node:process'
+
+interface SearchableModel {
+  name: string
+  table: string
+  slug: string
+  fields: string[]
+  icon: string
+}
+
+interface SearchResult {
+  id: string | number
+  title: string
+  subtitle?: string
+  href: string
+  icon: string
+}
+
+interface SearchUnavailable {
+  model: string
+  reason: string
+}
+
+const HIDDEN_FIELDS = new Set([
+  'password',
+  'remember_token',
+  'api_token',
+  'access_token',
+  'refresh_token',
+  'secret',
+  'two_factor_secret',
+])
+const MAX_QUERY_LENGTH = 120
+const MAX_GROUPS = 8
+const RESULTS_PER_MODEL = 5
+
+const modelCatalog: { promise: Promise<SearchableModel[]> | null } = { promise: null }
+
+function snakeCase(value: string): string {
+  return value
+    .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+    .replace(/[-\s]+/g, '_')
+    .toLowerCase()
+}
+
+function kebabCase(value: string): string {
+  return value
+    .replace(/([a-z\d])([A-Z])/g, '$1-$2')
+    .replace(/[_\s]+/g, '-')
+    .toLowerCase()
+}
+
+function pluralize(word: string): string {
+  if (word.endsWith('y') && !/[aeiou]y$/.test(word)) return `${word.slice(0, -1)}ies`
+  if (/(?:s|x|ch|sh)$/.test(word)) return `${word}es`
+  return `${word}s`
+}
+
+function isSafeIdentifier(value: string): boolean {
+  return /^[A-Z_][A-Z0-9_]*$/i.test(value) && value.length <= 64
+}
+
+function modelFiles(root: string): string[] {
+  const files: string[] = []
+
+  function walk(directory: string): void {
+    let entries
+    try {
+      entries = readdirSync(directory, { withFileTypes: true })
+    }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT')
+        return
+      throw new Error(`Could not scan searchable models in ${directory}: ${error instanceof Error ? error.message : String(error)}`)
+    }
+
+    for (const entry of entries) {
+      const file = join(directory, entry.name)
+      if (entry.isDirectory()) {
+        walk(file)
+        continue
+      }
+      if (!['.ts', '.js'].includes(extname(entry.name))) continue
+      if (entry.name.startsWith('.') || entry.name.startsWith('_') || entry.name.startsWith('index')) continue
+      files.push(file)
+    }
+  }
+
+  walk(root)
+  return files.sort()
+}
+
+function iconForModel(name: string): string {
+  const icons: Record<string, string> = {
+    User: 'i-hugeicons-user-group',
+    Team: 'i-hugeicons-user-multiple',
+    Product: 'i-hugeicons-shopping-bag-02',
+    Customer: 'i-hugeicons-user-02',
+    Order: 'i-hugeicons-shopping-cart-01',
+    Post: 'i-hugeicons-note-edit',
+    Page: 'i-hugeicons-file-02',
+    Release: 'i-hugeicons-package-delivered',
+    Deployment: 'i-hugeicons-cloud-upload',
+    Log: 'i-hugeicons-document-validation',
+  }
+  return icons[name] || 'i-hugeicons-database-02'
+}
+
+async function loadSearchableModels(): Promise<SearchableModel[]> {
+  const defaultsRoot = join(process.cwd(), 'storage/framework/defaults/app/Models')
+  const userRoot = join(process.cwd(), 'app/Models')
+  const merged = new Map<string, string>()
+
+  for (const file of modelFiles(defaultsRoot))
+    merged.set(basename(file, extname(file)), file)
+  for (const file of modelFiles(userRoot))
+    merged.set(basename(file, extname(file)), file)
+
+  const models: SearchableModel[] = []
+  for (const [fallbackName, file] of merged) {
+    try {
+      const module = await import(file)
+      const definition = module.default ?? module
+      const name = String(definition.name || fallbackName)
+      const search = definition.traits?.useSearch
+      if (!search || typeof search !== 'object' || !Array.isArray(search.searchable)) continue
+
+      const fields = search.searchable
+        .map((field: unknown) => snakeCase(String(field)))
+        .filter((field: string) => isSafeIdentifier(field) && !HIDDEN_FIELDS.has(field))
+      const table = String(definition.table || pluralize(snakeCase(name)))
+      if (fields.length === 0 || !isSafeIdentifier(table)) continue
+
+      models.push({
+        name,
+        table,
+        slug: kebabCase(name),
+        fields: [...new Set(fields)],
+        icon: iconForModel(name),
+      })
+    }
+    catch (error) {
+      throw new Error(`Could not load searchable model ${fallbackName}: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  return models.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+function catalog(): Promise<SearchableModel[]> {
+  modelCatalog.promise ||= loadSearchableModels()
+  return modelCatalog.promise
+}
+
+function rowValue(row: Record<string, unknown>, field: string): string {
+  const value = row[field]
+  if (value === null || value === undefined) return ''
+  return typeof value === 'string' ? value : String(value)
+}
+
+function resultTitle(model: SearchableModel, row: Record<string, unknown>): string {
+  for (const field of ['name', 'title', 'subject', 'version', 'code', 'email', ...model.fields]) {
+    const value = rowValue(row, field).trim()
+    if (value) return value
+  }
+  return `${model.name} #${rowValue(row, 'id') || 'record'}`
+}
+
+function resultSubtitle(model: SearchableModel, row: Record<string, unknown>, title: string): string | undefined {
+  for (const field of model.fields) {
+    const value = rowValue(row, field).trim()
+    if (value && value !== title) return value
+  }
+  return undefined
+}
 
 export default new Action({
   name: 'GlobalSearchAction',
-  description: 'Returns global search results grouped by model.',
+  description: 'Searches fields declared by model useSearch traits and groups matching records by model.',
   method: 'GET',
+  apiResponse: true,
   async handle(request: RequestInstance) {
-    const q = request?.get('q') || ''
-
+    const q = String(request?.get('q') || '').trim().slice(0, MAX_QUERY_LENGTH)
     if (!q) return { results: {} }
 
-    return {
-      results: {
-        users: [
-          { id: 1, title: 'Chris Breuer', subtitle: 'chris@stacks.dev', href: '/data/users', icon: 'i-hugeicons-user-02' },
-        ],
-        posts: [
-          { id: 1, title: 'Getting Started with Stacks', subtitle: 'Published 2 days ago', href: '/content/posts', icon: 'i-hugeicons-note-edit' },
-        ],
-        products: [
-          { id: 1, title: 'Premium Plan', subtitle: '$99/mo', href: '/commerce/products', icon: 'i-hugeicons-shopping-bag-02' },
-        ],
-      },
+    const { Database } = await import('bun:sqlite')
+    const db = new Database(env.DB_DATABASE_PATH || 'database/stacks.sqlite', { readonly: true })
+    const results: Record<string, SearchResult[]> = {}
+    const unavailable: SearchUnavailable[] = []
+
+    try {
+      for (const model of await catalog()) {
+        if (Object.keys(results).length >= MAX_GROUPS) break
+
+        const columns = db.query(`PRAGMA table_info(${model.table})`).all() as Array<{ name: string }>
+        if (columns.length === 0) {
+          unavailable.push({
+            model: model.name,
+            reason: `Table ${model.table} has not been migrated.`,
+          })
+          continue
+        }
+
+        const available = new Set(columns.map(column => column.name))
+        const fields = model.fields.filter(field => available.has(field))
+        if (fields.length === 0) {
+          unavailable.push({
+            model: model.name,
+            reason: 'Declared useSearch fields are not present in the migrated table.',
+          })
+          continue
+        }
+
+        const selected = [...new Set(['id', ...fields])].filter(field => available.has(field))
+        const where = fields.map(field => `${field} LIKE ? COLLATE NOCASE`).join(' OR ')
+        const bindings = fields.map(() => `%${q}%`)
+        let rows: Array<Record<string, unknown>>
+        try {
+          rows = db
+            .query(`SELECT ${selected.join(', ')} FROM ${model.table} WHERE ${where} LIMIT ?`)
+            .all(...bindings, RESULTS_PER_MODEL) as Array<Record<string, unknown>>
+        }
+        catch (error) {
+          throw new Error(`Could not search model ${model.name}: ${error instanceof Error ? error.message : String(error)}`)
+        }
+        if (rows.length === 0) continue
+
+        results[model.name] = rows.map((row, index) => {
+          const title = resultTitle(model, row)
+          return {
+            id: (row.id as string | number | undefined) ?? index,
+            title,
+            subtitle: resultSubtitle(model, row, title),
+            href: `/models/${model.slug}?q=${encodeURIComponent(q)}`,
+            icon: model.icon,
+          }
+        })
+      }
     }
+    finally {
+      db.close()
+    }
+
+    return { results, unavailable }
   },
 })

package/app/Actions/Dashboard/ServiceHealthAction.ts

@@ -1,243 +1 @@
-import { Action } from '@stacksjs/actions'
-
-export default new Action({
-  name: 'ServiceHealthAction',
-  description: 'Returns service health and configuration data for the services page.',
-  method: 'GET',
-  async handle() {
-    const { readFileSync, accessSync } = await import('node:fs')
-    const { join } = await import('node:path')
-    const projectRoot = process.cwd()
-
-    function readConfig(name: string): string {
-      try {
-        return readFileSync(join(projectRoot, 'config', name), 'utf-8')
-      }
-      catch { return '' }
-    }
-
-    function extractValue(content: string, pattern: RegExp): string {
-      const m = content.match(pattern)
-      return m ? m[1].trim().replace(/['"]/g, '') : ''
-    }
-
-    function fileExists(p: string): boolean {
-      try { accessSync(p); return true }
-      catch { return false }
-    }
-
-    // Infrastructure Services
-    const infra: Array<Record<string, unknown>> = []
-
-    // Database
-    const dbConf = readConfig('database.ts')
-    const dbDriver = extractValue(dbConf, /default:\s*['"](\w+)['"]/) || 'sqlite'
-    const dbFile = extractValue(dbConf, /filename:\s*['"]([^'"]+)['"]/) || 'database/stacks.sqlite'
-    const dbHost = extractValue(dbConf, /host:\s*['"]([^'"]+)['"]/) || 'localhost'
-    const dbPort = extractValue(dbConf, /port:\s*(\d+)/) || ''
-    infra.push({
-      name: 'Database',
-      configFile: 'database.ts',
-      category: 'data',
-      driver: dbDriver,
-      status: dbDriver === 'sqlite' && fileExists(join(projectRoot, dbFile)) ? 'running' : 'configured',
-      detail: dbDriver === 'sqlite' ? dbFile : `${dbHost}${dbPort ? `:${dbPort}` : ''}`,
-      fields: [{ key: 'default', label: 'Driver', value: dbDriver, options: 'sqlite,mysql,postgres,dynamodb' }],
-    })
-
-    // Cache
-    const cacheConf = readConfig('cache.ts')
-    const cacheDriver = extractValue(cacheConf, /driver:\s*['"](\w+)['"]/) || 'memory'
-    const redisHost = extractValue(cacheConf, /host:\s*['"]([^'"]+)['"]/) || '127.0.0.1'
-    const redisPort = extractValue(cacheConf, /port:\s*(\d+)/) || '6379'
-    infra.push({
-      name: 'Cache',
-      configFile: 'cache.ts',
-      category: 'data',
-      driver: cacheDriver,
-      status: cacheDriver === 'memory' ? 'running' : 'configured',
-      detail: cacheDriver === 'redis' ? `${redisHost}:${redisPort}` : 'In-Memory',
-      fields: [{ key: 'driver', label: 'Driver', value: cacheDriver, options: 'memory,redis' }],
-    })
-
-    // Queue
-    const queueConf = readConfig('queue.ts')
-    const queueDriver = extractValue(queueConf, /default:\s*['"](\w+)['"]/) || 'sync'
-    const queueDetail = queueDriver === 'redis' ? 'Redis (bun-queue)' : queueDriver === 'database' ? 'Database' : queueDriver === 'sqs' ? 'AWS SQS' : 'Sync (dev)'
-    infra.push({
-      name: 'Queue',
-      configFile: 'queue.ts',
-      category: 'data',
-      driver: queueDriver,
-      status: 'configured',
-      detail: queueDetail,
-      fields: [{ key: 'default', label: 'Driver', value: queueDriver, options: 'sync,database,redis,sqs,memory' }],
-    })
-
-    // Search
-    const searchConf = readConfig('search-engine.ts')
-    const searchDriver = extractValue(searchConf, /driver:\s*['"]([^'"]+)['"]/) || 'opensearch'
-    infra.push({
-      name: 'Search',
-      configFile: 'search-engine.ts',
-      category: 'data',
-      driver: searchDriver,
-      status: 'configured',
-      detail: searchDriver,
-      fields: [{ key: 'driver', label: 'Driver', value: searchDriver, options: 'opensearch,meilisearch,algolia,typesense' }],
-    })
-
-    // Storage
-    const storageConf = readConfig('filesystems.ts')
-    const storageDriver = extractValue(storageConf, /driver:\s*['"](\w+)['"]/) || 'bun'
-    const storageDetail = storageDriver === 's3' ? 'AWS S3' : storageDriver === 'bun' ? 'Bun Native' : 'Local FS'
-    infra.push({
-      name: 'Storage',
-      configFile: 'filesystems.ts',
-      category: 'data',
-      driver: storageDriver,
-      status: 'configured',
-      detail: storageDetail,
-      fields: [{ key: 'driver', label: 'Driver', value: storageDriver, options: 'bun,local,s3,memory' }],
-    })
-
-    // Email
-    const emailConf = readConfig('email.ts')
-    const emailMode = /mode:\s*['"]server['"]/.test(emailConf) ? 'server' : 'serverless'
-    const emailDomain = extractValue(emailConf, /domain:\s*['"]([^'"]+)['"]/) || ''
-    infra.push({
-      name: 'Email',
-      configFile: 'email.ts',
-      category: 'communication',
-      driver: emailMode === 'server' ? 'Zig Server' : 'Serverless',
-      status: emailDomain ? 'running' : 'configured',
-      detail: emailDomain || 'Not configured',
-      fields: [
-        { key: 'domain', label: 'Domain', value: emailDomain, options: '' },
-        { key: 'mode', label: 'Mode', value: emailMode, options: 'server,serverless' },
-      ],
-    })
-
-    // Realtime
-    const realtimeConf = readConfig('realtime.ts')
-    const rtPort = extractValue(realtimeConf, /port:\s*(\d+)/) || '6001'
-    const rtDriver = extractValue(realtimeConf, /driver:\s*['"](\w+)['"]/) || 'socket'
-    infra.push({
-      name: 'Realtime',
-      configFile: 'realtime.ts',
-      category: 'communication',
-      driver: 'WebSocket',
-      status: 'configured',
-      detail: `Port ${rtPort}`,
-      fields: [
-        { key: 'port', label: 'Port', value: rtPort, options: '' },
-        { key: 'driver', label: 'Driver', value: rtDriver, options: 'socket,pusher,bun,reverb,ably' },
-      ],
-    })
-
-    // AI
-    const aiConf = readConfig('ai.ts')
-    const aiModel = extractValue(aiConf, /default:\s*['"]([^'"]+)['"]/) || ''
-    infra.push({
-      name: 'AI',
-      configFile: 'ai.ts',
-      category: 'compute',
-      driver: 'Bedrock',
-      status: aiModel ? 'configured' : 'not set',
-      detail: aiModel || 'Not configured',
-      fields: [{ key: 'default', label: 'Model', value: aiModel, options: '' }],
-    })
-
-    // System Dependencies
-    const systemDeps: Array<{ name: string, version: string }> = []
-    const depsConf = readConfig('deps.ts')
-    const depPattern = /['"]([^'"]+)['"]\s*:\s*['"]([^'"]+)['"]/g
-    let depMatch
-    // eslint-disable-next-line no-cond-assign
-    while ((depMatch = depPattern.exec(depsConf)) !== null) {
-      const depName = depMatch[1]
-      const depVer = depMatch[2]
-      if (depName.includes('.') || depName === 'redis' || depName === 'mailpit') {
-        systemDeps.push({ name: depName, version: depVer })
-      }
-    }
-
-    // Third-Party API Services
-    const apiServices: Array<Record<string, unknown>> = []
-    const svcConf = readConfig('services.ts')
-    const keyPattern = /^ {2}(\w[\w]*)\s*:\s*\{/gm
-    let svcMatch
-    // eslint-disable-next-line no-cond-assign
-    while ((svcMatch = keyPattern.exec(svcConf)) !== null) {
-      const svcName = svcMatch[1]
-      const blockStart = svcMatch.index
-      let braceCount = 0
-      let blockEnd = blockStart
-      let inBlock = false
-      for (let i = blockStart; i < svcConf.length; i++) {
-        if (svcConf[i] === '{') { braceCount++; inBlock = true }
-        if (svcConf[i] === '}') { braceCount-- }
-        if (inBlock && braceCount === 0) { blockEnd = i; break }
-      }
-      const block = svcConf.substring(blockStart, blockEnd + 1)
-
-      const svcFields: Array<Record<string, string>> = []
-      const fieldPattern = /(\w+)\s*:\s*(?:env\.(\w+)\s*\?\?\s*)?['"]?([^'",\n}]*)['"]?/g
-      let fm
-      // eslint-disable-next-line no-cond-assign
-      while ((fm = fieldPattern.exec(block)) !== null) {
-        const fName = fm[1]
-        if (['maxRetries', 'retryTimeout'].includes(fName)) continue
-        const fValue = fm[3] ? fm[3].trim().replace(/['"]/g, '') : ''
-        const envVar = fm[2] || ''
-        svcFields.push({ key: fName, label: fName, value: fValue, env: envVar })
-      }
-
-      const hasEnvRef = /env\./.test(block)
-      let category = 'other'
-      if (['algolia', 'meilisearch'].includes(svcName)) category = 'search'
-      else if (['aws', 'digitalOcean', 'hetzner'].includes(svcName)) category = 'cloud'
-      else if (['github', 'google', 'facebook', 'twitter'].includes(svcName)) category = 'auth'
-      else if (['mailgun', 'mailtrap', 'sendgrid', 'ses', 'smtp'].includes(svcName)) category = 'email'
-      else if (['slack', 'discord', 'teams'].includes(svcName)) category = 'messaging'
-      else if (['expo', 'fcm'].includes(svcName)) category = 'push'
-      else if (['openai', 'anthropic', 'ollama'].includes(svcName)) category = 'ai'
-      else if (['stripe'].includes(svcName)) category = 'payment'
-
-      apiServices.push({ name: svcName, category, configured: hasEnvRef, fields: svcFields })
-    }
-
-    const categoryLabels: Record<string, string> = {
-      auth: 'Authentication',
-      cloud: 'Cloud',
-      email: 'Email',
-      messaging: 'Messaging',
-      push: 'Push Notifications',
-      ai: 'AI',
-      payment: 'Payments',
-      search: 'Search',
-      other: 'Other',
-    }
-    const categoryOrder = ['auth', 'cloud', 'email', 'messaging', 'push', 'ai', 'payment', 'search', 'other']
-    const apiCategories: Record<string, Array<Record<string, unknown>>> = {}
-    for (const s of apiServices) {
-      const cat = s.category as string
-      if (!apiCategories[cat]) apiCategories[cat] = []
-      apiCategories[cat].push(s)
-    }
-    const orderedApiGroups = categoryOrder
-      .filter(cat => apiCategories[cat] && apiCategories[cat].length > 0)
-      .map(cat => ({ key: cat, label: categoryLabels[cat] || cat, items: apiCategories[cat] }))
-
-    const configuredApi = apiServices.filter(s => s.configured).length
-
-    const stats = [
-      { label: 'Infrastructure', value: String(infra.length) },
-      { label: 'API Services', value: String(apiServices.length) },
-      { label: 'System Deps', value: String(systemDeps.length) },
-      { label: 'Configured', value: `${configuredApi}/${apiServices.length}` },
-    ]
-
-    return { infra, systemDeps, orderedApiGroups, stats }
-  },
-})
+export { default } from './DashboardHealthAction'

package/app/Actions/Dashboard/Settings/BillingShowAction.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'bun:test'
+import { billingReadFailures, serializeBillingTransaction, settleBillableRead } from './BillingShowAction'
+
+describe('BillingShowAction helpers', () => {
+  it('reports only rejected provider reads', () => {
+    expect(billingReadFailures([
+      { label: 'Active plan', result: { status: 'fulfilled', value: null } },
+      { label: 'Payment methods', result: { status: 'rejected', reason: new Error('Stripe is not configured') } },
+    ])).toEqual(['Payment methods: Stripe is not configured'])
+  })
+
+  it('serializes only the PaymentTransaction fields exposed to the dashboard', () => {
+    const values: Record<string, unknown> = {
+      id: 7,
+      uuid: 'transaction-7',
+      name: 'Pro plan',
+      description: 'Monthly plan',
+      amount: 5900,
+      type: 'subscription',
+      provider_id: 'provider-7',
+      payment_method_id: 3,
+      user_id: 2,
+    }
+
+    expect(serializeBillingTransaction({ get: (key: string) => values[key] })).toEqual({
+      id: 7,
+      uuid: 'transaction-7',
+      name: 'Pro plan',
+      description: 'Monthly plan',
+      amount: 5900,
+      type: 'subscription',
+      provider_id: 'provider-7',
+      payment_method_id: 3,
+    })
+  })
+
+  it('explains when the application User model is not billable', async () => {
+    const result = await settleBillableRead({}, 'activeSubscription')
+    expect(result.status).toBe('rejected')
+    if (result.status === 'rejected')
+      expect(result.reason.message).toContain('app/Models/User.ts')
+  })
+})

package/app/Actions/Dashboard/Settings/BillingShowAction.ts

@@ -0,0 +1,93 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { PaymentTransaction, User } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+
+interface SettledBillingRead {
+  label: string
+  result: PromiseSettledResult<unknown>
+}
+
+export function billingReadFailures(reads: SettledBillingRead[]): string[] {
+  return reads
+    .filter((read): read is SettledBillingRead & { result: PromiseRejectedResult } => read.result.status === 'rejected')
+    .map((read) => {
+      const reason = read.result.reason
+      const detail = reason instanceof Error ? reason.message : String(reason || '')
+      return detail ? `${read.label}: ${detail}` : read.label
+    })
+}
+
+export function serializeBillingTransaction(transaction: any): Record<string, unknown> {
+  return {
+    id: transaction.get('id'),
+    uuid: transaction.get('uuid'),
+    name: transaction.get('name'),
+    description: transaction.get('description'),
+    amount: transaction.get('amount'),
+    type: transaction.get('type'),
+    provider_id: transaction.get('provider_id'),
+    payment_method_id: transaction.get('payment_method_id'),
+  }
+}
+
+export async function settleBillableRead(user: any, methodName: string): Promise<PromiseSettledResult<unknown>> {
+  const method = user?.[methodName]
+  if (typeof method !== 'function') {
+    return {
+      status: 'rejected',
+      reason: new Error('Enable the billable trait on app/Models/User.ts to use provider billing.'),
+    }
+  }
+
+  try {
+    return { status: 'fulfilled', value: await method.call(user) }
+  }
+  catch (reason) {
+    return { status: 'rejected', reason }
+  }
+}
+
+/**
+ * One authenticated read for the Billing settings screen.
+ *
+ * The dashboard server only delegates `/api/*` routes to the Stacks router.
+ * Keeping the aggregation here makes `buddy dev --dashboard` self-contained
+ * and prevents the browser from depending on a separately running API port.
+ */
+export default new Action({
+  name: 'BillingShowAction',
+  description: 'Returns the authenticated user billing overview for the dashboard.',
+  method: 'GET',
+  apiResponse: true,
+  async handle(request: RequestInstance) {
+    const authenticatedUser = await request.user()
+    if (!authenticatedUser)
+      return response.unauthorized('Authentication required')
+
+    const user = await User.find(authenticatedUser.id)
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const [subscription, paymentMethods, defaultPaymentMethod, transactions] = await Promise.all([
+      settleBillableRead(user, 'activeSubscription'),
+      settleBillableRead(user, 'paymentMethods'),
+      settleBillableRead(user, 'defaultPaymentMethod'),
+      PaymentTransaction.where('user_id', authenticatedUser.id).orderByDesc('id').get(),
+    ])
+
+    const providerReads: SettledBillingRead[] = [
+      { label: 'Active plan', result: subscription },
+      { label: 'Payment methods', result: paymentMethods },
+      { label: 'Default payment method', result: defaultPaymentMethod },
+    ]
+
+    return {
+      subscription: subscription.status === 'fulfilled' ? subscription.value : null,
+      paymentMethods: paymentMethods.status === 'fulfilled' ? paymentMethods.value : [],
+      defaultPaymentMethod: defaultPaymentMethod.status === 'fulfilled' ? defaultPaymentMethod.value : null,
+      transactions: transactions.map(serializeBillingTransaction),
+      unavailable: billingReadFailures(providerReads),
+    }
+  },
+})

package/app/Actions/Dashboard/Settings/MailSettingsGetAction.ts

@@ -1,20 +1,16 @@
 import { Action } from '@stacksjs/actions'
+import { readMailSettings } from './mail-settings'
 
 export default new Action({
   name: 'MailSettingsGetAction',
-  description: 'Returns the current mail settings.',
+  description: 'Returns mail settings without exposing stored credentials.',
   method: 'GET',
+  apiResponse: true,
+
   async handle() {
-    return {
-      data: {
-        from: '',
-        to: '',
-        driver: 'SMTP',
-        host: '',
-        port: 587,
-        username: '',
-        password: '',
-      },
-    }
+    return Response.json(
+      { settings: await readMailSettings() },
+      { headers: { 'Cache-Control': 'no-store', Pragma: 'no-cache' } },
+    )
   },
 })