@stacksjs/defaults 0.70.88 → 0.70.90

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

@@ -1,41 +1,56 @@
 import { Action } from '@stacksjs/actions'
-import { Comment } from '@stacksjs/orm'
+import { db } from '@stacksjs/database'
+import { normalizeCommentStatus } from './comment-input'
 
+interface CommentRow {
+  id: number
+  author_name: string | null
+  author_email: string | null
+  content: string | null
+  body: string | null
+  post_title: string | null
+  status: string | null
+  is_approved: number | null
+  created_at: string | null
+  updated_at: string | null
+}
+
+/**
+ * `GET /api/dashboard/comments` — backs `views/dashboard/content/comments/index.stx`.
+ *
+ * Reads the `comments` table via `db`. The previous `Comment.orderBy(...)` call
+ * threw on every request (the ORM model exposes no query methods) and the catch
+ * turned that into an empty list, so a broken read looked like a CMS with no
+ * comments. It also mapped `author` / `email` / `ip` / `post_id`, none of which
+ * this table has — the columns are `author_name`, `author_email`, `ip_address`,
+ * and there is no post foreign key, only the denormalized `post_title`.
+ *
+ * Column names are returned as-is; the page normalizes them client-side.
+ */
 export default new Action({
   name: 'CommentIndexAction',
-  description: 'Returns comments data for the dashboard.',
+  description: 'Returns CMS comments for the dashboard.',
   method: 'GET',
+  apiResponse: true,
   async handle() {
-    try {
-      const allComments = await Comment.orderBy('created_at', 'desc').get()
-      const totalCount = await Comment.count()
-
-      const comments = allComments.map(c => ({
-        id: Number(c.get('id')),
-        author: String(c.get('author') || c.get('name') || ''),
-        email: String(c.get('email') || ''),
-        content: String(c.get('content') || c.get('body') || ''),
-        status: String(c.get('status') || 'pending'),
-        date: String(c.get('created_at') || ''),
-        postTitle: String(c.get('post_title') || ''),
-        postId: Number(c.get('post_id') || 0),
-        ip: String(c.get('ip') || ''),
-      }))
+    const rows = await db
+      .selectFrom('comments')
+      .selectAll()
+      .orderBy('created_at', 'desc')
+      .execute() as unknown as CommentRow[]
 
-      const pending = comments.filter(c => c.status === 'pending').length
-      const approved = comments.filter(c => c.status === 'approved').length
-      const spam = comments.filter(c => c.status === 'spam').length
+    const comments = rows.map(row => ({
+      id: Number(row.id),
+      author_name: String(row.author_name || ''),
+      author_email: String(row.author_email || ''),
+      content: String(row.content || row.body || ''),
+      post_title: String(row.post_title || ''),
+      status: normalizeCommentStatus(row.status),
+      is_approved: Boolean(row.is_approved),
+      created_at: row.created_at || null,
+      updated_at: row.updated_at || null,
+    }))
 
-      return {
-        comments,
-        stats: { total: totalCount, pending, approved, spam },
-      }
-    }
-    catch {
-      return {
-        comments: [],
-        stats: { total: 0, pending: 0, approved: 0, spam: 0 },
-      }
-    }
+    return { comments }
   },
 })

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

@@ -0,0 +1,48 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { COMMENT_STATUSES, parseCommentStatus } from './comment-input'
+import { findRow, rowExists, rowId, timestamp } from './content-input'
+
+/**
+ * `PATCH /api/dashboard/comments/{id}` — moderates a comment from the dashboard.
+ *
+ * Status is the only writable field: the page's approve/spam buttons are the
+ * only callers, and comment text belongs to the reader who wrote it.
+ *
+ * `is_approved` is kept in step with `status` so the two never disagree — the
+ * table carries both, and the page falls back to `is_approved` when a row has
+ * no status.
+ */
+export default new Action({
+  name: 'CommentUpdateAction',
+  description: 'Updates a CMS comment status from the dashboard.',
+  method: 'PATCH',
+  async handle(request: RequestInstance) {
+    const id = rowId(request)
+
+    if (!id)
+      return response.json({ message: 'A valid comment id is required.' }, 422)
+
+    const status = parseCommentStatus(request.get('status'))
+
+    if (!status)
+      return response.json({ message: `Status must be one of: ${COMMENT_STATUSES.join(', ')}.` }, 422)
+
+    if (!await rowExists('comments', id))
+      return response.json({ message: 'Comment not found.' }, 404)
+
+    await db
+      .updateTable('comments')
+      .set({
+        status,
+        is_approved: status === 'approved' ? 1 : 0,
+        updated_at: timestamp(),
+      } as any)
+      .where('id', '=', id)
+      .execute()
+
+    return response.json(await findRow('comments', id))
+  },
+})

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

@@ -0,0 +1,25 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { rowExists, rowId } from './content-input'
+
+/** `DELETE /api/dashboard/pages/{id}` — deletes a CMS page from the dashboard. */
+export default new Action({
+  name: 'PageDestroyAction',
+  description: 'Deletes a CMS page from the dashboard.',
+  method: 'DELETE',
+  async handle(request: RequestInstance) {
+    const id = rowId(request)
+
+    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)
+
+    await db.deleteFrom('pages').where('id', '=', id).execute()
+
+    return response.json({ message: 'Page deleted.', id })
+  },
+})

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

@@ -1,25 +1,53 @@
 import { Action } from '@stacksjs/actions'
-import { Page } from '@stacksjs/orm'
+import { db } from '@stacksjs/database'
 
+interface PageRow {
+  id: number
+  title: string | null
+  template: string | null
+  views: number | null
+  conversions: number | null
+  published_at: string | null
+  author_id: number | null
+  created_at: string | null
+  updated_at: string | null
+}
+
+/**
+ * `GET /api/dashboard/pages` — backs `views/dashboard/content/pages/index.stx`.
+ *
+ * Reads the `pages` table via `db`. The previous `Page.orderBy(...)` call threw
+ * on every request (the ORM model exposes no query methods) and the catch
+ * turned that into an empty list, so a broken read looked like a CMS with no
+ * pages. It also mapped `slug` and `status`, which this table does not have —
+ * a page is a title, a template, and its traffic counters.
+ *
+ * Ordered newest-first because the page's Newest tile reads the first row.
+ */
 export default new Action({
   name: 'PageIndexAction',
-  description: 'Returns pages data for the dashboard.',
+  description: 'Returns CMS pages for the dashboard.',
   method: 'GET',
+  apiResponse: true,
   async handle() {
-    try {
-      const allPages = await Page.orderBy('updated_at', 'desc').get()
+    const rows = await db
+      .selectFrom('pages')
+      .selectAll()
+      .orderBy('created_at', 'desc')
+      .execute() as unknown as PageRow[]
 
-      const pages = allPages.map(p => ({
-        title: String(p.get('title') || ''),
-        slug: String(p.get('slug') || ''),
-        status: String(p.get('status') || 'draft'),
-        updated: String(p.get('updated_at') || ''),
-      }))
+    const pages = rows.map(row => ({
+      id: Number(row.id),
+      title: String(row.title || ''),
+      template: String(row.template || 'default'),
+      views: Number(row.views || 0),
+      conversions: Number(row.conversions || 0),
+      published_at: row.published_at || null,
+      author_id: row.author_id ?? null,
+      created_at: row.created_at || null,
+      updated_at: row.updated_at || null,
+    }))
 
-      return { pages }
-    }
-    catch {
-      return { pages: [] }
-    }
+    return { pages }
   },
 })

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

@@ -0,0 +1,49 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { findRow, insertedId, str, timestamp } from './content-input'
+
+/**
+ * `POST /api/dashboard/pages` — creates a CMS page from the dashboard.
+ *
+ * No `uuid` is written: unlike `posts` / `authors` / `tags`, the `pages` table
+ * has no uuid column even though the model declares the `useUuid` trait.
+ *
+ * `published_at` stays null — the dialog has no publish control, and the page's
+ * Published column falls back to `created_at`.
+ */
+export default new Action({
+  name: 'PageStoreAction',
+  description: 'Creates a CMS page from the dashboard.',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const title = str(request.get('title')).trim()
+    const template = str(request.get('template')).trim() || 'default'
+
+    if (!title)
+      return response.json({ message: 'Title is required.' }, 422)
+
+    const now = timestamp()
+
+    const result = await db
+      .insertInto('pages')
+      .values({
+        title,
+        template,
+        views: 0,
+        conversions: 0,
+        published_at: null,
+        created_at: now,
+        updated_at: now,
+      } as any)
+      .executeTakeFirst()
+
+    const id = insertedId(result)
+
+    if (!id)
+      return response.json({ message: 'Could not create page.' }, 500)
+
+    return response.json(await findRow('pages', id), 201)
+  },
+})

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

@@ -0,0 +1,37 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+
+/**
+ * `DELETE /api/dashboard/posts/{id}` — deletes a CMS post from the dashboard.
+ *
+ * A plain row delete: this schema has no `categorizable_models` /
+ * `taggable_models` pivot tables, so there is nothing to cascade to. (The
+ * `@stacksjs/cms` `posts.destroy()` helper assumes those tables exist, which is
+ * why this action talks to `db` directly instead.)
+ */
+export default new Action({
+  name: 'PostDestroyAction',
+  description: 'Deletes a CMS post from the dashboard.',
+  method: 'DELETE',
+  async handle(request: RequestInstance) {
+    const id = Number(request.getParam('id'))
+
+    if (!Number.isInteger(id) || id <= 0)
+      return response.json({ message: 'A valid post id is required.' }, 422)
+
+    const existing = await db
+      .selectFrom('posts')
+      .select(['id'])
+      .where('id', '=', id)
+      .executeTakeFirst()
+
+    if (!existing)
+      return response.json({ message: 'Post not found.' }, 404)
+
+    await db.deleteFrom('posts').where('id', '=', id).execute()
+
+    return response.json({ message: 'Post deleted.', id })
+  },
+})

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

@@ -1,102 +1,83 @@
 import { Action } from '@stacksjs/actions'
-import { Post, Category, Tag } from '@stacksjs/orm'
+import { db } from '@stacksjs/database'
 
-// Mock data used when the ORM is unavailable or has no posts (e.g. dev
-// dashboard with no DB seeded). Shape matches the `BlogPost` interface in
-// storage/framework/defaults/views/dashboard/content/posts/index.stx so
-// the page can hydrate directly from this response.
-const mockPosts = [
-  { id: 1, title: '10 Tips for Better Code Quality', excerpt: 'Improve your code quality with these essential tips.', slug: '10-tips-for-better-code-quality', category: 'Tutorials', tags: ['Coding', 'Best Practices'], author: 'Jane Doe', views: 12450, comments: 78, published: '2023-12-01', status: 'Published', featured: true, poster: 'https://picsum.photos/seed/1/280/160' },
-  { id: 2, title: 'The Future of JavaScript Frameworks', excerpt: 'Exploring what\'s next for JS frameworks.', slug: 'future-of-javascript-frameworks', category: 'Technology', tags: ['JavaScript', 'Frameworks'], author: 'John Smith', views: 9870, comments: 124, published: '2023-11-28', status: 'Published', featured: true, poster: 'https://picsum.photos/seed/2/280/160' },
-  { id: 3, title: 'Getting Started with Vue 3', excerpt: 'A comprehensive guide to Vue 3 composition API.', slug: 'getting-started-with-vue-3', category: 'Tutorials', tags: ['Vue', 'JavaScript'], author: 'Jane Doe', views: 8760, comments: 45, published: '2023-11-25', status: 'Published', featured: false, poster: 'https://picsum.photos/seed/3/280/160' },
-  { id: 4, title: 'Review: Latest MacBook Pro', excerpt: 'In-depth review for developers.', slug: 'review-latest-macbook-pro', category: 'Reviews', tags: ['Hardware', 'Apple'], author: 'Michael Brown', views: 7650, comments: 92, published: '2023-11-20', status: 'Published', featured: false, poster: 'https://picsum.photos/seed/4/280/160' },
-  { id: 5, title: 'Understanding Web Accessibility', excerpt: 'Why accessibility matters and how to implement it.', slug: 'understanding-web-accessibility', category: 'Tutorials', tags: ['Accessibility', 'UX'], author: 'Emily Davis', views: 6540, comments: 31, published: '2023-11-15', status: 'Published', featured: false, poster: 'https://picsum.photos/seed/5/280/160' },
-  { id: 6, title: 'Introduction to TypeScript', excerpt: 'Learn the basics of TypeScript.', slug: 'introduction-to-typescript', category: 'Tutorials', tags: ['TypeScript', 'JavaScript'], author: 'Jane Doe', views: 0, comments: 0, published: '', status: 'Draft', featured: false, poster: 'https://picsum.photos/seed/6/280/160' },
-  { id: 7, title: 'Building a REST API with Node.js', excerpt: 'Step-by-step guide to building REST APIs.', slug: 'building-rest-api-nodejs', category: 'Tutorials', tags: ['Node.js', 'API'], author: 'John Smith', views: 0, comments: 0, published: '', status: 'Draft', featured: false, poster: 'https://picsum.photos/seed/7/280/160' },
-  { id: 8, title: 'The Impact of AI on Software Development', excerpt: 'How AI is changing software development.', slug: 'ai-impact-software-development', category: 'Technology', tags: ['AI', 'Future Tech'], author: 'Michael Brown', views: 5430, comments: 67, published: '2023-11-10', status: 'Published', featured: false, poster: 'https://picsum.photos/seed/8/280/160' },
-]
+interface PostRow {
+  id: number
+  title: string
+  excerpt: string | null
+  content: string | null
+  poster: string | null
+  status: string | null
+  views: number | null
+  published_at: string | null
+  created_at: string | null
+  updated_at: string | null
+  author_id: number | null
+  is_featured: number | null
+}
 
-const mockCategories = [
-  { id: 1, name: 'Tutorials', slug: 'tutorials' },
-  { id: 2, name: 'Technology', slug: 'technology' },
-  { id: 3, name: 'Reviews', slug: 'reviews' },
-]
+// `status` is stored lowercase (the posts table has a CHECK constraint on
+// 'published' | 'draft' | 'archived'), but older rows and hand-written seeds
+// have been seen with 'Draft'/'Published'. Normalize on read so the dashboard
+// filter and badge styling only ever deal with one casing.
+function normalizeStatus(status: string | null): string {
+  const value = String(status || 'draft').toLowerCase()
 
-const mockTags = [
-  { id: 1, name: 'Coding', slug: 'coding' },
-  { id: 2, name: 'JavaScript', slug: 'javascript' },
-  { id: 3, name: 'Vue', slug: 'vue' },
-  { id: 4, name: 'TypeScript', slug: 'typescript' },
-]
+  return value === 'published' || value === 'archived' ? value : 'draft'
+}
 
 function counts(posts: Array<{ status: string }>) {
   return {
-    publishedCount: posts.filter(p => p.status.toLowerCase() === 'published').length,
-    draftCount: posts.filter(p => p.status.toLowerCase() === 'draft').length,
-    scheduledCount: posts.filter(p => p.status.toLowerCase() === 'scheduled').length,
+    publishedCount: posts.filter(p => p.status === 'published').length,
+    draftCount: posts.filter(p => p.status === 'draft').length,
+    archivedCount: posts.filter(p => p.status === 'archived').length,
   }
 }
 
+/**
+ * `GET /api/dashboard/posts` — backs `views/dashboard/content/posts/index.stx`.
+ *
+ * Reads straight from the `posts` table via `db` rather than the ORM model:
+ * `Post` from `@stacksjs/orm` exposes no query methods today, so the previous
+ * `Post.orderBy(...)` call threw on every request.
+ *
+ * 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
+ * an unregistered endpoint look like it was working. A failure here must
+ * surface as a failure.
+ */
 export default new Action({
   name: 'PostIndexAction',
-  description: 'Returns posts data for the dashboard.',
+  description: 'Returns CMS posts for the dashboard.',
   method: 'GET',
+  apiResponse: true,
   async handle() {
-    try {
-      const [allPosts, allCategories, allTags] = await Promise.all([
-        Post.orderBy('created_at', 'desc').get(),
-        Category.all(),
-        Tag.all(),
-      ])
-
-      // Empty result from a real ORM still falls through to mock data so
-      // the dev dashboard always has something to render.
-      if (!allPosts || allPosts.length === 0) {
-        return {
-          posts: mockPosts,
-          categories: mockCategories,
-          tags: mockTags,
-          ...counts(mockPosts),
-        }
-      }
-
-      const posts = allPosts.map((p, idx) => ({
-        id: Number(p.get('id') || idx + 1),
-        title: String(p.get('title') || ''),
-        excerpt: String(p.get('excerpt') || ''),
-        slug: String(p.get('slug') || ''),
-        category: String(p.get('category') || ''),
-        tags: Array.isArray(p.get('tags')) ? p.get('tags') as string[] : [],
-        author: String(p.get('author') || ''),
-        views: Number(p.get('views') || 0),
-        comments: Number(p.get('comments') || 0),
-        published: String(p.get('published_at') || p.get('published') || p.get('created_at') || ''),
-        status: String(p.get('status') || 'Draft'),
-        featured: Boolean(p.get('featured')),
-        poster: String(p.get('poster') || ''),
-      }))
+    const rows = await db
+      .selectFrom('posts')
+      .selectAll()
+      .orderBy('created_at', 'desc')
+      .execute() as unknown as PostRow[]
 
-      const categories = allCategories.map(c => ({
-        id: Number(c.get('id')),
-        name: String(c.get('name') || ''),
-        slug: String(c.get('slug') || ''),
-      }))
+    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 tags = allTags.map(t => ({
-        id: Number(t.get('id')),
-        name: String(t.get('name') || ''),
-        slug: String(t.get('slug') || ''),
-      }))
+    const [categories, tags] = await Promise.all([
+      db.selectFrom('categories').select(['id', 'name', 'slug']).execute(),
+      db.selectFrom('tags').select(['id', 'name', 'slug']).execute(),
+    ])
 
-      return { posts, categories, tags, ...counts(posts) }
-    }
-    catch {
-      return {
-        posts: mockPosts,
-        categories: mockCategories,
-        tags: mockTags,
-        ...counts(mockPosts),
-      }
-    }
+    return { posts, categories, tags, ...counts(posts) }
   },
 })

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

@@ -0,0 +1,50 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { randomUUIDv7 } from 'bun'
+import { findPost, insertedId, postPayload, publishedAtFor, timestamp } from './post-input'
+
+/**
+ * `POST /api/dashboard/posts` — creates a CMS post from the dashboard.
+ *
+ * Deliberately does not reuse `Actions/Cms/PostStoreAction`: that action runs
+ * the `Post` model validation, which rejects the empty `excerpt` / `poster`
+ * that the dashboard dialog legitimately submits for a bare draft.
+ */
+export default new Action({
+  name: 'PostStoreAction',
+  description: 'Creates a CMS post from the dashboard.',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const payload = postPayload(request)
+
+    if (!payload.title)
+      return response.json({ message: 'Title is required.' }, 422)
+
+    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,
+        views: 0,
+        published_at: publishedAtFor(payload.status, null, now),
+        created_at: now,
+        updated_at: now,
+      } as any)
+      .executeTakeFirst()
+
+    const id = insertedId(result)
+
+    if (!id)
+      return response.json({ message: 'Could not create post.' }, 500)
+
+    return response.json(await findPost(id), 201)
+  },
+})

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

@@ -0,0 +1,54 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { findPost, postPayload, publishedAtFor, timestamp } from './post-input'
+
+/**
+ * `PATCH /api/dashboard/posts/{id}` — updates a CMS post from the dashboard.
+ *
+ * The dashboard dialog always submits the full post, so every writable column
+ * is replaced. `published_at` is derived from the incoming status rather than
+ * accepted from the body — see `publishedAtFor`.
+ */
+export default new Action({
+  name: 'PostUpdateAction',
+  description: 'Updates a CMS post from the dashboard.',
+  method: 'PATCH',
+  async handle(request: RequestInstance) {
+    const id = Number(request.getParam('id'))
+
+    if (!Number.isInteger(id) || id <= 0)
+      return response.json({ message: 'A valid post id is required.' }, 422)
+
+    const payload = postPayload(request)
+
+    if (!payload.title)
+      return response.json({ message: 'Title is required.' }, 422)
+
+    const existing = await db
+      .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)
+
+    await db
+      .updateTable('posts')
+      .set({
+        title: payload.title,
+        excerpt: payload.excerpt,
+        content: payload.content,
+        poster: payload.poster,
+        status: payload.status,
+        published_at: publishedAtFor(payload.status, existing.published_at, timestamp()),
+        updated_at: timestamp(),
+      } as any)
+      .where('id', '=', id)
+      .execute()
+
+    return response.json(await findPost(id))
+  },
+})

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

@@ -0,0 +1,30 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { rowExists, rowId } from './content-input'
+
+/**
+ * `DELETE /api/dashboard/tags/{id}` — deletes a CMS tag.
+ *
+ * A plain row delete: this schema has no `taggable_models` pivot table, so
+ * there is nothing to cascade to.
+ */
+export default new Action({
+  name: 'TagDestroyAction',
+  description: 'Deletes a CMS tag from the dashboard.',
+  method: 'DELETE',
+  async handle(request: RequestInstance) {
+    const id = rowId(request)
+
+    if (!id)
+      return response.json({ message: 'A valid tag id is required.' }, 422)
+
+    if (!await rowExists('tags', id))
+      return response.json({ message: 'Tag not found.' }, 404)
+
+    await db.deleteFrom('tags').where('id', '=', id).execute()
+
+    return response.json({ message: 'Tag deleted.', id })
+  },
+})