@stacksjs/defaults 0.70.58 → 0.70.60

package/app/Actions/Dashboard/Models/ModelShowAction.ts

@@ -0,0 +1,131 @@
+import { Action } from '@stacksjs/actions'
+import { loadModel, safeAll, safeGet } from '../../../../resources/functions/dashboard/data'
+
+/**
+ * `GET /api/dashboard/models/{slug}` (stacksjs/stacks#1838).
+ *
+ * Returns the first 50 rows of any model's table for the dynamic
+ * `views/dashboard/models/[model].stx` page. Previously the page did
+ * this work inline in a `<script server>` block — converting it for
+ * the #1838 sweep moved the ORM lookup + raw-SQLite fallback into an
+ * action so the page can stay `<script client>`-only.
+ *
+ * Resolution order:
+ *   1. ORM via `loadModel(name)` — covers every model the dashboard
+ *      knows about and respects scopes, casts, accessors, observers.
+ *   2. Raw SQLite via `bun:sqlite` — last-resort fallback for slugs
+ *      that don't have a matching ORM file (rare; usually a lookup
+ *      table or userland-only schema).
+ *
+ * The response shape mirrors what the original template consumed so
+ * the page rewrite is a 1:1 swap (no template restructuring needed).
+ */
+
+interface ResponseShape {
+  modelName: string
+  tableName: string
+  rows: Array<Record<string, unknown>>
+  columns: string[]
+  displayColumns: string[]
+  totalCount: number
+  source: 'orm' | 'sqlite-fallback'
+  error: string | null
+}
+
+function slugToPascal(str: string): string {
+  return str.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('')
+}
+
+function pascalToSnake(str: string): string {
+  return str.replace(/([a-z])([A-Z])/g, '$1_$2').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`
+}
+
+// Hide credential / token columns + private fields by default.
+const HIDDEN_COLUMNS = new Set(['password', 'remember_token', 'api_token', 'access_token', 'refresh_token', 'secret'])
+
+export default new Action({
+  name: 'Dashboard Model Show',
+  description: 'Returns the first N rows of a single model by URL slug.',
+  method: 'GET',
+  apiResponse: true,
+  async handle(request: { route?: { params?: { slug?: string } } }) {
+    const slug = request?.route?.params?.slug || ''
+    const modelName = slugToPascal(slug)
+    const tableName = pluralize(pascalToSnake(modelName))
+
+    const response: ResponseShape = {
+      modelName,
+      tableName,
+      rows: [],
+      columns: [],
+      displayColumns: [],
+      totalCount: 0,
+      source: 'orm',
+      error: null,
+    }
+
+    // ORM path.
+    try {
+      const Model = await loadModel(modelName)
+      if (Model && !Model._isStub) {
+        const all = await safeAll(Model) as Array<Record<string, unknown>>
+        const rows = all.slice(0, 50)
+        response.totalCount = all.length
+
+        if (rows.length > 0) {
+          const sample = rows[0] as Record<string, unknown>
+          const attrs = sample && typeof sample === 'object' && !Array.isArray(sample)
+            ? ((sample as { attributes?: Record<string, unknown> }).attributes ?? sample)
+            : sample
+          response.columns = Object.keys(attrs ?? {}).filter(k => typeof k === 'string' && !k.startsWith('_'))
+        }
+
+        // Flatten each row to a plain JSON-safe object — proxy models or
+        // accessor-rich rows don't serialise cleanly across the wire.
+        response.rows = rows.map((row) => {
+          const flat: Record<string, unknown> = {}
+          for (const col of response.columns)
+            flat[col] = safeGet(row, col, null)
+          return flat
+        })
+      }
+      else {
+        response.source = 'sqlite-fallback'
+      }
+    }
+    catch (e) {
+      response.source = 'sqlite-fallback'
+      response.error = e instanceof Error ? e.message : String(e)
+    }
+
+    // SQLite fallback path.
+    if (response.source === 'sqlite-fallback' && response.rows.length === 0) {
+      try {
+        const { Database } = await import('bun:sqlite')
+        const db = new Database('database/stacks.sqlite')
+        const tableInfo = db.query(`PRAGMA table_info(${tableName})`).all() as Array<{ name: string }>
+        response.columns = tableInfo.map(c => c.name)
+        if (response.columns.length > 0) {
+          const countResult = db.query(`SELECT COUNT(*) as count FROM ${tableName}`).get() as { count?: number } | null
+          response.totalCount = countResult?.count ?? 0
+          response.rows = db.query(`SELECT * FROM ${tableName} ORDER BY id DESC LIMIT 50`).all() as Array<Record<string, unknown>>
+          response.error = null
+        }
+        db.close()
+      }
+      catch (e) {
+        response.error = e instanceof Error ? e.message : String(e)
+      }
+    }
+
+    response.displayColumns = response.columns.filter(col => !HIDDEN_COLUMNS.has(col) && !col.startsWith('_'))
+
+    return response
+  },
+})

package/app/Actions/Dashboard/Models/ModelsIndexAction.ts

@@ -0,0 +1,169 @@
+import { Action } from '@stacksjs/actions'
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import process from 'node:process'
+import { loadModel, safeCount } from '../../../../resources/functions/dashboard/data'
+
+/**
+ * `GET /api/dashboard/models` (stacksjs/stacks#1838).
+ *
+ * Walks the userland (`app/Models/`) and framework default
+ * (`storage/framework/defaults/app/Models/`) trees, loads each model,
+ * counts its rows, and returns a grouped JSON shape for the
+ * `views/dashboard/models/index.stx` page to render.
+ *
+ * Previously this work happened inline in the page's `<script server>`
+ * block — converting the page to `<script client>` for the #1838 sweep
+ * required moving the file-walk + count work to a real endpoint since
+ * neither `node:fs` nor `loadModel` work in the browser.
+ *
+ * Userland wins on name collision: a project that overrides a default
+ * `User` in `app/Models/` sees its own row, not both.
+ */
+interface ModelRow {
+  name: string
+  table: string
+  href: string
+  count: number
+  category: string
+  source: 'userland' | 'framework'
+}
+
+interface ModelGroup {
+  key: string
+  label: string
+  models: ModelRow[]
+  countLabel: string
+}
+
+function pascalToSnake(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase()
+}
+
+function pascalToKebab(s: string): string {
+  return s.replace(/([a-z])([A-Z])/g, '$1-$2').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 walkModels(dir: string, recursive: boolean): Array<{ name: string, file: string }> {
+  const out: Array<{ name: string, file: string }> = []
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+    for (const ent of entries) {
+      const full = join(dir, ent.name)
+      if (ent.isDirectory()) {
+        if (recursive) out.push(...walkModels(full, true))
+        continue
+      }
+      if (!ent.name.endsWith('.ts')) continue
+      if (ent.name.startsWith('_') || ent.name === 'index.ts' || ent.name === 'README.ts') continue
+      out.push({ name: ent.name.replace('.ts', ''), file: full })
+    }
+  }
+  catch {
+    // Missing directory — return what we have.
+  }
+  return out
+}
+
+function categorize(model: { source: 'userland' | 'framework', file: string }): string {
+  if (model.source === 'userland') return 'userland'
+  const segs = model.file.split('/Models/')[1]?.split('/') ?? []
+  if (segs.length > 1) return segs[0].toLowerCase()
+  return 'framework'
+}
+
+const orderedCategories = ['userland', 'framework', 'commerce', 'content', 'marketing', 'realtime']
+
+function categoryOrder(k: string): number {
+  const idx = orderedCategories.indexOf(k)
+  return idx === -1 ? orderedCategories.length : idx
+}
+
+function categoryLabel(k: string): string {
+  return k === 'userland' ? 'Your Models' : k.charAt(0).toUpperCase() + k.slice(1)
+}
+
+export default new Action({
+  name: 'Dashboard Models Index',
+  description: 'List every model + live record count for the dashboard models overview.',
+  method: 'GET',
+  apiResponse: true,
+  async handle() {
+    const cwd = process.cwd()
+    const userlandDir = join(cwd, 'app', 'Models')
+    const defaultsDir = join(cwd, 'storage/framework/defaults/app/Models')
+
+    const userland = walkModels(userlandDir, false)
+    const defaults = walkModels(defaultsDir, true)
+
+    const seen = new Set<string>()
+    const merged: Array<{ name: string, file: string, source: 'userland' | 'framework' }> = []
+    for (const list of [userland, defaults]) {
+      for (const m of list) {
+        if (seen.has(m.name)) continue
+        seen.add(m.name)
+        merged.push({ ...m, source: list === userland ? 'userland' : 'framework' })
+      }
+    }
+
+    const enriched: ModelRow[] = []
+    for (const m of merged) {
+      try {
+        const Model = await loadModel(m.name)
+        const count = await safeCount(Model)
+        enriched.push({
+          name: m.name,
+          table: pluralize(pascalToSnake(m.name)),
+          href: `/models/${pascalToKebab(m.name)}`,
+          count,
+          category: categorize(m),
+          source: m.source,
+        })
+      }
+      catch {
+        enriched.push({
+          name: m.name,
+          table: pluralize(pascalToSnake(m.name)),
+          href: `/models/${pascalToKebab(m.name)}`,
+          count: 0,
+          category: categorize(m),
+          source: m.source,
+        })
+      }
+    }
+
+    enriched.sort((a, b) => a.name.localeCompare(b.name))
+
+    const totalModels = enriched.length
+    const totalRecords = enriched.reduce((sum, m) => sum + m.count, 0)
+    const userlandCount = enriched.filter(m => m.source === 'userland').length
+
+    const groupMap: Record<string, ModelRow[]> = {}
+    for (const m of enriched) {
+      if (!groupMap[m.category]) groupMap[m.category] = []
+      groupMap[m.category].push(m)
+    }
+
+    const categoryGroups: ModelGroup[] = Object.keys(groupMap)
+      .sort((a, b) => categoryOrder(a) - categoryOrder(b))
+      .map(key => ({
+        key,
+        label: categoryLabel(key),
+        models: groupMap[key],
+        countLabel: `${groupMap[key].length} model${groupMap[key].length === 1 ? '' : 's'}`,
+      }))
+
+    return {
+      totalModels,
+      totalRecords,
+      userlandCount,
+      categoryGroups,
+    }
+  },
+})

package/app/Actions/Dashboard/Notifications/CreateNotification.ts

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

package/app/Actions/Dashboard/Notifications/GetAverageNotificationTime.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Notification } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetAverageNotificationTime',
+  description: 'Gets the average notification time of your application.',
+  apiResponse: true,
+
+  async handle() {
+    // return Notification.averageDuration()
+  },
+})

package/app/Actions/Dashboard/Notifications/GetNotificationCount.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Notification } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetNotificationCount',
+  description: 'Gets the total number of notifications.',
+  apiResponse: true,
+
+  async handle() {
+    // return Notification.count()
+  },
+})

package/app/Actions/Dashboard/Notifications/GetNotificationDeliveryRate.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Notification } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetNotificationDeliveryRate',
+  description: 'Gets the notification delivery rate of your application.',
+  apiResponse: true,
+
+  async handle() {
+    // return Notification.deliveryRate()
+  },
+})

package/app/Actions/Dashboard/Notifications/GetNotificationHistory.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Notification } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetNotifications',
+  description: 'Gets your notifications.',
+  apiResponse: true,
+
+  async handle() {
+    // return Notification.all()
+  },
+})

package/app/Actions/Dashboard/Notifications/GetNotifications.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Notification } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetNotifications',
+  description: 'Gets your jobs.',
+  apiResponse: true,
+
+  async handle() {
+    // wip: needs to return the jobs from ./app/Notifications/
+  },
+})

package/app/Actions/Dashboard/Notifications/NotificationDashboardAction.ts

@@ -0,0 +1,43 @@
+import { Action } from '@stacksjs/actions'
+import { Notification } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'NotificationDashboardAction',
+  description: 'Returns notification dashboard stats and recent notifications.',
+  method: 'GET',
+  async handle() {
+    try {
+      const allNotifications = await Notification.orderByDesc('id').limit(50).get()
+
+      const notifications = allNotifications.map(r => ({
+        type: String(r.get('type') || 'email'),
+        recipient: String(r.get('recipient') || r.get('notifiable_id') || ''),
+        subject: String(r.get('subject') || r.get('data') || ''),
+        status: String(r.get('status') || 'sent'),
+        time: String(r.get('created_at') || ''),
+      }))
+
+      const sent = notifications.filter(n => n.status === 'sent' || n.status === 'delivered').length
+      const failed = notifications.filter(n => n.status === 'failed').length
+      const total = notifications.length
+
+      const stats = [
+        { label: 'Sent Today', value: String(sent) },
+        { label: 'Delivered', value: total > 0 ? `${Math.round((sent / total) * 100)}%` : '0%' },
+        { label: 'Failed', value: String(failed) },
+      ]
+
+      return { notifications, stats }
+    }
+    catch {
+      return {
+        notifications: [],
+        stats: [
+          { label: 'Sent Today', value: '0' },
+          { label: 'Delivered', value: '0%' },
+          { label: 'Failed', value: '0' },
+        ],
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Queries/QueryIndexAction.ts

@@ -0,0 +1,22 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'QueryIndexAction',
+  description: 'Returns recent database queries and stats for the dashboard.',
+  method: 'GET',
+  async handle() {
+    return {
+      queries: [
+        { query: 'SELECT * FROM users WHERE...', time: '12ms', rows: 150, timestamp: '10:45:32' },
+        { query: 'INSERT INTO orders VALUES...', time: '8ms', rows: 1, timestamp: '10:45:28' },
+        { query: 'UPDATE posts SET status...', time: '15ms', rows: 5, timestamp: '10:45:25' },
+        { query: 'SELECT * FROM products JOIN...', time: '234ms', rows: 1500, timestamp: '10:45:20' },
+      ],
+      stats: [
+        { label: 'Total Queries', value: '45.2K' },
+        { label: 'Avg Time', value: '8ms' },
+        { label: 'Slow Queries', value: '12' },
+      ],
+    }
+  },
+})

package/app/Actions/Dashboard/Queue/QueueRetryFailedAction.ts

@@ -0,0 +1,22 @@
+import { Action } from '@stacksjs/actions'
+import { executeFailedJobs } from '@stacksjs/queue'
+import { FailedJob } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'QueueRetryFailedAction',
+  description: 'Re-queues every failed job recorded in the failed_jobs table.',
+  method: 'POST',
+  async handle() {
+    try {
+      const before = await FailedJob.count()
+      await executeFailedJobs()
+      const after = await FailedJob.count()
+      const requeued = Math.max(0, before - after)
+
+      return { success: true, message: `Re-queued ${requeued} failed job${requeued === 1 ? '' : 's'}`, count: requeued }
+    }
+    catch (e) {
+      return { success: false, message: (e as Error).message || 'Failed to retry failed jobs', count: 0 }
+    }
+  },
+})

package/app/Actions/Dashboard/Queue/QueueStatsAction.ts

@@ -0,0 +1,98 @@
+import { Action } from '@stacksjs/actions'
+import { FailedJob, Job } from '@stacksjs/orm'
+import { getGlobalMetrics } from '@stacksjs/queue'
+
+interface QueueBucket {
+  pending: number
+  active: number
+  completed: number
+  failed: number
+  total: number
+}
+
+const isPending = (status: string) => status === 'pending' || status === 'waiting' || status === 'queued'
+const isActive = (status: string) => status === 'processing' || status === 'active'
+const isCompleted = (status: string) => status === 'completed' || status === 'done'
+
+export default new Action({
+  name: 'QueueStatsAction',
+  description: 'Returns aggregated queue statistics from the jobs/failed_jobs tables and the in-memory metrics tracker.',
+  method: 'GET',
+  async handle() {
+    try {
+      const [totalJobs, failedJobCount, allJobs] = await Promise.all([
+        Job.count(),
+        FailedJob.count(),
+        Job.all(),
+      ])
+
+      const queueMap: Record<string, QueueBucket> = {}
+      let active = 0
+      let completed = 0
+
+      for (const j of allJobs) {
+        const queueName = String(j.get('queue') || 'default')
+        const status = String(j.get('status') || 'pending')
+
+        if (!queueMap[queueName]) {
+          queueMap[queueName] = { pending: 0, active: 0, completed: 0, failed: 0, total: 0 }
+        }
+        const bucket = queueMap[queueName]
+        bucket.total++
+
+        if (isPending(status)) bucket.pending++
+        else if (isActive(status)) {
+          bucket.active++
+          active++
+        }
+        else if (isCompleted(status)) {
+          bucket.completed++
+          completed++
+        }
+        else if (status === 'failed') bucket.failed++
+      }
+
+      const queues = Object.entries(queueMap).map(([name, data]) => ({
+        name,
+        status: data.active > 0 ? 'active' : 'idle',
+        pending: data.pending,
+        active: data.active,
+        completed: data.completed,
+        failed: data.failed,
+        total: data.total,
+      }))
+
+      // The in-memory metrics tracker only sees jobs processed since the
+      // current API process started, so it complements (not replaces) the DB
+      // counts. If the process just booted there's nothing here yet.
+      const metrics = getGlobalMetrics().getMetrics()
+
+      const stats = {
+        totalQueues: queues.length,
+        totalJobs,
+        activeJobs: active,
+        completedJobs: completed,
+        failedJobs: failedJobCount,
+        throughputPerMinute: metrics.throughputPerMinute,
+        averageProcessingTimeMs: Math.round(metrics.averageDuration),
+      }
+
+      return { queues, stats, queueConnected: true }
+    }
+    catch {
+      return {
+        queues: [],
+        stats: {
+          totalQueues: 0,
+          totalJobs: 0,
+          activeJobs: 0,
+          completedJobs: 0,
+          failedJobs: 0,
+          throughputPerMinute: 0,
+          averageProcessingTimeMs: 0,
+        },
+        queueConnected: false,
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Queue/QueueWorkersAction.ts

@@ -0,0 +1,46 @@
+import { Action } from '@stacksjs/actions'
+import { getActiveJobCount, getWorkerTracker, isWorkerRunning } from '@stacksjs/queue'
+
+export default new Action({
+  name: 'QueueWorkersAction',
+  description: 'Returns queue worker information from the framework worker tracker.',
+  method: 'GET',
+  async handle() {
+    try {
+      const tracker = getWorkerTracker()
+      const tracked = tracker.getAll()
+
+      // Translate the tracker's internal status into the dashboard's vocabulary
+      // ("running" | "paused" | "stopped") so the existing UI badges keep working.
+      const data = tracked.map((w) => {
+        const status = w.status === 'active' || w.status === 'idle' ? 'running' : 'stopped'
+        const startedAt = new Date(w.startedAt)
+        const elapsedMs = Math.max(0, Date.now() - startedAt.getTime())
+        const elapsedHours = Math.floor(elapsedMs / 3_600_000)
+        const elapsedDays = Math.floor(elapsedHours / 24)
+        const uptime = elapsedDays > 0 ? `${elapsedDays}d ${elapsedHours % 24}h` : `${elapsedHours}h`
+
+        return {
+          id: w.id,
+          name: w.id,
+          status,
+          queues: [w.queue],
+          jobs_processed: w.processedCount,
+          failed_jobs: w.failedCount,
+          uptime,
+          last_heartbeat: w.lastActivityAt,
+          memory: '—',
+        }
+      })
+
+      return {
+        data,
+        worker_running: isWorkerRunning(),
+        active_jobs: getActiveJobCount(),
+      }
+    }
+    catch {
+      return { data: [], worker_running: false, active_jobs: 0 }
+    }
+  },
+})

package/app/Actions/Dashboard/Rbac/PermissionDestroyAction.ts

@@ -0,0 +1,33 @@
+import { Action } from '@stacksjs/actions'
+import { deletePermission } from '@stacksjs/auth'
+
+/**
+ * `DELETE /api/dashboard/rbac/permissions/:name` (stacksjs/stacks#1845).
+ *
+ * Removes a permission by name + guard. Cascades through
+ * role_permissions + user_permissions so the deleted permission
+ * disappears from every role and user that held it.
+ */
+export default new Action({
+  name: 'Dashboard RBAC Permission Destroy',
+  description: 'Hard-delete a permission + its pivot rows.',
+  method: 'DELETE',
+  apiResponse: true,
+  async handle(request) {
+    const name = String((request as any)?.params?.name ?? '').trim()
+    if (!name) {
+      return { error: '`name` route param is required.', status: 400 }
+    }
+    const url = new URL(request.url ?? 'http://localhost/')
+    const guardName = url.searchParams.get('guard') || 'web'
+
+    try {
+      await deletePermission(name, guardName)
+      return { deleted: true, name, guardName }
+    }
+    catch (err) {
+      console.error('[dashboard/rbac] PermissionDestroyAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})