@stacksjs/defaults 0.70.207 → 0.70.208

package/functions/monitoring/errors.ts

@@ -0,0 +1,295 @@
+import { useStorage } from '@stacksjs/browser'
+
+export interface GroupedError {
+  id: number
+  type: string
+  message: string
+  stack: string | null
+  status: string
+  count: number
+  first_seen: string
+  last_seen: string
+  error_ids: number[]
+}
+
+export interface ErrorRecord {
+  id: number
+  type: string
+  message: string
+  stack: string | null
+  status: number | null
+  additional_info: string | null
+  created_at: string
+  updated_at: string | null
+}
+
+export interface ErrorStats {
+  total: number
+  unresolved: number
+  resolved: number
+  ignored: number
+  last_24h: number
+  trend: number
+}
+
+export interface ErrorTimelinePoint {
+  hour: string
+  count: number
+}
+
+// Create persistent storage for errors data
+const groupedErrors = useStorage<GroupedError[]>('grouped-errors', [])
+const errorStats = useStorage<ErrorStats | null>('error-stats', null)
+const errorTimeline = useStorage<ErrorTimelinePoint[]>('error-timeline', [])
+
+const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+/**
+ * Fetch all grouped errors
+ */
+async function fetchGroupedErrors(): Promise<GroupedError[]> {
+  try {
+    const response = await fetch(`${baseURL}/monitoring/errors`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const { data } = await response.json() as { data: GroupedError[] }
+
+    if (Array.isArray(data)) {
+      groupedErrors.value = data
+      return data
+    }
+    else {
+      console.error('Expected array of errors but received:', typeof data)
+      return []
+    }
+  }
+  catch (error) {
+    console.error('Error fetching grouped errors:', error)
+    return groupedErrors.value
+  }
+}
+
+/**
+ * Fetch a single error by ID
+ */
+async function fetchErrorById(id: number): Promise<ErrorRecord | null> {
+  try {
+    const response = await fetch(`${baseURL}/monitoring/errors/${id}`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const { data } = await response.json() as { data: ErrorRecord }
+    return data
+  }
+  catch (error) {
+    console.error('Error fetching error by ID:', error)
+    return null
+  }
+}
+
+/**
+ * Fetch all errors in a specific group
+ */
+async function fetchErrorGroup(type: string, message: string): Promise<ErrorRecord[]> {
+  try {
+    const params = new URLSearchParams({
+      type: encodeURIComponent(type),
+      message: encodeURIComponent(message),
+    })
+    const response = await fetch(`${baseURL}/monitoring/errors/group?${params}`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const { data } = await response.json() as { data: ErrorRecord[] }
+    return data || []
+  }
+  catch (error) {
+    console.error('Error fetching error group:', error)
+    return []
+  }
+}
+
+/**
+ * Fetch error statistics
+ */
+async function fetchErrorStats(): Promise<ErrorStats | null> {
+  try {
+    const response = await fetch(`${baseURL}/monitoring/errors/stats`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const { data } = await response.json() as { data: ErrorStats }
+    errorStats.value = data
+    return data
+  }
+  catch (error) {
+    console.error('Error fetching error stats:', error)
+    return errorStats.value
+  }
+}
+
+/**
+ * Fetch error timeline
+ */
+async function fetchErrorTimeline(): Promise<ErrorTimelinePoint[]> {
+  try {
+    const response = await fetch(`${baseURL}/monitoring/errors/timeline`)
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+    const { data } = await response.json() as { data: ErrorTimelinePoint[] }
+    errorTimeline.value = data
+    return data
+  }
+  catch (error) {
+    console.error('Error fetching error timeline:', error)
+    return errorTimeline.value
+  }
+}
+
+/**
+ * Resolve all errors in a group
+ */
+async function resolveErrorGroup(type: string, message: string): Promise<boolean> {
+  try {
+    const response = await fetch(`${baseURL}/monitoring/errors/resolve`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ type, message }),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    // Update local state
+    const index = groupedErrors.value.findIndex(
+      e => e.type === type && e.message === message,
+    )
+    if (index !== -1) {
+      groupedErrors.value[index].status = 'resolved'
+    }
+
+    return true
+  }
+  catch (error) {
+    console.error('Error resolving error group:', error)
+    return false
+  }
+}
+
+/**
+ * Ignore all errors in a group
+ */
+async function ignoreErrorGroup(type: string, message: string): Promise<boolean> {
+  try {
+    const response = await fetch(`${baseURL}/monitoring/errors/ignore`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ type, message }),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    // Update local state
+    const index = groupedErrors.value.findIndex(
+      e => e.type === type && e.message === message,
+    )
+    if (index !== -1) {
+      groupedErrors.value[index].status = 'ignored'
+    }
+
+    return true
+  }
+  catch (error) {
+    console.error('Error ignoring error group:', error)
+    return false
+  }
+}
+
+/**
+ * Unresolve (reopen) all errors in a group
+ */
+async function unresolveErrorGroup(type: string, message: string): Promise<boolean> {
+  try {
+    const response = await fetch(`${baseURL}/monitoring/errors/unresolve`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ type, message }),
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    // Update local state
+    const index = groupedErrors.value.findIndex(
+      e => e.type === type && e.message === message,
+    )
+    if (index !== -1) {
+      groupedErrors.value[index].status = 'unresolved'
+    }
+
+    return true
+  }
+  catch (error) {
+    console.error('Error unresolving error group:', error)
+    return false
+  }
+}
+
+/**
+ * Delete all errors in a group
+ */
+async function deleteErrorGroup(type: string, message: string): Promise<boolean> {
+  try {
+    const params = new URLSearchParams({
+      type: encodeURIComponent(type),
+      message: encodeURIComponent(message),
+    })
+    const response = await fetch(`${baseURL}/monitoring/errors?${params}`, {
+      method: 'DELETE',
+    })
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`)
+    }
+
+    // Update local state
+    groupedErrors.value = groupedErrors.value.filter(
+      e => !(e.type === type && e.message === message),
+    )
+
+    return true
+  }
+  catch (error) {
+    console.error('Error deleting error group:', error)
+    return false
+  }
+}
+
+export function useErrors() {
+  return {
+    groupedErrors,
+    errorStats,
+    errorTimeline,
+    fetchGroupedErrors,
+    fetchErrorById,
+    fetchErrorGroup,
+    fetchErrorStats,
+    fetchErrorTimeline,
+    resolveErrorGroup,
+    ignoreErrorGroup,
+    unresolveErrorGroup,
+    deleteErrorGroup,
+  }
+}

package/functions/queue.ts

@@ -0,0 +1,111 @@
+/**
+ * Queue Composable
+ *
+ * Provides data fetching for the queue dashboard. The shape mirrors what
+ * `/queue/stats` and `/queue/workers` return, which in turn pull from the
+ * framework's Job ORM and `@stacksjs/queue` metrics tracker.
+ */
+
+import { ref } from '@stacksjs/stx'
+import { get, post } from './api'
+
+export interface QueueBucket {
+  name: string
+  status: 'active' | 'idle'
+  pending: number
+  active: number
+  completed: number
+  failed: number
+  total: number
+}
+
+export interface QueueAggregateStats {
+  totalQueues: number
+  totalJobs: number
+  activeJobs: number
+  completedJobs: number
+  failedJobs: number
+  throughputPerMinute: number
+  averageProcessingTimeMs: number
+}
+
+export interface QueueWorker {
+  id: string
+  name: string
+  status: 'running' | 'paused' | 'stopped'
+  queues: string[]
+  jobs_processed: number
+  failed_jobs: number
+  uptime: string
+  last_heartbeat: string
+  memory: string
+}
+
+export function useQueue() {
+  const queues = ref<QueueBucket[]>([])
+  const stats = ref<QueueAggregateStats>({
+    totalQueues: 0,
+    totalJobs: 0,
+    activeJobs: 0,
+    completedJobs: 0,
+    failedJobs: 0,
+    throughputPerMinute: 0,
+    averageProcessingTimeMs: 0,
+  })
+  const workers = ref<QueueWorker[]>([])
+  const queueConnected = ref(false)
+  const isLoading = ref(false)
+  const error = ref<string | null>(null)
+
+  async function fetchStats() {
+    const data = await get<{ queues: QueueBucket[], stats: QueueAggregateStats, queueConnected: boolean }>('/queue/stats')
+    queues.value = data.queues || []
+    stats.value = data.stats || stats.value
+    queueConnected.value = Boolean(data.queueConnected)
+  }
+
+  async function fetchWorkers() {
+    const data = await get<{ data: QueueWorker[] }>('/queue/workers')
+    workers.value = data.data || []
+  }
+
+  async function fetchAll() {
+    isLoading.value = true
+    error.value = null
+
+    try {
+      await Promise.all([fetchStats(), fetchWorkers()])
+    }
+    catch (e) {
+      error.value = 'Failed to load queue data.'
+      console.error('Failed to fetch queue data:', e)
+    }
+    finally {
+      isLoading.value = false
+    }
+  }
+
+  async function retryFailedJobs() {
+    try {
+      await post<{ success: boolean, count: number, message: string }>('/queue/retry-failed')
+      await fetchAll()
+    }
+    catch (e) {
+      error.value = 'Failed to retry failed jobs.'
+      console.error('Failed to retry failed jobs:', e)
+    }
+  }
+
+  return {
+    queues,
+    stats,
+    workers,
+    queueConnected,
+    isLoading,
+    error,
+    fetchStats,
+    fetchWorkers,
+    fetchAll,
+    retryFailedJobs,
+  }
+}

package/functions/realtime/websockets.ts

@@ -0,0 +1,96 @@
+import type { StoreWebsocket, Websockets } from '../../types/defaults'
+import { useFetch, useStorage } from '@stacksjs/browser'
+
+const baseURL = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+// Create a persistent websockets array using STX useStorage
+const websockets = useStorage<Websockets[]>('websockets', [])
+
+// Basic fetch function to get all websocket events
+async function fetchWebsockets() {
+  const { error, data } = await useFetch(`${baseURL}/realtime/websockets`).get().json()
+
+  const websocketsJson = data.value as Websockets[]
+  if (error.value) {
+    console.error('Error fetching websocket events:', error.value)
+    return []
+  }
+
+  // Ensure data is an array before assigning
+  if (Array.isArray(data.value)) {
+    websockets.value = websocketsJson
+    return data.value
+  }
+  else {
+    console.error('Expected array of websocket events but received:', typeof data.value)
+    return []
+  }
+}
+
+async function createWebsocket(websocket: Partial<StoreWebsocket>): Promise<Websockets | null> {
+  const { error, data } = await useFetch(`${baseURL}/realtime/websockets`)
+    .post(JSON.stringify(websocket))
+    .json()
+
+  if (error.value) {
+    console.error('Error creating websocket event:', error.value)
+    return null
+  }
+
+  const newWebsocket = data.value as Websockets
+  if (newWebsocket) {
+    websockets.value.unshift(newWebsocket)
+    return newWebsocket
+  }
+  return null
+}
+
+async function updateWebsocket(id: number, websocket: Partial<Websockets>) {
+  const { error, data } = await useFetch(`${baseURL}/realtime/websockets/${id}`)
+    .patch(JSON.stringify(websocket))
+    .json()
+
+  if (error.value) {
+    console.error('Error updating websocket event:', error.value)
+    return null
+  }
+
+  const updatedWebsocket = data.value as Websockets
+  if (updatedWebsocket) {
+    const index = websockets.value.findIndex(w => w.id === id)
+    if (index !== -1) {
+      websockets.value[index] = updatedWebsocket
+    }
+    return updatedWebsocket
+  }
+  return null
+}
+
+async function deleteWebsocket(id: number) {
+  const { error } = await useFetch(`${baseURL}/realtime/websockets/${id}`)
+    .delete()
+    .json()
+
+  if (error.value) {
+    console.error('Error deleting websocket event:', error.value)
+    return false
+  }
+
+  const index = websockets.value.findIndex(w => w.id === id)
+  if (index !== -1) {
+    websockets.value.splice(index, 1)
+  }
+
+  return true
+}
+
+// Export the composable
+export function useWebsockets() {
+  return {
+    websockets,
+    fetchWebsockets,
+    createWebsocket,
+    updateWebsocket,
+    deleteWebsocket,
+  }
+}

package/functions/realtime.ts

@@ -0,0 +1,52 @@
+/**
+ * Realtime Composable
+ */
+import { ref } from '@stacksjs/stx'
+
+const baseUrl = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+export interface RealtimeStats {
+  connectionsTriggered: number
+  connectionsChange: number
+  avgLatency: string
+  latencyChange: number
+  successRate: string
+  successChange: number
+}
+
+export interface ActiveConnection {
+  id: string
+  client: string
+  status: string
+  uptime: string
+  messages: number
+}
+
+export function useRealtimeStats() {
+  const stats = ref<RealtimeStats>({ connectionsTriggered: 0, connectionsChange: 0, avgLatency: '0ms', latencyChange: 0, successRate: '0%', successChange: 0 })
+  const activeConnections = ref<ActiveConnection[]>([])
+  const isLoading = ref(false)
+  const error = ref<string | null>(null)
+
+  async function fetchStats() {
+    isLoading.value = true
+    error.value = null
+    try {
+      const response = await fetch(`${baseUrl}/realtime/stats`, {
+        headers: { 'Accept': 'application/json' },
+      })
+      if (response.ok) {
+        const data = await response.json()
+        stats.value = data.stats || stats.value
+        activeConnections.value = data.activeConnections || []
+      }
+    } catch (e) {
+      error.value = 'Failed to load realtime stats.'
+      console.error('Failed to fetch realtime stats:', e)
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  return { stats, activeConnections, isLoading, error, fetchStats }
+}

package/functions/releases.ts

@@ -0,0 +1,49 @@
+/**
+ * Releases Composable
+ */
+import { ref } from '@stacksjs/stx'
+
+const baseUrl = process.env.VITE_API_URL || `http://localhost:${process.env.PORT_API || '3008'}`
+
+export interface Release {
+  version: string
+  codename: string
+  size: string
+  path: string
+  createdAt: string
+}
+
+export interface ReleaseStats {
+  labels: string[]
+  downloads: number[]
+  releaseTimes: number[]
+}
+
+export function useReleases() {
+  const releases = ref<Release[]>([])
+  const stats = ref<ReleaseStats>({ labels: [], downloads: [], releaseTimes: [] })
+  const isLoading = ref(false)
+  const error = ref<string | null>(null)
+
+  async function fetchAll() {
+    isLoading.value = true
+    error.value = null
+    try {
+      const response = await fetch(`${baseUrl}/releases`, {
+        headers: { 'Accept': 'application/json' },
+      })
+      if (response.ok) {
+        const data = await response.json()
+        releases.value = data.data || []
+        stats.value = data.stats || stats.value
+      }
+    } catch (e) {
+      error.value = 'Failed to load releases.'
+      console.error('Failed to fetch releases:', e)
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  return { releases, stats, isLoading, error, fetchAll }
+}