@stacksjs/defaults 0.70.356 → 0.70.357

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

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/ide/vscode/package.json

@@ -2,7 +2,7 @@
   "publisher": "Stacks",
   "name": "vscode-stacks",
   "displayName": "Stacks",
-  "version": "0.70.356",
+  "version": "0.70.357",
   "description": "A modern Stacks development environment.",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/defaults",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.356",
+  "version": "0.70.357",
   "description": "The complete managed Stacks application scaffold, including runtime defaults, AI guidance, editor metadata, and npm-backed project support files.",
   "author": "Chris Breuer",
   "license": "MIT",