A kind of notification of the app: who it goes to, by which channels, and what it says in each. Chime has none of its own; the app writes one module for each kind it has.

defmodule MyApp.Notifications.NewComment do
  use Chime.Notifier, category: :comments, group_window: {10, :minute}

  deliver :feed
  deliver :email, wait: {10, :minute}, unless: :read
  deliver :telegram, if: :telegram?

  @impl true
  def recipients(%{comment: comment}),
    do: MyApp.Stories.followers(comment.story_id) -- [comment.author]

  @impl true
  def data(%{comment: comment}) do
    %{"story_id" => comment.story_id, "story" => comment.story.title, "text" => comment.text}
  end

  @impl true
  def actor(%{comment: comment}),
    do: %{"id" => "user:#{comment.author.id}", "name" => comment.author.name}

  @impl true
  def group(%{comment: comment}), do: "story:#{comment.story_id}"

  @impl true
  def feed(data, notification) do
    %{
      title: "#{Chime.actors(notification)} commented on #{data["story"]}",
      body: data["text"],
      url: "/stories/#{data["story_id"]}"
    }
  end

  @impl true
  def email(data, _recipient, notification) do
    Swoosh.Email.new(
      subject: "#{Chime.actors(notification)} commented on #{data["story"]}",
      text_body: data["text"]
    )
  end

  def telegram?(_data, recipient), do: recipient.data.telegram_chat != nil
end

Then, where the comment is made:

Chime.notify(MyApp.Notifications.NewComment, %{comment: comment},
  key: "comment:#{comment.id}")

Options of use

• :category - the category of Chime.Config it is of, which the preferences turn on and off (required).
• :kind - its name in the JSON API and the components ("new_comment" for MyApp.Notifications.NewComment).
• :required - it goes whatever the person's preferences, and its emails have no link to unsubscribe (false; a category of required: true makes all its notifiers so).
• :notify_actor - whether the person who did it (actor/1) is notified too, when they are among the recipients (false: nobody is told of what they did).
• :audience_key - with audience/1: the field of the query's first binding its pages go by (:id).
• :group_window - with group/1: how long a notification stays open to the events of its group, from the first ({1, :hour}).

Channels

deliver/2 declares a channel, in the order they go: :feed, the bell and its list in the app (decided when the notification comes, with :if and :unless of the notifier's functions only); :email, through the app's mailer; or one of the app's :channels (Chime.Channel). Options:

• :wait - how long after the notification it goes: {10, :minute} (:second, :minute, :hour, :day) or a number of seconds. What is decided then (the conditions, the preferences) is decided at that time.
• :unless - it does not go if: :read (the person read it in the feed meanwhile), :seen (they saw it in the feed), or the name of a function of the notifier, (data, recipient) -> boolean. A list is any of them.
• :if - it goes only if this function of the notifier, (data, recipient) -> boolean, says so; or {module, function}.
• :throttle - at most one by the channel for a group (or, with no group, for the notifier) in this time: {15, :minute}. One that comes sooner waits for the end of it.
• :debounce - with :wait: each event that joins the group while it waits moves its time to :wait after that event, so a quick run of events (messages a minute apart) goes as one. :max_wait is the most it waits from the first (none).
• :quiet - false sends it in the person's quiet hours too (:quiet_hours of Chime.Config). A required notification always goes.

What it says

The feed and the emails are made from data/1, kept on the event as JSON when the notification comes, and rendered when they are shown: in the person's language, as the app's words are then, and with the count of a group ("Ana and 4 others"). Each channel calls its function of the notifier: feed/2, email/3, and, for an app's channel, the function of its name (telegram/3) when there is one.

See the Notifiers guide.