@stacksjs/defaults 0.70.356 → 0.70.358

package/app/Actions/Dashboard/Content/CategoryDestroyAction.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/categories/{id}` — deletes a CMS category.
  *
- * Detaches related posts through the model relation before removing the
- * category so no pivot rows are orphaned.
+ * Detaches related posts through the model-declared pivot before removing the
+ * category, with both writes committed by the same transaction.
  */
 export default new Action({
   name: 'CategoryDestroyAction',
@@ -19,13 +22,29 @@ export default new Action({
     if (!id)
       return response.json({ message: 'A valid category id is required.' }, 422)
 
-    const category = await Category.find(id)
-    if (!category)
-      return response.json({ message: 'Category not found.' }, 404)
+    try {
+      const deleted = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        const category = await trx.selectFrom('categories').select(['id']).where('id', '=', id).executeTakeFirst()
+        if (!category)
+          return false
 
-    await category.posts().detach()
-    await category.delete()
+        await trx
+          .deleteFrom('categorizable_models')
+          .where('category_id', '=', id)
+          .where('categorizable_type', '=', 'posts')
+          .execute()
+        await trx.deleteFrom('categories').where('id', '=', id).execute()
+        return true
+      })
 
-    return response.json({ message: 'Category deleted.', id })
+      if (!deleted)
+        return response.json({ message: 'Category not found.' }, 404)
+
+      return response.json({ message: 'Category deleted.', id })
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Category could not be deleted.', 'CategoryDestroyAction', 500)
+    }
   },
 })

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

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 interface CategoryRow {
   id: number
@@ -29,22 +30,27 @@ export default new Action({
   method: 'GET',
   apiResponse: true,
   async handle() {
-    const rows = await db
-      .selectFrom('categories')
-      .selectAll()
-      .orderBy('created_at', 'desc')
-      .execute() as unknown as CategoryRow[]
+    try {
+      const rows = await db
+        .selectFrom('categories')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .execute() as unknown as CategoryRow[]
 
-    const categories = rows.map(row => ({
-      id: Number(row.id),
-      name: String(row.name || ''),
-      slug: String(row.slug || ''),
-      description: String(row.description || ''),
-      is_active: row.is_active == null ? true : Boolean(row.is_active),
-      created_at: row.created_at || null,
-      updated_at: row.updated_at || null,
-    }))
+      const categories = rows.map(row => ({
+        id: Number(row.id),
+        name: String(row.name || ''),
+        slug: String(row.slug || ''),
+        description: String(row.description || ''),
+        is_active: row.is_active == null ? true : Boolean(row.is_active),
+        created_at: row.created_at || null,
+        updated_at: row.updated_at || null,
+      }))
 
-    return { categories }
+      return { categories }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Categories could not be loaded.', 'CategoryIndexAction')
+    }
   },
 })

package/app/Actions/Dashboard/Content/CategoryStoreAction.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 { randomUUIDv7 } from 'bun'
+import { dashboardOperationalError } from '../dashboard-response'
 import { findRow, insertedId, slugify, str, timestamp } from './content-input'
 
 /**
@@ -26,40 +28,56 @@ 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('categories')
-      .select(['id'])
-      .where('slug', '=', slug)
-      .executeTakeFirst()
+    try {
+      const category = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        const duplicate = await trx
+          .selectFrom('categories')
+          .select(['id'])
+          .where('slug', '=', slug)
+          .executeTakeFirst()
 
-    if (duplicate)
-      return response.json({ message: 'A category with that slug already exists.' }, 422)
+        if (duplicate)
+          return null
 
-    const now = timestamp()
-    const displayOrder = await db
-      .selectFrom('categories')
-      .select(db.fn.max('display_order').as('max_display_order'))
-      .executeTakeFirst()
+        const now = timestamp()
+        const displayOrder = await trx
+          .selectFrom('categories')
+          .select(db.fn.max('display_order').as('max_display_order'))
+          .executeTakeFirst()
 
-    const result = await db
-      .insertInto('categories')
-      .values({
-        uuid: randomUUIDv7(),
-        name,
-        slug,
-        description,
-        is_active: 1,
-        display_order: Number(displayOrder?.max_display_order || 0) + 1,
-        created_at: now,
-        updated_at: now,
-      } as any)
-      .executeTakeFirst()
+        const result = await trx
+          .insertInto('categories')
+          .values({
+            uuid: randomUUIDv7(),
+            name,
+            slug,
+            description,
+            is_active: 1,
+            display_order: Number(displayOrder?.max_display_order || 0) + 1,
+            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 category.' }, 500)
+        if (!id)
+          throw new Error('Category insert did not return an id.')
 
-    return response.json(await findRow('categories', id), 201)
+        const created = await findRow('categories', id, trx)
+        if (!created)
+          throw new Error('Created category could not be loaded.')
+        return created
+      })
+
+      if (!category)
+        return response.json({ message: 'A category with that slug already exists.' }, 422)
+
+      return response.json(category, 201)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Category could not be created.', 'CategoryStoreAction', 500)
+    }
   },
 })

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

@@ -1,7 +1,9 @@
 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 { rowExists, rowId } from './content-input'
 
 /**
@@ -20,11 +22,22 @@ export default new Action({
     if (!id)
       return response.json({ message: 'A valid comment id is required.' }, 422)
 
-    if (!await rowExists('comments', id))
-      return response.json({ message: 'Comment not found.' }, 404)
+    try {
+      const deleted = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        if (!await rowExists('comments', id, trx))
+          return false
+        await trx.deleteFrom('comments').where('id', '=', id).execute()
+        return true
+      })
 
-    await db.deleteFrom('comments').where('id', '=', id).execute()
+      if (!deleted)
+        return response.json({ message: 'Comment not found.' }, 404)
 
-    return response.json({ message: 'Comment deleted.', id })
+      return response.json({ message: 'Comment deleted.', id })
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Comment could not be deleted.', 'CommentDestroyAction', 500)
+    }
   },
 })

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

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 import { normalizeCommentStatus } from './comment-input'
 
 interface CommentRow {
@@ -33,24 +34,29 @@ export default new Action({
   method: 'GET',
   apiResponse: true,
   async handle() {
-    const rows = await db
-      .selectFrom('comments')
-      .selectAll()
-      .orderBy('created_at', 'desc')
-      .execute() as unknown as CommentRow[]
+    try {
+      const rows = await db
+        .selectFrom('comments')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .execute() as unknown as CommentRow[]
 
-    const comments = rows.map(row => ({
-      id: Number(row.id),
-      author_name: String(row.author_name || ''),
-      author_email: String(row.author_email || ''),
-      content: String(row.content || row.body || ''),
-      post_title: String(row.post_title || ''),
-      status: normalizeCommentStatus(row.status),
-      is_approved: Boolean(row.is_approved),
-      created_at: row.created_at || null,
-      updated_at: row.updated_at || null,
-    }))
+      const comments = rows.map(row => ({
+        id: Number(row.id),
+        author_name: String(row.author_name || ''),
+        author_email: String(row.author_email || ''),
+        content: String(row.content || row.body || ''),
+        post_title: String(row.post_title || ''),
+        status: normalizeCommentStatus(row.status),
+        is_approved: Boolean(row.is_approved),
+        created_at: row.created_at || null,
+        updated_at: row.updated_at || null,
+      }))
 
-    return { comments }
+      return { comments }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Comments could not be loaded.', 'CommentIndexAction')
+    }
   },
 })

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

@@ -1,7 +1,9 @@
 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 { COMMENT_STATUSES, parseCommentStatus } from './comment-input'
 import { findRow, rowExists, rowId, timestamp } from './content-input'
 
@@ -30,19 +32,35 @@ export default new Action({
     if (!status)
       return response.json({ message: `Status must be one of: ${COMMENT_STATUSES.join(', ')}.` }, 422)
 
-    if (!await rowExists('comments', id))
-      return response.json({ message: 'Comment not found.' }, 404)
+    try {
+      const comment = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        if (!await rowExists('comments', id, trx))
+          return null
 
-    await db
-      .updateTable('comments')
-      .set({
-        status,
-        is_approved: status === 'approved' ? 1 : 0,
-        updated_at: timestamp(),
-      } as any)
-      .where('id', '=', id)
-      .execute()
+        await trx
+          .updateTable('comments')
+          .set({
+            status,
+            is_approved: status === 'approved' ? 1 : 0,
+            updated_at: timestamp(),
+          } as any)
+          .where('id', '=', id)
+          .execute()
 
-    return response.json(await findRow('comments', id))
+        const updated = await findRow('comments', id, trx)
+        if (!updated)
+          throw new Error('Updated comment could not be loaded.')
+        return updated
+      })
+
+      if (!comment)
+        return response.json({ message: 'Comment not found.' }, 404)
+
+      return response.json(comment)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Comment could not be updated.', 'CommentUpdateAction', 500)
+    }
   },
 })

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

@@ -1,6 +1,7 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 const ALLOWED_RANGES = new Set([1, 7, 30, 90, 365])
 
@@ -214,42 +215,47 @@ export default new Action({
     const days = requestedDays(request)
     const since = threshold(days)
 
-    const postQuery = db
-      .selectFrom('posts')
-      .select(['id', 'title', 'status', 'views', 'author_id', 'published_at', 'created_at', 'updated_at'])
-    const pageQuery = db
-      .selectFrom('pages')
-      .select(['id', 'title', 'views', 'published_at', 'created_at'])
-    const commentQuery = db
-      .selectFrom('comments')
-      .select(['id', 'author_name', 'author_email', 'content', 'post_id', 'post_title', 'status', 'created_at'])
-
-    const [posts, pages, comments, categories, authors] = await Promise.all([
-      (since ? postQuery.where('created_at', '>=', since) : postQuery).execute() as unknown as Promise<ContentOverviewPostRow[]>,
-      (since ? pageQuery.where('created_at', '>=', since) : pageQuery).execute() as unknown as Promise<ContentOverviewPageRow[]>,
-      (since ? commentQuery.where('created_at', '>=', since) : commentQuery).execute() as unknown as Promise<ContentOverviewCommentRow[]>,
-      db.selectFrom('categories').select(['id', 'name']).execute() as unknown as Promise<NamedRow[]>,
-      db.selectFrom('authors').select(['id', 'name']).execute() as unknown as Promise<NamedRow[]>,
-    ])
-
-    const postIds = posts.map(post => Number(post.id))
-    const categoryRelations = postIds.length > 0
-      ? await db
-          .selectFrom('categorizable_models')
-          .whereIn('categorizable_id', postIds)
-          .where('categorizable_type', '=', 'posts')
-          .select(['categorizable_id as postId', 'category_id as categoryId'])
-          .execute() as unknown as ContentOverviewRelationRow[]
-      : []
-
-    return buildContentOverview({
-      posts,
-      pages,
-      comments,
-      categories,
-      categoryRelations,
-      authors,
-      days,
-    })
+    try {
+      const postQuery = db
+        .selectFrom('posts')
+        .select(['id', 'title', 'status', 'views', 'author_id', 'published_at', 'created_at', 'updated_at'])
+      const pageQuery = db
+        .selectFrom('pages')
+        .select(['id', 'title', 'views', 'published_at', 'created_at'])
+      const commentQuery = db
+        .selectFrom('comments')
+        .select(['id', 'author_name', 'author_email', 'content', 'post_id', 'post_title', 'status', 'created_at'])
+
+      const [posts, pages, comments, categories, authors] = await Promise.all([
+        (since ? postQuery.where('created_at', '>=', since) : postQuery).execute() as unknown as Promise<ContentOverviewPostRow[]>,
+        (since ? pageQuery.where('created_at', '>=', since) : pageQuery).execute() as unknown as Promise<ContentOverviewPageRow[]>,
+        (since ? commentQuery.where('created_at', '>=', since) : commentQuery).execute() as unknown as Promise<ContentOverviewCommentRow[]>,
+        db.selectFrom('categories').select(['id', 'name']).execute() as unknown as Promise<NamedRow[]>,
+        db.selectFrom('authors').select(['id', 'name']).execute() as unknown as Promise<NamedRow[]>,
+      ])
+
+      const postIds = posts.map(post => Number(post.id))
+      const categoryRelations = postIds.length > 0
+        ? await db
+            .selectFrom('categorizable_models')
+            .whereIn('categorizable_id', postIds)
+            .where('categorizable_type', '=', 'posts')
+            .select(['categorizable_id as postId', 'category_id as categoryId'])
+            .execute() as unknown as ContentOverviewRelationRow[]
+        : []
+
+      return buildContentOverview({
+        posts,
+        pages,
+        comments,
+        categories,
+        categoryRelations,
+        authors,
+        days,
+      })
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Content overview could not be loaded.', 'ContentDashboardAction')
+    }
   },
 })

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

@@ -1,7 +1,9 @@
 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 { rowExists, rowId } from './content-input'
 
 /** `DELETE /api/dashboard/pages/{id}` — deletes a CMS page from the dashboard. */
@@ -15,11 +17,22 @@ export default new Action({
     if (!id)
       return response.json({ message: 'A valid page id is required.' }, 422)
 
-    if (!await rowExists('pages', id))
-      return response.json({ message: 'Page not found.' }, 404)
+    try {
+      const deleted = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        if (!await rowExists('pages', id, trx))
+          return false
+        await trx.deleteFrom('pages').where('id', '=', id).execute()
+        return true
+      })
 
-    await db.deleteFrom('pages').where('id', '=', id).execute()
+      if (!deleted)
+        return response.json({ message: 'Page not found.' }, 404)
 
-    return response.json({ message: 'Page deleted.', id })
+      return response.json({ message: 'Page deleted.', id })
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Page could not be deleted.', 'PageDestroyAction', 500)
+    }
   },
 })

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

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 interface PageRow {
   id: number
@@ -30,24 +31,29 @@ export default new Action({
   method: 'GET',
   apiResponse: true,
   async handle() {
-    const rows = await db
-      .selectFrom('pages')
-      .selectAll()
-      .orderBy('created_at', 'desc')
-      .execute() as unknown as PageRow[]
+    try {
+      const rows = await db
+        .selectFrom('pages')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .execute() as unknown as PageRow[]
 
-    const pages = rows.map(row => ({
-      id: Number(row.id),
-      title: String(row.title || ''),
-      template: String(row.template || 'default'),
-      views: Number(row.views || 0),
-      conversions: Number(row.conversions || 0),
-      published_at: row.published_at || null,
-      author_id: row.author_id ?? null,
-      created_at: row.created_at || null,
-      updated_at: row.updated_at || null,
-    }))
+      const pages = rows.map(row => ({
+        id: Number(row.id),
+        title: String(row.title || ''),
+        template: String(row.template || 'default'),
+        views: Number(row.views || 0),
+        conversions: Number(row.conversions || 0),
+        published_at: row.published_at || null,
+        author_id: row.author_id ?? null,
+        created_at: row.created_at || null,
+        updated_at: row.updated_at || null,
+      }))
 
-    return { pages }
+      return { pages }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Pages could not be loaded.', 'PageIndexAction')
+    }
   },
 })

package/app/Actions/Dashboard/Content/PageStoreAction.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 { randomUUIDv7 } from 'bun'
+import { dashboardOperationalError } from '../dashboard-response'
 import { findRow, insertedId, timestamp } from './content-input'
 import { parsePageInput, parsePublished } from './page-input'
 
@@ -22,27 +24,40 @@ export default new Action({
     if ('message' in input)
       return response.json({ message: input.message }, 422)
 
-    const now = timestamp()
+    try {
+      const page = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        const now = timestamp()
 
-    const result = await db
-      .insertInto('pages')
-      .values({
-        uuid: randomUUIDv7(),
-        title: input.data.title,
-        template: input.data.template,
-        views: 0,
-        conversions: 0,
-        published_at: parsePublished(request.get('published')) ? now : null,
-        created_at: now,
-        updated_at: now,
-      } as any)
-      .executeTakeFirst()
+        const result = await trx
+          .insertInto('pages')
+          .values({
+            uuid: randomUUIDv7(),
+            title: input.data.title,
+            template: input.data.template,
+            views: 0,
+            conversions: 0,
+            published_at: parsePublished(request.get('published')) ? now : null,
+            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 page.' }, 500)
+        if (!id)
+          throw new Error('Page insert did not return an id.')
 
-    return response.json(await findRow('pages', id), 201)
+        const created = await findRow('pages', id, trx)
+        if (!created)
+          throw new Error('Created page could not be loaded.')
+        return created
+      })
+
+      return response.json(page, 201)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Page could not be created.', 'PageStoreAction', 500)
+    }
   },
 })