@stacksjs/commerce 0.70.53 → 0.70.55

package/src/tests/routes.test.ts

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { refreshDatabase } from './setup'
+import { bulkDestroy } from '../shippings/delivery-routes/destroy'
+import { fetchByDriver } from '../shippings/delivery-routes/fetch'
+import { store } from '../shippings/delivery-routes/store'
+
+beforeEach(async () => {
+  await refreshDatabase()
+})
+
+describe('Delivery Route Module', () => {
+  describe('fetch', () => {
+    it('should fetch routes by driver', async () => {
+      // Create routes for the same driver
+      const driverName = 'John Doe'
+      const routes = [
+        {
+          driver: driverName,
+          vehicle: 'Truck A123',
+          stops: 5,
+          delivery_time: 120,
+          total_distance: 50,
+        },
+        {
+          driver: driverName,
+          vehicle: 'Van B456',
+          stops: 3,
+          delivery_time: 60,
+          total_distance: 25,
+        },
+      ]
+
+      // Store each route individually
+      for (const routeData of routes) {
+        await store(routeData)
+      }
+
+      const driverRoutes = await fetchByDriver(driverName)
+      expect(driverRoutes.length).toBeGreaterThanOrEqual(2)
+      expect(driverRoutes.every(route => route.driver === driverName)).toBe(true)
+    })
+  })
+
+  describe('destroy', () => {
+    it('should return 0 when trying to delete an empty array of routes', async () => {
+      // Try to delete with an empty array
+      const deletedCount = await bulkDestroy([])
+      expect(deletedCount).toBe(0)
+    })
+  })
+})

package/src/tests/setup.ts

@@ -0,0 +1,149 @@
+/**
+ * Commerce package test harness.
+ *
+ * These suites used to import `refreshDatabase` from
+ * `@stacksjs/testing/database`, which (pre-existing breakage) never
+ * worked from a package directory: `bun test` run from
+ * storage/framework/core/commerce doesn't load the repo-root `.env`,
+ * so the driver fell back to mysql and the helper's dead kysely-era
+ * `sql\`...\`.execute(db)` calls threw in every `beforeEach`. Even
+ * forced to sqlite, the migration pipeline resolves `database/` and
+ * `database/migrations` off `process.cwd()` and the committed
+ * migration corpus is both unrunnable on a virgin DB and drifted from
+ * the models (missing `uuid` columns for the 28 `useUuid` commerce
+ * models).
+ *
+ * Strategy (mirrors auth/tests/password-reset-revocation.test.ts): pin
+ * env to a throwaway SQLite file BEFORE any framework module loads,
+ * then generate the schema directly from the live model definitions
+ * via bun-query-builder's loadModels → buildMigrationPlan →
+ * generateSql. Foreign-key references are stripped from the plan
+ * because the fixtures intentionally insert dangling parent ids
+ * (e.g. customer_id 1..3 with no customers row).
+ *
+ * Wired up via this package's bunfig.toml `[test] preload`, so the
+ * env pin always lands before any test file's own imports evaluate.
+ */
+
+import { existsSync, mkdtempSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import process from 'node:process'
+
+const DB_PATH = join(tmpdir(), `stacks-commerce-${process.pid}.sqlite`)
+process.env.DB_CONNECTION = 'sqlite'
+process.env.DB_DATABASE_PATH = DB_PATH
+process.env.APP_ENV = 'testing'
+
+// Dynamic imports AFTER the env pin so the lazy `db` proxy and the
+// config loader can't capture a different connection first.
+const { acquireDbConfigLock, db, ensureDatabaseConfigLoaded, initializeDbConfig } = await import('@stacksjs/database')
+const { buildMigrationPlan, generateSql, loadModels } = await import('bun-query-builder')
+
+// Holds `initializeDbConfig`'s process-wide config mutex (stacksjs/stacks#1862)
+// for this module's entire lifetime — no `describe`/`afterAll` boundary exists
+// here (this is a shared fixture imported by many test files, not a test file
+// itself), so it's released on process exit alongside the file cleanup below.
+const releaseDbConfigLock = await acquireDbConfigLock()
+
+// storage/framework/defaults — the framework's vendor layer where the
+// default model definitions live. `loadModels` does not recurse, so the
+// commerce subdirectory is loaded explicitly and merged.
+const defaultsModelsDir = join(import.meta.dir, '../../../../defaults/app/Models')
+const commerceModelsDir = join(defaultsModelsDir, 'commerce')
+
+/**
+ * Drain the one-shot async config reload, then force our temp SQLite
+ * config so a late-resolving override can't re-point the shared `db`
+ * proxy at a different database mid-test.
+ */
+async function forceConfig(): Promise<void> {
+  await ensureDatabaseConfigLoaded()
+  initializeDbConfig({
+    app: { env: 'testing' },
+    database: {
+      default: 'sqlite',
+      connections: { sqlite: { database: DB_PATH, prefix: '' } },
+    },
+  })
+}
+
+// Stale file from a recycled pid would otherwise leak a previous run's
+// schema/rows into this one.
+for (const suffix of ['', '-wal', '-shm']) {
+  if (existsSync(`${DB_PATH}${suffix}`))
+    unlinkSync(`${DB_PATH}${suffix}`)
+}
+
+await forceConfig()
+
+const models = {
+  ...(await loadModels({ modelsDir: defaultsModelsDir })),
+  ...(await loadModels({ modelsDir: commerceModelsDir })),
+}
+
+const plan = buildMigrationPlan(models, { dialect: 'sqlite' })
+
+// The fixtures insert dangling parent ids by design (e.g. orders with
+// customer_id 1 and no customers row), so FK constraints would reject
+// most of the corpus. Strip references — the suites exercise the
+// commerce modules' query logic, not referential integrity.
+for (const table of plan.tables) {
+  for (const column of table.columns)
+    delete column.references
+}
+
+// `generateSql()` also writes one `.sql` migration file per statement
+// into `<nearest package.json dir>/database/migrations` (resolved off
+// `process.cwd()`) as a side effect — from this package's cwd that
+// would litter storage/framework/core/commerce/database/. Point the
+// side effect at a disposable temp workspace for the duration of the
+// call. The stub package.json makes its workspace-root walk stop there.
+const scratchDir = mkdtempSync(join(tmpdir(), 'stacks-commerce-migrations-'))
+writeFileSync(join(scratchDir, 'package.json'), '{}')
+const originalCwd = process.cwd()
+let statements: string[]
+try {
+  process.chdir(scratchDir)
+  statements = generateSql(plan)
+}
+finally {
+  process.chdir(originalCwd)
+  rmSync(scratchDir, { recursive: true, force: true })
+}
+
+for (const statement of statements) {
+  await db.unsafe(statement).execute()
+}
+
+const tableNames = plan.tables.map(table => table.table)
+
+/**
+ * Wipe every model-derived table between tests. DELETE (not DROP) keeps
+ * the schema warm; with FK references stripped, order doesn't matter.
+ */
+export async function refreshDatabase(): Promise<void> {
+  await forceConfig()
+  for (const table of tableNames) {
+    await db.unsafe(`DELETE FROM ${table}`).execute()
+  }
+}
+
+// Cleanup on process exit, NOT in an `afterAll`: when this module is
+// imported by a test file mid-run (e.g. `bun test tests/` from the
+// repo root, where the path filter also matches these suites), an
+// `afterAll` registered during module evaluation attaches to the FIRST
+// importing file's scope and unlinks the shared DB while later files'
+// connections still use it (SQLITE_IOERR_VNODE).
+process.on('exit', () => {
+  for (const suffix of ['', '-wal', '-shm']) {
+    try {
+      if (existsSync(`${DB_PATH}${suffix}`))
+        unlinkSync(`${DB_PATH}${suffix}`)
+    }
+    catch {
+      // Best effort — pid-named file in tmpdir, the OS reclaims it.
+    }
+  }
+  releaseDbConfigLock()
+})

package/src/tests/shipping.test.ts

@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { refreshDatabase } from './setup'
+import { bulkDestroy, bulkSoftDelete } from '../shippings/shipping-methods/destroy'
+import { formatShippingOptions, getActiveShippingMethods, store } from '../shippings/shipping-methods/store'
+
+beforeEach(async () => {
+  await refreshDatabase()
+})
+
+describe('Shipping Methods Module', () => {
+  describe('store', () => {
+    it('should format shipping options correctly', async () => {
+      // Create test shipping methods
+      const request1 = {
+        name: 'Standard Shipping',
+        base_rate: 500,
+        status: 'active',
+      }
+
+      await store(request1)
+
+      const request2 = {
+        name: 'Express Shipping',
+        base_rate: 1500,
+        zones: JSON.stringify(['North America', 'Europe']),
+        status: 'active',
+      }
+
+      await store(request2)
+
+      // Get formatted options
+      const options = await formatShippingOptions()
+
+      expect(options.length).toBe(2)
+      expect(options[0].name).toBeDefined()
+      expect(options[0].base_rate).toBeDefined()
+      expect(options[0].status).toBeDefined()
+    })
+  })
+
+  describe('destroy', () => {
+    it('should return 0 when trying to delete an empty array of shipping methods', async () => {
+      // Try to delete with an empty array
+      const deletedCount = await bulkDestroy([])
+      expect(deletedCount).toBe(0)
+
+      // Try to soft delete with an empty array
+      const softDeletedCount = await bulkSoftDelete([])
+      expect(softDeletedCount).toBe(0)
+    })
+  })
+
+  describe('fetch', () => {
+    it('should get active shipping methods only', async () => {
+      // Create an active shipping method
+      const activeRequest = {
+        name: 'Active Shipping',
+        base_rate: 1000,
+        status: 'active',
+      }
+      await store(activeRequest)
+
+      // Create an inactive shipping method
+      const inactiveRequest = {
+        name: 'Inactive Shipping',
+        base_rate: 1500,
+        status: 'inactive',
+      }
+      await store(inactiveRequest)
+
+      // Create a draft shipping method
+      const draftRequest = {
+        name: 'Draft Shipping',
+        base_rate: 2000,
+        status: 'draft',
+      }
+      await store(draftRequest)
+
+      // Get active shipping methods
+      const activeMethods = await getActiveShippingMethods()
+
+      // Should only return active methods
+      expect(activeMethods.length).toBe(1)
+      expect(activeMethods[0].name).toBe('Active Shipping')
+      expect(activeMethods[0].status).toBe('active')
+    })
+  })
+})

package/src/tests/tax.test.ts

@@ -0,0 +1,25 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { refreshDatabase } from './setup'
+import { bulkDestroy } from '../tax/destroy'
+import { bulkStore } from '../tax/store'
+
+beforeEach(async () => {
+  await refreshDatabase()
+})
+
+describe('Tax Rate 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 tax rates', async () => {
+      // Try to delete with an empty array
+      const deletedCount = await bulkDestroy([])
+      expect(deletedCount).toBe(0)
+    })
+  })
+})

package/src/tests/units.test.ts

@@ -0,0 +1,110 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { refreshDatabase } from './setup'
+import { bulkDestroy } from '../products/units/destroy'
+import { bulkStore, formatUnitOptions } from '../products/units/store'
+import { bulkUpdate } from '../products/units/update'
+
+beforeEach(async () => {
+  await refreshDatabase()
+})
+
+describe('Product Unit Module', () => {
+  describe('bulkStore', () => {
+    it('should create multiple product units at once', async () => {
+      const unitRequests = [
+        {
+          name: 'Kilogram',
+          product_id: 1,
+          abbreviation: 'kg',
+          type: 'weight',
+          description: 'Standard weight unit',
+          is_default: true,
+        },
+        {
+          name: 'Liter',
+          product_id: 1,
+          abbreviation: 'L',
+          type: 'volume',
+          description: 'Standard volume unit',
+          is_default: true,
+        },
+        {
+          name: 'Piece',
+          product_id: 1,
+          abbreviation: 'pc',
+          type: 'quantity',
+          description: 'Standard quantity unit',
+          is_default: true,
+        },
+      ]
+
+      const createdCount = await bulkStore(unitRequests)
+      expect(createdCount).toBe(3)
+    })
+
+    it('should return 0 when trying to create an empty array of units', async () => {
+      const createdCount = await bulkStore([])
+      expect(createdCount).toBe(0)
+    })
+
+  })
+
+  describe('formatUnitOptions and getDefaultUnit', () => {
+    it('should format unit options correctly', async () => {
+      // Create units first
+      const unitRequests = [
+        {
+          name: 'Kilogram',
+          product_id: 1,
+          abbreviation: 'kg',
+          type: 'weight',
+          is_default: true,
+        },
+        {
+          name: 'Gram',
+          product_id: 1,
+          abbreviation: 'g',
+          type: 'weight',
+          is_default: false,
+        },
+        {
+          name: 'Liter',
+          product_id: 1,
+          abbreviation: 'L',
+          type: 'volume',
+          is_default: true,
+        },
+      ]
+
+      await bulkStore(unitRequests)
+
+      // Test formatting options for weight units
+      const weightUnits = await formatUnitOptions('weight')
+      expect(weightUnits.length).toBe(2)
+      expect(weightUnits[0].name).toBe('Gram') // Alphabetical order
+      expect(weightUnits[1].name).toBe('Kilogram')
+      expect(weightUnits[0].abbreviation).toBe('g')
+      expect(weightUnits[1].abbreviation).toBe('kg')
+      expect(Boolean(weightUnits[0].is_default)).toBe(false)
+      expect(Boolean(weightUnits[1].is_default)).toBe(true)
+
+      // Test formatting options for all units (no type filter)
+      const allUnits = await formatUnitOptions()
+      expect(allUnits.length).toBe(3)
+    })
+  })
+
+  describe('bulkUpdate', () => {
+    it('should return 0 when trying to update an empty array of units', async () => {
+      const updatedCount = await bulkUpdate([])
+      expect(updatedCount).toBe(0)
+    })
+  })
+
+  describe('bulkDestroy', () => {
+    it('should return 0 when trying to delete an empty array of units', async () => {
+      const deletedCount = await bulkDestroy([])
+      expect(deletedCount).toBe(0)
+    })
+  })
+})

package/src/tests/variants.test.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { refreshDatabase } from './setup'
+import { bulkDestroy } from '../products/variants/destroy'
+import { bulkStore, formatVariantOptions, generateVariantCombinations } from '../products/variants/store'
+import { bulkUpdate } from '../products/variants/update'
+
+beforeEach(async () => {
+  await refreshDatabase()
+})
+
+describe('Product Variant Module', () => {
+  describe('bulkStore', () => {
+    it('should create multiple product variants at once', async () => {
+      const requestsData = [
+        {
+          product_id: 1,
+          variant: 'Color',
+          type: 'dropdown',
+          description: 'Available colors',
+          options: JSON.stringify(['Red', 'Blue', 'Green']),
+          status: 'draft',
+        },
+        {
+          product_id: 1,
+          variant: 'Size',
+          type: 'radio',
+          description: 'Available sizes',
+          options: JSON.stringify(['S', 'M', 'L', 'XL']),
+          status: 'draft',
+        },
+      ]
+
+      const createdCount = await bulkStore(requestsData)
+
+      expect(createdCount).toBe(2)
+    })
+
+    it('should return 0 when trying to create an empty array of variants', async () => {
+      const createdCount = await bulkStore([])
+      expect(createdCount).toBe(0)
+    })
+  })
+
+  describe('bulkUpdate', () => {
+    it('should return 0 when trying to update an empty array of variants', async () => {
+      const updateCount = await bulkUpdate([])
+      expect(updateCount).toBe(0)
+    })
+  })
+
+  describe('bulkDestroy', () => {
+    it('should return 0 when trying to delete an empty array of variants', async () => {
+      const deletedCount = await bulkDestroy([])
+      expect(deletedCount).toBe(0)
+    })
+  })
+
+  describe('formatVariantOptions', () => {
+    it('should format an array of options as a JSON string', () => {
+      const rawOptions = ['Red', 'Blue', 'Green']
+      const formattedOptions = formatVariantOptions(rawOptions)
+      expect(formattedOptions).toBe(JSON.stringify(rawOptions))
+    })
+
+    it('should trim whitespace from options', () => {
+      const rawOptions = [' Red ', 'Blue  ', '  Green']
+      const formattedOptions = formatVariantOptions(rawOptions)
+      expect(formattedOptions).toBe(JSON.stringify(['Red', 'Blue', 'Green']))
+    })
+
+    it('should filter out empty options', () => {
+      const rawOptions = ['Red', '', 'Blue', '   ', 'Green']
+      const formattedOptions = formatVariantOptions(rawOptions)
+      expect(formattedOptions).toBe(JSON.stringify(['Red', 'Blue', 'Green']))
+    })
+
+    it('should return an empty array JSON string when given empty input', () => {
+      expect(formatVariantOptions([])).toBe('[]')
+      expect(formatVariantOptions([] as string[])).toBe('[]')
+    })
+  })
+
+  describe('generateVariantCombinations', () => {
+    it('should generate all possible combinations of variant options', () => {
+      const optionSets = {
+        size: ['S', 'M', 'L'],
+        color: ['Red', 'Blue'],
+      }
+
+      const combinations = generateVariantCombinations(optionSets)
+
+      expect(combinations.length).toBe(6) // 3 sizes * 2 colors
+      expect(combinations).toContainEqual({ size: 'S', color: 'Red' })
+      expect(combinations).toContainEqual({ size: 'S', color: 'Blue' })
+      expect(combinations).toContainEqual({ size: 'M', color: 'Red' })
+      expect(combinations).toContainEqual({ size: 'M', color: 'Blue' })
+      expect(combinations).toContainEqual({ size: 'L', color: 'Red' })
+      expect(combinations).toContainEqual({ size: 'L', color: 'Blue' })
+    })
+
+    it('should handle three or more option types', () => {
+      const optionSets = {
+        size: ['S', 'M'],
+        color: ['Red', 'Blue'],
+        material: ['Cotton', 'Polyester'],
+      }
+
+      const combinations = generateVariantCombinations(optionSets)
+
+      expect(combinations.length).toBe(8) // 2 sizes * 2 colors * 2 materials
+      expect(combinations).toContainEqual({ size: 'S', color: 'Red', material: 'Cotton' })
+      expect(combinations).toContainEqual({ size: 'M', color: 'Blue', material: 'Polyester' })
+    })
+
+    it('should return an empty array for empty input', () => {
+      const combinations = generateVariantCombinations({})
+      expect(combinations).toEqual([])
+    })
+
+    it('should handle a single option type correctly', () => {
+      const optionSets = {
+        size: ['S', 'M', 'L'],
+      }
+
+      const combinations = generateVariantCombinations(optionSets)
+
+      expect(combinations.length).toBe(3)
+      expect(combinations).toContainEqual({ size: 'S' })
+      expect(combinations).toContainEqual({ size: 'M' })
+      expect(combinations).toContainEqual({ size: 'L' })
+    })
+  })
+})