@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/Commerce/shipping-rate-records.ts

@@ -0,0 +1,147 @@
+import {
+  commerceEnum,
+  commerceNumber,
+  commerceOptionalString,
+  commerceOptionalTimestamp,
+  commerceRequiredString,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+import { shippingMethodStatuses } from './shipping-method-records'
+
+export interface ShippingRateMethod {
+  id: number
+  name: string
+  status: typeof shippingMethodStatuses[number]
+}
+
+export interface ShippingRateZone {
+  id: number
+  name: string
+  status: typeof shippingMethodStatuses[number]
+  shippingMethodId: number
+}
+
+export interface ShippingRateRecord {
+  id: number
+  shipping_method_id: number
+  shipping_zone_id: number
+  weight_from: number
+  weight_to: number
+  rate: number
+  shipping_method: ShippingRateMethod
+  shipping_zone: Omit<ShippingRateZone, 'shippingMethodId'>
+  created_at: string
+  updated_at: string
+  uuid: string
+}
+
+function numericIdentifier(input: unknown, source: string, field = 'id'): number {
+  const id = commerceNumber(input, source, field, { integer: true, min: 1 })
+  if (!Number.isSafeInteger(id))
+    throw new TypeError(`${source}.${field} must be a safe positive integer.`)
+  return id
+}
+
+export function indexShippingRateMethods(records: any[]): Map<number, ShippingRateMethod> {
+  const result = new Map<number, ShippingRateMethod>()
+  for (const record of records) {
+    const id = numericIdentifier(commerceValue(record, 'id'), 'ShippingMethod')
+    const source = `ShippingMethod ${id}`
+    if (result.has(id))
+      throw new TypeError(`Duplicate ShippingMethod ${id}.`)
+    result.set(id, {
+      id,
+      name: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+      status: commerceEnum(commerceValue(record, 'status'), source, 'status', shippingMethodStatuses),
+    })
+  }
+  return result
+}
+
+export function indexShippingRateZones(records: any[]): Map<number, ShippingRateZone> {
+  const result = new Map<number, ShippingRateZone>()
+  for (const record of records) {
+    const id = numericIdentifier(commerceValue(record, 'id'), 'ShippingZone')
+    const source = `ShippingZone ${id}`
+    if (result.has(id))
+      throw new TypeError(`Duplicate ShippingZone ${id}.`)
+    result.set(id, {
+      id,
+      name: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+      status: commerceEnum(commerceValue(record, 'status'), source, 'status', shippingMethodStatuses),
+      shippingMethodId: numericIdentifier(
+        commerceValue(record, 'shipping_method_id', 'shippingMethodId'),
+        source,
+        'shipping_method_id',
+      ),
+    })
+  }
+  return result
+}
+
+export function normalizeShippingRateRecord(
+  record: any,
+  methods: ReadonlyMap<number, ShippingRateMethod>,
+  zones: ReadonlyMap<number, ShippingRateZone>,
+): ShippingRateRecord {
+  const id = numericIdentifier(commerceValue(record, 'id'), 'ShippingRate')
+  const source = `ShippingRate ${id}`
+  const methodId = numericIdentifier(
+    commerceValue(record, 'shipping_method_id', 'shippingMethodId'),
+    source,
+    'shipping_method_id',
+  )
+  const zoneId = numericIdentifier(
+    commerceValue(record, 'shipping_zone_id', 'shippingZoneId'),
+    source,
+    'shipping_zone_id',
+  )
+  const method = methods.get(methodId)
+  const zone = zones.get(zoneId)
+  if (!method)
+    throw new TypeError(`${source}.shipping_method_id references missing ShippingMethod ${methodId}.`)
+  if (!zone)
+    throw new TypeError(`${source}.shipping_zone_id references missing ShippingZone ${zoneId}.`)
+  if (zone.shippingMethodId !== methodId) {
+    throw new TypeError(
+      `${source}.shipping_zone_id references ShippingZone ${zoneId} assigned to ShippingMethod ${zone.shippingMethodId}.`,
+    )
+  }
+
+  const weightFrom = commerceNumber(
+    commerceValue(record, 'weight_from', 'weightFrom'),
+    source,
+    'weight_from',
+    { min: 0 },
+  )
+  const weightTo = commerceNumber(
+    commerceValue(record, 'weight_to', 'weightTo'),
+    source,
+    'weight_to',
+    { min: 0 },
+  )
+  if (weightTo < weightFrom)
+    throw new TypeError(`${source}.weight_to must be greater than or equal to weight_from.`)
+
+  return {
+    id,
+    shipping_method_id: methodId,
+    shipping_zone_id: zoneId,
+    weight_from: weightFrom,
+    weight_to: weightTo,
+    rate: commerceNumber(commerceValue(record, 'rate'), source, 'rate', {
+      integer: true,
+      min: 0,
+    }),
+    shipping_method: method,
+    shipping_zone: {
+      id: zone.id,
+      name: zone.name,
+      status: zone.status,
+    },
+    created_at: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+    updated_at: commerceOptionalTimestamp(commerceValue(record, 'updated_at', 'updatedAt'), source, 'updated_at'),
+    uuid: commerceOptionalString(commerceValue(record, 'uuid'), source, 'uuid'),
+  }
+}

package/app/Actions/Dashboard/Commerce/shipping-zone-records.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  indexShippingZoneMethods,
+  normalizeShippingZoneRecord,
+} from './shipping-zone-records'
+
+describe('shipping zone records', () => {
+  const method = { id: 2, name: 'Ground', status: 'active' }
+  const methods = indexShippingZoneMethods([method])
+
+  test('normalizes lists and the shipping method relationship', () => {
+    expect(normalizeShippingZoneRecord({
+      id: 1,
+      name: 'Domestic',
+      countries: '["US","CA"]',
+      regions: 'West, East',
+      postal_codes: [],
+      shipping_method_id: 2,
+      status: 'active',
+      created_at: '2026-07-29 10:00:00',
+      updated_at: null,
+      uuid: null,
+    }, methods)).toEqual({
+      id: 1,
+      name: 'Domestic',
+      countries: ['US', 'CA'],
+      regions: ['West', 'East'],
+      postal_codes: [],
+      shipping_method_id: 2,
+      status: 'active',
+      shipping_method: method,
+      created_at: '2026-07-29T10:00:00.000Z',
+      updated_at: '',
+      uuid: '',
+    })
+  })
+
+  test('rejects invalid list JSON and missing methods', () => {
+    const base = {
+      id: 1,
+      name: 'Domestic',
+      countries: [],
+      regions: [],
+      postal_codes: [],
+      shipping_method_id: 2,
+      status: 'active',
+      created_at: '2026-07-29 10:00:00',
+    }
+    expect(() => normalizeShippingZoneRecord({ ...base, countries: '{"US":true}' }, methods))
+      .toThrow('ShippingZone 1.countries must be a JSON array or delimited string list')
+    expect(() => normalizeShippingZoneRecord({ ...base, shipping_method_id: 9 }, methods))
+      .toThrow('ShippingZone 1.shipping_method_id references missing ShippingMethod 9')
+  })
+})

package/app/Actions/Dashboard/Commerce/shipping-zone-records.ts

@@ -0,0 +1,88 @@
+import {
+  commerceEnum,
+  commerceNumber,
+  commerceOptionalString,
+  commerceOptionalTimestamp,
+  commerceRequiredString,
+  commerceStringList,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+import { shippingMethodStatuses } from './shipping-method-records'
+
+export interface ShippingZoneMethod {
+  id: number
+  name: string
+  status: typeof shippingMethodStatuses[number]
+}
+
+export interface ShippingZoneRecord {
+  id: number
+  name: string
+  countries: string[]
+  regions: string[]
+  postal_codes: string[]
+  shipping_method_id: number
+  status: typeof shippingMethodStatuses[number]
+  shipping_method: ShippingZoneMethod
+  created_at: string
+  updated_at: string
+  uuid: string
+}
+
+function numericIdentifier(input: unknown, source: string, field = 'id'): number {
+  const id = commerceNumber(input, source, field, { integer: true, min: 1 })
+  if (!Number.isSafeInteger(id))
+    throw new TypeError(`${source}.${field} must be a safe positive integer.`)
+  return id
+}
+
+export function indexShippingZoneMethods(records: any[]): Map<number, ShippingZoneMethod> {
+  const result = new Map<number, ShippingZoneMethod>()
+  for (const record of records) {
+    const id = numericIdentifier(commerceValue(record, 'id'), 'ShippingMethod')
+    const source = `ShippingMethod ${id}`
+    if (result.has(id))
+      throw new TypeError(`Duplicate ShippingMethod ${id}.`)
+    result.set(id, {
+      id,
+      name: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+      status: commerceEnum(commerceValue(record, 'status'), source, 'status', shippingMethodStatuses),
+    })
+  }
+  return result
+}
+
+export function normalizeShippingZoneRecord(
+  record: any,
+  methods: ReadonlyMap<number, ShippingZoneMethod>,
+): ShippingZoneRecord {
+  const id = numericIdentifier(commerceValue(record, 'id'), 'ShippingZone')
+  const source = `ShippingZone ${id}`
+  const methodId = numericIdentifier(
+    commerceValue(record, 'shipping_method_id', 'shippingMethodId'),
+    source,
+    'shipping_method_id',
+  )
+  const method = methods.get(methodId)
+  if (!method)
+    throw new TypeError(`${source}.shipping_method_id references missing ShippingMethod ${methodId}.`)
+
+  return {
+    id,
+    name: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+    countries: commerceStringList(commerceValue(record, 'countries'), source, 'countries'),
+    regions: commerceStringList(commerceValue(record, 'regions'), source, 'regions'),
+    postal_codes: commerceStringList(
+      commerceValue(record, 'postal_codes', 'postalCodes'),
+      source,
+      'postal_codes',
+    ),
+    shipping_method_id: methodId,
+    status: commerceEnum(commerceValue(record, 'status'), source, 'status', shippingMethodStatuses),
+    shipping_method: method,
+    created_at: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+    updated_at: commerceOptionalTimestamp(commerceValue(record, 'updated_at', 'updatedAt'), source, 'updated_at'),
+    uuid: commerceOptionalString(commerceValue(record, 'uuid'), source, 'uuid'),
+  }
+}

package/app/Actions/Dashboard/Commerce/tax-rate-records.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'bun:test'
+import { normalizeTaxRateRecord, summarizeTaxRates } from './tax-rate-records'
+
+describe('dashboard tax rate records', () => {
+  it('normalizes persisted TaxRate columns', () => {
+    expect(normalizeTaxRateRecord({
+      id: 4,
+      name: 'Standard VAT',
+      rate: '20',
+      type: 'VAT',
+      country: 'France',
+      region: 'Europe',
+      status: 'active',
+      is_default: 1,
+      created_at: '2026-07-29 10:00:00',
+    })).toEqual({
+      id: '4',
+      name: 'Standard VAT',
+      rate: 20,
+      type: 'VAT',
+      country: 'France',
+      region: 'Europe',
+      status: 'active',
+      isDefault: true,
+      createdAt: '2026-07-29T10:00:00.000Z',
+    })
+  })
+
+  it('rejects incomplete and coercive TaxRate columns', () => {
+    expect(() => normalizeTaxRateRecord({
+      id: 4,
+      name: 'Standard VAT',
+      rate: 'not-a-rate',
+      type: 'VAT',
+      country: 'France',
+      region: 'Europe',
+      status: 'active',
+      is_default: false,
+      created_at: '2026-07-29 10:00:00',
+    })).toThrow('TaxRate 4.rate must be a finite number')
+
+    expect(() => normalizeTaxRateRecord({
+      id: 5,
+      name: 'Legacy tax',
+      rate: 20,
+      type: 'VAT',
+      country: 'France',
+      region: 'Atlantis',
+      status: 'active',
+      is_default: false,
+      created_at: '2026-07-29 10:00:00',
+    })).toThrow('TaxRate 5.region must be North America')
+  })
+
+  it('summarizes rates and reports competing defaults', () => {
+    const records = [
+      normalizeTaxRateRecord({
+        id: 1,
+        name: 'VAT',
+        rate: 20,
+        type: 'VAT',
+        country: 'France',
+        region: 'Europe',
+        status: 'active',
+        is_default: true,
+        created_at: '2026-07-29 10:00:00',
+      }),
+      normalizeTaxRateRecord({
+        id: 2,
+        name: 'GST',
+        rate: 10,
+        type: 'GST',
+        country: 'Australia',
+        region: 'Oceania',
+        status: 'inactive',
+        is_default: true,
+        created_at: '2026-07-29 10:00:00',
+      }),
+      normalizeTaxRateRecord({
+        id: 3,
+        name: 'Reduced VAT',
+        rate: 5,
+        type: 'VAT',
+        country: 'France',
+        region: 'Europe',
+        status: 'active',
+        is_default: false,
+        created_at: '2026-07-29 10:00:00',
+      }),
+    ]
+
+    expect(summarizeTaxRates(records)).toEqual({
+      total: 3,
+      active: 2,
+      countries: 2,
+      averageRate: 35 / 3,
+      defaultConflicts: 1,
+    })
+  })
+})

package/app/Actions/Dashboard/Commerce/tax-rate-records.ts

@@ -0,0 +1,67 @@
+import {
+  commerceBoolean,
+  commerceEnum,
+  commerceIdentifier,
+  commerceNumber,
+  commerceRequiredString,
+  commerceTimestamp,
+  commerceValue,
+} from './commerce-record'
+
+export type TaxRateRegion = 'North America' | 'South America' | 'Europe' | 'Asia' | 'Africa' | 'Oceania' | 'Antarctica'
+
+export interface TaxRateRecord {
+  id: string
+  name: string
+  rate: number
+  type: string
+  country: string
+  region: TaxRateRegion
+  status: 'active' | 'inactive'
+  isDefault: boolean
+  createdAt: string
+}
+
+export interface TaxRateSummary {
+  total: number
+  active: number
+  countries: number
+  averageRate: number
+  defaultConflicts: number
+}
+
+export function normalizeTaxRateRecord(record: any): TaxRateRecord {
+  const id = commerceIdentifier(commerceValue(record, 'id', 'uuid'), 'TaxRate')
+  const source = `TaxRate ${id}`
+  return {
+    id,
+    name: commerceRequiredString(commerceValue(record, 'name'), source, 'name'),
+    rate: commerceNumber(commerceValue(record, 'rate'), source, 'rate', { min: 0, max: 100 }),
+    type: commerceRequiredString(commerceValue(record, 'type'), source, 'type'),
+    country: commerceRequiredString(commerceValue(record, 'country'), source, 'country'),
+    region: commerceEnum(commerceValue(record, 'region'), source, 'region', [
+      'North America',
+      'South America',
+      'Europe',
+      'Asia',
+      'Africa',
+      'Oceania',
+      'Antarctica',
+    ]),
+    status: commerceEnum(commerceValue(record, 'status'), source, 'status', ['active', 'inactive']),
+    isDefault: commerceBoolean(commerceValue(record, 'is_default', 'isDefault'), source, 'is_default'),
+    createdAt: commerceTimestamp(commerceValue(record, 'created_at', 'createdAt'), source),
+  }
+}
+
+export function summarizeTaxRates(records: TaxRateRecord[]): TaxRateSummary {
+  const totalRate = records.reduce((sum, record) => sum + record.rate, 0)
+  const defaults = records.filter(record => record.isDefault).length
+  return {
+    total: records.length,
+    active: records.filter(record => record.status === 'active').length,
+    countries: new Set(records.map(record => record.country).filter(Boolean)).size,
+    averageRate: records.length ? totalRate / records.length : 0,
+    defaultConflicts: Math.max(0, defaults - 1),
+  }
+}

package/app/Actions/Dashboard/Content/AuthorStoreAction.ts

@@ -3,14 +3,14 @@ import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
 import { response } from '@stacksjs/router'
 import { randomUUIDv7 } from 'bun'
-import { findRow, insertedId, str, timestamp } from './content-input'
+import { parseAuthorInput } from './author-input'
+import { findRow, insertedId, timestamp } from './content-input'
 
 /**
  * `POST /api/dashboard/authors` — creates a CMS author from the dashboard.
  *
- * Does not reuse `Actions/Cms/AuthorStoreAction`: that runs the `Author` model
- * validation, which requires a name of at least five characters and rejects the
- * empty bio/avatar the dashboard dialog submits.
+ * The shared parser mirrors the `Author` model's validation contract so the
+ * dashboard and generated `useApi` routes accept the same record shape.
  *
  * The email check is done here because `authors_email_name_index` is not a
  * unique index — nothing in the schema stops a duplicate.
@@ -20,19 +20,15 @@ export default new Action({
   description: 'Creates a CMS author from the dashboard.',
   method: 'POST',
   async handle(request: RequestInstance) {
-    const name = str(request.get('name')).trim()
-    const email = str(request.get('email')).trim()
+    const input = parseAuthorInput(request)
 
-    if (!name)
-      return response.json({ message: 'Name is required.' }, 422)
-
-    if (!email)
-      return response.json({ message: 'Email is required.' }, 422)
+    if ('message' in input)
+      return response.json({ message: input.message }, 422)
 
     const duplicate = await db
       .selectFrom('authors')
       .select(['id'])
-      .where('email', '=', email)
+      .where('email', '=', input.data.email)
       .executeTakeFirst()
 
     if (duplicate)
@@ -44,8 +40,10 @@ export default new Action({
       .insertInto('authors')
       .values({
         uuid: randomUUIDv7(),
-        name,
-        email,
+        name: input.data.name,
+        email: input.data.email,
+        bio: input.data.bio || null,
+        avatar: input.data.avatar || null,
         created_at: now,
         updated_at: now,
       } as any)

package/app/Actions/Dashboard/Content/AuthorUpdateAction.ts

@@ -0,0 +1,50 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { parseAuthorInput } from './author-input'
+import { findRow, rowExists, rowId, timestamp } from './content-input'
+
+export default new Action({
+  name: 'AuthorUpdateAction',
+  description: 'Updates a CMS author from the dashboard.',
+  method: 'PATCH',
+  async handle(request: RequestInstance) {
+    const id = rowId(request)
+
+    if (!id)
+      return response.json({ message: 'A valid author id is required.' }, 422)
+
+    if (!await rowExists('authors', id))
+      return response.json({ message: 'Author not found.' }, 404)
+
+    const input = parseAuthorInput(request)
+
+    if ('message' in input)
+      return response.json({ message: input.message }, 422)
+
+    const duplicate = await db
+      .selectFrom('authors')
+      .select(['id'])
+      .where('email', '=', input.data.email)
+      .where('id', '!=', id)
+      .executeTakeFirst()
+
+    if (duplicate)
+      return response.json({ message: 'An author with that email already exists.' }, 422)
+
+    await db
+      .updateTable('authors')
+      .set({
+        name: input.data.name,
+        email: input.data.email,
+        bio: input.data.bio || null,
+        avatar: input.data.avatar || null,
+        updated_at: timestamp(),
+      } as any)
+      .where('id', '=', id)
+      .execute()
+
+    return response.json(await findRow('authors', id))
+  },
+})

package/app/Actions/Dashboard/Content/CategoryDestroyAction.ts

@@ -1,14 +1,13 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
-import { db } from '@stacksjs/database'
 import { response } from '@stacksjs/router'
-import { rowExists, rowId } from './content-input'
+import { rowId } from './content-input'
 
 /**
  * `DELETE /api/dashboard/categories/{id}` — deletes a CMS category.
  *
- * A plain row delete: this schema has no `categorizable_models` pivot table, so
- * there is nothing to cascade to.
+ * Detaches related posts through the model relation before removing the
+ * category so no pivot rows are orphaned.
  */
 export default new Action({
   name: 'CategoryDestroyAction',
@@ -20,10 +19,12 @@ export default new Action({
     if (!id)
       return response.json({ message: 'A valid category id is required.' }, 422)
 
-    if (!await rowExists('categories', id))
+    const category = await Category.find(id)
+    if (!category)
       return response.json({ message: 'Category not found.' }, 404)
 
-    await db.deleteFrom('categories').where('id', '=', id).execute()
+    await category.posts().detach()
+    await category.delete()
 
     return response.json({ message: 'Category deleted.', id })
   },

package/app/Actions/Dashboard/Content/CategoryStoreAction.ts

@@ -2,6 +2,7 @@ import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions'
 import { db } from '@stacksjs/database'
 import { response } from '@stacksjs/router'
+import { randomUUIDv7 } from 'bun'
 import { findRow, insertedId, slugify, str, timestamp } from './content-input'
 
 /**
@@ -35,14 +36,20 @@ export default new Action({
       return response.json({ message: 'A category with that slug already exists.' }, 422)
 
     const now = timestamp()
+    const displayOrder = await db
+      .selectFrom('categories')
+      .select(db.fn.max('display_order').as('max_display_order'))
+      .executeTakeFirst()
 
     const result = await db
       .insertInto('categories')
       .values({
+        uuid: randomUUIDv7(),
         name,
         slug,
         description,
         is_active: 1,
+        display_order: Number(displayOrder?.max_display_order || 0) + 1,
         created_at: now,
         updated_at: now,
       } as any)