@stacksjs/cms 0.70.55 → 0.70.56

package/src/categorizables/destroy.ts

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

package/src/categorizables/fetch.ts

@@ -1,121 +0,0 @@
-import type { CategorizableTable } from '@stacksjs/orm'
-import { getDb } from '../database'
-import { slugify } from 'ts-slug'
-
-/**
- * Fetch a category by ID
- */
-export async function fetchById(id: number): Promise<CategorizableTable | undefined> {
-  const db = await getDb()
-  return await db
-    .selectFrom('categorizables')
-    .where('id', '=', id)
-    .where('is_active', '=', true)
-    .selectAll()
-    .executeTakeFirst() as unknown as CategorizableTable | undefined
-}
-
-/**
- * Fetch all categories
- */
-export async function fetchAll(): Promise<CategorizableTable[]> {
-  const db = await getDb()
-  return await db.selectFrom('categorizables').selectAll().execute() as unknown as CategorizableTable[]
-}
-
-/**
- * Fetch categories by name
- */
-export async function fetchByName(name: string): Promise<CategorizableTable[]> {
-  const db = await getDb()
-  return await db
-    .selectFrom('categorizables')
-    .where('name', '=', name)
-    .where('is_active', '=', true)
-    .selectAll()
-    .execute() as unknown as CategorizableTable[]
-}
-
-/**
- * Fetch category by slug
- */
-export async function fetchBySlug(slug: string): Promise<CategorizableTable | undefined> {
-  const db = await getDb()
-  return await db
-    .selectFrom('categorizables')
-    .where('slug', '=', slug)
-    .where('is_active', '=', true)
-    .selectAll()
-    .executeTakeFirst() as unknown as CategorizableTable | undefined
-}
-
-/**
- * Fetch categories with posts
- */
-export async function fetchWithPosts(id: number): Promise<CategorizableTable | undefined> {
-  const db = await getDb()
-  return await db
-    .selectFrom('categorizables')
-    .where('id', '=', id)
-    .where('is_active', '=', true)
-    .selectAll()
-    .executeTakeFirst() as unknown as CategorizableTable | undefined
-}
-
-/**
- * Find a category by name or create it if it doesn't exist
- *
- * @param name The name of the category to find or create
- * @param categorizableType Type of the categorizable entity
- * @param description Optional description for the category
- * @returns The existing or newly created category
- */
-export async function firstOrCreate(
-  name: string,
-  categorizableType: string,
-  description?: string,
-): Promise<CategorizableTable> {
-  const db = await getDb()
-  try {
-    // First try to find the category by name
-    const existingCategory = await db
-      .selectFrom('categorizables')
-      .selectAll()
-      .where('name', '=', name)
-      .executeTakeFirst()
-
-    if (existingCategory) {
-      return existingCategory as unknown as CategorizableTable
-    }
-
-    // If category doesn't exist, create it
-    const now = new Date()
-    const categoryData = {
-      name,
-      slug: slugify(name),
-      description,
-      is_active: true,
-      created_at: now.toDateString(),
-      categorizable_type: categorizableType,
-    }
-
-    const result = await db
-      .insertInto('categorizables')
-      .values(categoryData)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result) {
-      throw new Error('Failed to create category')
-    }
-
-    return result as unknown as CategorizableTable
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to find or create category: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/categorizables/index.ts

@@ -1,22 +0,0 @@
-export {
-  bulkDestroy,
-  destroy,
-} from './destroy'
-
-export {
-  fetchAll,
-  fetchById,
-  fetchByName,
-  fetchBySlug,
-  fetchWithPosts,
-} from './fetch'
-
-export {
-  bulkStore,
-  store,
-  storeCategorizableModel,
-} from './store'
-
-export {
-  update,
-} from './update'

package/src/categorizables/store.ts

@@ -1,140 +0,0 @@
-import type { CategorizableModelsTable, CategorizableTable } from '@stacksjs/orm'
-import { getDb } from '../database'
-import { slugify } from 'ts-slug'
-
-interface CategoryData {
-  name: string
-  description?: string
-  categorizable_type: string
-  is_active?: boolean
-}
-
-interface CategorizableModelData {
-  category_id: number
-  categorizable_type: string
-}
-
-/**
- * Create a new category and its pivot table entry
- *
- * @param data The category data to create
- * @returns The created category record
- */
-export async function store(data: CategoryData): Promise<CategorizableTable> {
-  const db = await getDb()
-  try {
-    if (!data.name || data.name.trim() === '') {
-      throw new Error('Category name is required')
-    }
-
-    if (!data.categorizable_type || data.categorizable_type.trim() === '') {
-      throw new Error('Category categorizable_type is required')
-    }
-
-    const categoryData = {
-      name: data.name,
-      slug: slugify(data.name),
-      description: data.description,
-      categorizable_type: data.categorizable_type,
-      is_active: data.is_active ?? true,
-    }
-
-    const category = await db
-      .insertInto('categorizables')
-      .values(categoryData)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!category)
-      throw new Error('Failed to create category')
-
-    return category as unknown as CategorizableTable
-  }
-  catch (error) {
-    if (error instanceof Error)
-      throw new TypeError(`Failed to create category: ${error.message}`)
-
-    throw error
-  }
-}
-
-/**
- * Create a new categorizable model relationship
- *
- * @param data The categorizable model data to create
- * @returns The created categorizable model record
- */
-export async function storeCategorizableModel(data: CategorizableModelData): Promise<CategorizableModelsTable> {
-  const db = await getDb()
-  try {
-    const modelData = {
-      category_id: data.category_id,
-      categorizable_type: data.categorizable_type,
-    }
-
-    const result = await db
-      .insertInto('categorizable_models')
-      .values(modelData)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to create categorizable model relationship')
-
-    return result as unknown as CategorizableModelsTable
-  }
-  catch (error) {
-    if (error instanceof Error)
-      throw new TypeError(`Failed to create categorizable model relationship: ${error.message}`)
-
-    throw error
-  }
-}
-
-/**
- * Create multiple categories and their pivot table entries in a single transaction
- *
- * @param data Array of category data to create
- * @returns Array of created category records
- */
-export async function bulkStore(data: CategoryData[]): Promise<CategorizableTable[]> {
-  const db = await getDb()
-  try {
-    // Start a transaction to ensure all inserts succeed or fail together
-    const results = await db.transaction(async (trx: any) => {
-      const categories: CategorizableTable[] = []
-
-      for (const item of data) {
-        const categoryData = {
-          name: item.name,
-          slug: slugify(item.name),
-          description: item.description,
-          categorizable_type: item.categorizable_type,
-          is_active: item.is_active ?? true,
-        }
-
-        // Insert into categorizable table
-        const category = await trx
-          .insertInto('categorizables')
-          .values(categoryData)
-          .returningAll()
-          .executeTakeFirst()
-
-        if (!category)
-          throw new Error(`Failed to create category: ${item.name}`)
-
-        categories.push(category as CategorizableTable)
-      }
-
-      return categories
-    })
-
-    return results
-  }
-  catch (error) {
-    if (error instanceof Error)
-      throw new TypeError(`Failed to create categories: ${error.message}`)
-
-    throw error
-  }
-}

package/src/categorizables/update.ts

@@ -1,57 +0,0 @@
-import type { CategorizableTable } from '@stacksjs/orm'
-import { getDb } from '../database'
-import { slugify } from 'ts-slug'
-
-interface UpdateCategoryData {
-  id: number
-  name?: string
-  description?: string
-  categorizable_type?: string
-  is_active?: boolean
-  slug?: string
-}
-
-/**
- * Update a category
- *
- * @param data The category data to update (must include id)
- * @returns The updated category record
- */
-export async function update(data: UpdateCategoryData): Promise<CategorizableTable> {
-  const db = await getDb()
-  try {
-    const id = data.id
-
-    if (!id) {
-      throw new Error('Category ID is required for update')
-    }
-
-    if (data.name !== undefined) {
-      if (data.name.trim() === '') {
-        throw new Error('Category name cannot be empty')
-      }
-      data.slug = slugify(data.name)
-    }
-
-    // Remove id from the data to avoid updating it
-    const { id: _id, ...updateData } = data
-
-    const result = await db
-      .updateTable('categorizables')
-      .set(updateData as unknown as Record<string, unknown>)
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update category')
-
-    return result as unknown as CategorizableTable
-  }
-  catch (error) {
-    if (error instanceof Error)
-      throw new TypeError(`Failed to update category: ${error.message}`)
-
-    throw error
-  }
-}

package/src/commentables/destroy.ts

@@ -1,64 +0,0 @@
-import { getDb } from '../database'
-import { fetchCommentById } from './fetch'
-
-/**
- * Delete a comment by ID
- *
- * @param id The ID of the comment 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 comment exists
-    const comment = await fetchCommentById(id)
-
-    if (!comment) {
-      throw new Error(`Comment with ID ${id} not found`)
-    }
-
-    // Delete the comment
-    const result = await db
-      .deleteFrom('commentables')
-      .where('id', '=', id)
-      .executeTakeFirst()
-
-    return result.numDeletedRows > 0
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to delete comment: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Bulk delete multiple comments
- *
- * @param ids Array of comment IDs to delete
- * @returns Number of comments successfully deleted
- */
-export async function bulkDestroy(ids: number[]): Promise<number> {
-  const db = await getDb()
-  if (!ids.length)
-    return 0
-
-  try {
-    // Delete all comments in the array
-    const result = await db
-      .deleteFrom('commentables')
-      .where('id', 'in', ids)
-      .executeTakeFirst()
-
-    return Number(result.numDeletedRows) || 0
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to delete comments in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}