@stacksjs/commerce 0.70.55 → 0.70.57

package/src/shippings/drivers/update.ts

@@ -1,117 +0,0 @@
-import { db } from '@stacksjs/database'
-// Import dependencies
-import { formatDate } from '@stacksjs/orm'
-type DriverJsonResponse = ModelRow<typeof Driver>
-type DriverUpdate = UpdateModelData<typeof Driver>
-
-/**
- * Update a driver
- *
- * @param id The id of the driver to update
- * @param data The driver data to update
- * @returns The updated driver record
- */
-export async function update(id: number, data: DriverUpdate): Promise<DriverJsonResponse> {
-  try {
-    if (!id)
-      throw new Error('Driver ID is required for update')
-
-    const result = await db
-      .updateTable('drivers')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update driver')
-
-    return result as DriverJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update driver: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update a driver's status
- *
- * @param id The ID of the driver
- * @param status The new status (active, on_delivery, on_break)
- * @returns The updated driver with the new status
- */
-export async function updateStatus(
-  id: number,
-  status: 'active' | 'on_delivery' | 'on_break',
-): Promise<DriverJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('drivers')
-      .set({
-        status,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update driver status')
-
-    return result as DriverJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update driver status: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update driver's contact information
- *
- * @param id The ID of the driver
- * @param phone The updated phone number
- * @returns The updated driver
- */
-export async function updateContact(
-  id: number,
-  phone?: string,
-): Promise<DriverJsonResponse> {
-  try {
-    const updateData: Record<string, any> = {
-      updated_at: formatDate(new Date()),
-    }
-
-    if (phone !== undefined)
-      updateData.phone = phone
-
-    const result = await db
-      .updateTable('drivers')
-      .set(updateData)
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update contact information')
-
-    return result as DriverJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update contact information: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/index.ts

@@ -1,39 +0,0 @@
-import * as routes from './delivery-routes'
-import * as digital from './digital-deliveries'
-import * as drivers from './drivers'
-import * as licenses from './license-keys'
-import * as methods from './shipping-methods'
-import * as rates from './shipping-rates'
-import * as zones from './shipping-zones'
-
-export {
-  digital,
-  drivers,
-  licenses,
-  methods,
-  rates,
-  routes,
-  zones,
-}
-
-interface ShippingsNamespace {
-  digital: typeof digital
-  drivers: typeof drivers
-  licenses: typeof licenses
-  methods: typeof methods
-  rates: typeof rates
-  routes: typeof routes
-  zones: typeof zones
-}
-
-const shippings: ShippingsNamespace = {
-  digital,
-  drivers,
-  licenses,
-  methods,
-  rates,
-  routes,
-  zones,
-}
-
-export default shippings

package/src/shippings/license-keys/destroy.ts

@@ -1,111 +0,0 @@
-import { db } from '@stacksjs/database'
-
-/**
- * Delete a license key by ID
- *
- * @param id The ID of the license key to delete
- * @returns True if the license key was deleted, false otherwise
- */
-export async function destroy(id: number): Promise<boolean> {
-  try {
-    const result = await db
-      .deleteFrom('license_keys')
-      .where('id', '=', id)
-      .executeTakeFirst()
-
-    return Number(result.numDeletedRows) > 0
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to delete license key: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Soft delete a license key by ID (updates status to 'inactive')
- *
- * @param id The ID of the license key to soft delete
- * @returns True if the license key 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('license_keys')
-      .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 license key: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Delete multiple license keys by ID
- *
- * @param ids Array of license key IDs to delete
- * @returns Number of license keys deleted
- */
-export async function bulkDestroy(ids: number[]): Promise<number> {
-  if (!ids.length)
-    return 0
-
-  try {
-    // Perform the delete operation
-    const result = await db
-      .deleteFrom('license_keys')
-      .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 license keys: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Soft delete multiple license keys by ID (updates status to 'inactive')
- *
- * @param ids Array of license key IDs to soft delete
- * @returns Number of license keys 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('license_keys')
-      .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 license keys: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/license-keys/fetch.ts

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

package/src/shippings/license-keys/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,
-  updateExpiration,
-  updateStatus,
-} from './update'

package/src/shippings/license-keys/store.ts

@@ -1,77 +0,0 @@
-// Import dependencies
-type LicenseKeyJsonResponse = ModelRow<typeof LicenseKey>
-type NewLicenseKey = NewModelData<typeof LicenseKey>
-import { randomUUIDv7 } from 'bun'
-import { db } from '@stacksjs/database'
-import { fetchById } from './fetch'
-
-/**
- * Create a new license key
- *
- * @param data The license key data to store
- * @returns The newly created license key record
- */
-export async function store(data: NewLicenseKey): Promise<LicenseKeyJsonResponse> {
-  try {
-    const licenseData = {
-      ...data,
-      uuid: randomUUIDv7(),
-    }
-
-    const result = await db
-      .insertInto('license_keys')
-      .values(licenseData)
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to create license key')
-
-    const insertedId = Number(result.insertId) || Number(result.numInsertedOrUpdatedRows)
-
-    const licenseKey = await fetchById(insertedId)
-
-    if (!licenseKey)
-      throw new Error('Failed to create license key')
-
-    return licenseKey
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create license key: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Create multiple license keys at once
- *
- * @param data Array of license key data to store
- * @returns Number of license keys created
- */
-export async function bulkStore(data: NewLicenseKey[]): Promise<number> {
-  if (!data.length)
-    return 0
-
-  try {
-    const licenseDataArray = data.map(item => ({
-      ...item,
-      uuid: randomUUIDv7(),
-    }))
-
-    const result = await db
-      .insertInto('license_keys')
-      .values(licenseDataArray)
-      .executeTakeFirst()
-
-    return Number(result.numInsertedOrUpdatedRows)
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to create license keys in bulk: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/license-keys/update.ts

@@ -1,117 +0,0 @@
-import { db } from '@stacksjs/database'
-// Import dependencies
-import { formatDate } from '@stacksjs/orm'
-type LicenseKeyJsonResponse = ModelRow<typeof LicenseKey>
-type LicenseKeyUpdate = UpdateModelData<typeof LicenseKey>
-
-/**
- * Update a license key
- *
- * @param id The ID of the license key
- * @param data The license key data to update
- * @returns The updated license key record
- */
-export async function update(id: number, data: LicenseKeyUpdate): Promise<LicenseKeyJsonResponse> {
-  try {
-    if (!id)
-      throw new Error('License key ID is required for update')
-
-    const result = await db
-      .updateTable('license_keys')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update license key')
-
-    return result as LicenseKeyJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update license key: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update a license key's status
- *
- * @param id The ID of the license key
- * @param status The new status
- * @returns The updated license key with the new status
- */
-export async function updateStatus(
-  id: number,
-  status: string | string[],
-): Promise<LicenseKeyJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('license_keys')
-      .set({
-        status,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update license key status')
-
-    return result as LicenseKeyJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update license key status: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update expiration information for a license key
- *
- * @param id The ID of the license key
- * @param expiryDate The updated expiry date
- * @returns The updated license key
- */
-export async function updateExpiration(
-  id: number,
-  expiryDate?: string | Date,
-): Promise<LicenseKeyJsonResponse> {
-  try {
-    const updateData: Record<string, any> = {
-      updated_at: formatDate(new Date()),
-    }
-
-    if (expiryDate !== undefined)
-      updateData.expiry_date = expiryDate
-
-    const result = await db
-      .updateTable('license_keys')
-      .set(updateData)
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update expiration information')
-
-    return result as LicenseKeyJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update expiration information: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/shipping-methods/destroy.ts

@@ -1,111 +0,0 @@
-import { db } from '@stacksjs/database'
-
-/**
- * Delete a shipping method by ID
- *
- * @param id The ID of the shipping method to delete
- * @returns True if the shipping method was deleted, false otherwise
- */
-export async function destroy(id: number): Promise<boolean> {
-  try {
-    const result = await db
-      .deleteFrom('shipping_methods')
-      .where('id', '=', id)
-      .executeTakeFirst()
-
-    return Number(result.numDeletedRows) > 0
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to delete shipping method: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Soft delete a shipping method by ID (updates status to 'inactive')
- *
- * @param id The ID of the shipping method to soft delete
- * @returns True if the shipping method 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('shipping_methods')
-      .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 shipping method: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Delete multiple shipping methods by ID
- *
- * @param ids Array of shipping method IDs to delete
- * @returns Number of shipping methods deleted
- */
-export async function bulkDestroy(ids: number[]): Promise<number> {
-  if (!ids.length)
-    return 0
-
-  try {
-    // Perform the delete operation
-    const result = await db
-      .deleteFrom('shipping_methods')
-      .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 shipping methods: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Soft delete multiple shipping methods by ID (updates status to 'inactive')
- *
- * @param ids Array of shipping method IDs to soft delete
- * @returns Number of shipping methods 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('shipping_methods')
-      .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 shipping methods: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/shippings/shipping-methods/fetch.ts

@@ -1,62 +0,0 @@
-type ShippingMethodJsonResponse = ModelRow<typeof ShippingMethod>
-import { db } from '@stacksjs/database'
-
-/**
- * Fetch a shipping method by ID
- */
-export async function fetchById(id: number): Promise<ShippingMethodJsonResponse | undefined> {
-  const model = await db
-    .selectFrom('shipping_methods')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst()
-
-  if (model) {
-    const shippingZones = await db.selectFrom('shipping_zones').where('shipping_method_id', '=', id).selectAll().execute()
-
-    return {
-      ...model,
-      shippingZones,
-    } as unknown as ShippingMethodJsonResponse
-  }
-
-  return undefined
-}
-
-/**
- * Fetch all shipping methods with their shipping zones
- */
-export async function fetchAll(): Promise<ShippingMethodJsonResponse[]> {
-  // Fetch all shipping methods
-  const models = await db.selectFrom('shipping_methods').selectAll().execute()
-
-  // Get the IDs of all shipping methods
-  const shippingMethodIds = models.map((model: any) => model.id)
-
-  let shippingQuery = db.selectFrom('shipping_zones') as any
-
-  if (shippingMethodIds.length > 0) {
-    shippingQuery = shippingQuery.where('shipping_method_id', 'in', shippingMethodIds)
-  }
-
-  // Fetch shipping zones for these specific shipping methods using WHERE IN
-  const allShippingZones = await shippingQuery.selectAll().execute()
-
-  // Group shipping zones by shipping method ID
-  const shippingZonesByMethodId = allShippingZones.reduce((acc: any, zone: any) => {
-    const methodId = zone.shipping_method_id
-    if (methodId !== null && methodId !== undefined) {
-      if (!acc[methodId]) {
-        acc[methodId] = []
-      }
-      acc[methodId].push(zone)
-    }
-    return acc
-  }, {} as Record<number, typeof allShippingZones>)
-
-  // Attach shipping zones to each shipping method
-  return models.map((model: any) => ({
-    ...model,
-    shipping_zones: shippingZonesByMethodId[model.id] || [],
-  }))
-}

package/src/shippings/shipping-methods/index.ts

@@ -1,28 +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,
-  formatShippingOptions,
-  getActiveShippingMethods,
-  store,
-} from './store'
-
-// Functions from update.ts
-export {
-  update,
-  updatePricing,
-  updateStatus,
-} from './update'