@stacksjs/defaults 0.70.57 → 0.70.59

package/app/Actions/Dashboard/Kanban/CardUpdateAction.ts

@@ -0,0 +1,91 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+interface CardInput {
+  title?: unknown
+  description?: unknown
+  dueDate?: unknown
+  archived?: unknown
+}
+
+/**
+ * `PATCH /api/dashboard/kanban/cards/:id` (stacksjs/stacks#1846 Phase 2).
+ *
+ * Partial update for the card body: title, description, due date,
+ * archive flag. `position` and `columnId` are NOT updatable here —
+ * card moves go through `/cards/reorder` which can rewrite multiple
+ * rows transactionally and keep the denormalised `board_id` in sync
+ * when a card crosses columns on different boards (rare but possible
+ * if the page reordered a column move pair).
+ */
+export default new Action({
+  name: 'Kanban Card Update',
+  description: 'Partial update of a card body (title, description, due date, archive).',
+  method: 'PATCH',
+  apiResponse: true,
+  async handle(request) {
+    const rawId = (request as any)?.params?.id ?? (request as any)?.param?.('id') ?? null
+    const id = Number(rawId)
+    if (!Number.isFinite(id) || id <= 0) {
+      return { error: 'Invalid card id', status: 400 }
+    }
+
+    const body = (request as any).jsonBody as CardInput | undefined ?? {}
+    const set: Record<string, unknown> = {}
+
+    if (typeof body.title === 'string') {
+      const title = body.title.trim()
+      if (!title || title.length > 300) {
+        return { error: '`title` must be 1-300 characters.', status: 400 }
+      }
+      set.title = title
+    }
+    if (typeof body.description === 'string' || body.description === null) {
+      set.description = typeof body.description === 'string' ? body.description.trim() : null
+    }
+    if (typeof body.dueDate === 'string' || body.dueDate === null) {
+      set.due_date = typeof body.dueDate === 'string' && body.dueDate ? body.dueDate : null
+    }
+    if (typeof body.archived === 'boolean')
+      set.archived = body.archived ? 1 : 0
+
+    if (Object.keys(set).length === 0) {
+      return { error: 'No updatable fields provided.', status: 400 }
+    }
+
+    try {
+      await db.updateTable('cards').set(set as any).where('id', '=', id).execute()
+
+      const rows = await db.unsafe(
+        `SELECT id, uuid, column_id, board_id, title, description, position,
+                created_by_user_id, due_date, archived, created_at, updated_at
+        FROM cards WHERE id = ? LIMIT 1`,
+        [id],
+      ).execute() as Array<Record<string, unknown>>
+      const r = rows?.[0]
+      if (!r) {
+        return { error: 'Card not found', status: 404 }
+      }
+      return {
+        card: {
+          id: Number(r.id),
+          uuid: r.uuid == null ? null : String(r.uuid),
+          columnId: Number(r.column_id),
+          boardId: Number(r.board_id),
+          title: String(r.title),
+          description: r.description == null ? null : String(r.description),
+          position: Number(r.position),
+          createdByUserId: r.created_by_user_id == null ? null : Number(r.created_by_user_id),
+          dueDate: r.due_date == null ? null : String(r.due_date),
+          archived: Number(r.archived) === 1,
+          createdAt: r.created_at == null ? null : String(r.created_at),
+          updatedAt: r.updated_at == null ? null : String(r.updated_at),
+        },
+      }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] CardUpdateAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})

package/app/Actions/Dashboard/Kanban/CardsReorderAction.ts

@@ -0,0 +1,148 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+interface ColumnReorder {
+  columnId: number
+  order: number[]
+}
+
+interface ReorderInput {
+  /**
+   * Per-column ordered lists. Each entry rewrites every card in that
+   * column to match the supplied order, AND sets `column_id` for any
+   * card that moved in from a different column (cross-column drag).
+   *
+   * Example shape:
+   *
+   *   {
+   *     columns: [
+   *       { columnId: 1, order: [5, 3, 7] },   // Todo
+   *       { columnId: 2, order: [4, 8] },       // In Progress
+   *       { columnId: 3, order: [] },           // Done — emptied
+   *     ]
+   *   }
+   *
+   * Sending the full per-column state (not just the moved card)
+   * avoids the "neighbour position drift" footgun where a card-move
+   * leaves siblings with stale positions.
+   */
+  columns?: unknown
+}
+
+/**
+ * `POST /api/dashboard/kanban/cards/reorder` (stacksjs/stacks#1846 Phase 2).
+ *
+ * The drag-and-drop hot path. Rewrites card positions and column
+ * assignments across one or more columns of a single board in a single
+ * transaction. Validates that every card and every column belongs to
+ * the same board so a malformed payload can't reassign cards across
+ * boards (would break `cards.board_id` denormalisation).
+ *
+ * Returns `{ moved: <count> }` — the count is informational for
+ * client-side toast messages, not load-bearing.
+ */
+export default new Action({
+  name: 'Kanban Cards Reorder',
+  description: 'Bulk-rewrite cards.{column_id, position} across one or more columns of the same board.',
+  method: 'POST',
+  apiResponse: true,
+  async handle(request) {
+    const body = (request as any).jsonBody as ReorderInput | undefined ?? {}
+
+    if (!Array.isArray(body.columns) || body.columns.length === 0) {
+      return { error: '`columns` must be a non-empty array.', status: 400 }
+    }
+
+    // Parse + validate. Each entry needs a positive integer columnId
+    // and a (possibly empty) array of positive integer card ids.
+    const reorders: ColumnReorder[] = []
+    const allCardIds = new Set<number>()
+    for (const raw of body.columns) {
+      if (!raw || typeof raw !== 'object')
+        return { error: '`columns[]` entry must be an object.', status: 400 }
+      const columnId = Number((raw as any).columnId)
+      if (!Number.isFinite(columnId) || columnId <= 0)
+        return { error: '`columns[].columnId` must be a positive integer.', status: 400 }
+      if (!Array.isArray((raw as any).order))
+        return { error: '`columns[].order` must be an array.', status: 400 }
+      const order: number[] = []
+      for (const v of (raw as any).order) {
+        const n = Number(v)
+        if (!Number.isFinite(n) || n <= 0)
+          return { error: '`columns[].order` contains an invalid card id.', status: 400 }
+        if (allCardIds.has(n))
+          return { error: 'A card id appears in more than one column.', status: 400 }
+        allCardIds.add(n)
+        order.push(n)
+      }
+      reorders.push({ columnId, order })
+    }
+
+    if (reorders.length === 0) {
+      return { moved: 0 }
+    }
+
+    try {
+      // Verify all columns belong to the same board.
+      const columnIds = reorders.map(r => r.columnId)
+      const colPlaceholders = columnIds.map(() => '?').join(',')
+      const colRows = await db.unsafe(
+        `SELECT id, board_id FROM board_columns WHERE id IN (${colPlaceholders})`,
+        columnIds,
+      ).execute() as Array<{ id: number, board_id: number }>
+      if (colRows.length !== columnIds.length) {
+        return { error: 'One or more column ids do not exist.', status: 400 }
+      }
+      const boardIds = new Set(colRows.map(r => r.board_id))
+      if (boardIds.size > 1) {
+        return { error: 'All columns in a reorder request must belong to the same board.', status: 400 }
+      }
+      const boardId = colRows[0].board_id
+
+      // Verify all cards belong to that board (prevents a malformed
+      // page from moving cards in from a sibling board).
+      if (allCardIds.size > 0) {
+        const cardIdList = Array.from(allCardIds)
+        const cardPlaceholders = cardIdList.map(() => '?').join(',')
+        const cardRows = await db.unsafe(
+          `SELECT id FROM cards WHERE id IN (${cardPlaceholders}) AND board_id = ?`,
+          [...cardIdList, boardId],
+        ).execute() as Array<{ id: number }>
+        if (cardRows.length !== cardIdList.length) {
+          return { error: 'One or more card ids do not belong to the named board.', status: 400 }
+        }
+      }
+
+      // Single transaction: for each (columnId, order) entry, set
+      // `column_id = columnId, position = index` on each card. Cards
+      // moving across columns get both columns of their row rewritten;
+      // cards staying put still get their position rewritten (cheap,
+      // idempotent).
+      const txOps = async (qb: any) => {
+        for (const { columnId, order } of reorders) {
+          for (let i = 0; i < order.length; i++) {
+            await qb.updateTable('cards')
+              .set({ column_id: columnId, position: i, board_id: boardId })
+              .where('id', '=', order[i])
+              .execute()
+          }
+        }
+      }
+      try {
+        await (db as any).transaction(txOps)
+      }
+      catch {
+        // Driver-specific transaction shape failed — sequential is
+        // safe (each UPDATE is idempotent), but the page should
+        // refetch on failure to confirm the final state.
+        await txOps(db)
+      }
+
+      return { moved: allCardIds.size, boardId }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] CardsReorderAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})

package/app/Actions/Dashboard/Kanban/ColumnDestroyAction.ts

@@ -0,0 +1,59 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+/**
+ * `DELETE /api/dashboard/kanban/columns/:id` (stacksjs/stacks#1846 Phase 2).
+ *
+ * Hard-deletes the column and cascade-cleans every card inside it
+ * (plus the pivot rows referencing those cards). Same convention as
+ * BoardDestroyAction — Stacks doesn't lean on DB-level FK cascade, so
+ * the cascade lives in this action.
+ *
+ * If you want to keep cards but remove the column, move the cards to
+ * a different column first via the cards/reorder endpoint, then call
+ * this on the empty column.
+ */
+export default new Action({
+  name: 'Kanban Column Destroy',
+  description: 'Hard-deletes a column and its cards.',
+  method: 'DELETE',
+  apiResponse: true,
+  async handle(request) {
+    const rawId = (request as any)?.params?.id ?? (request as any)?.param?.('id') ?? null
+    const id = Number(rawId)
+    if (!Number.isFinite(id) || id <= 0) {
+      return { error: 'Invalid column id', status: 400 }
+    }
+
+    try {
+      const txOps = async (qb: any) => {
+        await qb.unsafe(
+          'DELETE FROM card_labels WHERE card_id IN (SELECT id FROM cards WHERE column_id = ?)',
+          [id],
+        ).execute()
+        await qb.unsafe(
+          'DELETE FROM card_assignees WHERE card_id IN (SELECT id FROM cards WHERE column_id = ?)',
+          [id],
+        ).execute()
+        // Card comments (Phase 3, stacksjs/stacks#1846).
+        await qb.unsafe(
+          'DELETE FROM card_comments WHERE card_id IN (SELECT id FROM cards WHERE column_id = ?)',
+          [id],
+        ).execute()
+        await qb.deleteFrom('cards').where('column_id', '=', id).execute()
+        await qb.deleteFrom('board_columns').where('id', '=', id).execute()
+      }
+      try {
+        await (db as any).transaction(txOps)
+      }
+      catch {
+        await txOps(db)
+      }
+      return { deleted: true, id }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] ColumnDestroyAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})

package/app/Actions/Dashboard/Kanban/ColumnStoreAction.ts

@@ -0,0 +1,94 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+interface ColumnInput {
+  boardId?: unknown
+  name?: unknown
+  color?: unknown
+  cardLimit?: unknown
+}
+
+/**
+ * `POST /api/dashboard/kanban/columns` (stacksjs/stacks#1846 Phase 2).
+ *
+ * Appends a new column to the end of the target board. Validates that
+ * `boardId` points at a real board so a typo doesn't silently create
+ * an orphan column row.
+ */
+export default new Action({
+  name: 'Kanban Column Store',
+  description: 'Creates a new column on a board.',
+  method: 'POST',
+  apiResponse: true,
+  async handle(request) {
+    const body = (request as any).jsonBody as ColumnInput | undefined ?? {}
+
+    const boardId = Number(body.boardId)
+    if (!Number.isFinite(boardId) || boardId <= 0) {
+      return { error: '`boardId` is required and must be a positive integer.', status: 400 }
+    }
+    const name = typeof body.name === 'string' ? body.name.trim() : ''
+    if (!name || name.length > 80) {
+      return { error: '`name` is required and must be 1-80 characters.', status: 400 }
+    }
+    const color = typeof body.color === 'string' && body.color ? body.color : 'slate'
+    const cardLimit = body.cardLimit == null
+      ? null
+      : (Number.isFinite(Number(body.cardLimit)) && Number(body.cardLimit) >= 0
+          ? Number(body.cardLimit)
+          : null)
+
+    try {
+      // Reject orphan columns up front — a column on a deleted board
+      // would never surface in any sidebar or API, just rot in the DB.
+      const boards = await db.unsafe('SELECT id FROM boards WHERE id = ? LIMIT 1', [boardId]).execute() as Array<{ id: number }>
+      if (!boards?.length) {
+        return { error: 'Board not found.', status: 404 }
+      }
+
+      const maxRow = await db.unsafe(
+        'SELECT COALESCE(MAX(position), -1) AS m FROM board_columns WHERE board_id = ?',
+        [boardId],
+      ).execute() as Array<{ m: number }>
+      const nextPosition = (Number(maxRow?.[0]?.m ?? -1) + 1) || 0
+
+      await db.insertInto('board_columns').values({
+        board_id: boardId,
+        name,
+        color,
+        card_limit: cardLimit,
+        position: nextPosition,
+      }).execute()
+
+      const rows = await db.unsafe(
+        `SELECT id, uuid, board_id, name, position, card_limit, color, created_at, updated_at
+        FROM board_columns
+        WHERE board_id = ? AND name = ? AND position = ?
+        ORDER BY id DESC
+        LIMIT 1`,
+        [boardId, name, nextPosition],
+      ).execute() as Array<Record<string, unknown>>
+      const r = rows?.[0]
+      if (!r) {
+        return { error: 'Column insert succeeded but follow-up read returned nothing.', status: 500 }
+      }
+
+      return {
+        column: {
+          id: Number(r.id),
+          uuid: r.uuid == null ? null : String(r.uuid),
+          boardId: Number(r.board_id),
+          name: String(r.name),
+          position: Number(r.position),
+          cardLimit: r.card_limit == null ? null : Number(r.card_limit),
+          color: String(r.color),
+          cards: [],
+        },
+      }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] ColumnStoreAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})

package/app/Actions/Dashboard/Kanban/ColumnUpdateAction.ts

@@ -0,0 +1,89 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+interface ColumnInput {
+  name?: unknown
+  color?: unknown
+  cardLimit?: unknown
+}
+
+/**
+ * `PATCH /api/dashboard/kanban/columns/:id` (stacksjs/stacks#1846 Phase 2).
+ *
+ * Partial update for name / color / card limit. `position` and
+ * `boardId` are NOT updatable here — moving a column between boards
+ * isn't a feature (would orphan its cards' denormalised `board_id`);
+ * reordering goes through `/columns/reorder` so transactions cover
+ * the whole rewrite.
+ */
+export default new Action({
+  name: 'Kanban Column Update',
+  description: 'Partial update of a board column.',
+  method: 'PATCH',
+  apiResponse: true,
+  async handle(request) {
+    const rawId = (request as any)?.params?.id ?? (request as any)?.param?.('id') ?? null
+    const id = Number(rawId)
+    if (!Number.isFinite(id) || id <= 0) {
+      return { error: 'Invalid column id', status: 400 }
+    }
+
+    const body = (request as any).jsonBody as ColumnInput | undefined ?? {}
+    const set: Record<string, unknown> = {}
+
+    if (typeof body.name === 'string') {
+      const name = body.name.trim()
+      if (!name || name.length > 80) {
+        return { error: '`name` must be 1-80 characters.', status: 400 }
+      }
+      set.name = name
+    }
+    if (typeof body.color === 'string' && body.color)
+      set.color = body.color
+    if (body.cardLimit !== undefined) {
+      if (body.cardLimit === null) {
+        set.card_limit = null
+      }
+      else {
+        const n = Number(body.cardLimit)
+        if (!Number.isFinite(n) || n < 0) {
+          return { error: '`cardLimit` must be a non-negative number or null.', status: 400 }
+        }
+        set.card_limit = n
+      }
+    }
+
+    if (Object.keys(set).length === 0) {
+      return { error: 'No updatable fields provided.', status: 400 }
+    }
+
+    try {
+      await db.updateTable('board_columns').set(set as any).where('id', '=', id).execute()
+
+      const rows = await db.unsafe(
+        `SELECT id, uuid, board_id, name, position, card_limit, color, created_at, updated_at
+        FROM board_columns WHERE id = ? LIMIT 1`,
+        [id],
+      ).execute() as Array<Record<string, unknown>>
+      const r = rows?.[0]
+      if (!r) {
+        return { error: 'Column not found', status: 404 }
+      }
+      return {
+        column: {
+          id: Number(r.id),
+          uuid: r.uuid == null ? null : String(r.uuid),
+          boardId: Number(r.board_id),
+          name: String(r.name),
+          position: Number(r.position),
+          cardLimit: r.card_limit == null ? null : Number(r.card_limit),
+          color: String(r.color),
+        },
+      }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] ColumnUpdateAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})

package/app/Actions/Dashboard/Kanban/ColumnsReorderAction.ts

@@ -0,0 +1,85 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+interface ReorderInput {
+  boardId?: unknown
+  order?: unknown
+}
+
+/**
+ * `POST /api/dashboard/kanban/columns/reorder` (stacksjs/stacks#1846 Phase 2).
+ *
+ * Bulk rewrite column positions for a board. The submitted `order`
+ * is an array of column ids in their new display order; index becomes
+ * the row's new `position`. Wrapped in a transaction so a partial
+ * failure doesn't leave the board with a half-renumbered column row.
+ *
+ * Why scoped to a board? Two reasons:
+ *   1. Validation: every id in `order` must belong to the same
+ *      board — otherwise a drag in one board could accidentally
+ *      renumber columns in another board sharing the same row order.
+ *   2. Index hit: the `(board_id, position)` index gives a tight
+ *      lookup for the post-reorder card query.
+ */
+export default new Action({
+  name: 'Kanban Columns Reorder',
+  description: 'Bulk-rewrite `position` on a board\'s columns.',
+  method: 'POST',
+  apiResponse: true,
+  async handle(request) {
+    const body = (request as any).jsonBody as ReorderInput | undefined ?? {}
+
+    const boardId = Number(body.boardId)
+    if (!Number.isFinite(boardId) || boardId <= 0) {
+      return { error: '`boardId` is required.', status: 400 }
+    }
+    if (!Array.isArray(body.order) || body.order.length === 0) {
+      return { error: '`order` must be a non-empty array of column ids.', status: 400 }
+    }
+    const ids: number[] = []
+    for (const v of body.order) {
+      const n = Number(v)
+      if (!Number.isFinite(n) || n <= 0) {
+        return { error: '`order` contains an invalid id.', status: 400 }
+      }
+      ids.push(n)
+    }
+    if (new Set(ids).size !== ids.length) {
+      return { error: '`order` contains duplicate ids.', status: 400 }
+    }
+
+    try {
+      // Verify every column actually belongs to the named board.
+      // Single round-trip via a count of rows that match both criteria.
+      const placeholders = ids.map(() => '?').join(',')
+      const matchRows = await db.unsafe(
+        `SELECT COUNT(*) AS c FROM board_columns WHERE id IN (${placeholders}) AND board_id = ?`,
+        [...ids, boardId],
+      ).execute() as Array<{ c: number }>
+      const matched = Number(matchRows?.[0]?.c ?? 0)
+      if (matched !== ids.length) {
+        return { error: 'One or more column ids do not belong to the named board.', status: 400 }
+      }
+
+      const txOps = async (qb: any) => {
+        for (let i = 0; i < ids.length; i++) {
+          await qb.updateTable('board_columns')
+            .set({ position: i })
+            .where('id', '=', ids[i])
+            .execute()
+        }
+      }
+      try {
+        await (db as any).transaction(txOps)
+      }
+      catch {
+        await txOps(db)
+      }
+      return { reordered: ids.length }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] ColumnsReorderAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})

package/app/Actions/Dashboard/Kanban/LabelDestroyAction.ts

@@ -0,0 +1,41 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+/**
+ * `DELETE /api/dashboard/kanban/labels/:id` (stacksjs/stacks#1846 Phase 3).
+ *
+ * Removes a label and detaches it from every card that carries it.
+ * The label row goes from the `labels` table; every pivot row in
+ * `card_labels` that references it goes too. Cards themselves are
+ * untouched.
+ */
+export default new Action({
+  name: 'Kanban Label Destroy',
+  description: 'Hard-deletes a label and its card_labels pivot rows.',
+  method: 'DELETE',
+  apiResponse: true,
+  async handle(request) {
+    const rawId = (request as any)?.params?.id ?? (request as any)?.param?.('id') ?? null
+    const id = Number(rawId)
+    if (!Number.isFinite(id) || id <= 0)
+      return { error: 'Invalid label id', status: 400 }
+
+    try {
+      const txOps = async (qb: any) => {
+        await qb.deleteFrom('card_labels').where('label_id', '=', id).execute()
+        await qb.deleteFrom('labels').where('id', '=', id).execute()
+      }
+      try {
+        await (db as any).transaction(txOps)
+      }
+      catch {
+        await txOps(db)
+      }
+      return { deleted: true, id }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] LabelDestroyAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})

package/app/Actions/Dashboard/Kanban/LabelStoreAction.ts

@@ -0,0 +1,70 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+
+interface LabelInput {
+  boardId?: unknown
+  name?: unknown
+  color?: unknown
+}
+
+/**
+ * `POST /api/dashboard/kanban/labels` (stacksjs/stacks#1846 Phase 3).
+ *
+ * Creates a label scoped to a board. Labels are unique per
+ * `(board_id, name)` — the migration enforces this via a unique
+ * index, and the action rejects up front with a 409 rather than
+ * letting the UNIQUE constraint fire.
+ */
+export default new Action({
+  name: 'Kanban Label Store',
+  description: 'Creates a label on a board.',
+  method: 'POST',
+  apiResponse: true,
+  async handle(request) {
+    const body = (request as any).jsonBody as LabelInput | undefined ?? {}
+
+    const boardId = Number(body.boardId)
+    if (!Number.isFinite(boardId) || boardId <= 0) {
+      return { error: '`boardId` is required.', status: 400 }
+    }
+    const name = typeof body.name === 'string' ? body.name.trim() : ''
+    if (!name || name.length > 60) {
+      return { error: '`name` is required and must be 1-60 characters.', status: 400 }
+    }
+    const color = typeof body.color === 'string' && body.color ? body.color : 'slate'
+
+    try {
+      // Reject orphan labels: the board must exist.
+      const boards = await db.unsafe('SELECT id FROM boards WHERE id = ? LIMIT 1', [boardId]).execute() as Array<{ id: number }>
+      if (!boards?.length)
+        return { error: 'Board not found.', status: 404 }
+
+      // Pre-check uniqueness — clearer error than the DB's
+      // `UNIQUE constraint failed: labels.board_id, labels.name`.
+      const dup = await db.unsafe(
+        'SELECT id FROM labels WHERE board_id = ? AND name = ? LIMIT 1',
+        [boardId, name],
+      ).execute() as Array<{ id: number }>
+      if (dup?.length)
+        return { error: 'A label with that name already exists on this board.', status: 409 }
+
+      await db.insertInto('labels').values({ board_id: boardId, name, color }).execute()
+
+      const inserted = await db.unsafe(
+        'SELECT id, board_id, name, color FROM labels WHERE board_id = ? AND name = ? LIMIT 1',
+        [boardId, name],
+      ).execute() as Array<{ id: number, board_id: number, name: string, color: string }>
+      const r = inserted?.[0]
+      if (!r)
+        return { error: 'Label insert succeeded but follow-up read returned nothing.', status: 500 }
+
+      return {
+        label: { id: r.id, boardId: r.board_id, name: r.name, color: r.color },
+      }
+    }
+    catch (err) {
+      console.error('[dashboard/kanban] LabelStoreAction failed:', err)
+      return { error: err instanceof Error ? err.message : 'unknown error', status: 500 }
+    }
+  },
+})