@stacksjs/commerce 0.70.53 → 0.70.55

package/src/shippings/drivers/update.ts

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+// 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'