@pilotiq/pilotiq 0.24.1 → 0.24.3

package/src/notifications/Notification.test.ts

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

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

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