@stacksjs/defaults 0.70.356 → 0.70.358

package/app/Actions/Dashboard/Content/TagStoreAction.ts

@@ -1,8 +1,10 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { isUniqueViolation, transaction } from '@stacksjs/orm'
 import { response } from '@stacksjs/router'
 import { randomUUIDv7 } from 'bun'
+import { dashboardOperationalError } from '../dashboard-response'
 import { findRow, insertedId, slugify, str, timestamp } from './content-input'
 
 /**
@@ -26,34 +28,53 @@ export default new Action({
     if (!slug)
       return response.json({ message: 'Slug could not be derived from the name; enter one.' }, 422)
 
-    const duplicate = await db
-      .selectFrom('tags')
-      .select(['id'])
-      .where('slug', '=', slug)
-      .executeTakeFirst()
+    try {
+      const tag = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        const duplicate = await trx
+          .selectFrom('tags')
+          .select(['id'])
+          .where('slug', '=', slug)
+          .orWhere('name', '=', name)
+          .executeTakeFirst()
 
-    if (duplicate)
-      return response.json({ message: 'A tag with that slug already exists.' }, 422)
+        if (duplicate)
+          return null
 
-    const now = timestamp()
+        const now = timestamp()
 
-    const result = await db
-      .insertInto('tags')
-      .values({
-        uuid: randomUUIDv7(),
-        name,
-        slug,
-        description,
-        created_at: now,
-        updated_at: now,
-      } as any)
-      .executeTakeFirst()
+        const result = await trx
+          .insertInto('tags')
+          .values({
+            uuid: randomUUIDv7(),
+            name,
+            slug,
+            description,
+            created_at: now,
+            updated_at: now,
+          } as any)
+          .executeTakeFirst()
 
-    const id = insertedId(result)
+        const id = insertedId(result)
 
-    if (!id)
-      return response.json({ message: 'Could not create tag.' }, 500)
+        if (!id)
+          throw new Error('Tag insert did not return an id.')
 
-    return response.json(await findRow('tags', id), 201)
+        const created = await findRow('tags', id, trx)
+        if (!created)
+          throw new Error('Created tag could not be loaded.')
+        return created
+      })
+
+      if (!tag)
+        return response.json({ message: 'A tag with that name or slug already exists.' }, 422)
+
+      return response.json(tag, 201)
+    }
+    catch (error) {
+      if (isUniqueViolation(error))
+        return response.json({ message: 'A tag with that name or slug already exists.' }, 422)
+      return dashboardOperationalError(error, 'Tag could not be created.', 'TagStoreAction', 500)
+    }
   },
 })

package/app/Actions/Dashboard/Content/content-input.ts

@@ -53,13 +53,13 @@ export function slugify(value: string): string {
  * `table` is a literal at every call site; the cast is only here because the
  * query builder's types want a table union rather than a `string`.
  */
-export async function findRow(table: string, id: number): Promise<unknown> {
-  return await (db as any).selectFrom(table).selectAll().where('id', '=', id).executeTakeFirst()
+export async function findRow(table: string, id: number, database: typeof db = db): Promise<unknown> {
+  return await (database as any).selectFrom(table).selectAll().where('id', '=', id).executeTakeFirst()
 }
 
 /** Whether a row with this id exists — the 404 check every write shares. */
-export async function rowExists(table: string, id: number): Promise<boolean> {
-  const row = await (db as any).selectFrom(table).select(['id']).where('id', '=', id).executeTakeFirst()
+export async function rowExists(table: string, id: number, database: typeof db = db): Promise<boolean> {
+  const row = await (database as any).selectFrom(table).select(['id']).where('id', '=', id).executeTakeFirst()
 
   return Boolean(row)
 }

package/app/Actions/Dashboard/Content/post-input.ts

@@ -1,8 +1,8 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { db } from '@stacksjs/database'
-import { str } from './content-input'
+import { insertedId, str, timestamp } from './content-input'
 
-export { insertedId, timestamp } from './content-input'
+export { insertedId, timestamp }
 
 export interface PostPayload {
   title: string
@@ -42,8 +42,8 @@ export function publishedAtFor(status: string, existing: string | null, now: str
 }
 
 /** Reads a post row back after a write — see `findRow` for why writes re-select. */
-export async function findPost(id: number): Promise<unknown> {
-  return await db.selectFrom('posts').selectAll().where('id', '=', id).executeTakeFirst()
+export async function findPost(id: number, database: typeof db = db): Promise<unknown> {
+  return await database.selectFrom('posts').selectAll().where('id', '=', id).executeTakeFirst()
 }
 
 function ids(value: unknown): number[] {
@@ -83,16 +83,16 @@ export function invalidPostContent(payload: PostPayload): string | null {
   return null
 }
 
-export async function invalidPostReference(payload: PostPayload): Promise<string | null> {
+export async function invalidPostReference(payload: PostPayload, database: typeof db = db): Promise<string | null> {
   const [author, categoryRows, tagRows] = await Promise.all([
     payload.authorId
-      ? db.selectFrom('authors').select(['id']).where('id', '=', payload.authorId).executeTakeFirst()
+      ? database.selectFrom('authors').select(['id']).where('id', '=', payload.authorId).executeTakeFirst()
       : Promise.resolve(undefined),
     payload.categoryIds.length
-      ? db.selectFrom('categories').whereIn('id', payload.categoryIds).select(['id']).execute()
+      ? database.selectFrom('categories').whereIn('id', payload.categoryIds).select(['id']).execute()
       : Promise.resolve([]),
     payload.tagIds.length
-      ? db.selectFrom('tags').whereIn('id', payload.tagIds).select(['id']).execute()
+      ? database.selectFrom('tags').whereIn('id', payload.tagIds).select(['id']).execute()
       : Promise.resolve([]),
   ])
 
@@ -106,6 +106,58 @@ export async function invalidPostReference(payload: PostPayload): Promise<string
   return null
 }
 
+async function replacePostPivot(
+  database: typeof db,
+  table: 'categorizable_models' | 'taggable_models',
+  foreignKey: 'category_id' | 'tag_id',
+  ownerKey: 'categorizable_id' | 'taggable_id',
+  typeKey: 'categorizable_type' | 'taggable_type',
+  postId: number,
+  relatedIds: number[],
+  now: string,
+): Promise<void> {
+  await (database as any)
+    .deleteFrom(table)
+    .where(ownerKey, '=', postId)
+    .where(typeKey, '=', 'posts')
+    .execute()
+
+  if (relatedIds.length === 0)
+    return
+
+  await (database as any)
+    .insertInto(table)
+    .values(relatedIds.map(relatedId => ({
+      [foreignKey]: relatedId,
+      [ownerKey]: postId,
+      [typeKey]: 'posts',
+      created_at: now,
+      updated_at: now,
+    })))
+    .execute()
+}
+
+/** Replaces both post pivot sets on the caller's database or transaction. */
+export async function syncPostRelations(database: typeof db, postId: number, payload: Pick<PostPayload, 'categoryIds' | 'tagIds'>): Promise<void> {
+  const now = timestamp()
+  await replacePostPivot(database, 'categorizable_models', 'category_id', 'categorizable_id', 'categorizable_type', postId, payload.categoryIds, now)
+  await replacePostPivot(database, 'taggable_models', 'tag_id', 'taggable_id', 'taggable_type', postId, payload.tagIds, now)
+}
+
+/** Removes both post pivot sets on the caller's database or transaction. */
+export async function detachPostRelations(database: typeof db, postId: number): Promise<void> {
+  await (database as any)
+    .deleteFrom('categorizable_models')
+    .where('categorizable_id', '=', postId)
+    .where('categorizable_type', '=', 'posts')
+    .execute()
+  await (database as any)
+    .deleteFrom('taggable_models')
+    .where('taggable_id', '=', postId)
+    .where('taggable_type', '=', 'posts')
+    .execute()
+}
+
 /** Maps a dashboard request body onto the writable post columns. */
 export function postPayload(request: RequestInstance): PostPayload {
   return {

package/app/Actions/Dashboard/DashboardHealthAction.ts

@@ -1,6 +1,7 @@
 import process from 'node:process'
 import { Action } from '@stacksjs/actions'
 import { checkApplicationHealth } from '@stacksjs/router'
+import { dashboardOperationalError, dashboardOperationalIssue } from './dashboard-response'
 
 export default new Action({
   name: 'DashboardHealthAction',
@@ -10,21 +11,40 @@ export default new Action({
 
   async handle() {
     const startedAt = performance.now()
-    const health = await checkApplicationHealth()
-    const memory = process.memoryUsage()
+    try {
+      const health = await checkApplicationHealth()
+      const memory = process.memoryUsage()
+      const checks = Object.fromEntries(Object.entries(health.checks).map(([name, check]) => {
+        if (!check.ok) {
+          dashboardOperationalIssue(
+            check.message,
+            'Dependency probe failed.',
+            `DashboardHealthAction.${name}`,
+          )
+        }
+        return [name, {
+          ...check,
+          message: check.ok ? undefined : 'Dependency probe failed.',
+        }]
+      }))
 
-    return {
-      ...health,
-      durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
-      runtime: {
-        bunVersion: process.versions.bun || '',
-        nodeVersion: process.versions.node || '',
-        platform: process.platform,
-        architecture: process.arch,
-        uptimeSeconds: Math.max(0, Math.floor(process.uptime())),
-        residentMemoryBytes: memory.rss,
-        heapUsedBytes: memory.heapUsed,
-      },
+      return {
+        ...health,
+        checks,
+        durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
+        runtime: {
+          bunVersion: process.versions.bun || '',
+          nodeVersion: process.versions.node || '',
+          platform: process.platform,
+          architecture: process.arch,
+          uptimeSeconds: Math.max(0, Math.floor(process.uptime())),
+          residentMemoryBytes: memory.rss,
+          heapUsedBytes: memory.heapUsed,
+        },
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'System health could not be loaded.', 'DashboardHealthAction')
     }
   },
 })

package/app/Actions/Dashboard/DashboardHomeAction.test.ts

@@ -28,7 +28,7 @@ describe('dashboard HTTP metrics', () => {
       name: 'Cache',
       status: 'critical',
       latency: '1500ms',
-      detail: 'timeout',
+      detail: 'Dependency probe failed.',
     })
   })
 

package/app/Actions/Dashboard/DashboardHomeAction.ts

@@ -2,6 +2,7 @@ import { Action } from '@stacksjs/actions'
 import { Order, Post, Product, Request, User } from '@stacksjs/orm'
 import { checkApplicationHealth, type ApplicationHealthCheck } from '@stacksjs/router'
 import { formatRelative, safeGet } from '../../../resources/functions/dashboard/data'
+import { dashboardOperationalIssue } from './dashboard-response'
 
 interface HttpRequestSample {
   duration: number
@@ -28,7 +29,7 @@ export function serializeHealthCheck(name: string, check: ApplicationHealthCheck
     name: name.charAt(0).toUpperCase() + name.slice(1),
     status: check.ok ? 'healthy' : 'critical',
     latency: `${check.ms}ms`,
-    detail: check.message || '',
+    detail: check.ok ? '' : 'Dependency probe failed.',
   }
 }
 
@@ -43,7 +44,11 @@ function issue(source: string, result: PromiseSettledResult<unknown>) {
   return result.status === 'rejected'
     ? {
         source,
-        message: result.reason instanceof Error ? result.reason.message : 'Query failed.',
+        message: dashboardOperationalIssue(
+          result.reason,
+          `${source} data could not be loaded.`,
+          `DashboardHomeAction.${source.toLowerCase().replaceAll(' ', '-')}`,
+        ),
       }
     : null
 }
@@ -65,7 +70,7 @@ export default new Action({
       Request.count(),
       Request.orderBy('created_at', 'desc').limit(1000).get(),
     ])
-    const health = await checkApplicationHealth()
+    const healthResult = await Promise.allSettled([checkApplicationHealth()])
 
     const [
       userCount,
@@ -93,7 +98,19 @@ export default new Action({
       })))
       : summarizeHttpRequests(0, [])
 
-    const services = Object.entries(health.checks).map(([name, check]) => serializeHealthCheck(name, check))
+    const health = healthResult[0]
+    const services = health.status === 'fulfilled'
+      ? Object.entries(health.value.checks).map(([name, check]) => {
+          if (!check.ok) {
+            dashboardOperationalIssue(
+              check.message,
+              'Dependency probe failed.',
+              `DashboardHomeAction.health.${name}`,
+            )
+          }
+          return serializeHealthCheck(name, check)
+        })
+      : []
 
     const activities = [
       ...(recentOrders.status === 'fulfilled' ? recentOrders.value : []).map((order: any) => ({
@@ -127,6 +144,16 @@ export default new Action({
     const issues = modelResults
       .map((result, index) => issue(sources[index], result))
       .filter((entry): entry is { source: string, message: string } => entry !== null)
+    if (health.status === 'rejected') {
+      issues.push({
+        source: 'System health',
+        message: dashboardOperationalIssue(
+          health.reason,
+          'System health could not be loaded.',
+          'DashboardHomeAction.health',
+        ),
+      })
+    }
 
     return { stats, httpMetrics, services, activities, issues }
   },

package/app/Actions/Dashboard/DashboardStatsAction.ts

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { Customer, Order, Post, User } from '@stacksjs/orm'
+import { dashboardOperationalIssue } from './dashboard-response'
 
 interface DashboardStatDefinition {
   title: string
@@ -61,7 +62,11 @@ export default new Action({
     const issues = results.flatMap((result, index) => result.status === 'rejected'
       ? [{
           source: definitions[index].title,
-          message: result.reason instanceof Error ? result.reason.message : 'Model query failed.',
+          message: dashboardOperationalIssue(
+            result.reason,
+            `${definitions[index].title} data could not be loaded.`,
+            `DashboardStatsAction.${definitions[index].title.toLowerCase().replaceAll(' ', '-')}`,
+          ),
         }]
       : [])
 

package/app/Actions/Dashboard/Email/InboxSendAction.ts

@@ -3,6 +3,7 @@ import { Action } from '@stacksjs/actions'
 import { notify } from '@stacksjs/notifications'
 import { response } from '@stacksjs/router'
 import { schema } from '@stacksjs/validation'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'InboxSendAction',
@@ -29,15 +30,21 @@ export default new Action({
     const subject = String(request.get('subject') || '').trim()
     const body = String(request.get('body') || '').trim()
 
-    const [result] = await notify(
-      { email: to },
-      { subject, body, data: { source: 'dashboard-inbox' } },
-      ['email'],
-      { ignorePreferences: true },
-    )
+    let result
+    try {
+      [result] = await notify(
+        { email: to },
+        { subject, body, data: { source: 'dashboard-inbox' } },
+        ['email'],
+        { ignorePreferences: true },
+      )
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'The email could not be sent.', 'InboxSendAction.provider', 502)
+    }
 
     if (!result?.success)
-      return response.json({ message: result?.error?.message || 'The email could not be sent.' }, 502)
+      return dashboardOperationalError(result?.error, 'The email could not be sent.', 'InboxSendAction.result', 502)
 
     return response.json({ success: true })
   },

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

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, statSync } from 'node:fs'
 import { join, relative } from 'node:path'
 import process from 'node:process'
 import { parseCommandSource } from '../Source/source-inventory'
+import { dashboardOperationalError } from '../dashboard-response'
 
 interface CommandConfig {
   file: string
@@ -15,35 +16,40 @@ export default new Action({
   description: 'Lists commands registered by the application.',
   method: 'GET',
   async handle() {
-    const projectRoot = process.cwd()
-    const registryPath = join(projectRoot, 'app/Commands.ts')
-    const registryModule = await import(registryPath)
-    const registry = (registryModule.default || {}) as Record<string, string | CommandConfig>
-    const items = Object.entries(registry).flatMap(([signature, value]) => {
-      const config = typeof value === 'string'
-        ? { file: value, enabled: true, aliases: [] }
-        : { enabled: true, aliases: [], ...value }
-      const file = join(projectRoot, 'app/Commands', `${config.file}.ts`)
-      if (!existsSync(file))
-        return []
+    try {
+      const projectRoot = process.cwd()
+      const registryPath = join(projectRoot, 'app/Commands.ts')
+      const registryModule = await import(registryPath)
+      const registry = (registryModule.default || {}) as Record<string, string | CommandConfig>
+      const items = Object.entries(registry).flatMap(([signature, value]) => {
+        const config = typeof value === 'string'
+          ? { file: value, enabled: true, aliases: [] }
+          : { enabled: true, aliases: [], ...value }
+        const file = join(projectRoot, 'app/Commands', `${config.file}.ts`)
+        if (!existsSync(file))
+          return []
 
-      return [parseCommandSource(
-        readFileSync(file, 'utf8'),
-        relative(projectRoot, file),
-        signature,
-        config.aliases,
-        statSync(file).mtime.toISOString(),
-      )]
-    })
+        return [parseCommandSource(
+          readFileSync(file, 'utf8'),
+          relative(projectRoot, file),
+          signature,
+          config.aliases,
+          statSync(file).mtime.toISOString(),
+        )]
+      })
 
-    return {
-      items,
-      stats: {
-        total: items.length,
-        aliases: items.reduce((sum, item) => sum + (item.aliases?.length || 0), 0),
-        options: items.reduce((sum, item) => sum + (item.options?.length || 0), 0),
-        registered: Object.keys(registry).length,
-      },
+      return {
+        items,
+        stats: {
+          total: items.length,
+          aliases: items.reduce((sum, item) => sum + (item.aliases?.length || 0), 0),
+          options: items.reduce((sum, item) => sum + (item.options?.length || 0), 0),
+          registered: Object.keys(registry).length,
+        },
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Command sources could not be loaded.', 'CommandIndexAction')
     }
   },
 })

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

@@ -1,4 +1,5 @@
 import { Action } from '@stacksjs/actions'
+import { dashboardOperationalError } from '../dashboard-response'
 import { readEnvironmentFile } from './environment-file'
 
 export default new Action({
@@ -8,9 +9,14 @@ export default new Action({
   apiResponse: true,
 
   async handle() {
-    return Response.json(
-      { environment: await readEnvironmentFile() },
-      { headers: { 'Cache-Control': 'no-store', Pragma: 'no-cache' } },
-    )
+    try {
+      return Response.json(
+        { environment: await readEnvironmentFile() },
+        { headers: { 'Cache-Control': 'no-store', Pragma: 'no-cache' } },
+      )
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Environment file could not be loaded.', 'EnvironmentIndexAction')
+    }
   },
 })

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

@@ -1,6 +1,7 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
 import { updateEnvironmentFile } from './environment-file'
 
 export default new Action({
@@ -18,7 +19,13 @@ export default new Action({
     if (typeof revision !== 'string' || !/^[a-f0-9]{64}$/.test(revision))
       return response.json({ message: 'A valid environment revision is required.' }, 422)
 
-    const result = await updateEnvironmentFile(content, revision)
+    let result
+    try {
+      result = await updateEnvironmentFile(content, revision)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Environment file could not be saved.', 'EnvironmentUpdateAction', 500)
+    }
     if (result.issues?.length) {
       const errors = Object.fromEntries(result.issues.map((issue, index) => [
         issue.line ? String(issue.line) : `file-${index}`,

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

@@ -1,19 +1,21 @@
 import { Action } from '@stacksjs/actions'
 import { Request } from '@stacksjs/orm'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'RequestIndexAction',
   description: 'Returns request history data for the dashboard.',
   method: 'GET',
   async handle() {
-    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString()
-    const [allRequests, total, errorCount, averageDurationMs, requestsLastHour] = await Promise.all([
-      Request.orderByDesc('id').limit(100).get(),
-      Request.count(),
-      Request.where('status_code', '>=', 400).count(),
-      Request.avg('duration_ms'),
-      Request.where('created_at', '>=', oneHourAgo).count(),
-    ])
+    try {
+      const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString()
+      const [allRequests, total, errorCount, averageDurationMs, requestsLastHour] = await Promise.all([
+        Request.orderByDesc('id').limit(100).get(),
+        Request.count(),
+        Request.where('status_code', '>=', 400).count(),
+        Request.avg('duration_ms'),
+        Request.where('created_at', '>=', oneHourAgo).count(),
+      ])
 
     const requests = allRequests.map(request => ({
       id: Number(request.get('id') || 0),
@@ -28,16 +30,20 @@ export default new Action({
       createdAt: String(request.get('created_at') || ''),
     }))
 
-    return {
-      requests,
-      stats: {
-        total,
-        errorCount,
-        averageDurationMs: Number(averageDurationMs || 0),
-        successRate: total > 0 ? ((total - errorCount) / total) * 100 : 0,
-        requestsLastHour,
-        requestsPerMinute: requestsLastHour / 60,
-      },
+      return {
+        requests,
+        stats: {
+          total,
+          errorCount,
+          averageDurationMs: Number(averageDurationMs || 0),
+          successRate: total > 0 ? ((total - errorCount) / total) * 100 : 0,
+          requestsLastHour,
+          requestsPerMinute: requestsLastHour / 60,
+        },
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Request history could not be loaded.', 'RequestIndexAction')
     }
   },
 })

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

@@ -1,21 +1,27 @@
 import { Action } from '@stacksjs/actions'
 import { tsCloud } from '~/config/cloud'
 import { getDashboardCloudSnapshot } from '../Cloud/cloud-overview'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'ServerIndexAction',
   description: 'Returns configured servers and persisted deployment state.',
   method: 'GET',
   async handle() {
-    const snapshot = await getDashboardCloudSnapshot(tsCloud)
-    return {
-      project: snapshot.project,
-      environments: snapshot.environments,
-      servers: snapshot.serverDefinitions,
-      deployments: snapshot.deployments,
-      network: snapshot.resources.filter(resource => resource.category === 'network'),
-      events: snapshot.events,
-      generatedAt: snapshot.generatedAt,
+    try {
+      const snapshot = await getDashboardCloudSnapshot(tsCloud)
+      return {
+        project: snapshot.project,
+        environments: snapshot.environments,
+        servers: snapshot.serverDefinitions,
+        deployments: snapshot.deployments,
+        network: snapshot.resources.filter(resource => resource.category === 'network'),
+        events: snapshot.events,
+        generatedAt: snapshot.generatedAt,
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Server state could not be loaded.', 'ServerIndexAction')
     }
   },
 })