@stacksjs/commerce 0.70.55 → 0.70.57

package/src/tests/restaurant.test.ts

@@ -1,522 +0,0 @@
-type WaitlistRestaurantJsonResponse = ModelRow<typeof WaitlistRestaurant>
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { bulkDestroy } from '../waitlists/restaurant/destroy'
-import {
-  fetchBetweenDates,
-  fetchSeatedBetweenDates,
-  fetchTablesTurnedToday,
-  fetchWaiting,
-  fetchWaitingWithPartySizes,
-  fetchWaitingWithQuotedTimes,
-} from '../waitlists/restaurant/fetch'
-import { bulkStore } from '../waitlists/restaurant/store'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Restaurant Waitlist Module', () => {
-  describe('store', () => {
-    it('should return 0 when trying to bulk store an empty array', async () => {
-      const count = await bulkStore([])
-      expect(count).toBe(0)
-    })
-  })
-
-  describe('destroy', () => {
-    it('should return 0 when trying to delete an empty array of waitlist entries', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-
-  describe('fetch', () => {
-    it('should fetch waitlist entries between two dates', async () => {
-      // Create test dates using today
-      const today = new Date()
-      const startDate = new Date(today.setHours(0, 0, 0, 0))
-      const endDate = new Date(today.setHours(23, 59, 59, 999))
-
-      // Create test waitlist entries
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'waiting',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 2,
-          check_in_time: Date.now(),
-          table_preference: 'bar',
-          status: 'waiting',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          party_size: 6,
-          check_in_time: Date.now(),
-          table_preference: 'booth',
-          status: 'waiting',
-          quoted_wait_time: 45,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch entries between dates
-      const entries = await fetchBetweenDates(startDate, endDate)
-      expect(entries).toBeDefined()
-      expect(entries.length).toBe(3) // All entries should be within the date range
-      expect(entries.map((w: WaitlistRestaurantJsonResponse) => w.name)).toContain('John Doe')
-      expect(entries.map((w: WaitlistRestaurantJsonResponse) => w.name)).toContain('Jane Smith')
-      expect(entries.map((w: WaitlistRestaurantJsonResponse) => w.name)).toContain('Bob Wilson')
-    })
-
-    it('should fetch seated waitlist entries between two dates', async () => {
-      // Create test dates using today
-      const today = new Date()
-      const startDate = new Date(today.setHours(0, 0, 0, 0))
-      const endDate = new Date(today.setHours(23, 59, 59, 999))
-
-      // Create test waitlist entries with different statuses
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'seated',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 2,
-          check_in_time: Date.now(),
-          table_preference: 'bar',
-          status: 'seated',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          party_size: 6,
-          check_in_time: Date.now(),
-          table_preference: 'booth',
-          status: 'waiting',
-          quoted_wait_time: 45,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch seated entries between dates
-      const seatedEntries = await fetchSeatedBetweenDates(startDate, endDate)
-      expect(seatedEntries).toBeDefined()
-      expect(seatedEntries.length).toBe(2)
-      expect(seatedEntries.map((w: WaitlistRestaurantJsonResponse) => w.name)).toContain('John Doe')
-      expect(seatedEntries.map((w: WaitlistRestaurantJsonResponse) => w.name)).toContain('Jane Smith')
-    })
-
-    it('should fetch all waitlist entries with waiting status', async () => {
-      // Create test waitlist entries with different statuses
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'waiting',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 2,
-          check_in_time: Date.now(),
-          table_preference: 'bar',
-          status: 'waiting',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          party_size: 6,
-          check_in_time: Date.now(),
-          table_preference: 'booth',
-          status: 'seated',
-          quoted_wait_time: 45,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch entries with waiting status
-      const waitingEntries = await fetchWaiting()
-      expect(waitingEntries).toBeDefined()
-      expect(waitingEntries.length).toBe(2)
-      expect(waitingEntries.map((w: WaitlistRestaurantJsonResponse) => w.name)).toContain('John Doe')
-      expect(waitingEntries.map((w: WaitlistRestaurantJsonResponse) => w.name)).toContain('Jane Smith')
-    })
-
-    it('should fetch waiting entries with quoted wait times', async () => {
-      // Create test waitlist entries with different wait times and statuses
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'waiting',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 2,
-          check_in_time: Date.now(),
-          table_preference: 'bar',
-          status: 'waiting',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          party_size: 6,
-          check_in_time: Date.now(),
-          table_preference: 'booth',
-          status: 'seated',
-          quoted_wait_time: 45,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch waiting entries with quoted times
-      const result = await fetchWaitingWithQuotedTimes()
-
-      // Verify the results
-      expect(result).toBeDefined()
-      expect(result.entries).toBeDefined()
-      expect(result.entries.length).toBe(2) // Only waiting entries
-      expect(result.totalQuotedWaitTime).toBe(45) // 30 + 15
-      expect(result.averageQuotedWaitTime).toBe(22.5) // (30 + 15) / 2
-
-      // Verify individual entries
-      expect(result.entries.map(e => e.name)).toContain('John Doe')
-      expect(result.entries.map(e => e.name)).toContain('Jane Smith')
-      expect(result.entries.map(e => e.quoted_wait_time)).toContain(30)
-      expect(result.entries.map(e => e.quoted_wait_time)).toContain(15)
-    })
-
-    it('should handle empty waiting list for quoted times', async () => {
-      // Create only seated entries
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'seated',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 2,
-          check_in_time: Date.now(),
-          table_preference: 'bar',
-          status: 'seated',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch waiting entries with quoted times
-      const result = await fetchWaitingWithQuotedTimes()
-
-      // Verify the results
-      expect(result).toBeDefined()
-      expect(result.entries).toBeDefined()
-      expect(result.entries.length).toBe(0)
-      expect(result.totalQuotedWaitTime).toBe(0)
-      expect(result.averageQuotedWaitTime).toBe(0)
-    })
-
-    it('should fetch waiting entries with party size calculations', async () => {
-      // Create test waitlist entries with different party sizes and statuses
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'waiting',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 4,
-          check_in_time: Date.now(),
-          table_preference: 'bar',
-          status: 'waiting',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          party_size: 2,
-          check_in_time: Date.now(),
-          table_preference: 'booth',
-          status: 'waiting',
-          quoted_wait_time: 45,
-          customer_id: 3,
-        },
-        {
-          name: 'Alice Brown',
-          email: 'alice@example.com',
-          party_size: 6,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'seated',
-          quoted_wait_time: 60,
-          customer_id: 4,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch waiting entries with party sizes
-      const result = await fetchWaitingWithPartySizes()
-
-      // Verify the results
-      expect(result).toBeDefined()
-      expect(result.entries).toBeDefined()
-      expect(result.entries.length).toBe(3) // Only waiting entries
-      expect(result.totalPartySize).toBe(10) // 4 + 4 + 2
-      expect(result.averagePartySize).toBeCloseTo(3.33, 2) // 10 / 3
-
-      // Verify party size breakdown
-      expect(result.partySizeBreakdown).toBeDefined()
-      expect(Object.keys(result.partySizeBreakdown).length).toBe(2) // 2 different party sizes
-      expect(result.partySizeBreakdown[4]).toBe(2) // Two parties of 4
-      expect(result.partySizeBreakdown[2]).toBe(1) // One party of 2
-
-      // Verify individual entries
-      expect(result.entries.map(e => e.name)).toContain('John Doe')
-      expect(result.entries.map(e => e.name)).toContain('Jane Smith')
-      expect(result.entries.map(e => e.name)).toContain('Bob Wilson')
-    })
-
-    it('should handle empty waiting list for party sizes', async () => {
-      // Create only seated entries
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'seated',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 2,
-          check_in_time: Date.now(),
-          table_preference: 'bar',
-          status: 'seated',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch waiting entries with party sizes
-      const result = await fetchWaitingWithPartySizes()
-
-      // Verify the results
-      expect(result).toBeDefined()
-      expect(result.entries).toBeDefined()
-      expect(result.entries.length).toBe(0)
-      expect(result.totalPartySize).toBe(0)
-      expect(result.averagePartySize).toBe(0)
-      expect(result.partySizeBreakdown).toEqual({})
-    })
-
-    it('should fetch tables turned statistics for today', async () => {
-      // Create test dates using today
-      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)
-
-      // Create test waitlist entries with different statuses and table preferences
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: startOfDay.getTime(),
-          table_preference: 'indoor',
-          status: 'seated',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 2,
-          check_in_time: endOfDay.getTime(),
-          table_preference: 'bar',
-          status: 'seated',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          party_size: 6,
-          check_in_time: Date.now(),
-          table_preference: 'booth',
-          status: 'seated',
-          quoted_wait_time: 45,
-          customer_id: 3,
-        },
-        {
-          name: 'Alice Brown',
-          email: 'alice@example.com',
-          party_size: 3,
-          check_in_time: Date.now(),
-          table_preference: 'indoor',
-          status: 'waiting',
-          quoted_wait_time: 20,
-          customer_id: 4,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch tables turned statistics
-      const stats = await fetchTablesTurnedToday()
-
-      // Verify the results
-      expect(stats).toBeDefined()
-      expect(stats.totalTablesTurned).toBe(3) // 3 seated entries
-      expect(stats.totalCustomersSeated).toBe(12) // 4 + 2 + 6
-      expect(stats.averagePartySize).toBe(4) // 12 / 3
-
-      // Verify table preference breakdown
-      expect(stats.breakdownByTablePreference).toBeDefined()
-      expect(Object.keys(stats.breakdownByTablePreference).length).toBe(3) // indoor, bar, booth
-      expect(stats.breakdownByTablePreference.indoor).toBe(1)
-      expect(stats.breakdownByTablePreference.bar).toBe(1)
-      expect(stats.breakdownByTablePreference.booth).toBe(1)
-
-      // Verify party size breakdown
-      expect(stats.breakdownByPartySize).toBeDefined()
-      expect(Object.keys(stats.breakdownByPartySize).length).toBe(3) // 2, 3, 4, 6
-      expect(stats.breakdownByPartySize[2]).toBe(1)
-      expect(stats.breakdownByPartySize[4]).toBe(1)
-      expect(stats.breakdownByPartySize[6]).toBe(1)
-    })
-
-    it('should handle no tables turned today', async () => {
-      // Create test entries with different dates
-      const today = new Date()
-      const yesterday = new Date(today)
-      yesterday.setDate(yesterday.getDate() - 1)
-
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          party_size: 4,
-          check_in_time: yesterday.getTime(),
-          table_preference: 'indoor',
-          status: 'seated',
-          quoted_wait_time: 30,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          party_size: 2,
-          check_in_time: yesterday.getTime(),
-          table_preference: 'bar',
-          status: 'seated',
-          quoted_wait_time: 15,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          party_size: 6,
-          check_in_time: Date.now(),
-          table_preference: 'booth',
-          status: 'waiting',
-          quoted_wait_time: 45,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist entries
-      await bulkStore(requests)
-
-      // Fetch tables turned statistics
-      const stats = await fetchTablesTurnedToday()
-
-      // Verify the results
-      expect(stats).toBeDefined()
-      expect(stats.totalTablesTurned).toBe(0)
-      expect(stats.totalCustomersSeated).toBe(0)
-      expect(stats.averagePartySize).toBe(0)
-      expect(stats.breakdownByTablePreference).toEqual({})
-      expect(stats.breakdownByPartySize).toEqual({})
-    })
-  })
-})

package/src/tests/reviews.test.ts

@@ -1,165 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { bulkDestroy } from '../products/reviews/destroy'
-import { fetchApprovedByProductId, fetchByProductId, fetchByUserId, fetchMostHelpfulByProductId } from '../products/reviews/fetch'
-import { store } from '../products/reviews/store'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Product Review Module', () => {
-  describe('fetch methods', () => {
-    it('should fetch reviews by product ID', async () => {
-      // Create several reviews for the same product
-      const productId = 2
-
-      // Create first review
-      const request1 = {
-        product_id: productId,
-        customer_id: 1,
-        rating: 5,
-        title: 'First review',
-        content: 'First review content',
-        is_approved: true,
-      }
-
-      await store(request1)
-
-      // Create second review
-      const request2 = {
-        product_id: productId,
-        customer_id: 2,
-        rating: 4,
-        title: 'Second review',
-        content: 'Second review content',
-        is_approved: true,
-      }
-
-      await store(request2)
-
-      // Now fetch reviews by product ID
-      const result = await fetchByProductId(productId)
-
-      expect(result).toBeDefined()
-      expect(result.length).toBe(2)
-      expect(result[0].product_id).toBe(productId)
-      expect(result[1].product_id).toBe(productId)
-    })
-
-    it('should fetch reviews by user ID', async () => {
-      // Create several reviews for the same user
-      const customerId = 3
-
-      // Create first review
-      const request1 = {
-        product_id: 1,
-        customer_id: customerId,
-        rating: 5,
-        title: 'First user review',
-        content: 'First user review content',
-      }
-      await store(request1)
-
-      // Create second review
-      const request2 = {
-        product_id: 2,
-        customer_id: customerId,
-        rating: 3,
-        title: 'Second user review',
-        content: 'Second user review content',
-      }
-      await store(request2)
-
-      // Now fetch reviews by user ID
-      const result = await fetchByUserId(customerId)
-
-      expect(result).toBeDefined()
-      expect(result.length).toBe(2)
-      expect(result[0].customer_id).toBe(customerId)
-      expect(result[1].customer_id).toBe(customerId)
-    })
-
-    it('should fetch approved reviews for a product', async () => {
-      const productId = 3
-
-      // Create approved review
-      const request1 = {
-        product_id: productId,
-        customer_id: 1,
-        rating: 5,
-        title: 'Approved review',
-        content: 'Approved review content',
-        is_approved: true,
-      }
-
-      await store(request1)
-
-      // Create unapproved review
-      const request2 = {
-        product_id: productId,
-        customer_id: 2,
-        rating: 2,
-        title: 'Unapproved review',
-        content: 'Unapproved review content',
-        is_approved: false,
-      }
-
-      await store(request2)
-
-      // Now fetch only approved reviews
-      const result = await fetchApprovedByProductId(productId)
-
-      expect(result).toBeDefined()
-      expect(result.length).toBe(1)
-      expect(Boolean(result[0].is_approved)).toBe(true)
-      expect(result[0].title).toBe('Approved review')
-    })
-
-    it('should fetch most helpful reviews', async () => {
-      const productId = 5
-
-      // Create review with many helpful votes
-      const request1 = {
-        product_id: productId,
-        customer_id: 1,
-        rating: 5,
-        title: 'Most helpful review',
-        content: 'Very helpful content',
-        is_approved: true,
-        helpful_votes: 10,
-      }
-
-      await store(request1)
-
-      // Create review with fewer helpful votes
-      const request2 = {
-        product_id: productId,
-        customer_id: 2,
-        rating: 4,
-        title: 'Less helpful review',
-        content: 'Still helpful content',
-        is_approved: true,
-        helpful_votes: 5,
-      }
-
-      await store(request2)
-
-      // Now fetch most helpful reviews
-      const helpfulReviews = await fetchMostHelpfulByProductId(productId)
-
-      expect(helpfulReviews).toBeDefined()
-      expect(helpfulReviews.length).toBe(2)
-      expect(helpfulReviews[0].helpful_votes).toBe(10)
-      expect(helpfulReviews[1].helpful_votes).toBe(5)
-    })
-  })
-
-  describe('destroy', () => {
-    it('should return 0 when trying to delete an empty array of reviews', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-})