maia 4.0.3 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1164306f881ef2bbcafa53947387cd80389f0f41c7b7cc3b1b5c685ac2d52ad3
-  data.tar.gz: a0b5faf5699c23b693c161906ab14546e0a96656a88307e8d96cac82d81ff78e
+  metadata.gz: c639cbbcef83011669667b77953c031472de6770f2a9f84bc742530c90420ef6
+  data.tar.gz: 22aace941c9ab9957ce5b4d692c088eb9f34bb45aa6df3ab2bfc9ba51ac9c695
 SHA512:
-  metadata.gz: 7b2b6a594dafbd284acfed06d67714910f04ee2795bd40b261260366ebd930334b649a2b4ed28a12a7cf9610a7931963445a2e32156ed11a930216c2ee773845
-  data.tar.gz: f8c80d2f8f1cfcb57cbad64db76b7cfc6600f161141982285221157fb0540f899b8950f03485089504e02b2f4796df6fe6011a9abacd80afed7de2432c2182d0
+  metadata.gz: 4a9c6e9b6feafc62fbd044848687685eb1882bc7e513e484a34da2c57103132440e33c1ee4c643e161f694f9a4569ba8c7d52ad41adf26e018870ec3b0d99658
+  data.tar.gz: ff3bf75e9238f9a4861626b7372ea3abb1c2e3b27458e8108fa84c39b00c5648c1737557d2afca35f067710188d6925761f5fa4e17b6ab2cb376fdc9ff5d2398

data/README.md

@@ -2,6 +2,9 @@
 
 This project maintains a `Maia::Device` model and facilitates the delivery of push notifications for iOS and Android through FCM (Firebase Cloud Messaging).
 
+As of Maia 5, only the FCM HTTP v1 is supported. Use an older version of Maia if
+you need to use the FCM legacy API.
+
 ## Installation
 
 ```
@@ -13,27 +16,39 @@ bin/rake db:migrate
 
 This will copy the `maia_devices` table into your project.
 
-## Setup
+### Messenger configuration
 
-Maia relies on [ActiveJob](https://github.com/rails/rails/tree/master/activejob) to enqueue messages. Ensure your application is properly setup with ActiveJob!
+Maia is setup to use [ActiveJob](https://github.com/rails/rails/tree/master/activejob)
+as it's default messenger. If you want to send messages inline instead, use the inline adapter:
 
-Set your FCM key in an initializer, such as `config/initializers/maia.rb`:
+```
+Maia.messenger = Maia::Messengers::Inline.new
+```
+
+or set it to anything that responds to `#deliver(payload)`.
+
+### Gateway configuration
+
+Maia uses the FCM HTTP v1 gateway by default. This assumes you are using `['GOOGLE_APPLICATION_CREDENTIALS']`
+for authentication, so you should be good to go if this environment variable is set. If not, you can pass a custom
+object to the FCM gateway as long as it responds to `#project` and `#token`.
 
-```ruby
-Maia::FCM.key = Rails.application.secrets[:fcm][:key]
+```
+Maia.gateway = Maia::FCM::Gateway.new CustomFCMCredentials.new
 ```
 
-Alternatively, you can set `ENV['FCM_KEY']`, which Maia will check first.
+### Rails configuration
 
 Include `Maia::Model` into your User model. This will attach the `has_many` relationship you need with `Maia::Device`:
 
 ```ruby
 class User
   include Maia::Model
-  # ...
 end
 ```
 
+## Device Registration
+
 Create a Devices controller where you need it, which is most likely an API. The controller itself will be generated within your application so that Maia does not make any assumptions about your method of authentication, `respond_with` mimetypes, etc. The only requirement is that `current_user` exists and returns whatever model included `Maia::Model`.
 
 Here's an example of getting setup with an API Devices controller that mobile apps can register with:
@@ -50,25 +65,17 @@ class API::DevicesController
 
 Maia provides the `create` method for you, so devices can now register themselves by POSTing to that controller. If you'd like to add any other actions, feel free.
 
-## Device Registration
-
 Devices can register with your application by submitting a POST to your devices controller with these params:
 
 ```
 { "device": { "token": "<TOKEN>" } }
 ```
 
-Where `<TOKEN>` is the token from FCM registration.
-
-## Device Management
-
-When FCM responds with an invalid or unregistered device token, the device record will be destroyed from the database.
-
-When FCM responds with a canonical ID, the device record will be updated so that it's `token` field will be equal to the canonical ID given by FCM.
+Where `<TOKEN>` is the token from FCM registration. Maia will automatically destroy devices when FCM responds with an `UNREGISTERED` error.
 
 ## Device Expiration
 
-Devices will expire after 14 days. This is to ensure user's who sell or otherwise give away their device will not be tied to that device forever. Each time a POST to Devices is received, the token expiration will be refreshed.
+Devices will expire after 14 days. This is to ensure users who sell or otherwise give away their device will not be tied to that device forever. Each time a POST to Devices is received, the token expiration will be refreshed.
 
 ## Defining Messages
 
@@ -87,16 +94,16 @@ class ExampleMessage < Maia::Message
   end
 
   # Determines the icon to load on Android phones
-  def icon
+  def image
     'icn_maia'
   end
 
-  # Will use 'default' by default. Overriding to nil will prevent sound
+  # Sound to play on arrival (nil by default)
   def sound
     'default'
   end
 
-  # Badge to use on iOS
+  # Badge to use on iOS (nil by default)
   def badge
     1
   end
@@ -106,11 +113,6 @@ class ExampleMessage < Maia::Message
     '#ffffff'
   end
 
-  # click_action on Android, category on iOS
-  def on_click
-    'SOMETHING_HAPPENED'
-  end
-
   # Any additional data to send with the payload
   def data
     { foo: :bar }
@@ -122,45 +124,17 @@ class ExampleMessage < Maia::Message
   end
 
   # Override to true in order to send the iOS content-available flag
-  def content_available?
-    false
-  end
-
-  # Override to true in order to send a dry run push. This can help debug any device errors without actually sending a push message
-  def dry_run?
+  def background?
     false
   end
 end
 ```
 
-This message will generate the following FCM payload:
-
-```json
-{
-  "priority": "normal",
-  "dry_run": false,
-  "content_available": false,
-  "data": {
-    "foo": "bar"
-  },
-  "notification": {
-    "title": "Something happened!",
-    "body": "'Something very important has happened, check it out!'",
-    "icon": "icn_maia",
-    "sound": "default",
-    "badge": 1,
-    "color": "#ffffff",
-    "click_action": "SOMETHING_HAPPENED",
-  },
-  "registration_ids": ["<TOKEN1>", "<TOKEN2>"]
-}
-```
-
 `Maia::Message` does not define a constructor so you can construct your message however you want.
 
 ## Sending messages
 
-`Maia::Message` provides a `send_to` that pushes the message out to a user (or collection of users). The argument to `send_to` should be a single record or relation of records.
+`Maia::Message` provides a `send_to` method that pushes the message out to a user (or collection of users). The argument to `send_to` should be a single record or relation of records.
 
 For example:
 
@@ -169,14 +143,16 @@ ExampleMessage.new(...).send_to User.first
 ExampleMessage.new(...).send_to User.where(beta: true)
 ```
 
-`send_to` will batch users in groups of 999 tokens (FCM limitation) and send them via ActiveJob.
+You can also send a message directly to a raw token:
 
-## Specifying job options (`wait`, `queue`, etc)
+```ruby
+ExampleMessage.new(...).send_to token: 'token123'
+```
 
-The `send_to` method passes it's last argument into [ActiveJob's `set` method](http://apidock.com/rails/ActiveJob/Core/ClassMethods/set), for example:
+or to a topic:
 
 ```ruby
-ExampleMessage.new(...).send_to User.first, wait: 10.seconds, queue: :maia
+ExampleMessage.new(...).send_to topic: 'my-topic'
 ```
 
 ## Sending a test push

data/app/controllers/concerns/maia/controller.rb

@@ -8,7 +8,6 @@ module Maia
         update_device @device
       else
         @device = create_device_token
-        send_dry_run_to current_user
       end
       respond_with @device
     end
@@ -38,10 +37,6 @@ module Maia
         current_user.devices.create permitted_params
       end
 
-      def send_dry_run_to(user)
-        Maia::DryRun.new.send_to user
-      end
-
       def permitted_params
         params.require(:device).permit :token, :platform
       end

data/app/models/maia/device.rb

@@ -23,6 +23,10 @@ module Maia
       where(pushable: pushable).distinct
     end
 
+    def self.tokens
+      pluck(:token)
+    end
+
     def self.ios
       where platform: 'ios'
     end

data/lib/maia.rb

@@ -1,22 +1,34 @@
-require 'rails'
-require 'active_support/core_ext/enumerable'
+require 'rails/all'
 
 require 'maia/engine'
 require 'maia/message'
-require 'maia/messenger'
 require 'maia/poke'
-require 'maia/dry_run'
-require 'maia/error'
+require 'maia/token'
+require 'maia/topic'
+require 'maia/devices'
+
+require 'maia/messengers/array'
+require 'maia/messengers/inline'
+require 'maia/messengers/activejob'
+
+require 'maia/error/generic'
+require 'maia/error/unregistered'
+require 'maia/error/no_credentials'
 
-require 'maia/fcm'
 require 'maia/fcm/connection'
+require 'maia/fcm/credentials'
+require 'maia/fcm/gateway'
 require 'maia/fcm/notification'
-require 'maia/fcm/response_collection'
 require 'maia/fcm/response'
-require 'maia/fcm/result_collection'
-require 'maia/fcm/result'
-require 'maia/fcm/service'
+require 'maia/fcm/serializer'
+require 'maia/fcm/platform/android'
+require 'maia/fcm/platform/apns'
 
 module Maia
-  BATCH_SIZE = 999
+  class << self
+    attr_accessor :gateway, :messenger
+  end
 end
+
+Maia.gateway   = Maia::FCM::Gateway.new
+Maia.messenger = Maia::Messengers::ActiveJob.new

data/lib/maia/devices.rb

@@ -0,0 +1,21 @@
+module Maia
+  class Devices
+    include Enumerable
+
+    def initialize(models)
+      @models = models
+    end
+
+    def each(&block)
+      tokens.each(&block)
+    end
+
+    def tokens
+      return [] if @models.empty?
+
+      Maia::Device.owned_by(@models).tokens.map do |token|
+        Maia::Token.new token
+      end
+    end
+  end
+end

data/lib/maia/error/generic.rb

@@ -0,0 +1,7 @@
+module Maia
+  module Error
+    class Generic < ::StandardError
+      attr_accessor :payload
+    end
+  end
+end

data/lib/maia/error/no_credentials.rb

@@ -0,0 +1,9 @@
+module Maia
+  module Error
+    class NoCredentials < Generic
+      def initialize
+        super 'No credentials were found for this gateway.'
+      end
+    end
+  end
+end

data/lib/maia/error/unregistered.rb

@@ -0,0 +1,12 @@
+module Maia
+  module Error
+    class Unregistered < Generic
+      def token
+        json = JSON.parse(payload)
+        json['token']
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/maia/fcm/connection.rb

@@ -1,34 +1,34 @@
 module Maia
   module FCM
     class Connection
-      URL = 'https://fcm.googleapis.com/fcm/send'.freeze
-
-      def initialize(key)
-        @key = key
+      def initialize(project, token)
+        @project = project
+        @token   = token
       end
 
       def write(payload = {})
         request = Net::HTTP::Post.new uri, headers
-        request.body = payload.to_json
+        request.body = payload
         http.request request
       end
 
-      def uri
-        URI(URL)
-      end
+      private
+        def uri
+          URI("https://fcm.googleapis.com/v1/projects/#{@project}/messages:send")
+        end
 
-      def headers
-        {
-          'Content-Type' => 'application/json',
-          'Authorization' => "key=#{@key}"
-        }
-      end
+        def headers
+          {
+            'Content-Type' => 'application/json',
+            'Authorization' => "Bearer #{@token}"
+          }
+        end
 
-      def http
-        @_http ||= Net::HTTP.new(uri.host, uri.port).tap do |h|
-          h.use_ssl = true
+        def http
+          @_http ||= Net::HTTP.new(uri.host, uri.port).tap do |h|
+            h.use_ssl = true
+          end
         end
-      end
     end
   end
 end

data/lib/maia/fcm/credentials.rb

@@ -0,0 +1,41 @@
+require 'googleauth'
+
+module Maia
+  module FCM
+    class Credentials
+      SCOPE = 'https://www.googleapis.com/auth/firebase.messaging'.freeze
+
+      def initialize(path = ENV['GOOGLE_APPLICATION_CREDENTIALS'])
+        @path = path
+      end
+
+      def project
+        to_h['project_id']
+      end
+
+      def token
+        credentials.fetch_access_token!['access_token']
+      end
+
+      def to_h
+        @to_h ||= JSON.parse file.read
+      end
+
+      private
+        def file
+          if @path && File.exist?(@path)
+            File.new @path
+          else
+            raise Maia::Error::NoCredentials
+          end
+        end
+
+        def credentials
+          @credentials ||= Google::Auth::ServiceAccountCredentials.make_creds(
+            json_key_io: file,
+            scope: SCOPE
+          )
+        end
+    end
+  end
+end

data/lib/maia/fcm/gateway.rb

@@ -0,0 +1,30 @@
+module Maia
+  module FCM
+    class Gateway
+      def initialize(auth = Maia::FCM::Credentials.new)
+        @auth = auth
+      end
+
+      def deliver(payload)
+        response = Maia::FCM::Response.new connection.write(payload)
+
+        if response.fail?
+          error = response.error
+          error.payload = payload
+          raise error
+        end
+
+        response
+      end
+
+      def serialize(message, target)
+        Maia::FCM::Serializer.new(message, target).to_json
+      end
+
+      private
+        def connection
+          @connection ||= Maia::FCM::Connection.new(@auth.project, @auth.token)
+        end
+    end
+  end
+end

data/lib/maia/fcm/notification.rb

@@ -1,26 +1,28 @@
 module Maia
   module FCM
     class Notification
-      attr_accessor :attributes
-
-      def initialize(attributes = {})
-        @attributes = attributes
+      def initialize(message)
+        @message = message
       end
 
-      def to_h
-        @attributes
+      def title
+        @message.title
       end
 
-      def ==(other)
-        attributes == other.attributes
+      def body
+        @message.body
       end
 
-      def method_missing(method_name, *args, &block)
-        @attributes.fetch(method_name) { super }
+      def image
+        @message.image
       end
 
-      def respond_to_missing?(method_name)
-        @attributes.include? method_name
+      def to_h
+        {
+          title: title,
+          body:  body,
+          image: image
+        }.compact
       end
     end
   end

data/lib/maia/fcm/platform/android.rb

@@ -0,0 +1,37 @@
+module Maia
+  module FCM
+    module Platform
+      class Android
+        def initialize(message)
+          @message = message
+        end
+
+        def color
+          @message.color
+        end
+
+        def sound
+          @message.sound
+        end
+
+        def priority
+          if @message.priority == :high
+            :high
+          else
+            :normal
+          end
+        end
+
+        def to_h
+          {
+            priority: priority.to_s,
+            notification: {
+              color: color,
+              sound: sound,
+            }.compact
+          }
+        end
+      end
+    end
+  end
+end

data/lib/maia/fcm/platform/apns.rb

@@ -0,0 +1,42 @@
+module Maia
+  module FCM
+    module Platform
+      class APNS
+        def initialize(message)
+          @message = message
+        end
+
+        def badge
+          @message.badge
+        end
+
+        def sound
+          @message.sound
+        end
+
+        def priority
+          if @message.priority == :high && !@message.background?
+            10
+          else
+            5
+          end
+        end
+
+        def to_h
+          {
+            headers: {
+              'apns-priority': priority.to_s
+            }.compact,
+            payload: {
+              aps: {
+                badge: badge,
+                sound: sound,
+                'content-available': (1 if @message.background?)
+              }.compact
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/maia/fcm/response.rb

@@ -1,15 +1,16 @@
 module Maia
   module FCM
     class Response
-      attr_reader :http_response, :tokens
+      def initialize(response)
+        @response = response
+      end
 
-      def initialize(http_response, tokens = [])
-        @http_response = http_response
-        @tokens = tokens
+      def body
+        @response.body
       end
 
       def status
-        http_response.code
+        @response.code.to_i
       end
 
       def success?
@@ -20,36 +21,21 @@ module Maia
         !success?
       end
 
-      def results
-        @_results ||= begin
-          results = to_h.fetch 'results', []
-          results.map!.with_index do |attributes, i|
-            Result.new attributes, tokens[i]
-          end
-          ResultCollection.new(results)
-        end
-      end
-
       def error
-        case status
-        when 400
-          'Invalid JSON was sent to FCM.'
-        when 401
-          'Authentication error with FCM. Check the server whitelist and the validity of your project key.'
-        when 500..599
-          'FCM Internal server error.'
+        case json.dig('error', 'status')
+        when 'UNREGISTERED'
+          Maia::Error::Unregistered.new
+        else
+          Maia::Error::Generic.new json.dig('error', 'message')
         end
       end
 
-      def retry_after
-        http_response.headers['Retry-After']
-      end
-
-      def to_h
-        JSON.parse http_response.body
-      rescue JSON::ParserError
-        {}
-      end
+      private
+        def json
+          JSON.parse body
+        rescue JSON::ParserError
+          {}
+        end
     end
   end
 end

data/lib/maia/fcm/serializer.rb

@@ -0,0 +1,38 @@
+module Maia
+  module FCM
+    class Serializer
+      def initialize(message, target)
+        @message = message
+        @target  = target
+      end
+
+      def to_h
+        {
+          message: {
+            data: @message.data.to_h,
+            notification: notification.to_h,
+            android: android.to_h,
+            apns: apns.to_h
+          }.merge(@target.to_h)
+        }
+      end
+
+      def to_json
+        to_h.to_json
+      end
+
+      private
+        def notification
+          Maia::FCM::Notification.new @message
+        end
+
+        def android
+          Maia::FCM::Platform::Android.new @message
+        end
+
+        def apns
+          Maia::FCM::Platform::APNS.new @message
+        end
+    end
+  end
+end

data/lib/maia/message.rb

@@ -1,82 +1,41 @@
 module Maia
   class Message
-    def send_to(pushable, job_options = {})
-      devices = Device.owned_by pushable
-      worker  = Messenger.set job_options
-
-      enqueue worker, devices.android
-      enqueue worker, devices.ios
-      enqueue worker, devices.unknown
-    end
-
-    def enqueue(worker, devices)
-      devices.in_batches(of: Maia::BATCH_SIZE) do |devices|
-        worker.perform_later devices.pluck(:token), to_h.deep_stringify_keys
-      end
-    end
-
-    def title
-    end
-
-    def body
-    end
-
-    def on_click
-    end
-
-    def icon
-    end
-
-    def sound
-      :default
-    end
-
-    def badge
-    end
-
-    def color
-    end
+    def title; end
+    def body;  end
+    def image; end
+    def badge; end
+    def color; end
+    def background?; end
+    def priority; end
 
     def data
+      {}
     end
 
-    def priority
-      :normal
+    def sound
+      'default'
     end
 
-    def content_available?
-      false
+    def targeting(target)
+      tap { @target = target }
     end
 
-    def content_mutable?
-      false
+    def to_json
+      to_h.to_json
     end
 
-    def dry_run?
-      false
-    end
+    def send_to(*models, topic: nil, token: nil, messenger: Maia.messenger)
+      targets = []
+      targets << Maia::Topic.new(topic) if topic
+      targets << Maia::Token.new(token) if token
 
-    def notification
-      {
-        title: title,
-        body: body,
-        icon: icon,
-        sound: sound.to_s,
-        badge: badge,
-        color: color,
-        click_action: on_click
-      }.compact
-    end
+      Maia::Devices.new(models).each do |t|
+        targets << t
+      end
 
-    def to_h
-      {
-        priority: priority.to_s,
-        dry_run: dry_run?,
-        content_available: content_available?,
-        mutable_content: content_mutable?,
-        data: data,
-        notification: notification
-      }.compact
+      targets.map do |target|
+        messenger.deliver Maia.gateway.serialize(self, target)
+      end
     end
   end
 end

data/lib/maia/messengers/activejob.rb

@@ -0,0 +1,19 @@
+module Maia
+  module Messengers
+    class ActiveJob
+      def initialize(options = {})
+        @options = options
+      end
+
+      def deliver(payload)
+        MessengerJob.set(@options).perform_later payload
+      end
+
+      class MessengerJob < ::ActiveJob::Base
+        def perform(payload)
+          Maia::Messengers::Inline.new.deliver payload
+        end
+      end
+    end
+  end
+end

data/lib/maia/messengers/array.rb

@@ -0,0 +1,21 @@
+module Maia
+  module Messengers
+    class Array
+      include Enumerable
+
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+      end
+
+      def deliver(payload)
+        @messages << payload
+      end
+
+      def each(&block)
+        @messages.map { |msg| JSON.parse(msg) }.each(&block)
+      end
+    end
+  end
+end

data/lib/maia/messengers/inline.rb

@@ -0,0 +1,13 @@
+module Maia
+  module Messengers
+    class Inline
+      def deliver(payload, gateway: Maia.gateway)
+        gateway.deliver payload
+      rescue Maia::Error::Unregistered => e
+        device = Maia::Device.find_by(token: e.token)
+        device.destroy
+        raise
+      end
+    end
+  end
+end

data/lib/maia/token.rb

@@ -0,0 +1,21 @@
+module Maia
+  class Token
+    include Enumerable
+
+    def initialize(token)
+      @token = token
+    end
+
+    def each(&block)
+      [self].each(&block)
+    end
+
+    def to_s
+      @token
+    end
+
+    def to_h
+      { token: @token }
+    end
+  end
+end

data/lib/maia/topic.rb

@@ -0,0 +1,21 @@
+module Maia
+  class Topic
+    include Enumerable
+
+    def initialize(topic)
+      @topic = topic
+    end
+
+    def each(&block)
+      [self].each(&block)
+    end
+
+    def to_s
+      @topic
+    end
+
+    def to_h
+      { topic: @topic }
+    end
+  end
+end

data/lib/maia/version.rb

@@ -1,3 +1,3 @@
 module Maia
-  VERSION = '4.0.3'.freeze
+  VERSION = '5.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maia
 version: !ruby/object:Gem::Version
-  version: 4.0.3
+  version: 5.0.0
 platform: ruby
 authors:
 - Logan Serman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-12 00:00:00.000000000 Z
+date: 2019-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -65,13 +65,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: googleauth
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -79,7 +79,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec-rails
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -93,7 +93,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -107,7 +107,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: webmock-rspec-helper
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -139,20 +139,26 @@ files:
 - config/routes.rb
 - db/migrate/20150302191320_create_maia_devices.rb
 - lib/maia.rb
-- lib/maia/dry_run.rb
+- lib/maia/devices.rb
 - lib/maia/engine.rb
-- lib/maia/error.rb
-- lib/maia/fcm.rb
+- lib/maia/error/generic.rb
+- lib/maia/error/no_credentials.rb
+- lib/maia/error/unregistered.rb
 - lib/maia/fcm/connection.rb
+- lib/maia/fcm/credentials.rb
+- lib/maia/fcm/gateway.rb
 - lib/maia/fcm/notification.rb
+- lib/maia/fcm/platform/android.rb
+- lib/maia/fcm/platform/apns.rb
 - lib/maia/fcm/response.rb
-- lib/maia/fcm/response_collection.rb
-- lib/maia/fcm/result.rb
-- lib/maia/fcm/result_collection.rb
-- lib/maia/fcm/service.rb
+- lib/maia/fcm/serializer.rb
 - lib/maia/message.rb
-- lib/maia/messenger.rb
+- lib/maia/messengers/activejob.rb
+- lib/maia/messengers/array.rb
+- lib/maia/messengers/inline.rb
 - lib/maia/poke.rb
+- lib/maia/token.rb
+- lib/maia/topic.rb
 - lib/maia/version.rb
 homepage: https://github.com/lserman/maia
 licenses:

data/lib/maia/dry_run.rb

@@ -1,15 +0,0 @@
-module Maia
-  class DryRun < Message
-    def title
-      ''
-    end
-
-    def body
-      ''
-    end
-
-    def dry_run?
-      true
-    end
-  end
-end

data/lib/maia/error.rb

@@ -1,4 +0,0 @@
-module Maia
-  class Error < StandardError
-  end
-end

data/lib/maia/fcm.rb

@@ -1,7 +0,0 @@
-module Maia
-  module FCM
-    class << self
-      attr_accessor :key
-    end
-  end
-end

data/lib/maia/fcm/response_collection.rb

@@ -1,34 +0,0 @@
-module Maia
-  module FCM
-    class ResponseCollection
-      include Enumerable
-
-      def initialize(notification, responses = [])
-        @notification = notification
-        @responses = responses
-      end
-
-      def results
-        collection = ResultCollection.new
-        @responses.each do |response|
-          response.results.each do |result|
-            collection << result
-          end
-        end
-        collection
-      end
-
-      def [](index)
-        @responses[index]
-      end
-
-      def <<(response)
-        @responses.concat Array(response).flatten
-      end
-
-      def each(&block)
-        @responses.each(&block)
-      end
-    end
-  end
-end

data/lib/maia/fcm/result.rb

@@ -1,31 +0,0 @@
-module Maia
-  module FCM
-    class Result
-      include ActiveModel::Model
-
-      attr_accessor :message_id, :registration_id, :error
-      attr_reader :token
-
-      def initialize(attributes, token)
-        super attributes
-        @token = token
-      end
-
-      def success?
-        message_id.present?
-      end
-
-      def fail?
-        !success?
-      end
-
-      def canonical_id
-        registration_id
-      end
-
-      def has_canonical_id?
-        canonical_id.present?
-      end
-    end
-  end
-end

data/lib/maia/fcm/result_collection.rb

@@ -1,35 +0,0 @@
-module Maia
-  module FCM
-    class ResultCollection
-      include Enumerable
-
-      def initialize(results = [])
-        @results = results
-      end
-
-      def succeeded
-        @results.select(&:success?)
-      end
-
-      def failed
-        @results.select(&:fail?)
-      end
-
-      def with_canonical_ids
-        @results.select(&:has_canonical_id?)
-      end
-
-      def [](index)
-        @results[index]
-      end
-
-      def <<(result)
-        @results << result
-      end
-
-      def each(&block)
-        @results.each(&block)
-      end
-    end
-  end
-end

data/lib/maia/fcm/service.rb

@@ -1,48 +0,0 @@
-module Maia
-  module FCM
-    class Service
-      def initialize
-        @connection ||= FCM::Connection.new key
-      end
-
-      def key
-        ENV.fetch 'FCM_KEY', Maia::FCM.key
-      end
-
-      def deliver(notification, *tokens, topic: nil)
-        responses = ResponseCollection.new notification
-        responses << deliver_all(notification, tokens)
-        responses << deliver_all(notification, "/topics/#{topic}") if topic
-        responses
-      end
-
-      private
-        def deliver_all(notification, tokens)
-          batch(tokens).map do |batch|
-            if batch.one?
-              unicast notification, batch.first
-            elsif batch.many?
-              multicast notification, batch
-            end
-          end
-        end
-
-        def unicast(notification, recipient)
-          deliver! notification, recipient, to: recipient
-        end
-
-        def multicast(notification, recipients)
-          deliver! notification, recipients, registration_ids: recipients
-        end
-
-        def deliver!(notification, recipients, params = {})
-          payload = notification.to_h.merge params
-          Response.new @connection.write(payload), Array(recipients)
-        end
-
-        def batch(recipients, batch_size: Maia::BATCH_SIZE)
-          Array(recipients).flatten.compact.each_slice batch_size
-        end
-    end
-  end
-end

data/lib/maia/messenger.rb

@@ -1,61 +0,0 @@
-module Maia
-  class Messenger < ActiveJob::Base
-    def perform(tokens, payload)
-      logger.info "Pushing to #{tokens.size} token(s)..."
-      logger.info "Payload: #{payload}"
-
-      notification = FCM::Notification.new payload
-      responses    = fcm.deliver notification, tokens
-
-      responses.each do |response|
-        raise Maia::Error, response.error if response.error
-        handle_errors response.results.failed
-        update_devices_to_use_canonical_ids response.results.with_canonical_ids
-      end
-    end
-
-    private
-      def fcm
-        @_service ||= FCM::Service.new
-      end
-
-      def handle_errors(results)
-        results.each do |result|
-          device = Maia::Device.find_by token: result.token
-          next unless device.present?
-
-          if device_unrecoverable? result.error
-            log_error "Destroying device #{device.id}", result, device
-            device.destroy
-          else
-            log_error "Push to device #{device.id} failed", result, device
-          end
-        end
-      end
-
-      def device_unrecoverable?(error)
-        error =~ /InvalidRegistration|NotRegistered|MismatchSenderId/
-      end
-
-      def log_error(message, result, device)
-        logger.info "#{message} (error: #{result.error}, token: #{device.token})"
-      end
-
-      def update_devices_to_use_canonical_ids(results)
-        results.each do |result|
-          device = Maia::Device.find_by token: result.token
-          next if device.nil?
-
-          if user_already_has_token_registered?(device.pushable, result.canonical_id)
-            device.destroy
-          else
-            device.update token: result.canonical_id
-          end
-        end
-      end
-
-      def user_already_has_token_registered?(user, token)
-        user.devices.exists? token: token
-      end
-  end
-end