@stacksjs/commerce 0.70.53 → 0.70.55

package/src/shippings/shipping-rates/store.ts

@@ -0,0 +1,102 @@
+// Import dependencies
+type ShippingRateJsonResponse = ModelRow<typeof ShippingRate>
+type NewShippingRate = NewModelData<typeof ShippingRate>
+import { randomUUIDv7 } from 'bun'
+import { db } from '@stacksjs/database'
+import { fetchById as fetchShippingMethodById } from '../shipping-methods/fetch'
+import { fetchById as fetchShippingZoneById } from '../shipping-zones/fetch'
+import { fetchById } from './fetch'
+
+/**
+ * Create a new shipping rate
+ *
+ * @param data The shipping rate data to store
+ * @returns The newly created shipping rate record
+ */
+export async function store(data: NewShippingRate): Promise<ShippingRateJsonResponse> {
+  try {
+    // Validate that the shipping method and zone exist
+    const method = await fetchShippingMethodById(Number(data.shippingmethod_id))
+    const zone = await fetchShippingZoneById(Number(data.shippingzone_id))
+
+    const rateData = {
+      weightFrom: data.weightFrom,
+      weightTo: data.weightTo,
+      rate: data.rate,
+      shippingmethod_id: method?.id,
+      shippingzone_id: zone?.id,
+      uuid: randomUUIDv7(),
+    }
+
+    const result = await db
+      .insertInto('shipping_rates')
+      .values(rateData)
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create shipping rate')
+
+    const insertId = Number(result.insertId) || Number(result.numInsertedOrUpdatedRows)
+
+    const model = await fetchById(insertId)
+
+    return model as ShippingRateJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create shipping rate: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Create multiple shipping rates at once
+ *
+ * @param data Array of shipping rate data to store
+ * @returns Number of shipping rates created
+ */
+export async function bulkStore(data: NewShippingRate[]): Promise<number> {
+  if (!data.length)
+    return 0
+
+  try {
+    // Validate all methods and zones before bulk insert
+    for (const item of data) {
+      const method = await fetchShippingMethodById(Number(item.shippingmethod_id))
+      const zone = await fetchShippingZoneById(Number(item.shippingzone_id))
+
+      if (!method) {
+        console.warn(`Shipping method with ID "${item.shippingmethod_id}" not found for bulk insert`)
+      }
+
+      if (!zone) {
+        console.warn(`Shipping zone with ID "${item.shippingzone_id}" not found for bulk insert`)
+      }
+    }
+
+    const rateDataArray = data.map(item => ({
+      weightFrom: item.weightFrom,
+      weightTo: item.weightTo,
+      rate: item.rate,
+      shippingmethod_id: item.shippingmethod_id,
+      shippingzone_id: item.shippingzone_id,
+      uuid: randomUUIDv7(),
+    }))
+
+    const result = await db
+      .insertInto('shipping_rates')
+      .values(rateDataArray)
+      .executeTakeFirst()
+
+    return Number(result.numInsertedOrUpdatedRows)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create shipping rates in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/shippings/shipping-rates/update.ts

@@ -0,0 +1,139 @@
+import { db } from '@stacksjs/database'
+import { formatDate } from '@stacksjs/orm'
+type ShippingRateJsonResponse = ModelRow<typeof ShippingRate>
+type ShippingRateUpdate = UpdateModelData<typeof ShippingRate>
+
+/**
+ * Update a shipping rate
+ *
+ * @param id The shipping rate ID to update
+ * @param data The shipping rate data to update
+ * @returns The updated shipping rate record
+ */
+export async function update(id: number, data: ShippingRateUpdate): Promise<ShippingRateJsonResponse> {
+  try {
+    if (!id)
+      throw new Error('Shipping rate ID is required for update')
+
+    const result = await db
+      .updateTable('shipping_rates')
+      .set({
+        ...data,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update shipping rate')
+
+    return result as ShippingRateJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update shipping rate: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update multiple shipping rates at once
+ *
+ * @param updates Array of objects containing rate ID and update data
+ * @returns Number of shipping rates updated
+ */
+export async function bulkUpdate(updates: Array<{
+  id: number
+  data: ShippingRateUpdate
+}>): Promise<number> {
+  if (!updates.length)
+    return 0
+
+  try {
+    let updatedCount = 0
+
+    for (const { id, data } of updates) {
+      const result = await db
+        .updateTable('shipping_rates')
+        .set({
+          ...data,
+          updated_at: formatDate(new Date()),
+        })
+        .where('id', '=', id)
+        .executeTakeFirst()
+
+      if (Number(result.numUpdatedRows) > 0)
+        updatedCount++
+    }
+
+    return updatedCount
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update shipping rates in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update shipping rates by zone
+ *
+ * @param zone The zone to update rates for
+ * @param data The update data to apply
+ * @returns Number of shipping rates updated
+ */
+export async function updateByZone(zone: number, data: ShippingRateUpdate): Promise<number> {
+  try {
+    const result = await db
+      .updateTable('shipping_rates')
+      .set({
+        ...data,
+        updated_at: formatDate(new Date()),
+      })
+      .where('zone_id', '=', zone)
+      .executeTakeFirst()
+
+    return Number(result.numUpdatedRows)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update shipping rates by zone: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update shipping rates by method
+ *
+ * @param method The shipping method to update rates for
+ * @param data The update data to apply
+ * @returns Number of shipping rates updated
+ */
+export async function updateByMethod(method: string, data: ShippingRateUpdate): Promise<number> {
+  try {
+    const result = await db
+      .updateTable('shipping_rates')
+      .set({
+        ...data,
+        updated_at: formatDate(new Date()),
+      })
+      .where('method', '=', method)
+      .executeTakeFirst()
+
+    return Number(result.numUpdatedRows)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update shipping rates by method: ${error.message}`)
+    }
+
+    throw error
+  }
+}

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

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

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

@@ -0,0 +1,96 @@
+type ShippingZoneJsonResponse = ModelRow<typeof ShippingZone>
+import { db } from '@stacksjs/database'
+
+/**
+ * Fetch all shipping zones
+ */
+export async function fetchAll(): Promise<ShippingZoneJsonResponse[]> {
+  return await db.selectFrom('shipping_zones').selectAll().execute() as ShippingZoneJsonResponse[]
+}
+
+/**
+ * Fetch a shipping zone by ID
+ */
+export async function fetchById(id: number): Promise<ShippingZoneJsonResponse | undefined> {
+  return await db
+    .selectFrom('shipping_zones')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst() as ShippingZoneJsonResponse | undefined
+}
+
+/**
+ * Format shipping zone options for dropdown menus or selectors
+ *
+ * @returns Array of formatted shipping zone options with id, name, and status
+ */
+export function formatZoneOptions(): Promise<{ id: number, name: string, status: string | string[], countries: string | undefined }[]> {
+  try {
+    return db
+      .selectFrom('shipping_zones')
+      .select(['id', 'name', 'status', 'countries'])
+      .orderBy('name')
+      .execute() as any
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to format shipping zone options: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Get active shipping zones
+ *
+ * @returns List of active shipping zones
+ */
+export async function getActiveShippingZones(): Promise<ShippingZoneJsonResponse[]> {
+  try {
+    const activeZones = await db
+      .selectFrom('shipping_zones')
+      .selectAll()
+      .where('status', '=', 'active')
+      .orderBy('name')
+      .execute()
+
+    return activeZones as ShippingZoneJsonResponse[]
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to get active shipping zones: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Get shipping zones by country code
+ *
+ * @param countryCode ISO country code
+ * @returns List of shipping zones covering the specified country
+ */
+export async function getZonesByCountry(countryCode: string): Promise<ShippingZoneJsonResponse[]> {
+  try {
+    // This uses a LIKE query assuming countries are stored as JSON strings
+    // You may need to adjust based on your actual data structure
+    const zones = await db
+      .selectFrom('shipping_zones')
+      .selectAll()
+      .where('countries', 'like', `%${countryCode}%`)
+      .where('status', '=', 'active')
+      .orderBy('name')
+      .execute()
+
+    return zones as ShippingZoneJsonResponse[]
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to get shipping zones by country: ${error.message}`)
+    }
+
+    throw error
+  }
+}

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

@@ -0,0 +1,26 @@
+export {
+  bulkDestroy,
+  bulkSoftDelete,
+  destroy,
+  softDelete,
+} from './destroy'
+
+export {
+  fetchAll,
+  fetchById,
+  formatZoneOptions,
+  getActiveShippingZones,
+  getZonesByCountry,
+} from './fetch'
+
+export {
+  bulkStore,
+  store,
+} from './store'
+
+export {
+  update,
+  updateCountries,
+  updateRegionsAndPostalCodes,
+  updateStatus,
+} from './update'

package/src/shippings/shipping-zones/store.ts

@@ -0,0 +1,74 @@
+// Import dependencies
+type ShippingZoneJsonResponse = ModelRow<typeof ShippingZone>
+type NewShippingZone = NewModelData<typeof ShippingZone>
+import { randomUUIDv7 } from 'bun'
+import { db } from '@stacksjs/database'
+import { fetchById } from './fetch'
+
+/**
+ * Create a new shipping zone
+ *
+ * @param data The shipping zone data to store
+ * @returns The newly created shipping zone record
+ */
+export async function store(data: NewShippingZone): Promise<ShippingZoneJsonResponse> {
+  try {
+    const zoneData = {
+      ...data,
+      uuid: randomUUIDv7(),
+    }
+
+    const result = await db
+      .insertInto('shipping_zones')
+      .values(zoneData)
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to create shipping zone')
+
+    const insertId = Number(result.insertId) || Number(result.numInsertedOrUpdatedRows)
+
+    const model = await fetchById(insertId)
+
+    return model as ShippingZoneJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create shipping zone: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Create multiple shipping zones at once
+ *
+ * @param data Array of shipping zone data to store
+ * @returns Number of shipping zones created
+ */
+export async function bulkStore(data: NewShippingZone[]): Promise<number> {
+  if (!data.length)
+    return 0
+
+  try {
+    const zoneDataArray = data.map(item => ({
+      ...item,
+      uuid: randomUUIDv7(),
+    }))
+
+    const result = await db
+      .insertInto('shipping_zones')
+      .values(zoneDataArray)
+      .executeTakeFirst()
+
+    return Number(result.numInsertedOrUpdatedRows)
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to create shipping zones in bulk: ${error.message}`)
+    }
+
+    throw error
+  }
+}

package/src/shippings/shipping-zones/update.ts

@@ -0,0 +1,156 @@
+import { db } from '@stacksjs/database'
+import { formatDate } from '@stacksjs/orm'
+type ShippingZoneJsonResponse = ModelRow<typeof ShippingZone>
+type ShippingZoneUpdate = UpdateModelData<typeof ShippingZone>
+
+/**
+ * Update a shipping zone
+ *
+ * @param id The ID of the shipping zone
+ * @param data The shipping zone data to update
+ * @returns The updated shipping zone record
+ */
+export async function update(id: number, data: ShippingZoneUpdate): Promise<ShippingZoneJsonResponse> {
+  try {
+    if (!id)
+      throw new Error('Shipping zone ID is required for update')
+
+    const result = await db
+      .updateTable('shipping_zones')
+      .set({
+        ...data,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update shipping zone')
+
+    return result as ShippingZoneJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update shipping zone: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update a shipping zone's status
+ *
+ * @param id The ID of the shipping zone
+ * @param status The new status
+ * @returns The updated shipping zone with the new status
+ */
+export async function updateStatus(
+  id: number,
+  status: string | string[],
+): Promise<ShippingZoneJsonResponse> {
+  try {
+    const result = await db
+      .updateTable('shipping_zones')
+      .set({
+        status,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update shipping zone status')
+
+    return result as ShippingZoneJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update shipping zone status: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update countries for a shipping zone
+ *
+ * @param id The ID of the shipping zone
+ * @param countries The updated countries JSON string
+ * @returns The updated shipping zone
+ */
+export async function updateCountries(
+  id: number,
+  countries: string,
+): Promise<ShippingZoneJsonResponse> {
+  try {
+    const result = await db
+      .updateTable('shipping_zones')
+      .set({
+        countries,
+        updated_at: formatDate(new Date()),
+      })
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update shipping zone countries')
+
+    return result as ShippingZoneJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update shipping zone countries: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+/**
+ * Update regions and/or postal codes for a shipping zone
+ *
+ * @param id The ID of the shipping zone
+ * @param regions Optional updated regions JSON string
+ * @param postal_codes Optional updated postal codes JSON string
+ * @returns The updated shipping zone
+ */
+export async function updateRegionsAndPostalCodes(
+  id: number,
+  regions?: string,
+  postal_codes?: string,
+): Promise<ShippingZoneJsonResponse> {
+  try {
+    const updateData: Record<string, any> = {
+      updated_at: formatDate(new Date()),
+    }
+
+    if (regions !== undefined)
+      updateData.regions = regions
+    if (postal_codes !== undefined)
+      updateData.postal_codes = postal_codes
+
+    const result = await db
+      .updateTable('shipping_zones')
+      .set(updateData)
+      .where('id', '=', id)
+      .returningAll()
+      .executeTakeFirst()
+
+    if (!result)
+      throw new Error('Failed to update regions and postal codes')
+
+    return result as ShippingZoneJsonResponse
+  }
+  catch (error) {
+    if (error instanceof Error) {
+      throw new TypeError(`Failed to update regions and postal codes: ${error.message}`)
+    }
+
+    throw error
+  }
+}