actionwebpush 0.1.0

data/lib/actionwebpush/base.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class Base
+    include ActionWebPush::Authorization
+    def self.default_params
+      @default_params ||= {}
+    end
+
+    def self.default_params=(value)
+      @default_params = value.dup.freeze
+    end
+
+    def self.inherited(subclass)
+      # Each subclass gets its own copy of default_params
+      subclass.instance_variable_set(:@default_params, default_params.dup)
+      super
+    end
+
+    attr_reader :params
+
+    def initialize(**params)
+      @params = self.class.default_params.merge(params)
+    end
+
+    def self.push(subscriptions, **notification_params)
+      new(**notification_params).push(subscriptions)
+    end
+
+    def push(subscriptions, current_user: nil, **notification_params)
+      current_user ||= ActionWebPush::Authorization::Utils.current_user_context
+
+      # Authorization check
+      if current_user && !ActionWebPush::Authorization::Utils.authorization_bypassed?
+        authorize_notification_sending!(
+          current_user: current_user,
+          subscriptions: subscriptions
+        )
+      end
+
+      if notification_params.empty?
+        # Called with just subscriptions, use stored params
+        notifications = build_notifications(subscriptions, **@params)
+      else
+        # Called with both subscriptions and notification params
+        notifications = build_notifications(subscriptions, **notification_params)
+      end
+
+      deliver_notifications(notifications)
+      notifications.first # Return first notification for compatibility
+    end
+
+    def deliver_now(subscriptions)
+      push(subscriptions)
+    end
+
+    def deliver_later(subscriptions, wait: nil, wait_until: nil, queue: nil, priority: nil)
+      subscriptions = Array(subscriptions)
+
+      subscriptions.each do |subscription|
+        job = ActionWebPush::DeliveryJob.set(
+          wait: wait,
+          wait_until: wait_until,
+          queue: queue || :action_web_push,
+          priority: priority
+        )
+
+        job.perform_later(params, { id: subscription.id })
+      end
+    end
+
+    private
+
+    def build_notifications(subscriptions, **notification_params)
+      subscriptions = subscriptions.is_a?(Array) ? subscriptions : [subscriptions]
+      subscriptions.map do |subscription|
+        if subscription.respond_to?(:build_notification)
+          subscription.build_notification(**notification_params)
+        else
+          # Handle hash-based subscription data
+          ActionWebPush::Notification.new(
+            endpoint: subscription.is_a?(Hash) ? subscription[:endpoint] : subscription.endpoint,
+            p256dh_key: subscription.is_a?(Hash) ? subscription[:p256dh_key] : subscription.p256dh_key,
+            auth_key: subscription.is_a?(Hash) ? subscription[:auth_key] : subscription.auth_key,
+            **notification_params
+          )
+        end
+      end
+    end
+
+    def deliver_notifications(notifications)
+      if defined?(Rails) && Rails.respond_to?(:configuration) && Rails.configuration.respond_to?(:x) && Rails.configuration.x.respond_to?(:action_web_push_pool)
+        Rails.configuration.x.action_web_push_pool.queue(notifications)
+      else
+        # Fallback to direct delivery
+        delivery_method = ActionWebPush::DeliveryMethods.for(ActionWebPush.config.delivery_method)
+        notifications.each { |notification| delivery_method.deliver!(notification) }
+      end
+    end
+
+    def self.default(**params)
+      # Create a new merged hash without mutating existing params
+      merged_params = default_params.merge(params)
+      self.default_params = merged_params
+    end
+  end
+end

data/lib/actionwebpush/batch_delivery.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class BatchDelivery
+    include ActionWebPush::Logging
+    include ActionWebPush::Authorization
+    attr_reader :notifications, :pool, :batch_size, :current_user
+
+    def initialize(notifications, pool: nil, batch_size: nil, current_user: nil)
+      @notifications = Array(notifications)
+      @pool = pool || (defined?(Rails) ? Rails.configuration.x.action_web_push_pool : nil)
+      @batch_size = batch_size || ActionWebPush.config.batch_size || 100
+      @current_user = current_user || ActionWebPush::Authorization::Utils.current_user_context
+
+      # Authorization check for batch operations
+      if @current_user && !ActionWebPush::Authorization::Utils.authorization_bypassed?
+        # Extract subscriptions from notifications for authorization check
+        subscriptions = extract_subscriptions_from_notifications(@notifications)
+        authorize_batch_operation!(
+          current_user: @current_user,
+          subscriptions: subscriptions
+        )
+      end
+    end
+
+    def deliver_all
+      # Process notifications in batches to avoid overwhelming the system
+      notifications.each_slice(batch_size) do |batch|
+        if pool
+          batch_deliver_with_pool(batch)
+        else
+          direct_batch_deliver(batch)
+        end
+      end
+    end
+
+    def self.deliver(notifications, **options)
+      new(notifications, **options).deliver_all
+    end
+
+    private
+
+    def batch_deliver_with_pool(batch_notifications)
+      # Group notifications by endpoint to avoid overwhelming single endpoints
+      grouped = batch_notifications.group_by(&:endpoint)
+
+      grouped.each do |endpoint, endpoint_notifications|
+        # Stagger delivery to same endpoint to avoid rate limiting
+        endpoint_notifications.each_with_index do |notification, index|
+          pool.delivery_pool.post do
+            sleep(index * 0.01) if index > 0 # Small delay between same endpoint
+            deliver_single(notification)
+          end
+        end
+      end
+    end
+
+    def direct_batch_deliver(batch_notifications)
+      batch_notifications.each { |notification| deliver_single(notification) }
+    end
+
+    def deliver_single(notification)
+      notification.deliver_now
+    rescue ActionWebPush::ExpiredSubscriptionError => e
+      # Handle expired subscription cleanup if we can identify the subscription
+      handle_expired_subscription(notification)
+    rescue StandardError => e
+      logger.error "ActionWebPush batch delivery failed: #{e.class} #{e.message}"
+    end
+
+    def handle_expired_subscription(notification)
+      # Try to find and clean up the expired subscription
+      subscription = ActionWebPush::Subscription.find_by(endpoint: notification.endpoint)
+      subscription&.destroy
+    rescue StandardError => e
+      logger.warn "Failed to cleanup expired subscription: #{e.message}"
+    end
+
+    def extract_subscriptions_from_notifications(notifications)
+      # Extract subscription information from notifications for authorization
+      notifications.map do |notification|
+        if notification.respond_to?(:endpoint)
+          # Try to find the subscription by endpoint
+          ActionWebPush::Subscription.find_by(endpoint: notification.endpoint)
+        else
+          nil
+        end
+      end.compact
+    end
+
+  end
+end

data/lib/actionwebpush/configuration.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class Configuration
+    attr_accessor :vapid_public_key, :vapid_private_key, :vapid_subject
+    attr_accessor :pool_size, :queue_size, :delivery_method, :connection_pool_size, :batch_size
+    attr_accessor :logger, :timeout, :max_retries, :async
+    attr_reader :delivery_methods
+
+    def initialize
+      @pool_size = 50
+      @queue_size = 10000
+      @connection_pool_size = 150
+      @batch_size = 100
+      @delivery_method = :web_push
+      @vapid_subject = "mailto:support@example.com"
+      @logger = nil
+      @timeout = 30
+      @max_retries = 3
+      @async = false
+      @delivery_methods = {
+        web_push: ActionWebPush::DeliveryMethods::WebPush,
+        test: ActionWebPush::DeliveryMethods::Test
+      }
+    end
+
+    def vapid_keys
+      {
+        public_key: vapid_public_key,
+        private_key: vapid_private_key
+      }
+    end
+
+    def valid?
+      validate!
+      true
+    rescue ConfigurationError
+      false
+    end
+
+    def validate!
+      errors = []
+
+      # VAPID keys validation
+      errors << "vapid_public_key is required" if vapid_public_key.blank?
+      errors << "vapid_private_key is required" if vapid_private_key.blank?
+
+      if vapid_public_key.present? && vapid_public_key.length != 87
+        errors << "vapid_public_key must be 87 characters long (Base64 encoded)"
+      end
+
+      if vapid_private_key.present? && vapid_private_key.length != 43
+        errors << "vapid_private_key must be 43 characters long (Base64 encoded)"
+      end
+
+      # Email validation for vapid_subject
+      if vapid_subject.present? && !vapid_subject.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\z/i)
+        errors << "vapid_subject must be a valid email address (format: mailto:email@domain.com)"
+      end
+
+      # Numeric validations with reasonable bounds
+      errors << "pool_size must be between 1 and 1000" unless pool_size.is_a?(Integer) && pool_size.between?(1, 1000)
+      errors << "queue_size must be between 1 and 100000" unless queue_size.is_a?(Integer) && queue_size.between?(1, 100000)
+      errors << "connection_pool_size must be between 1 and 1000" unless connection_pool_size.is_a?(Integer) && connection_pool_size.between?(1, 1000)
+      errors << "batch_size must be between 1 and 10000" unless batch_size.is_a?(Integer) && batch_size.between?(1, 10000)
+      errors << "timeout must be between 1 and 300 seconds" unless timeout.is_a?(Integer) && timeout.between?(1, 300)
+      errors << "max_retries must be between 0 and 10" unless max_retries.is_a?(Integer) && max_retries.between?(0, 10)
+
+      # Delivery method validation
+      unless delivery_methods.key?(delivery_method)
+        available = delivery_methods.keys.join(", ")
+        errors << "delivery_method must be one of: #{available}"
+      end
+
+      # Boolean validation
+      unless [true, false].include?(async)
+        errors << "async must be true or false"
+      end
+
+      raise ConfigurationError, "Configuration errors: #{errors.join('; ')}" if errors.any?
+    end
+
+    def delivery_method_class
+      delivery_methods[delivery_method] || raise(ConfigurationError, "Unknown delivery method: #{delivery_method}")
+    end
+
+    def add_delivery_method(name, klass)
+      delivery_methods[name] = klass
+    end
+  end
+end

data/lib/actionwebpush/delivery_job.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class DeliveryJob < ActiveJob::Base
+    queue_as :action_web_push
+
+    # Retry on transient failures
+    retry_on ActionWebPush::DeliveryError, wait: :polynomially_longer, attempts: 5
+    retry_on Net::TimeoutError, wait: :exponentially_longer, attempts: 3
+    retry_on Errno::ECONNREFUSED, wait: :exponentially_longer, attempts: 3
+
+    # Don't retry on permanent failures
+    discard_on ActionWebPush::ExpiredSubscriptionError
+    discard_on ActiveRecord::RecordNotFound
+
+    def perform(notification_params, subscription_params = nil)
+      if subscription_params
+        # Single subscription with notification data
+        subscription = ActionWebPush::Subscription.find(subscription_params[:id])
+        notification = subscription.build_notification(**notification_params)
+        deliver_with_error_handling(notification, subscription)
+      else
+        # Direct notification delivery
+        notification = ActionWebPush::Notification.new(**notification_params)
+        deliver_with_error_handling(notification)
+      end
+    end
+
+    private
+
+    def deliver_with_error_handling(notification, subscription = nil)
+      notification.deliver_now
+
+      logger.info "ActionWebPush delivered: #{notification.title} to #{notification.endpoint[0..50]}..."
+    rescue ActionWebPush::ExpiredSubscriptionError => e
+      # Handle expired subscription
+      if subscription
+        subscription.destroy
+        logger.info "ActionWebPush destroyed expired subscription: #{subscription.id}"
+      end
+      raise # Re-raise to trigger discard_on
+    rescue ActionWebPush::DeliveryError => e
+      # Log delivery error and re-raise for retry
+      logger.warn "ActionWebPush delivery failed (will retry): #{e.message}"
+      raise
+    rescue StandardError => e
+      # Catch-all for unexpected errors
+      logger.error "ActionWebPush unexpected error: #{e.class} #{e.message}"
+      raise ActionWebPush::DeliveryError, "Unexpected delivery failure: #{e.message}"
+    end
+  end
+end

data/lib/actionwebpush/delivery_methods/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  module DeliveryMethods
+    class Base
+      include ActionWebPush::Logging
+
+      attr_reader :settings
+
+      def initialize(settings = {})
+        @settings = settings
+      end
+
+      def deliver!(notification, connection: nil)
+        raise NotImplementedError, "Subclasses must implement deliver!"
+      end
+    end
+  end
+end

data/lib/actionwebpush/delivery_methods/test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  module DeliveryMethods
+    class Test < Base
+      @@deliveries = []
+
+      def self.deliveries
+        @@deliveries
+      end
+
+      def self.deliveries=(value)
+        @@deliveries = value
+      end
+
+      def deliver!(notification, connection: nil)
+        self.class.deliveries << {
+          title: notification.title,
+          body: notification.body,
+          data: notification.data,
+          endpoint: notification.endpoint,
+          p256dh_key: notification.p256dh_key,
+          auth_key: notification.auth_key,
+          options: notification.options,
+          delivered_at: Time.now
+        }
+
+        logger.info "ActionWebPush::Test delivered: #{notification.title}"
+      end
+
+      def self.clear_deliveries!
+        deliveries.clear
+      end
+    end
+  end
+end

data/lib/actionwebpush/delivery_methods/web_push.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "web-push"
+
+module ActionWebPush
+  module DeliveryMethods
+    class WebPush < Base
+      def deliver!(notification, connection: nil)
+        ActionWebPush::Instrumentation.instrument("notification_delivery",
+          endpoint: notification.endpoint,
+          title: notification.title,
+          urgency: notification.options[:urgency] || "high"
+        ) do |payload|
+          response = ::WebPush.payload_send(
+            message: encoded_message(notification),
+            endpoint: notification.endpoint,
+            p256dh: notification.p256dh_key,
+            auth: notification.auth_key,
+            vapid: vapid_identification,
+            connection: connection,
+            urgency: notification.options[:urgency] || "high"
+          )
+
+          payload[:success] = response.success?
+          payload[:response_code] = response.code if response.respond_to?(:code)
+
+          response.success?
+        end
+      rescue ::WebPush::ExpiredSubscription => e
+        context = {
+          endpoint: notification.endpoint,
+          subscription_id: notification.respond_to?(:subscription_id) ? notification.subscription_id : nil
+        }
+        raise ActionWebPush::ErrorHandler.handle_expired_subscription_error(
+          ActionWebPush::ExpiredSubscriptionError.new(e.message), context
+        )
+      rescue StandardError => e
+        context = {
+          endpoint: notification.endpoint,
+          title: notification.title,
+          retry_count: 0
+        }
+        raise ActionWebPush::ErrorHandler.handle_delivery_failure(
+          ActionWebPush::DeliveryError.new("Failed to deliver push notification: #{e.message}"), context
+        )
+      end
+
+      private
+
+      def vapid_identification
+        config = ActionWebPush.config
+        {
+          subject: config.vapid_subject,
+          public_key: config.vapid_public_key,
+          private_key: config.vapid_private_key
+        }
+      end
+
+      def encoded_message(notification)
+        payload = {
+          title: notification.title,
+          options: {
+            body: notification.body,
+            icon: notification.options[:icon],
+            badge: notification.options[:badge],
+            data: notification.data
+          }
+        }
+
+        JSON.generate(payload)
+      end
+    end
+  end
+end

data/lib/actionwebpush/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module ActionWebPush
+  class Engine < ::Rails::Engine
+    isolate_namespace ActionWebPush
+
+    config.generators do |g|
+      g.test_framework :minitest
+      g.orm :active_record
+    end
+
+    initializer "action_web_push.routes" do |app|
+      app.routes.prepend do
+        mount ActionWebPush::Engine => "/action_web_push"
+      end
+    end
+  end
+end

data/lib/actionwebpush/error_handler.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  module ErrorHandler
+    def self.handle_delivery_error(error, context = {})
+      case error
+      when ActionWebPush::ExpiredSubscriptionError
+        handle_expired_subscription_error(error, context)
+      when ActionWebPush::RateLimitExceeded
+        handle_rate_limit_error(error, context)
+      when ActionWebPush::DeliveryError
+        handle_delivery_failure(error, context)
+      when ActionWebPush::ConfigurationError
+        handle_configuration_error(error, context)
+      else
+        handle_unexpected_error(error, context)
+      end
+    end
+
+    def self.handle_expired_subscription_error(error, context)
+      ActionWebPush::Instrumentation.publish("subscription_expired",
+        error: error.message,
+        endpoint: context[:endpoint],
+        subscription_id: context[:subscription_id]
+      )
+
+      ActionWebPush.logger.info "Subscription expired: #{error.message}"
+
+      # Cleanup subscription if possible
+      cleanup_expired_subscription(context[:subscription_id]) if context[:subscription_id]
+
+      error
+    end
+
+    def self.handle_rate_limit_error(error, context)
+      ActionWebPush::Instrumentation.publish("rate_limit_exceeded",
+        error: error.message,
+        resource_type: context[:resource_type],
+        resource_id: context[:resource_id]
+      )
+
+      ActionWebPush.logger.warn "Rate limit exceeded: #{error.message}"
+      error
+    end
+
+    def self.handle_delivery_failure(error, context)
+      ActionWebPush::Instrumentation.publish("notification_delivery_failed",
+        error: error.message,
+        error_class: error.class.name,
+        endpoint: context[:endpoint],
+        notification_title: context[:title],
+        retry_count: context[:retry_count] || 0
+      )
+
+      retry_count = context[:retry_count]
+      log_level = (retry_count.is_a?(Integer) && retry_count > 2) ? :error : :warn
+      ActionWebPush.logger.send(log_level, "Delivery failed: #{error.message}")
+
+      error
+    end
+
+    def self.handle_configuration_error(error, context)
+      ActionWebPush::Instrumentation.publish("configuration_error",
+        error: error.message,
+        context: context
+      )
+
+      ActionWebPush.logger.error "Configuration error: #{error.message}"
+      error
+    end
+
+    def self.handle_unexpected_error(error, context)
+      ActionWebPush::Instrumentation.publish("unexpected_error",
+        error: error.message,
+        error_class: error.class.name,
+        backtrace: error.backtrace&.first(5),
+        context: context
+      )
+
+      ActionWebPush.logger.error "Unexpected error in ActionWebPush: #{error.class} #{error.message}"
+
+      # Wrap in ActionWebPush error for consistency
+      ActionWebPush::DeliveryError.new("Unexpected error: #{error.message}")
+    end
+
+    private
+
+    def self.cleanup_expired_subscription(subscription_id)
+      return unless defined?(ActionWebPush::Subscription)
+
+      subscription = ActionWebPush::Subscription.find_by(id: subscription_id)
+      subscription&.destroy
+
+      ActionWebPush.logger.debug "Cleaned up expired subscription #{subscription_id}"
+    rescue StandardError => e
+      ActionWebPush.logger.warn "Failed to cleanup expired subscription #{subscription_id}: #{e.message}"
+    end
+  end
+end

data/lib/actionwebpush/generators/campfire_migration_generator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module ActionWebPush
+  module Generators
+    class CampfireMigrationGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generate migration from Campfire's existing push_subscriptions to ActionWebPush"
+
+      class_option :table_name, type: :string, default: "push_subscriptions",
+                   desc: "Name of existing Campfire table"
+
+      class_option :preserve_data, type: :boolean, default: true,
+                   desc: "Whether to preserve existing subscription data"
+
+      def create_data_migration
+        template(
+          "campfire_data_migration.rb",
+          "db/migrate/#{timestamp}_migrate_campfire_push_subscriptions_to_action_web_push.rb",
+          migration_version: migration_version
+        )
+      end
+
+      def create_compatibility_module
+        template(
+          "campfire_compatibility.rb",
+          "lib/action_web_push/campfire_compatibility.rb"
+        )
+      end
+
+      def show_migration_instructions
+        say "\n" + "="*70
+        say "Campfire to ActionWebPush Migration Generated!"
+        say "="*70
+        say "\nNext steps:"
+        say "1. Review the generated migration file"
+        say "2. Backup your existing push_subscriptions data"
+        say "3. Run: rails db:migrate"
+        say "4. Update your Campfire code to use ActionWebPush"
+        say "5. Test thoroughly in staging environment"
+        say "\nCompatibility module created at: lib/action_web_push/campfire_compatibility.rb"
+        say "This provides backward compatibility during the transition period."
+        say "\nIMPORTANT: Test this migration on a copy of production data first!"
+      end
+
+      private
+
+      def timestamp
+        Time.current.strftime("%Y%m%d%H%M%S")
+      end
+
+      def migration_version
+        if Rails::VERSION::MAJOR >= 5
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+
+      def old_table_name
+        options[:table_name]
+      end
+
+      def preserve_data?
+        options[:preserve_data]
+      end
+    end
+  end
+end