@stacksjs/commerce 0.70.55 → 0.70.56

package/src/tests/waitlist.test.ts

@@ -1,303 +0,0 @@
-type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { formatDate } from '@stacksjs/orm'
-import { refreshDatabase } from './setup'
-import { bulkDestroy } from '../waitlists/products/destroy'
-import {
-  fetchBetweenDates,
-  fetchCancelledBetweenDates,
-  fetchNotifiedBetweenDates,
-  fetchPurchasedBetweenDates,
-  fetchWaiting,
-} from '../waitlists/products/fetch'
-import { bulkStore } from '../waitlists/products/store'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Waitlist Product 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 products', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-
-  describe('fetch', () => {
-    it('should fetch waitlist products 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 products
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          quantity: 4,
-          notification_preference: 'email',
-          source: 'website',
-          status: 'waiting',
-          product_id: 1,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          quantity: 2,
-          notification_preference: 'sms',
-          source: 'website',
-          status: 'waiting',
-          product_id: 2,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          quantity: 6,
-          notification_preference: 'both',
-          source: 'app',
-          status: 'waiting',
-          product_id: 3,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist products
-      await bulkStore(requests)
-
-      // Fetch waitlists between dates
-      const waitlists = await fetchBetweenDates(startDate, endDate)
-      expect(waitlists).toBeDefined()
-      expect(waitlists.length).toBe(3) // All entries should be within the date range since they're created now
-      expect(waitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('John Doe')
-      expect(waitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('Jane Smith')
-      expect(waitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('Bob Wilson')
-    })
-
-    it('should fetch notified waitlist products 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 products with different notification dates
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          quantity: 4,
-          notification_preference: 'email',
-          source: 'website',
-          status: 'notified',
-          product_id: 1,
-          customer_id: 1,
-          notified_at: formatDate(startDate),
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          quantity: 2,
-          notification_preference: 'sms',
-          source: 'website',
-          status: 'notified',
-          product_id: 2,
-          customer_id: 2,
-          notified_at: formatDate(endDate),
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          quantity: 6,
-          notification_preference: 'both',
-          source: 'app',
-          status: 'waiting',
-          product_id: 3,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist products
-      await bulkStore(requests as any)
-
-      // Fetch notified waitlists between dates
-      const notifiedWaitlists = await fetchNotifiedBetweenDates(startDate, endDate)
-      expect(notifiedWaitlists).toBeDefined()
-      expect(notifiedWaitlists.length).toBe(2)
-      expect(notifiedWaitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('John Doe')
-      expect(notifiedWaitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('Jane Smith')
-    })
-
-    it('should fetch purchased waitlist products 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 products with different purchase dates
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          quantity: 4,
-          notification_preference: 'email',
-          source: 'website',
-          status: 'purchased',
-          product_id: 1,
-          customer_id: 1,
-          purchased_at: startDate.getTime(),
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          quantity: 2,
-          notification_preference: 'sms',
-          source: 'website',
-          status: 'purchased',
-          product_id: 2,
-          customer_id: 2,
-          purchased_at: endDate.getTime(),
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          quantity: 6,
-          notification_preference: 'both',
-          source: 'app',
-          status: 'waiting',
-          product_id: 3,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist products
-      await bulkStore(requests)
-
-      // Fetch purchased waitlists between dates
-      const purchasedWaitlists = await fetchPurchasedBetweenDates(startDate, endDate)
-      expect(purchasedWaitlists).toBeDefined()
-      expect(purchasedWaitlists.length).toBe(2)
-      expect(purchasedWaitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('John Doe')
-      expect(purchasedWaitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('Jane Smith')
-    })
-
-    it('should fetch cancelled waitlist products 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 products with different cancellation dates
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          quantity: 4,
-          notification_preference: 'email',
-          source: 'website',
-          status: 'cancelled',
-          product_id: 1,
-          customer_id: 1,
-          cancelled_at: formatDate(startDate),
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          quantity: 2,
-          notification_preference: 'sms',
-          source: 'website',
-          status: 'cancelled',
-          product_id: 2,
-          customer_id: 2,
-          cancelled_at: formatDate(endDate),
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          quantity: 6,
-          notification_preference: 'both',
-          source: 'app',
-          status: 'waiting',
-          product_id: 3,
-          customer_id: 3,
-        },
-      ]
-
-      // Create the waitlist products
-      await bulkStore(requests as any)
-
-      // Fetch cancelled waitlists between dates
-      const cancelledWaitlists = await fetchCancelledBetweenDates(startDate, endDate)
-      expect(cancelledWaitlists).toBeDefined()
-      expect(cancelledWaitlists.length).toBe(2)
-      expect(cancelledWaitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('John Doe')
-      expect(cancelledWaitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('Jane Smith')
-    })
-
-    it('should fetch all waitlist products with waiting status', async () => {
-      // Create test waitlist products with different statuses
-      const requests = [
-        {
-          name: 'John Doe',
-          email: 'john@example.com',
-          quantity: 4,
-          notification_preference: 'email',
-          source: 'website',
-          status: 'waiting',
-          product_id: 1,
-          customer_id: 1,
-        },
-        {
-          name: 'Jane Smith',
-          email: 'jane@example.com',
-          quantity: 2,
-          notification_preference: 'sms',
-          source: 'website',
-          status: 'waiting',
-          product_id: 2,
-          customer_id: 2,
-        },
-        {
-          name: 'Bob Wilson',
-          email: 'bob@example.com',
-          quantity: 6,
-          notification_preference: 'both',
-          source: 'app',
-          status: 'notified',
-          product_id: 3,
-          customer_id: 3,
-        },
-        {
-          name: 'Alice Brown',
-          email: 'alice@example.com',
-          quantity: 3,
-          notification_preference: 'email',
-          source: 'social_media',
-          status: 'purchased',
-          product_id: 4,
-          customer_id: 4,
-        },
-      ]
-
-      // Create the waitlist products
-      await bulkStore(requests as any)
-
-      // Fetch waitlists with waiting status
-      const waitingWaitlists = await fetchWaiting()
-      expect(waitingWaitlists).toBeDefined()
-      expect(waitingWaitlists.length).toBe(2)
-      expect(waitingWaitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('John Doe')
-      expect(waitingWaitlists.map((w: WaitlistProductJsonResponse) => w.name)).toContain('Jane Smith')
-    })
-  })
-})

package/src/tests/zones.test.ts

@@ -1,86 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { formatZoneOptions, getActiveShippingZones } from '../shippings/shipping-zones/fetch'
-import { bulkStore, store } from '../shippings/shipping-zones/store'
-import { bulkDestroy } from '../shippings/shipping-zones/destroy'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Shipping Zone Module', () => {
-  describe('store', () => {
-    it('should return 0 when trying to bulk store an empty array', async () => {
-      const count = await bulkStore([])
-      expect(count).toBe(0)
-    })
-
-    it('should format zone options for dropdowns', async () => {
-      // First create some zones
-      await store({
-        name: 'Zone A',
-        countries: JSON.stringify(['US']),
-        status: 'active',
-        shipping_method_id: 1,
-      })
-
-      await store({
-        name: 'Zone B',
-        countries: JSON.stringify(['CA']),
-        status: 'inactive',
-        shipping_method_id: 1,
-      })
-
-      // Now get formatted options
-      const options = await formatZoneOptions()
-
-      expect(options).toBeDefined()
-      expect(options.length).toBe(2)
-
-      // Verify structure of options
-      expect(options[0].id).toBeDefined()
-      expect(options[0].name).toBeDefined()
-      expect(options[0].status).toBeDefined()
-      expect(options[0].countries).toBeDefined()
-
-      // Verify names are present
-      const names = options.map(opt => opt.name)
-      expect(names).toContain('Zone A')
-      expect(names).toContain('Zone B')
-    })
-
-    it('should get active shipping zones', async () => {
-      // Create active zone
-      await store({
-        name: 'Active Zone',
-        countries: JSON.stringify(['US']),
-        status: 'active',
-        shipping_method_id: 1,
-      })
-
-      // Create inactive zone
-      await store({
-        name: 'Inactive Zone',
-        countries: JSON.stringify(['CA']),
-        status: 'inactive',
-        shipping_method_id: 1,
-      })
-
-      // Get active zones
-      const activeZones = await getActiveShippingZones()
-
-      expect(activeZones).toBeDefined()
-      expect(activeZones.length).toBe(1)
-      expect(activeZones[0].name).toBe('Active Zone')
-      expect(activeZones[0].status).toBe('active')
-    })
-  })
-
-  describe('destroy', () => {
-    it('should return 0 when trying to delete an empty array of zones', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-})

package/src/types.ts

@@ -1,312 +0,0 @@
-// Import the CustomerTable type from the ORM
-
-type CouponJsonResponse = ModelRow<typeof Coupon>
-type CustomerJsonResponse = ModelRow<typeof Customer>
-type GiftCardJsonResponse = ModelRow<typeof GiftCard>
-type ManufacturerJsonResponse = ModelRow<typeof Manufacturer>
-type OrderJsonResponse = ModelRow<typeof Order>
-type OrderItemJsonResponse = ModelRow<typeof OrderItem>
-type ReviewJsonResponse = ModelRow<typeof Review>
-
-// Define the input for creating a customer
-export interface CreateCustomerInput {
-  name: string
-  email: string
-  phone: string
-  orders?: number
-  total_spent?: number // Changed from totalSpent to match the schema
-  last_order?: string // Changed from lastOrder to match the schema
-  status?: string
-  avatar?: string
-  user_id?: number
-}
-
-// Define the input for updating a customer
-export interface UpdateCustomerInput {
-  name?: string
-  email?: string
-  phone?: string
-  orders?: number
-  total_spent?: number // Changed from totalSpent to match the schema
-  last_order?: string // Changed from lastOrder to match the schema
-  status?: string
-  avatar?: string
-  user_id?: number
-}
-
-// Define the structure of an order item
-export interface OrderItem {
-  product_id: string
-  quantity: number
-  price: number
-  special_instructions?: string
-}
-
-// Type for status count
-export interface StatusCount {
-  status: string
-  count: number | string // Using string since SQL count might return as string
-}
-
-// Type for order type count
-export interface OrderTypeCount {
-  order_type: string
-  count: number | string // Using string since SQL count might return as string
-}
-
-// Type for the stats return value
-export interface OrderStats {
-  total: number
-  by_status: StatusCount[]
-  by_type: OrderTypeCount[]
-  recent: OrderJsonResponse[]
-  revenue: number
-}
-
-/**
- * Represents a simplified order item structure with required properties for total calculation
- */
-export interface OrderItemForCalculation {
-  price: number
-  quantity: number
-}
-
-/**
- * Represents the totals calculated for an order
- */
-export interface OrderTotals {
-  subtotal: number
-  tax_amount: number
-  total_amount: number
-}
-
-/**
- * Represents statistics for a discount type
- */
-export interface DiscountTypeCount {
-  discount_type: string | undefined
-  count: string | number | bigint
-}
-
-/**
- * Represents comprehensive coupon statistics
- */
-export interface CouponStats {
-  /** Total number of coupons in the system */
-  total: number
-
-  /** Number of currently active coupons */
-  active: number
-
-  /** Distribution of coupons by discount type */
-  by_type: DiscountTypeCount[]
-
-  /** List of most frequently used coupons */
-  most_used: {
-    id: number | undefined
-    code: string | undefined
-    discount_type: string | undefined
-    discount_value: number | undefined
-    usage_count: number | undefined
-  }[]
-
-  /** List of upcoming coupons that will be active soon */
-  upcoming: {
-    id: number | undefined
-    code: string | undefined
-    discount_type: string | undefined
-    discount_value: number | undefined
-    start_date: Date | string
-    end_date: Date | string
-  }[]
-}
-export interface OrderWithTotals {
-  order_items: OrderItemJsonResponse[] | []
-  id: number
-  customer_id: number
-  customer: CustomerJsonResponse | undefined
-  coupon_id: number
-  coupon: CouponJsonResponse | undefined
-  status: string
-  total_amount: number
-  tax_amount: number | undefined
-  discount_amount: number | undefined
-  delivery_fee: number | undefined
-  tip_amount: number | undefined
-  order_type: string
-  delivery_address: string | undefined
-  special_instructions: string | undefined
-  estimated_delivery_time: string | undefined
-  applied_coupon_id: string | undefined
-  uuid: string | undefined
-  created_at: Date | undefined
-  updated_at: Date | undefined
-  customer_name: string | null
-  customer_email: string | null
-  // Add the new calculated fields
-  totalItems: number
-  totalPrice: number
-}
-
-export interface FetchGiftCardsOptions {
-  page?: number
-  limit?: number
-  search?: string
-  status?: string
-  is_active?: boolean
-  is_digital?: boolean
-  is_reloadable?: boolean
-  sortBy?: string
-  sortOrder?: 'asc' | 'desc'
-  purchaser_id?: string
-  from_date?: string
-  to_date?: string
-  min_balance?: number
-  max_balance?: number
-}
-
-interface BaseResponse {
-  paging: {
-    total_records: number
-    page: number
-    total_pages: number
-  }
-  next_cursor: number | null
-}
-
-export interface GiftCardResponse extends BaseResponse {
-  data: GiftCardJsonResponse[]
-}
-
-export interface GiftCardStats {
-  total: number
-  active: number
-  by_status: Array<{ status: string, count: number }>
-  by_balance: {
-    low: number // Count of cards with less than 25% of initial balance
-    medium: number // Count of cards with 25-75% of initial balance
-    high: number // Count of cards with more than 75% of initial balance
-  }
-  expiring_soon: GiftCardJsonResponse[]
-  recently_used: GiftCardJsonResponse[]
-}
-
-export interface FetchReviewsOptions {
-  page?: number
-  limit?: number
-}
-
-export interface ReviewResponse extends BaseResponse {
-  data: ReviewJsonResponse[]
-}
-
-export interface ManufacturerResponse extends BaseResponse {
-  data: ManufacturerJsonResponse[]
-}
-export interface ReviewStats {
-  total: number
-  average_rating: number
-  rating_distribution: {
-    one_star: number
-    two_star: number
-    three_star: number
-    four_star: number
-    five_star: number
-  }
-  recent_reviews: ReviewJsonResponse[]
-}
-
-/**
- * Represents comprehensive category statistics
- */
-export interface CategoryStats {
-  /** Total number of categories in the system */
-  total: number
-
-  /** Number of currently active categories */
-  active: number
-
-  /** Number of root categories (no parent) */
-  root_categories: number
-
-  /** Number of child categories (has parent) */
-  child_categories: number
-
-  /** Number of categories with images */
-  with_images: number
-
-  /** Recently added categories */
-  recently_added: Array<any>
-
-  /** Top parent categories with most children */
-  top_parent_categories: Array<{
-    id: string
-    name: string
-    child_count: number
-  }>
-}
-
-/**
- * Options for fetching product manufacturers
- */
-export interface FetchManufacturersOptions {
-  country?: string
-  featured?: boolean
-  search?: string
-}
-
-export interface FetchCouponsOptions {
-  page?: number
-  limit?: number
-  search?: string
-  is_active?: boolean
-  discount_type?: string
-  sortBy?: string
-  sortOrder?: 'asc' | 'desc'
-  product_id?: string
-  category_id?: string
-  from_date?: string
-  to_date?: string
-}
-
-/**
- * Interface for coupon count statistics
- */
-export interface CouponCountStats {
-  total: number
-  active: number
-  inactive: number
-}
-
-/**
- * Interface for time-based coupon statistics
- */
-export interface CouponTimeStats {
-  week: CouponCountStats
-  month: CouponCountStats
-  year: CouponCountStats
-  all_time: CouponCountStats
-}
-
-/**
- * Interface for coupon redemption statistics
- */
-export interface CouponRedemptionStats {
-  total: number
-  week: number
-  month: number
-  year: number
-  by_type: Record<string, number>
-}
-export interface FetchOrdersOptions {
-  page?: number
-  limit?: number
-  search?: string
-  status?: string
-  order_type?: string
-  customer_id?: number
-  sortBy?: string
-  sortOrder?: 'asc' | 'desc'
-  from_date?: string
-  to_date?: string
-}