@stacksjs/commerce 0.70.53 → 0.70.55

package/src/gift-cards/fetch.ts

@@ -0,0 +1,431 @@
+import type { GiftCardStats } from '../types'
+import type { StacksExpressionBuilder } from '@stacksjs/database'
+import { db, sql } from '@stacksjs/database'
+import { formatDate, toTimestamp } from '@stacksjs/orm'
+import { aggregateStats } from '../utils/typed-stats'
+type GiftCardJsonResponse = ModelRow<typeof GiftCard>
+
+/**
+ * Fetch all gift cards from the database
+ */
+export async function fetchAll(): Promise<GiftCardJsonResponse[]> {
+  const giftCards = await db
+    .selectFrom('gift_cards')
+    .selectAll()
+    .execute()
+
+  return giftCards as GiftCardJsonResponse[]
+}
+
+/**
+ * Fetch a gift card by ID
+ */
+export async function fetchById(id: number): Promise<GiftCardJsonResponse | undefined> {
+  return await db
+    .selectFrom('gift_cards')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as GiftCardJsonResponse | undefined
+}
+
+/**
+ * Fetch a gift card by code
+ */
+export async function fetchByCode(code: string): Promise<GiftCardJsonResponse | undefined> {
+  return await db
+    .selectFrom('gift_cards')
+    .where('code', '=', code)
+    .selectAll()
+    .executeTakeFirst() as GiftCardJsonResponse | undefined
+}
+
+/**
+ * Fetch active gift cards (is_active = true and not expired)
+ */
+export async function fetchActive(): Promise<GiftCardJsonResponse[]> {
+  const giftCards = await db
+    .selectFrom('gift_cards')
+    .where('is_active', '=', true)
+    .selectAll()
+    .execute()
+
+  return giftCards as GiftCardJsonResponse[]
+}
+
+/**
+ * Get gift card statistics
+ */
+export async function fetchStats(): Promise<GiftCardStats> {
+  // Total gift cards
+  const { count: totalCount } = await aggregateStats('gift_cards', { count: { kind: 'count' } })
+
+  // Active gift cards
+  const currentDate = toTimestamp(new Date())
+
+  // bun-query-builder doesn't expose a typed `eb.or([...])` helper, so the
+  // OR-with-NULL filter still uses the untyped expression-builder form.
+  // The boundary `as any` is localized; the result row uses the typed helper.
+  const activeGiftCards = await db
+    .selectFrom('gift_cards')
+    .where('is_active', '=', true)
+    .where('status', '=', 'ACTIVE')
+    .where(((eb: StacksExpressionBuilder) => eb.or([
+      eb('expiry_date', '>=', currentDate),
+      eb('expiry_date', 'is', null),
+    ])) as any)
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .executeTakeFirst() as { count: number } | undefined
+
+  // Gift cards by status
+  const giftCardsByStatus = await db
+    .selectFrom('gift_cards')
+    .select(['status', (eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')] as any)
+    .groupBy('status')
+    .execute() as { status: string, count: number }[]
+
+  // Balance distribution: each bucket needs a custom raw fraction filter, so
+  // these stay as direct queries — but we use the typed helper for the
+  // `count(id)` expression to avoid the `as any` chain on the result.
+  const { count: lowBalanceCount } = await aggregateStats('gift_cards', { count: { kind: 'count' } }, qb =>
+    qb.where(((eb: StacksExpressionBuilder) => sql`${eb.ref('current_balance')} / ${eb.ref('initial_balance')} < 0.25`) as any))
+
+  const { count: mediumBalanceCount } = await aggregateStats('gift_cards', { count: { kind: 'count' } }, qb =>
+    qb.where(((eb: StacksExpressionBuilder) => sql`${eb.ref('current_balance')} / ${eb.ref('initial_balance')} >= 0.25 AND ${eb.ref('current_balance')} / ${eb.ref('initial_balance')} <= 0.75`) as any))
+
+  const { count: highBalanceCount } = await aggregateStats('gift_cards', { count: { kind: 'count' } }, qb =>
+    qb.where(((eb: StacksExpressionBuilder) => sql`${eb.ref('current_balance')} / ${eb.ref('initial_balance')} > 0.75`) as any))
+
+  // Expiring soon gift cards (next 30 days)
+  const thirtyDaysFromNow = new Date()
+  thirtyDaysFromNow.setDate(thirtyDaysFromNow.getDate() + 30)
+
+  const expiringGiftCards = await db
+    .selectFrom('gift_cards')
+    .where('is_active', '=', true)
+    .where('status', '=', 'ACTIVE')
+    .where('expiry_date', '<=', toTimestamp(thirtyDaysFromNow))
+    .where('expiry_date', '>=', currentDate)
+    .selectAll()
+    .limit(5)
+    .execute()
+
+  // Recently used gift cards
+  const recentlyUsedGiftCards = await db
+    .selectFrom('gift_cards')
+    .where('last_used_date', 'is not', null)
+    .selectAll()
+    .limit(5)
+    .execute()
+
+  return {
+    total: totalCount,
+    active: Number(activeGiftCards?.count || 0),
+    by_status: giftCardsByStatus.map((item: { status: string, count: number }) => ({
+      status: item.status,
+      count: Number(item.count),
+    })),
+    by_balance: {
+      low: lowBalanceCount,
+      medium: mediumBalanceCount,
+      high: highBalanceCount,
+    },
+    expiring_soon: expiringGiftCards as GiftCardJsonResponse[],
+    recently_used: recentlyUsedGiftCards as GiftCardJsonResponse[],
+  }
+}
+
+/**
+ * Check gift card balance by code
+ */
+export async function checkBalance(code: string): Promise<{ valid: boolean, balance?: number, currency?: string, message?: string }> {
+  const giftCard = await fetchByCode(code)
+
+  if (!giftCard) {
+    return { valid: false, message: 'Gift card not found' }
+  }
+
+  if (!giftCard.isActive || giftCard.status !== 'ACTIVE') {
+    return {
+      valid: false,
+      balance: giftCard.currentBalance,
+      currency: giftCard.currency,
+      message: `Gift card is ${giftCard.status.toLowerCase()}`,
+    }
+  }
+
+  // Check if expired
+  if (giftCard.expiryDate) {
+    const expiryDate = new Date(giftCard.expiryDate)
+    const currentDate = new Date()
+
+    if (expiryDate < currentDate) {
+      return {
+        valid: false,
+        balance: giftCard.currentBalance,
+        currency: giftCard.currency,
+        message: 'Gift card has expired',
+      }
+    }
+  }
+
+  return {
+    valid: true,
+    balance: giftCard.currentBalance,
+    currency: giftCard.currency,
+  }
+}
+
+/**
+ * Compare active gift cards between different time periods
+ * @param daysRange Number of days to look back (7, 30, 60, etc.)
+ */
+export async function compareActiveGiftCards(_daysRange: number = 30): Promise<{
+  current_period: number
+  previous_period: number
+  difference: number
+  percentage_change: number
+  days_range: number
+}> {
+  const today = new Date()
+
+  // Current period (last N days)
+  const currentPeriodStart = new Date(today)
+  currentPeriodStart.setDate(today.getDate() - _daysRange)
+
+  // Previous period (N days before the current period)
+  const previousPeriodEnd = new Date(currentPeriodStart)
+  previousPeriodEnd.setDate(previousPeriodEnd.getDate() - 1)
+
+  const previousPeriodStart = new Date(previousPeriodEnd)
+  previousPeriodStart.setDate(previousPeriodEnd.getDate() - _daysRange)
+
+  // Get active gift cards for current period
+  const currentPeriodActive = await db
+    .selectFrom('gift_cards')
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .where('is_active', '=', true)
+    .where('status', '=', 'ACTIVE')
+    .where(((eb: StacksExpressionBuilder) => eb.or([
+      eb('expiry_date', '>=', toTimestamp(today)),
+      eb('expiry_date', 'is', null),
+    ])) as any)
+    .where('created_at', '>=', formatDate(currentPeriodStart))
+    .where('created_at', '<=', formatDate(today))
+    .executeTakeFirst() as { count: number } | undefined
+
+  // Get active gift cards for previous period
+  const previousPeriodActive = await db
+    .selectFrom('gift_cards')
+    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
+    .where('is_active', '=', true)
+    .where('status', '=', 'ACTIVE')
+    .where(((eb: StacksExpressionBuilder) => eb.or([
+      eb('expiry_date', '>=', toTimestamp(previousPeriodStart)),
+      eb('expiry_date', 'is', null),
+    ])) as any)
+    .where('created_at', '>=', formatDate(previousPeriodStart))
+    .where('created_at', '<=', formatDate(previousPeriodEnd))
+    .executeTakeFirst() as { count: number } | undefined
+
+  const currentCount = Number(currentPeriodActive?.count || 0)
+  const previousCount = Number(previousPeriodActive?.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,
+  }
+}
+
+/**
+ * Calculate gift card balances and initial values for different time periods
+ * with clear increase/decrease indicators
+ * @param daysRange Number of days to look back (7, 30, 60, etc.)
+ */
+export async function calculateGiftCardValues(_daysRange: number = 30): Promise<{
+  current_period: {
+    total_initial_value: number
+    total_remaining_balance: number
+    utilization_rate: number
+    card_count: number
+    average_initial_value: number
+    average_remaining_balance: number
+  }
+  previous_period: {
+    total_initial_value: number
+    total_remaining_balance: number
+    utilization_rate: number
+    card_count: number
+  }
+  comparison: {
+    initial_value: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+    balance: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+    card_count: {
+      difference: number
+      percentage: number
+      is_increase: boolean
+    }
+  }
+  days_range: number
+}> {
+  const today = new Date()
+
+  // Current period (last N days)
+  const currentPeriodStart = new Date(today)
+  currentPeriodStart.setDate(today.getDate() - _daysRange)
+
+  // Previous period (N days before the current period)
+  const previousPeriodEnd = new Date(currentPeriodStart)
+  previousPeriodEnd.setDate(previousPeriodEnd.getDate() - 1)
+
+  const previousPeriodStart = new Date(previousPeriodEnd)
+  previousPeriodStart.setDate(previousPeriodEnd.getDate() - _daysRange)
+
+  // Get values for current period
+  const currentPeriodValues = await db
+    .selectFrom('gift_cards')
+    .select(((eb: StacksExpressionBuilder) => [
+      eb.fn.sum('initial_balance').as('total_initial'),
+      eb.fn.sum('current_balance').as('total_balance'),
+      eb.fn.count('id').as('card_count'),
+    ]) as any)
+    .where('is_active', '=', true)
+    .where('status', '=', 'ACTIVE')
+    .where(((eb: StacksExpressionBuilder) => eb.or([
+      eb('expiry_date', '>=', toTimestamp(today)),
+      eb('expiry_date', 'is', null),
+    ])) as any)
+    .where('created_at', '>=', formatDate(currentPeriodStart))
+    .where('created_at', '<=', formatDate(today))
+    .executeTakeFirst() as { total_initial: number, total_balance: number, card_count: number } | undefined
+
+  // Get values for previous period
+  const previousPeriodValues = await db
+    .selectFrom('gift_cards')
+    .select(((eb: StacksExpressionBuilder) => [
+      eb.fn.sum('initial_balance').as('total_initial'),
+      eb.fn.sum('current_balance').as('total_balance'),
+      eb.fn.count('id').as('card_count'),
+    ]) as any)
+    .where('is_active', '=', true)
+    .where('status', '=', 'ACTIVE')
+    .where(((eb: StacksExpressionBuilder) => eb.or([
+      eb('expiry_date', '>=', toTimestamp(previousPeriodStart)),
+      eb('expiry_date', 'is', null),
+    ])) as any)
+    .where('created_at', '>=', formatDate(previousPeriodStart))
+    .where('created_at', '<=', formatDate(previousPeriodEnd))
+    .executeTakeFirst() as { total_initial: number, total_balance: number, card_count: number } | undefined
+
+  // Calculate values for current period
+  const currentInitialValue = Number(currentPeriodValues?.total_initial || 0)
+  const currentBalance = Number(currentPeriodValues?.total_balance || 0)
+  const currentCardCount = Number(currentPeriodValues?.card_count || 0)
+
+  // Calculate values for previous period
+  const previousInitialValue = Number(previousPeriodValues?.total_initial || 0)
+  const previousBalance = Number(previousPeriodValues?.total_balance || 0)
+  const previousCardCount = Number(previousPeriodValues?.card_count || 0)
+
+  // Calculate utilization rates (percentage of gift card value that has been spent)
+  const currentUtilizationRate = currentInitialValue > 0
+    ? ((currentInitialValue - currentBalance) / currentInitialValue) * 100
+    : 0
+
+  const previousUtilizationRate = previousInitialValue > 0
+    ? ((previousInitialValue - previousBalance) / previousInitialValue) * 100
+    : 0
+
+  // Calculate averages
+  const currentAverageInitial = currentCardCount > 0 ? currentInitialValue / currentCardCount : 0
+  const currentAverageBalance = currentCardCount > 0 ? currentBalance / currentCardCount : 0
+
+  // Calculate differences
+  const initialValueDifference = currentInitialValue - previousInitialValue
+  const balanceDifference = currentBalance - previousBalance
+  const cardCountDifference = currentCardCount - previousCardCount
+
+  // Calculate percentage changes
+  const initialValuePercentageChange = previousInitialValue !== 0
+    ? (initialValueDifference / previousInitialValue) * 100
+    : (currentInitialValue > 0 ? 100 : 0)
+
+  const balancePercentageChange = previousBalance !== 0
+    ? (balanceDifference / previousBalance) * 100
+    : (currentBalance > 0 ? 100 : 0)
+
+  const cardCountPercentageChange = previousCardCount !== 0
+    ? (cardCountDifference / previousCardCount) * 100
+    : (currentCardCount > 0 ? 100 : 0)
+
+  return {
+    current_period: {
+      total_initial_value: currentInitialValue,
+      total_remaining_balance: currentBalance,
+      utilization_rate: currentUtilizationRate,
+      card_count: currentCardCount,
+      average_initial_value: currentAverageInitial,
+      average_remaining_balance: currentAverageBalance,
+    },
+    previous_period: {
+      total_initial_value: previousInitialValue,
+      total_remaining_balance: previousBalance,
+      utilization_rate: previousUtilizationRate,
+      card_count: previousCardCount,
+    },
+    comparison: {
+      initial_value: {
+        difference: initialValueDifference,
+        percentage: Math.abs(initialValuePercentageChange),
+        is_increase: initialValueDifference >= 0,
+      },
+      balance: {
+        difference: balanceDifference,
+        percentage: Math.abs(balancePercentageChange),
+        is_increase: balanceDifference >= 0,
+      },
+      card_count: {
+        difference: cardCountDifference,
+        percentage: Math.abs(cardCountPercentageChange),
+        is_increase: cardCountDifference >= 0,
+      },
+    },
+    days_range: _daysRange,
+  }
+}
+
+/**
+ * Get total value of all gift cards
+ */
+export async function fetchTotalValue(): Promise<{
+  total_value: number
+}> {
+  const { total_value } = await aggregateStats('gift_cards', { total_value: { kind: 'sum', column: 'initial_balance' } })
+  return { total_value }
+}
+
+/**
+ * Get total current balance of all gift cards
+ */
+export async function fetchTotalCurrentBalance(): Promise<{
+  total_balance: number
+}> {
+  const { total_balance } = await aggregateStats('gift_cards', { total_balance: { kind: 'sum', column: 'current_balance' } })
+  return { total_balance }
+}

package/src/gift-cards/index.ts

@@ -0,0 +1,26 @@
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy'
+
+export {
+  calculateGiftCardValues,
+  checkBalance,
+  compareActiveGiftCards,
+  fetchActive,
+  fetchAll,
+  fetchByCode,
+  fetchById,
+  fetchStats,
+  fetchTotalCurrentBalance,
+  fetchTotalValue,
+} from './fetch'
+
+export {
+  store,
+} from './store'
+
+export {
+  update,
+  updateBalance,
+} from './update'

package/src/gift-cards/store.ts

@@ -0,0 +1,56 @@
+type GiftCardJsonResponse = ModelRow<typeof GiftCard>
+type NewGiftCard = NewModelData<typeof GiftCard>
+import { randomUUIDv7 } from 'bun'
+import { db } from '@stacksjs/database'
+import { HttpError } from '@stacksjs/error-handling'
+import { isUniqueViolation } from '@stacksjs/orm'
+
+/**
+ * Create a new gift card
+ *
+ * @param data The gift card data to store
+ * @returns The newly created gift card record
+ */
+export async function store(data: NewGiftCard): Promise<GiftCardJsonResponse | undefined> {
+  const d = data as Record<string, unknown>
+  const giftCardData = {
+    ...data,
+    current_balance: d.current_balance ?? d.initial_balance,
+    status: data.status || 'ACTIVE',
+    is_active: d.is_active ?? true,
+    uuid: randomUUIDv7(),
+  }
+
+  try {
+    // Insert the gift card record
+    const createdGiftCard = await db
+      .insertInto('gift_cards')
+      .values(giftCardData)
+      .executeTakeFirst()
+
+    const insertId = Number(createdGiftCard.insertId) || Number(createdGiftCard.numInsertedOrUpdatedRows)
+
+    // If insert was successful, retrieve the newly created gift card
+    if (insertId) {
+      const giftCard = await db
+        .selectFrom('gift_cards')
+        .where('id', '=', insertId)
+        .selectAll()
+        .executeTakeFirst()
+
+      return giftCard as GiftCardJsonResponse
+    }
+
+    return undefined
+  }
+  catch (error) {
+    if (error instanceof HttpError)
+      throw error
+    // Cross-dialect duplicate detection (#1957).
+    if (isUniqueViolation(error))
+      throw new HttpError(409, 'A gift card with this code already exists')
+    if (error instanceof Error)
+      throw new Error(`Failed to create gift card: ${error.message}`)
+    throw error
+  }
+}

package/src/gift-cards/update.ts

@@ -0,0 +1,102 @@
+import type { StacksExpressionBuilder } from '@stacksjs/database'
+import { db } from '@stacksjs/database'
+import { HttpError } from '@stacksjs/error-handling'
+import { formatDate, isUniqueViolation } from '@stacksjs/orm'
+type GiftCardJsonResponse = ModelRow<typeof GiftCard>
+type GiftCardUpdate = UpdateModelData<typeof GiftCard>
+import { fetchById } from './fetch'
+
+/**
+ * Update a gift card by ID
+ *
+ * @param id The ID of the gift card to update
+ * @param data The updated gift card data
+ * @returns The updated gift card record
+ */
+export async function update(id: number, data: Omit<GiftCardUpdate, 'id'>): Promise<GiftCardJsonResponse | undefined> {
+  // Check if gift card exists
+  const existingGiftCard = await fetchById(id)
+  if (!existingGiftCard) {
+    throw new Error(`Gift card with ID ${id} not found`)
+  }
+
+  try {
+    // Update the gift card
+    await db
+      .updateTable('gift_cards')
+      .set({
+        ...data,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .execute()
+
+    // Fetch and return the updated gift card
+    return await fetchById(id)
+  }
+  catch (error) {
+    if (error instanceof HttpError)
+      throw error
+    // Cross-dialect duplicate detection (#1957).
+    if (isUniqueViolation(error))
+      throw new HttpError(409, 'A gift card with this code already exists')
+    if (error instanceof Error)
+      throw new Error(`Failed to update gift card: ${error.message}`)
+    throw error
+  }
+}
+
+/**
+ * Update a gift card's balance atomically (stacksjs/stacks#1879 Co-8).
+ *
+ * Pre-fix: read balance → compute new → write. Two parallel $50
+ * redemptions of a $100 card both saw `current_balance = 100`,
+ * both wrote `50`, leaving `50` instead of `0`. The post-read
+ * negative-balance guard only caught single-threaded misuse.
+ *
+ * Post-fix: single conditional UPDATE that does the arithmetic and
+ * enforces every precondition in the WHERE clause. The database
+ * guarantees only one writer wins the race. Throws when the row
+ * was found but the precondition failed (insufficient balance,
+ * inactive, missing) so the caller can distinguish from a
+ * not-found row.
+ *
+ * @param id The ID of the gift card
+ * @param amount The amount to adjust (positive to add, negative to deduct)
+ * @returns The updated gift card with new balance
+ */
+export async function updateBalance(id: number, amount: number): Promise<GiftCardJsonResponse | undefined> {
+  const now = formatDate(new Date())
+
+  // Single atomic UPDATE — the arithmetic happens server-side via
+  // `current_balance + ?`, and the `>= 0` predicate stops over-spend.
+  // The new status flips to USED when the resulting balance is 0,
+  // computed inline via CASE so the status update is part of the
+  // same statement.
+  const result = await db
+    .updateTable('gift_cards')
+    .set({
+      current_balance: (db as any).raw(`current_balance + ${amount}`),
+      last_used_date: now,
+      status: (db as any).raw(`CASE WHEN current_balance + ${amount} = 0 THEN 'USED' ELSE 'ACTIVE' END`),
+      updated_at: now,
+    })
+    .where('id', '=', id)
+    .where('is_active', '=', 1)
+    .where('status', '=', 'ACTIVE')
+    .where((eb: StacksExpressionBuilder) => eb.cmpr(eb.raw(`current_balance + ${amount}`), '>=', 0))
+    .executeTakeFirst()
+
+  const affected = Number((result as any)?.numUpdatedRows ?? (result as any)?.affectedRows ?? 0)
+  if (affected > 0) {
+    return await fetchById(id)
+  }
+
+  // UPDATE matched zero rows — diagnose for a useful error.
+  const existing = await fetchById(id)
+  if (!existing) throw new Error(`Gift card with ID ${id} not found`)
+  if (!(existing as Record<string, unknown>).is_active || existing.status !== 'ACTIVE')
+    throw new Error(`Gift card is not active`)
+  // Fell through every other check — must be insufficient balance.
+  throw new Error(`Insufficient gift card balance`)
+}

package/src/index.ts

@@ -0,0 +1,78 @@
+// Main commerce module index file
+import * as coupons from './coupons'
+import * as customers from './customers'
+import * as devices from './devices'
+import * as errors from './errors'
+import * as giftCards from './gift-cards'
+import * as orders from './orders'
+import * as payments from './payments'
+import * as products from './products'
+import * as receipts from './receipts'
+import * as shippings from './shippings'
+import * as tax from './tax'
+import * as waitlists from './waitlists'
+import * as restaurant from './waitlists/restaurant'
+
+type CouponsModule = typeof coupons
+type CustomersModule = typeof customers
+type ErrorsModule = typeof errors
+type ShippingsModule = typeof shippings
+type GiftCardsModule = typeof giftCards
+type OrdersModule = typeof orders
+type PaymentsModule = typeof payments
+type ProductsModule = typeof products
+type RestaurantModule = typeof restaurant
+type TaxModule = typeof tax
+type WaitlistsModule = typeof waitlists
+type DevicesModule = typeof devices
+type ReceiptsModule = typeof receipts
+
+export interface CommerceNamespace {
+  coupons: CouponsModule
+  customers: CustomersModule
+  errors: ErrorsModule
+  giftCards: GiftCardsModule
+  orders: OrdersModule
+  payments: PaymentsModule
+  products: ProductsModule
+  restaurant: RestaurantModule
+  shippings: ShippingsModule
+  tax: TaxModule
+  waitlists: WaitlistsModule
+  devices: DevicesModule
+  receipts: ReceiptsModule
+}
+
+export const commerce: CommerceNamespace = {
+  coupons,
+  customers,
+  devices,
+  errors,
+  giftCards,
+  orders,
+  payments,
+  products,
+  receipts,
+  restaurant,
+  shippings,
+  tax,
+  waitlists,
+}
+
+export default commerce
+
+export {
+  coupons,
+  customers,
+  devices,
+  errors,
+  giftCards,
+  orders,
+  payments,
+  products,
+  receipts,
+  restaurant,
+  shippings,
+  tax,
+  waitlists,
+}