@stacksjs/commerce 0.70.53 → 0.70.55

package/src/tax/destroy.ts

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

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

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

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

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

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

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

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

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

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

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

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