@stacksjs/defaults 0.70.354 → 0.70.356

package/app/Actions/Dashboard/Library/DependencyIndexAction.ts

@@ -1,94 +1,105 @@
 import { Action } from '@stacksjs/actions'
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
+import { dashboardOperationalError } from '../dashboard-response'
 
-export default new Action({
-  name: 'DependencyIndexAction',
-  description: 'Returns dependency data for the dashboard.',
-  method: 'GET',
-  async handle() {
-    const projectRoot = process.cwd()
-    const lockPath = join(projectRoot, 'bun.lock')
+function dependencySnapshot() {
+  const projectRoot = process.cwd()
+  const lockPath = join(projectRoot, 'bun.lock')
 
-    const declared: Array<Record<string, unknown>> = []
-    const transitive: Array<Record<string, unknown>> = []
-    let workspaceCount = 0
-    let thirdPartyCount = 0
-    let transitiveCount = 0
-    let totalCount = 0
+  const declared: Array<Record<string, unknown>> = []
+  const transitive: Array<Record<string, unknown>> = []
+  let workspaceCount = 0
+  let thirdPartyCount = 0
+  let transitiveCount = 0
+  let totalCount = 0
 
-    if (!existsSync(lockPath)) {
-      return {
-        available: false,
-        source: 'bun.lock',
-        declared,
-        thirdParty: [],
-        workspace: [],
-        transitive,
-        stats: [],
-        totalCount,
-        transitiveCount,
-        workspaceCount,
-        thirdPartyCount,
-      }
+  if (!existsSync(lockPath)) {
+    return {
+      available: false,
+      source: 'bun.lock',
+      declared,
+      thirdParty: [],
+      workspace: [],
+      transitive,
+      stats: [],
+      totalCount,
+      transitiveCount,
+      workspaceCount,
+      thirdPartyCount,
     }
+  }
 
-    const declaredSet: Record<string, boolean> = {}
-    const lockfile = Bun.JSONC.parse(readFileSync(lockPath, 'utf-8')) as {
-      workspaces?: Record<string, { name?: string, dependencies?: Record<string, string>, devDependencies?: Record<string, string> }>
-      packages?: Record<string, [string, ...unknown[]]>
-    }
-    const workspaces = lockfile.workspaces || {}
-    const workspaceNames = new Set(
-      Object.values(workspaces)
-        .map(workspace => workspace.name)
-        .filter((name): name is string => Boolean(name)),
-    )
+  const declaredSet: Record<string, boolean> = {}
+  const lockfile = Bun.JSONC.parse(readFileSync(lockPath, 'utf-8')) as {
+    workspaces?: Record<string, { name?: string, dependencies?: Record<string, string>, devDependencies?: Record<string, string> }>
+    packages?: Record<string, [string, ...unknown[]]>
+  }
+  const workspaces = lockfile.workspaces || {}
+  const workspaceNames = new Set(
+    Object.values(workspaces)
+      .map(workspace => workspace.name)
+      .filter((name): name is string => Boolean(name)),
+  )
 
-    for (const wsKey of Object.keys(workspaces)) {
-      const ws = workspaces[wsKey]
-      const allDeps = { ...ws.dependencies, ...ws.devDependencies }
-      for (const depName of Object.keys(allDeps)) {
-        if (declaredSet[depName]) continue
-        declaredSet[depName] = true
-        const version = allDeps[depName]
-        const isWorkspace = workspaceNames.has(depName)
-        declared.push({ name: depName, version, isWorkspace, isScoped: depName.includes('/') })
-      }
+  for (const wsKey of Object.keys(workspaces)) {
+    const ws = workspaces[wsKey]
+    const allDeps = { ...ws.dependencies, ...ws.devDependencies }
+    for (const depName of Object.keys(allDeps)) {
+      if (declaredSet[depName]) continue
+      declaredSet[depName] = true
+      const version = allDeps[depName]
+      const isWorkspace = workspaceNames.has(depName)
+      declared.push({ name: depName, version, isWorkspace, isScoped: depName.includes('/') })
     }
-    declared.sort((a, b) => String(a.name).localeCompare(String(b.name)))
+  }
+  declared.sort((a, b) => String(a.name).localeCompare(String(b.name)))
 
-    const transitiveSet = new Set<string>()
-    for (const value of Object.values(lockfile.packages || {})) {
-      const resolution = value[0]
-      if (resolution.includes('@workspace:')) continue
-      const versionSeparator = resolution.startsWith('@')
-        ? resolution.indexOf('@', 1)
-        : resolution.lastIndexOf('@')
-      if (versionSeparator <= 0) continue
-      const name = resolution.slice(0, versionSeparator)
-      const version = resolution.slice(versionSeparator + 1)
-      if (declaredSet[name] || transitiveSet.has(name)) continue
-      transitiveSet.add(name)
-      transitive.push({ name, version, isScoped: name.includes('/') })
-    }
-    transitive.sort((a, b) => String(a.name).localeCompare(String(b.name)))
+  const transitiveSet = new Set<string>()
+  for (const value of Object.values(lockfile.packages || {})) {
+    const resolution = value[0]
+    if (resolution.includes('@workspace:')) continue
+    const versionSeparator = resolution.startsWith('@')
+      ? resolution.indexOf('@', 1)
+      : resolution.lastIndexOf('@')
+    if (versionSeparator <= 0) continue
+    const name = resolution.slice(0, versionSeparator)
+    const version = resolution.slice(versionSeparator + 1)
+    if (declaredSet[name] || transitiveSet.has(name)) continue
+    transitiveSet.add(name)
+    transitive.push({ name, version, isScoped: name.includes('/') })
+  }
+  transitive.sort((a, b) => String(a.name).localeCompare(String(b.name)))
+
+  workspaceCount = declared.filter(p => p.isWorkspace).length
+  thirdPartyCount = declared.length - workspaceCount
+  transitiveCount = transitive.length
+  totalCount = declared.length + transitiveCount
 
-    workspaceCount = declared.filter(p => p.isWorkspace).length
-    thirdPartyCount = declared.length - workspaceCount
-    transitiveCount = transitive.length
-    totalCount = declared.length + transitiveCount
+  const thirdParty = declared.filter(p => !p.isWorkspace)
+  const workspace = declared.filter(p => p.isWorkspace)
 
-    const thirdParty = declared.filter(p => !p.isWorkspace)
-    const workspace = declared.filter(p => p.isWorkspace)
+  const stats = [
+    { label: 'Declared', value: String(declared.length) },
+    { label: 'Third-Party', value: String(thirdPartyCount) },
+    { label: 'Workspace', value: String(workspaceCount) },
+    { label: 'Transitive', value: String(transitiveCount) },
+  ]
 
-    const stats = [
-      { label: 'Declared', value: String(declared.length) },
-      { label: 'Third-Party', value: String(thirdPartyCount) },
-      { label: 'Workspace', value: String(workspaceCount) },
-      { label: 'Transitive', value: String(transitiveCount) },
-    ]
+  return { available: true, source: 'bun.lock', declared, thirdParty, workspace, transitive, stats, totalCount, transitiveCount, workspaceCount, thirdPartyCount }
+}
 
-    return { available: true, source: 'bun.lock', declared, thirdParty, workspace, transitive, stats, totalCount, transitiveCount, workspaceCount, thirdPartyCount }
+export default new Action({
+  name: 'DependencyIndexAction',
+  description: 'Returns dependency data for the dashboard.',
+  method: 'GET',
+  apiResponse: true,
+  async handle() {
+    try {
+      return dependencySnapshot()
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Dependency data could not be loaded.', 'DependencyIndexAction')
+    }
   },
 })

package/app/Actions/Dashboard/Library/GetAverageReleaseTime.ts

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'GetAverageReleaseTime',
@@ -7,24 +8,29 @@ export default new Action({
   apiResponse: true,
 
   async handle() {
-    const rows = await db
-      .selectFrom('releases')
-      .select(['created_at'])
-      .whereNotNull('created_at')
-      .orderBy('created_at')
-      .execute() as unknown as Array<{ created_at: string }>
+    try {
+      const rows = await db
+        .selectFrom('releases')
+        .select(['created_at'])
+        .whereNotNull('created_at')
+        .orderBy('created_at')
+        .execute() as unknown as Array<{ created_at: string }>
 
-    const timestamps = rows
-      .map(row => new Date(row.created_at).getTime())
-      .filter(Number.isFinite)
+      const timestamps = rows
+        .map(row => new Date(row.created_at).getTime())
+        .filter(Number.isFinite)
 
-    if (timestamps.length < 2)
-      return { averageSeconds: null, intervals: 0 }
+      if (timestamps.length < 2)
+        return { averageSeconds: null, intervals: 0 }
 
-    const elapsed = timestamps.slice(1).reduce((total, value, index) => total + value - timestamps[index]!, 0)
-    return {
-      averageSeconds: Math.round(elapsed / (timestamps.length - 1) / 1000),
-      intervals: timestamps.length - 1,
+      const elapsed = timestamps.slice(1).reduce((total, value, index) => total + value - timestamps[index]!, 0)
+      return {
+        averageSeconds: Math.round(elapsed / (timestamps.length - 1) / 1000),
+        intervals: timestamps.length - 1,
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Average release time could not be loaded.', 'GetAverageReleaseTime')
     }
   },
 })

package/app/Actions/Dashboard/Library/GetComponents.ts

@@ -1,20 +1,27 @@
 import { Action } from '@stacksjs/actions'
+import { dashboardOperationalError } from '../dashboard-response'
 import { componentSourceRows } from './library-source'
 
 export default new Action({
   name: 'GetComponents',
   description: 'Gets your UI components.',
   method: 'GET',
+  apiResponse: true,
 
   async handle() {
-    const components = componentSourceRows()
-    const categories = ['All', ...new Set(components.map(component => component.category))]
+    try {
+      const components = componentSourceRows()
+      const categories = ['All', ...new Set(components.map(component => component.category))]
 
-    return {
-      components,
-      categories,
-      totalBytes: components.reduce((sum, component) => sum + component.bytes, 0),
-      sourceRoot: 'resources/components',
+      return {
+        components,
+        categories,
+        totalBytes: components.reduce((sum, component) => sum + component.bytes, 0),
+        sourceRoot: 'resources/components',
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Component library could not be loaded.', 'GetComponents')
     }
   },
 })

package/app/Actions/Dashboard/Library/GetDownloadCount.ts

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'GetDownloadCount',
@@ -7,11 +8,19 @@ export default new Action({
   apiResponse: true,
 
   async handle() {
-    const row = await db
-      .selectFrom('releases')
-      .select(db.fn.sum('downloads').as('downloads'))
-      .executeTakeFirst() as { downloads?: number | string | null } | undefined
+    try {
+      const row = await db
+        .selectFrom('releases')
+        .select(db.fn.sum('downloads').as('downloads'))
+        .executeTakeFirst() as { downloads?: number | string | null } | undefined
+      const downloads = Number(row?.downloads || 0)
+      if (!Number.isSafeInteger(downloads) || downloads < 0)
+        throw new TypeError('Release download total must be a non-negative integer.')
 
-    return { downloads: Number(row?.downloads || 0), source: 'releases.downloads' }
+      return { downloads, source: 'releases.downloads' }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Release download count could not be loaded.', 'GetDownloadCount')
+    }
   },
 })

package/app/Actions/Dashboard/Library/GetFunctions.ts

@@ -1,18 +1,25 @@
 import { Action } from '@stacksjs/actions'
+import { dashboardOperationalError } from '../dashboard-response'
 import { functionSourceRows } from './library-source'
 
 export default new Action({
   name: 'GetFunctions',
   description: 'Gets your utility functions.',
   method: 'GET',
+  apiResponse: true,
 
   async handle() {
-    const functions = functionSourceRows()
+    try {
+      const functions = functionSourceRows()
 
-    return {
-      functions,
-      totalBytes: functions.reduce((sum, fn) => sum + fn.bytes, 0),
-      sourceRoot: 'resources/functions',
+      return {
+        functions,
+        totalBytes: functions.reduce((sum, fn) => sum + fn.bytes, 0),
+        sourceRoot: 'resources/functions',
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Function library could not be loaded.', 'GetFunctions')
     }
   },
 })

package/app/Actions/Dashboard/Library/GetReleaseCount.ts

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'GetReleaseCount',
@@ -7,11 +8,19 @@ export default new Action({
   apiResponse: true,
 
   async handle() {
-    const row = await db
-      .selectFrom('releases')
-      .select(db.fn.count('id').as('count'))
-      .executeTakeFirst() as { count?: number | string } | undefined
+    try {
+      const row = await db
+        .selectFrom('releases')
+        .select(db.fn.count('id').as('count'))
+        .executeTakeFirst() as { count?: number | string } | undefined
+      const count = Number(row?.count || 0)
+      if (!Number.isSafeInteger(count) || count < 0)
+        throw new TypeError('Release count must be a non-negative integer.')
 
-    return { count: Number(row?.count || 0) }
+      return { count }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Release count could not be loaded.', 'GetReleaseCount')
+    }
   },
 })

package/app/Actions/Dashboard/Library/GetReleases.ts

@@ -1,23 +1,30 @@
 import { Action } from '@stacksjs/actions'
 import { Release } from '@stacksjs/orm'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'GetReleases',
   description: 'Gets your releases.',
   method: 'GET',
+  apiResponse: true,
 
   async handle() {
-    const allReleases = await Release.orderByDesc('id').get()
+    try {
+      const allReleases = await Release.orderByDesc('id').limit(500).get()
 
-    const releases = allReleases.map(r => ({
-      version: String(r.get('version') || ''),
-      date: String(r.get('created_at') || r.get('released_at') || ''),
-      type: String(r.get('type') || 'patch'),
-      status: String(r.get('status') || 'previous'),
-      changes: Number(r.get('changes') || r.get('change_count') || 0),
-      breaking: Boolean(r.get('breaking') || false),
-    }))
+      const releases = allReleases.map(r => ({
+        version: String(r.get('version') || ''),
+        date: String(r.get('created_at') || r.get('released_at') || ''),
+        type: String(r.get('type') || 'patch'),
+        status: String(r.get('status') || 'previous'),
+        changes: Number(r.get('changes') || r.get('change_count') || 0),
+        breaking: Boolean(r.get('breaking') || false),
+      }))
 
-    return { releases }
+      return { releases }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Releases could not be loaded.', 'GetReleases')
+    }
   },
 })

package/app/Actions/Dashboard/Library/PackageIndexAction.ts

@@ -1,19 +1,26 @@
 import { Action } from '@stacksjs/actions'
+import { dashboardOperationalError } from '../dashboard-response'
 import { workspacePackageRows } from './library-source'
 
 export default new Action({
   name: 'PackageIndexAction',
   description: 'Returns package data for the dashboard.',
   method: 'GET',
+  apiResponse: true,
   async handle() {
-    const packages = workspacePackageRows()
+    try {
+      const packages = workspacePackageRows()
 
-    return {
-      packages,
-      publicCount: packages.filter(pkg => !pkg.private).length,
-      privateCount: packages.filter(pkg => pkg.private).length,
-      dependencyCount: packages.reduce((sum, pkg) => sum + pkg.dependencyCount, 0),
-      source: 'bun.lock',
+      return {
+        packages,
+        publicCount: packages.filter(pkg => !pkg.private).length,
+        privateCount: packages.filter(pkg => pkg.private).length,
+        dependencyCount: packages.reduce((sum, pkg) => sum + pkg.dependencyCount, 0),
+        source: 'bun.lock',
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Workspace packages could not be loaded.', 'PackageIndexAction')
     }
   },
 })

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

@@ -1,4 +1,7 @@
+import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
 import { parseRowId, resolveWritableModel } from './model-write'
 
 /**
@@ -13,24 +16,24 @@ export default new Action({
   description: 'Deletes one row of a model from the dashboard model browser.',
   method: 'DELETE',
   apiResponse: true,
-  async handle(req: { getParam?: (name: string) => unknown, route?: { params?: { slug?: string, id?: string } } }) {
-    const resolved = await resolveWritableModel(String(req?.getParam?.('slug') ?? req?.route?.params?.slug ?? ''), 'destroy')
+  async handle(request: RequestInstance) {
+    const resolved = await resolveWritableModel(request.getParam('slug'), 'destroy')
     if ('error' in resolved)
-      return { ok: false, error: resolved.error }
+      return response.json({ message: resolved.error }, resolved.status)
 
-    const id = parseRowId(req?.getParam?.('id') ?? req?.route?.params?.id)
+    const id = parseRowId(request.getParam('id'))
     if (id === null)
-      return { ok: false, error: 'A numeric row id is required.' }
+      return response.json({ message: 'A numeric row id is required.' }, 400)
 
     try {
       const row = await resolved.Model.find(id)
       if (!row)
-        return { ok: false, error: `${resolved.modelName} ${id} not found.` }
+        return response.json({ message: `${resolved.modelName} ${id} not found.` }, 404)
       await row.delete()
       return { ok: true, id }
     }
-    catch (e) {
-      return { ok: false, error: e instanceof Error ? e.message : String(e) }
+    catch (error) {
+      return dashboardOperationalError(error, 'The model record could not be deleted.', 'ModelDestroyAction', 500)
     }
   },
 })