maia 4.0.0 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1f16e5e9cba3546a3653e1fd2e3f87d19fa46784
-  data.tar.gz: aa5f6350dd17689e8dd01c999c3f509680b73e80
+SHA256:
+  metadata.gz: d3efb00ad0b208362f022cc62718c3e7acf26f850007dfa899123f5b1de33250
+  data.tar.gz: 77b3a882f44ee407c1bc00075ba591646097adbb284f8a7429de575b43ca28a8
 SHA512:
-  metadata.gz: 51ae47908f1ae0e3a1e0b04eb3812023a20db60276b07fa2156583b325191ea7c3231057d0f461c36832dcfd9db6d37c831b10f1a58f5e2cd304431197f4ad71
-  data.tar.gz: 1bbdf160cdeaefebd160966ad92c39ec18d795af55a2e0e4ec291b91e8af91dd199e0d1374cda1bea091f29f150a8f523584221c505274d12cd1ad72f9c82a9c
+  metadata.gz: d8ff83629565645b0b6ea9c8802974d0d924f08c596f61364956b73e92bf4610f801ba41b8a9e9b486cc8c19a0db0e1f3445d1217dda66e205554c2c28e962d3
+  data.tar.gz: 31da736742c1b67abbdea6863f2cd090576f7f08bde0466dabee5f1cee6e088ff6428439731886d14c060207498a673b4f5171c62f7354a1212e670f9772ca2a

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
@@ -25,7 +24,7 @@ module Maia
       end
 
       def find_device(token = params[:device][:token])
-        current_user.devices.find_by token: token
+        current_user.devices.find_by! token: token
       end
 
       def update_device(device)
@@ -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,44 @@
+require 'googleauth'
+
+module Maia
+  module FCM
+    class Credentials
+      SCOPE = 'https://www.googleapis.com/auth/firebase.messaging'.freeze
+
+      def initialize(path = ENV['GOOGLE_APPLICATION_CREDENTIALS'], cache: Rails.cache)
+        @path  = path
+        @cache = cache
+      end
+
+      def project
+        @project ||= to_h['project_id']
+      end
+
+      def token
+        @cache.fetch('maia-fcm-token', expires_in: 1.hour) do
+          credentials.fetch_access_token!['access_token']
+        end
+      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
+          Maia::FCM::Connection.new(@auth.project, @auth.token)
+        end
+    end
+  end
+end