@stacksjs/commerce 0.70.55 → 0.70.56

package/src/tax/destroy.ts

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

package/src/tax/fetch.ts

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

package/src/tax/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,
-  updateRate,
-  updateStatus,
-} from './update'

package/src/tax/store.ts

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

package/src/tax/update.ts

@@ -1,119 +0,0 @@
-import { db } from '@stacksjs/database'
-import { formatDate } from '@stacksjs/orm'
-type TaxRateJsonResponse = ModelRow<typeof TaxRate>
-type TaxRateUpdate = UpdateModelData<typeof TaxRate>
-
-/**
- * Update a tax rate
- *
- * @param id The id of the tax rate to update
- * @param data The tax rate data to update
- * @returns The updated tax rate record
- */
-export async function update(id: number, data: TaxRateUpdate): Promise<TaxRateJsonResponse> {
-  try {
-    if (!id)
-      throw new Error('Tax rate ID is required for update')
-
-    const d = data as Record<string, unknown>
-    const result = await db
-      .updateTable('tax_rates')
-      .set({
-        name: data.name,
-        rate: data.rate,
-        type: data.type,
-        country: data.country,
-        region: data.region,
-        status: data.status,
-        is_default: d.is_default,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update tax rate')
-
-    return result as TaxRateJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update tax rate: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update a tax rate's status
- *
- * @param id The ID of the tax rate
- * @param status The new status
- * @returns The updated tax rate with the new status
- */
-export async function updateStatus(
-  id: number,
-  status: 'active' | 'inactive',
-): Promise<TaxRateJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('tax_rates')
-      .set({
-        status,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update tax rate status')
-
-    return result as TaxRateJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update tax rate status: ${error.message}`)
-    }
-
-    throw error
-  }
-}
-
-/**
- * Update rate information for a tax rate
- *
- * @param id The ID of the tax rate
- * @param rate The updated rate value
- * @returns The updated tax rate
- */
-export async function updateRate(
-  id: number,
-  rate: number,
-): Promise<TaxRateJsonResponse> {
-  try {
-    const result = await db
-      .updateTable('tax_rates')
-      .set({
-        rate,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .returningAll()
-      .executeTakeFirst()
-
-    if (!result)
-      throw new Error('Failed to update rate information')
-
-    return result as TaxRateJsonResponse
-  }
-  catch (error) {
-    if (error instanceof Error) {
-      throw new TypeError(`Failed to update rate information: ${error.message}`)
-    }
-
-    throw error
-  }
-}

package/src/tests/coupons.test.ts

@@ -1,90 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { formatDate } from '@stacksjs/orm'
-import { refreshDatabase } from './setup'
-import { fetchActive, fetchAll } from '../coupons/fetch'
-import { store } from '../coupons/store'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Coupon Module', () => {
-  describe('fetchById and fetchByCode', () => {
-    it('should fetch all coupons', async () => {
-      // Create multiple coupons
-      const codes = []
-      for (let i = 0; i < 3; i++) {
-        const code = `COUPON-ALL-${i}-${Date.now()}`
-        codes.push(code)
-
-        const couponData = {
-          code,
-          discount_type: 'percentage',
-          discount_value: 10 + i,
-          product_id: 1,
-          start_date: formatDate(new Date('2023-01-01')),
-          end_date: formatDate(new Date('2023-12-31')),
-        }
-
-        await store(couponData)
-      }
-
-      // Fetch all coupons
-      const allCoupons = await fetchAll()
-
-      // Verify all coupons are fetched
-      expect(allCoupons.length).toBeGreaterThanOrEqual(3)
-
-      // Check if our created coupons are in the results
-      for (const code of codes) {
-        const found = allCoupons.some(coupon => coupon.code === code)
-        expect(found).toBe(true)
-      }
-    })
-
-    it('should fetch active coupons', async () => {
-      // Create an active coupon (current date within range)
-      const today = new Date()
-      const futureDate = new Date(today)
-      futureDate.setMonth(today.getMonth() + 1)
-
-      const activeCode = `COUPON-ACTIVE-${Date.now()}`
-      const activeData = {
-        code: activeCode,
-        discount_type: 'percentage',
-        discount_value: 20,
-        product_id: 1,
-        start_date: formatDate(today),
-        end_date: formatDate(futureDate),
-        is_active: true,
-      }
-
-      await store(activeData)
-
-      // Create an inactive coupon (same date range but is_active = false)
-      const inactiveCode = `COUPON-INACTIVE-${Date.now()}`
-      const inactiveData = {
-        code: inactiveCode,
-        discount_type: 'percentage',
-        discount_value: 20,
-        product_id: 1,
-        start_date: formatDate(today),
-        end_date: formatDate(futureDate),
-        is_active: false,
-      }
-
-      await store(inactiveData)
-
-      // Fetch active coupons
-      const activeCoupons = await fetchActive()
-
-      // Check that active coupon is included
-      const hasActiveCoupon = activeCoupons.some(coupon => coupon.code === activeCode)
-      expect(hasActiveCoupon).toBe(true)
-
-      // Check that inactive coupon is not included
-      const hasInactiveCoupon = activeCoupons.some(coupon => coupon.code === inactiveCode)
-      expect(hasInactiveCoupon).toBe(false)
-    })
-  })
-})

package/src/tests/customers.test.ts

@@ -1,39 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { destroy } from '../customers/destroy'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Customer Module', () => {
-  describe('remove', () => {
-    it('should throw an error when trying to delete a non-existent customer', async () => {
-      // Use a very large ID that is unlikely to exist
-      const nonExistentId = 99999999
-
-      // Attempt to delete and expect an error
-      try {
-        await destroy(nonExistentId)
-        // If we get here, the test should fail as we expect an error
-        expect(true).toBe(false) // This line should not be reached
-      }
-      catch (error) {
-        expect(error).toBeDefined()
-        expect(error instanceof Error).toBe(true)
-        expect((error as Error).message).toContain(`Customer with ID ${nonExistentId} not found`)
-      }
-    })
-  })
-
-  describe('bulkRemove', () => {
-    it('should return 0 when trying to delete an empty array of customers', async () => {
-      // Import the bulkRemove function
-      const { bulkDestroy } = await import('../customers/destroy')
-
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-})

package/src/tests/device.test.ts

@@ -1,111 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { bulkDestroy } from '../devices/destroy'
-import { exportPrintDevices } from '../devices/export'
-import { bulkStore, store } from '../devices/store'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Print Device Module', () => {
-  describe('store', () => {
-    it('should create multiple print devices with bulk store', async () => {
-      const devices = [
-        {
-          name: 'Printer 1',
-          mac_address: '00:11:22:33:44:55',
-          location: 'Office 101',
-          terminal: 'TERM001',
-          status: 'online',
-          last_ping: Date.now(),
-          print_count: 0,
-        },
-        {
-          name: 'Printer 2',
-          mac_address: 'AA:BB:CC:DD:EE:FF',
-          location: 'Office 102',
-          terminal: 'TERM002',
-          status: 'online',
-          last_ping: Date.now(),
-          print_count: 0,
-        },
-        {
-          name: 'Printer 3',
-          mac_address: '11:22:33:44:55:66',
-          location: 'Office 103',
-          terminal: 'TERM003',
-          status: 'online',
-          last_ping: Date.now(),
-          print_count: 0,
-        },
-      ]
-
-      const count = await bulkStore(devices)
-      expect(count).toBe(3)
-
-      // Verify devices can be fetched
-      const { fetchAll } = await import('../devices/fetch')
-      const allDevices = await fetchAll()
-      expect(allDevices.length).toBeGreaterThanOrEqual(3)
-    })
-
-    it('should return 0 when trying to bulk store an empty array', async () => {
-      const count = await bulkStore([])
-      expect(count).toBe(0)
-    })
-  })
-
-  describe('destroy', () => {
-    it('should return 0 when trying to delete an empty array of devices', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-
-  describe('export', () => {
-    it('should export print devices to CSV format', async () => {
-      // Create a test device
-      const deviceData = {
-        name: 'Main Printer',
-        mac_address: '00:11:22:33:44:55',
-        location: 'Office 101',
-        terminal: 'TERM001',
-        status: 'online',
-        last_ping: Date.now(),
-        print_count: 100,
-      }
-
-      await store(deviceData)
-
-      // Export devices
-      const spreadsheet = await exportPrintDevices('csv')
-      expect(spreadsheet).toBeDefined()
-    })
-
-    it('should export print devices to Excel format', async () => {
-      // Create a test device
-      const deviceData = {
-        name: 'Main Printer',
-        mac_address: '00:11:22:33:44:55',
-        location: 'Office 101',
-        terminal: 'TERM001',
-        status: 'online',
-        last_ping: Date.now(),
-        print_count: 100,
-      }
-
-      await store(deviceData)
-
-      // Export devices
-      const spreadsheet = await exportPrintDevices('excel')
-      expect(spreadsheet).toBeDefined()
-    })
-
-    it('should handle empty device list during export', async () => {
-      const spreadsheet = await exportPrintDevices('csv')
-      expect(spreadsheet).toBeDefined()
-    })
-  })
-})

package/src/tests/digitals.test.ts

@@ -1,31 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { bulkDestroy, bulkSoftDelete } from '../shippings/digital-deliveries/destroy'
-import { bulkStore } from '../shippings/digital-deliveries/store'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Digital Delivery Module', () => {
-  describe('store', () => {
-    it('should return 0 when trying to bulk store an empty array', async () => {
-      const count = await bulkStore([])
-      expect(count).toBe(0)
-    })
-  })
-
-  describe('destroy', () => {
-    it('should return 0 when trying to delete an empty array of deliveries', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-
-    it('should return 0 when trying to soft delete an empty array of deliveries', async () => {
-      // Try to soft delete with an empty array
-      const deletedCount = await bulkSoftDelete([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-})

package/src/tests/drivers.test.ts

@@ -1,25 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { bulkDestroy } from '../shippings/drivers/destroy'
-import { bulkStore } from '../shippings/drivers/store'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Driver Module', () => {
-  describe('store', () => {
-    it('should return 0 when trying to bulk store an empty array', async () => {
-      const count = await bulkStore([])
-      expect(count).toBe(0)
-    })
-  })
-
-  describe('destroy', () => {
-    it('should return 0 when trying to delete an empty array of drivers', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-})

package/src/tests/gift-cards.test.ts

@@ -1,36 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { bulkDestroy, destroy } from '../gift-cards/destroy'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('Gift Card Module', () => {
-  describe('remove', () => {
-    it('should throw an error when trying to delete a non-existent gift card', async () => {
-      // Use a very large ID that is unlikely to exist
-      const nonExistentId = 99999999
-
-      // Attempt to delete and expect an error
-      try {
-        await destroy(nonExistentId)
-        // If we get here, the test should fail as we expect an error
-        expect(true).toBe(false) // This line should not be reached
-      }
-      catch (error) {
-        expect(error).toBeDefined()
-        expect(error instanceof Error).toBe(true)
-        expect((error as Error).message).toContain(`Gift card with ID ${nonExistentId} not found`)
-      }
-    })
-  })
-
-  describe('bulkRemove', () => {
-    it('should return 0 when trying to delete an empty array of gift cards', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-})

package/src/tests/license.test.ts

@@ -1,31 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import { refreshDatabase } from './setup'
-import { bulkDestroy, bulkSoftDelete } from '../shippings/license-keys/destroy'
-import { bulkStore } from '../shippings/license-keys/store'
-
-beforeEach(async () => {
-  await refreshDatabase()
-})
-
-describe('License Key Module', () => {
-  describe('store', () => {
-    it('should return 0 when trying to bulk store an empty array', async () => {
-      const count = await bulkStore([])
-      expect(count).toBe(0)
-    })
-  })
-
-  describe('destroy', () => {
-    it('should return 0 when trying to delete an empty array of licenses', async () => {
-      // Try to delete with an empty array
-      const deletedCount = await bulkDestroy([])
-      expect(deletedCount).toBe(0)
-    })
-
-    it('should return 0 when trying to soft delete an empty array of licenses', async () => {
-      // Try to soft delete with an empty array
-      const deletedCount = await bulkSoftDelete([])
-      expect(deletedCount).toBe(0)
-    })
-  })
-})