@stacksjs/commerce 0.70.53 → 0.70.55

package/src/tests/waitlist.test.ts

@@ -0,0 +1,303 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,312 @@
+// 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
+}