@stacksjs/commerce 0.70.55 → 0.70.56

package/src/waitlists/restaurant/fetch.ts

@@ -1,538 +0,0 @@
-import type { StacksExpressionBuilder } from '@stacksjs/database'
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-type WaitlistRestaurantJsonResponse = ModelRow<typeof WaitlistRestaurant>
-
-/**
- * Fetch a restaurant waitlist entry by ID
- */
-export async function fetchById(id: number): Promise<WaitlistRestaurantJsonResponse | undefined> {
-  return await db
-    .selectFrom('waitlist_restaurants')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst() as WaitlistRestaurantJsonResponse | undefined
-}
-
-/**
- * Fetch all restaurant waitlist entries
- */
-export async function fetchAll(): Promise<WaitlistRestaurantJsonResponse[]> {
-  return await db.selectFrom('waitlist_restaurants').selectAll().execute() as WaitlistRestaurantJsonResponse[]
-}
-
-/**
- * Fetch the count of restaurant waitlist entries grouped by table preference
- * @returns An object containing the count for each table preference
- */
-export async function fetchCountByTablePreference(): Promise<Record<string, number>> {
-  const results = await db
-    .selectFrom('waitlist_restaurants')
-    .select(['table_preference', (eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')] as any)
-    .groupBy('table_preference')
-    .execute() as { table_preference: string, count: number }[]
-
-  return results.reduce((acc: Record<string, number>, { table_preference, count }) => {
-    acc[table_preference as string] = count
-    return acc
-  }, {} as Record<string, number>)
-}
-
-/**
- * Fetch the count of restaurant waitlist entries for a specific date
- * @param date The date to count entries for (defaults to today)
- * @returns The count of entries for the specified date
- */
-export async function fetchCountByDate(date: Date = new Date()): Promise<number> {
-  const startOfDay = new Date(date)
-  startOfDay.setHours(0, 0, 0, 0)
-
-  const endOfDay = new Date(date)
-  endOfDay.setHours(23, 59, 59, 999)
-
-  const startDateStr = formatDate(startOfDay)
-  const endDateStr = formatDate(endOfDay)
-
-  const result = await db
-    .selectFrom('waitlist_restaurants')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .where('created_at', '>=', startDateStr)
-    .where('created_at', '<=', endDateStr)
-    .executeTakeFirst() as { count: number } | undefined
-
-  return result?.count ?? 0
-}
-
-/**
- * Fetch the count of restaurant waitlist entries with a specific party size
- * @param partySize The party size to count entries for
- * @returns The count of entries with the specified party size
- */
-export async function fetchCountByPartySize(partySize: number): Promise<number> {
-  const result = await db
-    .selectFrom('waitlist_restaurants')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .where('party_size', '=', partySize)
-    .executeTakeFirst() as { count: number } | undefined
-
-  return result?.count ?? 0
-}
-
-/**
- * Fetch the count of restaurant waitlist entries grouped by party size
- * @returns An object containing the count for each party size
- */
-export async function fetchCountByAllPartySizes(): Promise<Record<number, number>> {
-  const results = await db
-    .selectFrom('waitlist_restaurants')
-    .select(['party_size', (eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')] as any)
-    .groupBy('party_size')
-    .execute() as { party_size: number, count: number }[]
-
-  return results.reduce((acc: Record<number, number>, { party_size, count }) => {
-    acc[party_size] = count
-    return acc
-  }, {} as Record<number, number>)
-}
-
-/**
- * Fetch restaurant waitlist entries between two dates
- * @param startDate The start date of the range
- * @param endDate The end date of the range
- * @returns Array of waitlist entries within the date range
- */
-export async function fetchBetweenDates(
-  startDate: Date,
-  _endDate: Date,
-): Promise<WaitlistRestaurantJsonResponse[]> {
-  const startDateStr = formatDate(startDate)
-  const endDateStr = formatDate(_endDate)
-
-  return await db
-    .selectFrom('waitlist_restaurants')
-    .selectAll()
-    .where('created_at', '>=', startDateStr)
-    .where('created_at', '<=', endDateStr)
-    .execute() as WaitlistRestaurantJsonResponse[]
-}
-
-/**
- * Fetch restaurant waitlist entries that were seated between two dates
- * @param startDate The start date of the range
- * @param endDate The end date of the range
- * @returns Array of waitlist entries that were seated within the date range
- */
-export async function fetchSeatedBetweenDates(
-  startDate: Date,
-  _endDate: Date,
-): Promise<WaitlistRestaurantJsonResponse[]> {
-  const startDateStr = formatDate(startDate)
-  const endDateStr = formatDate(_endDate)
-
-  return await db
-    .selectFrom('waitlist_restaurants')
-    .selectAll()
-    .where('check_in_time', '>=', startDateStr)
-    .where('check_in_time', '<=', endDateStr)
-    .where('status', '=', 'seated')
-    .execute() as WaitlistRestaurantJsonResponse[]
-}
-
-/**
- * Fetch all restaurant waitlist entries with waiting status
- * @returns Array of waitlist entries with waiting status
- */
-export async function fetchWaiting(): Promise<WaitlistRestaurantJsonResponse[]> {
-  return await db
-    .selectFrom('waitlist_restaurants')
-    .selectAll()
-    .where('status', '=', 'waiting')
-    .execute() as WaitlistRestaurantJsonResponse[]
-}
-
-/**
- * Fetch conversion rates for restaurant waitlist entries
- * @returns Object containing total conversion rate and breakdown by status
- */
-export async function fetchConversionRates(): Promise<{
-  totalConversionRate: number
-  statusBreakdown: Record<string, { count: number, percentage: number }>
-}> {
-  const results = await db
-    .selectFrom('waitlist_restaurants')
-    .select(['status', (eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')] as any)
-    .groupBy('status')
-    .execute() as { status: string, count: number }[]
-
-  const totalCount = results.reduce((sum: number, { count }) => sum + count, 0)
-  const seatedCount = results.find((r) => r.status === 'seated')?.count ?? 0
-
-  const totalConversionRate = totalCount > 0 ? (Number(seatedCount) / totalCount) * 100 : 0
-
-  const statusBreakdown = results.reduce((acc: Record<string, { count: number, percentage: number }>, { status, count }) => {
-    acc[status as string] = {
-      count,
-      percentage: totalCount > 0 ? (count / totalCount) * 100 : 0,
-    }
-    return acc
-  }, {} as Record<string, { count: number, percentage: number }>)
-
-  return {
-    totalConversionRate,
-    statusBreakdown,
-  }
-}
-
-/**
- * Fetch average wait times for restaurant waitlist entries
- * @returns Object containing average quoted and actual wait times
- */
-export async function fetchAverageWaitTimes(): Promise<{
-  averageQuotedWaitTime: number
-  averageActualWaitTime: number
-}> {
-  const result = await db
-    .selectFrom('waitlist_restaurants')
-    .select([(eb: StacksExpressionBuilder) => eb.fn.avg('quoted_wait_time').as('avg_quoted_wait_time'), (eb: StacksExpressionBuilder) => eb.fn.avg('actual_wait_time').as('avg_actual_wait_time')] as any)
-    .executeTakeFirst() as { avg_quoted_wait_time: number, avg_actual_wait_time: number } | undefined
-
-  return {
-    averageQuotedWaitTime: result?.avg_quoted_wait_time ?? 0,
-    averageActualWaitTime: result?.avg_actual_wait_time ?? 0,
-  }
-}
-
-/**
- * Fetch all waiting entries with their quoted wait times
- * @returns Array of waiting entries with their quoted wait times
- */
-export async function fetchWaitingWithQuotedTimes(): Promise<{
-  entries: WaitlistRestaurantJsonResponse[]
-  totalQuotedWaitTime: number
-  averageQuotedWaitTime: number
-}> {
-  const waitingEntries = await db
-    .selectFrom('waitlist_restaurants')
-    .selectAll()
-    .where('status', '=', 'waiting')
-    .execute() as WaitlistRestaurantJsonResponse[]
-
-  const totalQuotedWaitTime = waitingEntries.reduce((sum: any, entry: any) => sum + (entry.quoted_wait_time ?? 0), 0)
-  const averageQuotedWaitTime = waitingEntries.length > 0 ? totalQuotedWaitTime / waitingEntries.length : 0
-
-  return {
-    entries: waitingEntries,
-    totalQuotedWaitTime,
-    averageQuotedWaitTime,
-  }
-}
-
-/**
- * Fetch all waiting entries with party size calculations
- * @returns Object containing waiting entries and party size statistics
- */
-export async function fetchWaitingWithPartySizes(): Promise<{
-  entries: WaitlistRestaurantJsonResponse[]
-  totalPartySize: number
-  averagePartySize: number
-  partySizeBreakdown: Record<number, number>
-}> {
-  const waitingEntries = await db
-    .selectFrom('waitlist_restaurants')
-    .selectAll()
-    .where('status', '=', 'waiting')
-    .execute() as WaitlistRestaurantJsonResponse[]
-
-  const totalPartySize = waitingEntries.reduce((sum: any, entry: any) => sum + entry.party_size, 0)
-  const averagePartySize = waitingEntries.length > 0 ? totalPartySize / waitingEntries.length : 0
-
-  // Calculate breakdown of party sizes
-  const partySizeBreakdown = waitingEntries.reduce((acc: any, entry: any) => {
-    acc[entry.party_size] = (acc[entry.party_size] || 0) + 1
-    return acc
-  }, {} as Record<number, number>)
-
-  return {
-    entries: waitingEntries as WaitlistRestaurantJsonResponse[],
-    totalPartySize,
-    averagePartySize,
-    partySizeBreakdown,
-  }
-}
-
-/**
- * Fetch tables turned statistics for today
- * @returns Object containing tables turned statistics
- */
-export async function fetchTablesTurnedToday(): Promise<{
-  totalTablesTurned: number
-  averagePartySize: number
-  totalCustomersSeated: number
-  breakdownByTablePreference: Record<string, number>
-  breakdownByPartySize: Record<number, number>
-}> {
-  const today = new Date()
-  const startOfDay = new Date(today)
-  startOfDay.setHours(0, 0, 0, 0)
-  const endOfDay = new Date(today)
-  endOfDay.setHours(23, 59, 59, 999)
-
-  const startDateStr = formatDate(startOfDay)
-  const endDateStr = formatDate(endOfDay)
-
-  // Fetch all seated entries for today
-  const seatedEntries = await db
-    .selectFrom('waitlist_restaurants')
-    .selectAll()
-    .where('status', '=', 'seated')
-    .where('check_in_time', '>=', startDateStr)
-    .where('check_in_time', '<=', endDateStr)
-    .execute()
-
-  // Calculate total tables turned
-  const totalTablesTurned = seatedEntries.length
-
-  // Calculate total customers seated
-  const totalCustomersSeated = seatedEntries.reduce((sum: any, entry: any) => sum + entry.party_size, 0)
-
-  // Calculate average party size
-  const averagePartySize = totalTablesTurned > 0 ? totalCustomersSeated / totalTablesTurned : 0
-
-  // Calculate breakdown by table preference
-  const breakdownByTablePreference = seatedEntries.reduce((acc: any, entry: any) => {
-    acc[entry.table_preference as string] = (acc[entry.table_preference as string] || 0) + 1
-    return acc
-  }, {} as Record<string, number>)
-
-  // Calculate breakdown by party size
-  const breakdownByPartySize = seatedEntries.reduce((acc: any, entry: any) => {
-    acc[entry.party_size] = (acc[entry.party_size] || 0) + 1
-    return acc
-  }, {} as Record<number, number>)
-
-  return {
-    totalTablesTurned,
-    averagePartySize,
-    totalCustomersSeated,
-    breakdownByTablePreference,
-    breakdownByPartySize,
-  }
-}
-
-/**
- * Fetch seating rate statistics
- * @param startDate Start date for filtering entries
- * @param endDate End date for filtering entries
- * @returns Object containing seating rate and status breakdown
- */
-export async function fetchSeatingRate(
-  _startDate: Date,
-  _endDate: Date,
-): Promise<{
-    totalEntries: number
-    seatedEntries: number
-    seatingRate: number
-    statusBreakdown: Record<string, { count: number, percentage: number }>
-  }> {
-  const startDateStr = formatDate(_startDate)
-  const endDateStr = formatDate(_endDate)
-
-  const results = await db
-    .selectFrom('waitlist_restaurants')
-    .select(['status', (eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')] as any)
-    .where('check_in_time', '>=', startDateStr)
-    .where('check_in_time', '<=', endDateStr)
-    .groupBy('status')
-    .execute() as { status: string, count: number }[]
-
-  const totalEntries = results.reduce((sum: number, { count }) => sum + count, 0)
-  const seatedCount = results.find((r) => r.status === 'seated')?.count ?? 0
-
-  const seatingRate = totalEntries > 0 ? (Number(seatedCount) / totalEntries) * 100 : 0
-
-  const statusBreakdown = results.reduce((acc: Record<string, { count: number, percentage: number }>, { status, count }) => {
-    acc[status as string] = {
-      count,
-      percentage: totalEntries > 0 ? (count / totalEntries) * 100 : 0,
-    }
-    return acc
-  }, {} as Record<string, { count: number, percentage: number }>)
-
-  return {
-    totalEntries,
-    seatedEntries: seatedCount,
-    seatingRate,
-    statusBreakdown,
-  }
-}
-
-/**
- * Fetch no-show statistics
- * @param startDate Start date for filtering entries
- * @param endDate End date for filtering entries
- * @returns Object containing no-show statistics and related information
- */
-export async function fetchNoShowStats(
-  _startDate: Date,
-  _endDate: Date,
-): Promise<{
-    totalNoShows: number
-    noShowRate: number
-    averageQuotedWaitTime: number
-    averagePartySize: number
-    breakdownByTablePreference: Record<string, number>
-    breakdownByPartySize: Record<number, number>
-  }> {
-  const startDateStr = formatDate(_startDate)
-  const endDateStr = formatDate(_endDate)
-
-  // Build base query for no-show entries
-  const noShowQuery = db
-    .selectFrom('waitlist_restaurants')
-    .selectAll()
-    .where('status', '=', 'no_show')
-    .where('check_in_time', '>=', startDateStr)
-    .where('check_in_time', '<=', endDateStr)
-
-  // Build base query for total entries - use expression builder for count
-  const totalResult = await db
-    .selectFrom('waitlist_restaurants')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .where('check_in_time', '>=', startDateStr)
-    .where('check_in_time', '<=', endDateStr)
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Execute queries
-  const noShowEntries = await noShowQuery.execute()
-
-  const totalNoShows = noShowEntries.length
-
-  const noShowRate = totalResult?.count && totalResult.count > 0
-    ? (totalNoShows / totalResult.count) * 100
-    : 0
-
-  // Calculate average quoted wait time for no-shows
-  const totalQuotedWaitTime = noShowEntries.reduce((sum: any, entry: any) => sum + (entry.quoted_wait_time ?? 0), 0)
-  const averageQuotedWaitTime = totalNoShows > 0 ? totalQuotedWaitTime / totalNoShows : 0
-
-  // Calculate average party size for no-shows
-  const totalPartySize = noShowEntries.reduce((sum: any, entry: any) => sum + entry.party_size, 0)
-  const averagePartySize = totalNoShows > 0 ? totalPartySize / totalNoShows : 0
-
-  // Calculate breakdown by table preference
-  const breakdownByTablePreference = noShowEntries.reduce((acc: any, entry: any) => {
-    acc[entry.table_preference as string] = (acc[entry.table_preference as string] || 0) + 1
-    return acc
-  }, {} as Record<string, number>)
-
-  // Calculate breakdown by party size
-  const breakdownByPartySize = noShowEntries.reduce((acc: any, entry: any) => {
-    acc[entry.party_size] = (acc[entry.party_size] || 0) + 1
-    return acc
-  }, {} as Record<number, number>)
-
-  return {
-    totalNoShows,
-    noShowRate,
-    averageQuotedWaitTime,
-    averagePartySize,
-    breakdownByTablePreference,
-    breakdownByPartySize,
-  }
-}
-
-/**
- * Fetch current wait time statistics
- * @returns Object containing average quoted and actual wait times
- */
-export async function fetchCurrentWaitTimes(): Promise<{
-  averageQuoted: number
-  averageActual: number
-}> {
-  const waitingEntries = await db
-    .selectFrom('waitlist_restaurants')
-    .select(['quoted_wait_time', 'actual_wait_time'])
-    .where('status', '=', 'waiting')
-    .execute()
-
-  const totalQuoted = waitingEntries.reduce((sum: any, entry: any) => sum + (entry.quoted_wait_time || 0), 0)
-  const totalActual = waitingEntries.reduce((sum: any, entry: any) => sum + (entry.actual_wait_time || 0), 0)
-  const count = waitingEntries.length
-
-  return {
-    averageQuoted: count > 0 ? totalQuoted / count : 0,
-    averageActual: count > 0 ? totalActual / count : 0,
-  }
-}
-
-/**
- * Fetch seated statistics for the last 24 hours
- * @returns Object containing total seated count and hourly breakdown
- */
-export async function fetchSeatedStats(): Promise<{
-  total: number
-  byHour: Array<{ hour: number, count: number }>
-}> {
-  const twentyFourHoursAgo = Date.now() - 24 * 60 * 60 * 1000
-  const seatedEntries = await db
-    .selectFrom('waitlist_restaurants')
-    .select(['seated_at'])
-    .where('status', '=', 'seated')
-    .where('seated_at', '>=', twentyFourHoursAgo)
-    .execute()
-
-  const byHour = Array.from({ length: 24 }, (_, hour) => ({
-    hour,
-    count: seatedEntries.filter((entry: any) => {
-      const entryHour = entry.seated_at
-
-      return entryHour === hour
-    }).length,
-  }))
-
-  return {
-    total: seatedEntries.length,
-    byHour,
-  }
-}
-
-/**
- * Fetch time series statistics for all statuses
- * @returns Object containing daily counts for each status
- */
-export async function fetchTimeSeriesStats(): Promise<Record<string, {
-  total: number
-  waiting: number
-  seated: number
-  cancelled: number
-  no_show: number
-}>> {
-  const entries = await db
-    .selectFrom('waitlist_restaurants')
-    .select(['created_at', 'status'])
-    .execute()
-
-  return entries.reduce((acc: any, curr: any) => {
-    const date = curr.created_at
-
-    if (!acc[date!]) {
-      acc[date!] = {
-        total: 0,
-        waiting: 0,
-        seated: 0,
-        cancelled: 0,
-        no_show: 0,
-      }
-    }
-    acc[date!].total++
-    acc[date!][curr.status]++
-
-    return acc
-  }, {} as Record<string, {
-    total: number
-    waiting: number
-    seated: number
-    cancelled: number
-    no_show: number
-  }>)
-}

package/src/waitlists/restaurant/index.ts

@@ -1,43 +0,0 @@
-// Functions from destroy.ts
-export {
-  bulkDestroy,
-  destroy,
-} from './destroy'
-
-// Functions from fetch.ts
-export {
-  fetchAll,
-  fetchAverageWaitTimes,
-  fetchBetweenDates,
-  fetchById,
-  fetchConversionRates,
-  fetchCountByAllPartySizes,
-  fetchCountByDate,
-  fetchCountByPartySize,
-  fetchCountByTablePreference,
-  fetchCurrentWaitTimes,
-  fetchNoShowStats,
-  fetchSeatedBetweenDates,
-  fetchSeatedStats,
-  fetchSeatingRate,
-  fetchTablesTurnedToday,
-  fetchTimeSeriesStats,
-  fetchWaiting,
-  fetchWaitingWithPartySizes,
-  fetchWaitingWithQuotedTimes,
-} from './fetch'
-
-// Functions from store.ts
-export {
-  bulkStore,
-  store,
-} from './store'
-
-// Functions from update.ts
-export {
-  update,
-  updatePartySize,
-  updateQueuePosition,
-  updateStatus,
-  updateWaitTimes,
-} from './update'

package/src/waitlists/restaurant/store.ts

@@ -1,109 +0,0 @@
-type WaitlistRestaurantJsonResponse = ModelRow<typeof WaitlistRestaurant>
-type NewWaitlistRestaurant = NewModelData<typeof WaitlistRestaurant>
-import { randomUUIDv7 } from 'bun'
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-
-/**
- * Create a new restaurant waitlist entry
- *
- * @param data Restaurant waitlist data to store
- * @returns The newly created restaurant waitlist record
- */
-export async function store(data: NewWaitlistRestaurant): Promise<WaitlistRestaurantJsonResponse> {
-  try {
-    const d = data as Record<string, unknown>
-    const waitlistData = {
-      name: data.name,
-      email: data.email,
-      phone: data.phone,
-      party_size: d.party_size,
-      check_in_time: typeof d.check_in_time === 'number' ? formatDate(d.check_in_time) : d.check_in_time,
-      table_preference: d.table_preference,
-      status: data.status || 'waiting',
-      quoted_wait_time: data.quoted_wait_time,
-      actual_wait_time: data.actual_wait_time,
-      queue_position: data.queue_position,
-      customer_id: data.customer_id,
-      uuid: randomUUIDv7(),
-    }
-
-    // Filter out undefined values to avoid storing explicit nulls
-    const filteredData: Record<string, any> = {}
-    for (const [key, value] of Object.entries(waitlistData)) {
-      if (value !== undefined) {
-        filteredData[key] = value
-      }
-    }
-
-    const result = await db
-      .insertInto('waitlist_restaurants')
-      .values(filteredData)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to create restaurant waitlist entry')
-
-    // Convert null values to undefined for nullable fields
-    const cleaned: any = { ...result }
-    for (const key of Object.keys(cleaned)) {
-      if (cleaned[key] === null)
-        cleaned[key] = undefined
-    }
-
-    return cleaned as WaitlistRestaurantJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create restaurant waitlist entry: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Create multiple restaurant waitlist entries at once
- *
- * @param data Array of restaurant waitlist data to store
- * @returns Number of restaurant waitlist entries created
- */
-export async function bulkStore(data: NewWaitlistRestaurant[]): Promise<number> {
-  if (!data.length)
-    return 0
-
-  try {
-    const waitlistDataArray = data.map((item) => {
-      const i = item as Record<string, unknown>
-      return {
-      name: item.name,
-      email: item.email,
-      phone: item.phone,
-      party_size: i.party_size,
-      check_in_time: typeof i.check_in_time === 'number' ? formatDate(i.check_in_time as number) : i.check_in_time,
-      table_preference: i.table_preference,
-      status: item.status || 'waiting',
-      quoted_wait_time: item.quoted_wait_time,
-      actual_wait_time: item.actual_wait_time,
-      queue_position: item.queue_position,
-      customer_id: item.customer_id,
-      uuid: randomUUIDv7(),
-    }
-    })
-
-    const result = await db
-      .insertInto('waitlist_restaurants')
-      .values(waitlistDataArray)
-      .executeTakeFirst()
-
-    return Number(result.numInsertedOrUpdatedRows)
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create restaurant waitlist entries in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}