@stacksjs/commerce 0.70.53 → 0.70.55

package/src/waitlists/products/store.ts

@@ -0,0 +1,112 @@
+type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>
+type NewWaitlistProduct = NewModelData<typeof WaitlistProduct>
+import { randomUUIDv7 } from 'bun'
+import { db } from '@stacksjs/database'
+import { formatDate } from '@stacksjs/orm'
+
+/**
+ * Create a new waitlist product entry
+ *
+ * @param data Waitlist product data to store
+ * @returns The newly created waitlist product record
+ */
+export async function store(data: NewWaitlistProduct): Promise<WaitlistProductJsonResponse> {
+  try {
+    const d = data as Record<string, unknown>
+    const waitlistData: Record<string, any> = {
+      name: data.name,
+      email: data.email,
+      phone: data.phone,
+      quantity: data.quantity ?? d.party_size,
+      notification_preference: d.notification_preference,
+      source: data.source,
+      notes: data.notes,
+      product_id: data.product_id,
+      customer_id: data.customer_id,
+      uuid: randomUUIDv7(),
+      status: data.status || 'waiting',
+    }
+
+    if ((data as any).notified_at !== undefined)
+      waitlistData.notified_at = typeof (data as any).notified_at === 'number' ? formatDate((data as any).notified_at) : (data as any).notified_at
+
+    if ((data as any).purchased_at !== undefined)
+      waitlistData.purchased_at = typeof (data as any).purchased_at === 'number' ? formatDate((data as any).purchased_at) : (data as any).purchased_at
+
+    if ((data as any).cancelled_at !== undefined)
+      waitlistData.cancelled_at = typeof (data as any).cancelled_at === 'number' ? formatDate((data as any).cancelled_at) : (data as any).cancelled_at
+
+    const result = await db
+      .insertInto('waitlist_products')
+      .values(waitlistData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create waitlist product')
+
+    return result as WaitlistProductJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create waitlist product: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Create multiple waitlist product entries at once
+ *
+ * @param data Array of waitlist product data to store
+ * @returns Number of waitlist products created
+ */
+export async function bulkStore(data: NewWaitlistProduct[]): Promise<number> {
+  if (!data.length)
+    return 0
+
+  try {
+    const waitlistDataArray = data.map((item) => {
+      const i = item as Record<string, unknown>
+      const entry: Record<string, any> = {
+        name: item.name,
+        email: item.email,
+        phone: item.phone,
+        quantity: item.quantity ?? i.party_size,
+        notification_preference: i.notification_preference,
+        source: item.source,
+        notes: item.notes,
+        product_id: item.product_id,
+        customer_id: item.customer_id,
+        uuid: randomUUIDv7(),
+        status: item.status || 'waiting',
+      }
+
+      if ((item as any).notified_at !== undefined)
+        entry.notified_at = typeof (item as any).notified_at === 'number' ? formatDate((item as any).notified_at) : (item as any).notified_at
+
+      if ((item as any).purchased_at !== undefined)
+        entry.purchased_at = typeof (item as any).purchased_at === 'number' ? formatDate((item as any).purchased_at) : (item as any).purchased_at
+
+      if ((item as any).cancelled_at !== undefined)
+        entry.cancelled_at = typeof (item as any).cancelled_at === 'number' ? formatDate((item as any).cancelled_at) : (item as any).cancelled_at
+
+      return entry
+    })
+
+    const result = await db
+      .insertInto('waitlist_products')
+      .values(waitlistDataArray)
+      .executeTakeFirst()
+
+    return Number(result.numInsertedOrUpdatedRows)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create waitlist products in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/waitlists/products/update.ts

@@ -0,0 +1,125 @@
+import { db } from '@stacksjs/database'
+import { formatDate } from '@stacksjs/orm'
+type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>
+type WaitlistProductUpdate = UpdateModelData<typeof WaitlistProduct>
+
+/**
+ * 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 async function update(id: number, data: WaitlistProductUpdate): Promise<WaitlistProductJsonResponse> {
+  try {
+    if (!id)
+      throw new Error('Waitlist product ID is required for update')
+
+    const d = data as Record<string, unknown>
+    const result = await db
+      .updateTable('waitlist_products')
+      .set({
+        name: data.name,
+        email: data.email,
+        phone: data.phone,
+        quantity: data.quantity ?? d.party_size,
+        notification_preference: d.notification_preference,
+        source: data.source,
+        notes: data.notes,
+        status: data.status,
+        product_id: data.product_id,
+        customer_id: data.customer_id,
+        notified_at: d.notified_at,
+        purchased_at: d.purchased_at,
+        cancelled_at: d.cancelled_at,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update waitlist product')
+
+    return result as WaitlistProductJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update waitlist product: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * 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 async function updateStatus(
+  id: number,
+  status: 'waiting' | 'purchased' | 'notified' | 'cancelled',
+): Promise<WaitlistProductJsonResponse> {
+  try {
+    const result = await db
+      .updateTable('waitlist_products')
+      .set({
+        status,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update waitlist product status')
+
+    return result as WaitlistProductJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update waitlist product status: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * 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 async function updatePartySize(
+  id: number,
+  partySize: number,
+): Promise<WaitlistProductJsonResponse> {
+  try {
+    const result = await db
+      .updateTable('waitlist_products')
+      .set({
+        quantity: partySize,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update party size')
+
+    return result as WaitlistProductJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update party size: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/waitlists/restaurant/destroy.ts

@@ -0,0 +1,65 @@
+type WaitlistRestaurantJsonResponse = ModelRow<typeof WaitlistRestaurant>
+import { db } from '@stacksjs/database'
+
+/**
+ * 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 async function destroy(id: number): Promise<WaitlistRestaurantJsonResponse | undefined> {
+  try {
+    // First get the restaurant waitlist entry to return it after deletion
+    const waitlistEntry = await db
+      .selectFrom('waitlist_restaurants')
+      .where('id', '=', id)
+      .selectAll()
+      .executeTakeFirst()
+
+    if (!waitlistEntry)
+      return undefined
+
+    // Delete the restaurant waitlist entry
+    await db
+      .deleteFrom('waitlist_restaurants')
+      .where('id', '=', id)
+      .execute()
+
+    return waitlistEntry as WaitlistRestaurantJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete restaurant waitlist entry: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * 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 async function bulkDestroy(ids: number[]): Promise<number> {
+  if (!ids.length)
+    return 0
+
+  try {
+    // Delete all restaurant waitlist entries with the given IDs
+    const result = await db
+      .deleteFrom('waitlist_restaurants')
+      .where('id', 'in', ids)
+      .execute()
+
+    return (result as any).length || 0
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete restaurant waitlist entries in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/waitlists/restaurant/export.ts

@@ -0,0 +1,107 @@
+type WaitlistRestaurantJsonResponse = ModelRow<typeof WaitlistRestaurant>
+import type { SpreadsheetWrapper } from 'ts-spreadsheets'
+import { createSpreadsheet } from 'ts-spreadsheets'
+import { fetchAll } from './fetch'
+
+/**
+ * Represents the structure of an exported restaurant waitlist entry
+ */
+export interface ExportedRestaurantWaitlist {
+  'ID': number
+  'Name': string
+  'Phone': string
+  'Party Size': number
+  'Table Preference': string
+  'Status': string
+  'Quoted Wait Time': number
+  'Actual Wait Time': number
+  'Check In Time': string
+  'Created At': string
+  'Notes': string
+}
+
+/**
+ * Export restaurant waitlist entries to a spreadsheet
+ * @param format The format of the spreadsheet (default is CSV)
+ * @returns Spreadsheet object ready for download or storage
+ */
+export async function exportRestaurantWaitlist(format: 'csv' | 'excel' = 'csv'): Promise<SpreadsheetWrapper> {
+  // Fetch all restaurant waitlist entries
+  const waitlistEntries = await fetchAll()
+
+  // Prepare data for spreadsheet
+  const spreadsheetData = prepareRestaurantWaitlistForExport(waitlistEntries)
+
+  // Create and return spreadsheet
+  return createSpreadsheet(spreadsheetData, { type: format })
+}
+
+/**
+ * Prepare restaurant waitlist data for spreadsheet export
+ * @param waitlistEntries Array of restaurant waitlist entry objects
+ * @returns Spreadsheet data structure
+ */
+function prepareRestaurantWaitlistForExport(waitlistEntries: WaitlistRestaurantJsonResponse[]) {
+  // Define headings
+  const headings: (keyof ExportedRestaurantWaitlist)[] = [
+    'ID',
+    'Name',
+    'Phone',
+    'Party Size',
+    'Table Preference',
+    'Status',
+    'Quoted Wait Time',
+    'Actual Wait Time',
+    'Check In Time',
+    'Created At',
+    'Notes',
+  ]
+
+  // Transform waitlist entries into export format
+  const data = waitlistEntries.map((entry) => {
+    return [
+      entry.id,
+      entry.name,
+      entry.phone || 'N/A',
+      entry.partySize,
+      entry.tablePreference,
+      entry.status,
+      (entry as any).quoted_wait_time || 'N/A',
+      (entry as any).actual_wait_time || 'N/A',
+      entry.checkInTime || 'N/A',
+      entry.created_at,
+      (entry as any).notes || 'N/A',
+    ]
+  })
+
+  return { headings, data }
+}
+
+/**
+ * Export restaurant waitlist entries and automatically download
+ * @param format The format of the spreadsheet (default is CSV)
+ * @param filename Optional filename for the download
+ * @returns Download response
+ */
+export async function downloadRestaurantWaitlist(format: 'csv' | 'excel' = 'csv', filename?: string): Promise<Response> {
+  const spreadsheet = await exportRestaurantWaitlist(format)
+
+  // Use default filename if not provided
+  const defaultFilename = `restaurant_waitlist_export_${new Date().toISOString().split('T')[0]}.${format}`
+  return spreadsheet.download(filename || defaultFilename)
+}
+
+/**
+ * Store restaurant waitlist export to disk
+ * @param format The format of the spreadsheet (default is CSV)
+ * @param path Optional path to store the file
+ * @returns Path where the file is stored
+ */
+export async function storeRestaurantWaitlistExport(format: 'csv' | 'excel' = 'csv', path?: string): Promise<void> {
+  const spreadsheet = await exportRestaurantWaitlist(format)
+
+  // Use default path and filename if not provided
+  const defaultPath = `restaurant_waitlist_export_${new Date().toISOString().split('T')[0]}.${format}`
+
+  spreadsheet.store(path || defaultPath)
+}