@stacksjs/commerce 0.70.55 → 0.70.56

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

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

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

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

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

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

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

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