@stacksjs/commerce 0.70.55 → 0.70.57

package/src/waitlists/products/store.ts

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

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

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

@@ -1,107 +0,0 @@
-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)
-}