@stacksjs/commerce 0.70.54 → 0.70.55

package/src/products/categories/fetch.ts

@@ -0,0 +1,285 @@
+import type { CategoryStats } from '../../types'
+import type { StacksExpressionBuilder } from '@stacksjs/database'
+import { db } from '@stacksjs/database'
+import { formatDate } from '@stacksjs/orm'
+type CategoryJsonResponse = ModelRow<typeof Category>
+
+/**
+ * Fetch all categories from the database
+ */
+export async function fetchAll(): Promise<CategoryJsonResponse[]> {
+  const categories = await db
+    .selectFrom('categories')
+    .selectAll()
+    .execute()
+
+  return categories as CategoryJsonResponse[]
+}
+
+/**
+ * Fetch a category by ID
+ */
+export async function fetchById(id: number): Promise<CategoryJsonResponse | undefined> {
+  return await db
+    .selectFrom('categories')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as CategoryJsonResponse | undefined
+}
+
+/**
+ * Fetch a category by name
+ */
+export async function fetchByName(name: string): Promise<CategoryJsonResponse | undefined> {
+  return await db
+    .selectFrom('categories')
+    .where('name', '=', name)
+    .selectAll()
+    .executeTakeFirst() as CategoryJsonResponse | undefined
+}
+
+/**
+ * Fetch active categories (is_active = true)
+ */
+export async function fetchActive(): Promise<CategoryJsonResponse[]> {
+  const categories = await db
+    .selectFrom('categories')
+    .where('is_active', '=', true)
+    .selectAll()
+    .execute()
+
+  return categories as CategoryJsonResponse[]
+}
+
+/**
+ * Fetch root categories (parent_category_id is null)
+ */
+export async function fetchRootCategories(): Promise<CategoryJsonResponse[]> {
+  const categories = await db
+    .selectFrom('categories')
+    .where('parent_category_id', 'is', null)
+    .where('is_active', '=', true)
+    .selectAll()
+    .execute()
+
+  return categories as CategoryJsonResponse[]
+}
+
+/**
+ * Fetch child categories for a given parent category ID
+ */
+export async function fetchChildCategories(parentId: string): Promise<CategoryJsonResponse[]> {
+  const categories = await db
+    .selectFrom('categories')
+    .where('parent_category_id', '=', parentId)
+    .where('is_active', '=', true)
+    .selectAll()
+    .execute()
+
+  return categories as CategoryJsonResponse[]
+}
+
+/**
+ * Fetch categories sorted by display order
+ */
+export async function fetchByDisplayOrder(ascending: boolean = true): Promise<CategoryJsonResponse[]> {
+  const query = db
+    .selectFrom('categories')
+    .where('is_active', '=', true)
+    .selectAll()
+
+  if (ascending) {
+    return await query.orderBy('display_order', 'asc').execute() as CategoryJsonResponse[]
+  }
+  else {
+    return await query.orderBy('display_order', 'desc').execute() as CategoryJsonResponse[]
+  }
+}
+
+/**
+ * Get category statistics
+ */
+export async function fetchStats(): Promise<CategoryStats> {
+  // Total categories
+  const totalCategories = await db
+    .selectFrom('categories')
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .executeTakeFirst() as { count: number } | undefined
+
+  // Active categories
+  const activeCategories = await db
+    .selectFrom('categories')
+    .where('is_active', '=', true)
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .executeTakeFirst() as { count: number } | undefined
+
+  // Root vs child categories
+  const rootCategories = await db
+    .selectFrom('categories')
+    .where('parent_category_id', 'is', null)
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .executeTakeFirst() as { count: number } | undefined
+
+  // Categories with images
+  const categoriesWithImages = await db
+    .selectFrom('categories')
+    .where('image_url', 'is not', null)
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .executeTakeFirst() as { count: number } | undefined
+
+  // Recently added categories (last 30 days)
+  const thirtyDaysAgo = new Date()
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30)
+  const thirtyDaysAgoStr = formatDate(thirtyDaysAgo)
+
+  const recentlyAddedCategories = await db
+    .selectFrom('categories')
+    .where('created_at', '>=', thirtyDaysAgoStr)
+    .selectAll()
+    .limit(5)
+    .execute()
+
+  // Categories by parent (top 5 parents with most children)
+  const categoriesByParent = await db
+    .selectFrom('categories as c')
+    .leftJoin('categories as parent', 'c.parent_category_id', '=', 'parent.id')
+    .where('c.parent_category_id', 'is not', null)
+    .select([
+      'c.parent_category_id',
+      'parent.name as parent_name',
+      (eb: StacksExpressionBuilder) => eb.fn.count('c.id').as('child_count'),
+    ] as any)
+    .groupBy(['c.parent_category_id', 'parent.name'] as any)
+    .orderBy('child_count', 'desc')
+    .limit(5)
+    .execute() as { parent_category_id: string, parent_name: string, child_count: number }[]
+
+  return {
+    total: Number(totalCategories?.count || 0),
+    active: Number(activeCategories?.count || 0),
+    root_categories: Number(rootCategories?.count || 0),
+    child_categories: Number(totalCategories?.count || 0) - Number(rootCategories?.count || 0),
+    with_images: Number(categoriesWithImages?.count || 0),
+    recently_added: recentlyAddedCategories,
+    top_parent_categories: categoriesByParent.map((item: any) => ({
+      id: String(item.parent_category_id || ''),
+      name: String(item.parent_name || ''),
+      child_count: Number(item.child_count),
+    })),
+  }
+}
+
+/**
+ * Compare category growth between different time periods
+ * @param daysRange Number of days to look back (7, 30, 60, etc.)
+ */
+export async function compareCategoryGrowth(_daysRange: number = 30): Promise<{
+  current_period: number
+  previous_period: number
+  difference: number
+  percentage_change: number
+  days_range: number
+}> {
+  const today = new Date()
+  const todayStr = formatDate(today)
+
+  // Current period (last N days)
+  const currentPeriodStart = new Date()
+  currentPeriodStart.setDate(today.getDate() - _daysRange)
+  const currentPeriodStartStr = formatDate(currentPeriodStart)
+
+  // Previous period (N days before the current period)
+  const previousPeriodEnd = new Date(currentPeriodStart)
+  previousPeriodEnd.setDate(previousPeriodEnd.getDate() - 1)
+  const previousPeriodEndStr = formatDate(previousPeriodEnd)
+
+  const previousPeriodStart = new Date(previousPeriodEnd)
+  previousPeriodStart.setDate(previousPeriodEnd.getDate() - _daysRange)
+  const previousPeriodStartStr = formatDate(previousPeriodStart)
+
+  // Get categories for current period
+  const currentPeriodCategories = await db
+    .selectFrom('categories')
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .where('created_at', '>=', currentPeriodStartStr)
+    .where('created_at', '<=', todayStr)
+    .executeTakeFirst() as { count: number } | undefined
+
+  // Get categories for previous period
+  const previousPeriodCategories = await db
+    .selectFrom('categories')
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .where('created_at', '>=', previousPeriodStartStr)
+    .where('created_at', '<=', previousPeriodEndStr)
+    .executeTakeFirst() as { count: number } | undefined
+
+  const currentCount = Number(currentPeriodCategories?.count || 0)
+  const previousCount = Number(previousPeriodCategories?.count || 0)
+  const difference = currentCount - previousCount
+
+  // Calculate percentage change, handling division by zero
+  const percentageChange = previousCount !== 0
+    ? (difference / previousCount) * 100
+    : (currentCount > 0 ? 100 : 0)
+
+  return {
+    current_period: currentCount,
+    previous_period: previousCount,
+    difference,
+    percentage_change: percentageChange,
+    days_range: _daysRange,
+  }
+}
+
+/**
+ * Build category tree structure
+ */
+export async function fetchCategoryTree(): Promise<any[]> {
+  // First get all categories
+  const allCategories = await fetchAll()
+
+  // Create a map for quick access
+  const categoryMap = new Map<any, any>()
+  allCategories.forEach((category: any) => {
+    categoryMap.set(category.id, {
+      ...category,
+      children: [],
+    })
+  })
+
+  // Build the tree
+  const rootCategories: any[] = []
+
+  allCategories.forEach((category: any) => {
+    const categoryWithChildren = categoryMap.get(category.id)
+
+    if (category.parent_category_id) {
+      // This is a child category
+      const parent = categoryMap.get(category.parent_category_id)
+      if (parent) {
+        parent.children.push(categoryWithChildren)
+      }
+    }
+    else {
+      // This is a root category
+      rootCategories.push(categoryWithChildren)
+    }
+  })
+
+  // Sort root categories by display_order
+  rootCategories.sort((a, b) => a.display_order - b.display_order)
+
+  // Sort children by display_order
+  const sortChildrenByDisplayOrder = (categories: any[]) => {
+    categories.sort((a, b) => a.display_order - b.display_order)
+    categories.forEach((category: any) => {
+      if (category.children.length > 0) {
+        sortChildrenByDisplayOrder(category.children)
+      }
+    })
+  }
+
+  sortChildrenByDisplayOrder(rootCategories)
+
+  return rootCategories
+}

package/src/products/categories/index.ts

@@ -0,0 +1,36 @@
+// Export all functions from destroy.ts
+export {
+  bulkRemove,
+  deactivate,
+  deactivateChildCategories,
+  remove,
+  removeChildCategories,
+} from './destroy'
+
+// Export all functions from fetch.ts
+export {
+  compareCategoryGrowth,
+  fetchActive,
+  fetchAll,
+  fetchByDisplayOrder,
+  fetchById,
+  fetchByName,
+  fetchCategoryTree,
+  fetchChildCategories,
+  fetchRootCategories,
+  fetchStats,
+} from './fetch'
+
+// Export all functions from store.ts
+export {
+  findOrCreateByName,
+  store,
+} from './store'
+
+// Export all functions from update.ts
+export {
+  update,
+  updateActiveStatus,
+  updateDisplayOrder,
+  updateParent,
+} from './update'

package/src/products/categories/store.ts

@@ -0,0 +1,87 @@
+type CategoryJsonResponse = ModelRow<typeof Category>
+type NewCategory = NewModelData<typeof Category>
+import { db } from '@stacksjs/database'
+import { slug } from '@stacksjs/strings'
+import { fetchById } from './fetch'
+
+export interface CategorizableTable {
+  id: number
+  name: string
+  slug: string
+  description?: string
+  is_active: boolean
+  categorizable_type: string
+  created_at?: string
+  updated_at?: string
+}
+
+/**
+ * Create a new category
+ *
+ * @param data The category data to store
+ * @returns The newly created category record
+ */
+export async function store(data: NewCategory): Promise<CategoryJsonResponse> {
+  try {
+    // Add missing required properties
+    const categoryData = {
+      ...data,
+      slug: data.name?.toLowerCase().replace(/\s+/g, '-') || '',
+      categorizable_type: 'product',
+      display_order: 0,
+    }
+
+    const result = await db
+      .insertInto('categories')
+      .values(categoryData)
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create category')
+
+    const insertId = Number(result.insertId) || Number(result.numInsertedOrUpdatedRows)
+
+    const model = await fetchById(insertId)
+
+    if (!model)
+      throw new Error('Failed to create category')
+
+    return model
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes('Duplicate entry') && error.message.includes('name')) {
+        throw new Error('A category with this name already exists')
+      }
+
+      throw new Error(`Failed to create category: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+export async function findOrCreateByName(data: Partial<CategorizableTable>): Promise<CategoryJsonResponse> {
+  if (!data.name)
+    throw new Error('Name is required')
+
+  const existingCategory = await db
+    .selectFrom('categories')
+    .selectAll()
+    .where('name', '=', data.name)
+    .executeTakeFirst()
+
+  if (existingCategory)
+    return existingCategory as CategoryJsonResponse
+
+  const categoryData = {
+    name: data.name,
+    slug: slug(data.name),
+    is_active: data.is_active ?? true,
+    categorizable_type: data.categorizable_type ?? 'default',
+    display_order: 0,
+
+  }
+
+  return await store(categoryData)
+}

package/src/products/categories/update.ts

@@ -0,0 +1,251 @@
+import { db } from '@stacksjs/database'
+import { formatDate } from '@stacksjs/orm'
+import { fetchById } from './fetch'
+
+type CategoryRow = ModelRow<typeof Category>
+
+/**
+ * Update a category by ID
+ *
+ * @param id The ID of the category to update
+ * @param request The updated category data
+ * @returns The updated category record
+ */
+export async function update(id: number, request: RequestInstance<typeof Category>): Promise<CategoryRow | undefined> {
+  // Validate the request data
+  await request.validate()
+
+  // Check if category exists
+  const existingCategory = await fetchById(id)
+  if (!existingCategory) {
+    throw new Error(`Category with ID ${id} not found`)
+  }
+
+  // Create update data object using request fields
+  const updateData = {
+    name: request.get('name'),
+    description: request.get('description'),
+    imageUrl: request.get('imageUrl'),
+    isActive: request.get('isActive'),
+    parentCategoryId: request.get('parentCategoryId'),
+    displayOrder: request.get('displayOrder'),
+    updated_at: formatDate(new Date()),
+  }
+
+  // If no fields to update, just return the existing category
+  if (Object.keys(updateData).length === 0) {
+    return existingCategory
+  }
+
+  try {
+    // Update the category
+    await db
+      .updateTable('categories')
+      .set(updateData)
+      .where('id', '=', id)
+      .execute()
+
+    // Fetch and return the updated category
+    return await fetchById(id)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      // Handle duplicate name error
+      if (error.message.includes('Duplicate entry') && error.message.includes('name')) {
+        throw new Error('A category with this name already exists')
+      }
+
+      throw new Error(`Failed to update category: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update category display order
+ *
+ * @param id The ID of the category
+ * @param newOrder The new display order value
+ * @returns The updated category
+ */
+export async function updateDisplayOrder(id: number, newOrder: number): Promise<CategoryRow | undefined> {
+  // Check if category exists
+  const category = await fetchById(id)
+
+  if (!category) {
+    throw new Error(`Category with ID ${id} not found`)
+  }
+
+  try {
+    // Update the category's display order
+    await db
+      .updateTable('categories')
+      .set({
+        display_order: newOrder,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .execute()
+
+    // Fetch the updated category
+    return await fetchById(id)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update category display order: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update category active status
+ *
+ * @param id The ID of the category
+ * @param isActive Whether the category should be active
+ * @returns The updated category
+ */
+export async function updateActiveStatus(id: number, isActive: boolean): Promise<CategoryRow | undefined> {
+  // Check if category exists
+  const category = await fetchById(id)
+
+  if (!category) {
+    throw new Error(`Category with ID ${id} not found`)
+  }
+
+  try {
+    // Update the category's active status
+    await db
+      .updateTable('categories')
+      .set({
+        is_active: isActive,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .execute()
+
+    // Fetch the updated category
+    return await fetchById(id)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update category active status: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Move category to a different parent
+ *
+ * @param id The ID of the category to move
+ * @param newParentId The ID of the new parent category, or null to make it a root category
+ * @returns The updated category
+ */
+export async function updateParent(id: number, newParentId: string | null): Promise<CategoryRow | undefined> {
+  // Check if category exists
+  const category = await fetchById(id)
+
+  if (!category) {
+    throw new Error(`Category with ID ${id} not found`)
+  }
+
+  // If moving to a parent, check that the parent exists and is not the same category
+  if (newParentId) {
+    // Convert to number for comparison since id is number
+    const newParentIdNum = Number(newParentId)
+
+    if (newParentIdNum === id) {
+      throw new Error('A category cannot be its own parent')
+    }
+
+    const parentCategory = await fetchById(newParentIdNum)
+    if (!parentCategory) {
+      throw new Error(`Parent category with ID ${newParentId} not found`)
+    }
+
+    // Check for circular reference
+    if (await wouldCreateCircularReference(id, newParentId)) {
+      throw new Error('This operation would create a circular reference in the category hierarchy')
+    }
+  }
+
+  try {
+    // Update the category's parent
+    const updateObject: { updated_at: string, parent_category_id?: string | undefined } = {
+      updated_at: formatDate(new Date()),
+    }
+
+    // Set parent_category_id explicitly based on whether newParentId is null
+    if (newParentId === null) {
+      await db
+        .updateTable('categories')
+        .set({
+          ...updateObject,
+          parent_category_id: undefined,
+        })
+        .where('id', '=', id)
+        .execute()
+    }
+    else {
+      await db
+        .updateTable('categories')
+        .set({
+          ...updateObject,
+          parent_category_id: newParentId,
+        })
+        .where('id', '=', id)
+        .execute()
+    }
+
+    // Fetch the updated category
+    return await fetchById(id)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update category parent: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Helper function to check if changing a category's parent would create a circular reference
+ * @param categoryId ID of the category being moved
+ * @param newParentId ID of the new parent
+ * @returns boolean indicating if a circular reference would be created
+ */
+async function wouldCreateCircularReference(categoryId: number, newParentId: string): Promise<boolean> {
+  // Convert to number for consistency in the check
+  let currentParentId = Number(newParentId)
+  const visited = new Set<number>()
+
+  while (currentParentId) {
+    // If we've seen this ID before, we have a cycle
+    if (visited.has(currentParentId)) {
+      return true
+    }
+
+    // If we've reached the original category, we have a cycle
+    if (currentParentId === categoryId) {
+      return true
+    }
+
+    visited.add(currentParentId)
+
+    // Get the parent's parent
+    const parent = await fetchById(currentParentId)
+    if (!parent || !parent.parentCategoryId) {
+      // We've reached a root category, no cycle
+      return false
+    }
+
+    currentParentId = Number(parent.parentCategoryId)
+  }
+
+  return false
+}

package/src/products/index.ts

@@ -0,0 +1,35 @@
+import * as categories from './categories'
+import * as items from './items'
+import * as manufacturers from './manufacturers'
+import * as reviews from './reviews'
+import * as units from './units'
+import * as variants from './variants'
+
+export {
+  categories,
+  items,
+  manufacturers,
+  reviews,
+  units,
+  variants,
+}
+
+interface ProductsNamespace {
+  categories: typeof categories
+  items: typeof items
+  manufacturers: typeof manufacturers
+  reviews: typeof reviews
+  units: typeof units
+  variants: typeof variants
+}
+
+const products: ProductsNamespace = {
+  categories,
+  items,
+  manufacturers,
+  reviews,
+  units,
+  variants,
+}
+
+export default products