@stacksjs/commerce 0.70.55 → 0.70.57

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

@@ -1,120 +0,0 @@
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-type DeliveryRouteJsonResponse = ModelRow<typeof DeliveryRoute>
-type DeliveryRouteUpdate = UpdateModelData<typeof DeliveryRoute>
-
-/**
- * Update a delivery route
- *
- * @param id The ID of the delivery route
- * @param data The delivery route data to update
- * @returns The updated delivery route record
- */
-export async function update(id: number, data: DeliveryRouteUpdate): Promise<DeliveryRouteJsonResponse> {
-  try {
-    if (!id)
-      throw new Error('Delivery route ID is required for update')
-
-    const result = await db
-      .updateTable('delivery_routes')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update delivery route')
-
-    return result as DeliveryRouteJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update delivery route: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update a delivery route's stops count
- *
- * @param id The ID of the delivery route
- * @param stops The new number of stops
- * @returns The updated delivery route with the new stops count
- */
-export async function updateStops(
-  id: number,
-  stops: number,
-): Promise<DeliveryRouteJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('delivery_routes')
-      .set({
-        stops,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update delivery route stops')
-
-    return result as DeliveryRouteJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update delivery route stops: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update delivery metrics for a route
- *
- * @param id The ID of the delivery route
- * @param delivery_time The updated delivery time
- * @param total_distance The updated total distance
- * @returns The updated delivery route
- */
-export async function updateMetrics(
-  id: number,
-  delivery_time?: number,
-  total_distance?: number,
-): Promise<DeliveryRouteJsonResponse> {
-  try {
-    const updateData: Record<string, any> = {
-      updated_at: formatDate(new Date()),
-    }
-
-    if (delivery_time !== undefined)
-      updateData.delivery_time = delivery_time
-    if (total_distance !== undefined)
-      updateData.total_distance = total_distance
-
-    const result = await db
-      .updateTable('delivery_routes')
-      .set(updateData)
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update delivery metrics')
-
-    return result as DeliveryRouteJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update delivery metrics: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/digital-deliveries/destroy.ts

@@ -1,111 +0,0 @@
-import { db } from '@stacksjs/database'
-
-/**
- * Delete a digital delivery by ID
- *
- * @param id The ID of the digital delivery to delete
- * @returns True if the digital delivery was deleted, false otherwise
- */
-export async function destroy(id: number): Promise<boolean> {
-  try {
-    const result = await db
-      .deleteFrom('digital_deliveries')
-      .where('id', '=', id)
-      .executeTakeFirst()
-
-    return Number(result.numDeletedRows) > 0
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to delete digital delivery: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Soft delete a digital delivery by ID (updates status to 'inactive')
- *
- * @param id The ID of the digital delivery to soft delete
- * @returns True if the digital delivery was soft deleted, false otherwise
- */
-export async function softDelete(id: number): Promise<boolean> {
-  try {
-    // Update the status to 'inactive' instead of deleting
-    const result = await db
-      .updateTable('digital_deliveries')
-      .set({ status: 'inactive' })
-      .where('id', '=', id)
-      .executeTakeFirst()
-
-    // Return true if any row was affected (updated)
-    return Number(result.numUpdatedRows) > 0
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to soft delete digital delivery: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Delete multiple digital deliveries by ID
- *
- * @param ids Array of digital delivery IDs to delete
- * @returns Number of digital deliveries deleted
- */
-export async function bulkDestroy(ids: number[]): Promise<number> {
-  if (!ids.length)
-    return 0
-
-  try {
-    // Perform the delete operation
-    const result = await db
-      .deleteFrom('digital_deliveries')
-      .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 digital deliveries: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Soft delete multiple digital deliveries by ID (updates status to 'inactive')
- *
- * @param ids Array of digital delivery IDs to soft delete
- * @returns Number of digital deliveries soft deleted
- */
-export async function bulkSoftDelete(ids: number[]): Promise<number> {
-  if (!ids.length)
-    return 0
-
-  try {
-    // Update the status to 'inactive' instead of deleting
-    const result = await db
-      .updateTable('digital_deliveries')
-      .set({ status: 'inactive' })
-      .where('id', 'in', ids)
-      .executeTakeFirst()
-
-    // Return the number of updated rows
-    return Number(result.numUpdatedRows)
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to soft delete digital deliveries: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/digital-deliveries/fetch.ts

@@ -1,20 +0,0 @@
-type DigitalDeliveryJsonResponse = ModelRow<typeof DigitalDelivery>
-import { db } from '@stacksjs/database'
-
-/**
- * Fetch a shipping method by ID
- */
-export async function fetchById(id: number): Promise<DigitalDeliveryJsonResponse | undefined> {
-  return await db
-    .selectFrom('digital_deliveries')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst() as DigitalDeliveryJsonResponse | undefined
-}
-
-/**
- * Fetch all digital deliveries
- */
-export async function fetchAll(): Promise<DigitalDeliveryJsonResponse[]> {
-  return await db.selectFrom('digital_deliveries').selectAll().execute() as DigitalDeliveryJsonResponse[]
-}

package/src/shippings/digital-deliveries/index.ts

@@ -1,26 +0,0 @@
-// Functions from destroy.ts
-export {
-  bulkDestroy,
-  bulkSoftDelete,
-  destroy,
-  softDelete,
-} 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,
-  updateDeliverySettings,
-  updateStatus,
-} from './update'

package/src/shippings/digital-deliveries/store.ts

@@ -1,76 +0,0 @@
-type DigitalDeliveryJsonResponse = ModelRow<typeof DigitalDelivery>
-type NewDigitalDelivery = NewModelData<typeof DigitalDelivery>
-import { randomUUIDv7 } from 'bun'
-import { db } from '@stacksjs/database'
-import { fetchById } from './fetch'
-
-/**
- * Create a new digital delivery
- *
- * @param data The digital delivery data to store
- * @returns The newly created digital delivery record
- */
-export async function store(data: NewDigitalDelivery): Promise<DigitalDeliveryJsonResponse> {
-  try {
-    const deliveryData = {
-      ...data,
-      uuid: randomUUIDv7(),
-    }
-
-    const result = await db
-      .insertInto('digital_deliveries')
-      .values(deliveryData)
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to create digital delivery')
-
-    const insertedId = Number(result.insertId) || Number(result.numInsertedOrUpdatedRows)
-
-    const digitalDelivery = await fetchById(insertedId)
-
-    if (!digitalDelivery)
-      throw new Error('Failed to create digital delivery')
-
-    return digitalDelivery
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create digital delivery: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Create multiple digital deliveries at once
- *
- * @param data Array of digital delivery data to store
- * @returns Number of digital deliveries created
- */
-export async function bulkStore(data: NewDigitalDelivery[]): Promise<number> {
-  if (!data.length)
-    return 0
-
-  try {
-    const deliveryDataArray = data.map(item => ({
-      ...item,
-      uuid: randomUUIDv7(),
-    }))
-
-    const result = await db
-      .insertInto('digital_deliveries')
-      .values(deliveryDataArray)
-      .executeTakeFirst()
-
-    return Number(result.numInsertedOrUpdatedRows)
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create digital deliveries in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/digital-deliveries/update.ts

@@ -1,129 +0,0 @@
-import { db } from '@stacksjs/database'
-// Import dependencies
-import { formatDate } from '@stacksjs/orm'
-type DigitalDeliveryJsonResponse = ModelRow<typeof DigitalDelivery>
-type DigitalDeliveryUpdate = UpdateModelData<typeof DigitalDelivery>
-
-/**
- * Update a digital delivery
- *
- * @param id The id of the digital delivery to update
- * @param data The digital delivery data to update
- * @returns The updated digital delivery record
- */
-export async function update(id: number, data: DigitalDeliveryUpdate): Promise<DigitalDeliveryJsonResponse> {
-  try {
-    if (!id)
-      throw new Error('Digital delivery ID is required for update')
-
-    const result = await db
-      .updateTable('digital_deliveries')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update digital delivery')
-
-    return result as DigitalDeliveryJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update digital delivery: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update a digital delivery's status
- *
- * @param id The ID of the digital delivery
- * @param status The new status
- * @returns The updated digital delivery with the new status
- */
-export async function updateStatus(
-  id: number,
-  status: string | string[],
-): Promise<DigitalDeliveryJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('digital_deliveries')
-      .set({
-        status,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update digital delivery status')
-
-    return result as DigitalDeliveryJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update digital delivery status: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update delivery settings for a digital delivery
- *
- * @param id The ID of the digital delivery
- * @param download_limit Optional updated download limit
- * @param expiry_days Optional updated expiry days
- * @param requires_login Optional updated requires login flag
- * @param automatic_delivery Optional updated automatic delivery flag
- * @returns The updated digital delivery
- */
-export async function updateDeliverySettings(
-  id: number,
-  download_limit?: number,
-  expiry_days?: number,
-  requires_login?: boolean,
-  automatic_delivery?: boolean,
-): Promise<DigitalDeliveryJsonResponse> {
-  try {
-    const updateData: Record<string, any> = {
-      updated_at: formatDate(new Date()),
-    }
-
-    if (download_limit !== undefined)
-      updateData.download_limit = download_limit
-    if (expiry_days !== undefined)
-      updateData.expiry_days = expiry_days
-    if (requires_login !== undefined)
-      updateData.requires_login = requires_login
-    if (automatic_delivery !== undefined)
-      updateData.automatic_delivery = automatic_delivery
-
-    const result = await db
-      .updateTable('digital_deliveries')
-      .set(updateData)
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update delivery settings')
-
-    return result as DigitalDeliveryJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update delivery settings: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/drivers/destroy.ts

@@ -1,78 +0,0 @@
-// Import dependencies
-type DriverJsonResponse = ModelRow<typeof Driver>
-import { db } from '@stacksjs/database'
-import { fetchById } from './fetch'
-
-/**
- * Delete a driver by ID
- *
- * @param id The ID of the driver to delete
- * @returns The deleted driver record
- */
-export async function destroy(id: number): Promise<DriverJsonResponse | undefined> {
-  // Check if driver exists
-  const driver = await fetchById(id)
-
-  if (!driver) {
-    throw new Error(`Driver with ID ${id} not found`)
-  }
-
-  try {
-    // Delete the driver
-    await db
-      .deleteFrom('drivers')
-      .where('id', '=', id)
-      .execute()
-
-    return driver
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to delete driver: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Delete multiple drivers at once
- *
- * @param ids Array of driver IDs to delete
- * @returns Number of drivers deleted
- */
-export async function bulkDestroy(ids: number[]): Promise<number> {
-  if (!ids.length)
-    return 0
-
-  let deletedCount = 0
-
-  try {
-    // Process each driver deletion in a transaction
-    await (db as any).transaction().execute(async (trx: any) => {
-      for (const id of ids) {
-        // Check if driver exists
-        const driver = await fetchById(id)
-
-        if (driver) {
-          // Delete the driver
-          await trx
-            .deleteFrom('drivers')
-            .where('id', '=', id)
-            .execute()
-
-          deletedCount++
-        }
-      }
-    })
-
-    return deletedCount
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to delete drivers in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/drivers/fetch.ts

@@ -1,20 +0,0 @@
-type DriverJsonResponse = ModelRow<typeof Driver>
-import { db } from '@stacksjs/database'
-
-/**
- * Fetch a driver by ID
- */
-export async function fetchById(id: number): Promise<DriverJsonResponse | undefined> {
-  return await db
-    .selectFrom('drivers')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst() as DriverJsonResponse | undefined
-}
-
-/**
- * Fetch all drivers
- */
-export async function fetchAll(): Promise<DriverJsonResponse[]> {
-  return await db.selectFrom('drivers').selectAll().execute() as DriverJsonResponse[]
-}

package/src/shippings/drivers/index.ts

@@ -1,24 +0,0 @@
-// 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,
-  updateContact,
-  updateStatus,
-} from './update'

package/src/shippings/drivers/store.ts

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