@strav/notification 1.0.0-alpha.25

package/README.md

@@ -0,0 +1,36 @@
+# @strav/notification
+
+Multi-channel notifications for Strav 1.0. One fluent surface (`notifications.send(notifiable, notification)`) that fan-outs to ≥1 channel drivers — mail / database / log / webhook / broadcast today; Discord / SMS channels in follow-up slices.
+
+```ts
+import { BaseNotification, type Notifiable, NotificationManager } from '@strav/notification'
+
+class InvoicePaid extends BaseNotification {
+  override via(): readonly string[] {
+    return ['mail', 'database']
+  }
+  toMail(notifiable: Notifiable) {
+    return { to: [notifiable.email], subject: 'Invoice paid', text: '...' }
+  }
+  toDatabase(_notifiable: Notifiable) {
+    return { invoiceId: 'inv_42', amount: 4900 }
+  }
+}
+
+const notifications = container.resolve(NotificationManager)
+await notifications.send(alice, new InvoicePaid())
+```
+
+Canonical docs live in [`docs/notification/README.md`](../../docs/notification/README.md).
+
+## What ships in v1
+
+| Channel | Subpath | Notes |
+|---|---|---|
+| Mail | `@strav/notification/mail` | Wraps `@strav/mail`'s `MailManager.send`. |
+| Database | `@strav/notification/database` | Append-only `notification` ledger + `NotificationRepository` (`unread()` / `markAsRead()`). Tenanted variant under `@strav/notification/tenanted`. |
+| Log | `@strav/notification/log` | Routes through `@strav/kernel`'s `Logger`. Useful for dev + tests. |
+| Webhook | `@strav/notification/webhook` | POSTs a signed JSON envelope (`x-strav-signature: sha256=...` over `${timestamp}.${body}`) to a configured endpoint. Exports `verifyWebhookSignature` for receiver-side validation. |
+| Broadcast | `@strav/notification/broadcast` | Publishes a `BroadcastEvent` via `@strav/broadcast`'s `Broadcaster`. Pairs with `router.sse(...)` so live UI clients receive the same dispatch. |
+
+Deferred: Discord, SMS channel drivers. Apps register custom channels via `manager.extend(name, factory)`.

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@strav/notification",
+  "version": "1.0.0-alpha.25",
+  "description": "Strav multi-channel notifications — NotificationManager fan-out across channel drivers (mail / database / log / webhook / broadcast). Manager+drivers shape; new channels register via `manager.extend(name, factory)`. Discord / SMS channels ship in follow-up slices.",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./mail": "./src/drivers/mail/index.ts",
+    "./database": "./src/drivers/database/index.ts",
+    "./log": "./src/drivers/log/index.ts",
+    "./webhook": "./src/drivers/webhook/index.ts",
+    "./broadcast": "./src/drivers/broadcast/index.ts",
+    "./tenanted": "./src/drivers/database/tenanted/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@strav/kernel": "1.0.0-alpha.25"
+  },
+  "peerDependencies": {
+    "@strav/broadcast": "1.0.0-alpha.25",
+    "@strav/database": "1.0.0-alpha.25",
+    "@strav/mail": "1.0.0-alpha.25",
+    "@types/bun": ">=1.3.14"
+  },
+  "peerDependenciesMeta": {
+    "@strav/broadcast": {
+      "optional": true
+    },
+    "@strav/database": {
+      "optional": true
+    },
+    "@strav/mail": {
+      "optional": true
+    }
+  },
+  "devDependencies": null
+}

package/src/drivers/broadcast/broadcast_config.ts

@@ -0,0 +1,21 @@
+/**
+ * Vendor-specific config shape for the broadcast channel.
+ * Discriminator `driver: 'broadcast'` selects this factory.
+ *
+ * The channel has no provider-specific knobs — routing is decided
+ * per-notification by `toBroadcast(notifiable)`'s returned `channel`
+ * field. Apps using multiple broadcast backplanes (rare) wire two
+ * channels at the manager level:
+ *
+ *   broadcast:     { driver: 'broadcast' }
+ *   broadcast.alt: { driver: 'broadcast' }
+ *
+ * …and override `via()` on the notification to pick between them.
+ * The shared `Broadcaster` token is resolved from the container.
+ */
+
+import type { ChannelConfig } from '../../notification_config.ts'
+
+export interface BroadcastChannelConfig extends ChannelConfig {
+  driver: 'broadcast'
+}

package/src/drivers/broadcast/broadcast_notification_driver.ts

@@ -0,0 +1,105 @@
+/**
+ * `BroadcastNotificationDriver` — fans a notification onto the
+ * configured `Broadcaster`. Reads
+ * `notification.toBroadcast(notifiable): BroadcastNotificationPayload`
+ * for the channel routing + event body.
+ *
+ * Skips delivery (returns `{ delivered: false }` without throwing) when
+ * the hook is absent — same opt-out semantics as the mail / webhook
+ * drivers.
+ *
+ * Depends on `@strav/broadcast` (peer, optional on `@strav/notification`).
+ * Apps that want this driver register `BroadcastNotificationProvider`
+ * AND have a `BroadcastProvider` (or `PostgresBroadcastProvider`)
+ * binding `Broadcaster` in the container.
+ */
+
+import type { Broadcaster } from '@strav/broadcast'
+import type { Notifiable } from '../../notifiable.ts'
+import type { BaseNotification } from '../../notification.ts'
+import type { NotificationDriver } from '../../notification_driver.ts'
+import { NotificationDeliveryError } from '../../notification_error.ts'
+import type { NotificationContext, NotificationDeliveryResult } from '../../types.ts'
+
+/**
+ * What `toBroadcast(notifiable)` returns. `channel` is the target
+ * pub/sub channel name; `event` defaults to the notification class
+ * name when omitted; `data` is the JSON-serialisable payload.
+ */
+export interface BroadcastNotificationPayload {
+  channel: string
+  event?: string
+  data: unknown
+}
+
+interface BroadcastCapableNotification extends BaseNotification {
+  toBroadcast?(
+    notifiable: Notifiable,
+  ): BroadcastNotificationPayload | Promise<BroadcastNotificationPayload>
+}
+
+export interface BroadcastNotificationDriverOptions {
+  name: string
+  broadcaster: Broadcaster
+}
+
+export class BroadcastNotificationDriver implements NotificationDriver {
+  readonly name: string
+  private readonly broadcaster: Broadcaster
+
+  constructor(options: BroadcastNotificationDriverOptions) {
+    this.name = options.name
+    this.broadcaster = options.broadcaster
+  }
+
+  async send(
+    notifiable: Notifiable,
+    notification: BaseNotification,
+    context: NotificationContext,
+  ): Promise<NotificationDeliveryResult> {
+    const hook = (notification as BroadcastCapableNotification).toBroadcast
+    if (typeof hook !== 'function') {
+      return { channel: this.name, delivered: false }
+    }
+
+    let payload: BroadcastNotificationPayload
+    try {
+      payload = await hook.call(notification, notifiable)
+    } catch (cause) {
+      throw new NotificationDeliveryError(
+        `BroadcastNotificationDriver: toBroadcast() threw for channel "${this.name}".`,
+        {
+          context: {
+            channel: this.name,
+            notifiableId: notifiable.id,
+            notification: notification.constructor.name,
+          },
+          cause,
+        },
+      )
+    }
+
+    try {
+      await this.broadcaster.publish(payload.channel, {
+        id: context.id,
+        event: payload.event ?? notification.constructor.name,
+        data: payload.data,
+      })
+    } catch (cause) {
+      throw new NotificationDeliveryError(
+        `BroadcastNotificationDriver: publish failed on broadcast channel "${payload.channel}".`,
+        {
+          context: {
+            channel: this.name,
+            broadcastChannel: payload.channel,
+            notifiableId: notifiable.id,
+            notification: notification.constructor.name,
+          },
+          cause,
+        },
+      )
+    }
+
+    return { channel: this.name, delivered: true, reference: context.id }
+  }
+}

package/src/drivers/broadcast/broadcast_notification_provider.ts

@@ -0,0 +1,18 @@
+import { Broadcaster } from '@strav/broadcast'
+import { type Application, ServiceProvider } from '@strav/kernel'
+import { NotificationManager } from '../../notification_manager.ts'
+import { BroadcastNotificationDriver } from './broadcast_notification_driver.ts'
+
+export class BroadcastNotificationProvider extends ServiceProvider {
+  override readonly name = 'notification.broadcast'
+  override readonly dependencies = ['notification', 'broadcast']
+
+  override async boot(app: Application): Promise<void> {
+    const manager = app.resolve(NotificationManager)
+    const broadcaster = app.resolve(Broadcaster)
+    manager.extend(
+      'broadcast',
+      ({ instanceName }) => new BroadcastNotificationDriver({ name: instanceName, broadcaster }),
+    )
+  }
+}

package/src/drivers/broadcast/index.ts

@@ -0,0 +1,7 @@
+export type { BroadcastChannelConfig } from './broadcast_config.ts'
+export {
+  BroadcastNotificationDriver,
+  type BroadcastNotificationDriverOptions,
+  type BroadcastNotificationPayload,
+} from './broadcast_notification_driver.ts'
+export { BroadcastNotificationProvider } from './broadcast_notification_provider.ts'

package/src/drivers/database/apply_notification_migration.ts

@@ -0,0 +1,44 @@
+/**
+ * `applyNotificationMigration` — emit DDL for the `notification`
+ * table plus a `(notifiable_id, read_at)` lookup index used by
+ * `NotificationRepository.unread(...)`.
+ *
+ * Non-tenanted by default (framework policy: multitenancy is opt-in).
+ * Apps that need per-tenant scoping use
+ * `applyTenantedNotificationMigration` from
+ * `@strav/notification/tenanted` instead.
+ *
+ * ```ts
+ * export const migration: Migration = {
+ *   name: '20260601000000_create_notification',
+ *   async up(db) {
+ *     await applyNotificationMigration(db, { registry })
+ *   },
+ *   async down(db) {
+ *     await db.execute(emitDropTable(notificationSchema.name).sql)
+ *   },
+ * }
+ * ```
+ */
+
+import { type DatabaseExecutor, emitCreateTable, type SchemaRegistry } from '@strav/database'
+import { notificationSchema } from './schemas/notification_schema.ts'
+
+export interface ApplyNotificationMigrationOptions {
+  registry: SchemaRegistry
+}
+
+export async function applyNotificationMigration(
+  db: DatabaseExecutor,
+  options: ApplyNotificationMigrationOptions,
+): Promise<void> {
+  const { registry } = options
+  await db.execute(emitCreateTable(notificationSchema, { registry }).sql)
+  // Badge / inbox lookup — "all unread for a recipient" is the
+  // hottest read path. Partial index keeps it tight.
+  await db.execute(
+    `CREATE INDEX IF NOT EXISTS "idx_notification_notifiable_unread"
+     ON "${notificationSchema.name}" ("notifiable_id", "created_at" DESC)
+     WHERE "read_at" IS NULL`,
+  )
+}

package/src/drivers/database/database_config.ts

@@ -0,0 +1,7 @@
+import type { ChannelConfig } from '../../notification_config.ts'
+
+export interface DatabaseChannelConfig extends ChannelConfig {
+  driver: 'database'
+  /** Force tenanted variant. Default: non-tenanted (framework policy: opt-in). */
+  tenanted?: boolean
+}

package/src/drivers/database/database_notification_driver.ts

@@ -0,0 +1,72 @@
+/**
+ * `DatabaseNotificationDriver` — persists every dispatched notification
+ * into the `notification` ledger via `NotificationRepository.record`.
+ *
+ * Reads `notification.toDatabase(notifiable)` for the per-notification
+ * payload. When the hook is absent, the driver returns
+ * `{ delivered: false }` with no error — the channel chooses not to
+ * service notifications that don't model themselves as persistable.
+ *
+ * Tenanted variant uses `TenantedNotificationRepository` from
+ * `@strav/notification/tenanted` — the wiring is identical apart
+ * from the repository class.
+ */
+
+import type { Notifiable } from '../../notifiable.ts'
+import type { BaseNotification } from '../../notification.ts'
+import type { NotificationDriver } from '../../notification_driver.ts'
+import { NotificationDeliveryError } from '../../notification_error.ts'
+import type { NotificationContext, NotificationDeliveryResult } from '../../types.ts'
+import type { NotificationRepository } from './notification_repository.ts'
+
+interface PersistableNotification extends BaseNotification {
+  toDatabase?(notifiable: Notifiable): Record<string, unknown> | Promise<Record<string, unknown>>
+}
+
+export interface DatabaseNotificationDriverOptions {
+  name: string
+  repository: NotificationRepository
+}
+
+export class DatabaseNotificationDriver implements NotificationDriver {
+  readonly name: string
+  private readonly repository: NotificationRepository
+
+  constructor(options: DatabaseNotificationDriverOptions) {
+    this.name = options.name
+    this.repository = options.repository
+  }
+
+  async send(
+    notifiable: Notifiable,
+    notification: BaseNotification,
+    context: NotificationContext,
+  ): Promise<NotificationDeliveryResult> {
+    const hook = (notification as PersistableNotification).toDatabase
+    if (typeof hook !== 'function') {
+      return { channel: this.name, delivered: false }
+    }
+    try {
+      const data = await hook.call(notification, notifiable)
+      const record = await this.repository.record({
+        id: context.id,
+        notifiable,
+        type: notification.constructor.name,
+        data,
+      })
+      return { channel: this.name, delivered: true, reference: record.id }
+    } catch (cause) {
+      throw new NotificationDeliveryError(
+        `DatabaseNotificationDriver: persist failed for channel "${this.name}".`,
+        {
+          context: {
+            channel: this.name,
+            notifiableId: notifiable.id,
+            notification: notification.constructor.name,
+          },
+          cause,
+        },
+      )
+    }
+  }
+}

package/src/drivers/database/database_notification_provider.ts

@@ -0,0 +1,44 @@
+/**
+ * ServiceProvider that registers the database-channel factory on the
+ * `NotificationManager` and the `NotificationRepository` as a
+ * container singleton.
+ *
+ * Apps include this AFTER `NotificationProvider` + `DatabaseProvider`.
+ * The factory reads each channel's `tenanted` flag at construction
+ * time — but the tenanted-repository wiring is the app's job
+ * (apps that want it import from `@strav/notification/tenanted` and
+ * register the tenanted-repository binding themselves, same pattern
+ * as `@strav/social/tenanted`).
+ */
+
+import { PostgresDatabase, SchemaRegistry } from '@strav/database'
+import { type Application, EventBus, ServiceProvider } from '@strav/kernel'
+import { NotificationManager } from '../../notification_manager.ts'
+import { DatabaseNotificationDriver } from './database_notification_driver.ts'
+import { NotificationRepository } from './notification_repository.ts'
+
+export class DatabaseNotificationProvider extends ServiceProvider {
+  override readonly name = 'notification.database'
+  override readonly dependencies = ['notification', 'database']
+
+  override register(app: Application): void {
+    app.singleton(
+      NotificationRepository,
+      (c) =>
+        new NotificationRepository({
+          db: c.resolve(PostgresDatabase),
+          events: c.resolve(EventBus),
+          registry: c.resolve(SchemaRegistry),
+        }),
+    )
+  }
+
+  override async boot(app: Application): Promise<void> {
+    const manager = app.resolve(NotificationManager)
+    const repository = app.resolve(NotificationRepository)
+    manager.extend(
+      'database',
+      ({ instanceName }) => new DatabaseNotificationDriver({ name: instanceName, repository }),
+    )
+  }
+}

package/src/drivers/database/index.ts

@@ -0,0 +1,16 @@
+export {
+  type ApplyNotificationMigrationOptions,
+  applyNotificationMigration,
+} from './apply_notification_migration.ts'
+export type { DatabaseChannelConfig } from './database_config.ts'
+export {
+  DatabaseNotificationDriver,
+  type DatabaseNotificationDriverOptions,
+} from './database_notification_driver.ts'
+export { DatabaseNotificationProvider } from './database_notification_provider.ts'
+export { NotificationRecord } from './notification_record.ts'
+export {
+  NotificationRepository,
+  type RecordInput,
+} from './notification_repository.ts'
+export { notificationSchema } from './schemas/notification_schema.ts'

package/src/drivers/database/notification_record.ts

@@ -0,0 +1,22 @@
+/**
+ * `NotificationRecord` — typed row of the `notification` ledger.
+ * Apps subclass when they want a per-notifiable model (e.g. extend
+ * with `notifiable_relation` helpers); the framework only needs the
+ * generic shape.
+ */
+
+import { Model } from '@strav/database'
+import { notificationSchema } from './schemas/notification_schema.ts'
+
+export class NotificationRecord extends Model {
+  static override readonly schema = notificationSchema
+
+  id!: string
+  notifiable_id!: string
+  notifiable_type!: string
+  type!: string
+  data!: Record<string, unknown>
+  read_at!: Date | null
+  created_at!: Date
+  updated_at!: Date
+}

package/src/drivers/database/notification_repository.ts

@@ -0,0 +1,67 @@
+/**
+ * `NotificationRepository` — domain helpers on top of the generic
+ * `Repository<NotificationRecord>` surface. The methods apps actually
+ * reach for:
+ *
+ *   - `record({ id, notifiable, type, data })` — insert a fresh row.
+ *     Called by `DatabaseNotificationDriver.send()`; apps usually
+ *     don't invoke this directly.
+ *
+ *   - `unread(notifiable)` — every unread row for one recipient,
+ *     newest first. Apps render a badge from `unread(...).length`.
+ *
+ *   - `markAsRead(id)` — flip `read_at` from null to now. Returns
+ *     the updated row.
+ */
+
+import { quoteIdent, Repository } from '@strav/database'
+import type { Notifiable } from '../../notifiable.ts'
+import { NotificationRecord } from './notification_record.ts'
+import { notificationSchema } from './schemas/notification_schema.ts'
+
+export interface RecordInput {
+  /** Notification ULID (matches `NotificationContext.id`). */
+  id: string
+  notifiable: Notifiable
+  /** Notification class name (`notification.constructor.name`). */
+  type: string
+  /** jsonb payload from `notification.toDatabase(notifiable)`. */
+  data: Record<string, unknown>
+}
+
+export class NotificationRepository extends Repository<NotificationRecord> {
+  static override readonly schema = notificationSchema
+  static override readonly model = NotificationRecord
+
+  async record(input: RecordInput): Promise<NotificationRecord> {
+    const now = new Date()
+    return this.create({
+      id: input.id,
+      notifiable_id: String(input.notifiable.id),
+      notifiable_type: input.notifiable.notifiableType ?? 'Notifiable',
+      type: input.type,
+      data: input.data,
+      read_at: null,
+      created_at: now,
+      updated_at: now,
+    } as Partial<NotificationRecord>)
+  }
+
+  async unread(notifiable: Notifiable): Promise<NotificationRecord[]> {
+    const table = quoteIdent(notificationSchema.name)
+    const rows = await this.db.query<Record<string, unknown>>(
+      `SELECT * FROM ${table}
+       WHERE "notifiable_id" = $1 AND "read_at" IS NULL
+       ORDER BY "created_at" DESC`,
+      [String(notifiable.id)],
+    )
+    return rows.map((r) => this.hydrate(r))
+  }
+
+  async markAsRead(id: string): Promise<NotificationRecord | undefined> {
+    const found = await this.findMany([id])
+    const model = found[0]
+    if (!model) return undefined
+    return this.update(model, { read_at: new Date() } as Partial<NotificationRecord>)
+  }
+}

package/src/drivers/database/schemas/notification_schema.ts

@@ -0,0 +1,44 @@
+/**
+ * `notificationSchema` — append-only ledger of dispatched
+ * notifications. **Non-tenanted by default** (framework policy:
+ * multitenancy is opt-in). Apps that need per-tenant scoping import
+ * `tenantedNotificationSchema` from `@strav/notification/tenanted`
+ * instead.
+ *
+ * One row per `(notifiable, notification, dispatch)` triple. The
+ * `read_at` column lets apps render an "unread" badge by counting
+ * rows where it's null.
+ *
+ * Columns:
+ *
+ *   - `id`               ULID PK — matches `NotificationContext.id`
+ *                        so a notification's persisted row, log line,
+ *                        and any downstream channel references all
+ *                        share the same correlation id.
+ *   - `notifiable_id`    Recipient's domain id (string). Apps store
+ *                        ulids, uuids, ints — all fit as strings.
+ *   - `notifiable_type`  Recipient class name (free-form). Apps
+ *                        with one Notifiable model (e.g. `User`)
+ *                        leave it constant; multi-Notifiable apps
+ *                        use it to dispatch resolution.
+ *   - `type`             Notification class name. Apps render by
+ *                        type (`new_message`, `invoice_paid`, …).
+ *   - `data`             jsonb payload from `toDatabase(notifiable)`.
+ *   - `read_at`          When the recipient marked this read.
+ *                        Null = unread.
+ *   - `created_at`       Dispatch timestamp.
+ *   - `updated_at`       Last touched (mark-as-read).
+ */
+
+import { Archetype, defineSchema } from '@strav/database'
+
+export const notificationSchema = defineSchema('notification', Archetype.Entity, (t) => {
+  t.id()
+  t.string('notifiable_id').max(64).notNull()
+  t.string('notifiable_type').max(128).notNull()
+  t.string('type').max(128).notNull()
+  t.json('data').notNull().default({})
+  t.timestamp('read_at').nullable()
+  t.timestamp('created_at').notNull()
+  t.timestamp('updated_at').notNull()
+})

package/src/drivers/database/tenanted/apply_tenanted_notification_migration.ts

@@ -0,0 +1,19 @@
+import { type DatabaseExecutor, emitCreateTable, type SchemaRegistry } from '@strav/database'
+import { tenantedNotificationSchema } from './schemas/tenanted_notification_schema.ts'
+
+export interface ApplyTenantedNotificationMigrationOptions {
+  registry: SchemaRegistry
+}
+
+export async function applyTenantedNotificationMigration(
+  db: DatabaseExecutor,
+  options: ApplyTenantedNotificationMigrationOptions,
+): Promise<void> {
+  const { registry } = options
+  await db.execute(emitCreateTable(tenantedNotificationSchema, { registry }).sql)
+  await db.execute(
+    `CREATE INDEX IF NOT EXISTS "idx_notification_notifiable_unread"
+     ON "${tenantedNotificationSchema.name}" ("tenant_id", "notifiable_id", "created_at" DESC)
+     WHERE "read_at" IS NULL`,
+  )
+}

package/src/drivers/database/tenanted/index.ts

@@ -0,0 +1,10 @@
+export {
+  type ApplyTenantedNotificationMigrationOptions,
+  applyTenantedNotificationMigration,
+} from './apply_tenanted_notification_migration.ts'
+export { tenantedNotificationSchema } from './schemas/tenanted_notification_schema.ts'
+export { TenantedNotificationRecord } from './tenanted_notification_record.ts'
+export {
+  type RecordInput as TenantedRecordInput,
+  TenantedNotificationRepository,
+} from './tenanted_notification_repository.ts'

package/src/drivers/database/tenanted/schemas/tenanted_notification_schema.ts

@@ -0,0 +1,28 @@
+/**
+ * `tenantedNotificationSchema` — opt-in tenant-scoped variant of the
+ * notification ledger. Same columns as the default schema, with
+ * `tenanted: true` so `@strav/database` injects the `tenant_id` FK
+ * + RLS policy.
+ *
+ * Apps register this schema instead of the default. The matching
+ * `Model` + `Repository` + `applyTenantedNotificationMigration` ship
+ * here too so the wiring stays consistent.
+ */
+
+import { Archetype, defineSchema } from '@strav/database'
+
+export const tenantedNotificationSchema = defineSchema(
+  'notification',
+  Archetype.Entity,
+  (t) => {
+    t.id()
+    t.string('notifiable_id').max(64).notNull()
+    t.string('notifiable_type').max(128).notNull()
+    t.string('type').max(128).notNull()
+    t.json('data').notNull().default({})
+    t.timestamp('read_at').nullable()
+    t.timestamp('created_at').notNull()
+    t.timestamp('updated_at').notNull()
+  },
+  { tenanted: true },
+)

package/src/drivers/database/tenanted/tenanted_notification_record.ts

@@ -0,0 +1,15 @@
+import { Model } from '@strav/database'
+import { tenantedNotificationSchema } from './schemas/tenanted_notification_schema.ts'
+
+export class TenantedNotificationRecord extends Model {
+  static override readonly schema = tenantedNotificationSchema
+
+  id!: string
+  notifiable_id!: string
+  notifiable_type!: string
+  type!: string
+  data!: Record<string, unknown>
+  read_at!: Date | null
+  created_at!: Date
+  updated_at!: Date
+}