@stacksjs/commerce 0.70.55 → 0.70.57

package/src/coupons/fetch.ts

@@ -1,510 +0,0 @@
-import type { CouponCountStats, CouponRedemptionStats, CouponStats, CouponTimeStats } from '../types'
-import type { StacksExpressionBuilder } from '@stacksjs/database'
-import { db } from '@stacksjs/database'
-import { extractDate, formatDate } from '@stacksjs/orm'
-type CouponJsonResponse = ModelRow<typeof Coupon>
-
-/**
- * Process coupon data from the database
- * Parses JSON strings for applicable_products and applicable_categories
- */
-function processCouponData(coupon: CouponJsonResponse): CouponJsonResponse {
-  // Create a copy to avoid modifying the original object
-  const processed = { ...coupon }
-
-  if (processed.endDate) {
-    processed.endDate = extractDate(new Date(processed.endDate))
-  }
-  if (processed.startDate) {
-    processed.startDate = extractDate(new Date(processed.startDate))
-  }
-
-  // Convert isActive to boolean if needed
-  if (processed.isActive !== undefined) {
-    processed.isActive = Boolean(processed.isActive)
-  }
-
-  return processed
-}
-
-/**
- * Fetch all coupons from the database
- */
-export async function fetchAll(): Promise<CouponJsonResponse[]> {
-  const coupons = await db
-    .selectFrom('coupons')
-    .selectAll()
-    .execute()
-
-  return (coupons as CouponJsonResponse[]).map(processCouponData)
-}
-
-/**
- * Fetch a coupon by ID
- */
-export async function fetchById(id: number): Promise<CouponJsonResponse | undefined> {
-  const coupon = await db
-    .selectFrom('coupons')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst()
-
-  if (coupon) {
-    return processCouponData(coupon as CouponJsonResponse)
-  }
-
-  return undefined
-}
-
-/**
- * Fetch a coupon by code
- */
-export async function fetchByCode(code: string): Promise<CouponJsonResponse | undefined> {
-  const coupon = await db
-    .selectFrom('coupons')
-    .where('code', '=', code)
-    .selectAll()
-    .executeTakeFirst()
-
-  if (coupon) {
-    return processCouponData(coupon as CouponJsonResponse)
-  }
-
-  return undefined
-}
-
-/**
- * Fetch active coupons (is_active = true and within date range)
- */
-export async function fetchActive(): Promise<CouponJsonResponse[]> {
-  const currentDate = formatDate(new Date())
-
-  const coupons = await db
-    .selectFrom('coupons')
-    .where('is_active', '=', true)
-    .where('start_date', '<=', currentDate)
-    .where('end_date', '>=', currentDate)
-    .selectAll()
-    .execute()
-
-  return (coupons as CouponJsonResponse[]).map(processCouponData)
-}
-
-/**
- * Get coupon statistics
- */
-export async function fetchStats(): Promise<CouponStats> {
-  // Total coupons
-  const totalCoupons = await db
-    .selectFrom('coupons')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Active coupons
-  const currentDate = formatDate(new Date())
-  const activeCoupons = await db
-    .selectFrom('coupons')
-    .where('is_active', '=', true)
-    .where('start_date', '<=', currentDate)
-    .where('end_date', '>=', currentDate)
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Coupons by discount type
-  const couponsByType = await db
-    .selectFrom('coupons')
-    .select(['discount_type', (eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')] as any)
-    .groupBy('discount_type')
-    .execute() as { discount_type: string, count: number }[]
-
-  // Most used coupons
-  const mostUsedCoupons = await db
-    .selectFrom('coupons')
-    .select(['id', 'code', 'discount_type', 'discount_value', 'usage_count'])
-    .orderBy('usage_count', 'desc')
-    .limit(5)
-    .execute() as { id: number, code: string, discount_type: string, discount_value: number, usage_count: number }[]
-
-  // Upcoming coupons (active but not yet started)
-  const upcomingCoupons = await db
-    .selectFrom('coupons')
-    .where('is_active', '=', true)
-    .where('start_date', '>', currentDate)
-    .select(['id', 'code', 'discount_type', 'discount_value', 'start_date', 'end_date'])
-    .orderBy('start_date', 'asc')
-    .limit(5)
-    .execute() as { id: number, code: string, discount_type: string, discount_value: number, start_date: string | Date, end_date: string | Date }[]
-
-  return {
-    total: Number(totalCoupons?.count || 0),
-    active: Number(activeCoupons?.count || 0),
-    by_type: couponsByType,
-    most_used: mostUsedCoupons,
-    upcoming: upcomingCoupons,
-  }
-}
-
-/**
- * Get count of active and inactive coupons for different time periods
- */
-export async function fetchCouponCounts(): Promise<CouponTimeStats> {
-  const currentDate = new Date()
-
-  // Calculate start dates for different periods
-  const weekStart = new Date(currentDate)
-  weekStart.setDate(currentDate.getDate() - 7)
-
-  const monthStart = new Date(currentDate)
-  monthStart.setMonth(currentDate.getMonth() - 1)
-
-  const yearStart = new Date(currentDate)
-  yearStart.setFullYear(currentDate.getFullYear() - 1)
-
-  // All-time counts
-  const allTimeCounts = await fetchCountsForPeriod(null, null, currentDate)
-
-  // Week counts
-  const weekCounts = await fetchCountsForPeriod(weekStart, null, currentDate)
-
-  // Month counts
-  const monthCounts = await fetchCountsForPeriod(monthStart, null, currentDate)
-
-  // Year counts
-  const yearCounts = await fetchCountsForPeriod(yearStart, null, currentDate)
-
-  return {
-    week: weekCounts,
-    month: monthCounts,
-    year: yearCounts,
-    all_time: allTimeCounts,
-  }
-}
-
-/**
- * Helper function to fetch coupon counts for a specific time period
- *
- * @param startDate - Start of the period (or null for all time)
- * @param endDate - End of the period (or null for current date)
- * @param currentDate - Current date for active/inactive calculation
- */
-async function fetchCountsForPeriod(
-  startDate: Date | null,
-  endDate: Date | null,
-  currentDate: Date,
-): Promise<CouponCountStats> {
-  let query = db.selectFrom('coupons') as any
-
-  // Apply date filter if startDate is provided
-  if (startDate) {
-    query = query.where('created_at', '>=', startDate.toISOString())
-  }
-
-  // Apply end date filter if endDate is provided
-  if (endDate) {
-    query = query.where('created_at', '<=', endDate.toISOString())
-  }
-
-  // Get total count
-  const totalResult = await query
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Get active count (is_active = true, start_date <= current date, end_date >= current date)
-  // Create a new query instead of cloning
-  let activeQuery = db.selectFrom('coupons') as any
-
-  // Apply the same date filters as the total query if needed
-  if (startDate) {
-    activeQuery = activeQuery.where('created_at', '>=', startDate.toISOString())
-  }
-
-  if (endDate) {
-    activeQuery = activeQuery.where('created_at', '<=', endDate.toISOString())
-  }
-
-  // Add active coupon conditions
-  activeQuery = activeQuery
-    .where('is_active', '=', true)
-    .where('start_date', '<=', currentDate)
-    .where('end_date', '>=', currentDate)
-
-  const activeResult = await activeQuery
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Calculate counts
-  const total = Number(totalResult?.count || 0)
-  const active = Number(activeResult?.count || 0)
-  const inactive = total - active
-
-  return {
-    total,
-    active,
-    inactive,
-  }
-}
-
-/**
- * Get detailed breakdown of active/inactive coupons by discount type
- */
-export async function fetchCouponCountsByType(): Promise<Record<string, CouponCountStats>> {
-  const currentDate = new Date()
-
-  // Get all discount types
-  const discountTypes = await db
-    .selectFrom('coupons')
-    .select('discount_type' as any)
-    .distinct()
-    .execute() as { discount_type: string }[]
-
-  const result: Record<string, CouponCountStats> = {}
-
-  // For each discount type, get the counts
-  for (const { discount_type } of discountTypes) {
-    // Total count for this type
-    const totalResult = await db
-      .selectFrom('coupons')
-      .where('discount_type', '=', discount_type)
-      .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-      .executeTakeFirst() as { count: number } | undefined
-
-    // Active count for this type - create a new query instead of cloning
-    const activeResult = await db
-      .selectFrom('coupons')
-      .where('discount_type', '=', discount_type)
-      .where('is_active', '=', true)
-      .where('start_date', '<=', currentDate)
-      .where('end_date', '>=', currentDate)
-      .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-      .executeTakeFirst() as { count: number } | undefined
-
-    const total = Number(totalResult?.count || 0)
-    const active = Number(activeResult?.count || 0)
-
-    result[discount_type] = {
-      total,
-      active,
-      inactive: total - active,
-    }
-  }
-
-  return result
-}
-
-/**
- * Fetch coupon redemption statistics based on usage_count
- */
-export async function fetchRedemptionStats(): Promise<CouponRedemptionStats> {
-  // Total redemptions (sum of all usage_count)
-  const totalResult = await db
-    .selectFrom('coupons')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.sum('usage_count').as('total')) as any)
-    .executeTakeFirst() as { total: number } | undefined
-
-  const currentDate = new Date()
-
-  // Calculate start dates for different periods
-  const weekStart = new Date(currentDate)
-  weekStart.setDate(currentDate.getDate() - 7)
-
-  const monthStart = new Date(currentDate)
-  monthStart.setMonth(currentDate.getMonth() - 1)
-
-  const yearStart = new Date(currentDate)
-  yearStart.setFullYear(currentDate.getFullYear() - 1)
-
-  // Weekly redemptions (for coupons updated in the last week)
-  const weekResult = await db
-    .selectFrom('coupons')
-    .where('updated_at', '>=', weekStart.toISOString())
-    .select(((eb: StacksExpressionBuilder) => eb.fn.sum('usage_count').as('total')) as any)
-    .executeTakeFirst() as { total: number } | undefined
-
-  // Monthly redemptions
-  const monthResult = await db
-    .selectFrom('coupons')
-    .where('updated_at', '>=', monthStart.toISOString())
-    .select(((eb: StacksExpressionBuilder) => eb.fn.sum('usage_count').as('total')) as any)
-    .executeTakeFirst() as { total: number } | undefined
-
-  // Yearly redemptions
-  const yearResult = await db
-    .selectFrom('coupons')
-    .where('updated_at', '>=', yearStart.toISOString())
-    .select(((eb: StacksExpressionBuilder) => eb.fn.sum('usage_count').as('total')) as any)
-    .executeTakeFirst() as { total: number } | undefined
-
-  // Redemptions by discount type
-  const byTypeResults = await db
-    .selectFrom('coupons')
-    .select(['discount_type', (eb: StacksExpressionBuilder) => eb.fn.sum('usage_count').as('total')] as any)
-    .groupBy('discount_type')
-    .execute() as { discount_type: string, total: number }[]
-
-  const byType: Record<string, number> = {}
-  byTypeResults.forEach((item: any) => {
-    byType[item.discount_type] = Number(item.total || 0)
-  })
-
-  return {
-    total: Number(totalResult?.total || 0),
-    week: Number(weekResult?.total || 0),
-    month: Number(monthResult?.total || 0),
-    year: Number(yearResult?.total || 0),
-    by_type: byType,
-  }
-}
-
-/**
- * Get top redeemed coupons
- */
-export async function fetchTopRedeemedCoupons(limit: number = 5): Promise<any[]> {
-  return await db
-    .selectFrom('coupons')
-    .select([
-      'id',
-      'code',
-      'discount_type',
-      'discount_value',
-      'usage_count',
-      'start_date',
-      'end_date',
-    ])
-    .where('usage_count', '>', 0)
-    .orderBy('usage_count', 'desc')
-    .limit(limit)
-    .execute()
-}
-
-/**
- * Get redemption trend data in a simplified manner
- */
-export async function fetchRedemptionTrend(days: number = 30): Promise<any[]> {
-  const endDate = new Date().toISOString()
-  const startDate = new Date()
-  startDate.setDate(startDate.getDate() - days)
-
-  // Get coupons updated in the specified timeframe
-  const coupons = await db
-    .selectFrom('coupons')
-    .select(['id', 'code', 'updated_at', 'usage_count'])
-    .where('updated_at', '>=', startDate.toISOString())
-    .where('updated_at', '<=', endDate)
-    .where('usage_count', '>', 0)
-    .orderBy('updated_at', 'desc')
-    .execute()
-
-  // Group by date (this is done in JS rather than SQL for simplicity)
-  const trendData: Record<string, number> = {}
-
-  coupons.forEach((coupon: any) => {
-    // Format date as YYYY-MM-DD
-    const dateString = coupon.updated_at
-      ? new Date(coupon.updated_at).toISOString().split('T')[0]
-      : 'unknown-date' // Fallback for undefined date
-
-    // Add or increment the count for this date
-    if (!trendData[dateString]) {
-      trendData[dateString] = 0
-    }
-    trendData[dateString] += coupon?.usage_count || 0
-  })
-
-  // Convert to array format
-  return Object.entries(trendData).map(([date, count]) => ({
-    date,
-    count,
-  }))
-}
-
-/**
- * Get conversion rate (number of redemptions / number of active coupons)
- */
-export async function fetchConversionRate(): Promise<{
-  rate: number
-  total_active: number
-  total_redeemed: number
-}> {
-  const currentDate = new Date()
-
-  // Get count of active coupons
-  const activeResult = await db
-    .selectFrom('coupons')
-    .where('is_active', '=', true)
-    .where('start_date', '<=', currentDate)
-    .where('end_date', '>=', currentDate)
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Get count of coupons with usage > 0
-  const redeemedResult = await db
-    .selectFrom('coupons')
-    .where('usage_count', '>', 0)
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .executeTakeFirst() as { count: number } | undefined
-
-  const totalActive = Number(activeResult?.count || 0)
-  const totalRedeemed = Number(redeemedResult?.count || 0)
-
-  // Calculate rate (avoid division by zero)
-  const rate = totalActive > 0 ? (totalRedeemed / totalActive) * 100 : 0
-
-  return {
-    rate,
-    total_active: totalActive,
-    total_redeemed: totalRedeemed,
-  }
-}
-
-/**
- * Calculate the month-over-month change in active coupons
- */
-export async function getActiveCouponsMoMChange(): Promise<{
-  current_month: number
-  previous_month: number
-  difference: number
-  percentage_change: number
-}> {
-  const today = new Date()
-
-  // Current month (start of current month to today)
-  const currentMonthStart = new Date(today.getFullYear(), today.getMonth(), 1)
-
-  // Previous month
-  const previousMonthStart = new Date(today.getFullYear(), today.getMonth() - 1, 1)
-  const previousMonthEnd = new Date(today.getFullYear(), today.getMonth(), 0)
-
-  // Get active coupons for current month
-  const currentMonthActive = await db
-    .selectFrom('coupons')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .where('is_active', '=', true)
-    .where('start_date', '<=', today)
-    .where('end_date', '>=', currentMonthStart)
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Get active coupons for previous month
-  const previousMonthActive = await db
-    .selectFrom('coupons')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .where('is_active', '=', true)
-    .where('start_date', '<=', previousMonthEnd)
-    .where('end_date', '>=', previousMonthStart)
-    .executeTakeFirst() as { count: number } | undefined
-
-  const currentCount = Number(currentMonthActive?.count || 0)
-  const previousCount = Number(previousMonthActive?.count || 0)
-  const difference = currentCount - previousCount
-
-  // Calculate percentage change, handling division by zero
-  const percentageChange = previousCount !== 0
-    ? (difference / previousCount) * 100
-    : (currentCount > 0 ? 100 : 0) // If previous month was 0, and current is > 0, that's a 100% increase
-
-  return {
-    current_month: currentCount,
-    previous_month: previousCount,
-    difference,
-    percentage_change: percentageChange,
-  }
-}

package/src/coupons/index.ts

@@ -1,30 +0,0 @@
-export {
-  deleteCoupon,
-  deleteCoupons,
-  deleteExpiredCoupons,
-} from './destroy'
-
-export {
-  fetchActive,
-  fetchAll,
-  fetchByCode,
-  fetchById,
-  fetchConversionRate,
-  fetchCouponCounts,
-  fetchCouponCountsByType,
-  fetchRedemptionStats,
-  fetchRedemptionTrend,
-  fetchStats,
-  fetchTopRedeemedCoupons,
-  getActiveCouponsMoMChange,
-} from './fetch'
-
-export {
-  store,
-} from './store'
-
-export {
-  redeem,
-  update,
-} from './update'
-export type { CouponRedemptionResult } from './update'

package/src/coupons/store.ts

@@ -1,46 +0,0 @@
-type CouponJsonResponse = ModelRow<typeof Coupon>
-type NewCoupon = NewModelData<typeof Coupon>
-import { db } from '@stacksjs/database'
-import { HttpError } from '@stacksjs/error-handling'
-import { isUniqueViolation } from '@stacksjs/orm'
-
-/**
- * Create a new coupon
- *
- * @param data The coupon data to store
- * @returns The newly created coupon record
- */
-export async function store(data: NewCoupon): Promise<CouponJsonResponse | undefined> {
-  try {
-    // Insert the coupon record
-    const createdCoupon = await db
-      .insertInto('coupons')
-      .values(data)
-      .executeTakeFirst()
-
-    const couponId = Number(createdCoupon.insertId) || Number(createdCoupon.numInsertedOrUpdatedRows)
-
-    if (couponId) {
-      const coupon = await db
-        .selectFrom('coupons')
-        .where('id', '=', couponId)
-        .selectAll()
-        .executeTakeFirst()
-
-      return coupon as CouponJsonResponse
-    }
-
-    return undefined
-  }
-  catch (error) {
-    if (error instanceof HttpError)
-      throw error
-    // Cross-dialect duplicate detection (#1957) — replaces the MySQL-only
-    // 'Duplicate entry' sniff so SQLite/Postgres duplicates also map to 409.
-    if (isUniqueViolation(error))
-      throw new HttpError(409, 'A coupon with this code already exists')
-    if (error instanceof Error)
-      throw new Error(`Failed to create coupon: ${error.message}`)
-    throw error
-  }
-}