@stacksjs/cms 0.70.55 → 0.70.56

package/src/pages/fetch.ts

@@ -1,82 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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
-  }
-}