notey 0.1.0

data/lib/notey.rb

@@ -0,0 +1,166 @@
+require "notey/version"
+require "notey/engine"
+require "notey/catalog"
+require "notey/channels"
+require "notey/destinations"
+require "notey/event_delivery"
+require "notey/inbox"
+require "notey/digest_run"
+require "notey/records_attempt"
+
+module Notey
+  ALWAYS_ON_DELIVERY = { "email" => "Notey::Email", "in_app" => "Notey::InApp" }.freeze
+  ALWAYS_ON = ALWAYS_ON_DELIVERY.keys.freeze
+
+  RegisteredChannel = Struct.new(:name, :delivery_method, :addressed, keyword_init: true) do
+    def addressed?
+      addressed == true
+    end
+  end
+
+  class UndeclaredType < StandardError; end
+  class UndeliverableChannel < StandardError; end
+  class MissingSender < StandardError; end
+
+  class << self
+    attr_writer :notification_url, :mailer_sender
+  end
+
+  def self.mailer_sender
+    @mailer_sender
+  end
+
+  def self.notification_url
+    @notification_url || ->(notification) { nil }
+  end
+
+  def self.register_notifier(notifier)
+    notifiers << notifier unless notifiers.include?(notifier)
+  end
+
+  def self.notifiers
+    @notifiers ||= []
+  end
+
+  def self.channels
+    registered_channels.map(&:name)
+  end
+
+  def self.notification_types
+    notifiers.filter_map(&:notey_notification_type).uniq
+  end
+
+  def self.default_channels
+    channels & ALWAYS_ON
+  end
+
+  def self.channel(name, delivery_method: nil, addressed: false)
+    host_channels << RegisteredChannel.new(
+      name: name.to_s, delivery_method: delivery_method, addressed: addressed
+    )
+  end
+
+  def self.registered_channels
+    always_on_channels + host_channels
+  end
+
+  def self.addressed_channels
+    registered_channels.select(&:addressed?).map(&:name)
+  end
+
+  def self.always_on_channels
+    ALWAYS_ON_DELIVERY.filter_map do |name, delivery_method|
+      next if host_channels.any? { |channel| channel.name == name }
+
+      RegisteredChannel.new(name: name, delivery_method: delivery_method)
+    end
+  end
+
+  def self.host_channels
+    @host_channels ||= []
+  end
+
+  def self.forget_notifiers
+    @notifiers = []
+  end
+
+  def self.check!
+    return if catalog.notifications.empty?
+
+    check_declared_types!
+    check_deliverable_channels!
+    check_sender!
+  end
+
+  def self.check_sender!
+    return if mailer_sender.present?
+
+    raise MissingSender, "notey sends digests by email and no mailer_sender is set"
+  end
+
+  def self.check_deliverable_channels!
+    delivered = notifiers.flat_map { |notifier| notifier.delivery_methods.keys.map(&:to_s) }.uniq
+
+    (catalog.channels - delivered).each do |channel|
+      raise UndeliverableChannel, "the catalog offers the channel #{channel}, which no notifier delivers on"
+    end
+  end
+
+  def self.check_declared_types!
+    notifiers.each do |notifier|
+      notification_type = notifier.notey_notification_type
+      next if notification_type.nil? || catalog.declared?(notification_type)
+
+      raise UndeclaredType,
+        "#{notifier} declares the notification type #{notification_type}, which the catalog does not hold"
+    end
+  end
+
+  def self.destination_address(channel)
+    -> { Destinations.for(event.account_id, channel, member: recipient)&.address }
+  end
+
+  def self.addressed(channel)
+    -> { Destinations.for(event.account_id, channel, member: recipient).present? }
+  end
+
+  def self.deliver_on(event_name, notifier)
+    event_notifiers[event_name.to_s] = notifier
+  end
+
+  def self.notifier_for(event_name)
+    event_notifiers[event_name.to_s]
+  end
+
+  def self.event_notifiers
+    @event_notifiers ||= {}
+  end
+
+  def self.catalog(&block)
+    @catalog ||= Catalog.new
+    @catalog.instance_eval(&block) if block
+    @catalog
+  end
+
+  def self.wanted(notification_type, on:)
+    sends(notification_type, on: on)
+  end
+
+  def self.sends(notification_type, on:, addressed: false)
+    lambda do
+      decision = Channels.decision_for(recipient, notification_type, account_id: event.account_id)
+
+      next false unless decision.window == "immediate" && decision.channels.include?(on.to_s)
+      next true unless addressed
+
+      Destinations.for(event.account_id, on, member: recipient).present?
+    end
+  end
+
+  def self.reset!
+    @catalog = nil
+    @event_notifiers = nil
+    @host_channels = nil
+    forget_notifiers
+  end
+end

data/lib/tasks/notey_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :notey do
+#   # Task goes here
+# end

data/the_local/agents/notey-develop.md

@@ -0,0 +1,178 @@
+---
+name: notey-develop
+description: Use PROACTIVELY for naming a notifier's notification type, gating a delivery method on what a person wants, addressing a channel at the account, firing a notifier from a domain event, scheduling daily and weekly digest runs, reading a person's inbox, and reading their channels and window — MUST BE USED instead of hand-rolling preference checks, per-account delivery addresses, or a digest loop.
+tools: Read, Write, Edit, Grep
+scope: notifications — a catalog of notification types, per-person per-account channel preferences, digest windows, an in-app inbox, per-account destinations, and a mapping from domain events to notifiers
+---
+
+This local follows the steps below exactly and invents no others. Where a step
+names a decision, put it to the developer and wait for an answer rather than
+picking one.
+
+## What notey is
+
+notey is the notification layer for a multi-tenant Rails app on top of Noticed.
+It holds which notification types exist, which channels each person wants in
+each account they belong to, and whether they want them as they happen or in a
+daily or weekly digest. Fire this local when a notifier is being written or
+changed, when a domain event should send one, when digests need running, or when
+the host's own code needs to read a person's notifications or their preferences.
+
+This local assumes the gem is already hooked into the app; if it is not, that is
+`notey-install`'s work and it comes first.
+
+## Interface
+
+- `notey_type` — declared inside a notifier class, names which of the catalog's
+  notification types that class delivers.
+- `Notey.wanted(type, on:)` — returns a condition for one delivery method that
+  is true only when the person wants that type on that channel and wants it
+  immediately.
+- `Notey.deliver_on(event_name, notifier)` — maps a domain event to a notifier,
+  so the notifier is delivered whenever that event fires.
+- `Notey.destination_address(channel)` — returns the stored address for the
+  channel on the account the notification belongs to.
+- `Notey.addressed(channel)` — returns a condition that is true only when that
+  account has a stored address for the channel.
+- `Notey::DigestRun` — sends one window's digests, with `call` for everyone on
+  that window and `deliver_to_member(member, account_id)` for one person in one
+  account.
+- `Notey::Inbox.for(member, account_id:)` — returns that person's notifications
+  for that account, as a relation.
+- `wants?(type, on:, account_id:)` — on the recipient model, true when that
+  person wants that type on that channel in that account.
+- `channels_for(type, account_id:)` — on the recipient model, the channels that
+  person gets that type on in that account.
+- `digest_window_for(type, account_id:)` — on the recipient model, `immediate`,
+  `daily` or `weekly` for that type in that account.
+- `Notey.reset!` — drops the catalog and the event-to-notifier mappings, for
+  tests that declare their own.
+
+## How to use it
+
+1. Name the type at the top of each notifier class:
+
+   ```ruby
+   class CommentNotifier < Noticed::Event
+     notey_type :comment
+   end
+   ```
+
+   The name must be one the catalog declares, or the app raises when it boots
+   with eager loading on. Two notifier classes may name the same type.
+
+2. Gate every delivery method on what the person wants:
+
+   ```ruby
+   deliver_by :email do |config|
+     config.if = Notey.wanted(:comment, on: :email)
+   end
+   ```
+
+   Pass the same type the class names and the channel this delivery method
+   sends on. Without this the delivery runs for everyone regardless of their
+   preferences.
+
+3. Leave the digest to notey. `Notey.wanted` is false when the person's window
+   for that type is daily or weekly, so nothing sends at the time and the
+   notification waits in their inbox for the next run. Never write a second
+   condition for the window.
+
+4. For a channel addressed at the account rather than at the person, read the
+   stored address and skip the delivery when there is none:
+
+   ```ruby
+   deliver_by :webhook, class: "WebhookDeliveryMethod" do |config|
+     config.url = Notey.destination_address(:webhook)
+     config.if = Notey.addressed(:webhook)
+   end
+   ```
+
+   Ask the developer which channels are addressed at the account, since the two
+   kinds of channel are gated differently and only they know which is which. A
+   channel can carry both conditions, one from step 2 and one from here.
+
+5. Map a domain event to a notifier in an initializer, one line per mapping:
+
+   ```ruby
+   Notey.deliver_on :comment_posted, CommentNotifier
+   ```
+
+   The subscriber sets the account from the event's payload, delivers the
+   notifier with the whole payload as its params, and puts back the account that
+   was set before. An event with no mapping delivers nothing and raises nothing.
+   Ask the developer which events map to which notifiers; nothing in the gem
+   infers it. The payload must carry `account_id`, or the notification is stored
+   against no account and never reaches an inbox.
+
+6. Schedule the digest windows. notey registers no schedule of its own, so a
+   window nobody runs never sends:
+
+   ```ruby
+   Notey::DigestRun.new(window: "daily").call
+   Notey::DigestRun.new(window: "weekly").call
+   ```
+
+   Run daily once a day and weekly once a week; those are the only two windows a
+   run accepts. Each run enqueues one job per person per account, so one failing
+   send does not stop the rest. Ask the developer what schedules recurring work
+   in this app — cron, a scheduler gem, or a platform scheduler — and at what
+   hour each window should go out.
+
+7. Read a person's notifications through the inbox rather than querying Noticed
+   directly:
+
+   ```ruby
+   Notey::Inbox.for(current_user, account_id: current_account.id)
+   ```
+
+   It returns a relation, so chain `.unread`, `.order` and `.limit` onto it. With
+   no account it returns an empty relation, never another account's rows.
+
+8. Read a person's preferences from the host's own code when the app needs to
+   branch on them:
+
+   ```ruby
+   user.wants?(:comment, on: :email, account_id: account.id)
+   user.channels_for(:comment, account_id: account.id)
+   user.digest_window_for(:comment, account_id: account.id)
+   ```
+
+   All three take the account from the current request when it is left out. All
+   three read a person's stored row for that type, and fall back to the
+   catalog's declared defaults when they have never stored one.
+
+9. In tests that declare their own notification types or event mappings, call
+   `Notey.reset!` in teardown. Both are held for the life of the process, so a
+   test that skips this leaves its types and mappings in place for every test
+   after it.
+
+## Conventions
+
+- **Every notifier names a type.** A notifier without one delivers, but no
+  digest ever includes it, because a digest picks its rows by the type the
+  notifier names.
+- **Every delivery method carries a condition.** An ungated one ignores the
+  person's channels and their window, which is the whole point of the gem.
+- **Every channel the catalog offers is delivered by some notifier.** A channel
+  the catalog offers that no notifier has a delivery method for raises when the
+  app boots with eager loading on.
+- **Only channels the catalog offers for that type may be gated on.** Gating on
+  a channel the type does not offer makes a condition that is always false, and
+  the delivery silently never runs.
+- **A digest is mailed to the person's `email`.** A recipient model without one
+  raises when its digest is sent, not when the run starts.
+- **A run sends one window once.** Overlapping runs of the same window send one
+  digest, and a send that fails releases the window so the next run picks it up
+  again.
+- **A digest covers the current day or week to the moment it runs**, so a run
+  late in the period covers everything and a second run in the same period sends
+  nothing.
+- **A digest sends nothing when there is nothing to send** — no empty mail, and
+  no row saying it went out.
+- **Notifiers, event mappings and digest schedules all belong in the host's
+  code**, never in the gem.
+- **Out of scope.** Declaring the notification types and their channels, making
+  a model a recipient, setting the current person and account, storing an
+  account's addresses, and the pages a person picks their own channels on all
+  belong to `notey-install`.

data/the_local/agents/notey-info.md

@@ -0,0 +1,80 @@
+---
+name: notey-info
+description: Use to learn what notey offers — notification types and the channels they allow, per-person per-account delivery preferences, digest windows, an in-app inbox, and per-account destinations.
+tools: Read
+scope: notifications — a catalog of notification types, per-person per-account channel preferences, digest windows, an in-app inbox, per-account destinations, and a mapping from domain events to notifiers
+---
+
+This local explains what notey is and which of its other two locals you need. It
+changes nothing and gives no steps.
+
+## What notey is
+
+notey is the notification layer for a multi-tenant Rails app, built on top of
+Noticed. Noticed delivers a notification on whatever channels a notifier
+declares. notey decides which of those channels a given person actually gets,
+per notification type and per account they belong to, stores that decision, and
+gives them screens to change it. It also scopes the in-app inbox to the account
+the person is currently in, holds notifications back into daily or weekly
+digests when that is what the person asked for, keeps a per-account address for
+channels that deliver to the account rather than to a person, and delivers a
+notification when a domain event the host publishes says to.
+
+Reach for it when the same person belongs to more than one account and wants
+different notifications in each, when notifications should arrive grouped rather
+than one at a time, or when a channel's address belongs to the account rather
+than to the person. It is not worth reaching for to send one transactional email
+to one address.
+
+## Interface
+
+The manifest declares no commands for this local, so nothing here is called.
+
+Standing notey up in a host app — the tables, the engine, the declaration of
+which notification types exist and which channels each one offers, the models
+that receive and send, and the screens people set their own preferences on — is
+the install local, `notey-install`.
+
+Building on notey once it is installed — tying a notifier to a notification
+type, delivering one when a domain event fires, holding a delivery back unless
+the person wants it on that channel, addressing a channel from the account's
+destination, reading the inbox, and running the digests — is the develop local,
+`notey-develop`.
+
+## How to use it
+
+Two questions settle which local you need. If the host app does not yet have
+notey's tables, engine and declared notification types, you are installing, and
+`notey-install` owns every step of that. If it does and you are adding a new
+notification, changing when an existing one goes out, or reading what a person
+has already been sent, you are building, and `notey-develop` owns it.
+
+## Conventions
+
+- **Notification type** — the name of one kind of notification, as a string. It
+  is the unit everything else is keyed by: a person's preference, a notifier's
+  declaration, and the channels on offer.
+- **Catalog** — the one declaration of which notification types exist, which
+  channels each offers, and which of those channels apply when a person has
+  stored nothing. A type that is not in it is unknown to notey, and a channel a
+  type does not offer cannot be stored against it.
+- **Channel** — a named way of delivering, such as email or a chat webhook. The
+  catalog offers them per notification type; a notifier is what actually
+  delivers on one.
+- **Member** — the person a preference belongs to. It is polymorphic, so a host
+  app names whichever model of its own receives notifications.
+- **Account** — the tenant. Preferences, notifications, digests and destinations
+  are all scoped to one, so the same person in two accounts has two independent
+  sets of preferences and two separate inboxes.
+- **Preference** — one stored row per member, per account, per notification
+  type, holding the channels chosen and the digest window.
+- **Digest window** — `immediate`, `daily` or `weekly`. Immediate sends as the
+  notification happens; the other two hold it for a grouped email covering the
+  current day or week.
+- **Destination** — one address per account per channel, with an optional stored
+  credential, for channels addressed at the account rather than at a person.
+- **Inbox** — the notifications a member has received within one account, which
+  is what the in-app list reads and what a digest gathers from.
+- **Notifier** — the Noticed class that delivers one notification type. Every
+  notifier names a type the catalog holds, and every channel the catalog offers
+  is delivered on by some notifier.

data/the_local/agents/notey-install.md

@@ -0,0 +1,191 @@
+---
+name: notey-install
+description: Use to hook notey into a project — installing its tables, mounting its engine, declaring the notification catalog, making a model a recipient, setting the current person and account, putting the account on Noticed's rows, supplying a notification url, checking the catalog against the notifiers, and reaching the preferences, inbox and destinations pages.
+tools: Bash, Read, Edit
+scope: notifications — a catalog of notification types, per-person per-account channel preferences, digest windows, an in-app inbox, per-account destinations, and a mapping from domain events to notifiers
+---
+
+This local follows the steps below exactly and invents no others. Where a step
+names a decision, put it to the developer and wait for an answer rather than
+picking one.
+
+## What notey is
+
+notey is the notification layer for a multi-tenant Rails app on top of Noticed.
+Hook it in when the same person belongs to more than one account and should get
+different notifications in each.
+
+## Interface
+
+- `bin/rails notey:install:migrations` — copies notey's six migrations into the
+  host's `db/migrate`.
+- `mount Notey::Engine` — in the host's `config/routes.rb`, putting notey's
+  three pages under a path the host chooses.
+- `Notey.catalog` — declares every notification type, the channels each type may
+  be delivered on, and the channels a person gets before they have stored
+  anything.
+- `Notey::Recipient` — included in the host model that receives notifications,
+  which gives that model its stored preferences.
+- `Notey::Notifier` — included in each Noticed event class, which registers it
+  so notey can check it when the app boots.
+- `Notey::Current` — holds the person and the account id for the current
+  request, and every preference read, preference save and inbox read goes
+  through it.
+- `Notey.notification_url=` — takes a lambda returning the host's own url for
+  one notification, used to link the rows in a digest email.
+- `Notey.check!` — raises when a notifier names a type the catalog does not
+  hold, or the catalog offers a channel no notifier delivers on, and notey runs
+  it itself after initialization when the app eager loads.
+- `/notey/preferences` — the page a person picks their channels and their
+  immediate, daily or weekly window on, per notification type.
+- `/notey/notifications` — the person's inbox for the account they are in, 25
+  rows newest first with an unread count, and a button that marks one read.
+- `/notey/destinations` — the page an account's address and credential are
+  stored on, one pair per channel the catalog offers.
+
+The three paths assume the engine is mounted at `/notey`; a different mount path
+moves all three.
+
+## How to use it
+
+1. Add `gem "notey"` to the host's `Gemfile` and run `bundle install`.
+
+2. Run `bin/rails notey:install:migrations` and then `bin/rails db:migrate`.
+   This creates `notey_preferences`, `notey_digests` and `notey_destinations` in
+   the host's database.
+
+3. Mount the engine in the host's `config/routes.rb`:
+
+   ```ruby
+   mount Notey::Engine => "/notey"
+   ```
+
+   Ask the developer which path to mount at if the app already has a convention
+   for engine paths, since the path prefixes all three pages.
+
+4. Declare the catalog in `config/initializers/notey.rb`:
+
+   ```ruby
+   Notey.catalog do
+     notification :comment, channels: %w[email sms], default: %w[email]
+   end
+   ```
+
+   Ask the developer which notification types exist, which channels each one
+   offers, and which of those channels apply before a person has chosen — there
+   is no default for any of the three. Declare only channels a notifier in the
+   app actually delivers on, or the app will refuse to boot at step 10.
+
+5. Include the recipient concern in the model that receives notifications:
+
+   ```ruby
+   class User < ApplicationRecord
+     include Notey::Recipient
+   end
+   ```
+
+   Ask the developer which model that is. It must respond to `email`, because
+   that is the address a digest is sent to.
+
+6. Set the current person and account on every request, in the host's
+   `ApplicationController`:
+
+   ```ruby
+   before_action do
+     Notey::Current.member = current_user
+     Notey::Current.account_id = current_account&.id
+   end
+   ```
+
+   Ask the developer what supplies the signed-in person and the current account
+   in this app, since both names above are guesses about the host. A read with
+   no account set returns the catalog's default channels and an empty inbox,
+   never another account's rows, and a save on the preferences page fails
+   because a stored preference needs an account.
+
+7. Add the account to Noticed's own rows with a host migration:
+
+   ```ruby
+   add_column :noticed_events, :account_id, :bigint
+   add_column :noticed_notifications, :account_id, :bigint
+   ```
+
+   Then fill them in `config/initializers/noticed.rb`:
+
+   ```ruby
+   ActiveSupport.on_load :noticed_event do
+     after_initialize { self.account_id ||= Notey::Current.account_id }
+
+     def recipient_attributes_for(recipient)
+       super.merge(account_id: account_id)
+     end
+   end
+   ```
+
+   Without these columns the inbox is empty and every digest is, because a
+   delivery runs in a job where the current account is gone.
+
+8. Include the notifier concern in each Noticed event class that delivers one of
+   the catalog's types:
+
+   ```ruby
+   class CommentNotifier < Noticed::Event
+     include Notey::Notifier
+   end
+   ```
+
+   Naming which type the class delivers, and gating each delivery method on what
+   the person wants, are `notey-develop`'s steps rather than this local's.
+
+9. Point digest links at the host's own pages in
+   `config/initializers/notey.rb`:
+
+   ```ruby
+   Notey.notification_url = lambda do |notification|
+     Rails.application.routes.url_helpers.notification_url(notification)
+   end
+   ```
+
+   Ask the developer which of their pages shows one notification. With nothing
+   set, a digest still sends and its rows are plain text instead of links.
+
+10. Boot the app with eager loading on and watch it raise or come up. notey runs
+    `Notey.check!` itself at that point; call it directly in a test or a console
+    to check the same thing without a boot.
+
+11. Decide the pages' layout. They render in notey's own layout, which loads
+    notey's stylesheet and nothing of the host's, unless the host defines
+    `app/views/layouts/notey/application.html.erb`, which takes precedence over
+    the engine's copy. Ask the developer whether these pages should carry the
+    app's navigation.
+
+12. Set up destinations only if a channel in the catalog is addressed at the
+    account rather than at a person. The stored credential is encrypted, so
+    Active Record encryption keys must be configured in the host's credentials
+    (`bin/rails db:encryption:init` generates a set) or saving a destination
+    raises. Ask the developer whether any channel needs this before doing it.
+
+## Conventions
+
+- **Check each page while signed in with an account set.** `/notey/preferences`
+  lists one panel per declared type, `/notey/notifications` lists that person's
+  notifications for the current account, and `/notey/destinations` lists one
+  address and credential field per channel the catalog offers.
+- **A preferences page that will not save is the symptom of a missing account.**
+  Reads fall back to the catalog's default channels when
+  `Notey::Current.account_id` is nil and a save is refused, so check step 6
+  before anything else.
+- **Boot with eager loading after every catalog change.** The catalog and the
+  notifiers are checked against each other only then, and an empty catalog
+  skips the check entirely.
+- **Authentication on the three pages is the host's.** Its controllers inherit
+  from the host's `ApplicationController`, so the host's own filters run and
+  notey adds no authorization of its own — restricting who may set an account's
+  destinations is the host's to write.
+- **Digest emails send from `from@example.com`** and notey exposes no setting
+  that changes it.
+- **Re-run `bin/rails notey:install:migrations` after upgrading the gem.** It
+  copies only the migrations the host does not already have.
+- **Out of scope.** Scheduling the digest runs, tying a notifier to a
+  notification type, delivering one when a domain event fires, and reading the
+  inbox from the host's own code all belong to `notey-develop`.

data/the_local/interface.yml

@@ -0,0 +1,52 @@
+scope: notifications — a catalog of notification types, per-person per-account channel preferences, digest windows, an in-app inbox, per-account destinations, and a mapping from domain events to notifiers
+
+install:
+  - bin/rails notey:install:migrations
+  - mount Notey::Engine
+  - Notey.catalog
+  - Notey::Recipient
+  - Notey::Notifier
+  - Notey::Current
+  - Notey.notification_url=
+  - Notey.check!
+  - /notey/preferences
+  - /notey/notifications
+  - /notey/destinations
+
+develop:
+  - notey_type
+  - Notey.wanted
+  - Notey.deliver_on
+  - Notey.destination_address
+  - Notey.addressed
+  - Notey::DigestRun
+  - Notey::Inbox.for
+  - wants?
+  - channels_for
+  - digest_window_for
+  - Notey.reset!
+
+sources:
+  - lib/notey.rb
+  - lib/notey/engine.rb
+  - lib/notey/catalog.rb
+  - lib/notey/channels.rb
+  - lib/notey/destinations.rb
+  - lib/notey/digest_run.rb
+  - lib/notey/event_subscriber.rb
+  - lib/notey/inbox.rb
+  - app/models/concerns/notey/recipient.rb
+  - app/models/concerns/notey/notifier.rb
+  - app/models/notey/current.rb
+  - app/models/notey/preference.rb
+  - app/models/notey/destination.rb
+  - app/models/notey/digest.rb
+  - app/jobs/notey/digest_job.rb
+  - app/mailers/notey/digest_mailer.rb
+  - app/controllers/notey/preferences_controller.rb
+  - app/controllers/notey/notifications_controller.rb
+  - app/controllers/notey/destinations_controller.rb
+  - config/routes.rb
+  - db/migrate/20260917000002_create_notey_preferences.rb
+  - db/migrate/20260918030002_create_notey_digests.rb
+  - db/migrate/20260918050001_create_notey_destinations.rb