@stacksjs/defaults 0.70.58 → 0.70.59

package/app/Actions/Dashboard/Infrastructure/LogIndexAction.ts

@@ -0,0 +1,50 @@
+import { Action } from '@stacksjs/actions'
+import { Log } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'LogIndexAction',
+  description: 'Returns log data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    const levels = ['All', 'Error', 'Warning', 'Info', 'Debug']
+    const sources = ['All Sources', 'api', 'auth', 'queue', 'http', 'cache', 'payment', 'deploy']
+
+    try {
+      const allLogs = await Log.orderByDesc('id').limit(50).get()
+      const totalLogs = await Log.count()
+
+      const logs = allLogs.map(l => ({
+        timestamp: String(l.get('created_at') || l.get('timestamp') || ''),
+        level: String(l.get('level') || 'info'),
+        source: String(l.get('source') || l.get('channel') || ''),
+        message: String(l.get('message') || ''),
+        context: String(l.get('context') || ''),
+      }))
+
+      const errorCount = allLogs.filter(l => l.get('level') === 'error').length
+      const warnCount = allLogs.filter(l => l.get('level') === 'warn' || l.get('level') === 'warning').length
+
+      const stats = [
+        { label: 'Total Logs (24h)', value: String(totalLogs) },
+        { label: 'Errors', value: String(errorCount) },
+        { label: 'Warnings', value: String(warnCount) },
+        { label: 'Avg Response', value: '-' },
+      ]
+
+      return { logs, stats, levels, sources }
+    }
+    catch {
+      return {
+        logs: [],
+        stats: [
+          { label: 'Total Logs (24h)', value: '0' },
+          { label: 'Errors', value: '0' },
+          { label: 'Warnings', value: '0' },
+          { label: 'Avg Response', value: '-' },
+        ],
+        levels,
+        sources,
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Infrastructure/MailboxIndexAction.ts

@@ -0,0 +1,85 @@
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+
+export default new Action({
+  name: 'MailboxIndexAction',
+  description: 'Returns mailbox configuration from config files.',
+  method: 'GET',
+  async handle() {
+    try {
+      const emailConfig = config.email || {}
+
+      const domain = (emailConfig as any).domain || 'stacksjs.com'
+      const rawMailboxes = (emailConfig as any).mailboxes || []
+      const serverConfig = (emailConfig as any).server || {}
+      const fromConfig = (emailConfig as any).from || {}
+
+      // Build mailbox list from config/email.ts mailboxes array
+      const mailboxes = rawMailboxes.map((entry: string | Record<string, unknown>) => {
+        if (typeof entry === 'string') {
+          return {
+            email: entry.includes('@') ? entry : `${entry}@${domain}`,
+            username: entry.includes('@') ? entry.split('@')[0] : entry,
+            status: 'configured',
+          }
+        }
+
+        // Object format: { email: 'chris', password: '...' }
+        const email = typeof entry.email === 'string'
+          ? (entry.email.includes('@') ? entry.email : `${entry.email}@${domain}`)
+          : ''
+        return {
+          email,
+          username: email.split('@')[0] || '',
+          status: 'configured',
+        }
+      })
+
+      // Read server features
+      const features = serverConfig.features || {}
+      const featureList = Object.entries(features)
+        .map(([name, enabled]) => ({ name, enabled: Boolean(enabled) }))
+
+      // Read server ports
+      const ports = serverConfig.ports || {}
+
+      // Read server mode and settings
+      const mode = serverConfig.mode || 'server'
+      const scan = serverConfig.scan ?? false
+      const subdomain = serverConfig.subdomain || 'mail'
+
+      // Build domain info
+      const domains = [{
+        domain,
+        mailboxes: mailboxes.length,
+        status: 'configured',
+        subdomain: `${subdomain}.${domain}`,
+      }]
+
+      const stats = [
+        { label: 'Mailboxes', value: String(mailboxes.length) },
+        { label: 'Server Mode', value: mode },
+        { label: 'Domain', value: domain },
+        { label: 'Features', value: String(featureList.filter(f => f.enabled).length) },
+      ]
+
+      return {
+        mailboxes,
+        from: fromConfig,
+        server: {
+          mode,
+          scan,
+          subdomain,
+          features: featureList,
+          ports,
+          storage: serverConfig.storage || {},
+        },
+        domains,
+        stats,
+      }
+    }
+    catch {
+      return { mailboxes: [], domains: [], stats: [] }
+    }
+  },
+})

package/app/Actions/Dashboard/Infrastructure/PermissionIndexAction.ts

@@ -0,0 +1,54 @@
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+
+export default new Action({
+  name: 'PermissionIndexAction',
+  description: 'Returns security and permission configuration from config files.',
+  method: 'GET',
+  async handle() {
+    try {
+      const securityConfig = config.security || {}
+
+      // Read firewall settings from config/security.ts
+      const firewall = (securityConfig as any).firewall || {}
+
+      const firewallRules = {
+        enabled: firewall.enabled ?? false,
+        rateLimitPerMinute: firewall.rateLimitPerMinute || 0,
+        useIpReputationLists: firewall.useIpReputationLists ?? false,
+        useKnownBadInputsRuleSet: firewall.useKnownBadInputsRuleSet ?? false,
+      }
+
+      // Read blocked countries
+      const blockedCountries = firewall.countryCodes || []
+
+      // Read blocked IP addresses
+      const blockedIps = firewall.ipAddresses || []
+
+      // Read blocked query strings
+      const blockedQueryStrings = firewall.queryString || []
+
+      // Read blocked HTTP headers
+      const blockedHttpHeaders = firewall.httpHeaders || []
+
+      const stats = [
+        { label: 'Firewall', value: firewallRules.enabled ? 'Enabled' : 'Disabled' },
+        { label: 'Rate Limit', value: `${firewallRules.rateLimitPerMinute}/min` },
+        { label: 'Blocked Countries', value: String(blockedCountries.length) },
+        { label: 'Blocked IPs', value: String(blockedIps.length) },
+      ]
+
+      return {
+        firewall: firewallRules,
+        blockedCountries,
+        blockedIps,
+        blockedQueryStrings,
+        blockedHttpHeaders,
+        stats,
+      }
+    }
+    catch {
+      return { firewall: {}, blockedCountries: [], blockedIps: [], stats: [] }
+    }
+  },
+})

package/app/Actions/Dashboard/Infrastructure/RequestIndexAction.ts

@@ -0,0 +1,44 @@
+import { Action } from '@stacksjs/actions'
+import { Request } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'RequestIndexAction',
+  description: 'Returns request history data for the dashboard.',
+  method: 'GET',
+  async handle() {
+    try {
+      const allRequests = await Request.orderByDesc('id').limit(50).get()
+      const totalReqs = await Request.count()
+
+      const requests = allRequests.map(r => ({
+        method: String(r.get('method') || 'GET'),
+        path: String(r.get('path') || r.get('url') || ''),
+        status: Number(r.get('status_code') || r.get('status') || 200),
+        time: String(r.get('duration') || '-'),
+        timestamp: String(r.get('created_at') || ''),
+      }))
+
+      const errorReqs = allRequests.filter(r => (Number(r.get('status_code') || r.get('status') || 200)) >= 400).length
+
+      const stats = [
+        { label: 'Total Requests', value: String(totalReqs) },
+        { label: 'Avg Response', value: '-' },
+        { label: 'Error Rate', value: totalReqs > 0 ? `${((errorReqs / totalReqs) * 100).toFixed(2)}%` : '0%' },
+        { label: 'Requests/min', value: '-' },
+      ]
+
+      return { requests, stats }
+    }
+    catch {
+      return {
+        requests: [],
+        stats: [
+          { label: 'Total Requests', value: '0' },
+          { label: 'Avg Response', value: '-' },
+          { label: 'Error Rate', value: '0%' },
+          { label: 'Requests/min', value: '-' },
+        ],
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Infrastructure/ServerIndexAction.ts

@@ -0,0 +1,101 @@
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+
+export default new Action({
+  name: 'ServerIndexAction',
+  description: 'Returns server configuration from config files.',
+  method: 'GET',
+  async handle() {
+    try {
+      const cloudConfig = config.cloud || {}
+      const servers: Array<Record<string, unknown>> = []
+
+      // Read compute configuration from config/cloud.ts
+      const infra = (cloudConfig as any).infrastructure ?? (cloudConfig as any)
+      const compute = infra?.compute ?? (cloudConfig as any).compute
+
+      if (compute) {
+        const diskSize = compute.disk?.size ? `${compute.disk.size}GB` : '20GB'
+        const diskType = compute.disk?.type ?? 'ssd'
+
+        servers.push({
+          name: 'App Server',
+          type: compute.size || 'small',
+          instances: compute.instances || 1,
+          storage: diskSize,
+          diskType,
+          encrypted: compute.disk?.encrypted ?? false,
+          status: 'configured',
+        })
+      }
+
+      // Read server definitions from config/cloud.ts infrastructure.servers
+      const serverDefs = infra?.servers ?? {}
+      for (const [key, value] of Object.entries(serverDefs)) {
+        if (value && typeof value === 'object') {
+          servers.push({
+            name: key,
+            ...value as Record<string, unknown>,
+            status: 'configured',
+          })
+        }
+        else if (value) {
+          servers.push({
+            name: key,
+            reference: String(value),
+            status: 'configured',
+          })
+        }
+      }
+
+      // Read container configuration if present
+      const containers = infra?.containers ?? {}
+      const containerList: Array<Record<string, unknown>> = []
+      for (const [name, containerConfig] of Object.entries(containers)) {
+        if (containerConfig && typeof containerConfig === 'object') {
+          containerList.push({
+            name,
+            ...containerConfig as Record<string, unknown>,
+          })
+        }
+      }
+
+      // Read load balancer configuration
+      const loadBalancer = infra?.loadBalancer ?? {}
+
+      // Read SSL configuration
+      const ssl = infra?.ssl ?? {}
+
+      // Read DNS configuration from cloud config
+      const dns = infra?.dns ?? {}
+
+      // Read storage buckets
+      const storageBuckets = infra?.storage ?? {}
+      const bucketNames = Object.keys(storageBuckets)
+
+      // Build stats from actual config
+      const totalServers = servers.length
+      const mode = (cloudConfig as any).mode ?? 'server'
+
+      const stats = [
+        { label: 'Total Servers', value: String(totalServers) },
+        { label: 'Mode', value: mode },
+        { label: 'Region', value: String((cloudConfig as any).project?.region ?? infra?.dns?.domain ?? 'us-east-1') },
+        { label: 'Storage Buckets', value: String(bucketNames.length) },
+      ]
+
+      return {
+        servers,
+        containers: containerList,
+        loadBalancer,
+        ssl,
+        dns,
+        storageBuckets: bucketNames,
+        stats,
+      }
+    }
+    catch {
+      return { servers: [], containers: [], stats: [] }
+    }
+  },
+})

package/app/Actions/Dashboard/Jobs/CreateJob.ts

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

package/app/Actions/Dashboard/Jobs/GetAverageJobTime.ts

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

package/app/Actions/Dashboard/Jobs/GetJobHistory.ts

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

package/app/Actions/Dashboard/Jobs/GetJobs.ts

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

package/app/Actions/Dashboard/Jobs/GetJobsPerMinute.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Job } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetJobsPerMinute',
+  description: 'Gets the jobs per minute of your application.',
+  apiResponse: true,
+
+  async handle() {
+    // return Job.averagePerMinute()
+  },
+})

package/app/Actions/Dashboard/Jobs/JobIndexAction.ts

@@ -0,0 +1,136 @@
+import { Action } from '@stacksjs/actions'
+import { FailedJob, Job } from '@stacksjs/orm'
+import { request } from '@stacksjs/router'
+
+interface NormalizedJob {
+  id: string
+  name: string
+  queue: string
+  status: 'queued' | 'processing' | 'completed' | 'failed'
+  attempts: number
+  maxAttempts: number
+  duration: string
+  runtime?: number
+  error?: string
+  payload: unknown
+  created_at: string
+  started_at?: string
+  finished_at?: string
+}
+
+const STATUS_MAP: Record<string, NormalizedJob['status']> = {
+  pending: 'queued',
+  waiting: 'queued',
+  queued: 'queued',
+  active: 'processing',
+  processing: 'processing',
+  done: 'completed',
+  completed: 'completed',
+  failed: 'failed',
+}
+
+function safeParse(payload: unknown): unknown {
+  if (typeof payload !== 'string') return payload ?? null
+  try {
+    return JSON.parse(payload)
+  }
+  catch {
+    return payload
+  }
+}
+
+export default new Action({
+  name: 'JobIndexAction',
+  description: 'Returns a paginated list of jobs across the active queue and the failed_jobs table.',
+  method: 'GET',
+  async handle() {
+    // bun-router populates `request.query` as a Record<string, string|string[]>.
+    // Outside a request context (e.g. ad-hoc tests) it's undefined — fall back
+    // to defaults so the action stays callable.
+    const query = ((request as any).query || {}) as Record<string, string | string[] | undefined>
+    const pick = (key: string) => {
+      const v = query[key]
+      return Array.isArray(v) ? v[0] : v
+    }
+    const page = Math.max(1, Number(pick('page')) || 1)
+    const perPage = Math.min(200, Math.max(1, Number(pick('per_page')) || 25))
+    const queueFilter = String(pick('queue') || '').trim()
+    const statusFilter = String(pick('status') || '').trim().toLowerCase()
+    const search = String(pick('search') || '').trim().toLowerCase()
+
+    try {
+      const [activeJobs, failedJobs] = await Promise.all([
+        Job.orderByDesc('id').get(),
+        FailedJob.orderByDesc('id').get(),
+      ])
+
+      const activeNormalized: NormalizedJob[] = activeJobs.map((j) => {
+        const rawStatus = String(j.get('status') || 'pending').toLowerCase()
+        const status = STATUS_MAP[rawStatus] || 'queued'
+        const payload = safeParse(j.get('payload'))
+        const name = String(
+          (payload && typeof payload === 'object' && (payload as { displayName?: string }).displayName)
+          || j.get('name')
+          || j.get('queue')
+          || 'Job',
+        )
+        const duration = j.get('duration') ? `${j.get('duration')}ms` : '-'
+        return {
+          id: String(j.get('id') ?? ''),
+          name,
+          queue: String(j.get('queue') || 'default'),
+          status,
+          attempts: Number(j.get('attempts') || 0),
+          maxAttempts: Number(j.get('max_attempts') || 3),
+          duration,
+          runtime: Number(j.get('duration') || 0),
+          payload,
+          created_at: String(j.get('created_at') || ''),
+        }
+      })
+
+      const failedNormalized: NormalizedJob[] = failedJobs.map((f) => {
+        const payload = safeParse(f.get('payload'))
+        const name = String(
+          (payload && typeof payload === 'object' && (payload as { displayName?: string }).displayName)
+          || f.get('queue')
+          || 'Failed job',
+        )
+        return {
+          id: String(f.get('id') ?? ''),
+          name,
+          queue: String(f.get('queue') || 'default'),
+          status: 'failed',
+          attempts: Number(f.get('attempts') || 0),
+          maxAttempts: Number(f.get('max_attempts') || 3),
+          duration: '-',
+          error: String(f.get('exception') || ''),
+          payload,
+          created_at: String(f.get('failed_at') || f.get('created_at') || ''),
+          finished_at: String(f.get('failed_at') || ''),
+        }
+      })
+
+      const merged = [...activeNormalized, ...failedNormalized].sort((a, b) =>
+        new Date(b.created_at).getTime() - new Date(a.created_at).getTime(),
+      )
+
+      const filtered = merged.filter((job) => {
+        if (queueFilter && queueFilter !== 'all' && job.queue !== queueFilter) return false
+        if (statusFilter && statusFilter !== 'all' && job.status !== statusFilter) return false
+        if (search && !job.name.toLowerCase().includes(search)) return false
+        return true
+      })
+
+      const total = filtered.length
+      const start = (page - 1) * perPage
+      const data = filtered.slice(start, start + perPage)
+      const queues = Array.from(new Set(merged.map(j => j.queue))).sort()
+
+      return { data, total, page, perPage, queues, queueConnected: true }
+    }
+    catch {
+      return { data: [], total: 0, page, perPage, queues: [], queueConnected: false }
+    }
+  },
+})

package/app/Actions/Dashboard/Jobs/JobRetryAction.ts

@@ -0,0 +1,23 @@
+import { Action } from '@stacksjs/actions'
+import { request } from '@stacksjs/router'
+import { retryFailedJob } from '@stacksjs/queue'
+
+export default new Action({
+  name: 'JobRetryAction',
+  description: 'Retries a single failed job by its failed_jobs id.',
+  method: 'POST',
+  async handle() {
+    const id = Number((request as any).params?.id)
+    if (!Number.isFinite(id) || id <= 0) {
+      return { success: false, message: 'Invalid job id' }
+    }
+
+    try {
+      await retryFailedJob(id)
+      return { success: true, message: `Job ${id} re-queued` }
+    }
+    catch (e) {
+      return { success: false, message: (e as Error).message || 'Retry failed' }
+    }
+  },
+})

package/app/Actions/Dashboard/Jobs/JobStatsAction.ts

@@ -0,0 +1,49 @@
+import { Action } from '@stacksjs/actions'
+import { FailedJob, Job } from '@stacksjs/orm'
+import { getGlobalMetrics } from '@stacksjs/queue'
+
+export default new Action({
+  name: 'JobStatsAction',
+  description: 'Returns headline job statistics from the in-memory metrics tracker and DB job counts.',
+  method: 'GET',
+  async handle() {
+    try {
+      const [totalJobs, totalFailed] = await Promise.all([
+        Job.count(),
+        FailedJob.count(),
+      ])
+
+      const metrics = getGlobalMetrics().getMetrics()
+      const completedSeen = metrics.counts.completed
+      const failedSeen = metrics.counts.failed
+      const totalSeen = completedSeen + failedSeen
+      const failureRate = totalSeen > 0 ? `${((failedSeen / totalSeen) * 100).toFixed(1)}%` : '0%'
+
+      const avgMs = Math.round(metrics.averageDuration)
+      const avgProcessingTime = avgMs >= 1000
+        ? `${(avgMs / 1000).toFixed(2)}s`
+        : `${avgMs}ms`
+
+      return {
+        totalJobs,
+        totalFailed,
+        avgProcessingTime,
+        jobsPerMinute: metrics.throughputPerMinute,
+        failureRate,
+        // The composable doesn't render a chart, so we omit the synthetic
+        // throughput/waitTime arrays the previous handler returned. If you
+        // need historical data, persist completion events and serve them
+        // from a dedicated endpoint.
+      }
+    }
+    catch {
+      return {
+        totalJobs: 0,
+        totalFailed: 0,
+        avgProcessingTime: '0ms',
+        jobsPerMinute: 0,
+        failureRate: '0%',
+      }
+    }
+  },
+})