@stacksjs/commerce 0.70.55 → 0.70.57

package/src/devices/store.ts

@@ -1,82 +0,0 @@
-type PrintDeviceJsonResponse = ModelRow<typeof PrintDevice>
-type NewPrintDevice = NewModelData<typeof PrintDevice>
-import { randomUUIDv7 } from 'bun'
-import { db } from '@stacksjs/database'
-
-/**
- * Create a new print device
- *
- * @param data Print device data to store
- * @returns The newly created print device record
- */
-export async function store(data: NewPrintDevice): Promise<PrintDeviceJsonResponse | undefined> {
-  try {
-    // Prepare print device data
-    const deviceData = {
-      ...data,
-      uuid: randomUUIDv7(),
-    }
-
-    // Insert the print device
-    const result = await db
-      .insertInto('print_devices')
-      .values(deviceData as NewPrintDevice)
-      .executeTakeFirst()
-
-    const deviceId = Number(result.insertId) || Number(result.numInsertedOrUpdatedRows)
-
-    // Retrieve the newly created print device
-    const printDevice = await db
-      .selectFrom('print_devices')
-      .where('id', '=', deviceId)
-      .selectAll()
-      .executeTakeFirst()
-
-    return printDevice as PrintDeviceJsonResponse | undefined
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create print device: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Create multiple print devices at once
- *
- * @param data Array of print device data to store
- * @returns Number of print devices created
- */
-export async function bulkStore(data: NewPrintDevice[]): Promise<number> {
-  if (!data.length)
-    return 0
-
-  let createdCount = 0
-
-  try {
-    for (const device of data) {
-      const deviceData = {
-        ...device,
-        uuid: randomUUIDv7(),
-      }
-
-      await db
-        .insertInto('print_devices')
-        .values(deviceData as NewPrintDevice)
-        .execute()
-
-      createdCount++
-    }
-
-    return createdCount
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create print devices in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/devices/update.ts

@@ -1,125 +0,0 @@
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-type PrintDeviceJsonResponse = ModelRow<typeof PrintDevice>
-type PrintDeviceUpdate = UpdateModelData<typeof PrintDevice>
-import { fetchById } from './fetch'
-
-/**
- * Update a print device by ID
- *
- * @param id The ID of the print device to update
- * @param data The updated print device data
- * @returns The updated print device record
- */
-export async function update(id: number, data: Omit<PrintDeviceUpdate, 'id'>): Promise<PrintDeviceJsonResponse | undefined> {
-  // Check if print device exists
-  const existingDevice = await fetchById(id)
-
-  if (!existingDevice) {
-    throw new Error(`Print device with ID ${id} not found`)
-  }
-
-  try {
-    // Update the print device
-    await db
-      .updateTable('print_devices')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .execute()
-
-    // Fetch and return the updated print device
-    return await fetchById(id)
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update print device: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update a print device's status
- *
- * @param id The ID of the print device
- * @param status The new status
- * @returns The updated print device with the new status
- */
-export async function updateStatus(
-  id: number,
-  status: 'online' | 'offline' | 'warning',
-): Promise<PrintDeviceJsonResponse | undefined> {
-  // Check if print device exists
-  const printDevice = await fetchById(id)
-
-  if (!printDevice) {
-    throw new Error(`Print device with ID ${id} not found`)
-  }
-
-  try {
-    // Update the print device status
-    await db
-      .updateTable('print_devices')
-      .set({
-        status,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .execute()
-
-    // Fetch the updated print device
-    return await fetchById(id)
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update print device status: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update print count for a print device
- *
- * @param id The ID of the print device
- * @param printCount The updated print count value
- * @returns The updated print device
- */
-export async function updatePrintCount(
-  id: number,
-  printCount?: number,
-): Promise<PrintDeviceJsonResponse | undefined> {
-  // Check if print device exists
-  const printDevice = await fetchById(id)
-
-  if (!printDevice) {
-    throw new Error(`Print device with ID ${id} not found`)
-  }
-
-  try {
-    // Update the print device
-    await db
-      .updateTable('print_devices')
-      .set({
-        print_count: printCount,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .execute()
-
-    // Fetch the updated print device
-    return await fetchById(id)
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update print count: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/errors/destroy.ts

@@ -1,54 +0,0 @@
-import { db } from '@stacksjs/database'
-import { log } from '@stacksjs/logging'
-
-/**
- * Delete a single error by ID
- */
-export async function destroy(id: number): Promise<boolean> {
-  try {
-    await db
-      .deleteFrom('errors')
-      .where('id', '=', id)
-      .execute()
-    return true
-  }
-  catch (error) {
-    log.error('[commerce/errors] destroy failed', { id, error })
-    return false
-  }
-}
-
-/**
- * Delete multiple errors by IDs
- */
-export async function bulkDestroy(ids: number[]): Promise<boolean> {
-  try {
-    await db
-      .deleteFrom('errors')
-      .where('id', 'in', ids)
-      .execute()
-    return true
-  }
-  catch (error) {
-    log.error('[commerce/errors] bulkDestroy failed', { count: ids.length, error })
-    return false
-  }
-}
-
-/**
- * Delete all errors in a group (by type and message)
- */
-export async function destroyGroup(type: string, message: string): Promise<boolean> {
-  try {
-    await db
-      .deleteFrom('errors')
-      .where('type', '=', type)
-      .where('message', '=', message)
-      .execute()
-    return true
-  }
-  catch (error) {
-    log.error('[commerce/errors] destroyGroup failed', { type, message, error })
-    return false
-  }
-}

package/src/errors/fetch.ts

@@ -1,197 +0,0 @@
-import { db } from '@stacksjs/database'
-
-export interface ErrorRecord {
-  id: number
-  type: string
-  message: string
-  stack: string | null
-  status: number | null
-  additional_info: string | null
-  created_at: string
-  updated_at: string | null
-}
-
-export interface GroupedError {
-  id: number
-  type: string
-  message: string
-  stack: string | null
-  status: string
-  count: number
-  first_seen: string
-  last_seen: string
-  error_ids: number[]
-}
-
-export interface ErrorStats {
-  total: number
-  unresolved: number
-  resolved: number
-  ignored: number
-  last_24h: number
-  trend: number
-}
-
-/**
- * Fetch a single error by ID
- */
-export async function fetchById(id: number): Promise<ErrorRecord | undefined> {
-  return await db
-    .selectFrom('errors')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst() as unknown as ErrorRecord | undefined
-}
-
-/**
- * Fetch all errors (raw, ungrouped)
- */
-export async function fetchAll(): Promise<ErrorRecord[]> {
-  return await db
-    .selectFrom('errors')
-    .selectAll()
-    .orderBy('created_at', 'desc')
-    .execute() as unknown as ErrorRecord[]
-}
-
-/**
- * Fetch errors grouped by type and message (Sentry-like behavior)
- * Same errors are aggregated instead of creating duplicate entries
- */
-export async function fetchGrouped(): Promise<GroupedError[]> {
-  const errors = await db
-    .selectFrom('errors')
-    .selectAll()
-    .orderBy('created_at', 'desc')
-    .execute() as unknown as ErrorRecord[]
-
-  // Group errors by type + message combination
-  const groupMap = new Map<string, {
-    errors: ErrorRecord[]
-    firstSeen: Date
-    lastSeen: Date
-  }>()
-
-  for (const error of errors) {
-    const key = `${error.type}:${error.message}`
-
-    if (!groupMap.has(key)) {
-      groupMap.set(key, {
-        errors: [],
-        firstSeen: new Date(error.created_at),
-        lastSeen: new Date(error.created_at),
-      })
-    }
-
-    const group = groupMap.get(key)!
-    group.errors.push(error)
-
-    const errorDate = new Date(error.created_at)
-    if (errorDate < group.firstSeen)
-      group.firstSeen = errorDate
-    if (errorDate > group.lastSeen)
-      group.lastSeen = errorDate
-  }
-
-  // Convert to grouped error format
-  const groupedErrors: GroupedError[] = []
-
-  for (const [_, group] of groupMap) {
-    const representative = group.errors[0]
-    // Determine status - use latest non-null status or default to 'unresolved'
-    const latestStatus = group.errors.find(e => e.status !== null)?.status
-    let statusLabel = 'unresolved'
-    if (latestStatus === 1)
-      statusLabel = 'resolved'
-    else if (latestStatus === 2)
-      statusLabel = 'ignored'
-
-    groupedErrors.push({
-      id: representative.id,
-      type: representative.type,
-      message: representative.message,
-      stack: representative.stack,
-      status: statusLabel,
-      count: group.errors.length,
-      first_seen: group.firstSeen.toISOString(),
-      last_seen: group.lastSeen.toISOString(),
-      error_ids: group.errors.map(e => e.id),
-    })
-  }
-
-  // Sort by last_seen descending
-  groupedErrors.sort((a, b) => new Date(b.last_seen).getTime() - new Date(a.last_seen).getTime())
-
-  return groupedErrors
-}
-
-/**
- * Fetch errors for a specific group (by type and message)
- */
-export async function fetchByGroup(type: string, message: string): Promise<ErrorRecord[]> {
-  return await db
-    .selectFrom('errors')
-    .where('type', '=', type)
-    .where('message', '=', message)
-    .selectAll()
-    .orderBy('created_at', 'desc')
-    .execute() as unknown as ErrorRecord[]
-}
-
-/**
- * Fetch error statistics
- */
-export async function fetchStats(): Promise<ErrorStats> {
-  const errors = await fetchAll()
-  const now = new Date()
-  const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000)
-  const twoDaysAgo = new Date(now.getTime() - 48 * 60 * 60 * 1000)
-
-  const last24h = errors.filter(e => new Date(e.created_at) >= yesterday).length
-  const previous24h = errors.filter(e => {
-    const date = new Date(e.created_at)
-    return date >= twoDaysAgo && date < yesterday
-  }).length
-
-  // Calculate trend (percentage change)
-  const trend = previous24h === 0
-    ? (last24h > 0 ? 100 : 0)
-    : Math.round(((last24h - previous24h) / previous24h) * 100)
-
-  return {
-    total: errors.length,
-    unresolved: errors.filter(e => e.status === null || e.status === 0).length,
-    resolved: errors.filter(e => e.status === 1).length,
-    ignored: errors.filter(e => e.status === 2).length,
-    last_24h: last24h,
-    trend,
-  }
-}
-
-/**
- * Fetch error timeline (hourly counts for the last 24 hours)
- */
-export async function fetchTimeline(): Promise<{ hour: string, count: number }[]> {
-  const errors = await fetchAll()
-  const now = new Date()
-  const timeline: { hour: string, count: number }[] = []
-
-  // Create hourly buckets for last 24 hours
-  for (let i = 23; i >= 0; i--) {
-    const hourStart = new Date(now.getTime() - i * 60 * 60 * 1000)
-    hourStart.setMinutes(0, 0, 0)
-    const hourEnd = new Date(hourStart.getTime() + 60 * 60 * 1000)
-
-    const count = errors.filter(e => {
-      const date = new Date(e.created_at)
-      return date >= hourStart && date < hourEnd
-    }).length
-
-    timeline.push({
-      hour: hourStart.toISOString(),
-      count,
-    })
-  }
-
-  return timeline
-}

package/src/errors/index.ts

@@ -1,28 +0,0 @@
-export {
-  bulkDestroy,
-  destroy,
-  destroyGroup,
-} from './destroy'
-
-export {
-  fetchAll,
-  fetchByGroup,
-  fetchById,
-  fetchGrouped,
-  fetchStats,
-  fetchTimeline,
-} from './fetch'
-
-export type {
-  ErrorRecord,
-  ErrorStats,
-  GroupedError,
-} from './fetch'
-
-export {
-  bulkUpdateStatus,
-  ignoreGroup,
-  resolveGroup,
-  unresolveGroup,
-  update,
-} from './update'

package/src/errors/update.ts

@@ -1,116 +0,0 @@
-import { db } from '@stacksjs/database'
-import { sql } from '@stacksjs/database'
-import { log } from '@stacksjs/logging'
-
-export interface UpdateErrorData {
-  status?: number
-  additional_info?: string
-}
-
-/**
- * Update a single error by ID
- */
-export async function update(id: number, data: UpdateErrorData): Promise<boolean> {
-  try {
-    await db
-      .updateTable('errors')
-      .set({
-        ...data,
-        updated_at: sql.raw('CURRENT_TIMESTAMP'),
-      })
-      .where('id', '=', id)
-      .execute()
-    return true
-  }
-  catch (error) {
-    log.error('[commerce/errors] update failed', { id, error })
-    return false
-  }
-}
-
-/**
- * Update multiple errors by IDs (for bulk status updates on grouped errors)
- */
-export async function bulkUpdateStatus(ids: number[], status: number): Promise<boolean> {
-  try {
-    await db
-      .updateTable('errors')
-      .set({
-        status,
-        updated_at: sql.raw('CURRENT_TIMESTAMP'),
-      })
-      .where('id', 'in', ids)
-      .execute()
-    return true
-  }
-  catch (error) {
-    log.error('[commerce/errors] bulkUpdateStatus failed', { count: ids.length, status, error })
-    return false
-  }
-}
-
-/**
- * Resolve a grouped error (sets status = 1 for all errors in the group)
- */
-export async function resolveGroup(type: string, message: string): Promise<boolean> {
-  try {
-    await db
-      .updateTable('errors')
-      .set({
-        status: 1,
-        updated_at: sql.raw('CURRENT_TIMESTAMP'),
-      })
-      .where('type', '=', type)
-      .where('message', '=', message)
-      .execute()
-    return true
-  }
-  catch (error) {
-    log.error('[commerce/errors] resolveGroup failed', { type, message, error })
-    return false
-  }
-}
-
-/**
- * Ignore a grouped error (sets status = 2 for all errors in the group)
- */
-export async function ignoreGroup(type: string, message: string): Promise<boolean> {
-  try {
-    await db
-      .updateTable('errors')
-      .set({
-        status: 2,
-        updated_at: sql.raw('CURRENT_TIMESTAMP'),
-      })
-      .where('type', '=', type)
-      .where('message', '=', message)
-      .execute()
-    return true
-  }
-  catch (error) {
-    log.error('[commerce/errors] ignoreGroup failed', { type, message, error })
-    return false
-  }
-}
-
-/**
- * Unresolve a grouped error (sets status = 0 for all errors in the group)
- */
-export async function unresolveGroup(type: string, message: string): Promise<boolean> {
-  try {
-    await db
-      .updateTable('errors')
-      .set({
-        status: 0,
-        updated_at: sql.raw('CURRENT_TIMESTAMP'),
-      })
-      .where('type', '=', type)
-      .where('message', '=', message)
-      .execute()
-    return true
-  }
-  catch (error) {
-    log.error('[commerce/errors] unresolveGroup failed', { type, message, error })
-    return false
-  }
-}

package/src/gift-cards/destroy.ts

@@ -1,87 +0,0 @@
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-import { fetchById } from './fetch'
-
-/**
- * Delete a gift card by ID
- * @param id The ID of the gift card to delete
- * @returns A boolean indicating whether the deletion was successful
- */
-export async function destroy(id: number): Promise<boolean> {
-  // First check if the gift card exists
-  const giftCard = await fetchById(id)
-
-  if (!giftCard) {
-    throw new Error(`Gift card with ID ${id} not found`)
-  }
-
-  // Delete the gift card
-  const result = await db
-    .deleteFrom('gift_cards')
-    .where('id', '=', id)
-    .executeTakeFirst()
-
-  return !!result
-}
-
-/**
- * Bulk delete multiple gift cards
- * @param ids Array of gift card IDs to delete
- * @returns Number of gift cards successfully deleted
- */
-export async function bulkDestroy(ids: number[]): Promise<number> {
-  if (!ids.length) {
-    return 0
-  }
-
-  // Delete all gift cards in the array
-  const result = await db
-    .deleteFrom('gift_cards')
-    .where('id', 'in', ids)
-    .executeTakeFirst()
-
-  return Number(result?.numDeletedRows) || 0
-}
-
-/**
- * Delete expired gift cards
- * @returns Number of gift cards deleted
- */
-export async function destroyExpired(): Promise<number> {
-  const currentDate = new Date().toISOString().split('T')[0]
-
-  // Delete expired gift cards
-  const result = await db
-    .deleteFrom('gift_cards')
-    .where('expiry_date', '<', currentDate)
-    .executeTakeFirst()
-
-  return Number(result?.numDeletedRows) || 0
-}
-
-/**
- * Deactivate a gift card (set is_active to false)
- * @param id The ID of the gift card to deactivate
- * @returns A boolean indicating whether the deactivation was successful
- */
-export async function deactivate(id: number): Promise<boolean> {
-  // First check if the gift card exists
-  const giftCard = await fetchById(id)
-
-  if (!giftCard) {
-    throw new Error(`Gift card with ID ${id} not found`)
-  }
-
-  // Update the gift card status
-  const result = await db
-    .updateTable('gift_cards')
-    .set({
-      is_active: false,
-      status: 'DEACTIVATED',
-      updated_at: formatDate(new Date()),
-    })
-    .where('id', '=', id)
-    .executeTakeFirst()
-
-  return !!result
-}