@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/Content/ContentDashboardAction.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from 'bun:test'
+import { buildContentOverview } from './ContentDashboardAction'
+
+describe('content dashboard overview', () => {
+  test('derives metrics, rankings, drafts, and charts from persisted rows', () => {
+    const overview = buildContentOverview({
+      days: 30,
+      posts: [
+        {
+          id: 1,
+          title: 'Published guide',
+          status: 'published',
+          views: 100,
+          author_id: 1,
+          published_at: '2026-07-10T00:00:00.000Z',
+          created_at: '2026-07-01T00:00:00.000Z',
+          updated_at: '2026-07-11T00:00:00.000Z',
+        },
+        {
+          id: 2,
+          title: 'Working draft',
+          status: 'draft',
+          views: 20,
+          author_id: 1,
+          published_at: null,
+          created_at: '2026-06-20T00:00:00.000Z',
+          updated_at: '2026-07-12T00:00:00.000Z',
+        },
+        {
+          id: 3,
+          title: 'Archived note',
+          status: 'archived',
+          views: 5,
+          author_id: null,
+          published_at: null,
+          created_at: '2026-07-02T00:00:00.000Z',
+          updated_at: null,
+        },
+      ],
+      pages: [
+        {
+          id: 1,
+          title: 'About',
+          views: 50,
+          published_at: '2026-07-03T00:00:00.000Z',
+          created_at: '2026-06-01T00:00:00.000Z',
+        },
+      ],
+      comments: [
+        {
+          id: 1,
+          author_name: 'Reader One',
+          author_email: 'one@example.com',
+          content: 'Useful',
+          post_id: 1,
+          post_title: 'Published guide',
+          status: 'approved',
+          created_at: '2026-07-12T00:00:00.000Z',
+        },
+        {
+          id: 2,
+          author_name: 'Reader Two',
+          author_email: 'two@example.com',
+          content: 'Question',
+          post_id: 1,
+          post_title: 'Published guide',
+          status: 'pending',
+          created_at: '2026-07-13T00:00:00.000Z',
+        },
+        {
+          id: 3,
+          author_name: null,
+          author_email: null,
+          content: 'Draft note',
+          post_id: 2,
+          post_title: 'Working draft',
+          status: 'spam',
+          created_at: '2026-07-11T00:00:00.000Z',
+        },
+      ],
+      categories: [{ id: 10, name: 'Tutorials' }],
+      categoryRelations: [
+        { postId: 1, categoryId: 10 },
+        { postId: 3, categoryId: 10 },
+      ],
+      authors: [{ id: 1, name: 'Ada' }],
+    })
+
+    expect(overview.stats).toEqual({
+      posts: 3,
+      pages: 1,
+      comments: 3,
+      views: 175,
+    })
+    expect(overview.topPosts[0]).toEqual(expect.objectContaining({
+      id: 1,
+      category: 'Tutorials',
+      comments: 2,
+      views: 100,
+    }))
+    expect(overview.drafts).toEqual([
+      expect.objectContaining({
+        id: 2,
+        author: 'Ada',
+        category: 'Uncategorized',
+      }),
+    ])
+    expect(overview.recentComments.map(comment => comment.id)).toEqual([2, 1, 3])
+    expect(overview.charts.views).toEqual({
+      labels: ['Jun 2026', 'Jul 2026'],
+      data: [20, 155],
+    })
+    expect(overview.charts.categories).toEqual({
+      labels: ['Tutorials', 'Uncategorized'],
+      data: [2, 1],
+    })
+  })
+})

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

@@ -1,54 +1,255 @@
+import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
-import { Post, Page, Comment } from '@stacksjs/orm'
+import { db } from '@stacksjs/database'
+
+const ALLOWED_RANGES = new Set([1, 7, 30, 90, 365])
+
+export interface ContentOverviewPostRow {
+  id: number
+  title: string
+  status: string | null
+  views: number | null
+  author_id: number | null
+  published_at: string | null
+  created_at: string
+  updated_at: string | null
+}
+
+export interface ContentOverviewPageRow {
+  id: number
+  title: string
+  views: number | null
+  published_at: string | null
+  created_at: string
+}
+
+export interface ContentOverviewCommentRow {
+  id: number
+  author_name: string | null
+  author_email: string | null
+  content: string | null
+  post_id: number | null
+  post_title: string | null
+  status: string | null
+  created_at: string
+}
+
+export interface ContentOverviewRelationRow {
+  postId: number
+  categoryId: number
+}
+
+interface NamedRow {
+  id: number
+  name: string
+}
+
+interface ContentOverviewInput {
+  posts: ContentOverviewPostRow[]
+  pages: ContentOverviewPageRow[]
+  comments: ContentOverviewCommentRow[]
+  categories: NamedRow[]
+  categoryRelations: ContentOverviewRelationRow[]
+  authors: NamedRow[]
+  days: number
+}
+
+function normalizedStatus(value: string | null): string {
+  const status = String(value || 'draft').toLowerCase()
+  return status === 'published' || status === 'archived' ? status : 'draft'
+}
+
+function monthKey(value: string | null): string | null {
+  if (!value)
+    return null
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime()))
+    return null
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}`
+}
+
+function monthLabel(key: string): string {
+  const [year, month] = key.split('-').map(Number)
+  return new Intl.DateTimeFormat('en-US', {
+    month: 'short',
+    timeZone: 'UTC',
+    year: 'numeric',
+  }).format(new Date(Date.UTC(year || 1970, (month || 1) - 1, 1)))
+}
+
+export function buildContentOverview(input: ContentOverviewInput) {
+  const authors = new Map(input.authors.map(author => [Number(author.id), String(author.name || '')]))
+  const categories = new Map(input.categories.map(category => [Number(category.id), String(category.name || '')]))
+  const categoryIdsByPost = new Map<number, number[]>()
+
+  for (const relation of input.categoryRelations) {
+    const postId = Number(relation.postId)
+    categoryIdsByPost.set(postId, [...(categoryIdsByPost.get(postId) || []), Number(relation.categoryId)])
+  }
+
+  const commentCountsByPost = new Map<number, number>()
+  for (const comment of input.comments) {
+    if (comment.post_id == null)
+      continue
+    const postId = Number(comment.post_id)
+    commentCountsByPost.set(postId, (commentCountsByPost.get(postId) || 0) + 1)
+  }
+
+  const posts = input.posts.map(post => ({
+    ...post,
+    id: Number(post.id),
+    status: normalizedStatus(post.status),
+    views: Number(post.views || 0),
+  }))
+  const pages = input.pages.map(page => ({
+    ...page,
+    id: Number(page.id),
+    views: Number(page.views || 0),
+  }))
+
+  const topPosts = [...posts]
+    .sort((left, right) => right.views - left.views || right.id - left.id)
+    .slice(0, 5)
+    .map(post => ({
+      id: post.id,
+      title: String(post.title || ''),
+      category: categories.get(categoryIdsByPost.get(post.id)?.[0] || 0) || 'Uncategorized',
+      views: post.views,
+      comments: commentCountsByPost.get(post.id) || 0,
+      publishedAt: post.published_at || post.created_at,
+      status: post.status,
+    }))
+
+  const recentComments = [...input.comments]
+    .sort((left, right) => String(right.created_at).localeCompare(String(left.created_at)))
+    .slice(0, 5)
+    .map(comment => ({
+      id: Number(comment.id),
+      author: String(comment.author_name || 'Anonymous'),
+      email: String(comment.author_email || ''),
+      content: String(comment.content || ''),
+      postId: comment.post_id == null ? null : Number(comment.post_id),
+      postTitle: String(comment.post_title || ''),
+      createdAt: String(comment.created_at || ''),
+      status: String(comment.status || 'pending').toLowerCase(),
+    }))
+
+  const drafts = posts
+    .filter(post => post.status === 'draft')
+    .sort((left, right) => String(right.updated_at || right.created_at).localeCompare(String(left.updated_at || left.created_at)))
+    .slice(0, 5)
+    .map(post => ({
+      id: post.id,
+      title: String(post.title || ''),
+      category: categories.get(categoryIdsByPost.get(post.id)?.[0] || 0) || 'Uncategorized',
+      author: authors.get(Number(post.author_id || 0)) || 'Unassigned',
+      updatedAt: post.updated_at || post.created_at,
+    }))
+
+  const viewsByMonth = new Map<string, number>()
+  for (const content of [...posts, ...pages]) {
+    const key = monthKey(content.published_at || content.created_at)
+    if (key)
+      viewsByMonth.set(key, (viewsByMonth.get(key) || 0) + content.views)
+  }
+  const viewKeys = [...viewsByMonth.keys()].sort()
+
+  const categoryCounts = new Map<string, number>()
+  for (const post of posts) {
+    const names = (categoryIdsByPost.get(post.id) || [])
+      .map(categoryId => categories.get(categoryId))
+      .filter((name): name is string => Boolean(name))
+    const resolved = names.length > 0 ? names : ['Uncategorized']
+    for (const name of resolved)
+      categoryCounts.set(name, (categoryCounts.get(name) || 0) + 1)
+  }
+  const categoryRows = [...categoryCounts.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+
+  return {
+    rangeDays: input.days,
+    stats: {
+      posts: posts.length,
+      pages: pages.length,
+      comments: input.comments.length,
+      views: posts.reduce((sum, post) => sum + post.views, 0) + pages.reduce((sum, page) => sum + page.views, 0),
+    },
+    topPosts,
+    recentComments,
+    drafts,
+    charts: {
+      views: {
+        labels: viewKeys.map(monthLabel),
+        data: viewKeys.map(key => viewsByMonth.get(key) || 0),
+      },
+      categories: {
+        labels: categoryRows.map(([name]) => name),
+        data: categoryRows.map(([, count]) => count),
+      },
+    },
+  }
+}
+
+function requestedDays(request: RequestInstance): number {
+  const value = Number(request.get('days') || 30)
+  if (value === 0)
+    return 0
+  return ALLOWED_RANGES.has(value) ? value : 30
+}
+
+function threshold(days: number): string | null {
+  if (days === 0)
+    return null
+  const date = new Date()
+  date.setUTCDate(date.getUTCDate() - days)
+  return date.toISOString()
+}
 
 export default new Action({
   name: 'ContentDashboardAction',
-  description: 'Returns content dashboard overview data.',
+  description: 'Returns persisted CMS overview metrics and recent content.',
   method: 'GET',
-  async handle() {
-    try {
-      const [postCount, pageCount, commentCount, recentPosts, recentComments] = await Promise.all([
-        Post.count(),
-        Page.count(),
-        Comment.count(),
-        Post.orderBy('created_at', 'desc').limit(4).get(),
-        Comment.orderBy('created_at', 'desc').limit(3).get(),
-      ])
-
-      const stats = [
-        { label: 'Total Posts', value: String(postCount), trend: '', up: true },
-        { label: 'Pages', value: String(pageCount), trend: '', up: true },
-        { label: 'Comments', value: String(commentCount), trend: '', up: true },
-        { label: 'Total Views', value: '-', trend: '', up: true },
-      ]
-
-      const topPosts = recentPosts.map(p => ({
-        title: String(p.get('title') || ''),
-        views: Number(p.get('views') || 0),
-        comments: 0,
-        date: String(p.get('created_at') || ''),
-      }))
-
-      const recentCommentsList = recentComments.map(c => ({
-        author: String(c.get('author') || c.get('name') || ''),
-        content: String(c.get('content') || c.get('body') || ''),
-        post: String(c.get('post_title') || ''),
-        time: String(c.get('created_at') || ''),
-      }))
-
-      return { stats, topPosts, recentComments: recentCommentsList }
-    }
-    catch {
-      return {
-        stats: [
-          { label: 'Total Posts', value: '0', trend: '', up: true },
-          { label: 'Pages', value: '0', trend: '', up: true },
-          { label: 'Comments', value: '0', trend: '', up: true },
-          { label: 'Total Views', value: '-', trend: '', up: true },
-        ],
-        topPosts: [],
-        recentComments: [],
-      }
-    }
+  apiResponse: true,
+
+  async handle(request: RequestInstance) {
+    const days = requestedDays(request)
+    const since = threshold(days)
+
+    const postQuery = db
+      .selectFrom('posts')
+      .select(['id', 'title', 'status', 'views', 'author_id', 'published_at', 'created_at', 'updated_at'])
+    const pageQuery = db
+      .selectFrom('pages')
+      .select(['id', 'title', 'views', 'published_at', 'created_at'])
+    const commentQuery = db
+      .selectFrom('comments')
+      .select(['id', 'author_name', 'author_email', 'content', 'post_id', 'post_title', 'status', 'created_at'])
+
+    const [posts, pages, comments, categories, authors] = await Promise.all([
+      (since ? postQuery.where('created_at', '>=', since) : postQuery).execute() as unknown as Promise<ContentOverviewPostRow[]>,
+      (since ? pageQuery.where('created_at', '>=', since) : pageQuery).execute() as unknown as Promise<ContentOverviewPageRow[]>,
+      (since ? commentQuery.where('created_at', '>=', since) : commentQuery).execute() as unknown as Promise<ContentOverviewCommentRow[]>,
+      db.selectFrom('categories').select(['id', 'name']).execute() as unknown as Promise<NamedRow[]>,
+      db.selectFrom('authors').select(['id', 'name']).execute() as unknown as Promise<NamedRow[]>,
+    ])
+
+    const postIds = posts.map(post => Number(post.id))
+    const categoryRelations = postIds.length > 0
+      ? await db
+          .selectFrom('categorizable_models')
+          .whereIn('categorizable_id', postIds)
+          .where('categorizable_type', '=', 'posts')
+          .select(['categorizable_id as postId', 'category_id as categoryId'])
+          .execute() as unknown as ContentOverviewRelationRow[]
+      : []
+
+    return buildContentOverview({
+      posts,
+      pages,
+      comments,
+      categories,
+      categoryRelations,
+      authors,
+      days,
+    })
   },
 })

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

@@ -0,0 +1,24 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { DashboardFileError, deleteDashboardFile } from './file-manager'
+
+export default new Action({
+  name: 'FileDestroyAction',
+  description: 'Deletes a file or directory from a configured storage disk.',
+  method: 'DELETE',
+  async handle(request: RequestInstance) {
+    try {
+      const deleted = await deleteDashboardFile({
+        disk: String(request.get('disk', 'public')),
+        path: request.get('path'),
+      })
+      return response.json(deleted)
+    }
+    catch (error) {
+      if (error instanceof DashboardFileError)
+        return response.json({ message: error.message, fields: error.fields }, error.status)
+      throw error
+    }
+  },
+})

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

@@ -0,0 +1,25 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { createDashboardDirectory, DashboardFileError } from './file-manager'
+
+export default new Action({
+  name: 'FileDirectoryStoreAction',
+  description: 'Creates a directory on a configured storage disk.',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    try {
+      const directory = await createDashboardDirectory({
+        disk: String(request.get('disk', 'public')),
+        path: String(request.get('path', '')),
+        name: request.get('name'),
+      })
+      return response.json(directory, 201)
+    }
+    catch (error) {
+      if (error instanceof DashboardFileError)
+        return response.json({ message: error.message, fields: error.fields }, error.status)
+      throw error
+    }
+  },
+})

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

@@ -1,24 +1,24 @@
+import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { DashboardFileError, getDashboardFileSnapshot, normalizeDashboardFileLimit } from './file-manager'
 
 export default new Action({
   name: 'FileIndexAction',
-  description: 'Returns file/media data for the dashboard.',
+  description: 'Returns real storage data for the dashboard file manager.',
   method: 'GET',
-  async handle() {
-    return {
-      files: [
-        { name: 'images', type: 'folder', items: 247, size: '1.2 GB', modified: '2024-01-10' },
-        { name: 'documents', type: 'folder', items: 89, size: '456 MB', modified: '2024-01-09' },
-        { name: 'videos', type: 'folder', items: 34, size: '4.8 GB', modified: '2024-01-08' },
-        { name: 'hero-banner.png', type: 'image', items: null, size: '2.4 MB', modified: '2024-01-10' },
-        { name: 'style-guide.pdf', type: 'document', items: null, size: '892 KB', modified: '2024-01-07' },
-        { name: 'product-demo.mp4', type: 'video', items: null, size: '124 MB', modified: '2024-01-05' },
-      ],
-      storage: {
-        used: 12.4,
-        total: 50,
-        percentage: 24.8,
-      },
+  apiResponse: true,
+  async handle(request: RequestInstance) {
+    try {
+      return await getDashboardFileSnapshot({
+        disk: request.get('disk', 'public'),
+        maxEntries: normalizeDashboardFileLimit(request.get('limit')),
+      })
+    }
+    catch (error) {
+      if (error instanceof DashboardFileError)
+        return response.json({ message: error.message, fields: error.fields }, error.status)
+      throw error
     }
   },
 })

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

@@ -0,0 +1,42 @@
+import type { RequestInstance } from '@stacksjs/types'
+import type { UploadedFileLike } from '@stacksjs/storage'
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { DashboardFileError, uploadDashboardFiles } from './file-manager'
+
+const MAX_FILES = 20
+const MAX_FILE_BYTES = 10 * 1024 * 1024
+
+export default new Action({
+  name: 'FileUploadAction',
+  description: 'Uploads files to a configured storage disk.',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const multiple = request.getFiles('files')
+    const single = request.file('file')
+    const files = (multiple.length ? multiple : single ? [single] : []) as UploadedFileLike[]
+
+    if (!files.length)
+      return response.json({ message: 'Choose at least one file.', fields: { files: 'Choose at least one file.' } }, 422)
+    if (files.length > MAX_FILES)
+      return response.json({ message: `Upload at most ${MAX_FILES} files at a time.`, fields: { files: `Choose ${MAX_FILES} files or fewer.` } }, 422)
+
+    const oversized = files.find(file => Number((file as UploadedFileLike & { size?: number }).size || 0) > MAX_FILE_BYTES)
+    if (oversized)
+      return response.json({ message: 'Each file must be 10 MB or smaller.', fields: { files: 'A selected file exceeds 10 MB.' } }, 422)
+
+    try {
+      const uploaded = await uploadDashboardFiles({
+        disk: String(request.get('disk', 'public')),
+        path: String(request.get('path', '')),
+        files,
+      })
+      return response.json({ uploaded }, 201)
+    }
+    catch (error) {
+      if (error instanceof DashboardFileError)
+        return response.json({ message: error.message, fields: error.fields }, error.status)
+      throw error
+    }
+  },
+})

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

@@ -2,38 +2,37 @@ 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'
+import { randomUUIDv7 } from 'bun'
+import { findRow, insertedId, timestamp } from './content-input'
+import { parsePageInput, parsePublished } from './page-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`.
+ * New pages are drafts unless the dashboard explicitly submits `published`;
+ * published records receive the same SQL-style timestamp as other CMS writes.
  */
 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'
+    const input = parsePageInput(request)
 
-    if (!title)
-      return response.json({ message: 'Title is required.' }, 422)
+    if ('message' in input)
+      return response.json({ message: input.message }, 422)
 
     const now = timestamp()
 
     const result = await db
       .insertInto('pages')
       .values({
-        title,
-        template,
+        uuid: randomUUIDv7(),
+        title: input.data.title,
+        template: input.data.template,
         views: 0,
         conversions: 0,
-        published_at: null,
+        published_at: parsePublished(request.get('published')) ? now : null,
         created_at: now,
         updated_at: now,
       } as any)

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

@@ -0,0 +1,46 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { findRow, rowExists, rowId, timestamp } from './content-input'
+import { parsePageInput, parsePublished } from './page-input'
+
+export default new Action({
+  name: 'PageUpdateAction',
+  description: 'Updates a CMS page from the dashboard.',
+  method: 'PATCH',
+  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)
+
+    const input = parsePageInput(request)
+
+    if ('message' in input)
+      return response.json({ message: input.message }, 422)
+
+    const current = await db
+      .selectFrom('pages')
+      .select(['published_at'])
+      .where('id', '=', id)
+      .executeTakeFirst()
+    const published = parsePublished(request.get('published'))
+
+    await db
+      .updateTable('pages')
+      .set({
+        title: input.data.title,
+        template: input.data.template,
+        published_at: published ? current?.published_at || timestamp() : null,
+        updated_at: timestamp(),
+      } as any)
+      .where('id', '=', id)
+      .execute()
+
+    return response.json(await findRow('pages', id))
+  },
+})