@pilotiq/pilotiq 0.1.0

package/src/notifications/Notification.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Notification, _resetNotificationIdSeq, serializeForNotification } from './Notification.js'
+import { Action } from '../actions/Action.js'
+
+beforeEach(() => _resetNotificationIdSeq())
+
+describe('Notification builder', () => {
+  it('defaults to type:info', () => {
+    const meta = Notification.make('Hello').toMeta()
+    assert.equal(meta.type, 'info')
+    assert.equal(meta.title, 'Hello')
+  })
+
+  it('title via constructor or .title()', () => {
+    assert.equal(Notification.make('A').toMeta().title, 'A')
+    assert.equal(Notification.make().title('B').toMeta().title, 'B')
+  })
+
+  it('type sugar — info / success / warning / error', () => {
+    assert.equal(Notification.make().info().toMeta().type,    'info')
+    assert.equal(Notification.make().success().toMeta().type, 'success')
+    assert.equal(Notification.make().warning().toMeta().type, 'warning')
+    assert.equal(Notification.make().error().toMeta().type,   'error')
+  })
+
+  it('body / icon / duration round-trip', () => {
+    const meta = Notification.make('Saved').body('All good.').icon('check-circle-2').duration(2500).toMeta()
+    assert.equal(meta.body,     'All good.')
+    assert.equal(meta.icon,     'check-circle-2')
+    assert.equal(meta.duration, 2500)
+  })
+
+  it('id is auto-generated when not set', () => {
+    const a = Notification.make('A').toMeta()
+    const b = Notification.make('B').toMeta()
+    assert.notEqual(a.id, b.id)
+    assert.match(a.id, /^n-\d+-\d+$/)
+  })
+
+  it('explicit .id() overrides the auto id', () => {
+    const meta = Notification.make('A').id('my-id').toMeta()
+    assert.equal(meta.id, 'my-id')
+  })
+
+  it('omits body / icon / duration when not set', () => {
+    const meta = Notification.make('A').toMeta()
+    assert.equal(meta.body,     undefined)
+    assert.equal(meta.icon,     undefined)
+    assert.equal(meta.duration, undefined)
+  })
+})
+
+describe('Notification.actions([…])', () => {
+  it('emits no `actions` key when the slot is empty', () => {
+    const meta = Notification.make('A').toMeta()
+    assert.equal(meta.actions, undefined)
+
+    const data = Notification.make('A').toDatabase()
+    assert.equal(data['actions'], undefined)
+  })
+
+  it('serializes a url-mode action through both transports', () => {
+    const n = Notification.make('Hi').actions([
+      Action.make('view').url('/p/123').color('primary').icon('eye'),
+    ])
+    const meta = n.toMeta().actions
+    const data = n.toDatabase()['actions'] as unknown[]
+    assert.deepEqual(meta, [{
+      name:  'view',
+      label: 'View',
+      url:   '/p/123',
+      color: 'primary',
+      icon:  'eye',
+    }])
+    // toDatabase() emits the same shape (no closure leakage).
+    assert.deepEqual(data, meta)
+  })
+
+  it('serializes a method-post action with action-url', () => {
+    const meta = Notification.make('Hi').actions([
+      Action.make('archive').label('Archive').method('post').action('/p/123/archive'),
+    ]).toMeta().actions
+
+    assert.deepEqual(meta, [{
+      name:  'archive',
+      label: 'Archive',
+      post:  '/p/123/archive',
+    }])
+  })
+
+  it('serializes a registry-handler action with payload', () => {
+    const meta = Notification.make('Hi').actions([
+      Action.make('archive')
+        .label('Archive')
+        .handler('archive-project')
+        .payload({ projectId: 123 })
+        .markAsRead(),
+    ]).toDatabase()['actions'] as unknown[]
+
+    assert.deepEqual(meta, [{
+      name:        'archive',
+      label:       'Archive',
+      handler:     'archive-project',
+      payload:     { projectId: 123 },
+      markAsRead:  true,
+    }])
+  })
+
+  it('omits empty payload when the slot is unset', () => {
+    const meta = Notification.make('Hi').actions([
+      Action.make('archive').handler('archive-project'),
+    ]).toMeta().actions
+    assert.equal(meta?.[0]?.payload, undefined)
+  })
+
+  it('toMeta tolerates closure handlers (transient toast escape hatch)', () => {
+    // Closures don't ride the wire — the toaster reads them off
+    // Notification.getActions(). The wire shape carries the action
+    // name as the dispatch key.
+    const meta = Notification.make('Hi').actions([
+      Action.make('do').handler(async () => undefined),
+    ]).toMeta().actions
+    assert.equal(meta?.[0]?.handler, 'do')
+    assert.equal(meta?.[0]?.url,     undefined)
+    assert.equal(meta?.[0]?.post,    undefined)
+  })
+
+  it('toDatabase rejects closure handlers with a clear error', () => {
+    const n = Notification.make('Hi').actions([
+      Action.make('do').handler(async () => undefined),
+    ])
+    assert.throws(() => n.toDatabase(), /closure handler/)
+  })
+
+  it('rejects modal-form actions at config time', () => {
+    const n = Notification.make('Hi').actions([
+      Action.make('edit').schema([]).handler('x'),
+    ])
+    assert.throws(() => n.toMeta(), /modal-form/)
+  })
+
+  it('rejects submit actions at config time', () => {
+    const n = Notification.make('Hi').actions([
+      Action.make('save').submit(),
+    ])
+    assert.throws(() => n.toMeta(), /submit button/)
+  })
+
+  it('rejects bulk-placement actions at config time', () => {
+    const n = Notification.make('Hi').actions([
+      Action.make('bulk').placement('bulk').handler('x'),
+    ])
+    assert.throws(() => n.toMeta(), /bulk-placed/)
+  })
+
+  it('rejects actions with no dispatch target', () => {
+    const n = Notification.make('Hi').actions([
+      Action.make('orphan'),
+    ])
+    assert.throws(() => n.toMeta(), /no dispatch target/)
+  })
+
+  it('passes through chrome (color / outlined / size / openUrlInNewTab)', () => {
+    const meta = serializeForNotification(
+      Action.make('view').url('/x').color('destructive').size('lg').openUrlInNewTab(),
+      { transient: true },
+    )
+    assert.equal(meta.color,           'destructive')
+    assert.equal(meta.size,            'lg')
+    assert.equal(meta.openUrlInNewTab, true)
+
+    const outlined = serializeForNotification(
+      Action.make('view').url('/x').color('primary').outlined(),
+      { transient: true },
+    )
+    assert.equal(outlined.outlined, true)
+  })
+
+  it('Action.markAsRead() chain modifier sets the wire flag', () => {
+    const meta = serializeForNotification(
+      Action.make('view').url('/x').markAsRead(),
+      { transient: true },
+    )
+    assert.equal(meta.markAsRead, true)
+  })
+
+  it('Action.markAsRead(false) clears the flag', () => {
+    const meta = serializeForNotification(
+      Action.make('view').url('/x').markAsRead().markAsRead(false),
+      { transient: true },
+    )
+    assert.equal(meta.markAsRead, undefined)
+  })
+
+  it('Action.handler() switches between closure and string', () => {
+    const a = Action.make('a').handler(async () => undefined)
+    assert.equal(typeof a.getHandler(), 'function')
+    assert.equal(a.getHandlerName(), undefined)
+
+    a.handler('archive')
+    assert.equal(a.getHandler(), undefined)
+    assert.equal(a.getHandlerName(), 'archive')
+
+    a.handler(async () => undefined)
+    assert.equal(typeof a.getHandler(), 'function')
+    assert.equal(a.getHandlerName(), undefined)
+  })
+})

package/src/notifications/Notification.ts

@@ -0,0 +1,354 @@
+/**
+ * Notification — fluent builder for toast/flash messages emitted from
+ * action handlers, form lifecycle hooks, or the route layer. Serializes
+ * to a `NotificationMeta` that the client `<Toaster>` consumes.
+ *
+ * The same builder also doubles as the entry-point for persistent
+ * notifications: `notification.sendToDatabase(user)` writes a row on
+ * the `notification` table shipped by `@rudderjs/notification`. The
+ * panel's bell-icon dropdown reads from that table so the same call
+ * site that emits a toast can also drop a row into the user's inbox.
+ */
+import type { Notifiable, NotificationActionMeta } from './types.js'
+import type { Action } from '../actions/Action.js'
+import { persist as persistDatabaseNotification } from './database.js'
+import {
+  push as pushBroadcast,
+  notificationChannel,
+} from './broadcast.js'
+
+export type NotificationType = 'info' | 'success' | 'warning' | 'error'
+
+export interface NotificationMeta {
+  /** Stable id; used by the client to dedupe and dismiss. Auto-generated
+   * when not supplied. */
+  id:        string
+  type:      NotificationType
+  title:     string
+  body?:     string
+  icon?:     string
+  /** Auto-dismiss duration in ms. `0` keeps the toast until manually
+   * dismissed. Default 5000. */
+  duration?: number
+  /** Filament-style action strip rendered below the body. Same shape
+   *  on transient toasts and persisted bell rows. Closure-handler
+   *  actions are valid on toasts but rejected at `sendToDatabase` time
+   *  (closures don't survive serialization). */
+  actions?:  NotificationActionMeta[]
+}
+
+let _idSeq = 0
+function nextId(): string {
+  _idSeq += 1
+  return `n-${_idSeq}-${Date.now()}`
+}
+
+export class Notification {
+  protected _id?: string
+  protected _type: NotificationType = 'info'
+  protected _title = ''
+  protected _body?: string
+  protected _icon?: string
+  protected _duration?: number
+  protected _actions: Action[] = []
+
+  private constructor() {}
+
+  static make(title?: string): Notification {
+    const n = new Notification()
+    if (title) n._title = title
+    return n
+  }
+
+  // ─── Type sugar ───────────────────────────────────────
+
+  info(): this    { this._type = 'info';    return this }
+  success(): this { this._type = 'success'; return this }
+  warning(): this { this._type = 'warning'; return this }
+  error(): this   { this._type = 'error';   return this }
+
+  // ─── Content ──────────────────────────────────────────
+
+  title(s: string): this { this._title = s; return this }
+  body(s: string): this  { this._body  = s; return this }
+  icon(i: string): this  { this._icon  = i; return this }
+
+  // ─── Behavior ─────────────────────────────────────────
+
+  /** Auto-dismiss timeout in ms. `0` means persistent. Default 5000. */
+  duration(ms: number): this { this._duration = ms; return this }
+
+  /** Override the auto-generated id (rarely needed). */
+  id(s: string): this { this._id = s; return this }
+
+  /**
+   * Filament-style action strip — buttons rendered below the body on
+   * both transient toasts and persisted bell rows.
+   *
+   * Three serializable dispatch modes:
+   *   - `Action.make('view').url('/p/123')`             — href anchor
+   *   - `Action.make('post').method('post').action(u)`  — form-POST
+   *   - `Action.make('archive').handler('name').payload({…})`
+   *                                                      — registered
+   *                                                        handler
+   *
+   * Closure handlers (`.handler(async ctx => …)`) work on transient
+   * toasts (dispatched against the page's `_action/:name`) but are
+   * rejected at `sendToDatabase()` time — closures don't round-trip
+   * through the `data` JSON column. Use the named-registry path
+   * (`Pilotiq.notificationHandlers({…})`) for persistent rows.
+   *
+   * Pair with `.markAsRead()` on any action to flip the row's
+   * `read_at` when the action fires:
+   *
+   *   Notification.make('New project assigned')
+   *     .actions([
+   *       Action.make('view').url('/p/123').markAsRead(),
+   *       Action.make('archive').handler('archive-project')
+   *         .payload({ projectId: 123 }).markAsRead(),
+   *     ])
+   *     .sendToDatabase(currentUser)
+   */
+  actions(actions: Action[]): this {
+    this._actions = actions
+    return this
+  }
+
+  /** Internal — exposed so the toaster / dispatcher can read the
+   *  authored Action instances directly when needed (rare). Most
+   *  consumers should read from `toMeta().actions` instead. */
+  getActions(): readonly Action[] { return this._actions }
+
+  /**
+   * Optional click-through URL. When set on a row that's been written
+   * to the database via `sendToDatabase()`, the bell-icon dropdown
+   * navigates here when the row is clicked (and marks it read in the
+   * same step). Ignored on transient toasts.
+   */
+  url(href: string): this { this._url = href; return this }
+
+  protected _url?: string
+
+  // ─── Serialization ────────────────────────────────────
+
+  toMeta(): NotificationMeta {
+    const actions = this._actions.length > 0
+      ? this._actions.map(a => serializeForNotification(a, { transient: true }))
+      : undefined
+    return {
+      id:    this._id ?? nextId(),
+      type:  this._type,
+      title: this._title,
+      ...(this._body     !== undefined ? { body:     this._body     } : {}),
+      ...(this._icon     !== undefined ? { icon:     this._icon     } : {}),
+      ...(this._duration !== undefined ? { duration: this._duration } : {}),
+      ...(actions        !== undefined ? { actions                  } : {}),
+    }
+  }
+
+  /**
+   * Build the JSON payload stored in the `notification.data` column.
+   * Mirrors the toast meta but always includes `type` (so the bell
+   * dropdown can apply the matching tint chip) and `url` when set.
+   *
+   * Action strip: closure-handler actions are rejected here — their
+   * dispatch target only exists on the page that authored the notify,
+   * and the row may outlive that page by days. The named-registry path
+   * (`Pilotiq.notificationHandlers({…})`) is the persistence-safe
+   * escape hatch.
+   */
+  toDatabase(): Record<string, unknown> {
+    const data: Record<string, unknown> = {
+      type:  this._type,
+      title: this._title,
+    }
+    if (this._body !== undefined) data['body'] = this._body
+    if (this._icon !== undefined) data['icon'] = this._icon
+    if (this._url  !== undefined) data['url']  = this._url
+    if (this._actions.length > 0) {
+      data['actions'] = this._actions.map(a => serializeForNotification(a, { transient: false }))
+    }
+    return data
+  }
+
+  /**
+   * Persist this notification on the `notification` table for
+   * `recipient`. The bell-icon dropdown surfaces it on the recipient's
+   * next poll (or immediately on broadcast — see Phase 2).
+   *
+   * Throws when no `@rudderjs/orm` adapter is registered, with a clear
+   * message pointing at the providers list.
+   *
+   * `notifiableType` lets the caller override the column value when an
+   * app stores notifications scoped to a non-`'users'` notifiable
+   * (teams, projects, etc). Default `'users'` matches the table layout
+   * `@rudderjs/notification`'s `DatabaseChannel` writes.
+   *
+   *   await Notification.make('Saved successfully')
+   *     .body('Changes to the post have been saved.')
+   *     .success()
+   *     .sendToDatabase(currentUser)
+   */
+  async sendToDatabase(
+    recipient: Notifiable,
+    opts: { notifiableType?: string; broadcast?: boolean } = {},
+  ): Promise<{ id: string }> {
+    const data = this.toDatabase() as NotificationMeta & Record<string, unknown>
+    const result = await persistDatabaseNotification({
+      notifiableType: opts.notifiableType ?? 'users',
+      notifiableId:   String(recipient.id),
+      data,
+    })
+    // Phase 2: push the same payload over WebSocket so the bell client
+    // can refetch immediately. Soft-fails when `@rudderjs/broadcast`
+    // isn't installed (or when the provider hasn't booted) — apps still
+    // get the persisted row via polling.
+    if (opts.broadcast) {
+      await pushBroadcast({
+        recipientId: recipient.id,
+        payload: { ...data, id: result.id, createdAt: Date.now() },
+      })
+    }
+    return result
+  }
+
+  /**
+   * Push this notification over WebSocket without persisting it. Pairs
+   * with `sendToDatabase()` (or runs standalone for ephemeral pushes
+   * like "user-X started typing"). Soft-fails when `@rudderjs/broadcast`
+   * isn't installed.
+   *
+   * Channel: `private-pilotiq-notifications.${recipient.id}`. The bell
+   * client subscribes to this channel automatically when broadcast is
+   * enabled in `Pilotiq.databaseNotifications({ broadcast: true })`.
+   *
+   *   await Notification.make('Live update')
+   *     .info()
+   *     .broadcast(currentUser)
+   */
+  async broadcast(recipient: Notifiable): Promise<{ ok: boolean }> {
+    return pushBroadcast({
+      recipientId: recipient.id,
+      payload: this.toDatabase(),
+    })
+  }
+}
+
+/** Re-export so callers can build channel names without reaching into
+ *  the internal broadcast module. Useful for apps that want to push
+ *  custom events from their own code (e.g. presence pings). */
+export { notificationChannel }
+
+/** @internal — reset id sequence; tests use this for stability. */
+export function _resetNotificationIdSeq(): void {
+  _idSeq = 0
+}
+
+/**
+ * Walk an `Action` instance and emit the slim `NotificationActionMeta`
+ * wire shape — the same format on transient toasts (`toMeta()`) and
+ * persisted bell rows (`toDatabase()`).
+ *
+ * Rejects Action features that don't fit a notification context:
+ *
+ *   - Modal / form-modal actions (`.schema()`, `.modal*()`,
+ *     `.slideOver()`) — notifications aren't Resource pages, the modal
+ *     dispatcher's row/page context isn't available.
+ *   - Submit-button actions (`.submit()` / `.formField()`) — there's no
+ *     surrounding `<form>` to submit.
+ *   - Bulk placement — notifications are per-row, no `records[]`.
+ *   - Visibility callbacks (`.visible(fn)` / `.disabled(fn)`) — need
+ *     a render context the notification doesn't carry. Use the
+ *     server-side filter (only emit the action when relevant) instead.
+ *
+ * `transient: true` (used by `toMeta()`) tolerates closure handlers —
+ * they dispatch through the current page's `_action/:name` endpoint.
+ * `transient: false` (used by `toDatabase()`) rejects closures with a
+ * clear message pointing at the named-registry pattern.
+ */
+export function serializeForNotification(
+  action: Action,
+  opts: { transient: boolean },
+): NotificationActionMeta {
+  // Reject incompatible Action features at config time (works on both
+  // transports; the row's wire shape can't carry these even if we
+  // wanted it to).
+  if (action.hasModal()) {
+    throw new Error(
+      `[Pilotiq] Notification.actions: action "${action.name}" carries a modal-form ` +
+      `(.schema() / .modalHeading() / .slideOver()). Modal-form actions aren't supported ` +
+      `inside notifications in v1 — drop the modal or move the workflow to a Resource action.`,
+    )
+  }
+  if (action.isSubmit()) {
+    throw new Error(
+      `[Pilotiq] Notification.actions: action "${action.name}" is a submit button (.submit()). ` +
+      `Notifications have no surrounding <form>; use .url() / .method() / .handler() instead.`,
+    )
+  }
+  if (action.getPlacement() === 'bulk') {
+    throw new Error(
+      `[Pilotiq] Notification.actions: action "${action.name}" is bulk-placed. ` +
+      `Notifications are per-row — bulk placement has no recipient context.`,
+    )
+  }
+
+  const handlerFn   = action.getHandler()
+  const handlerName = action.getHandlerName()
+  const href        = action.getHref()
+  const method      = action.getMethod()
+  const actionUrl   = action.getActionUrl()
+
+  // Closure handler on a persisted row — reject loudly. The caller
+  // explicitly asked to `sendToDatabase`; silently dropping the action
+  // would surprise.
+  if (!opts.transient && handlerFn && !handlerName) {
+    throw new Error(
+      `[Pilotiq] Notification.actions: action "${action.name}" has a closure handler ` +
+      `but is being persisted via .sendToDatabase(). Closures don't survive serialization. ` +
+      `Use Pilotiq.notificationHandlers({ '${action.name}': async ctx => … }) and call ` +
+      `Action.handler('${action.name}') instead.`,
+    )
+  }
+
+  const meta: NotificationActionMeta = {
+    name:  action.name,
+    label: action.getLabel(),
+  }
+  // Dispatch mode — exactly one of url / post / handler. Precedence
+  // matches the Action surface: explicit href wins over method-form.
+  if (href) {
+    meta.url = href
+  } else if (method && actionUrl) {
+    meta.post = actionUrl
+  } else if (handlerName) {
+    meta.handler = handlerName
+    const payload = action.getPayload()
+    if (Object.keys(payload).length > 0) meta.payload = payload
+  } else if (handlerFn && opts.transient) {
+    // Transient toast with a closure handler — defer dispatch to the
+    // current page's `_action/:name`. Wire shape doesn't carry the
+    // closure itself; the toaster reads `Notification.getActions()`
+    // for closures and falls back to the page-level dispatch URL.
+    meta.handler = action.name
+  } else {
+    throw new Error(
+      `[Pilotiq] Notification.actions: action "${action.name}" has no dispatch target. ` +
+      `Set one of .url() / .method().action() / .handler(closureOrName).`,
+    )
+  }
+
+  // Chrome — copy through the subset that makes sense in a strip.
+  const color    = action.getColor()
+  const icon     = action.getIcon()
+  const outlined = action.isOutlined()
+  const size     = action.getSize()
+  if (color    !== undefined) meta.color           = color
+  if (icon     !== undefined) meta.icon            = icon
+  if (outlined)               meta.outlined        = true
+  if (size     !== undefined) meta.size            = size
+  if (action.isOpenUrlInNewTab()) meta.openUrlInNewTab = true
+  if (action.isMarkAsReadOnFire()) meta.markAsRead = true
+
+  return meta
+}

package/src/notifications/broadcast.test.ts

@@ -0,0 +1,110 @@
+/**
+ * Broadcast push helpers — unit tests. The real `@rudderjs/broadcast`
+ * package isn't a peer dep here, so we inject a fake module via the
+ * `_setTestBroadcast` seam in `broadcast.ts` and assert call shape.
+ */
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  push,
+  notificationChannel,
+  NOTIFICATION_CREATED_EVENT,
+  _setTestBroadcast,
+} from './broadcast.js'
+import { Notification } from './Notification.js'
+
+interface BroadcastCall {
+  channel: string
+  event:   string
+  data:    unknown
+}
+
+function makeFakeBroadcast() {
+  const calls: BroadcastCall[] = []
+  return {
+    calls,
+    mod: {
+      broadcast(channel: string, event: string, data: unknown) {
+        calls.push({ channel, event, data })
+      },
+    },
+  }
+}
+
+describe('notificationChannel()', () => {
+  it('builds the private channel name with the user id', () => {
+    assert.equal(notificationChannel(1),    'private-pilotiq-notifications.1')
+    assert.equal(notificationChannel('42'), 'private-pilotiq-notifications.42')
+  })
+
+  it('coerces non-string ids', () => {
+    assert.equal(notificationChannel(123n as unknown as number), 'private-pilotiq-notifications.123')
+  })
+})
+
+describe('push()', () => {
+  afterEach(() => _setTestBroadcast(undefined))
+
+  it('returns ok:false when broadcast module is unavailable', async () => {
+    _setTestBroadcast(null)
+    const r = await push({ recipientId: 1, payload: { id: 'n1', title: 'X' } })
+    assert.equal(r.ok, false)
+  })
+
+  it('calls broadcast() with the default channel + event', async () => {
+    const fake = makeFakeBroadcast()
+    _setTestBroadcast(fake.mod)
+    const r = await push({ recipientId: 1, payload: { id: 'n1', title: 'X' } })
+    assert.equal(r.ok, true)
+    assert.equal(fake.calls.length, 1)
+    assert.equal(fake.calls[0]!.channel, 'private-pilotiq-notifications.1')
+    assert.equal(fake.calls[0]!.event,   NOTIFICATION_CREATED_EVENT)
+    assert.deepEqual(fake.calls[0]!.data, { id: 'n1', title: 'X' })
+  })
+
+  it('honors channel + event overrides', async () => {
+    const fake = makeFakeBroadcast()
+    _setTestBroadcast(fake.mod)
+    await push({
+      recipientId: 1,
+      channel: 'public-firehose',
+      event:   'custom',
+      payload: {},
+    })
+    assert.equal(fake.calls[0]!.channel, 'public-firehose')
+    assert.equal(fake.calls[0]!.event,   'custom')
+  })
+
+  it('returns ok:false when broadcast() throws', async () => {
+    _setTestBroadcast({
+      broadcast() { throw new Error('nope') },
+    })
+    const r = await push({ recipientId: 1, payload: {} })
+    assert.equal(r.ok, false)
+  })
+})
+
+describe('Notification.broadcast(recipient)', () => {
+  beforeEach(() => _setTestBroadcast(null))
+  afterEach(() => _setTestBroadcast(undefined))
+
+  it('soft-fails when @rudderjs/broadcast isn\'t installed', async () => {
+    const r = await Notification.make('Hi').info().broadcast({ id: 1 })
+    assert.equal(r.ok, false)
+  })
+
+  it('pushes the toDatabase() payload on the user\'s private channel', async () => {
+    const fake = makeFakeBroadcast()
+    _setTestBroadcast(fake.mod)
+    await Notification.make('Hi').success().body('Body').url('/x').broadcast({ id: 99 })
+    assert.equal(fake.calls.length, 1)
+    assert.equal(fake.calls[0]!.channel, 'private-pilotiq-notifications.99')
+    assert.equal(fake.calls[0]!.event,   NOTIFICATION_CREATED_EVENT)
+    const data = fake.calls[0]!.data as Record<string, unknown>
+    assert.equal(data['type'],  'success')
+    assert.equal(data['title'], 'Hi')
+    assert.equal(data['body'],  'Body')
+    assert.equal(data['url'],   '/x')
+  })
+})