actionwebpush 0.1.0

data/lib/actionwebpush/generators/install_generator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module ActionWebPush
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_migration
+        migration_template(
+          "create_action_web_push_subscriptions.rb",
+          "db/migrate/create_action_web_push_subscriptions.rb",
+          migration_version: migration_version
+        )
+      end
+
+      def create_initializer
+        template "initializer.rb", "config/initializers/action_web_push.rb"
+      end
+
+      def mount_engine
+        route "mount ActionWebPush::Engine => '/push'"
+      end
+
+      def show_readme
+        say "\n" + "="*50
+        say "ActionWebPush has been installed!"
+        say "="*50
+        say "\nNext steps:"
+        say "1. Run: rails db:migrate"
+        say "2. Configure VAPID keys in config/initializers/action_web_push.rb"
+        say "3. Add 'has_many :push_subscriptions, class_name: \"ActionWebPush::Subscription\"' to your User model"
+        say "4. Generate VAPID keys with: bundle exec rails generate action_web_push:vapid_keys"
+        say "\nFor more information, visit: https://github.com/keshav-k3/actionwebpush"
+      end
+
+      private
+
+      def migration_version
+        if Rails::VERSION::MAJOR >= 5
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+    end
+  end
+end

data/lib/actionwebpush/generators/templates/campfire_compatibility.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+# Compatibility module for transitioning from Campfire's web push to ActionWebPush
+# Include this in your existing code during the migration period
+
+module ActionWebPush
+  module CampfireCompatibility
+    extend ActiveSupport::Concern
+
+    included do
+      # Alias old method names to new ones
+      alias_method :push_subscriptions, :action_web_push_subscriptions if respond_to?(:action_web_push_subscriptions)
+    end
+
+    module ClassMethods
+      # Provide backward compatibility for existing Campfire classes
+      def setup_campfire_compatibility
+        # Map old WebPush module to ActionWebPush
+        if defined?(::WebPush::Notification)
+          ::WebPush::Notification.class_eval do
+            def self.new(*args, **kwargs)
+              ActionWebPush::Notification.new(*args, **kwargs)
+            end
+          end
+        end
+
+        # Map old Pool class
+        if defined?(::WebPush::Pool)
+          ::WebPush::Pool.class_eval do
+            def self.new(*args, **kwargs)
+              ActionWebPush::Pool.new(*args, **kwargs)
+            end
+          end
+        end
+      end
+    end
+
+    # Legacy notification pusher that mimics Campfire's Room::MessagePusher
+    class LegacyMessagePusher
+      attr_reader :room, :message
+
+      def initialize(room:, message:)
+        @room, @message = room, message
+      end
+
+      def push
+        build_payload.tap do |payload|
+          push_to_users_involved_in_everything(payload)
+          push_to_users_involved_in_mentions(payload)
+        end
+      end
+
+      private
+
+      def build_payload
+        if room.direct?
+          build_direct_payload
+        else
+          build_shared_payload
+        end
+      end
+
+      def build_direct_payload
+        {
+          title: message.creator.name,
+          body: message.plain_text_body,
+          data: { path: room_path }
+        }
+      end
+
+      def build_shared_payload
+        {
+          title: room.name,
+          body: "#{message.creator.name}: #{message.plain_text_body}",
+          data: { path: room_path }
+        }
+      end
+
+      def push_to_users_involved_in_everything(payload)
+        subscriptions = relevant_subscriptions.merge(involved_in_everything_scope)
+        ActionWebPush::BatchDelivery.deliver(
+          subscriptions.map { |sub| sub.build_notification(**payload) }
+        )
+      end
+
+      def push_to_users_involved_in_mentions(payload)
+        return unless message.mentionees.any?
+
+        subscriptions = relevant_subscriptions
+                       .merge(involved_in_mentions_scope)
+                       .where(user_id: message.mentionees.ids)
+
+        ActionWebPush::BatchDelivery.deliver(
+          subscriptions.map { |sub| sub.build_notification(**payload) }
+        )
+      end
+
+      def relevant_subscriptions
+        ActionWebPush::Subscription
+          .joins(user: :memberships)
+          .merge(visible_disconnected_scope)
+          .where.not(user: message.creator)
+      end
+
+      def involved_in_everything_scope
+        # This should match your existing Membership.involved_in_everything scope
+        # Placeholder implementation:
+        Membership.where(involved_in_everything: true)
+      end
+
+      def involved_in_mentions_scope
+        # This should match your existing Membership.involved_in_mentions scope
+        # Placeholder implementation:
+        Membership.where(involved_in_mentions: true)
+      end
+
+      def visible_disconnected_scope
+        # This should match your existing Membership.visible.disconnected.where(room: room) scope
+        # Placeholder implementation:
+        Membership.where(room: room, visible: true, connected: false)
+      end
+
+      def room_path
+        # Use your existing route helper
+        Rails.application.routes.url_helpers.room_path(room)
+      rescue
+        "/rooms/#{room.id}"
+      end
+    end
+
+    # Helper methods for migrating existing code
+    module MigrationHelpers
+      def migrate_push_subscription_creation(params)
+        # Convert old push subscription params to ActionWebPush format
+        {
+          endpoint: params[:endpoint],
+          p256dh_key: params[:p256dh_key] || params[:keys]&.dig(:p256dh),
+          auth_key: params[:auth_key] || params[:keys]&.dig(:auth),
+          user_agent: params[:user_agent]
+        }
+      end
+
+      def create_action_web_push_subscription(user, params)
+        ActionWebPush::Subscription.find_or_create_subscription(
+          user: user,
+          **migrate_push_subscription_creation(params)
+        )
+      end
+
+      # Batch migrate existing Push::Subscription records
+      def migrate_legacy_subscriptions!(batch_size: 1000)
+        return unless defined?(Push::Subscription)
+
+        Push::Subscription.find_in_batches(batch_size: batch_size) do |batch|
+          batch.each do |legacy_subscription|
+            ActionWebPush::Subscription.find_or_create_subscription(
+              user: legacy_subscription.user,
+              endpoint: legacy_subscription.endpoint,
+              p256dh_key: legacy_subscription.p256dh_key,
+              auth_key: legacy_subscription.auth_key,
+              user_agent: legacy_subscription.user_agent
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-setup compatibility when this file is loaded
+if Rails.env.development? || Rails.env.staging?
+  ActionWebPush::CampfireCompatibility.setup_campfire_compatibility
+end

data/lib/actionwebpush/generators/templates/campfire_data_migration.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+class MigrateCampfirePushSubscriptionsToActionWebPush < ActiveRecord::Migration<%= migration_version %>
+  def up
+    # Create new ActionWebPush subscriptions table if it doesn't exist
+    unless table_exists?(:action_web_push_subscriptions)
+      create_table :action_web_push_subscriptions do |t|
+        t.references :user, null: false, foreign_key: true
+        t.string :endpoint, null: false
+        t.string :p256dh_key, null: false
+        t.string :auth_key, null: false
+        t.string :user_agent
+        t.timestamps null: false
+
+        t.index [:user_id]
+        t.index [:endpoint, :p256dh_key, :auth_key], name: "idx_action_web_push_subscription_keys"
+      end
+    end
+
+    <% if preserve_data? %>
+    # Migrate existing data
+    if table_exists?(:<%= old_table_name %>)
+      say "Migrating data from <%= old_table_name %> to action_web_push_subscriptions..."
+
+      # Migrate in batches to avoid memory issues
+      batch_size = 1000
+      offset = 0
+
+      loop do
+        batch = connection.select_all(
+          "SELECT * FROM <%= old_table_name %> LIMIT #{batch_size} OFFSET #{offset}"
+        )
+
+        break if batch.empty?
+
+        batch.each do |record|
+          # Map old columns to new columns
+          new_record = {
+            user_id: record['user_id'],
+            endpoint: record['endpoint'],
+            p256dh_key: record['p256dh_key'],
+            auth_key: record['auth_key'],
+            user_agent: record['user_agent'],
+            created_at: record['created_at'] || Time.current,
+            updated_at: record['updated_at'] || Time.current
+          }
+
+          # Insert with duplicate handling
+          connection.execute(
+            sanitize_sql_array([
+              "INSERT INTO action_web_push_subscriptions (user_id, endpoint, p256dh_key, auth_key, user_agent, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?)
+               ON CONFLICT (endpoint, p256dh_key, auth_key) DO NOTHING",
+              new_record[:user_id],
+              new_record[:endpoint],
+              new_record[:p256dh_key],
+              new_record[:auth_key],
+              new_record[:user_agent],
+              new_record[:created_at],
+              new_record[:updated_at]
+            ])
+          )
+        end
+
+        offset += batch_size
+        say "Migrated batch #{offset / batch_size} (#{offset} total records)"
+      end
+
+      migrated_count = connection.select_value("SELECT COUNT(*) FROM action_web_push_subscriptions")
+      original_count = connection.select_value("SELECT COUNT(*) FROM <%= old_table_name %>")
+
+      say "Migration completed: #{migrated_count} records in new table, #{original_count} in original table"
+    end
+    <% end %>
+
+    # Create a backup table for safety
+    if table_exists?(:<%= old_table_name %>) && !table_exists?(:<%= old_table_name %>_backup)
+      connection.execute("CREATE TABLE <%= old_table_name %>_backup AS SELECT * FROM <%= old_table_name %>")
+      say "Created backup table: <%= old_table_name %>_backup"
+    end
+  end
+
+  def down
+    # Remove ActionWebPush table and restore from backup if needed
+    drop_table :action_web_push_subscriptions if table_exists?(:action_web_push_subscriptions)
+
+    if table_exists?(:<%= old_table_name %>_backup) && !table_exists?(:<%= old_table_name %>)
+      connection.execute("CREATE TABLE <%= old_table_name %> AS SELECT * FROM <%= old_table_name %>_backup")
+      say "Restored from backup table: <%= old_table_name %>_backup"
+    end
+  end
+
+  private
+
+  def sanitize_sql_array(array)
+    ActiveRecord::Base.sanitize_sql_array(array)
+  end
+end

data/lib/actionwebpush/generators/templates/create_action_web_push_subscriptions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateActionWebPushSubscriptions < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :action_web_push_subscriptions do |t|
+      t.references :user, null: false, foreign_key: true
+      t.string :endpoint, null: false
+      t.string :p256dh_key, null: false
+      t.string :auth_key, null: false
+      t.string :user_agent
+      t.timestamps null: false
+
+      t.index [:user_id]
+      t.index [:endpoint, :p256dh_key, :auth_key], name: "idx_action_web_push_subscription_keys"
+    end
+  end
+end

data/lib/actionwebpush/generators/templates/initializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+ActionWebPush.configure do |config|
+  # VAPID keys for Web Push notifications
+  # Generate with: bundle exec rails generate action_web_push:vapid_keys
+  config.vapid_public_key = ENV['VAPID_PUBLIC_KEY']
+  config.vapid_private_key = ENV['VAPID_PRIVATE_KEY']
+  config.vapid_subject = 'mailto:support@example.com'
+
+  # Thread pool configuration
+  config.pool_size = 50
+  config.queue_size = 10000
+
+  # Delivery method
+  config.delivery_method = :web_push
+end

data/lib/actionwebpush/generators/vapid_keys_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "web-push"
+
+module ActionWebPush
+  module Generators
+    class VapidKeysGenerator < Rails::Generators::Base
+      desc "Generate VAPID key pair for Web Push notifications"
+
+      def generate_vapid_keys
+        vapid_key = WebPush.generate_key
+
+        say "Generated VAPID key pair:"
+        say "========================="
+        say ""
+        say "Add these to your environment variables or Rails credentials:"
+        say ""
+        say "VAPID_PUBLIC_KEY=#{vapid_key.public_key}"
+        say "VAPID_PRIVATE_KEY=#{vapid_key.private_key}"
+        say ""
+        say "Or add to config/credentials.yml.enc:"
+        say ""
+        say "action_web_push:"
+        say "  vapid_public_key: #{vapid_key.public_key}"
+        say "  vapid_private_key: #{vapid_key.private_key}"
+        say ""
+        say "Then update your config/initializers/action_web_push.rb:"
+        say ""
+        say "ActionWebPush.configure do |config|"
+        say "  config.vapid_public_key = Rails.application.credentials.action_web_push[:vapid_public_key]"
+        say "  config.vapid_private_key = Rails.application.credentials.action_web_push[:vapid_private_key]"
+        say "  # ... other config"
+        say "end"
+      end
+    end
+  end
+end

data/lib/actionwebpush/instrumentation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  module Instrumentation
+    def self.instrument(event_name, payload = {})
+      if defined?(ActiveSupport::Notifications)
+        ActiveSupport::Notifications.instrument("action_web_push.#{event_name}", payload) do |notification_payload|
+          yield notification_payload if block_given?
+        end
+      else
+        yield payload if block_given?
+      end
+    end
+
+    def self.publish(event_name, payload = {})
+      if defined?(ActiveSupport::Notifications)
+        ActiveSupport::Notifications.publish("action_web_push.#{event_name}", payload)
+      end
+    end
+
+    # Available events:
+    # action_web_push.notification_delivery
+    # action_web_push.notification_delivery_failed
+    # action_web_push.pool_overflow
+    # action_web_push.rate_limit_exceeded
+    # action_web_push.batch_delivery
+    # action_web_push.subscription_expired
+    # action_web_push.subscription_created
+    # action_web_push.subscription_destroyed
+  end
+end

data/lib/actionwebpush/logging.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module ActionWebPush
+  module Logging
+    def logger
+      ActionWebPush.logger
+    end
+
+    module_function :logger
+  end
+
+  class << self
+    def logger
+      @logger ||= config.logger || default_logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    private
+
+    def default_logger
+      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+        Rails.logger
+      else
+        Logger.new(STDOUT).tap do |log|
+          log.level = Logger::INFO
+          log.formatter = proc do |severity, datetime, progname, msg|
+            "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity} -- ActionWebPush: #{msg}\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actionwebpush/metrics.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ActionWebPush
+  class Metrics
+    @mutex = Mutex.new
+    @stats = {
+      deliveries_attempted: 0,
+      deliveries_succeeded: 0,
+      deliveries_failed: 0,
+      expired_subscriptions: 0,
+      queue_size: 0
+    }
+
+    class << self
+      attr_reader :stats
+
+      def increment(metric, count = 1)
+        @mutex.synchronize { @stats[metric] += count }
+      end
+
+      def set(metric, value)
+        @mutex.synchronize { @stats[metric] = value }
+      end
+
+      def get(metric)
+        @mutex.synchronize { @stats[metric] }
+      end
+
+      def reset!
+        @mutex.synchronize do
+          @stats.keys.each { |key| @stats[key] = 0 }
+        end
+      end
+
+      def delivery_attempted!
+        increment(:deliveries_attempted)
+      end
+
+      def delivery_succeeded!
+        increment(:deliveries_succeeded)
+      end
+
+      def delivery_failed!
+        increment(:deliveries_failed)
+      end
+
+      def subscription_expired!
+        increment(:expired_subscriptions)
+      end
+
+      def success_rate
+        attempted = get(:deliveries_attempted)
+        return 0.0 if attempted.zero?
+
+        (get(:deliveries_succeeded).to_f / attempted * 100).round(2)
+      end
+
+      def failure_rate
+        100.0 - success_rate
+      end
+
+      def to_h
+        @mutex.synchronize { @stats.dup }
+      end
+    end
+  end
+end

data/lib/actionwebpush/notification.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "web-push"
+
+module ActionWebPush
+  class Notification
+    include ActionWebPush::Authorization
+    attr_reader :title, :body, :data, :endpoint, :p256dh_key, :auth_key, :options, :current_user
+
+    def initialize(title:, body:, endpoint:, p256dh_key:, auth_key:, data: {}, current_user: nil, **options)
+      @title = title
+      @body = body
+      @data = data
+      @endpoint = endpoint
+      @p256dh_key = p256dh_key
+      @auth_key = auth_key
+      @options = options
+      @current_user = current_user || ActionWebPush::Authorization::Utils.current_user_context
+    end
+
+    def deliver(connection: nil)
+      # Authorization check if current_user is present
+      if @current_user && !ActionWebPush::Authorization::Utils.authorization_bypassed?
+        # Find subscription by endpoint for authorization
+        subscription = ActionWebPush::Subscription.find_by(endpoint: endpoint)
+        if subscription
+          authorize_notification_sending!(
+            current_user: @current_user,
+            subscriptions: [subscription]
+          )
+        end
+      end
+
+      delivery_method = ActionWebPush.config.delivery_method_class.new
+      delivery_method.deliver!(self, connection: connection)
+    end
+
+    def deliver_now(connection: nil)
+      deliver(connection: connection)
+    end
+
+    def deliver_later(wait: nil, wait_until: nil, queue: nil, priority: nil)
+      job = ActionWebPush::DeliveryJob.set(
+        wait: wait,
+        wait_until: wait_until,
+        queue: queue || :action_web_push,
+        priority: priority
+      )
+
+      job.perform_later(to_params)
+    end
+
+    def to_params
+      {
+        title: title,
+        body: body,
+        data: data,
+        endpoint: endpoint,
+        p256dh_key: p256dh_key,
+        auth_key: auth_key
+      }.merge(options)
+    end
+
+    def to_json(*args)
+      {
+        title: title,
+        body: body,
+        data: data
+      }.merge(options).to_json(*args)
+    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
+      payload = {
+        title: title,
+        options: {
+          body: body,
+          icon: options[:icon],
+          badge: options[:badge],
+          data: data
+        }
+      }
+
+      JSON.generate(payload)
+    end
+  end
+end