@stacksjs/commerce 0.70.88 → 0.70.90

package/dist/types.d.ts

@@ -0,0 +1,265 @@
+// Define the input for creating a customer
+export declare interface CreateCustomerInput {
+  name: string
+  email: string
+  phone: string
+  orders?: number
+  total_spent?: number
+  last_order?: string
+  status?: string
+  avatar?: string
+  user_id?: number
+}
+// Define the input for updating a customer
+export declare interface UpdateCustomerInput {
+  name?: string
+  email?: string
+  phone?: string
+  orders?: number
+  total_spent?: number
+  last_order?: string
+  status?: string
+  avatar?: string
+  user_id?: number
+}
+// Define the structure of an order item
+export declare interface OrderItem {
+  product_id: string
+  quantity: number
+  price: number
+  special_instructions?: string
+}
+// Type for status count
+export declare interface StatusCount {
+  status: string
+  count: number | string
+}
+// Type for order type count
+export declare interface OrderTypeCount {
+  order_type: string
+  count: number | string
+}
+// Type for the stats return value
+export declare 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 declare interface OrderItemForCalculation {
+  price: number
+  quantity: number
+}
+/**
+ * Represents the totals calculated for an order
+ */
+export declare interface OrderTotals {
+  subtotal: number
+  tax_amount: number
+  total_amount: number
+}
+/**
+ * Represents statistics for a discount type
+ */
+export declare interface DiscountTypeCount {
+  discount_type: string | undefined
+  count: string | number | bigint
+}
+/**
+ * Represents comprehensive coupon statistics
+ */
+export declare interface CouponStats {
+  total: number
+  active: number
+  by_type: DiscountTypeCount[]
+  most_used: {
+    id: number | undefined
+    code: string | undefined
+    discount_type: string | undefined
+    discount_value: number | undefined
+    usage_count: number | undefined
+  }[]
+  upcoming: {
+    id: number | undefined
+    code: string | undefined
+    discount_type: string | undefined
+    discount_value: number | undefined
+    start_date: Date | string
+    end_date: Date | string
+  }[]
+}
+export declare 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
+  totalItems: number
+  totalPrice: number
+}
+export declare 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
+}
+declare interface BaseResponse {
+  paging: {
+    total_records: number
+    page: number
+    total_pages: number
+  }
+  next_cursor: number | null
+}
+export declare interface GiftCardResponse extends BaseResponse {
+  data: GiftCardJsonResponse[]
+}
+export declare interface GiftCardStats {
+  total: number
+  active: number
+  by_status: Array<{ status: string, count: number }>
+  by_balance: {
+    low: number
+    medium: number
+    high: number
+  }
+  expiring_soon: GiftCardJsonResponse[]
+  recently_used: GiftCardJsonResponse[]
+}
+export declare interface FetchReviewsOptions {
+  page?: number
+  limit?: number
+}
+export declare interface ReviewResponse extends BaseResponse {
+  data: ReviewJsonResponse[]
+}
+export declare interface ManufacturerResponse extends BaseResponse {
+  data: ManufacturerJsonResponse[]
+}
+export declare 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 declare interface CategoryStats {
+  total: number
+  active: number
+  root_categories: number
+  child_categories: number
+  with_images: number
+  recently_added: Array<any>
+  top_parent_categories: Array<{
+    id: string
+    name: string
+    child_count: number
+  }>
+}
+/**
+ * Options for fetching product manufacturers
+ */
+export declare interface FetchManufacturersOptions {
+  country?: string
+  featured?: boolean
+  search?: string
+}
+export declare 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 declare interface CouponCountStats {
+  total: number
+  active: number
+  inactive: number
+}
+/**
+ * Interface for time-based coupon statistics
+ */
+export declare interface CouponTimeStats {
+  week: CouponCountStats
+  month: CouponCountStats
+  year: CouponCountStats
+  all_time: CouponCountStats
+}
+/**
+ * Interface for coupon redemption statistics
+ */
+export declare interface CouponRedemptionStats {
+  total: number
+  week: number
+  month: number
+  year: number
+  by_type: Record<string, number>
+}
+export declare 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
+}
+// Import the CustomerTable type from the ORM
+declare type CouponJsonResponse = ModelRow<typeof Coupon>;
+declare type CustomerJsonResponse = ModelRow<typeof Customer>;
+declare type GiftCardJsonResponse = ModelRow<typeof GiftCard>;
+declare type ManufacturerJsonResponse = ModelRow<typeof Manufacturer>;
+declare type OrderJsonResponse = ModelRow<typeof Order>;
+declare type OrderItemJsonResponse = ModelRow<typeof OrderItem>;
+declare type ReviewJsonResponse = ModelRow<typeof Review>;

package/dist/utils/typed-stats.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Run a typed aggregate query against a table.
+ *
+ * @example
+ * ```ts
+ * const stats = await aggregateStats('receipts', {
+ *   total: { kind: 'count' },
+ *   success: { kind: 'count', filter: { column: 'status', op: '=', value: 'success' } },
+ *   averageSize: { kind: 'avg', column: 'size' },
+ * }, qb => qb.where('timestamp', '>=', start).where('timestamp', '<=', end))
+ * // typeof stats: { total: number; success: number; averageSize: number }
+ * ```
+ */
+export declare function aggregateStats<TKeys extends string>(table: string, descriptors: Record<TKeys, StatsDescriptor>, applyWhere?: (qb: any) => any): Promise<Record<TKeys, number>>;
+/**
+ * Stats descriptors map: each key is the result-row alias; each value is
+ * a `{ kind, column, where? }` triple describing the aggregate to emit.
+ */
+export type StatsDescriptor = | { kind: 'count', column?: string, filter?: { column: string, op: string, value: unknown } }
+  | { kind: 'sum', column: string, filter?: { column: string, op: string, value: unknown } }
+  | { kind: 'avg', column: string, filter?: { column: string, op: string, value: unknown } }
+  | { kind: 'min', column: string, filter?: { column: string, op: string, value: unknown } }
+  | { kind: 'max', column: string, filter?: { column: string, op: string, value: unknown } }

package/dist/waitlists/index.d.ts

@@ -0,0 +1,12 @@
+import * as products from './products/index';
+import * as restaurant from './restaurant/index';
+declare const waitlists: WaitlistsNamespace;
+declare interface WaitlistsNamespace {
+  products: typeof products
+  restaurant: typeof restaurant
+}
+export {
+  products,
+  restaurant,
+};
+export default waitlists;

package/dist/waitlists/products/destroy.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Delete a waitlist product entry by ID
+ *
+ * @param id The ID of the waitlist product to delete
+ * @returns The deleted waitlist product record
+ */
+export declare function destroy(id: number): Promise<WaitlistProductJsonResponse | undefined>;
+/**
+ * Delete multiple waitlist product entries by their IDs
+ *
+ * @param ids Array of waitlist product IDs to delete
+ * @returns Number of waitlist products deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;
+declare type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>;

package/dist/waitlists/products/fetch.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Fetch a waitlist product by ID
+ */
+export declare function fetchById(id: number): Promise<WaitlistProductJsonResponse | undefined>;
+/**
+ * Fetch all waitlist products
+ */
+export declare function fetchAll(): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch the count of waitlist products grouped by source
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns An object containing the count for each source
+ */
+export declare function fetchCountBySource(startDate?: Date, _endDate?: Date): Promise<Record<string, number>>;
+/**
+ * Fetch the count of waitlist products 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 declare function fetchCountByDate(date?: Date): Promise<number>;
+/**
+ * Fetch the count of waitlist products with a specific quantity
+ * @param quantity The quantity to count orders for
+ * @returns The count of orders with the specified quantity
+ */
+export declare function fetchCountByQuantity(quantity: number): Promise<number>;
+/**
+ * Fetch the count of waitlist products grouped by quantity
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns An object containing the count for each quantity
+ */
+export declare function fetchCountByAllQuantities(startDate?: Date, _endDate?: Date): Promise<Record<number, number>>;
+/**
+ * Fetch waitlist products between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns Array of waitlist products within the date range
+ */
+export declare function fetchBetweenDates(startDate: Date, endDate: Date): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch waitlist products that were notified between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns Array of waitlist products that were notified within the date range
+ */
+export declare function fetchNotifiedBetweenDates(startDate: Date, endDate: Date): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch waitlist products that were purchased between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns Array of waitlist products that were purchased within the date range
+ */
+export declare function fetchPurchasedBetweenDates(startDate: Date, endDate: Date): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch waitlist products that were cancelled between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns Array of waitlist products that were cancelled within the date range
+ */
+export declare function fetchCancelledBetweenDates(startDate: Date, endDate: Date): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch all waitlist products with waiting status
+ * @returns Array of waitlist products with waiting status
+ */
+export declare function fetchWaiting(): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch the count of waitlist products by status
+ * @param status The status to filter by
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns The count of waitlist products with the specified status
+ */
+export declare function fetchCountByStatus(status: string, startDate?: Date, _endDate?: Date): Promise<number>;
+/**
+ * Fetch conversion rates for waitlist products
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns Object containing total conversion rate and breakdown by status
+ */
+export declare function fetchConversionRates(_startDate?: Date, _endDate?: Date): Promise<{
+    totalConversionRate: number
+    statusBreakdown: Record<string, { count: number, percentage: number }>
+  }>;
+/**
+ * Fetch the count of waitlist products between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns The count of waitlist products within the date range
+ */
+export declare function fetchCountBetweenDates(startDate: Date, endDate: Date): Promise<number>;
+/**
+ * Fetch the count of waitlist products grouped by date
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns An array of objects containing date and count
+ */
+export declare function fetchCountByDateGrouped(startDate?: Date, _endDate?: Date): Promise<{ date: string, count: number }[]>;
+declare type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>;

package/dist/waitlists/products/index.d.ts

@@ -0,0 +1,30 @@
+// Functions from destroy.ts
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy';
+export {
+  fetchAll,
+  fetchById,
+  fetchCancelledBetweenDates,
+  fetchConversionRates,
+  fetchCountBetweenDates,
+  fetchCountByAllQuantities,
+  fetchCountByDate,
+  fetchCountByDateGrouped,
+  fetchCountByQuantity,
+  fetchCountBySource,
+  fetchCountByStatus,
+  fetchNotifiedBetweenDates,
+  fetchPurchasedBetweenDates,
+  fetchWaiting,
+} from './fetch';
+export {
+  bulkStore,
+  store,
+} from './store';
+export {
+  update,
+  updatePartySize,
+  updateStatus,
+} from './update';

package/dist/waitlists/products/store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Create a new waitlist product entry
+ *
+ * @param data Waitlist product data to store
+ * @returns The newly created waitlist product record
+ */
+export declare function store(data: NewWaitlistProduct): Promise<WaitlistProductJsonResponse>;
+/**
+ * Create multiple waitlist product entries at once
+ *
+ * @param data Array of waitlist product data to store
+ * @returns Number of waitlist products created
+ */
+export declare function bulkStore(data: NewWaitlistProduct[]): Promise<number>;
+declare type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>;
+declare type NewWaitlistProduct = NewModelData<typeof WaitlistProduct>;

package/dist/waitlists/products/update.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Update a waitlist product
+ *
+ * @param id The id of the waitlist product to update
+ * @param data The waitlist product data to update
+ * @returns The updated waitlist product record
+ */
+export declare function update(id: number, data: WaitlistProductUpdate): Promise<WaitlistProductJsonResponse>;
+/**
+ * Update a waitlist product's status
+ *
+ * @param id The ID of the waitlist product
+ * @param status The new status
+ * @returns The updated waitlist product with the new status
+ */
+export declare function updateStatus(id: number, status: 'waiting' | 'purchased' | 'notified' | 'cancelled'): Promise<WaitlistProductJsonResponse>;
+/**
+ * Update party size for a waitlist product
+ *
+ * @param id The ID of the waitlist product
+ * @param partySize The updated party size
+ * @returns The updated waitlist product
+ */
+export declare function updatePartySize(id: number, partySize: number): Promise<WaitlistProductJsonResponse>;
+declare type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>;
+declare type WaitlistProductUpdate = UpdateModelData<typeof WaitlistProduct>;

package/dist/waitlists/restaurant/destroy.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Delete a restaurant waitlist entry by ID
+ *
+ * @param id The ID of the restaurant waitlist entry to delete
+ * @returns The deleted restaurant waitlist record
+ */
+export declare function destroy(id: number): Promise<WaitlistRestaurantJsonResponse | undefined>;
+/**
+ * Delete multiple restaurant waitlist entries by their IDs
+ *
+ * @param ids Array of restaurant waitlist entry IDs to delete
+ * @returns Number of restaurant waitlist entries deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;
+declare type WaitlistRestaurantJsonResponse = ModelRow<typeof WaitlistRestaurant>;

package/dist/waitlists/restaurant/fetch.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Fetch a restaurant waitlist entry by ID
+ */
+export declare function fetchById(id: number): Promise<WaitlistRestaurantJsonResponse | undefined>;
+/**
+ * Fetch all restaurant waitlist entries
+ */
+export declare function fetchAll(): Promise<WaitlistRestaurantJsonResponse[]>;
+/**
+ * Fetch the count of restaurant waitlist entries grouped by table preference
+ * @returns An object containing the count for each table preference
+ */
+export declare function fetchCountByTablePreference(): Promise<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 declare function fetchCountByDate(date?: Date): Promise<number>;
+/**
+ * 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 declare function fetchCountByPartySize(partySize: number): Promise<number>;
+/**
+ * Fetch the count of restaurant waitlist entries grouped by party size
+ * @returns An object containing the count for each party size
+ */
+export declare function fetchCountByAllPartySizes(): Promise<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 declare function fetchBetweenDates(startDate: Date, _endDate: Date): Promise<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 declare function fetchSeatedBetweenDates(startDate: Date, _endDate: Date): Promise<WaitlistRestaurantJsonResponse[]>;
+/**
+ * Fetch all restaurant waitlist entries with waiting status
+ * @returns Array of waitlist entries with waiting status
+ */
+export declare function fetchWaiting(): Promise<WaitlistRestaurantJsonResponse[]>;
+/**
+ * Fetch conversion rates for restaurant waitlist entries
+ * @returns Object containing total conversion rate and breakdown by status
+ */
+export declare function fetchConversionRates(): Promise<{
+  totalConversionRate: number
+  statusBreakdown: Record<string, { count: number, percentage: number }>
+}>;
+/**
+ * Fetch average wait times for restaurant waitlist entries
+ * @returns Object containing average quoted and actual wait times
+ */
+export declare function fetchAverageWaitTimes(): Promise<{
+  averageQuotedWaitTime: number
+  averageActualWaitTime: number
+}>;
+/**
+ * Fetch all waiting entries with their quoted wait times
+ * @returns Array of waiting entries with their quoted wait times
+ */
+export declare function fetchWaitingWithQuotedTimes(): Promise<{
+  entries: WaitlistRestaurantJsonResponse[]
+  totalQuotedWaitTime: number
+  averageQuotedWaitTime: number
+}>;
+/**
+ * Fetch all waiting entries with party size calculations
+ * @returns Object containing waiting entries and party size statistics
+ */
+export declare function fetchWaitingWithPartySizes(): Promise<{
+  entries: WaitlistRestaurantJsonResponse[]
+  totalPartySize: number
+  averagePartySize: number
+  partySizeBreakdown: Record<number, number>
+}>;
+/**
+ * Fetch tables turned statistics for today
+ * @returns Object containing tables turned statistics
+ */
+export declare function fetchTablesTurnedToday(): Promise<{
+  totalTablesTurned: number
+  averagePartySize: number
+  totalCustomersSeated: number
+  breakdownByTablePreference: Record<string, number>
+  breakdownByPartySize: Record<number, number>
+}>;
+/**
+ * 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 declare function fetchSeatingRate(_startDate: Date, _endDate: Date): Promise<{
+    totalEntries: number
+    seatedEntries: number
+    seatingRate: number
+    statusBreakdown: Record<string, { count: number, percentage: number }>
+  }>;
+/**
+ * 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 declare function fetchNoShowStats(_startDate: Date, _endDate: Date): Promise<{
+    totalNoShows: number
+    noShowRate: number
+    averageQuotedWaitTime: number
+    averagePartySize: number
+    breakdownByTablePreference: Record<string, number>
+    breakdownByPartySize: Record<number, number>
+  }>;
+/**
+ * Fetch current wait time statistics
+ * @returns Object containing average quoted and actual wait times
+ */
+export declare function fetchCurrentWaitTimes(): Promise<{
+  averageQuoted: number
+  averageActual: number
+}>;
+/**
+ * Fetch seated statistics for the last 24 hours
+ * @returns Object containing total seated count and hourly breakdown
+ */
+export declare function fetchSeatedStats(): Promise<{
+  total: number
+  byHour: Array<{ hour: number, count: number }>
+}>;
+/**
+ * Fetch time series statistics for all statuses
+ * @returns Object containing daily counts for each status
+ */
+export declare function fetchTimeSeriesStats(): Promise<Record<string, {
+  total: number
+  waiting: number
+  seated: number
+  cancelled: number
+  no_show: number
+}>>;
+declare type WaitlistRestaurantJsonResponse = ModelRow<typeof WaitlistRestaurant>;