@stacksjs/defaults 0.70.356 → 0.70.357

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)
+    }
   },
 })

package/app/Actions/Dashboard/Content/PageUpdateAction.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 { findRow, rowExists, rowId, timestamp } from './content-input'
 import { parsePageInput, parsePublished } from './page-input'
 
@@ -15,32 +17,48 @@ 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)
-
     const input = parsePageInput(request)
 
     if ('message' in input)
       return response.json({ message: input.message }, 422)
 
-    const current = await db
-      .selectFrom('pages')
-      .select(['published_at'])
-      .where('id', '=', id)
-      .executeTakeFirst()
-    const published = parsePublished(request.get('published'))
-
-    await db
-      .updateTable('pages')
-      .set({
-        title: input.data.title,
-        template: input.data.template,
-        published_at: published ? current?.published_at || timestamp() : null,
-        updated_at: timestamp(),
-      } as any)
-      .where('id', '=', id)
-      .execute()
-
-    return response.json(await findRow('pages', id))
+    try {
+      const page = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        if (!await rowExists('pages', id, trx))
+          return null
+
+        const current = await trx
+          .selectFrom('pages')
+          .select(['published_at'])
+          .where('id', '=', id)
+          .executeTakeFirst()
+        const published = parsePublished(request.get('published'))
+
+        await trx
+          .updateTable('pages')
+          .set({
+            title: input.data.title,
+            template: input.data.template,
+            published_at: published ? current?.published_at || timestamp() : null,
+            updated_at: timestamp(),
+          } as any)
+          .where('id', '=', id)
+          .execute()
+
+        const updated = await findRow('pages', id, trx)
+        if (!updated)
+          throw new Error('Updated page could not be loaded.')
+        return updated
+      })
+
+      if (!page)
+        return response.json({ message: 'Page not found.' }, 404)
+
+      return response.json(page)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Page could not be updated.', 'PageUpdateAction', 500)
+    }
   },
 })

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

@@ -1,12 +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 { detachPostRelations } from './post-input'
 
 /**
  * `DELETE /api/dashboard/posts/{id}` — deletes a CMS post from the dashboard.
  *
- * Detaches the native category and tag relations before removing the post so
- * no pivot rows are orphaned.
+ * Detaches the model-declared category and tag pivots before removing the post,
+ * with all three writes committed by the same transaction.
  */
 export default new Action({
   name: 'PostDestroyAction',
@@ -18,17 +22,26 @@ export default new Action({
     if (!Number.isInteger(id) || id <= 0)
       return response.json({ message: 'A valid post id is required.' }, 422)
 
-    const post = await Post.find(id)
+    try {
+      const deleted = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        const post = await trx.selectFrom('posts').select(['id']).where('id', '=', id).executeTakeFirst()
 
-    if (!post)
-      return response.json({ message: 'Post not found.' }, 404)
+        if (!post)
+          return false
 
-    await Promise.all([
-      post.categories().detach(),
-      post.tags().detach(),
-    ])
-    await post.delete()
+        await detachPostRelations(trx, id)
+        await trx.deleteFrom('posts').where('id', '=', id).execute()
+        return true
+      })
 
-    return response.json({ message: 'Post deleted.', id })
+      if (!deleted)
+        return response.json({ message: 'Post not found.' }, 404)
+
+      return response.json({ message: 'Post deleted.', id })
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Post could not be deleted.', 'PostDestroyAction', 500)
+    }
   },
 })

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

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 interface PostRow {
   id: number
@@ -55,8 +56,8 @@ function counts(posts: Array<{ status: string }>) {
  * `GET /api/dashboard/posts` — backs `views/dashboard/content/posts/index.stx`.
  *
  * Uses one bounded query per persisted dataset and groups pivot ids in maps,
- * avoiding relation N+1 queries while still keeping all writes on the native
- * model relations.
+ * avoiding relation N+1 queries. Writes use the same model-declared pivots on
+ * one native database transaction.
  *
  * There is deliberately no mock-data fallback. This action used to catch every
  * error and serve placeholder rows, which made a page that was 404ing against
@@ -69,56 +70,61 @@ export default new Action({
   method: 'GET',
   apiResponse: true,
   async handle() {
-    const rows = await db
-      .selectFrom('posts')
-      .selectAll()
-      .orderBy('created_at', 'desc')
-      .execute() as unknown as PostRow[]
+    try {
+      const rows = await db
+        .selectFrom('posts')
+        .selectAll()
+        .orderBy('created_at', 'desc')
+        .execute() as unknown as PostRow[]
 
-    const posts = rows.map(row => ({
-      id: Number(row.id),
-      title: String(row.title || ''),
-      excerpt: String(row.excerpt || ''),
-      content: String(row.content || ''),
-      poster: String(row.poster || ''),
-      status: normalizeStatus(row.status),
-      views: Number(row.views || 0),
-      published_at: row.published_at || null,
-      created_at: row.created_at || null,
-      updated_at: row.updated_at || null,
-      author_id: row.author_id ?? null,
-      featured: Boolean(row.is_featured),
-    }))
+      const posts = rows.map(row => ({
+        id: Number(row.id),
+        title: String(row.title || ''),
+        excerpt: String(row.excerpt || ''),
+        content: String(row.content || ''),
+        poster: String(row.poster || ''),
+        status: normalizeStatus(row.status),
+        views: Number(row.views || 0),
+        published_at: row.published_at || null,
+        created_at: row.created_at || null,
+        updated_at: row.updated_at || null,
+        author_id: row.author_id ?? null,
+        featured: Boolean(row.is_featured),
+      }))
 
-    const postIds = posts.map(post => post.id)
-    const [categories, tags, authors, categoryRelations, tagRelations] = await Promise.all([
-      db.selectFrom('categories').select(['id', 'name', 'slug']).orderBy('name').execute(),
-      db.selectFrom('tags').select(['id', 'name', 'slug']).orderBy('name').execute(),
-      db.selectFrom('authors').select(['id', 'name', 'email']).orderBy('name').execute(),
-      postIds.length
-        ? db.selectFrom('categorizable_models')
-            .whereIn('categorizable_id', postIds)
-            .where('categorizable_type', '=', 'posts')
-            .select(['category_id as relatedId', 'categorizable_id as postId'])
-            .execute() as unknown as Promise<PivotRow[]>
-        : Promise.resolve([]),
-      postIds.length
-        ? db.selectFrom('taggable_models')
-            .whereIn('taggable_id', postIds)
-            .where('taggable_type', '=', 'posts')
-            .select(['tag_id as relatedId', 'taggable_id as postId'])
-            .execute() as unknown as Promise<PivotRow[]>
-        : Promise.resolve([]),
-    ])
+      const postIds = posts.map(post => post.id)
+      const [categories, tags, authors, categoryRelations, tagRelations] = await Promise.all([
+        db.selectFrom('categories').select(['id', 'name', 'slug']).orderBy('name').execute(),
+        db.selectFrom('tags').select(['id', 'name', 'slug']).orderBy('name').execute(),
+        db.selectFrom('authors').select(['id', 'name', 'email']).orderBy('name').execute(),
+        postIds.length
+          ? db.selectFrom('categorizable_models')
+              .whereIn('categorizable_id', postIds)
+              .where('categorizable_type', '=', 'posts')
+              .select(['category_id as relatedId', 'categorizable_id as postId'])
+              .execute() as unknown as Promise<PivotRow[]>
+          : Promise.resolve([]),
+        postIds.length
+          ? db.selectFrom('taggable_models')
+              .whereIn('taggable_id', postIds)
+              .where('taggable_type', '=', 'posts')
+              .select(['tag_id as relatedId', 'taggable_id as postId'])
+              .execute() as unknown as Promise<PivotRow[]>
+          : Promise.resolve([]),
+      ])
 
-    const categoryIdsByPost = relatedIdsByPost(categoryRelations)
-    const tagIdsByPost = relatedIdsByPost(tagRelations)
-    const withRelations = posts.map(post => ({
-      ...post,
-      categoryIds: categoryIdsByPost.get(post.id) || [],
-      tagIds: tagIdsByPost.get(post.id) || [],
-    }))
+      const categoryIdsByPost = relatedIdsByPost(categoryRelations)
+      const tagIdsByPost = relatedIdsByPost(tagRelations)
+      const withRelations = posts.map(post => ({
+        ...post,
+        categoryIds: categoryIdsByPost.get(post.id) || [],
+        tagIds: tagIdsByPost.get(post.id) || [],
+      }))
 
-    return { posts: withRelations, categories, tags, authors, ...counts(posts) }
+      return { posts: withRelations, categories, tags, authors, ...counts(posts) }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Posts could not be loaded.', 'PostIndexAction')
+    }
   },
 })