@stacksjs/defaults 0.70.356 → 0.70.358

package/ai/skills/stacks-browse/SKILL.md

@@ -100,13 +100,17 @@ Extracts headings, links (`text -> href`), buttons, forms (action + field count)
 ```bash
 bun storage/framework/defaults/ai/skills/stacks-browse/scripts/browse.ts scenario <url> \
   --step '{"action":"click","selector":"button[data-open]"}' \
+  --step '{"action":"focus","selector":"input[name=name]"}' \
   --step '{"action":"fill","selector":"input[name=name]","value":"Example"}' \
   --step '{"action":"click","selector":"button[type=submit]"}' \
   --step '{"action":"assert","selector":"main","text":"Saved"}' \
+  --step '{"action":"assert","selector":"[role=dialog]","absent":true}' \
   --out storage/framework/runtime/shots/scenario.png
 ```
 
-Steps run in order within one isolated browser page, preserving reactive STX state and SPA navigation. Supported actions are `click`, `fill`, `press`, `wait`, and `assert`. Each step is a JSON object passed through a repeatable `--step` flag. A click step may include `text` to select the matching control from its CSS selector. The command reports every completed step, the final URL and page text, console exceptions, failed requests, and an optional screenshot. It exits nonzero when the scenario assertion, browser console, or network fails.
+Steps run in order within one isolated browser page, preserving reactive STX state and SPA navigation. Supported actions are `click`, `fill`, `focus`, `press`, `wait`, and `assert`. Each step is a JSON object passed through a repeatable `--step` flag. Click and focus steps may include `text` to select the matching control from their CSS selector. The command reports every completed step, the final URL and page text, console messages, console exceptions, failed requests, and an optional screenshot. It exits nonzero when the scenario assertion, browser console, or network fails.
+Use `{"action":"assert","selector":"...","absent":true}` to verify that an element is missing or hidden after an interaction.
+Use `{"action":"assert","selector":"button","text":"Save","focused":true}` to verify keyboard focus and focus restoration.
 
 ### Crawl (whole-site browser audit)
 ```bash

package/ai/skills/stacks-browse/scripts/browse.ts

@@ -497,12 +497,14 @@ function parseViewport(value: string | undefined): { w: number, h: number } {
   return { w, h }
 }
 
-type ScenarioAction = 'assert' | 'click' | 'fill' | 'press' | 'wait'
+type ScenarioAction = 'assert' | 'click' | 'fill' | 'focus' | 'press' | 'wait'
 
 interface ScenarioStep {
   action: ScenarioAction
   selector?: string
   text?: string
+  absent?: boolean
+  focused?: boolean
   value?: string
   key?: string
   ms?: number
@@ -522,14 +524,18 @@ function parseScenarioStep(value: string): ScenarioStep {
     throw new TypeError('Each scenario step must be a JSON object.')
 
   const step = parsed as Record<string, unknown>
-  if (!['assert', 'click', 'fill', 'press', 'wait'].includes(String(step.action)))
+  if (!['assert', 'click', 'fill', 'focus', 'press', 'wait'].includes(String(step.action)))
     throw new TypeError(`Unsupported scenario action: ${String(step.action)}`)
 
   const action = step.action as ScenarioAction
-  if (['assert', 'click', 'fill'].includes(action) && typeof step.selector !== 'string')
+  if (['assert', 'click', 'fill', 'focus'].includes(action) && typeof step.selector !== 'string')
     throw new TypeError(`Scenario action "${action}" requires a selector.`)
   if (action === 'fill' && typeof step.value !== 'string')
     throw new TypeError('Scenario action "fill" requires a string value.')
+  if (step.absent !== undefined && (action !== 'assert' || typeof step.absent !== 'boolean'))
+    throw new TypeError('Scenario "absent" is a boolean supported only by assert actions.')
+  if (step.focused !== undefined && (action !== 'assert' || typeof step.focused !== 'boolean'))
+    throw new TypeError('Scenario "focused" is a boolean supported only by assert actions.')
   if (action === 'press' && typeof step.key !== 'string')
     throw new TypeError('Scenario action "press" requires a key.')
   if (action === 'wait' && (!Number.isFinite(step.ms) || Number(step.ms) < 0 || Number(step.ms) > 30_000))
@@ -557,23 +563,36 @@ async function runScenarioStep(cdp: Cdp, step: ScenarioStep): Promise<Record<str
       const step = ${JSON.stringify(step)}
       const candidates = Array.from(document.querySelectorAll(step.selector))
       const normalizedText = (element) => (element.innerText || element.textContent || '').replace(/\\s+/g, ' ').trim()
-      const element = step.action === 'click' && step.text !== undefined
+      const element = (step.action === 'click' || step.action === 'focus' || step.action === 'assert') && step.text !== undefined
         ? candidates.find(candidate => normalizedText(candidate) === step.text)
           || candidates.find(candidate => normalizedText(candidate).includes(step.text))
         : candidates[0]
+      if (!element && step.action === 'assert' && step.absent)
+        return { ok: true, action: step.action, selector: step.selector, absent: true }
       if (!element)
         return { ok: false, error: 'Element not found', selector: step.selector }
 
       const rect = element.getBoundingClientRect()
       const style = getComputedStyle(element)
       const visible = rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none'
+      if (step.action === 'assert' && step.absent) {
+        if (visible)
+          return { ok: false, error: 'Expected element to be absent', selector: step.selector }
+        return { ok: true, action: step.action, selector: step.selector, absent: true }
+      }
       if (!visible)
         return { ok: false, error: 'Element is not visible', selector: step.selector }
 
       if (step.action === 'click') {
         if (element.disabled || element.getAttribute('aria-disabled') === 'true')
           return { ok: false, error: 'Element is disabled', selector: step.selector }
-        element.click()
+      }
+      else if (step.action === 'focus') {
+        if (typeof element.focus !== 'function')
+          return { ok: false, error: 'Element cannot receive focus', selector: step.selector }
+        element.focus()
+        if (document.activeElement !== element)
+          return { ok: false, error: 'Element did not receive focus', selector: step.selector }
       }
       else if (step.action === 'fill') {
         if (!('value' in element))
@@ -593,12 +612,19 @@ async function runScenarioStep(cdp: Cdp, step: ScenarioStep): Promise<Record<str
           return { ok: false, error: 'Expected text was not found', selector: step.selector, expected: step.text, actual: content.slice(0, 240) }
       }
 
+      if (step.action === 'assert' && step.focused !== undefined) {
+        const focused = document.activeElement === element
+        if (focused !== step.focused)
+          return { ok: false, error: step.focused ? 'Expected element to be focused' : 'Expected element not to be focused', selector: step.selector }
+      }
+
       return {
         ok: true,
         action: step.action,
         selector: step.selector,
         tag: element.tagName.toLowerCase(),
         text: normalizedText(element).slice(0, 160),
+        clickPoint: step.action === 'click' ? { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 } : undefined,
       }
     })()`,
     returnByValue: true,
@@ -606,6 +632,12 @@ async function runScenarioStep(cdp: Cdp, step: ScenarioStep): Promise<Record<str
   const value = result.result?.value as Record<string, unknown> | undefined
   if (!value?.ok)
     throw new Error(`Scenario ${step.action} failed: ${String(value?.error || 'unknown error')} (${step.selector || step.key || ''})`)
+  if (step.action === 'click') {
+    const point = value.clickPoint as { x: number, y: number }
+    await cdp.send('Input.dispatchMouseEvent', { type: 'mousePressed', x: point.x, y: point.y, button: 'left', clickCount: 1 })
+    await cdp.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: point.x, y: point.y, button: 'left', clickCount: 1 })
+    delete value.clickPoint
+  }
   return value
 }
 
@@ -741,6 +773,20 @@ async function main() {
       const viewport = parseViewport(typeof flags.viewport === 'string' ? flags.viewport : undefined)
       const state = await gotoAndInstrument(cdp, url, { viewport, cookies, settleMs, scheme })
       const results: Record<string, unknown>[] = []
+      await cdp.send('Page.bringToFront')
+      await cdp.send('Runtime.evaluate', {
+        expression: `(() => {
+          window.__browseFocusHistory = []
+          const describe = (element) => element ? {
+            tag: element.tagName?.toLowerCase() || null,
+            role: element.getAttribute?.('role') || null,
+            ariaLabel: element.getAttribute?.('aria-label') || null,
+            text: (element.innerText || element.textContent || '').replace(/\\s+/g, ' ').trim().slice(0, 80),
+          } : null
+          document.addEventListener('focusin', event => window.__browseFocusHistory.push({ event: 'focusin', target: describe(event.target) }), true)
+          document.addEventListener('focusout', event => window.__browseFocusHistory.push({ event: 'focusout', target: describe(event.target), related: describe(event.relatedTarget) }), true)
+        })()`,
+      })
 
       for (const step of steps) {
         results.push(await runScenarioStep(cdp, step))
@@ -752,7 +798,15 @@ async function main() {
         expression: `({
           url: location.href,
           title: document.title,
-          activeElement: document.activeElement?.tagName?.toLowerCase() || null,
+          focusHistory: window.__browseFocusHistory || [],
+          activeElement: document.activeElement ? {
+            tag: document.activeElement.tagName?.toLowerCase() || null,
+            id: document.activeElement.id || null,
+            role: document.activeElement.getAttribute?.('role') || null,
+            ariaLabel: document.activeElement.getAttribute?.('aria-label') || null,
+            ref: document.activeElement.getAttribute?.('data-stx-ref') || null,
+            text: (document.activeElement.innerText || document.activeElement.textContent || '').replace(/\\s+/g, ' ').trim().slice(0, 120),
+          } : null,
           bodyText: (document.body.innerText || '').replace(/\\s+/g, ' ').trim().slice(0, 500),
         })`,
         returnByValue: true,
@@ -770,6 +824,7 @@ async function main() {
         steps: results,
         final: finalState.result?.value,
         screenshot,
+        consoleMessages: state.console,
         consoleErrors: state.consoleErrors,
         failedRequests,
       }, null, 2))

package/ai/skills/stacks-orm/SKILL.md

@@ -196,6 +196,12 @@ await createUser('Alice', 'alice@example.com') // auto-wrapped
 
 Both `transaction()` and `savepoint()` delegate to `db.transaction()` and `db.savepoint()` from `@stacksjs/database`.
 
+### Transaction executor boundary
+
+Every query that must commit or roll back together must use the callback handle (`tx` or `sp`), including validation reads, pivot writes, and the final readback. Do not mix `Model.find()`, `Model.create()`, instance `update()` / `delete()`, or instance relation calls into a raw query-builder transaction. The model executor is a separate execution surface and is not rebound to the callback handle. On SQLite it may use a separate connection, so it cannot observe an uncommitted row written through `tx`.
+
+`runInTransactionScope()` buffers supported side effects until commit, but it does not rebind model queries. For a transaction-backed custom action, use the model definition as the schema and relationship source of truth, then execute the complete persistence workflow through `tx`. Read the created or updated row through `tx` before returning so a readback failure also rolls back the mutation.
+
 ## Trait Methods (traits/)
 
 ### Taggable (when `traits.taggable: true`)

package/app/Actions/Dashboard/Actions/GetActions.ts

@@ -1,22 +1,28 @@
 import { Action } from '@stacksjs/actions'
 import process from 'node:process'
 import { discoverActionSources } from '../Source/source-inventory'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'GetActions',
   description: 'Lists application and framework Actions from their native source files.',
   method: 'GET',
   async handle() {
-    const items = await discoverActionSources(process.cwd())
+    try {
+      const items = await discoverActionSources(process.cwd())
 
-    return {
-      items,
-      stats: {
-        total: items.length,
-        application: items.filter(item => item.origin === 'Application').length,
-        framework: items.filter(item => item.origin === 'Framework').length,
-        writes: items.filter(item => !['ANY', 'GET', 'HEAD', 'OPTIONS'].includes(item.method || 'ANY')).length,
-      },
+      return {
+        items,
+        stats: {
+          total: items.length,
+          application: items.filter(item => item.origin === 'Application').length,
+          framework: items.filter(item => item.origin === 'Framework').length,
+          writes: items.filter(item => !['ANY', 'GET', 'HEAD', 'OPTIONS'].includes(item.method || 'ANY')).length,
+        },
+      }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Action sources could not be loaded.', 'GetActions')
     }
   },
 })

package/app/Actions/Dashboard/Analytics/EventStoreAction.ts

@@ -1,7 +1,8 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
-import { AnalyticsEvent } from '@stacksjs/orm'
+import { AnalyticsEvent, ModelValidationError } from '@stacksjs/orm'
 import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
 
 function token(value: unknown, fallback: string): string {
   const normalized = String(value || '')
@@ -46,14 +47,25 @@ export default new Action({
     if (properties.length > 10_000)
       return response.json({ message: 'Properties must be 10,000 characters or fewer.' }, 422)
 
-    await AnalyticsEvent.create({
-      name,
-      category,
-      path,
-      value,
-      currency,
-      properties,
-    })
+    try {
+      await AnalyticsEvent.create({
+        name,
+        category,
+        path,
+        value,
+        currency,
+        properties,
+      })
+    }
+    catch (error) {
+      if (error instanceof ModelValidationError) {
+        return response.json({
+          message: 'Validation failed.',
+          errors: error.errors,
+        }, 422)
+      }
+      return dashboardOperationalError(error, 'Analytics event could not be recorded.', 'EventStoreAction', 500)
+    }
 
     return response.json({ success: true }, 201)
   },

package/app/Actions/Dashboard/Commerce/ProductUnitDefaultAction.ts

@@ -2,6 +2,7 @@ import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { products } from '@stacksjs/commerce'
 import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'ProductUnitDefaultAction',
@@ -11,11 +12,19 @@ export default new Action({
 
   async handle(request: RequestInstance) {
     const id = Number(request.getParam('id'))
+    if (!Number.isSafeInteger(id) || id <= 0)
+      return response.json({ error: 'A valid product unit id is required.' }, 400)
+    if (typeof request.get('isDefault') !== 'boolean')
+      return response.json({ error: 'isDefault must be a boolean.' }, 422)
     const isDefault = request.boolean('isDefault')
-    if (!Number.isFinite(id) || id <= 0)
-      return response.notFound({ error: 'Product unit not found' })
 
-    const updated = await products.units.updateDefaultStatus(id, isDefault)
+    let updated
+    try {
+      updated = await products.units.updateDefaultStatus(id, isDefault)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Product unit default could not be updated.', 'ProductUnitDefaultAction', 500)
+    }
     if (!updated)
       return response.notFound({ error: 'Product unit not found' })
 

package/app/Actions/Dashboard/Commerce/TaxRateDefaultAction.ts

@@ -2,6 +2,7 @@ import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { tax } from '@stacksjs/commerce'
 import { response } from '@stacksjs/router'
+import { dashboardOperationalError } from '../dashboard-response'
 
 export default new Action({
   name: 'TaxRateDefaultAction',
@@ -11,11 +12,19 @@ export default new Action({
 
   async handle(request: RequestInstance) {
     const id = Number(request.getParam('id'))
+    if (!Number.isSafeInteger(id) || id <= 0)
+      return response.json({ error: 'A valid tax rate id is required.' }, 400)
+    if (typeof request.get('isDefault') !== 'boolean')
+      return response.json({ error: 'isDefault must be a boolean.' }, 422)
     const isDefault = request.boolean('isDefault')
-    if (!Number.isFinite(id) || id <= 0)
-      return response.notFound({ error: 'Tax rate not found' })
 
-    const updated = await tax.updateDefaultStatus(id, isDefault)
+    let updated
+    try {
+      updated = await tax.updateDefaultStatus(id, isDefault)
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Tax rate default could not be updated.', 'TaxRateDefaultAction', 500)
+    }
     if (!updated)
       return response.notFound({ error: 'Tax rate not found' })
 

package/app/Actions/Dashboard/Content/AuthorDestroyAction.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, timestamp } from './content-input'
 
 /**
@@ -22,17 +24,29 @@ export default new Action({
     if (!id)
       return response.json({ message: 'A valid author id is required.' }, 422)
 
-    if (!await rowExists('authors', id))
-      return response.json({ message: 'Author not found.' }, 404)
+    try {
+      const deleted = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        if (!await rowExists('authors', id, trx))
+          return false
 
-    await db
-      .updateTable('posts')
-      .set({ author_id: null, updated_at: timestamp() } as any)
-      .where('author_id', '=', id)
-      .execute()
+        await trx
+          .updateTable('posts')
+          .set({ author_id: null, updated_at: timestamp() } as any)
+          .where('author_id', '=', id)
+          .execute()
 
-    await db.deleteFrom('authors').where('id', '=', id).execute()
+        await trx.deleteFrom('authors').where('id', '=', id).execute()
+        return true
+      })
 
-    return response.json({ message: 'Author deleted.', id })
+      if (!deleted)
+        return response.json({ message: 'Author not found.' }, 404)
+
+      return response.json({ message: 'Author deleted.', id })
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Author could not be deleted.', 'AuthorDestroyAction', 500)
+    }
   },
 })

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

@@ -1,5 +1,6 @@
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
+import { dashboardOperationalError } from '../dashboard-response'
 
 interface AuthorRow {
   id: number
@@ -30,36 +31,41 @@ export default new Action({
   method: 'GET',
   apiResponse: true,
   async handle() {
-    const [rows, postAuthors] = await Promise.all([
-      db.selectFrom('authors').selectAll().orderBy('created_at', 'desc').execute() as unknown as Promise<AuthorRow[]>,
-      db.selectFrom('posts').select(['author_id']).execute() as unknown as Promise<Array<{ author_id: number | null }>>,
-    ])
+    try {
+      const [rows, postAuthors] = await Promise.all([
+        db.selectFrom('authors').selectAll().orderBy('created_at', 'desc').execute() as unknown as Promise<AuthorRow[]>,
+        db.selectFrom('posts').select(['author_id']).execute() as unknown as Promise<Array<{ author_id: number | null }>>,
+      ])
 
-    const postCounts = new Map<number, number>()
-    for (const post of postAuthors) {
-      if (post.author_id == null)
-        continue
+      const postCounts = new Map<number, number>()
+      for (const post of postAuthors) {
+        if (post.author_id == null)
+          continue
 
-      const id = Number(post.author_id)
-      postCounts.set(id, (postCounts.get(id) || 0) + 1)
-    }
+        const id = Number(post.author_id)
+        postCounts.set(id, (postCounts.get(id) || 0) + 1)
+      }
 
-    const authors = rows.map(row => ({
-      id: Number(row.id),
-      name: String(row.name || ''),
-      email: String(row.email || ''),
-      bio: String(row.bio || ''),
-      avatar: String(row.avatar || ''),
-      postCount: postCounts.get(Number(row.id)) || 0,
-      created_at: row.created_at || null,
-      updated_at: row.updated_at || null,
-    }))
+      const authors = rows.map(row => ({
+        id: Number(row.id),
+        name: String(row.name || ''),
+        email: String(row.email || ''),
+        bio: String(row.bio || ''),
+        avatar: String(row.avatar || ''),
+        postCount: postCounts.get(Number(row.id)) || 0,
+        created_at: row.created_at || null,
+        updated_at: row.updated_at || null,
+      }))
 
-    // Posts whose author no longer exists are not counted: the stat means
-    // "posts reachable from this list", which is what the page's Assigned Posts
-    // tile claims to show.
-    const assignedPostCount = authors.reduce((sum, author) => sum + author.postCount, 0)
+      // Posts whose author no longer exists are not counted: the stat means
+      // "posts reachable from this list", which is what the page's Assigned Posts
+      // tile claims to show.
+      const assignedPostCount = authors.reduce((sum, author) => sum + author.postCount, 0)
 
-    return { authors, assignedPostCount }
+      return { authors, assignedPostCount }
+    }
+    catch (error) {
+      return dashboardOperationalError(error, 'Authors could not be loaded.', 'AuthorIndexAction')
+    }
   },
 })

package/app/Actions/Dashboard/Content/AuthorStoreAction.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 { parseAuthorInput } from './author-input'
 import { findRow, insertedId, timestamp } from './content-input'
 
@@ -25,35 +27,53 @@ export default new Action({
     if ('message' in input)
       return response.json({ message: input.message }, 422)
 
-    const duplicate = await db
-      .selectFrom('authors')
-      .select(['id'])
-      .where('email', '=', input.data.email)
-      .executeTakeFirst()
+    try {
+      const author = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        const duplicate = await trx
+          .selectFrom('authors')
+          .select(['id'])
+          .where('email', '=', input.data.email)
+          .executeTakeFirst()
 
-    if (duplicate)
-      return response.json({ message: 'An author with that email already exists.' }, 422)
+        if (duplicate)
+          return null
 
-    const now = timestamp()
+        const now = timestamp()
 
-    const result = await db
-      .insertInto('authors')
-      .values({
-        uuid: randomUUIDv7(),
-        name: input.data.name,
-        email: input.data.email,
-        bio: input.data.bio || null,
-        avatar: input.data.avatar || null,
-        created_at: now,
-        updated_at: now,
-      } as any)
-      .executeTakeFirst()
+        const result = await trx
+          .insertInto('authors')
+          .values({
+            uuid: randomUUIDv7(),
+            name: input.data.name,
+            email: input.data.email,
+            bio: input.data.bio || null,
+            avatar: input.data.avatar || 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 author.' }, 500)
+        if (!id)
+          throw new Error('Author insert did not return an id.')
 
-    return response.json(await findRow('authors', id), 201)
+        const created = await findRow('authors', id, trx)
+        if (!created)
+          throw new Error('Created author could not be loaded.')
+        return created
+      })
+
+      if (!author)
+        return response.json({ message: 'An author with that email already exists.' }, 422)
+
+      return response.json(author, 201)
+    }
+    catch (error) {
+      if (isUniqueViolation(error))
+        return response.json({ message: 'An author with that email already exists.' }, 422)
+      return dashboardOperationalError(error, 'Author could not be created.', 'AuthorStoreAction', 500)
+    }
   },
 })

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

@@ -1,7 +1,9 @@
 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 { dashboardOperationalError } from '../dashboard-response'
 import { parseAuthorInput } from './author-input'
 import { findRow, rowExists, rowId, timestamp } from './content-input'
 
@@ -15,36 +17,56 @@ export default new Action({
     if (!id)
       return response.json({ message: 'A valid author id is required.' }, 422)
 
-    if (!await rowExists('authors', id))
-      return response.json({ message: 'Author not found.' }, 404)
-
     const input = parseAuthorInput(request)
 
     if ('message' in input)
       return response.json({ message: input.message }, 422)
 
-    const duplicate = await db
-      .selectFrom('authors')
-      .select(['id'])
-      .where('email', '=', input.data.email)
-      .where('id', '!=', id)
-      .executeTakeFirst()
-
-    if (duplicate)
-      return response.json({ message: 'An author with that email already exists.' }, 422)
-
-    await db
-      .updateTable('authors')
-      .set({
-        name: input.data.name,
-        email: input.data.email,
-        bio: input.data.bio || null,
-        avatar: input.data.avatar || null,
-        updated_at: timestamp(),
-      } as any)
-      .where('id', '=', id)
-      .execute()
-
-    return response.json(await findRow('authors', id))
+    try {
+      const result = await transaction(async (rawTrx) => {
+        const trx = rawTrx as unknown as typeof db
+        if (!await rowExists('authors', id, trx))
+          return { kind: 'not-found' } as const
+
+        const duplicate = await trx
+          .selectFrom('authors')
+          .select(['id'])
+          .where('email', '=', input.data.email)
+          .where('id', '!=', id)
+          .executeTakeFirst()
+
+        if (duplicate)
+          return { kind: 'duplicate' } as const
+
+        await trx
+          .updateTable('authors')
+          .set({
+            name: input.data.name,
+            email: input.data.email,
+            bio: input.data.bio || null,
+            avatar: input.data.avatar || null,
+            updated_at: timestamp(),
+          } as any)
+          .where('id', '=', id)
+          .execute()
+
+        const author = await findRow('authors', id, trx)
+        if (!author)
+          throw new Error('Updated author could not be loaded.')
+        return { kind: 'updated', author } as const
+      })
+
+      if (result.kind === 'not-found')
+        return response.json({ message: 'Author not found.' }, 404)
+      if (result.kind === 'duplicate')
+        return response.json({ message: 'An author with that email already exists.' }, 422)
+
+      return response.json(result.author)
+    }
+    catch (error) {
+      if (isUniqueViolation(error))
+        return response.json({ message: 'An author with that email already exists.' }, 422)
+      return dashboardOperationalError(error, 'Author could not be updated.', 'AuthorUpdateAction', 500)
+    }
   },
 })