@stacksjs/defaults 0.70.229 → 0.70.231

package/app/Actions/Dashboard/Models/model-write.ts

@@ -6,7 +6,7 @@
  * casts and no observers; writing to it from a generic admin screen would
  * bypass every guarantee the ORM makes. Those rows stay read-only.
  */
-import { loadModel } from '../../../../resources/functions/dashboard/data'
+import { loadModelIfExists } from '../../../../resources/functions/dashboard/data'
 
 /** Never writable from a generic admin table, whatever the model declares. */
 export const PROTECTED_COLUMNS: ReadonlySet<string> = new Set([
@@ -27,22 +27,286 @@ export function slugToPascal(str: string): string {
   return str.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('')
 }
 
+/**
+ * Model browser URLs are generated from PascalCase model names as lowercase
+ * kebab-case slugs. Validate that public boundary before deriving a model or
+ * table name from it.
+ */
+export function isValidModelSlug(str: string): boolean {
+  return /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(str)
+}
+
 export interface ResolvedModel {
   Model: any
   modelName: string
 }
 
+export type ModelWriteOperation = 'store' | 'update' | 'destroy'
+
+export interface ModelWriteCapabilities {
+  create: boolean
+  update: boolean
+  destroy: boolean
+}
+
+export interface ModelCreateField {
+  name: string
+  label: string
+  type: 'boolean' | 'date' | 'datetime' | 'email' | 'enum' | 'number' | 'text'
+  required: boolean
+  defaultValue: unknown
+  options: string[]
+}
+
+export interface PreparedModelFields {
+  data: Record<string, unknown>
+  errors: Record<string, string[]>
+}
+
+function snakeCase(name: string): string {
+  return name
+    .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+    .replace(/[\s-]+/g, '_')
+    .toLowerCase()
+}
+
+function humanize(name: string): string {
+  return name
+    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+    .replace(/_/g, ' ')
+    .replace(/\b\w/g, character => character.toUpperCase())
+    .replace(/\bId\b/g, 'ID')
+}
+
+/**
+ * Derive the physical columns declared by a model when its table has no rows
+ * to inspect. This mirrors model-driven migrations closely enough for the
+ * generic browser to render and sort an empty model without falling back to
+ * raw SQLite.
+ */
+export function modelSchemaColumns(Model: any): string[] {
+  const columns: string[] = []
+  const add = (column: string) => {
+    if (column && !columns.includes(column))
+      columns.push(column)
+  }
+
+  add(snakeCase(String(Model?.primaryKey || 'id')))
+  for (const name of Object.keys(Model?.attributes ?? {}))
+    add(snakeCase(name))
+
+  for (const relation of Model?.belongsTo ?? []) {
+    const name = typeof relation === 'string' ? relation : relation?.model
+    if (typeof name === 'string' && name.trim())
+      add(`${snakeCase(name)}_id`)
+  }
+
+  const traits = Model?.traits ?? {}
+  if (traits.useUuid)
+    add('uuid')
+  if ((traits.useTimestamps ?? traits.timestampable) !== false) {
+    add('created_at')
+    add('updated_at')
+  }
+  if (traits.useSoftDeletes ?? traits.softDeletable)
+    add('deleted_at')
+
+  return columns
+}
+
+function isProtectedField(name: string): boolean {
+  const column = name
+    .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+    .toLowerCase()
+  return PROTECTED_COLUMNS.has(name) || PROTECTED_COLUMNS.has(column)
+}
+
+function useApiRoutes(Model: any): string[] {
+  const useApi = Model?.traits?.useApi
+  if (!useApi)
+    return []
+  if (typeof useApi === 'object' && Array.isArray(useApi.routes))
+    return useApi.routes.map(String)
+  return ['index', 'store', 'show', 'update', 'destroy']
+}
+
+export function modelWriteCapabilities(Model: any): ModelWriteCapabilities {
+  const routes = useApiRoutes(Model)
+  return {
+    create: routes.includes('store'),
+    update: routes.includes('update'),
+    destroy: routes.includes('destroy'),
+  }
+}
+
+function relationFieldName(relation: string): string {
+  const words = relation
+    .trim()
+    .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+    .toLowerCase()
+    .split('_')
+    .filter(Boolean)
+  return `${words[0]}${words.slice(1).map(word => `${word[0]?.toUpperCase()}${word.slice(1)}`).join('')}Id`
+}
+
+export function modelCreateFields(Model: any): ModelCreateField[] {
+  const fields: ModelCreateField[] = []
+  const attributes = Model?.attributes ?? {}
+
+  for (const [name, definition] of Object.entries(attributes as Record<string, any>)) {
+    if (!definition?.fillable || definition.hidden || isProtectedField(name))
+      continue
+    const rule = definition.validation?.rule
+    const ruleName = String(rule?.name || definition.type || 'string')
+    const options = Array.isArray(rule?.allowedValues) ? rule.allowedValues.map(String) : []
+    let type: ModelCreateField['type'] = 'text'
+    if (options.length > 0 || ruleName === 'enum')
+      type = 'enum'
+    else if (ruleName === 'number' || ruleName === 'integer' || ruleName === 'timestamp')
+      type = 'number'
+    else if (ruleName === 'boolean')
+      type = 'boolean'
+    else if (ruleName === 'date')
+      type = 'date'
+    else if (ruleName === 'datetime' || ruleName === 'timestampTz')
+      type = 'datetime'
+    else if (name.toLowerCase().includes('email'))
+      type = 'email'
+
+    fields.push({
+      name,
+      label: humanize(name),
+      type,
+      required: definition.required === true || rule?.isRequired === true,
+      defaultValue: definition.default ?? (type === 'boolean' ? false : ''),
+      options,
+    })
+  }
+
+  for (const relation of Model?.belongsTo ?? []) {
+    if (typeof relation !== 'string' || !relation.trim())
+      continue
+    const name = relationFieldName(relation)
+    if (fields.some(field => field.name === name) || isProtectedField(name))
+      continue
+    fields.push({
+      name,
+      label: humanize(name),
+      type: 'number',
+      required: false,
+      defaultValue: '',
+      options: [],
+    })
+  }
+
+  return fields.sort((left, right) => {
+    const leftOrder = attributes[left.name]?.order ?? Number.MAX_SAFE_INTEGER
+    const rightOrder = attributes[right.name]?.order ?? Number.MAX_SAFE_INTEGER
+    return leftOrder - rightOrder
+  })
+}
+
+function normalizeModelValue(type: ModelCreateField['type'], value: unknown): unknown {
+  if (type === 'number') {
+    if (value === '' || value === null || value === undefined)
+      return null
+    const number = Number(value)
+    return Number.isFinite(number) ? number : value
+  }
+  if (type === 'boolean')
+    return value === true || value === 1 || value === '1' || value === 'true' || value === 'on'
+  return value
+}
+
+function normalizeValidationValue(rule: any, value: unknown): unknown {
+  if (typeof value !== 'string')
+    return value
+  if (rule?.name === 'date') {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value)
+    if (!match)
+      return value
+    return new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3])))
+  }
+  if (rule?.name === 'datetime') {
+    const parsed = new Date(value)
+    return Number.isNaN(parsed.getTime()) ? value : parsed
+  }
+  return value
+}
+
+/**
+ * Filter, coerce and validate fields through the model definition. Both
+ * camelCase attribute names and snake_case database columns are accepted.
+ * Partial mode validates only supplied fields for PATCH requests.
+ */
+export function prepareModelFields(
+  Model: any,
+  body: Record<string, unknown>,
+  partial = false,
+): PreparedModelFields {
+  const data: Record<string, unknown> = {}
+  const errors: Record<string, string[]> = {}
+  const attributes = Model?.attributes ?? {}
+
+  for (const field of modelCreateFields(Model)) {
+    const column = snakeCase(field.name)
+    const hasAttribute = Object.prototype.hasOwnProperty.call(body, field.name)
+    const hasColumn = Object.prototype.hasOwnProperty.call(body, column)
+    if (!hasAttribute && !hasColumn) {
+      if (!partial && field.required)
+        errors[field.name] = [`${field.label} is required.`]
+      continue
+    }
+
+    const rawValue = hasAttribute ? body[field.name] : body[column]
+    const value = normalizeModelValue(field.type, rawValue)
+    if ((value === '' || value === null || value === undefined) && field.required) {
+      errors[field.name] = [`${field.label} is required.`]
+      continue
+    }
+    if ((value === '' || value === null || value === undefined) && !field.required) {
+      if (partial)
+        data[field.name] = null
+      continue
+    }
+
+    const definition = attributes[field.name]
+    const rule = definition?.validation?.rule
+    if (rule && typeof rule.validate === 'function') {
+      const result = rule.validate(normalizeValidationValue(rule, value))
+      if (!result?.valid && Array.isArray(result?.errors)) {
+        errors[field.name] = result.errors.map((error: any) =>
+          definition?.validation?.message?.[error?.code] ?? error?.message ?? 'Invalid value.',
+        )
+        continue
+      }
+    }
+
+    data[field.name] = value
+  }
+
+  return { data, errors }
+}
+
 /**
  * Resolve a URL slug to a writable model, preferring the global the ORM
  * injects (the same object the rest of the dashboard queries, so scopes,
  * casts and observers all apply) over the path-map lookup.
  */
-export async function resolveWritableModel(slug: string): Promise<ResolvedModel | { error: string }> {
+export async function resolveWritableModel(slug: string, operation?: ModelWriteOperation): Promise<ResolvedModel | { error: string }> {
+  if (!isValidModelSlug(slug))
+    return { error: 'Model slug must be lowercase kebab-case.' }
+
   const modelName = slugToPascal(slug)
   const injected = (globalThis as Record<string, any>)[modelName]
-  const Model = (injected && typeof injected.where === 'function') ? injected : await loadModel(modelName)
-  if (!Model || Model._isStub || typeof Model.find !== 'function')
+  const Model = (injected && typeof injected.where === 'function') ? injected : await loadModelIfExists(modelName)
+  if (!Model || typeof Model.find !== 'function')
     return { error: `No ORM model named ${modelName}. Rows from tables without a model are read-only.` }
+  if (operation) {
+    const capability = operation === 'store' ? 'create' : operation
+    if (!modelWriteCapabilities(Model)[capability])
+      return { error: `${modelName} does not declare the ${operation} route in its useApi trait.` }
+  }
   return { Model, modelName }
 }
 

package/app/Actions/Dashboard/Notifications/NotificationDeliveryHistoryAction.ts

@@ -0,0 +1,100 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { request as routerRequest, response } from '@stacksjs/router'
+import {
+  type NotificationDeliveryRow,
+  serializeNotificationDelivery,
+} from './notification-delivery'
+
+const CHANNELS = ['email', 'sms', 'chat', 'database', 'push', 'broadcast'] as const
+const STATUSES = ['sent', 'delivered', 'failed', 'pending'] as const
+const SORTS = ['sent_at', 'recipient', 'channel', 'status', 'id'] as const
+
+type DeliveryChannel = typeof CHANNELS[number]
+type DeliveryStatus = typeof STATUSES[number]
+type DeliverySort = typeof SORTS[number]
+
+function queryValue(request: RequestInstance, key: string): string {
+  const query = ((routerRequest as any).query || {}) as Record<string, string | string[] | undefined>
+  const value = query[key]
+  return String((Array.isArray(value) ? value[0] : value) || request.get(key) || '').trim()
+}
+
+function allowedValue<T extends string>(value: string, values: readonly T[]): T | null {
+  return values.includes(value as T) ? value as T : null
+}
+
+export default new Action({
+  name: 'Notification Delivery History',
+  description: 'Returns filtered, sorted, paginated notification transport history.',
+  method: 'GET',
+  apiResponse: true,
+  async handle(request: RequestInstance) {
+    const page = Math.max(1, Number.parseInt(queryValue(request, 'page') || '1', 10) || 1)
+    const perPage = Math.min(100, Math.max(1, Number.parseInt(queryValue(request, 'per_page') || '20', 10) || 20))
+    const channel = allowedValue(queryValue(request, 'channel').toLowerCase(), CHANNELS)
+    const status = allowedValue(queryValue(request, 'status').toLowerCase(), STATUSES)
+    const sort = allowedValue(queryValue(request, 'sort').toLowerCase(), SORTS) || 'sent_at'
+    const direction = queryValue(request, 'direction').toLowerCase() === 'asc' ? 'asc' : 'desc'
+    const search = queryValue(request, 'search')
+    const searchPattern = `%${search}%`
+
+    const applyFilters = <T extends {
+      where: (...args: any[]) => T
+    }>(query: T): T => {
+      let filtered = query
+      if (channel)
+        filtered = filtered.where('channel', '=', channel)
+      if (status)
+        filtered = filtered.where('status', '=', status)
+      if (search) {
+        filtered = filtered.where((expression: any) => expression.or([
+          expression('recipient', 'like', searchPattern),
+          expression('subject', 'like', searchPattern),
+          expression('body', 'like', searchPattern),
+          expression('error', 'like', searchPattern),
+        ]))
+      }
+      return filtered
+    }
+
+    const countQuery = applyFilters(
+      db
+        .selectFrom('notification_deliveries')
+        .select(db.fn.count('id').as('count')),
+    )
+    const rowsQuery = applyFilters(
+      db
+        .selectFrom('notification_deliveries')
+        .selectAll(),
+    )
+
+    const [countRow, rows] = await Promise.all([
+      countQuery.executeTakeFirst() as Promise<{ count: number | string } | undefined>,
+      rowsQuery
+        .orderBy(sort as DeliverySort, direction)
+        .limit(perPage)
+        .offset((page - 1) * perPage)
+        .execute() as Promise<NotificationDeliveryRow[]>,
+    ])
+
+    const total = Number(countRow?.count || 0)
+    return response.json({
+      deliveries: rows.map(serializeNotificationDelivery),
+      pagination: {
+        page,
+        per_page: perPage,
+        total,
+        total_pages: Math.max(1, Math.ceil(total / perPage)),
+      },
+      filters: {
+        channel: channel as DeliveryChannel | null,
+        status: status as DeliveryStatus | null,
+        search,
+        sort,
+        direction,
+      },
+    })
+  },
+})

package/app/Actions/Dashboard/Notifications/NotificationDeliveryIndexAction.ts

@@ -0,0 +1,61 @@
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { NotificationDelivery } from '@stacksjs/orm'
+import { request as routerRequest, response } from '@stacksjs/router'
+import { parseDeliveryMetadata } from './notification-delivery'
+
+type DashboardDeliveryChannel = 'email' | 'sms'
+
+function isDashboardChannel(value: string): value is DashboardDeliveryChannel {
+  return value === 'email' || value === 'sms'
+}
+
+export function resolveDashboardDeliveryChannel(
+  url: string,
+  queryChannel?: string,
+  routeChannel?: string,
+): DashboardDeliveryChannel | null {
+  const explicitChannel = String(queryChannel || routeChannel || '').toLowerCase()
+  if (isDashboardChannel(explicitChannel))
+    return explicitChannel
+
+  const pathChannel = new URL(url, 'http://localhost').pathname.split('/').filter(Boolean).at(-1)?.toLowerCase() || ''
+  return isDashboardChannel(pathChannel) ? pathChannel : null
+}
+
+export default new Action({
+  name: 'Notification Delivery Index',
+  description: 'Returns real email or SMS transport attempts for the dashboard.',
+  method: 'GET',
+  apiResponse: true,
+  async handle(request: RequestInstance) {
+    const query = ((routerRequest as any).query || {}) as Record<string, string | string[] | undefined>
+    const queryChannel = Array.isArray(query.channel) ? query.channel[0] : query.channel
+    const channel = resolveDashboardDeliveryChannel(request.url, queryChannel, request.get('channel'))
+    if (!channel)
+      return response.json({ message: 'Channel must be email or sms.' }, 422)
+
+    const records = await NotificationDelivery.where('channel', '=', channel).get()
+    const deliveries = records
+      .map(record => ({
+        id: Number(record.get('id')),
+        user_id: record.get('user_id') ? Number(record.get('user_id')) : null,
+        channel,
+        recipient: String(record.get('recipient') || ''),
+        subject: String(record.get('subject') || ''),
+        body: String(record.get('body') || ''),
+        status: String(record.get('status') || 'pending'),
+        error: String(record.get('error') || ''),
+        metadata: parseDeliveryMetadata(
+          record.get('metadata'),
+          `notification delivery ${record.get('id')} metadata`,
+        ),
+        sent_at: String(record.get('sent_at') || record.get('created_at') || ''),
+        created_at: String(record.get('created_at') || ''),
+      }))
+      .sort((a, b) => new Date(b.sent_at).getTime() - new Date(a.sent_at).getTime())
+      .slice(0, 500)
+
+    return response.json(deliveries)
+  },
+})

package/app/Actions/Dashboard/Notifications/NotificationDeliveryOverviewAction.ts

@@ -0,0 +1,120 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import {
+  type NotificationDeliveryRow,
+  serializeNotificationDelivery,
+} from './notification-delivery'
+
+interface CountRow {
+  count: number | string
+}
+
+interface StatusCountRow extends CountRow {
+  status: string
+}
+
+interface ChannelStatusCountRow extends StatusCountRow {
+  channel: string
+}
+
+const DELIVERY_STATUSES = ['sent', 'delivered', 'failed', 'pending'] as const
+
+function numericCount(value: number | string | undefined): number {
+  const count = Number(value || 0)
+  return Number.isFinite(count) ? count : 0
+}
+
+export default new Action({
+  name: 'Notification Delivery Overview',
+  description: 'Returns aggregate transport health and recent notification delivery attempts.',
+  method: 'GET',
+  apiResponse: true,
+  async handle() {
+    const [totalRow, statusRows, channelRows, recentRows] = await Promise.all([
+      db
+        .selectFrom('notification_deliveries')
+        .select(db.fn.count('id').as('count'))
+        .executeTakeFirst() as Promise<CountRow | undefined>,
+      db
+        .selectFrom('notification_deliveries')
+        .select(['status', db.fn.count('id').as('count')])
+        .groupBy('status')
+        .execute() as Promise<StatusCountRow[]>,
+      db
+        .selectFrom('notification_deliveries')
+        .select(['channel', 'status', db.fn.count('id').as('count')])
+        .groupBy(['channel', 'status'])
+        .execute() as Promise<ChannelStatusCountRow[]>,
+      db
+        .selectFrom('notification_deliveries')
+        .selectAll()
+        .orderBy('sent_at', 'desc')
+        .limit(8)
+        .execute() as Promise<NotificationDeliveryRow[]>,
+    ])
+
+    const statuses = Object.fromEntries(
+      DELIVERY_STATUSES.map(status => [status, 0]),
+    ) as Record<typeof DELIVERY_STATUSES[number], number>
+
+    for (const row of statusRows) {
+      if (DELIVERY_STATUSES.includes(row.status as typeof DELIVERY_STATUSES[number]))
+        statuses[row.status as typeof DELIVERY_STATUSES[number]] = numericCount(row.count)
+    }
+
+    const channelMap = new Map<string, {
+      channel: string
+      total: number
+      sent: number
+      delivered: number
+      failed: number
+      pending: number
+    }>()
+
+    for (const row of channelRows) {
+      const channel = String(row.channel || 'unknown')
+      const entry = channelMap.get(channel) || {
+        channel,
+        total: 0,
+        sent: 0,
+        delivered: 0,
+        failed: 0,
+        pending: 0,
+      }
+      const count = numericCount(row.count)
+      entry.total += count
+      if (DELIVERY_STATUSES.includes(row.status as typeof DELIVERY_STATUSES[number]))
+        entry[row.status as typeof DELIVERY_STATUSES[number]] += count
+      channelMap.set(channel, entry)
+    }
+
+    const channels = [...channelMap.values()]
+      .map(channel => ({
+        ...channel,
+        success_rate: channel.total > 0
+          ? Number((((channel.sent + channel.delivered) / channel.total) * 100).toFixed(1))
+          : 0,
+      }))
+      .sort((a, b) => b.total - a.total || a.channel.localeCompare(b.channel))
+
+    const total = numericCount(totalRow?.count)
+    const successful = statuses.sent + statuses.delivered
+
+    return response.json({
+      stats: {
+        total,
+        successful,
+        failed: statuses.failed,
+        pending: statuses.pending,
+        success_rate: total > 0
+          ? Number(((successful / total) * 100).toFixed(1))
+          : 0,
+        active_channels: channels.length,
+      },
+      statuses,
+      channels,
+      recent: recentRows.map(serializeNotificationDelivery),
+    })
+  },
+})

package/app/Actions/Dashboard/Notifications/NotificationDeliveryRetryAction.ts

@@ -0,0 +1,61 @@
+import type { NotificationChannel } from '@stacksjs/notifications'
+import type { RequestInstance } from '@stacksjs/types'
+import { Action } from '@stacksjs/actions'
+import { notify } from '@stacksjs/notifications'
+import { NotificationDelivery } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+import { parseDeliveryMetadata } from './notification-delivery'
+
+type RetryChannel = 'email' | 'sms'
+
+function isRetryChannel(value: string): value is RetryChannel {
+  return value === 'email' || value === 'sms'
+}
+
+export default new Action({
+  name: 'Retry Notification Delivery',
+  description: 'Retries a failed email or SMS notification using its stored payload.',
+  method: 'POST',
+  apiResponse: true,
+  async handle(request: RequestInstance) {
+    const id = Number(request.getParam('id'))
+    if (!Number.isFinite(id) || id <= 0)
+      return response.json({ message: 'A valid delivery ID is required.' }, 422)
+
+    const delivery = await NotificationDelivery.find(id)
+    if (!delivery)
+      return response.json({ message: 'Notification delivery not found.' }, 404)
+
+    const channel = String(delivery.get('channel') || '').toLowerCase()
+    if (!isRetryChannel(channel))
+      return response.json({ message: 'Only email and SMS deliveries can be retried here.' }, 422)
+
+    const recipientValue = String(delivery.get('recipient') || '')
+    if (!recipientValue)
+      return response.json({ message: 'The original delivery has no recipient.' }, 422)
+
+    const channels: NotificationChannel[] = [channel]
+    const results = await notify(
+      {
+        userId: delivery.get('user_id') ? Number(delivery.get('user_id')) : undefined,
+        ...(channel === 'email' ? { email: recipientValue } : { phone: recipientValue }),
+      },
+      {
+        subject: String(delivery.get('subject') || ''),
+        body: String(delivery.get('body') || ''),
+        data: parseDeliveryMetadata(
+          delivery.get('metadata'),
+          `notification delivery ${id} metadata`,
+        ),
+      },
+      channels,
+      { ignorePreferences: true },
+    )
+
+    const result = results[0]
+    if (!result?.success)
+      return response.json({ message: result?.error?.message || 'The retry failed.' }, 502)
+
+    return response.json({ success: true })
+  },
+})

package/app/Actions/Dashboard/Notifications/notification-delivery-index.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'bun:test'
+import { resolveDashboardDeliveryChannel } from './NotificationDeliveryIndexAction'
+
+describe('notification delivery channel routing', () => {
+  test('uses an explicit query or route channel', () => {
+    expect(resolveDashboardDeliveryChannel('https://example.test/api/notifications/history', 'email')).toBe('email')
+    expect(resolveDashboardDeliveryChannel('https://example.test/api/notifications/history', undefined, 'sms')).toBe('sms')
+  })
+
+  test('supports the legacy email and SMS route paths', () => {
+    expect(resolveDashboardDeliveryChannel('https://example.test/api/notifications/email')).toBe('email')
+    expect(resolveDashboardDeliveryChannel('https://example.test/api/notifications/sms')).toBe('sms')
+  })
+
+  test('rejects unsupported channels', () => {
+    expect(resolveDashboardDeliveryChannel('https://example.test/api/notifications/push')).toBeNull()
+  })
+})

package/app/Actions/Dashboard/Notifications/notification-delivery.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'bun:test'
+import { parseDeliveryMetadata } from './notification-delivery'
+
+describe('dashboard notification delivery metadata', () => {
+  it('parses persisted metadata objects', () => {
+    expect(parseDeliveryMetadata('{"provider":"log"}')).toEqual({ provider: 'log' })
+    expect(parseDeliveryMetadata({ provider: 'ses' })).toEqual({ provider: 'ses' })
+    expect(parseDeliveryMetadata(null)).toEqual({})
+  })
+
+  it('reports corrupt or non-object metadata', () => {
+    expect(() => parseDeliveryMetadata('{', 'delivery 4 metadata'))
+      .toThrow('Could not parse delivery 4 metadata')
+    expect(() => parseDeliveryMetadata('[]', 'delivery 4 metadata'))
+      .toThrow('delivery 4 metadata must be a JSON object')
+  })
+})