firebase-admin 0.1.0

data/lib/firebase-admin/client.rb

@@ -0,0 +1,11 @@
+module FirebaseAdmin
+  # Wrapper for the Firebase Admin REST API
+  #
+  # @note All methods have been separated into modules and follow the same grouping used in http://???
+  # @see http://???
+  class Client < API
+    Dir[File.expand_path('client/*.rb', __dir__)].sort.each { |f| require f }
+
+    include FirebaseAdmin::Client::Accounts
+  end
+end

data/lib/firebase-admin/client/accounts.rb

@@ -0,0 +1,159 @@
+require 'jwt'
+
+module FirebaseAdmin
+  class Client
+    # Defines methods related to accounts
+    module Accounts
+      # Create a new account
+      #
+      # @param params [Hash] A customizable set of params
+      # @option options [String] :email
+      # @option options [String] :password
+      # @option options [String] :phoneNumber
+      # @option options [String] :displayName
+      # @option options [String] :photoUrl
+      # @option options [String] :customAttributes
+      # @option customAttributes [String] :roles
+      #
+      # @return [Resource]
+      # @see https://firebase.google.com/docs/reference/rest/auth#section-create-email-password
+      #
+      # @example
+      #   FirebaseAdmin.create_account(
+      #     :email => "lebron@lakers.com",
+      #     :password => "super-secret",
+      #     :phoneNumber => "+5555555555",
+      #     :displayName => "LeBron James",
+      #     :photoUrl => "http://www.example.com/photo.jpg",
+      #     :customAttributes => {
+      #       :roles => ['admin']
+      #     }
+      # )
+      def create_account(params)
+        post("v1/projects/#{project_id}/accounts", params)
+      end
+
+      # Update an existing account
+      #
+      # @param params [Hash] A customizable set of params
+      # @option options [String] :email
+      # @option options [String] :password
+      # @option options [String] :phoneNumber
+      # @option options [String] :displayName
+      # @option options [String] :photoUrl
+      # @option options [String] :customAttributes
+      # @option customAttributes [String] :roles
+      #
+      # @return [Resource]
+      # @see https://firebase.google.com/docs/reference/rest/auth
+      #
+      # @example
+      #   FirebaseAdmin.update_account(
+      #     email: "lebron@lakers.com",
+      #     password: "super-secret",
+      #     phoneNumber: "+5555555555",
+      #     displayName: "LeBron James",
+      #     photoUrl: "http://www.example.com/photo.jpg",
+      #     localId: "1234",
+      #     customAttributes: {
+      #       :roles => ['admin']
+      #     }
+      # )
+      def update_account(params)
+        post("v1/projects/#{project_id}/accounts:update", params)
+      end
+
+      # Sign in with a password
+      #
+      # @param params [Hash] A customizable set of params
+      # @option options [String] :email
+      # @option options [String] :password
+      #
+      # @return [Resource]
+      # @see https://firebase.google.com/docs/reference/rest/auth
+      #
+      # @example
+      #   FirebaseAdmin.sign_in_with_password(
+      #     email: "lebron@lakers.com",
+      #     password: "super-secret"
+      # )
+      def sign_in_with_password(params)
+        post('v1/accounts:signInWithPassword', params)
+      end
+
+      # Sign in with custom token
+      #
+      # @param token [String] A custom token
+      #
+      # @return [Resource] with idToken
+      #
+      # @example
+      #   FirebaseAdmin.sign_in_with_custom_token("...")
+      def sign_in_with_custom_token(token)
+        post('v1/accounts:signInWithCustomToken', { token: token, returnSecureToken: true })
+      end
+
+      # Create a custom JWT token for a UID
+      #
+      # @param uid [String] The uid of a user
+      #
+      # @return [String]
+      # @see https://firebase.google.com/docs/reference/rest/auth
+      #
+      # @example
+      #   FirebaseAdmin.create_custom_token('...')
+      def create_custom_token(uid)
+        credentials = default_credentials
+
+        service_account_email = credentials.fetch('client_email', ENV['GOOGLE_CLIENT_EMAIL'])
+        private_key = OpenSSL::PKey::RSA.new credentials.fetch('private_key', ENV['GOOGLE_PRIVATE_KEY'])
+
+        now_seconds = Time.now.to_i
+        payload = {
+          iss: service_account_email,
+          sub: service_account_email,
+          aud: 'https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit',
+          iat: now_seconds,
+          exp: now_seconds + (60 * 60), # Maximum expiration time is one hour
+          uid: uid
+        }
+        JWT.encode(payload, private_key, 'RS256')
+      end
+
+      # Get user by email/phone/uid
+      #
+      # @param key [String] either :email or :phone
+      # @param value [String] the value to search for
+      #
+      # @return [Resource]
+      #
+      # @example
+      #   FirebaseAdmin.get_user_by(:email, "lebron@lakers.com")
+      def get_user_by(key, value)
+        params = {}
+        params[key] = Array(value)
+        response = post('v1/accounts:lookup', params)
+        (response[:users] || []).first
+      end
+
+      # Reset emulator
+      #
+      # @return [Resource]
+      # @see https://firebase.google.com/docs/reference/rest/auth
+      #
+      # @example
+      #   FirebaseAdmin.reset()
+      def reset
+        delete("emulator/v1/projects/#{project_id}/accounts")
+      end
+
+      private
+
+      def default_credentials
+        return {} if ENV['GOOGLE_APPLICATION_CREDENTIALS'].nil?
+
+        JSON.parse(File.read(ENV['GOOGLE_APPLICATION_CREDENTIALS']))
+      end
+    end
+  end
+end

data/lib/firebase-admin/configuration.rb

@@ -0,0 +1,78 @@
+require 'faraday'
+require File.expand_path('version', __dir__)
+
+module FirebaseAdmin
+  # Defines constants and methods related to configuration
+  module Configuration
+    # An array of valid keys in the options hash when configuring a {FirebaseAdmin::API}
+    VALID_OPTIONS_KEYS = %i[
+      access_token
+      adapter
+      connection_options
+      endpoint
+      user_agent
+      project_id
+      loud_logger
+    ].freeze
+
+    # By default, don't set a user access token
+    DEFAULT_ACCESS_TOKEN = 'owner'.freeze
+
+    # The adapter that will be used to connect if none is set
+    #
+    # @note The default faraday adapter is Net::HTTP.
+    DEFAULT_ADAPTER = Faraday.default_adapter
+
+    # By default, don't set any connection options
+    DEFAULT_CONNECTION_OPTIONS = {}.freeze
+
+    # The endpoint that will be used to connect if none is set
+    #
+    # @note There is no reason to use any other endpoint at this time
+    DEFAULT_ENDPOINT = 'https://identitytoolkit.googleapis.com/'.freeze
+
+    # The response format appended to the path and sent in the 'Accept' header if none is set
+    #
+    # @note JSON is the only available format at this time
+    DEFAULT_FORMAT = :json
+
+    # The user agent that will be sent to the API endpoint if none is set
+    DEFAULT_USER_AGENT = "Firebase Admin Ruby Gem #{FirebaseAdmin::VERSION}".freeze
+
+    DEFAULT_PROJECT_ID = ''.freeze
+
+    # By default, don't turn on loud logging
+    DEFAULT_LOUD_LOGGER = nil
+
+    # @private
+    attr_accessor(*VALID_OPTIONS_KEYS)
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+    end
+
+    # Create a hash of options and their values
+    def options
+      VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    # Reset all configuration options to defaults
+    def reset
+      self.access_token       = DEFAULT_ACCESS_TOKEN
+      self.adapter            = DEFAULT_ADAPTER
+      self.connection_options = DEFAULT_CONNECTION_OPTIONS
+      self.endpoint           = DEFAULT_ENDPOINT
+      self.user_agent         = DEFAULT_USER_AGENT
+      self.project_id         = DEFAULT_PROJECT_ID
+      self.loud_logger        = DEFAULT_LOUD_LOGGER
+    end
+  end
+end

data/lib/firebase-admin/connection.rb

@@ -0,0 +1,30 @@
+require 'faraday_middleware'
+Dir[File.expand_path('../faraday/*.rb', __dir__)].sort.each { |f| require f }
+
+module FirebaseAdmin
+  # @private
+  module Connection
+    private
+
+    def connection
+      options = {
+        headers: {
+          'Content-Type' => 'application/json; charset=utf-8',
+          'Accept' => 'application/json; charset=utf-8',
+          'User-Agent' => user_agent
+        },
+        url: endpoint
+      }.merge(connection_options)
+
+      Faraday::Connection.new(options) do |connection|
+        connection.authorization :Bearer, access_token if access_token
+        connection.use Faraday::Request::UrlEncoded
+        connection.use FaradayMiddleware::Mashify
+        connection.use Faraday::Response::ParseJson
+        connection.use FaradayMiddleware::RaiseHttpException
+        connection.use FaradayMiddleware::LoudLogger if loud_logger
+        connection.adapter(adapter)
+      end
+    end
+  end
+end

data/lib/firebase-admin/error.rb

@@ -0,0 +1,28 @@
+module FirebaseAdmin
+  # Custom error class for rescuing from all Firebase errors
+  class Error < StandardError; end
+
+  # Raised when Firebase returns the HTTP status code 400
+  class BadRequest < Error; end
+
+  # Raised when Firebase returns the HTTP status code 404
+  class NotFound < Error; end
+
+  # Raised when Firebase returns the HTTP status code 429
+  class TooManyRequests < Error; end
+
+  # Raised when Firebase returns the HTTP status code 500
+  class InternalServerError < Error; end
+
+  # Raised when Firebase returns the HTTP status code 502
+  class BadGateway < Error; end
+
+  # Raised when Firebase returns the HTTP status code 503
+  class ServiceUnavailable < Error; end
+
+  # Raised when Firebase returns the HTTP status code 504
+  class GatewayTimeout < Error; end
+
+  # Raised when Firebase returns the HTTP status code 429
+  class RateLimitExceeded < Error; end
+end

data/lib/firebase-admin/request.rb

@@ -0,0 +1,44 @@
+require 'addressable/uri'
+require 'json'
+
+module FirebaseAdmin
+  # Defines HTTP request methods
+  module Request
+    # Perform an HTTP GET request
+    def get(path, options = {})
+      request(:get, path, options)
+    end
+
+    # Perform an HTTP POST request
+    def post(path, options = {})
+      request(:post, path, options)
+    end
+
+    # Perform an HTTP PUT request
+    def put(path, options = {})
+      request(:put, path, options)
+    end
+
+    # Perform an HTTP DELETE request
+    def delete(path, options = {})
+      request(:delete, path, options)
+    end
+
+    private
+
+    # Perform an HTTP request
+    def request(method, path, options)
+      response = connection.send(method) do |request|
+        case method
+        when :post, :put
+          request.path = Addressable::URI.escape(path)
+          request.body = options.to_json unless options.empty?
+
+        else
+          request.url(Addressable::URI.escape(path), options)
+        end
+      end
+      response.body
+    end
+  end
+end

data/lib/firebase-admin/version.rb

@@ -0,0 +1,3 @@
+module FirebaseAdmin
+  VERSION = '0.1.0'.freeze unless defined?(::FirebaseAdmin::VERSION)
+end

data/spec/faraday/raise_http_exceptions_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require File.expand_path('../spec_helper', __dir__)
+
+describe Faraday::Response do
+  before do
+    @client = FirebaseAdmin::Client.new(project_id: 'test-project')
+  end
+
+  {
+    400 => FirebaseAdmin::BadRequest,
+    404 => FirebaseAdmin::NotFound,
+    429 => FirebaseAdmin::TooManyRequests,
+    500 => FirebaseAdmin::InternalServerError,
+    503 => FirebaseAdmin::ServiceUnavailable
+  }.each do |status, exception|
+    context "when HTTP status is #{status}" do
+      before do
+        stub_post('v1/projects/test-project/accounts')
+          .to_return(status: status)
+      end
+
+      it "should raise #{exception.name} error" do
+        expect do
+          @client.create_account({})
+        end.to raise_error(exception)
+      end
+    end
+  end
+
+  context 'when a 400 is raised' do
+    before do
+      stub_post('v1/projects/test-project/accounts')
+        .to_return(body: fixture('400_error.json'), status: 400)
+    end
+
+    it 'should return the body error message' do
+      expect do
+        @client.create_account({})
+      end.to raise_error(FirebaseAdmin::BadRequest, /INVALID_PHONE_NUMBER : Invalid format\./)
+    end
+  end
+
+  context 'when a 502 is raised with an HTML response' do
+    before do
+      stub_post('v1/projects/test-project/accounts').to_return(
+        body: fixture('bad_gateway.html'),
+        status: 502
+      )
+    end
+
+    it 'should raise an FirebaseAdmin::BadGateway' do
+      expect do
+        @client.create_account({})
+      end.to raise_error(FirebaseAdmin::BadGateway)
+    end
+  end
+
+  context 'when a 504 is raised with an HTML response' do
+    before do
+      stub_post('v1/projects/test-project/accounts').to_return(
+        body: fixture('gateway_timeout.html'),
+        status: 504
+      )
+    end
+
+    it 'should raise an FirebaseAdmin::GatewayTimeout' do
+      expect do
+        @client.create_account({})
+      end.to raise_error(FirebaseAdmin::GatewayTimeout)
+    end
+  end
+end

data/spec/firebase-admin/api_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path('../spec_helper', __dir__)
+
+describe FirebaseAdmin::API do
+  before do
+    @keys = FirebaseAdmin::Configuration::VALID_OPTIONS_KEYS
+  end
+
+  context 'with module configuration' do
+    before do
+      FirebaseAdmin.configure do |config|
+        @keys.each do |key|
+          config.send("#{key}=", key)
+        end
+      end
+    end
+
+    after do
+      FirebaseAdmin.reset
+    end
+
+    it 'should inherit module configuration' do
+      api = FirebaseAdmin::API.new
+      @keys.each do |key|
+        expect(api.send(key)).to eq(key)
+      end
+    end
+
+    context 'with class configuration' do
+      before do
+        @configuration = {
+          access_token: 'AT',
+          adapter: :typhoeus,
+          connection_options: { ssl: { verify: true } },
+          endpoint: 'http://tumblr.com/',
+          user_agent: 'Custom User Agent',
+          project_id: 'test-project',
+          loud_logger: true
+        }
+      end
+
+      context 'during initialization' do
+        it 'should override module configuration' do
+          api = FirebaseAdmin::API.new(@configuration)
+          @keys.each do |key|
+            expect(api.send(key)).to eq(@configuration[key])
+          end
+        end
+      end
+
+      context 'after initialization' do
+        let(:api) { FirebaseAdmin::API.new }
+
+        before do
+          @configuration.each do |key, value|
+            api.send("#{key}=", value)
+          end
+        end
+
+        it 'should override module configuration after initialization' do
+          @keys.each do |key|
+            expect(api.send(key)).to eq(@configuration[key])
+          end
+        end
+
+        describe '#connection' do
+          it 'should use the connection_options' do
+            expect(Faraday::Connection).to receive(:new).with(include(ssl: { verify: true }))
+            api.send(:connection)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#config' do
+    subject { FirebaseAdmin::API.new }
+
+    let(:config) do
+      c = {}
+      @keys.each { |key| c[key] = key }
+      c
+    end
+
+    it 'returns a hash representing the configuration' do
+      @keys.each do |key|
+        subject.send("#{key}=", key)
+      end
+      expect(subject.config).to eq(config)
+    end
+  end
+
+  describe 'loud_logger param' do
+    before do
+      @client = FirebaseAdmin::Client.new(project_id: 'test-project', loud_logger: true)
+    end
+
+    context 'outputs to STDOUT with faraday logs when enabled' do
+      before do
+        stub_post('v1/projects/test-project/accounts')
+          .to_return(body: fixture('create_account.json'), headers: { content_type: 'application/json; charset=utf-8' })
+      end
+
+      it 'should return the body error message' do
+        output = capture_output do
+          @client.create_account({})
+        end
+
+        expect(output).to include 'INFO -- : Started POST request to: '
+        expect(output).to include 'DEBUG -- : Response Headers:'
+        expect(output).to include "User-Agent    : Firebase Admin Ruby Gem #{FirebaseAdmin::VERSION}"
+      end
+    end
+
+    context 'shows STDOUT output when errors occur' do
+      before do
+        stub_post('v1/projects/test-project/accounts')
+          .to_return(body: '{"error":{"message": "Bad words are bad."}}', status: 400)
+      end
+
+      it 'should return the body error message' do
+        output = capture_output do
+          @client.create_account({})
+        rescue StandardError
+          nil
+        end
+
+        expect(output).to include 'INFO -- : Started POST request to: '
+        expect(output).to include 'DEBUG -- : Response Headers:'
+        expect(output).to include "User-Agent    : Firebase Admin Ruby Gem #{FirebaseAdmin::VERSION}"
+        expect(output).to include '{"error":{"message": "Bad words are bad."}}'
+      end
+    end
+  end
+end