@stacksjs/defaults 0.70.355 → 0.70.357

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

@@ -1,8 +1,10 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { transaction } from '@stacksjs/orm'
 import { response } from '@stacksjs/router'
-import { findPost, invalidPostContent, invalidPostReference, postPayload, publishedAtFor, timestamp } from './post-input'
+import { dashboardOperationalError } from '../dashboard-response'
+import { findPost, invalidPostContent, invalidPostReference, postPayload, publishedAtFor, syncPostRelations, timestamp } from './post-input'
 
 /**
  * `PATCH /api/dashboard/posts/{id}` — updates a CMS post from the dashboard.
@@ -27,45 +29,55 @@ export default new Action({
     if (invalidContent)
       return response.json({ message: invalidContent }, 422)
 
-    const invalidReference = await invalidPostReference(payload)
-    if (invalidReference)
-      return response.json({ message: invalidReference }, 422)
+    try {
+      const result = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        const invalidReference = await invalidPostReference(payload, trx)
+        if (invalidReference)
+          return { kind: 'invalid', message: invalidReference } as const
 
-    const existing = await db
-      .selectFrom('posts')
-      .select(['id', 'published_at'])
-      .where('id', '=', id)
-      .executeTakeFirst() as { id: number, published_at: string | null } | undefined
+        const existing = await trx
+          .selectFrom('posts')
+          .select(['id', 'published_at'])
+          .where('id', '=', id)
+          .executeTakeFirst() as { id: number, published_at: string | null } | undefined
 
-    if (!existing)
-      return response.json({ message: 'Post not found.' }, 404)
+        if (!existing)
+          return { kind: 'not-found' } as const
 
-    await db
-      .updateTable('posts')
-      .set({
-        title: payload.title,
-        excerpt: payload.excerpt,
-        content: payload.content,
-        poster: payload.poster,
-        status: payload.status,
-        author_id: payload.authorId,
-        is_featured: payload.featured ? 1 : 0,
-        published_at: publishedAtFor(payload.status, existing.published_at, timestamp()),
-        updated_at: timestamp(),
-      } as any)
-      .where('id', '=', id)
-      .execute()
+        await trx
+          .updateTable('posts')
+          .set({
+            title: payload.title,
+            excerpt: payload.excerpt,
+            content: payload.content,
+            poster: payload.poster,
+            status: payload.status,
+            author_id: payload.authorId,
+            is_featured: payload.featured ? 1 : 0,
+            published_at: publishedAtFor(payload.status, existing.published_at, timestamp()),
+            updated_at: timestamp(),
+          } as any)
+          .where('id', '=', id)
+          .execute()
 
-    const post = await Post.find(id)
+        await syncPostRelations(trx, id, payload)
 
-    if (!post)
-      return response.json({ message: 'Updated post could not be loaded.' }, 500)
+        const updated = await findPost(id, trx)
+        if (!updated)
+          throw new Error('Updated post could not be read back.')
+        return { kind: 'updated', post: updated } as const
+      })
 
-    await Promise.all([
-      post.categories().sync(payload.categoryIds),
-      post.tags().sync(payload.tagIds),
-    ])
+      if (result.kind === 'invalid')
+        return response.json({ message: result.message }, 422)
+      if (result.kind === 'not-found')
+        return response.json({ message: 'Post not found.' }, 404)
 
-    return response.json(await findPost(id))
+      return response.json(result.post)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Post could not be updated.', 'PostUpdateAction', 500)
+    }
   },
 })

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

@@ -1,13 +1,16 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { transaction } from '@stacksjs/orm'
 import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
 import { rowId } from './content-input'
 
 /**
  * `DELETE /api/dashboard/tags/{id}` — deletes a CMS tag.
  *
- * Detaches related posts through the model relation before removing the tag so
- * no pivot rows are orphaned.
+ * Detaches related posts through the model-declared pivot before removing the
+ * tag, with both writes committed by the same transaction.
  */
 export default new Action({
   name: 'TagDestroyAction',
@@ -19,13 +22,29 @@ export default new Action({
     if (!id)
       return response.json({ message: 'A valid tag id is required.' }, 422)
 
-    const tag = await Tag.find(id)
-    if (!tag)
-      return response.json({ message: 'Tag not found.' }, 404)
+    try {
+      const deleted = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        const tag = await trx.selectFrom('tags').select(['id']).where('id', '=', id).executeTakeFirst()
+        if (!tag)
+          return false
 
-    await tag.posts().detach()
-    await tag.delete()
+        await trx
+          .deleteFrom('taggable_models')
+          .where('tag_id', '=', id)
+          .where('taggable_type', '=', 'posts')
+          .execute()
+        await trx.deleteFrom('tags').where('id', '=', id).execute()
+        return true
+      })
 
-    return response.json({ message: 'Tag deleted.', id })
+      if (!deleted)
+        return response.json({ message: 'Tag not found.' }, 404)
+
+      return response.json({ message: 'Tag deleted.', id })
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Tag could not be deleted.', 'TagDestroyAction', 500)
+    }
   },
 })

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

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 interface TagRow {
   id: number
@@ -28,32 +29,37 @@ export default new Action({
   method: 'GET',
   apiResponse: true,
   async handle() {
-    const [rows, countRows] = await Promise.all([
-      db
-        .selectFrom('tags')
-        .select(['id', 'name', 'slug', 'description', 'color', 'created_at', 'updated_at'])
-        .orderBy('created_at', 'desc')
-        .execute() as unknown as Promise<TagRow[]>,
-      db
-        .selectFrom('taggable_models')
-        .select(['tag_id', db.fn.count('taggable_id').as('count')])
-        .where('taggable_type', '=', 'posts')
-        .groupBy('tag_id')
-        .execute() as unknown as Promise<TagCountRow[]>,
-    ])
-    const countByTag = new Map(countRows.map(row => [Number(row.tag_id), Number(row.count)]))
+    try {
+      const [rows, countRows] = await Promise.all([
+        db
+          .selectFrom('tags')
+          .select(['id', 'name', 'slug', 'description', 'color', 'created_at', 'updated_at'])
+          .orderBy('created_at', 'desc')
+          .execute() as unknown as Promise<TagRow[]>,
+        db
+          .selectFrom('taggable_models')
+          .select(['tag_id', db.fn.count('taggable_id').as('count')])
+          .where('taggable_type', '=', 'posts')
+          .groupBy('tag_id')
+          .execute() as unknown as Promise<TagCountRow[]>,
+      ])
+      const countByTag = new Map(countRows.map(row => [Number(row.tag_id), Number(row.count)]))
 
-    const tags = rows.map(row => ({
-      id: Number(row.id),
-      name: String(row.name || ''),
-      slug: String(row.slug || ''),
-      description: String(row.description || ''),
-      color: String(row.color || ''),
-      post_count: countByTag.get(Number(row.id)) || 0,
-      created_at: row.created_at || null,
-      updated_at: row.updated_at || null,
-    }))
+      const tags = rows.map(row => ({
+        id: Number(row.id),
+        name: String(row.name || ''),
+        slug: String(row.slug || ''),
+        description: String(row.description || ''),
+        color: String(row.color || ''),
+        post_count: countByTag.get(Number(row.id)) || 0,
+        created_at: row.created_at || null,
+        updated_at: row.updated_at || null,
+      }))
 
-    return { tags }
+      return { tags }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Tags could not be loaded.', 'TagIndexAction')
+    }
   },
 })

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/DashboardActivityAction.ts

@@ -1,6 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { Activity } from '@stacksjs/orm'
 import { safeGet } from '../../../resources/functions/dashboard/data'
+import { dashboardOperationalError } from './dashboard-response'
 import { dateValue, numberValue, textValue } from './Data/data-records'
 
 export function activityStatus(type: string): 'success' | 'warning' {
@@ -35,11 +36,7 @@ export default new Action({
       return { activity, count: activity.length }
     }
     catch (error) {
-      return {
-        activity: [],
-        count: 0,
-        error: error instanceof Error ? error.message : 'Activity records could not be loaded.',
-      }
+      return dashboardOperationalError(error, 'Activity records could not be loaded.', 'DashboardActivityAction')
     }
   },
 })

package/app/Actions/Dashboard/Data/ActivityIndexAction.ts

@@ -1,6 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { Activity } from '@stacksjs/orm'
 import { safeGet } from '../../../../resources/functions/dashboard/data'
+import { dashboardOperationalError } from '../dashboard-response'
 import { dateValue, daysAgoIso, numberValue, textValue } from './data-records'
 
 export default new Action({
@@ -37,11 +38,7 @@ export default new Action({
       }
     }
     catch (error) {
-      return {
-        activities: [],
-        stats: { total: 0, last24Hours: 0, last7Days: 0 },
-        error: error instanceof Error ? error.message : 'Activity could not be loaded.',
-      }
+      return dashboardOperationalError(error, 'Activity could not be loaded.', 'ActivityIndexAction')
     }
   },
 })

package/app/Actions/Dashboard/Data/SubscriberIndexAction.ts

@@ -1,6 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { Subscriber } from '@stacksjs/orm'
 import { safeGet } from '../../../../resources/functions/dashboard/data'
+import { dashboardOperationalError } from '../dashboard-response'
 import { dateValue, daysAgoIso, numberValue, textValue } from './data-records'
 
 export default new Action({
@@ -38,11 +39,7 @@ export default new Action({
       }
     }
     catch (error) {
-      return {
-        subscribers: [],
-        stats: { total: 0, subscribed: 0, unsubscribed: 0, newThisMonth: 0 },
-        error: error instanceof Error ? error.message : 'Subscribers could not be loaded.',
-      }
+      return dashboardOperationalError(error, 'Subscribers could not be loaded.', 'SubscriberIndexAction')
     }
   },
 })

package/app/Actions/Dashboard/Data/TeamIndexAction.ts

@@ -1,6 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { Team } from '@stacksjs/orm'
 import { safeGet } from '../../../../resources/functions/dashboard/data'
+import { dashboardOperationalError } from '../dashboard-response'
 import { dateValue, daysAgoIso, numberValue, textValue } from './data-records'
 
 export default new Action({
@@ -39,11 +40,7 @@ export default new Action({
       }
     }
     catch (error) {
-      return {
-        teams: [],
-        stats: { total: 0, active: 0, members: 0, newThisMonth: 0 },
-        error: error instanceof Error ? error.message : 'Teams could not be loaded.',
-      }
+      return dashboardOperationalError(error, 'Teams could not be loaded.', 'TeamIndexAction')
     }
   },
 })

package/app/Actions/Dashboard/Data/UserIndexAction.ts

@@ -1,6 +1,7 @@
 import { Action } from '@stacksjs/actions'
 import { User } from '@stacksjs/orm'
 import { safeGet } from '../../../../resources/functions/dashboard/data'
+import { dashboardOperationalError } from '../dashboard-response'
 import { dateValue, daysAgoIso, numberValue, textValue } from './data-records'
 
 export default new Action({
@@ -36,11 +37,7 @@ export default new Action({
       }
     }
     catch (error) {
-      return {
-        users: [],
-        stats: { total: 0, newThisWeek: 0, verified: 0 },
-        error: error instanceof Error ? error.message : 'Users could not be loaded.',
-      }
+      return dashboardOperationalError(error, 'Users could not be loaded.', 'UserIndexAction')
     }
   },
 })

package/app/Actions/Dashboard/Deployments/CreateDeployment.ts

@@ -4,6 +4,7 @@ import { join } from 'node:path'
 import process from 'node:process'
 import { Deployment } from '@stacksjs/orm'
 import { response } from '@stacksjs/router'
+import { dashboardOperationalError, dashboardOperationalIssue } from '../dashboard-response'
 import { booleanValue, deploymentCommandArgs } from './deployment-input'
 
 function gitValue(args: string[]): string {
@@ -63,10 +64,7 @@ export default new Action({
         })
       }
       catch (error) {
-        return response.json({
-          success: false,
-          message: error instanceof Error ? error.message : 'Deployment record could not be created.',
-        }, { status: 500 })
+        return dashboardOperationalError(error, 'Deployment record could not be created.', 'CreateDeployment.record', 500)
       }
     }
 
@@ -81,27 +79,33 @@ export default new Action({
     }
     catch (error) {
       if (deployment) {
-        await deployment.update({
-          status: 'failed',
-          duration: 0,
-          errorLog: error instanceof Error ? error.message : String(error),
-        })
+        try {
+          await deployment.update({
+            status: 'failed',
+            duration: 0,
+            errorLog: 'Deployment process could not be started.',
+          })
+        }
+        catch (updateError) {
+          dashboardOperationalIssue(updateError, 'Deployment failure status could not be recorded.', 'CreateDeployment.failureRecord')
+        }
       }
-      return response.json({
-        success: false,
-        message: error instanceof Error ? error.message : 'Deployment process could not be started.',
-      }, { status: 500 })
+      return dashboardOperationalError(error, 'Deployment process could not be started.', 'CreateDeployment.process', 500)
     }
 
     if (deployment) {
       const record = deployment
-      void child.exited.then(async (exitCode) => {
-        await record.update({
-          status: exitCode === 0 ? 'success' : 'failed',
-          duration: Math.max(0, Math.round((Date.now() - startedAt) / 1000)),
-          errorLog: exitCode === 0 ? '' : `buddy deploy exited with code ${exitCode}`,
+      void child.exited
+        .then(async (exitCode) => {
+          await record.update({
+            status: exitCode === 0 ? 'success' : 'failed',
+            duration: Math.max(0, Math.round((Date.now() - startedAt) / 1000)),
+            errorLog: exitCode === 0 ? '' : `buddy deploy exited with code ${exitCode}`,
+          })
+        })
+        .catch((error) => {
+          dashboardOperationalIssue(error, 'Deployment completion could not be recorded.', 'CreateDeployment.completionRecord')
         })
-      })
     }
 
     return {

package/app/Actions/Dashboard/Deployments/GetAverageDeploymentTime.ts

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { Deployment } from '@stacksjs/orm'
+import { dashboardOperationalError } from '../dashboard-response'
 import { averageRecordedDuration } from './deployment-input'
 
 export default new Action({
@@ -9,7 +10,12 @@ export default new Action({
   apiResponse: true,
 
   async handle() {
-    const deployments = await Deployment.all()
-    return { average_seconds: averageRecordedDuration(deployments) }
+    try {
+      const deployments = await Deployment.all()
+      return { average_seconds: averageRecordedDuration(deployments) }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Average deployment time could not be loaded.', 'GetAverageDeploymentTime')
+    }
   },
 })