@stacksjs/cms 0.70.53 → 0.70.55

package/src/commentables/fetch.ts

@@ -0,0 +1,319 @@
+import { getDb } from '../database'
+import { formatDate } from '@stacksjs/orm'
+
+export interface Commentable {
+  id?: number
+  title: string
+  body: string
+  status: string
+  approved_at: number | null
+  rejected_at: number | null
+  commentables_id: number
+  commentables_type: string
+  reports_count?: number
+  reported_at?: number | null
+  upvotes_count?: number
+  downvotes_count?: number
+  user_id: number | null
+  created_at?: string
+  updated_at?: string | null
+}
+
+export type CommentStatus = 'approved' | 'pending' | 'spam'
+
+export async function fetchComments(options: {
+  status?: Commentable['status']
+  commentables_id?: number
+  commentables_type?: string
+  limit?: number
+  offset?: number
+} = {}): Promise<Commentable[]> {
+  const db = await getDb()
+  let query = db.selectFrom('commentables') as any
+
+  if (options.status)
+    query = query.where('status', '=', options.status)
+
+  if (options.commentables_id)
+    query = query.where('commentables_id', '=', options.commentables_id)
+
+  if (options.commentables_type)
+    query = query.where('commentables_type', '=', options.commentables_type)
+
+  if (options.limit)
+    query = query.limit(options.limit)
+
+  if (options.offset)
+    query = query.offset(options.offset)
+
+  return query.selectAll().execute() as Promise<Commentable[]>
+}
+
+export async function fetchCommentById(id: number): Promise<Commentable | undefined> {
+  const db = await getDb()
+  return db
+    .selectFrom('commentables')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as unknown as Promise<Commentable | undefined>
+}
+
+export async function fetchCommentsByCommentables(
+  commentables_id: number,
+  commentables_type: string,
+  options: { status?: Commentable['status'], limit?: number, offset?: number } = {},
+): Promise<Commentable[]> {
+  const db = await getDb()
+  let query = db
+    .selectFrom('commentables')
+    .where('commentables_id', '=', commentables_id)
+    .where('commentables_type', '=', commentables_type) as any
+
+  if (options.status)
+    query = query.where('status', '=', options.status)
+
+  if (options.limit)
+    query = query.limit(options.limit)
+
+  if (options.offset)
+    query = query.offset(options.offset)
+
+  return query.selectAll().execute() as Promise<Commentable[]>
+}
+
+/**
+ * Fetch comment counts for different time periods
+ *
+ * @param days The number of days to look back (e.g., 7, 14, 30, 60, 90)
+ * @returns The count of comments within the specified time period
+ */
+export async function fetchCommentCountByPeriod(days: number): Promise<number> {
+  const db = await getDb()
+  try {
+    const result = await db
+      .selectFrom('commentables')
+      .where('created_at', '>=', new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString())
+      .count()
+
+    return Number(result) || 0
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to fetch comment count: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+export async function fetchCommentsByStatus(status: CommentStatus, options: { limit?: number, offset?: number } = {}): Promise<Commentable[]> {
+  const db = await getDb()
+  try {
+    let query = db
+      .selectFrom('commentables')
+      .where('status', '=', status) as any
+
+    if (options.limit)
+      query = query.limit(options.limit)
+
+    if (options.offset)
+      query = query.offset(options.offset)
+
+    return query.selectAll().execute() as Promise<Commentable[]>
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to fetch comments by status: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+export async function calculateApprovalRate(): Promise<{ approved: number, total: number, rate: number }> {
+  const db = await getDb()
+  try {
+    const [approvedCount, totalCount] = await Promise.all([
+      db
+        .selectFrom('commentables')
+        .where('status', '=', 'approved')
+        .count(),
+      db
+        .selectFrom('commentables')
+        .count(),
+    ])
+
+    const approved = Number(approvedCount || 0)
+    const total = Number(totalCount || 0)
+    const rate = total > 0 ? (approved / total) * 100 : 0
+
+    return {
+      approved,
+      total,
+      rate,
+    }
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to calculate approval rate: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+export interface PostWithCommentCount {
+  id: number
+  title: string
+  comment_count: number
+}
+
+export interface DateRange {
+  startDate: Date
+  endDate: Date
+}
+
+export async function fetchPostsWithMostComments(dateRange: DateRange, options: { limit?: number } = {}): Promise<PostWithCommentCount[]> {
+  const db = await getDb()
+  try {
+    let query = db
+      .selectFrom('posts')
+      .leftJoin('commentables', 'posts.id', '=', 'commentables.commentables_id')
+      .where('commentables.created_at', '>=', formatDate(dateRange.startDate))
+      .where('commentables.created_at', '<=', formatDate(dateRange.endDate))
+      .select([
+        'posts.id',
+        'posts.title',
+      ])
+      .groupBy('posts.id', 'posts.title')
+      .orderBy('posts.id', 'desc') as any
+
+    if (options.limit)
+      query = query.limit(options.limit)
+
+    const results = await query.execute()
+
+    return (results as Record<string, unknown>[]).map((row: Record<string, unknown>) => ({
+      id: Number(row.id),
+      title: String(row.title),
+      comment_count: Number(row.comment_count || 0),
+    }))
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to fetch posts with most comments: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+export interface BarGraphData {
+  labels: string[]
+  values: number[]
+}
+
+export async function fetchCommentCountBarGraph(dateRange: DateRange, options: { limit?: number } = {}): Promise<BarGraphData> {
+  try {
+    const posts = await fetchPostsWithMostComments(dateRange, options)
+
+    return {
+      labels: posts.map((post: any) => post.title),
+      values: posts.map((post: any) => post.comment_count),
+    }
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to fetch bar graph data: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+export interface DonutGraphData {
+  labels: string[]
+  values: number[]
+  percentages: number[]
+}
+
+export async function fetchStatusDistributionDonut(dateRange: DateRange): Promise<DonutGraphData> {
+  const db = await getDb()
+  try {
+    const results = await db
+      .selectFrom('commentables')
+      .where('created_at', '>=', formatDate(dateRange.startDate))
+      .where('created_at', '<=', formatDate(dateRange.endDate))
+      .select([
+        'status',
+      ])
+      .groupBy('status')
+      .execute()
+
+    const typedResults = results as Record<string, unknown>[]
+    const total = typedResults.reduce((sum: number, row: Record<string, unknown>) => sum + Number(row.count || 0), 0)
+    const labels = typedResults.map((row: Record<string, unknown>) => String(row.status))
+    const values = typedResults.map((row: Record<string, unknown>) => Number(row.count || 0))
+    const percentages = values.map((value: number) => total > 0 ? (value / total) * 100 : 0)
+
+    return {
+      labels,
+      values,
+      percentages,
+    }
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to fetch status distribution: ${error.message}`)
+
+    throw error
+  }
+}
+
+export interface LineGraphData {
+  labels: string[]
+  values: number[]
+}
+
+export async function fetchMonthlyCommentCounts(dateRange: DateRange): Promise<LineGraphData> {
+  const db = await getDb()
+  try {
+    const results = await db
+      .selectFrom('commentables')
+      .where('created_at', '>=', formatDate(dateRange.startDate))
+      .where('created_at', '<=', formatDate(dateRange.endDate))
+      .select([
+        'created_at',
+      ])
+      .groupBy('created_at')
+      .orderBy('created_at', 'asc')
+      .execute()
+
+    // Group results by year and month
+    const monthlyCounts = new Map<string, number>()
+    ;(results as Record<string, unknown>[]).forEach((row: Record<string, unknown>) => {
+      if (!row.created_at)
+        return
+      const date = new Date(row.created_at as string)
+      const key = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`
+      monthlyCounts.set(key, (monthlyCounts.get(key) || 0) + Number(row.count || 0))
+    })
+
+    // Convert to arrays for the graph
+    const labels: string[] = []
+    const values: number[] = []
+    monthlyCounts.forEach((count: any, key: any) => {
+      const [year, month] = key.split('-')
+      labels.push(new Date(Number(year), Number(month) - 1).toLocaleString('default', { month: 'short', year: 'numeric' }))
+      values.push(count)
+    })
+
+    return { labels, values }
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to fetch monthly comment counts: ${error.message}`)
+
+    throw error
+  }
+}

package/src/commentables/index.ts

@@ -0,0 +1,25 @@
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy'
+
+export {
+  calculateApprovalRate,
+  fetchCommentById,
+  fetchCommentCountBarGraph,
+  fetchCommentCountByPeriod,
+  fetchComments,
+  fetchCommentsByCommentables,
+  fetchCommentsByStatus,
+  fetchMonthlyCommentCounts,
+  fetchPostsWithMostComments,
+  fetchStatusDistributionDonut,
+} from './fetch'
+
+export {
+  store,
+} from './store'
+
+export {
+  update,
+} from './update'

package/src/commentables/store.ts

@@ -0,0 +1,156 @@
+import type { CommentablesTable } from '@stacksjs/orm'
+import { getDb } from '../database'
+
+export interface CreateCommentInput {
+  title: string
+  body: string
+  commentables_id: number
+  commentables_type: string
+}
+
+export interface UpdateCommentInput {
+  title?: string
+  body?: string
+  status?: string
+}
+
+export async function createComment(data: CreateCommentInput): Promise<CommentablesTable> {
+  const db = await getDb()
+  const now = new Date()
+
+  const commentData = {
+    title: data.title,
+    body: data.body,
+    commentables_id: data.commentables_id,
+    commentables_type: data.commentables_type,
+    status: 'pending',
+    created_at: now.toISOString(),
+  }
+
+  return db
+    .insertInto('commentables')
+    .values(commentData)
+    .returningAll()
+    .executeTakeFirstOrThrow() as unknown as Promise<CommentablesTable>
+}
+
+export async function updateComment(
+  id: number,
+  input: UpdateCommentInput,
+): Promise<CommentablesTable> {
+  const db = await getDb()
+  return db
+    .updateTable('commentables')
+    .set({
+      ...input,
+      updated_at: new Date().toISOString(),
+    })
+    .where('id', '=', id)
+    .returningAll()
+    .executeTakeFirstOrThrow() as unknown as Promise<CommentablesTable>
+}
+
+export async function approveComment(id: number): Promise<CommentablesTable> {
+  const db = await getDb()
+  return db
+    .updateTable('commentables')
+    .set({
+      status: 'approved',
+      approved_at: Date.now(),
+      updated_at: new Date().toISOString(),
+    })
+    .where('id', '=', id)
+    .returningAll()
+    .executeTakeFirstOrThrow() as unknown as Promise<CommentablesTable>
+}
+
+export async function rejectComment(id: number): Promise<CommentablesTable> {
+  const db = await getDb()
+  return db
+    .updateTable('commentables')
+    .set({
+      status: 'rejected',
+      rejected_at: Date.now(),
+      updated_at: new Date().toISOString(),
+    })
+    .where('id', '=', id)
+    .returningAll()
+    .executeTakeFirstOrThrow() as unknown as Promise<CommentablesTable>
+}
+
+export async function deleteComment(id: number): Promise<void> {
+  const db = await getDb()
+  await db
+    .deleteFrom('commentables')
+    .where('id', '=', id)
+    .execute()
+}
+
+interface CommentStore {
+  title: string
+  body: string
+  status: string
+  user_id: number
+  commentables_id: number
+  commentables_type: string
+  is_active?: boolean | null
+  approved_at?: number | null
+  rejected_at?: number | null
+}
+
+/**
+ * Create a new comment
+ *
+ * @param data The comment data to store
+ * @returns The newly created comment record
+ */
+export async function store(data: CommentStore): Promise<CommentablesTable> {
+  const db = await getDb()
+  try {
+    if (!data.title || data.title.trim() === '') {
+      throw new Error('Comment title is required')
+    }
+
+    if (!data.body || data.body.trim() === '') {
+      throw new Error('Comment body is required')
+    }
+
+    if (!data.commentables_type || data.commentables_type.trim() === '') {
+      throw new Error('Comment commentables_type is required')
+    }
+
+    const validStatuses = ['pending', 'approved', 'rejected']
+    if (data.status && !validStatuses.includes(data.status)) {
+      throw new Error(`Invalid comment status: ${data.status}`)
+    }
+
+    const commentData = {
+      title: data.title,
+      body: data.body,
+      status: data.status,
+      commentables_id: data.commentables_id,
+      commentables_type: data.commentables_type,
+      user_id: data.user_id,
+      is_active: data.is_active,
+    }
+
+    const result = await db
+      .insertInto('commentables')
+      .values(commentData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result) {
+      throw new Error('Failed to create comment')
+    }
+
+    return result as unknown as CommentablesTable
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to store comment: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/commentables/update.ts

@@ -0,0 +1,75 @@
+import type { CommentablesTable } from '@stacksjs/orm'
+import { getDb } from '../database'
+import { formatDate } from '@stacksjs/orm'
+
+interface CommentUpdate {
+  title?: string
+  body?: string
+  status?: string
+  approved_at?: number | null
+  rejected_at?: number | null
+  commentables_id?: number
+  commentables_type?: string
+  user_id?: number | null
+  updated_at?: string | null
+}
+
+/**
+ * Update a comment by ID
+ *
+ * @param id The ID of the comment to update
+ * @param data The updated comment data
+ * @returns The updated comment record
+ */
+export async function update(id: number, data: CommentUpdate): Promise<CommentablesTable | undefined> {
+  const db = await getDb()
+  try {
+    if (data.title !== undefined && data.title.trim() === '') {
+      throw new Error('Comment title cannot be empty')
+    }
+
+    if (data.body !== undefined && data.body.trim() === '') {
+      throw new Error('Comment body cannot be empty')
+    }
+
+    const validStatuses = ['pending', 'approved', 'rejected']
+    if (data.status !== undefined && !validStatuses.includes(data.status)) {
+      throw new Error(`Invalid comment status: ${data.status}`)
+    }
+
+    // Only include fields that are explicitly provided
+    const commentData: Record<string, unknown> = {
+      updated_at: formatDate(new Date()),
+    }
+
+    if (data.title !== undefined) commentData.title = data.title
+    if (data.body !== undefined) commentData.body = data.body
+    if (data.status !== undefined) commentData.status = data.status
+    if (data.commentables_id !== undefined) commentData.commentables_id = data.commentables_id
+    if (data.commentables_type !== undefined) commentData.commentables_type = data.commentables_type
+    if (data.approved_at !== undefined) commentData.approved_at = data.approved_at
+    if (data.rejected_at !== undefined) commentData.rejected_at = data.rejected_at
+
+    // Update the comment record
+    await db
+      .updateTable('commentables')
+      .set(commentData)
+      .where('id', '=', id)
+      .execute()
+
+    const updatedComment = await db
+      .selectFrom('commentables')
+      .where('id', '=', id)
+      .selectAll()
+      .executeTakeFirst()
+
+    return updatedComment as unknown as CommentablesTable | undefined
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update comment: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/database.ts

@@ -0,0 +1,9 @@
+type StacksDatabase = typeof import('@stacksjs/database').db
+
+let dbPromise: Promise<StacksDatabase> | undefined
+
+export async function getDb(): Promise<StacksDatabase> {
+  dbPromise ??= import('@stacksjs/database').then(module => module.db)
+
+  return dbPromise
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+import * as authors from './authors'
+import * as postCategories from './categorizables'
+import * as comments from './commentables'
+import * as pages from './pages'
+import * as posts from './posts'
+import * as tags from './taggables'
+
+type PostsModule = typeof posts
+type PostCategoriesModule = typeof postCategories
+type TagsModule = typeof tags
+type CommentsModule = typeof comments
+type AuthorsModule = typeof authors
+type PagesModule = typeof pages
+
+export interface CmsNamespace {
+  posts: PostsModule
+  postCategories: PostCategoriesModule
+  tags: TagsModule
+  comments: CommentsModule
+  authors: AuthorsModule
+  pages: PagesModule
+}
+
+export const cms: CmsNamespace = {
+  posts,
+  postCategories,
+  tags,
+  comments,
+  authors,
+  pages,
+}
+
+export default cms
+
+export {
+  authors,
+  postCategories as categorizable,
+  comments,
+  pages,
+  posts,
+  tags,
+}

package/src/pages/destroy.ts

@@ -0,0 +1,64 @@
+import { getDb } from '../database'
+import { fetchById } from './fetch'
+
+/**
+ * Delete a page by ID
+ *
+ * @param id The ID of the page to delete
+ * @returns True if the deletion was successful, false otherwise
+ */
+export async function destroy(id: number): Promise<boolean> {
+  const db = await getDb()
+  try {
+    // First check if the page exists
+    const page = await fetchById(id)
+
+    if (!page) {
+      throw new Error(`Page with ID ${id} not found`)
+    }
+
+    // Delete the page
+    const result = await db
+      .deleteFrom('pages')
+      .where('id', '=', id)
+      .executeTakeFirst()
+
+    return result.numDeletedRows > 0
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete page: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Bulk delete multiple pages
+ *
+ * @param ids Array of page IDs to delete
+ * @returns Number of pages successfully deleted
+ */
+export async function bulkDestroy(ids: number[]): Promise<number> {
+  const db = await getDb()
+  if (!ids.length)
+    return 0
+
+  try {
+    // Delete all pages in the array
+    const result = await db
+      .deleteFrom('pages')
+      .where('id', 'in', ids)
+      .executeTakeFirst()
+
+    return Number(result.numDeletedRows) || 0
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete pages in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}