@stacksjs/commerce 0.70.54 → 0.70.55

package/src/receipts/fetch.ts

@@ -0,0 +1,222 @@
+import { db } from '@stacksjs/database'
+import { aggregateStats } from '../utils/typed-stats'
+type ReceiptJsonResponse = ModelRow<typeof Receipt>
+
+/**
+ * Fetch a print log by ID
+ */
+export async function fetchById(id: number): Promise<ReceiptJsonResponse | undefined> {
+  // Single `as` at the kysely → typed-result boundary — schema-wide
+  // typing for `selectAll()` would force every consumer to import the
+  // generated row types, which we want to keep optional in user code.
+  return await db
+    .selectFrom('receipts')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as ReceiptJsonResponse | undefined
+}
+
+/**
+ * Fetch all print logs
+ */
+export async function fetchAll(): Promise<ReceiptJsonResponse[]> {
+  return await db.selectFrom('receipts').selectAll().execute() as ReceiptJsonResponse[]
+}
+
+/**
+ * Fetch print job statistics by status within a date range
+ *
+ * @param startDate Start date for the range
+ * @param endDate End date for the range
+ * @returns Object containing counts for each status and total
+ */
+export async function fetchPrintJobStats(
+  _startDate: Date | number,
+  _endDate: Date | number,
+): Promise<{
+    total: number
+    success: number
+    failed: number
+    warning: number
+    averageSize: number
+    averagePages: number
+    averageDuration: number
+  }> {
+  const start = typeof _startDate === 'number' ? _startDate : _startDate.getTime()
+  const end = typeof _endDate === 'number' ? _endDate : _endDate.getTime()
+
+  const stats = await aggregateStats('receipts', {
+    total: { kind: 'count' },
+    success: { kind: 'count', filter: { column: 'status', op: '=', value: 'success' } },
+    failed: { kind: 'count', filter: { column: 'status', op: '=', value: 'failed' } },
+    warning: { kind: 'count', filter: { column: 'status', op: '=', value: 'warning' } },
+    averageSize: { kind: 'avg', column: 'size' },
+    averagePages: { kind: 'avg', column: 'pages' },
+    averageDuration: { kind: 'avg', column: 'duration' },
+  }, qb => qb.where('timestamp', '>=', start).where('timestamp', '<=', end))
+
+  return {
+    total: stats.total,
+    success: stats.success,
+    failed: stats.failed,
+    warning: stats.warning,
+    averageSize: Math.round(stats.averageSize),
+    averagePages: Math.round(stats.averagePages),
+    averageDuration: Math.round(stats.averageDuration),
+  }
+}
+
+/**
+ * Calculate the success rate percentage for print jobs within a date range
+ *
+ * @param startDate Start date for the range
+ * @param endDate End date for the range
+ * @returns Object containing success rate percentage and detailed counts
+ */
+export async function fetchSuccessRate(
+  _startDate: Date | number,
+  _endDate: Date | number,
+): Promise<{
+    successRate: number
+    total: number
+    success: number
+    failed: number
+    warning: number
+  }> {
+  const start = typeof _startDate === 'number' ? _startDate : _startDate.getTime()
+  const end = typeof _endDate === 'number' ? _endDate : _endDate.getTime()
+
+  const stats = await aggregateStats('receipts', {
+    total: { kind: 'count' },
+    success: { kind: 'count', filter: { column: 'status', op: '=', value: 'success' } },
+    failed: { kind: 'count', filter: { column: 'status', op: '=', value: 'failed' } },
+    warning: { kind: 'count', filter: { column: 'status', op: '=', value: 'warning' } },
+  }, qb => qb.where('timestamp', '>=', start).where('timestamp', '<=', end))
+
+  const successRate = stats.total > 0 ? Math.round((stats.success / stats.total) * 100) : 0
+
+  return {
+    successRate,
+    total: stats.total,
+    success: stats.success,
+    failed: stats.failed,
+    warning: stats.warning,
+  }
+}
+
+/**
+ * Calculate total pages and average pages per receipt within a date range
+ *
+ * @param startDate Start date for the range
+ * @param endDate End date for the range
+ * @returns Object containing total pages and average pages per receipt
+ */
+export async function fetchPageStats(
+  _startDate: Date | number,
+  _endDate: Date | number,
+): Promise<{
+    totalPages: number
+    averagePagesPerReceipt: number
+    totalReceipts: number
+  }> {
+  const start = typeof _startDate === 'number' ? _startDate : _startDate.getTime()
+  const end = typeof _endDate === 'number' ? _endDate : _endDate.getTime()
+
+  const stats = await aggregateStats('receipts', {
+    totalReceipts: { kind: 'count' },
+    totalPages: { kind: 'sum', column: 'pages' },
+    averagePagesPerReceipt: { kind: 'avg', column: 'pages' },
+  }, qb => qb.where('timestamp', '>=', start).where('timestamp', '<=', end))
+
+  return {
+    totalPages: stats.totalPages,
+    averagePagesPerReceipt: Math.round(stats.averagePagesPerReceipt),
+    totalReceipts: stats.totalReceipts,
+  }
+}
+
+/**
+ * Calculate average print time statistics within a date range
+ *
+ * @param startDate Start date for the range
+ * @param endDate End date for the range
+ * @returns Object containing average print time and related statistics
+ */
+export async function fetchPrintTimeStats(
+  _startDate: Date | number,
+  _endDate: Date | number,
+): Promise<{
+    averageDuration: number
+    minDuration: number
+    maxDuration: number
+    totalJobs: number
+  }> {
+  const start = typeof _startDate === 'number' ? _startDate : _startDate.getTime()
+  const end = typeof _endDate === 'number' ? _endDate : _endDate.getTime()
+
+  const stats = await aggregateStats('receipts', {
+    totalJobs: { kind: 'count' },
+    averageDuration: { kind: 'avg', column: 'duration' },
+    minDuration: { kind: 'min', column: 'duration' },
+    maxDuration: { kind: 'max', column: 'duration' },
+  }, qb => qb.where('timestamp', '>=', start).where('timestamp', '<=', end))
+
+  return {
+    averageDuration: Math.round(stats.averageDuration),
+    minDuration: stats.minDuration,
+    maxDuration: stats.maxDuration,
+    totalJobs: stats.totalJobs,
+  }
+}
+
+/**
+ * Calculate prints per hour statistics within a date range
+ *
+ * @param startDate Start date for the range
+ * @param endDate End date for the range
+ * @returns Object containing prints per hour statistics
+ */
+export async function fetchPrintsPerHour(
+  _startDate: Date | number,
+  _endDate: Date | number,
+): Promise<{
+    totalPrints: number
+    totalHours: number
+    printsPerHour: number
+    hourlyBreakdown: Array<{
+      hour: number
+      count: number
+    }>
+  }> {
+  const start = typeof _startDate === 'number' ? _startDate : _startDate.getTime()
+  const end = typeof _endDate === 'number' ? _endDate : _endDate.getTime()
+
+  const receipts = await db
+    .selectFrom('receipts')
+    .where('timestamp', '>=', start)
+    .where('timestamp', '<=', end)
+    .selectAll()
+    .execute()
+
+  const totalPrints = receipts.length
+  const totalHours = Math.ceil((end - start) / (1000 * 60 * 60))
+  const printsPerHour = totalHours > 0 ? Math.round(totalPrints / totalHours) : 0
+
+  const hourlyBreakdown = Array.from({ length: 24 }, (_, i) => ({
+    hour: i,
+    count: 0,
+  }))
+
+  receipts.forEach((receipt: any) => {
+    const date = new Date(Number(receipt.timestamp))
+    const hour = date.getHours()
+    hourlyBreakdown[hour].count++
+  })
+
+  return {
+    totalPrints,
+    totalHours,
+    printsPerHour,
+    hourlyBreakdown,
+  }
+}

package/src/receipts/index.ts

@@ -0,0 +1,24 @@
+// Functions from destroy.ts
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy'
+
+// Functions from fetch.ts
+export {
+  fetchAll,
+  fetchById,
+} from './fetch'
+
+// Functions from store.ts
+export {
+  bulkStore,
+  store,
+} from './store'
+
+// Functions from update.ts
+export {
+  update,
+  updatePrintJob,
+  updateStatus,
+} from './update'

package/src/receipts/printer.ts

@@ -0,0 +1,69 @@
+// wip
+import { log } from '@stacksjs/logging'
+
+interface Printer {
+  id: string | number
+  name: string
+  status: string
+}
+
+interface PrintJob {
+  printer: Printer
+  receipt: Receipt
+}
+
+interface PrinterDriver {
+  print: (printJob: PrintJob) => Promise<void>
+  cleanUp: (printer: Printer) => Promise<void>
+  checkStatus: (printer: Printer) => Promise<boolean>
+  findPrinters: () => Promise<Printer[]>
+  setup: (printer: Printer) => Promise<void>
+  restart: () => Promise<void>
+  canInteractWithPrinter: (printer: Printer) => Promise<boolean>
+}
+
+type Path = string
+
+interface Receipt {
+  id: string | number
+  name: string
+  price: number
+  quantity: number
+  template: Path
+}
+
+class TSPIVPrinter implements PrinterDriver {
+  async print(printJob: PrintJob): Promise<void> {
+    log.debug('TSP IV Printer: Printing receipt', printJob.receipt)
+  }
+
+  async cleanUp(_printer: Printer): Promise<void> {
+    log.debug('TSP IV Printer: Cleaning up print job...')
+  }
+
+  async checkStatus(_printer: Printer): Promise<boolean> {
+    log.debug('TSP IV Printer: Checking online status...')
+    return true
+  }
+
+  async findPrinters(): Promise<Printer[]> {
+    log.debug('TSP IV Printer: Finding printers...')
+    return []
+  }
+
+  async setup(_printer: Printer): Promise<void> {
+    log.debug('TSP IV Printer: Setting up printer...')
+  }
+
+  async restart(): Promise<void> {
+    log.debug('TSP IV Printer: Restarting...')
+  }
+
+  async canInteractWithPrinter(_printer: Printer): Promise<boolean> {
+    log.debug('TSP IV Printer: Checking if can interact with printer...')
+    return true
+  }
+}
+
+// Export the TSP IV printer instance
+export const tspIVPrinter: PrinterDriver = new TSPIVPrinter()

package/src/receipts/store.ts

@@ -0,0 +1,69 @@
+type ReceiptJsonResponse = ModelRow<typeof Receipt>
+type NewReceipt = NewModelData<typeof Receipt>
+import { randomUUIDv7 } from 'bun'
+import { db } from '@stacksjs/database'
+
+/**
+ * Create a new receipt
+ *
+ * @param data The receipt data to store
+ * @returns The newly created receipt record
+ */
+export async function store(data: NewReceipt): Promise<ReceiptJsonResponse> {
+  try {
+    const receiptData = {
+      ...data,
+      uuid: randomUUIDv7(),
+    }
+
+    const result = await db
+      .insertInto('receipts')
+      .values(receiptData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create receipt')
+
+    return result as ReceiptJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create receipt: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Create multiple receipts at once
+ *
+ * @param data Array of receipt data to store
+ * @returns Number of receipts created
+ */
+export async function bulkStore(data: NewReceipt[]): Promise<number> {
+  if (!data.length)
+    return 0
+
+  try {
+    const receiptDataArray = data.map(item => ({
+      ...item,
+      uuid: randomUUIDv7(),
+    }))
+
+    const result = await db
+      .insertInto('receipts')
+      .values(receiptDataArray)
+      .executeTakeFirst()
+
+    return Number(result.numInsertedOrUpdatedRows)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create receipts in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/receipts/update.ts

@@ -0,0 +1,124 @@
+import { db } from '@stacksjs/database'
+import { formatDate } from '@stacksjs/orm'
+type ReceiptJsonResponse = ModelRow<typeof Receipt>
+type ReceiptUpdate = UpdateModelData<typeof Receipt>
+
+/**
+ * Update a receipt
+ *
+ * @param id The id of the receipt to update
+ * @param data The receipt data to update
+ * @returns The updated receipt record
+ */
+export async function update(id: number, data: ReceiptUpdate): Promise<ReceiptJsonResponse> {
+  try {
+    if (!id)
+      throw new Error('Receipt ID is required for update')
+
+    const result = await db
+      .updateTable('receipts')
+      .set({
+        ...data,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update receipt')
+
+    return result as ReceiptJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update receipt: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update a receipt's status
+ *
+ * @param id The ID of the receipt
+ * @param status The new status
+ * @returns The updated receipt with the new status
+ */
+export async function updateStatus(
+  id: number,
+  status: 'success' | 'failed' | 'warning',
+): Promise<ReceiptJsonResponse> {
+  try {
+    const result = await db
+      .updateTable('receipts')
+      .set({
+        status,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update receipt status')
+
+    return result as ReceiptJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update receipt status: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update print job information
+ *
+ * @param id The ID of the receipt
+ * @param size Optional new size value
+ * @param pages Optional new pages value
+ * @param duration Optional new duration value
+ * @returns The updated receipt
+ */
+export async function updatePrintJob(
+  id: number,
+  size?: number,
+  pages?: number,
+  duration?: number,
+): Promise<ReceiptJsonResponse> {
+  try {
+    const updateData: Record<string, any> = {
+      updated_at: formatDate(new Date()),
+    }
+
+    if (size !== undefined)
+      updateData.size = size
+    if (pages !== undefined)
+      updateData.pages = pages
+    if (duration !== undefined)
+      updateData.duration = duration
+
+    const result = await db
+      .updateTable('receipts')
+      .set(updateData)
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update receipt job information')
+
+    return result as ReceiptJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update receipt job information: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/shippings/delivery-routes/destroy.ts

@@ -0,0 +1,54 @@
+import { db } from '@stacksjs/database'
+
+/**
+ * Delete a delivery route by ID
+ *
+ * @param id The ID of the delivery route to delete
+ * @returns True if the delivery route was deleted, false otherwise
+ */
+export async function destroy(id: number): Promise<boolean> {
+  try {
+    const result = await db
+      .deleteFrom('delivery_routes')
+      .where('id', '=', id)
+      .executeTakeFirst()
+
+    return Number(result.numDeletedRows) > 0
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete delivery route: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Delete multiple delivery routes by ID
+ *
+ * @param ids Array of delivery route IDs to delete
+ * @returns Number of delivery routes deleted
+ */
+export async function bulkDestroy(ids: number[]): Promise<number> {
+  if (!ids.length)
+    return 0
+
+  try {
+    // Perform the delete operation
+    const result = await db
+      .deleteFrom('delivery_routes')
+      .where('id', 'in', ids)
+      .executeTakeFirst()
+
+    // Return the number of deleted rows
+    return Number(result.numDeletedRows)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to delete delivery routes: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/shippings/delivery-routes/fetch.ts

@@ -0,0 +1,42 @@
+type DeliveryRouteJsonResponse = ModelRow<typeof DeliveryRoute>
+import { db } from '@stacksjs/database'
+
+/**
+ * Fetch a delivery route by ID
+ */
+export async function fetchById(id: number): Promise<DeliveryRouteJsonResponse | undefined> {
+  return await db
+    .selectFrom('delivery_routes')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as DeliveryRouteJsonResponse | undefined
+}
+
+/**
+ * Fetch all delivery routes
+ */
+export async function fetchAll(): Promise<DeliveryRouteJsonResponse[]> {
+  return await db.selectFrom('delivery_routes').selectAll().execute() as DeliveryRouteJsonResponse[]
+}
+
+/**
+ * Fetch active delivery routes
+ */
+export async function fetchActive(): Promise<DeliveryRouteJsonResponse[]> {
+  return await db
+    .selectFrom('delivery_routes')
+    .where('last_active', '<=', new Date(Date.now() - 24 * 60 * 60 * 1000)) // Last 24 hours
+    .selectAll()
+    .execute() as DeliveryRouteJsonResponse[]
+}
+
+/**
+ * Fetch delivery routes by driver
+ */
+export async function fetchByDriver(driver: string): Promise<DeliveryRouteJsonResponse[]> {
+  return await db
+    .selectFrom('delivery_routes')
+    .where('driver', '=', driver)
+    .selectAll()
+    .execute() as DeliveryRouteJsonResponse[]
+}

package/src/shippings/delivery-routes/index.ts

@@ -0,0 +1,26 @@
+// Functions from destroy.ts
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy'
+
+// Functions from fetch.ts
+export {
+  fetchActive,
+  fetchAll,
+  fetchByDriver,
+  fetchById,
+} from './fetch'
+
+// Functions from store.ts
+export {
+  store,
+  updateLastActive,
+} from './store'
+
+// Functions from update.ts
+export {
+  update,
+  updateMetrics,
+  updateStops,
+} from './update'

package/src/shippings/delivery-routes/store.ts

@@ -0,0 +1,69 @@
+type DeliveryRouteJsonResponse = ModelRow<typeof DeliveryRoute>
+type NewDeliveryRoute = NewModelData<typeof DeliveryRoute>
+import { randomUUIDv7 } from 'bun'
+import { db } from '@stacksjs/database'
+
+/**
+ * Create a new delivery route
+ *
+ * @param data The delivery route data to store
+ * @returns The newly created delivery route record
+ */
+export async function store(data: NewDeliveryRoute): Promise<DeliveryRouteJsonResponse> {
+  try {
+    const routeData = {
+      ...data,
+      uuid: randomUUIDv7(),
+    }
+
+    const result = await db
+      .insertInto('delivery_routes')
+      .values(routeData)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create delivery route')
+
+    return result as DeliveryRouteJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create delivery route: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update a delivery route's last active timestamp
+ *
+ * @param id The ID of the delivery route to update
+ * @returns The updated delivery route record
+ */
+export async function updateLastActive(id: number): Promise<DeliveryRouteJsonResponse> {
+  try {
+    const result = await db
+      .updateTable('delivery_routes')
+      .set({
+        last_active: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update delivery route last active')
+
+    return result as DeliveryRouteJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update delivery route last active: ${error.message}`)
+    }
+
+    throw error
+  }
+}