@stacksjs/commerce 0.70.55 → 0.70.57

package/src/tests/routes.test.ts

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

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

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

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

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

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