@stacksjs/cms 0.70.53 → 0.70.55

package/src/pages/fetch.ts

@@ -0,0 +1,82 @@
+type PageJsonResponse = ModelRow<typeof Page>
+import { getDb } from '../database'
+
+/**
+ * Fetch a page by ID
+ */
+export async function fetchById(id: number): Promise<PageJsonResponse | undefined> {
+  const db = await getDb()
+  return await db
+    .selectFrom('pages')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as PageJsonResponse | undefined
+}
+
+/**
+ * Fetch all pages
+ */
+export async function fetchAll(): Promise<PageJsonResponse[]> {
+  const db = await getDb()
+  return await db.selectFrom('pages').selectAll().execute() as PageJsonResponse[]
+}
+
+/**
+ * Fetch pages by template
+ */
+export async function fetchByTemplate(template: string): Promise<PageJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('pages')
+    .where('template', '=', template)
+    .selectAll()
+    .execute() as PageJsonResponse[]
+}
+
+/**
+ * Fetch pages by author
+ */
+export async function fetchByAuthor(authorId: number): Promise<PageJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('pages')
+    .where('author_id', '=', authorId)
+    .selectAll()
+    .execute() as PageJsonResponse[]
+}
+
+/**
+ * Fetch pages with minimum views
+ */
+export async function fetchByMinViews(minViews: number): Promise<PageJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('pages')
+    .where('views', '>=', minViews)
+    .selectAll()
+    .execute() as PageJsonResponse[]
+}
+
+/**
+ * Fetch pages with minimum conversions
+ */
+export async function fetchByMinConversions(minConversions: number): Promise<PageJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('pages')
+    .where('conversions', '>=', minConversions)
+    .selectAll()
+    .execute() as PageJsonResponse[]
+}
+
+/**
+ * Fetch pages published after a specific date
+ */
+export async function fetchPublishedAfter(timestamp: number): Promise<PageJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('pages')
+    .where('published_at', '>', timestamp)
+    .selectAll()
+    .execute() as PageJsonResponse[]
+}

package/src/pages/index.ts

@@ -0,0 +1,21 @@
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy'
+
+export {
+  fetchAll,
+  fetchByAuthor,
+  fetchById,
+  fetchByMinConversions,
+  fetchByMinViews,
+  fetchPublishedAfter,
+} from './fetch'
+
+export {
+  store,
+} from './store'
+
+export {
+  update,
+} from './update'

package/src/pages/store.ts

@@ -0,0 +1,42 @@
+type PageJsonResponse = ModelRow<typeof Page>
+type NewPage = NewModelData<typeof Page>
+import { getDb } from '../database'
+import { formatDate } from '@stacksjs/orm'
+
+/**
+ * Create a new page
+ *
+ * @param data The page data to create
+ * @returns The created page record
+ */
+export async function store(data: NewPage): Promise<PageJsonResponse> {
+  const db = await getDb()
+  try {
+    const pageData = {
+      author_id: data.author_id,
+      title: data.title,
+      template: data.template,
+      views: data.views || 0,
+      conversions: data.conversions || 0,
+      created_at: formatDate(new Date()),
+      updated_at: formatDate(new Date()),
+    }
+
+    const result = await db
+      .insertInto('pages')
+      .values(pageData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create page')
+
+    return result as PageJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to create page: ${error.message}`)
+
+    throw error
+  }
+}

package/src/pages/update.ts

@@ -0,0 +1,39 @@
+type PageJsonResponse = ModelRow<typeof Page>
+type PageUpdate = UpdateModelData<typeof Page>
+import { getDb } from '../database'
+import { formatDate } from '@stacksjs/orm'
+
+/**
+ * Update a page
+ *
+ * @param id The id of the page to update
+ * @param data The page data to update
+ * @returns The updated page record
+ */
+export async function update(id: number, data: Partial<PageUpdate>): Promise<PageJsonResponse> {
+  const db = await getDb()
+  try {
+    const updateData = {
+      ...data,
+      updated_at: formatDate(new Date()),
+    }
+
+    const result = await db
+      .updateTable('pages')
+      .set(updateData)
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update page')
+
+    return result as PageJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to update page: ${error.message}`)
+
+    throw error
+  }
+}

package/src/posts/destroy.ts

@@ -0,0 +1,90 @@
+import { getDb } from '../database'
+import { fetchById } from './fetch'
+
+/**
+ * Delete a post by ID
+ *
+ * @param id The ID of the post 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 post exists
+    const post = await fetchById(id)
+
+    if (!post) {
+      throw new Error(`Post with ID ${id} not found`)
+    }
+
+    // Delete related categorizable_models entries first
+    await db
+      .deleteFrom('categorizable_models')
+      .where('categorizable_id', '=', id)
+      .where('categorizable_type', '=', 'posts')
+      .execute()
+
+    // Delete the post
+    const result = await db
+      .deleteFrom('posts')
+      .where('id', '=', id)
+      .executeTakeFirst()
+
+    return (result as { numDeletedRows?: number })?.numDeletedRows ? (result as { numDeletedRows: number }).numDeletedRows > 0 : false
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete post: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Bulk delete multiple posts
+ *
+ * @param ids Array of post IDs to delete
+ * @returns Number of posts successfully deleted
+ */
+export async function bulkDestroy(ids: number[]): Promise<number> {
+  const db = await getDb()
+  if (!ids.length)
+    return 0
+
+  try {
+    // First verify which posts actually exist
+    const existingPosts = await db
+      .selectFrom('posts')
+      .select(['id'])
+      .where('id', 'in', ids)
+      .execute()
+
+    const existingIds = existingPosts.map((post: Record<string, unknown>) => post.id as number)
+
+    if (!existingIds.length)
+      return 0
+
+    // Delete related categorizable_models entries first
+    await db
+      .deleteFrom('categorizable_models')
+      .where('categorizable_id', 'in', existingIds)
+      .where('categorizable_type', '=', 'posts')
+      .execute()
+
+    // Delete all existing posts
+    const result = await db
+      .deleteFrom('posts')
+      .where('id', 'in', existingIds)
+      .executeTakeFirst()
+
+    return Number((result as { numDeletedRows?: number })?.numDeletedRows) || 0
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete posts in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/posts/fetch.ts

@@ -0,0 +1,82 @@
+type PostJsonResponse = ModelRow<typeof Post>
+import { getDb } from '../database'
+
+/**
+ * Fetch a post by ID
+ */
+export async function fetchById(id: number): Promise<PostJsonResponse | undefined> {
+  const db = await getDb()
+  return await db
+    .selectFrom('posts')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as PostJsonResponse | undefined
+}
+
+/**
+ * Fetch all posts
+ */
+export async function fetchAll(): Promise<PostJsonResponse[]> {
+  const db = await getDb()
+  return await db.selectFrom('posts').selectAll().execute() as PostJsonResponse[]
+}
+
+/**
+ * Fetch posts by status
+ */
+export async function fetchByStatus(status: 'published' | 'draft' | 'archived'): Promise<PostJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('posts')
+    .where('status', '=', status)
+    .selectAll()
+    .execute() as PostJsonResponse[]
+}
+
+/**
+ * Fetch posts by category
+ */
+export async function fetchByCategory(category: string): Promise<PostJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('posts')
+    .where('category', '=', category)
+    .selectAll()
+    .execute() as PostJsonResponse[]
+}
+
+/**
+ * Fetch posts by author
+ */
+export async function fetchByAuthor(author: string): Promise<PostJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('posts')
+    .where('author', '=', author)
+    .selectAll()
+    .execute() as PostJsonResponse[]
+}
+
+/**
+ * Fetch posts with minimum views
+ */
+export async function fetchByMinViews(minViews: number): Promise<PostJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('posts')
+    .where('views', '>=', minViews)
+    .selectAll()
+    .execute() as PostJsonResponse[]
+}
+
+/**
+ * Fetch posts published after a specific date
+ */
+export async function fetchPublishedAfter(timestamp: number): Promise<PostJsonResponse[]> {
+  const db = await getDb()
+  return await db
+    .selectFrom('posts')
+    .where('published_at', '>', timestamp)
+    .selectAll()
+    .execute() as PostJsonResponse[]
+}

package/src/posts/index.ts

@@ -0,0 +1,25 @@
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy'
+
+export {
+  fetchAll,
+  fetchByAuthor,
+  fetchByCategory,
+  fetchById,
+  fetchByMinViews,
+  fetchByStatus,
+  fetchPublishedAfter,
+} from './fetch'
+
+export {
+  attach,
+  detach,
+  store,
+  sync,
+} from './store'
+
+export {
+  update,
+} from './update'

package/src/posts/store.ts

@@ -0,0 +1,213 @@
+type PostJsonResponse = ModelRow<typeof Post>
+type NewPost = NewModelData<typeof Post>
+import { randomUUIDv7 } from 'bun'
+import { getDb } from '../database'
+import { formatDate } from '@stacksjs/orm'
+
+export const POST_STATUS_DRAFT = 'Draft'
+export const POST_STATUS_PUBLISHED = 'Published'
+export const POST_STATUS_ARCHIVED = 'Archived'
+
+/**
+ * Create a new post
+ *
+ * @param data The post data to create
+ * @returns The created post record
+ */
+export async function store(data: NewPost & { body?: string, category?: string }): Promise<PostJsonResponse & { body?: string, category?: string }> {
+  const db = await getDb()
+  try {
+    if (!data.title || (typeof data.title === 'string' && data.title.trim() === '')) {
+      throw new Error('Post title is required')
+    }
+
+    // Map body -> content if body is provided and content is not
+    const content = data.content || data.body
+
+    const d = data as Record<string, unknown>
+    const postData: Record<string, unknown> = {
+      author_id: d.author_id,
+      uuid: randomUUIDv7(),
+      title: data.title,
+      poster: data.poster,
+      content,
+      body: data.body,
+      category: data.category,
+      excerpt: data.excerpt,
+      is_featured: d.is_featured ? Date.now() : undefined,
+      views: data.views || 0,
+      published_at: d.published_at || Date.now(),
+      status: data.status || POST_STATUS_DRAFT,
+    }
+
+    const result = await db
+      .insertInto('posts')
+      .values(postData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create post')
+
+    return result as PostJsonResponse & { body?: string, category?: string }
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to create post: ${error.message}`)
+
+    throw error
+  }
+}
+
+/**
+ * Attach related records to a post through a pivot table
+ *
+ * @param postId The ID of the post to attach records to
+ * @param tableName The name of the pivot table (e.g., 'categorizable_models', 'taggable')
+ * @param ids Array of IDs to attach
+ * @returns Promise<void>
+ */
+export async function attach(
+  postId: number,
+  tableName: 'categorizable_models' | 'taggable_models',
+  ids: number[],
+): Promise<void> {
+  const db = await getDb()
+  try {
+    // Get the foreign key names based on the table name
+    const postForeignKey = tableName === 'categorizable_models' ? 'categorizable_id' : 'taggable_id'
+    const postTypeField = tableName === 'categorizable_models' ? 'categorizable_type' : 'taggable_type'
+
+    const tablePrimary = tableName === 'categorizable_models' ? 'category_id' : 'tag_id'
+
+    // Prepare the data for insertion
+    const pivotData = ids.map((id: number) => ({
+      [tablePrimary]: id,
+      [postForeignKey]: postId,
+      [postTypeField]: 'posts',
+      created_at: formatDate(new Date()),
+      updated_at: formatDate(new Date()),
+    }))
+
+    for (const data of pivotData) {
+      await db
+        .insertInto(tableName)
+        .values(data)
+        .execute()
+    }
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to attach records: ${error.message}`)
+
+    throw error
+  }
+}
+
+/**
+ * Detach related records from a post through a pivot table
+ *
+ * @param postId The ID of the post to detach records from
+ * @param tableName The name of the pivot table (e.g., 'categorizable_models', 'taggable')
+ * @param ids Optional array of IDs to detach. If not provided, all related records will be detached
+ * @returns Promise<void>
+ */
+export async function detach(
+  postId: number,
+  tableName: 'categorizable_models' | 'taggable_models',
+  ids?: number[],
+): Promise<void> {
+  const db = await getDb()
+  try {
+    // Get the foreign key names based on the table name
+    const postForeignKey = tableName === 'categorizable_models' ? 'categorizable_id' : 'taggable_id'
+    const postTypeField = tableName === 'categorizable_models' ? 'categorizable_type' : 'taggable_type'
+
+    // Build the delete query
+    let query = db
+      .deleteFrom(tableName)
+      .where(postForeignKey, '=', postId)
+      .where(postTypeField, '=', 'posts')
+
+    if (ids) {
+      query = query.where('id', 'in', ids)
+    }
+
+    await query.execute()
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to detach records: ${error.message}`)
+
+    throw error
+  }
+}
+
+/**
+ * Synchronize related records for a post through a pivot table
+ * This will detach relationships not in the new set and attach only new relationships
+ *
+ * @param postId The ID of the post to sync records for
+ * @param tableName The name of the pivot table (e.g., 'categorizable_models', 'taggable')
+ * @param ids Array of IDs to sync
+ * @returns Promise<void>
+ */
+export async function sync(
+  postId: number,
+  tableName: 'categorizable_models' | 'taggable_models',
+  ids: number[],
+): Promise<void> {
+  const db = await getDb()
+  try {
+    // Get the foreign key names based on the table name
+    const postForeignKey = tableName === 'categorizable_models' ? 'categorizable_id' : 'taggable_id'
+    const postTypeField = tableName === 'categorizable_models' ? 'categorizable_type' : 'taggable_type'
+
+    // Get existing relationships
+    const existingRelations = await db
+      .selectFrom(tableName)
+      .select(['id'])
+      .where(postForeignKey, '=', postId)
+      .where(postTypeField, '=', 'posts')
+      .execute()
+
+    const existingIds = existingRelations.map((rel: Record<string, unknown>) => rel.id as number)
+
+    // Find IDs to remove (in existing but not in new set)
+    const idsToRemove = existingIds.filter((id: number) => !ids.includes(id))
+
+    // Find IDs to add (in new set but not in existing)
+    const idsToAdd = ids.filter(id => !existingIds.includes(id))
+
+    // Remove relationships that are no longer needed
+    if (idsToRemove.length > 0) {
+      await db
+        .deleteFrom(tableName)
+        .where(postForeignKey, '=', postId)
+        .where(postTypeField, '=', 'posts')
+        .where('id', 'in', idsToRemove)
+        .execute()
+    }
+
+    // Add new relationships
+    if (idsToAdd.length > 0) {
+      const pivotData = idsToAdd.map(() => ({
+        [postForeignKey]: postId,
+        [postTypeField]: 'posts',
+        created_at: formatDate(new Date()),
+        updated_at: formatDate(new Date()),
+      }))
+
+      await db
+        .insertInto(tableName)
+        .values(pivotData)
+        .execute()
+    }
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to sync records: ${error.message}`)
+
+    throw error
+  }
+}

package/src/posts/update.ts

@@ -0,0 +1,46 @@
+type PostJsonResponse = ModelRow<typeof Post>
+type PostUpdate = UpdateModelData<typeof Post>
+import { getDb } from '../database'
+
+/**
+ * Update a post
+ *
+ * @param id The id of the post to update
+ * @param data The post data to update
+ * @returns The updated post record
+ */
+export async function update(id: number, data: Partial<PostUpdate>): Promise<PostJsonResponse> {
+  const db = await getDb()
+  try {
+    if (data.title !== undefined && typeof data.title === 'string' && data.title.trim() === '') {
+      throw new Error('Post title cannot be empty')
+    }
+
+    const validStatuses = ['published', 'draft', 'archived']
+    if (data.status !== undefined && typeof data.status === 'string' && !validStatuses.includes(data.status)) {
+      throw new Error(`Invalid post status: ${data.status}`)
+    }
+
+    if (data.views !== undefined && typeof data.views === 'number' && data.views < 0) {
+      throw new Error('Views count cannot be negative')
+    }
+
+    const result = await db
+      .updateTable('posts')
+      .set(data)
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update post')
+
+    return result as PostJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error)
+      throw new TypeError(`Failed to update post: ${error.message}`)
+
+    throw error
+  }
+}

package/src/taggables/destroy.ts

@@ -0,0 +1,49 @@
+import { getDb } from '../database'
+
+/**
+ * Delete a tag by its ID
+ *
+ * @param id The ID of the tag to delete
+ * @returns void
+ */
+export async function destroy(id: number): Promise<void> {
+  const db = await getDb()
+  // First check if the tag exists
+  const tag = await db
+    .selectFrom('taggables')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst()
+
+  if (!tag) {
+    throw new Error(`Tag with ID ${id} not found`)
+  }
+
+  await db
+    .deleteFrom('taggables')
+    .where('id', '=', id)
+    .executeTakeFirst()
+}
+
+/**
+ * Delete multiple tags by their IDs
+ *
+ * @param ids An array of tag IDs to delete
+ * @returns void
+ */
+export async function bulkDestroy(ids: number[]): Promise<void> {
+  const db = await getDb()
+  try {
+    await db
+      .deleteFrom('taggables')
+      .where('id', 'in', ids)
+      .execute()
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete tags: ${error.message}`)
+    }
+
+    throw error
+  }
+}