@stacksjs/defaults 0.70.356 → 0.70.358

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

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

@@ -1,9 +1,11 @@
 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 { findPost, insertedId, invalidPostContent, invalidPostReference, postPayload, publishedAtFor, timestamp } from './post-input'
+import { dashboardOperationalError } from '../dashboard-response'
+import { findPost, insertedId, invalidPostContent, invalidPostReference, postPayload, publishedAtFor, syncPostRelations, timestamp } from './post-input'
 
 /**
  * `POST /api/dashboard/posts` — creates a CMS post from the dashboard.
@@ -23,45 +25,53 @@ 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 now = timestamp()
+        const now = timestamp()
 
-    const result = await db
-      .insertInto('posts')
-      .values({
-        uuid: randomUUIDv7(),
-        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,
-        views: 0,
-        published_at: publishedAtFor(payload.status, null, now),
-        created_at: now,
-        updated_at: now,
-      } as any)
-      .executeTakeFirst()
+        const insertResult = await trx
+          .insertInto('posts')
+          .values({
+            uuid: randomUUIDv7(),
+            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,
+            views: 0,
+            published_at: publishedAtFor(payload.status, null, now),
+            created_at: now,
+            updated_at: now,
+          } as any)
+          .executeTakeFirst()
 
-    const id = insertedId(result)
+        const id = insertedId(insertResult)
 
-    if (!id)
-      return response.json({ message: 'Could not create post.' }, 500)
+        if (!id)
+          throw new Error('Post insert did not return an id.')
 
-    const post = await Post.find(id)
+        await syncPostRelations(trx, id, payload)
 
-    if (!post)
-      return response.json({ message: 'Created post could not be loaded.' }, 500)
+        const created = await findPost(id, trx)
+        if (!created)
+          throw new Error('Created post could not be read back.')
+        return { kind: 'created', post: created } 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)
 
-    return response.json(await findPost(id), 201)
+      return response.json(result.post, 201)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Post could not be created.', 'PostStoreAction', 500)
+    }
   },
 })

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