notey 0.1.0

data/app/models/notey/save_destination.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Notey
+  class SaveDestination
+    def initialize(values:, person: nil, account: nil)
+      @person = person
+      @account_id = account.respond_to?(:id) ? account.id : account
+      @values = values
+    end
+
+    def call
+      refusal = submitted.filter_map { |channel, attributes| store(channel, attributes) }.first
+
+      refusal || Kept.new
+    end
+
+    private
+
+    def owner
+      nil
+    end
+
+    def submitted
+      @values.fetch(:destinations, {}).slice(*Notey.addressed_channels)
+    end
+
+    def store(channel, attributes)
+      destination = Destination.find_or_initialize_by(
+        account_id: @account_id, channel: channel.to_s, member: owner
+      )
+      destination.address = attributes["address"]
+      destination.credential = attributes["credential"] if attributes["credential"].present?
+
+      Refusal.new(destination.errors.full_messages.first) unless destination.save
+    end
+  end
+end

data/app/models/notey/save_my_destination.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Notey
+  class SaveMyDestination < SaveDestination
+    private
+
+    def owner
+      @person
+    end
+  end
+end

data/app/models/notey/save_preferences.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Notey
+  class SavePreferences
+    def initialize(values:, person: nil, account: nil)
+      @person = person
+      @account_id = account.respond_to?(:id) ? account.id : account
+      @values = values
+    end
+
+    def call
+      refusal = chosen.filter_map { |notification_type, channels| store(notification_type, channels) }.first
+
+      refusal || Kept.new
+    end
+
+    private
+
+    def chosen
+      @values.fetch(:preferences, {}).select { |type, _| Notey.notification_types.include?(type.to_s) }
+    end
+
+    def windows
+      @values.fetch(:windows, {})
+    end
+
+    def store(notification_type, channels)
+      preference = Preference.find_or_initialize_by(
+        member: @person, account_id: @account_id, notification_type: notification_type.to_s
+      )
+      preference.channels = Array(channels).map(&:to_s).reject(&:blank?)
+      preference.digest_window = windows.fetch(notification_type.to_s, "immediate")
+
+      Refusal.new(preference.errors.full_messages.first) unless preference.save
+    end
+  end
+end

data/app/views/notey/_destinations.html.erb

@@ -0,0 +1,13 @@
+<% stored = Notey::Destination.where(account_id: account, member_id: nil).index_by(&:channel) %>
+
+<%= ui_form(action: submit_url, method: :patch) do %>
+  <% Notey.addressed_channels.each do |channel| %>
+    <%= ui_panel do %>
+      <%= ui_section(title: channel.humanize) do %>
+        <%= ui_input(name: "destinations[#{channel}][address]", value: stored[channel]&.address) %>
+        <%= ui_input(name: "destinations[#{channel}][credential]", type: :password) %>
+      <% end %>
+    <% end %>
+  <% end %>
+  <%= ui_button(label: "Save") %>
+<% end %>

data/app/views/notey/_my_destinations.html.erb

@@ -0,0 +1,12 @@
+<% stored = Notey::Destination.where(account_id: account, member: person).index_by(&:channel) %>
+
+<%= ui_form(action: submit_url, method: :patch) do %>
+  <% Notey.addressed_channels.each do |channel| %>
+    <%= ui_panel do %>
+      <%= ui_section(title: channel.humanize) do %>
+        <%= ui_input(name: "destinations[#{channel}][address]", value: stored[channel]&.address) %>
+      <% end %>
+    <% end %>
+  <% end %>
+  <%= ui_button(label: "Save") %>
+<% end %>

data/app/views/notey/_preferences.html.erb

@@ -0,0 +1,25 @@
+<% stored = Notey::Preference.where(member: person, account_id: account).index_by(&:notification_type) %>
+
+<%= ui_form(action: submit_url, method: :patch) do %>
+  <% Notey.notification_types.each do |name| %>
+    <%= ui_panel do %>
+      <%= ui_section(title: name.humanize) do %>
+        <%= hidden_field_tag "preferences[#{name}][]", "", id: nil %>
+        <% Notey.channels.each do |channel| %>
+          <%= ui_checkbox_row(
+                name: "preferences[#{name}][]",
+                value: channel,
+                label: channel.humanize,
+                checked: Notey::Channels.channels_of(stored[name], name).include?(channel)
+              ) %>
+        <% end %>
+      <%= ui_select(
+            name: "windows[#{name}]",
+            options: [ [ "Immediately", "immediate" ], [ "Once a day", "daily" ], [ "Once a week", "weekly" ] ],
+            selected: stored[name]&.digest_window || "immediate"
+          ) %>
+      <% end %>
+    <% end %>
+  <% end %>
+  <%= ui_button(label: "Save") %>
+<% end %>

data/app/views/notey/destinations/show.html.erb

@@ -0,0 +1,7 @@
+<%= ui_page(max_width: :lg) do %>
+  <%= ui_section(title: "Destinations") do %>
+    <%= render partial: "notey/destinations",
+          locals: { person: Notey::Current.member, account: Notey::Current.account_id,
+                    selection: {}, submit_url: destinations_path } %>
+  <% end %>
+<% end %>

data/app/views/notey/digest_mailer/digest.html.erb

@@ -0,0 +1,8 @@
+<h1>Your <%= @window %> notifications</h1>
+
+<ul>
+  <% @notifications.each do |notification| %>
+    <% url = Notey.notification_url.call(notification) %>
+    <li><%= url ? link_to(notification.event.class.name, url) : notification.event.class.name %></li>
+  <% end %>
+</ul>

data/app/views/notey/notification_mailer/notification.html.erb

@@ -0,0 +1,6 @@
+<h1><%= @notification.event.title %></h1>
+
+<p><%= @notification.event.body %></p>
+
+<% url = Notey.notification_url.call(@notification) %>
+<%= link_to "View it", url if url %>

data/app/views/notey/notifications/index.html.erb

@@ -0,0 +1,17 @@
+<%= ui_page(max_width: :lg) do %>
+  <%= ui_section(title: "Notifications", subtitle: "#{@unread_count} unread") do %>
+    <% @notifications.each do |notification| %>
+      <%= ui_panel do %>
+        <div data-notification-id="<%= notification.id %>">
+          <%= notification.event.class.name %>
+          <%= ui_badge(label: notification.read? ? "Read" : "Unread") %>
+          <% unless notification.read? %>
+            <%= ui_form(action: notification_path(notification), method: :patch) do %>
+              <%= ui_button(label: "Mark read") %>
+            <% end %>
+          <% end %>
+        </div>
+      <% end %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/notey/preferences/show.html.erb

@@ -0,0 +1,7 @@
+<%= ui_page(max_width: :lg) do %>
+  <%= ui_section(title: "Notifications") do %>
+    <%= render partial: "notey/preferences",
+          locals: { person: Notey::Current.member, account: Notey::Current.account_id,
+                    selection: {}, submit_url: preferences_path } %>
+  <% end %>
+<% end %>

data/config/routes.rb

@@ -0,0 +1,5 @@
+Notey::Engine.routes.draw do
+  resource :preferences, only: [ :show, :update ]
+  resources :notifications, only: [ :index, :update ]
+  resource :destinations, only: [ :show, :update ]
+end

data/db/migrate/20260917000002_create_notey_preferences.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateNoteyPreferences < ActiveRecord::Migration[8.1]
+  def change
+    create_table :notey_preferences do |t|
+      t.references :member, polymorphic: true, null: false
+      t.bigint :account_id, null: false
+      t.string :notification_type, null: false
+      t.json :channels, null: false, default: []
+
+      t.timestamps
+    end
+
+    add_index :notey_preferences, %i[member_type member_id account_id notification_type],
+      unique: true, name: "index_notey_preferences_unique"
+  end
+end

data/db/migrate/20260918020001_add_digest_window_to_notey_preferences.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddDigestWindowToNoteyPreferences < ActiveRecord::Migration[8.1]
+  def change
+    add_column :notey_preferences, :digest_window, :string, null: false, default: "immediate"
+  end
+end

data/db/migrate/20260918030002_create_notey_digests.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateNoteyDigests < ActiveRecord::Migration[8.1]
+  def change
+    create_table :notey_digests do |t|
+      t.references :member, polymorphic: true, null: false
+      t.bigint :account_id, null: false
+      t.string :digest_window, null: false
+      t.datetime :period_start, null: false
+      t.integer :notifications_count, null: false, default: 0
+      t.datetime :sent_at
+
+      t.timestamps
+    end
+
+    add_index :notey_digests,
+      %i[member_type member_id account_id digest_window period_start],
+      unique: true, name: "index_notey_digests_unique"
+  end
+end

data/db/migrate/20260918050001_create_notey_destinations.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateNoteyDestinations < ActiveRecord::Migration[8.1]
+  def change
+    create_table :notey_destinations do |t|
+      t.bigint :account_id, null: false
+      t.string :channel, null: false
+      t.string :address, null: false
+      t.text :credential
+
+      t.timestamps
+    end
+
+    add_index :notey_destinations, %i[account_id channel], unique: true
+  end
+end

data/db/migrate/20260918060001_index_digest_window_on_notey_preferences.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class IndexDigestWindowOnNoteyPreferences < ActiveRecord::Migration[8.1]
+  def change
+    add_index :notey_preferences, :digest_window
+  end
+end

data/db/migrate/20260919010001_add_member_to_notey_destinations.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class AddMemberToNoteyDestinations < ActiveRecord::Migration[8.1]
+  def change
+    add_reference :notey_destinations, :member, polymorphic: true, null: true
+
+    remove_index :notey_destinations, %i[account_id channel]
+    add_index :notey_destinations, %i[member_type member_id account_id channel],
+      unique: true, name: "index_notey_destinations_unique"
+  end
+end

data/db/migrate/20260921000001_create_notey_attempts.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateNoteyAttempts < ActiveRecord::Migration[8.1]
+  def change
+    create_table :notey_attempts do |t|
+      t.references :notification, null: false, foreign_key: { to_table: :noticed_notifications, on_delete: :cascade }
+      t.string :channel, null: false
+      t.string :state, null: false, default: "claimed"
+      t.text :failure
+
+      t.timestamps
+    end
+
+    add_index :notey_attempts, %i[notification_id channel], unique: true, name: "index_notey_attempts_unique"
+  end
+end

data/lib/notey/catalog.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Notey
+  class Catalog
+    Notification = Struct.new(:channels, :default, keyword_init: true)
+
+    def initialize
+      @notifications = {}
+      @addressed = []
+    end
+
+    def addressed(*channels)
+      return @addressed if channels.empty?
+
+      @addressed |= channels.map(&:to_s)
+    end
+
+    def notification(name, channels: [], default: [])
+      @notifications[name.to_s] = Notification.new(
+        channels: Array(channels).map(&:to_s),
+        default: Array(default).map(&:to_s)
+      )
+    end
+
+    def notifications
+      @notifications
+    end
+
+    def channels
+      @notifications.values.flat_map(&:channels).uniq
+    end
+
+    def declared?(notification_type)
+      @notifications.key?(notification_type.to_s)
+    end
+
+    def channels_for(notification_type)
+      declared(notification_type)&.channels || []
+    end
+
+    def default_channels_for(notification_type)
+      declared(notification_type)&.default || []
+    end
+
+    private
+
+    def declared(notification_type)
+      @notifications[notification_type.to_s]
+    end
+  end
+end

data/lib/notey/channels.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Notey
+  class Channels
+    Decision = Struct.new(:channels, :window, keyword_init: true)
+
+    def self.decision_for(member, notification_type, account_id:)
+      return Decision.new(channels: [], window: "immediate") unless Notey.notification_types.include?(notification_type.to_s)
+
+      stored = stored_for(member, notification_type, account_id)
+
+      Decision.new(
+        channels: stored ? Array(stored.channels).map(&:to_s) : Notey.default_channels,
+        window: stored&.digest_window || "immediate"
+      )
+    end
+
+    def self.for(member, notification_type, account_id:)
+      decision_for(member, notification_type, account_id: account_id).channels
+    end
+
+    def self.window_for(member, notification_type, account_id:)
+      decision_for(member, notification_type, account_id: account_id).window
+    end
+
+    def self.channels_of(preference, _notification_type)
+      return Array(preference.channels).map(&:to_s) if preference
+
+      Notey.default_channels
+    end
+
+    def self.window_of(preference)
+      preference.digest_window || "immediate"
+    end
+
+    def self.stored_for(member, notification_type, account_id)
+      member.notey_preferences.find_by(account_id: account_id, notification_type: notification_type.to_s)
+    end
+    private_class_method :stored_for
+  end
+end

data/lib/notey/destinations.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Notey
+  class Destinations
+    def self.for(account_id, channel, member: nil)
+      return nil if account_id.blank?
+
+      Destination.find_by(account_id: account_id, channel: channel.to_s, member: member)
+    end
+  end
+end

data/lib/notey/digest_run.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Notey
+  class DigestRun
+    PERIODS = { "daily" => :day, "weekly" => :week }.freeze
+
+    def initialize(window:, now: Time.current)
+      @window = window.to_s
+      @now = now
+    end
+
+    def call
+      preferences.group_by { |preference| [ preference.member, preference.account_id ] }
+                 .each { |(member, account_id), _| DigestJob.perform_later(member, account_id, window) }
+    end
+
+    def deliver_to_member(member, account_id)
+      deliver_to(member, account_id, preferences.where(member: member, account_id: account_id))
+    end
+
+    private
+
+    attr_reader :window, :now
+
+    def preferences
+      Preference.where(digest_window: window)
+    end
+
+    def deliver_to(member, account_id, grouped)
+      notifications = gathered(member, account_id, types_in_window(grouped))
+      return if notifications.empty?
+
+      digest = claim(member, account_id)
+      return if digest.nil?
+
+      send_digest(digest, member, notifications)
+    end
+
+    def send_digest(digest, member, notifications)
+      DigestMailer.digest(member, notifications, window).deliver_now
+      digest.update!(notifications_count: notifications.size, sent_at: Time.current)
+    rescue StandardError
+      digest.destroy
+      raise
+    end
+
+    def claim(member, account_id)
+      Digest.create!(member: member, account_id: account_id, digest_window: window, period_start: period_start)
+    rescue ActiveRecord::RecordNotUnique
+      nil
+    end
+
+    def types_in_window(grouped)
+      grouped.select { |preference| Channels.window_of(preference) == window }
+             .map(&:notification_type)
+    end
+
+    def gathered(member, account_id, notification_types)
+      Inbox.for(member, account_id: account_id)
+        .includes(:event)
+        .where(created_at: period_start..now)
+        .select { |notification| notification_types.include?(type_of(notification)) }
+    end
+
+    def type_of(notification)
+      notification.event.class.try(:notey_notification_type)
+    end
+
+    def period_start
+      @period_start ||= now.public_send("beginning_of_#{PERIODS.fetch(window)}")
+    end
+  end
+end

data/lib/notey/engine.rb

@@ -0,0 +1,20 @@
+require "noticed"
+require "keystone_ui"
+
+module Notey
+  class Engine < ::Rails::Engine
+    isolate_namespace Notey
+
+    initializer "notey.filter_parameters" do |app|
+      app.config.filter_parameters += [ :credential ]
+    end
+
+    initializer "notey.forget_notifiers_on_reload" do
+      ActiveSupport::Reloader.before_class_unload { Notey.forget_notifiers }
+    end
+
+    config.to_prepare { Noticed::DeliveryMethod.include(Notey::RecordsAttempt) }
+
+    config.after_initialize { |app| Notey.check! if app.config.eager_load }
+  end
+end

data/lib/notey/event_delivery.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Notey
+  class EventDelivery
+    def self.call(event)
+      notifier = Notey.notifier_for(event.event_name)
+      return if notifier.nil?
+
+      payload = event.payload.to_h.symbolize_keys
+
+      Current.set(account_id: payload[:account_id]) { notifier.with(**payload).deliver }
+    end
+  end
+end

data/lib/notey/inbox.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Notey
+  class Inbox
+    def self.for(member, account_id:)
+      return Noticed::Notification.none if account_id.blank?
+
+      Noticed::Notification.where(recipient: member, account_id: account_id)
+    end
+  end
+end

data/lib/notey/records_attempt.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Notey
+  module RecordsAttempt
+    extend ActiveSupport::Concern
+
+    included do
+      around_deliver :record_attempt
+    end
+
+    def outbound?
+      true
+    end
+
+    def record_attempt
+      channel = config[:notey_channel]
+      return yield if channel.blank? || !outbound?
+
+      attempt = claim_attempt(channel)
+      return if attempt.nil?
+
+      begin
+        yield
+        attempt.update!(state: "sent")
+      rescue StandardError => error
+        attempt.update!(state: "failed", failure: error.message)
+        raise
+      end
+    end
+
+    def claim_attempt(channel)
+      Attempt.create!(notification: notification, channel: channel)
+    rescue ActiveRecord::RecordNotUnique
+      nil
+    end
+  end
+end

data/lib/notey/version.rb

@@ -0,0 +1,3 @@
+module Notey
+  VERSION = "0.1.0"
+end