sincerely 1.0.0

data/lib/generators/templates/events/delivery_event_model.rb.erb

@@ -0,0 +1,5 @@
+class Sincerely::DeliveryEvent < ApplicationRecord
+  self.table_name_prefix = :sincerely_
+
+  serialize :options, coder: JSON
+end

data/lib/generators/templates/events/delivery_events_create.rb.erb

@@ -0,0 +1,20 @@
+class CreateSincerelyDeliveryEvents < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :sincerely_delivery_events do |t|
+      t.string :message_id
+      t.string :delivery_system
+      t.string :event_type
+      t.string :recipient
+      t.string :delivery_event_type
+      t.string :delivery_event_subtype
+      t.text :options
+      t.datetime :timestamp
+
+      t.timestamps
+    end
+
+    add_index :sincerely_delivery_events, :message_id
+    add_index :sincerely_delivery_events, :delivery_system
+    add_index :sincerely_delivery_events, :created_at
+  end
+end

data/lib/generators/templates/events/engagement_event_model.rb.erb

@@ -0,0 +1,5 @@
+class Sincerely::EngagementEvent < ApplicationRecord
+  self.table_name_prefix = :sincerely_
+
+  serialize :options, coder: JSON
+end

data/lib/generators/templates/events/engagement_events_create.rb.erb

@@ -0,0 +1,21 @@
+class CreateSincerelyEngagementEvents < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :sincerely_engagement_events do |t|
+      t.string :message_id
+      t.string :delivery_system
+      t.string :event_type
+      t.string :recipient
+      t.string :ip_address
+      t.string :user_agent
+      t.string :link
+      t.string :feedback_type
+      t.text :options
+      t.datetime :timestamp
+
+      t.timestamps
+    end
+
+    add_index :sincerely_engagement_events, :message_id
+    add_index :sincerely_engagement_events, :created_at
+  end
+end

data/lib/generators/templates/notification_model.rb.erb

@@ -0,0 +1,3 @@
+class <%= class_name %> < ApplicationRecord
+  include Sincerely::Mixins::NotificationModel
+end

data/lib/generators/templates/notifications_create.rb.erb

@@ -0,0 +1,21 @@
+class Create<%= class_name.pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= table_name %> do |t|
+      t.string   :recipient
+      t.string   :notification_type
+      t.text     :delivery_options
+      t.string   :delivery_system
+      t.string   :delivery_state
+      t.string   :template_id
+      t.datetime :sent_at
+      t.datetime :scheduled_at
+      t.integer  :delivery_attempts
+      t.string   :message_id
+      t.string   :error_message
+
+      t.timestamps
+    end
+
+    add_index :<%= table_name %>, :recipient
+  end
+end

data/lib/generators/templates/notifications_update.rb.erb

@@ -0,0 +1,16 @@
+class Update<%= class_name.pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    add_column :<%= table_name %>, :recipient, :string
+    add_column :<%= table_name %>, :notification_type, :string
+    add_column :<%= table_name %>, :delivery_options, :text
+    add_column :<%= table_name %>, :delivery_system, :string
+    add_column :<%= table_name %>, :delivery_state, :string
+    add_column :<%= table_name %>, :sent_at, :datetime
+    add_column :<%= table_name %>, :scheduled_at, :datetime
+    add_column :<%= table_name %>, :delivery_attempts, :integer
+    add_column :<%= table_name %>, :message_id, :string
+    add_column :<%= table_name %>, :error_message, :string
+
+    add_index :<%= table_name %>, :recipient
+  end
+end

data/lib/generators/templates/sincerely.yml

@@ -0,0 +1,21 @@
+defaults: &defaults
+  notification_model_name: Notification
+  delivery_methods:
+    email:
+      delivery_system: Sincerely::DeliverySystems::EmailAwsSes
+      options:
+        region: <%%= ENV['AWS_REGION'] %>
+        access_key_id: <%%= ENV['AWS_ACCESS_KEY_ID'] %>
+        secret_access_key: <%%= ENV['AWS_SECRET_ACCESS_KEY'] %>
+        configuration_set_name: config_set
+test:
+  <<: *defaults
+
+development:
+  <<: *defaults
+
+staging:
+  <<: *defaults
+
+production:
+  <<: *defaults

data/lib/generators/templates/templates_create.rb.erb

@@ -0,0 +1,15 @@
+class Create<%= class_name %>Templates < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :notification_templates do |t|
+      t.integer :template_id
+      t.string  :name
+      t.string  :subject
+      t.string  :sender
+      t.string  :html_content
+      t.string  :text_content
+      t.string  :type
+
+      t.timestamps
+    end
+  end
+end

data/lib/sincerely/delivery_systems/email_aws_ses.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-sesv2'
+
+module Sincerely
+  module DeliverySystems
+    class EmailAwsSes
+      DELIVERY_SYSTEM = :aws_ses2
+
+      class << self
+        def call(notification:, options: {})
+          new(notification:, options:).deliver
+        end
+      end
+
+      def initialize(notification:, options:)
+        @notification = notification
+        @template = notification.template
+        @options = options.symbolize_keys
+      end
+
+      def deliver
+        response = client.send_email(email_options)
+        update_notification(response)
+      end
+
+      private
+
+      attr_reader :notification, :template, :options
+
+      def client
+        client_options = options.slice(:region, :access_key_id, :secret_access_key)
+        @client ||= Aws::SESV2::Client.new(**client_options)
+      end
+
+      def email_options
+        opts = {
+          from_email_address: template.sender,
+          destination: { to_addresses: [notification.recipient] },
+          content: {
+            simple: {
+              subject: { data: subject },
+              body: {
+                html: {
+                  data: notification.render_content(:html)
+                },
+                text: {
+                  data: notification.render_content(:text)
+                }
+              }
+            }
+          }
+        }
+        config_set = options[:configuration_set_name]
+        opts = opts.merge(configuration_set_name: config_set) if config_set.present?
+        opts
+      end
+
+      def subject
+        raw_subject = notification.delivery_options&.fetch('subject', nil) || template.subject
+        template.renderer.render(raw_subject, notification.delivery_options&.stringify_keys)
+      end
+
+      def update_notification(response)
+        notification.update(message_id: response.message_id, delivery_system: DELIVERY_SYSTEM, sent_at: Time.current)
+      end
+    end
+  end
+end

data/lib/sincerely/engine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sincerely
+  class Engine < ::Rails::Engine
+    isolate_namespace Sincerely
+  end
+end

data/lib/sincerely/mixins/notification_model.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'aasm'
+require 'active_support/concern'
+
+module Sincerely
+  module Mixins
+    module NotificationModel
+      extend ActiveSupport::Concern
+
+      included do # rubocop:disable Metrics/BlockLength
+        include AASM
+
+        serialize :delivery_options, coder: JSON
+
+        belongs_to :template, class_name: 'Sincerely::Templates::NotificationTemplate'
+
+        validates :recipient, presence: true
+        validates :notification_type, inclusion: { in: %w[email sms push] }
+
+        aasm column: :delivery_state do # rubocop:disable Metrics/BlockLength
+          state :draft, initial: true
+          state :accepted
+          state :rejected
+          state :delivered
+          state :bounced
+          state :complained
+          state :delayed
+          state :opened
+          state :clicked
+
+          # Terminal states: bounced, complained, rejected - no transitions allowed from these
+          # Flow: draft -> accepted -> delivered -> opened -> clicked
+          #                        \-> bounced (terminal)
+          #                        \-> complained (terminal from delivered/opened/clicked)
+
+          event :set_accepted do
+            transitions to: :accepted, from: [:draft]
+          end
+
+          event :set_rejected do
+            transitions to: :rejected, from: %i[draft accepted]
+          end
+
+          event :set_delivered do
+            transitions to: :delivered, from: %i[draft accepted delayed]
+          end
+
+          event :set_bounced do
+            transitions to: :bounced, from: %i[draft accepted delivered delayed]
+          end
+
+          event :set_complained do
+            transitions to: :complained, from: %i[delivered opened clicked]
+          end
+
+          event :set_delayed do
+            transitions to: :delayed, from: %i[draft accepted]
+          end
+
+          event :set_opened do
+            transitions to: :opened, from: [:delivered]
+          end
+
+          event :set_clicked do
+            transitions to: :clicked, from: %i[delivered opened]
+          end
+        end
+
+        def render_content(content_type)
+          template.render(content_type, delivery_options)
+        end
+
+        def deliver
+          raise StandardError, "Delivery method not configured for #{notification_type}." if delivery_method.blank?
+
+          call_delivery_method
+        end
+
+        private
+
+        def delivery_method
+          @delivery_method ||= Sincerely.config.delivery_methods&.fetch(notification_type, {})
+        end
+
+        def call_delivery_method
+          class_name, options = delivery_method.values_at('delivery_system', 'options')
+          klass = class_name.constantize
+          klass.call(notification: self, options:)
+        end
+      end
+    end
+  end
+end

data/lib/sincerely/mixins/webhooks/aws_ses_events.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'aws-sdk-sns'
+
+require 'sincerely/services/process_delivery_event'
+require 'sincerely/services/events/aws_ses_event'
+
+module Sincerely
+  module Mixins
+    module Webhooks
+      module AwsSesEvents
+        extend ActiveSupport::Concern
+
+        included do # rubocop:disable Metrics/BlockLength
+          skip_before_action :verify_authenticity_token, only: [:create]
+
+          def create
+            verifier.authenticate!(request.raw_post)
+
+            case sns_message_type
+            when 'SubscriptionConfirmation'
+              confirm_subscription
+            when 'Notification'
+              logger&.info event_payload # temporary log
+              event = Sincerely::Services::Events::AwsSesEvent.event_for(event_payload)
+              Sincerely::Services::ProcessDeliveryEvent.call(event:)
+            end
+
+            render json: { message: 'ok' }, status: :ok
+          end
+
+          private
+
+          def verifier
+            @verifier ||= Aws::SNS::MessageVerifier.new
+          end
+
+          def posted_message_body
+            @posted_message_body ||= JSON.parse(request.raw_post)
+          end
+
+          def sns_message_type
+            posted_message_body['Type']
+          end
+
+          def topic_arn
+            posted_message_body['TopicArn']
+          end
+
+          def token
+            posted_message_body['Token']
+          end
+
+          def event_payload
+            message = posted_message_body['Message']
+            JSON.parse(message) if message.present?
+          end
+
+          def delivery_options
+            Sincerely.config.delivery_methods.dig('email', 'options').symbolize_keys
+          end
+
+          def confirm_subscription
+            client_options = delivery_options.slice(:region, :access_key_id, :secret_access_key)
+            client = Aws::SNS::Client.new(**client_options)
+
+            client.confirm_subscription(topic_arn:, token:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sincerely/renderers/liquid.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'liquid'
+
+module Sincerely
+  module Renderers
+    class Liquid
+      def self.render(content, options = {})
+        template = ::Liquid::Template.parse(content)
+        template.render(options&.dig('template_data')&.stringify_keys)
+      end
+    end
+  end
+end

data/lib/sincerely/services/events/aws_ses_bounce_event.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Services
+    module Events
+      class AwsSesBounceEvent < AwsSesEvent
+        def delivery_event_type
+          event.dig('bounce', 'bounceType')
+        end
+
+        def delivery_event_subtype
+          event.dig('bounce', 'bounceSubType')
+        end
+
+        def options
+          bounced_recipient = event.dig('bounce', 'bouncedRecipients')[0]
+          {
+            action: bounced_recipient&.dig('action'),
+            status: bounced_recipient&.dig('status'),
+            diagnostic_code: bounced_recipient&.dig('diagnosticCode')
+          }
+        end
+      end
+    end
+  end
+end

data/lib/sincerely/services/events/aws_ses_click_event.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Services
+    module Events
+      class AwsSesClickEvent < AwsSesEvent
+        def ip_address
+          event.dig('click', 'ipAddress')
+        end
+
+        def user_agent
+          event.dig('click', 'userAgent')
+        end
+
+        def link
+          event.dig('click', 'link')
+        end
+
+        def feedback_type
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/sincerely/services/events/aws_ses_complaint_event.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Services
+    module Events
+      class AwsSesComplaintEvent < AwsSesEvent
+        def ip_address
+          nil
+        end
+
+        def user_agent
+          event.dig('complaint', 'userAgent')
+        end
+
+        def link
+          nil
+        end
+
+        def feedback_type
+          event.dig('complaint', 'complaintFeedbackType')
+        end
+      end
+    end
+  end
+end

data/lib/sincerely/services/events/aws_ses_delivery_event.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Services
+    module Events
+      class AwsSesDeliveryEvent < AwsSesEvent
+        def delivery_event_type
+          nil
+        end
+
+        def delivery_event_subtype
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/sincerely/services/events/aws_ses_event.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Services
+    module Events
+      class AwsSesEvent
+        attr_reader :event
+
+        class << self
+          def event_for(event_payload)
+            case event_type(event_payload)
+            when 'bounce' then AwsSesBounceEvent.new(event_payload)
+            when 'delivery' then AwsSesDeliveryEvent.new(event_payload)
+            when 'click' then AwsSesClickEvent.new(event_payload)
+            when 'open' then AwsSesOpenEvent.new(event_payload)
+            when 'complaint' then AwsSesComplaintEvent.new(event_payload)
+            else new(event_payload)
+            end
+          end
+
+          def event_type(event_payload)
+            event_payload&.dig('eventType')&.downcase
+          end
+        end
+
+        def initialize(event_payload)
+          @event = event_payload
+        end
+
+        def event_type
+          self.class.event_type(event)
+        end
+
+        def message_id
+          event.dig('mail', 'messageId')
+        end
+
+        def recipient
+          event.dig('mail', 'destination')[0]
+        end
+
+        def timestamp
+          Time.parse(event.dig(event_type, 'timestamp') || event.dig('mail', 'timestamp')) # rubocop:disable Rails/TimeZone
+        end
+
+        def options
+          nil
+        end
+
+        def delivery_system
+          Sincerely::DeliverySystems::EmailAwsSes::DELIVERY_SYSTEM
+        end
+      end
+    end
+  end
+end

data/lib/sincerely/services/events/aws_ses_open_event.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Services
+    module Events
+      class AwsSesOpenEvent < AwsSesEvent
+        def ip_address
+          event.dig('open', 'ipAddress')
+        end
+
+        def user_agent
+          event.dig('open', 'userAgent')
+        end
+
+        def link
+          nil
+        end
+
+        def feedback_type
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/sincerely/services/process_delivery_event.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Services
+    class ProcessDeliveryEvent
+      delegate :event_type, :message_id, :recipient, :timestamp, :options, :delivery_system,
+               to: :event
+
+      class << self
+        def call(event:)
+          new(event:).call
+        end
+      end
+
+      def initialize(event:)
+        @event = event
+      end
+
+      def call
+        return if notification.blank?
+
+        case event_type.to_sym
+        when :bounce
+          notification.set_bounced!
+          create_event
+        when :complaint
+          notification.set_complained!
+          create_event
+        when :delivery
+          notification.set_delivered!
+          create_event
+        when :send
+          notification.set_accepted! if notification.may_set_accepted?
+        when :reject
+          notification.set_rejected!
+          notification.update(error_message: event.rejection_reason)
+        when :open
+          notification.set_opened!
+          create_event
+        when :click
+          notification.set_clicked!
+          create_event
+        end
+      end
+
+      private
+
+      attr_reader :event
+
+      def create_event
+        case event_type.to_sym
+        when :bounce, :delivery
+          Sincerely::DeliveryEvent.create(
+            message_id:, delivery_system:, event_type:, recipient:, timestamp:, options:,
+            delivery_event_type: event.delivery_event_type, delivery_event_subtype: event.delivery_event_subtype
+          )
+        else
+          Sincerely::EngagementEvent.create(
+            message_id:, delivery_system:, event_type:, recipient:, timestamp:, options:,
+            ip_address: event.ip_address, user_agent: event.user_agent, link: event.link,
+            feedback_type: event.feedback_type
+          )
+        end
+      end
+
+      def notification
+        model = Sincerely.config.notification_model_name.constantize
+        @notification ||= model.find_by(message_id:)
+      end
+    end
+  end
+end

data/lib/sincerely/templates/email_liquid_template.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'sincerely/templates/notification_template'
+
+module Sincerely
+  module Templates
+    class EmailLiquidTemplate < NotificationTemplate
+      def renderer
+        Sincerely::Renderers::Liquid
+      end
+    end
+  end
+end