fmrest 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccf62593af664237c1cd0c67928c869ae74cdcde4b2e3c9bd82c20fa0f6b0354
-  data.tar.gz: 9f6bd645aed2551d278b0b31e194dc97726e66396a76148ee7dae3bca5c67a93
+  metadata.gz: e6433cf32d6d0111377f6080967e96fd5ff4cd54c5e223551c777a24c58e8662
+  data.tar.gz: 1a0fcd5951ab9b5bee88d822a429f16b02dcb01d5c95f74de9d529bb1ed00278
 SHA512:
-  metadata.gz: 421a3be4119f862e31787b6027c7824e42641d85d6dbdcb6d5df2b849ef3e93556a03060a74e093a11fed962cdfbe61be19833c5d2195f6b4dad121ef759aeb6
-  data.tar.gz: 7bd1359945a7da96afdfd05c8948148bc6c8740351eb7c4dd1a31ba501fc82f5ad79dd68a166b2fee3022c636fddd187f0b27b97fc2d645922afddb813f98787
+  metadata.gz: a0130f8b3598b3723d3c9e2514448a44a10381045176894cfed21244547c7ed41d0bc83fd18ab40981e9a2fc9ac7bd5c7290a5026b301878ea2c1d9ec440bb76
+  data.tar.gz: 0fc6a827bb57dea0b261bb812b58322dad8a01eecf78a4344bef877732f4f0b016636750833c048c5831e63e5015c707264a0697282cc7fba9a6879a0cd7e8b1

data/.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@ec106b438a1ff6ff109590de34ddc62c540232e0
+      with:
+        ruby-version: 2.6
+    - name: Install dependencies
+      run: bundle install
+    - name: Run specs
+      run: bundle exec rspec spec

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## Changelog
 
+### 0.11.0
+
+* Added custom class for connection settings, providing indifferent access
+  (i.e. keys can be strings or symbols), and centralized default values and
+  validations
+* Added `:autologin`, `:token` and `:token_store` connection settings
+* Added `FmRest::Base.fmrest_config_overlay=` and related methods
+* Added `FmRest::V1.request_auth_token` and
+  `FmRest::Spyke::Base.request_auth_token` (as well as `!`-suffixed versions
+  which raise exceptions on failure)
+
 ### 0.10.1
 
 * Fix `URI.escape` obsolete warning messages in Ruby 2.7 by replacing it with

data/README.md

@@ -1,6 +1,7 @@
 # fmrest-ruby
 
-<a href="https://rubygems.org/gems/fmrest"><img src="https://badge.fury.io/rb/fmrest.svg?style=flat" alt="Gem Version"></a>
+[![Gem Version](https://badge.fury.io/rb/fmrest.svg?style=flat)](https://rubygems.org/gems/fmrest)
+![CI](https://github.com/beezwax/fmrest-ruby/workflows/CI/badge.svg)
 
 A Ruby client for
 [FileMaker 18 and 19's Data API](https://help.claris.com/en/data-api-guide)
@@ -121,6 +122,8 @@ Option              | Description                                | Format
 `:timestamp_format` | Timestmap parsing format                   | String (FM date format)     | `"MM/dd/yyyy HH:mm:ss"`
 `:time_format`      | Time parsing format                        | String (FM date format)     | `"HH:mm:ss"`
 `:timezone`         | The timezone for the FM server             | `:local` \| `:utc` \| `nil` | `nil`
+`:autologin`        | Whether to automatically start Data API sessions | Boolean               | `true`
+`:token`            | Used to manually provide a session token (e.g. if `:autologin` is `false`) | String | None
 
 ### Default connection settings
 
@@ -418,6 +421,59 @@ class Honeybee < BeeBase
 end
 ```
 
+### Model.fmrest_config_overlay=
+
+There may be cases where you want to use different connection settings
+depending on context, for example if you want to use username and password
+provided by the user in a web application. Since `Model.fmrest_config` is
+global, changing the username/password for one context would also change it for
+all other contexts, leading to security issues.
+
+`Model.fmrest_config_overlay=` solves that issue by allowing you to override
+some settings in a thread-local and reversible manner. That way, using the same
+example as above, you could connect to the Data API with user-provided
+credentials without having them leak into other users of your web application.
+
+E.g.:
+
+```ruby
+class BeeBase < Spyke::Base
+  include FmRest::Spyke
+
+  # Host and database provided as base settings
+  self.fmrest_config = {
+    host:     "example.com",
+    database: "My Database"
+  }
+end
+
+# E.g. in a controller-action of a Rails application:
+
+# User-provided credentials
+BeeBase.fmrest_config_overlay = {
+  username: params[:username],
+  password: params[:password]
+}
+
+# Perform some Data API requests ...
+```
+
+### Model.clear_fmrest_config_overlay
+
+Clears the thread-local settings provided to `fmrest_config_overaly=`.
+
+### Model.with_overlay
+
+Runs a block with the given settings overlay, resetting them after the block
+finishes running. It wraps execution in its own fiber, so it doesn't affect the
+overlay of the currently-running thread.
+
+```ruby
+Honeybee.with_overlay(username: "...", password: "...") do
+  Honeybee.query(...)
+end
+```
+
 ### Model.layout
 
 Use `layout` to set the `:layout` part of API URLs, e.g.:
@@ -434,6 +490,15 @@ Data API models.
 Note that you only need to set this if the name of the model and the name of
 the layout differ, otherwise the default will just work.
 
+### Model.request_auth_token
+
+Requests a Data API session token using the connection settings in
+`fmrest_config` and returns it if successful, otherwise returns `false`.
+
+You normally don't need to use this method as fmrest-ruby will automatically
+request and store session tokens for you (provided that `:autologin` is
+`true`).
+
 ### Model.logout
 
 Use `logout` to log out from the database session (you may call it on any model

data/lib/fmrest.rb

@@ -4,16 +4,21 @@ require "faraday"
 require "faraday_middleware"
 
 require "fmrest/version"
-require "fmrest/v1"
+require "fmrest/connection_settings"
 
 module FmRest
+  autoload :V1,         "fmrest/v1"
+  autoload :TokenStore, "fmrest/token_store"
+
   class << self
     attr_accessor :token_store
 
-    attr_writer :default_connection_settings
+    def default_connection_settings=(settings)
+      @default_connection_settings = ConnectionSettings.wrap(settings, skip_validation: true)
+    end
 
     def default_connection_settings
-      @default_connection_settings || {}
+      @default_connection_settings || ConnectionSettings.new({}, skip_validation: true)
     end
 
     def config=(connection_hash)

data/lib/fmrest/connection_settings.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module FmRest
+  # Wrapper class for connection settings hash, with a number of purposes:
+  #
+  # * Provide indifferent access (base hash can have either string or symbol
+  #   keys)
+  # * Method access
+  # * Default values
+  # * Basic validation
+  # * Normalization (e.g. aliased settings)
+  # * Useful error messages
+  class ConnectionSettings
+    class MissingSetting < ArgumentError; end
+
+    PROPERTIES = %i(
+      host
+      database
+      username
+      password
+      token
+      token_store
+      autologin
+      ssl
+      proxy
+      log
+      coerce_dates
+      date_format
+      timestamp_format
+      time_format
+      timezone
+    ).freeze
+
+    # NOTE: password intentionally left non-required since it's only really
+    # needed when no token exists, and should only be required when logging in
+    REQUIRED = %i(
+      host
+      database
+    ).freeze
+
+    DEFAULT_DATE_FORMAT = "MM/dd/yyyy"
+    DEFAULT_TIME_FORMAT = "HH:mm:ss"
+    DEFAULT_TIMESTAMP_FORMAT = "#{DEFAULT_DATE_FORMAT} #{DEFAULT_TIME_FORMAT}"
+
+    DEFAULTS = {
+      autologin:        true,
+      log:              false,
+      date_format:      DEFAULT_DATE_FORMAT,
+      time_format:      DEFAULT_TIME_FORMAT,
+      timestamp_format: DEFAULT_TIMESTAMP_FORMAT,
+      coerce_dates:     false
+    }.freeze
+
+    def self.wrap(settings, skip_validation: false)
+      if settings.kind_of?(self)
+        settings.validate unless skip_validation
+        return settings
+      end
+      new(settings, skip_validation: skip_validation)
+    end
+
+    def initialize(settings, skip_validation: false)
+      @settings = settings.to_h.dup
+      normalize
+      validate unless skip_validation
+    end
+
+    PROPERTIES.each do |p|
+      define_method(p) do
+        get(p)
+      end
+
+      define_method("#{p}!") do
+        r = get(p)
+        raise MissingSetting, "Missing required setting: `#{p}'" if r.nil?
+        r
+      end
+
+      define_method("#{p}?") do
+        !!get(p)
+      end
+    end
+
+    def [](key)
+      raise ArgumentError, "Unknown setting `#{key}'" unless PROPERTIES.include?(key.to_sym)
+      get(key)
+    end
+
+    def to_h
+      PROPERTIES.each_with_object({}) do |p, h|
+        v = get(p)
+        h[p] = v unless v == DEFAULTS[p]
+      end
+    end
+
+    def merge(other, **keyword_args)
+      other = self.class.wrap(other, skip_validation: true)
+      self.class.new(to_h.merge(other.to_h), **keyword_args)
+    end
+
+    def validate
+      missing = REQUIRED.select { |r| get(r).nil? }.map { |m| "`#{m}'" }
+      raise MissingSetting, "Missing required setting(s): #{missing.join(', ')}" unless missing.empty?
+
+      unless username? || token?
+        raise MissingSetting, "A minimum of `username' or `token' are required to be able to establish a connection"
+      end
+    end
+
+    private
+
+    def get(key)
+      return @settings[key.to_sym] if @settings.has_key?(key.to_sym)
+      return @settings[key.to_s] if @settings.has_key?(key.to_s)
+      DEFAULTS[key.to_sym]
+    end
+
+    def normalize
+      if !get(:username) && account_name = get(:account_name)
+        @settings[:username] = account_name
+      end
+    end
+  end
+end

data/lib/fmrest/errors.rb

@@ -21,6 +21,8 @@ module FmRest
   class APIError::NoMatchingRecordsError < APIError::ParameterError; end
   class APIError::ValidationError < APIError; end      # error codes 500..599
   class APIError::SystemError < APIError; end          # error codes 800..899
+  class APIError::InvalidToken < APIError; end         # error code 952
+  class APIError::MaximumDataAPICallsExceeded < APIError; end # error code 953
   class APIError::ScriptError < APIError; end          # error codes 1200..1299
   class APIError::ODBCError < APIError; end            # error codes 1400..1499
 

data/lib/fmrest/spyke/model/auth.rb

@@ -28,6 +28,14 @@ module FmRest
           rescue FmRest::V1::TokenSession::NoSessionTokenSet
             false
           end
+
+          def request_auth_token
+            FmRest::V1.request_auth_token(FmRest::V1.auth_connection(fmrest_config))
+          end
+
+          def request_auth_token!
+            FmRest::V1.request_auth_token!(FmRest::V1.auth_connection(fmrest_config))
+          end
         end
       end
     end

data/lib/fmrest/spyke/model/connection.rb

@@ -7,25 +7,67 @@ module FmRest
         extend ActiveSupport::Concern
 
         included do
-          class_attribute :fmrest_config, instance_writer: false, instance_predicate: false
-
-          # Overrides the fmrest_config reader created by class_attribute so we
-          # can default set the default at call time.
-          #
-          # This method gets overwriten in subclasses if self.fmrest_config= is
-          # called.
-          define_singleton_method(:fmrest_config) do
-            FmRest.default_connection_settings
-          end
-
           class_attribute :faraday_block, instance_accessor: false, instance_predicate: false
           class << self; private :faraday_block, :faraday_block=; end
 
-          # FM Data API expects PATCH for updates (Spyke's default was PUT)
+          # FM Data API expects PATCH for updates (Spyke's default is PUT)
           self.callback_methods = { create: :post, update: :patch }.freeze
         end
 
         class_methods do
+          def fmrest_config
+            if fmrest_config_overlay
+              return FmRest.default_connection_settings.merge(fmrest_config_overlay, skip_validation: true)
+            end
+
+            FmRest.default_connection_settings
+          end
+
+          # Behaves similar to ActiveSupport's class_attribute, redefining the
+          # reader method so it can be inherited and overwritten in subclasses
+          #
+          def fmrest_config=(settings)
+            settings = ConnectionSettings.new(settings, skip_validation: true)
+
+            redefine_singleton_method(:fmrest_config) do
+              overlay = fmrest_config_overlay
+              return settings.merge(overlay, skip_validation: true) if overlay
+              settings
+            end
+          end
+
+          # Allows overwriting some connection settings in a thread-local
+          # manner. Useful in the use case where you want to connect to the
+          # same database using different accounts (e.g. credentials provided
+          # by users in a web app context)
+          #
+          def fmrest_config_overlay=(settings)
+            Thread.current[fmrest_config_overlay_key] = settings
+          end
+
+          def fmrest_config_overlay
+            Thread.current[fmrest_config_overlay_key] || begin
+              superclass.fmrest_config_overlay
+            rescue NoMethodError
+              nil
+            end
+          end
+
+          def clear_fmrest_config_overlay
+            Thread.current[fmrest_config_overlay_key] = nil
+          end
+
+          def with_overlay(settings, &block)
+            Fiber.new do
+              begin
+                self.fmrest_config_overlay = settings
+                yield
+              ensure
+                self.clear_fmrest_config_overlay
+              end
+            end.resume
+          end
+
           def connection
             super || fmrest_connection
           end
@@ -47,26 +89,45 @@ module FmRest
           private
 
           def fmrest_connection
-            @fmrest_connection ||=
-              begin
-                config = fmrest_config
+            memoize = false
 
-                FmRest::V1.build_connection(config) do |conn|
-                  faraday_block.call(conn) if faraday_block
+            # Don't memoize the connection if there's an overlay, since
+            # overlays are thread-local and so should be the connection
+            unless fmrest_config_overlay
+              return @fmrest_connection if @fmrest_connection
+              memoize = true
+            end
 
-                  # Pass the class to SpykeFormatter's initializer so it can have
-                  # access to extra context defined in the model, e.g. a portal
-                  # where name of the portal and the attributes prefix don't match
-                  # and need to be specified as options to `portal`
-                  conn.use FmRest::Spyke::SpykeFormatter, self
+            config = ConnectionSettings.wrap(fmrest_config)
 
-                  conn.use FmRest::V1::TypeCoercer, config
+            connection =
+              FmRest::V1.build_connection(config) do |conn|
+                faraday_block.call(conn) if faraday_block
 
-                  # FmRest::Spyke::JsonParse expects symbol keys
-                  conn.response :json, parser_options: { symbolize_names: true }
-                end
+                # Pass the class to SpykeFormatter's initializer so it can have
+                # access to extra context defined in the model, e.g. a portal
+                # where name of the portal and the attributes prefix don't match
+                # and need to be specified as options to `portal`
+                conn.use FmRest::Spyke::SpykeFormatter, self
+
+                conn.use FmRest::V1::TypeCoercer, config
+
+                # FmRest::Spyke::JsonParse expects symbol keys
+                conn.response :json, parser_options: { symbolize_names: true }
               end
+
+            @fmrest_connection = connection if memoize
+
+            connection
           end
+
+          def fmrest_config_overlay_key
+            :"#{object_id}.fmrest_config_overlay"
+          end
+        end
+
+        def fmrest_config
+          self.class.fmrest_config
         end
       end
     end

data/lib/fmrest/spyke/model/serialization.rb

@@ -76,7 +76,7 @@ module FmRest
         end
 
         def convert_datetime_timezone(dt)
-          case fmrest_config.fetch(:timezone, nil)
+          case fmrest_config.timezone
           when :utc, "utc"
             dt.new_offset(0)
           when :local, "local"

data/lib/fmrest/token_store.rb

@@ -2,5 +2,11 @@
 
 module FmRest
   module TokenStore
+    autoload :Base,         "fmrest/token_store/base"
+    autoload :Memory,       "fmrest/token_store/memory"
+    autoload :Null,         "fmrest/token_store/null"
+    autoload :ActiveRecord, "fmrest/token_store/active_record"
+    autoload :Moneta,       "fmrest/token_store/moneta"
+    autoload :Redis,        "fmrest/token_store/redis"
   end
 end

data/lib/fmrest/token_store/base.rb

@@ -10,15 +10,15 @@ module FmRest
       end
 
       def load(key)
-        raise "Not implemented"
+        raise NotImplementedError
       end
 
       def store(key, value)
-        raise "Not implemented"
+        raise NotImplementedError
       end
 
       def delete(key)
-        raise "Not implemented"
+        raise NotImplementedError
       end
     end
   end

data/lib/fmrest/v1.rb

@@ -5,17 +5,19 @@ require "fmrest/v1/paths"
 require "fmrest/v1/container_fields"
 require "fmrest/v1/utils"
 require "fmrest/v1/dates"
+require "fmrest/v1/auth"
 
 module FmRest
   module V1
-    DEFAULT_DATE_FORMAT = "MM/dd/yyyy"
-    DEFAULT_TIME_FORMAT = "HH:mm:ss"
-    DEFAULT_TIMESTAMP_FORMAT = "#{DEFAULT_DATE_FORMAT} #{DEFAULT_TIME_FORMAT}"
-
     extend Connection
     extend Paths
     extend ContainerFields
     extend Utils
     extend Dates
+    extend Auth
+
+    autoload :TokenSession, "fmrest/v1/token_session"
+    autoload :RaiseErrors, "fmrest/v1/raise_errors"
+    autoload :TypeCoercer, "fmrest/v1/type_coercer"
   end
 end

data/lib/fmrest/v1/auth.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module FmRest
+  module V1
+    module Auth
+      # Requests a token through basic auth
+      #
+      # @param connection [Faraday] the auth connection to use for
+      #   the request
+      # @return The token if successful
+      # @return `false` if authentication failed
+      def request_auth_token(connection = FmRest::V1.auth_connection)
+        request_auth_token!(connection)
+      rescue FmRest::APIError::AccountError
+        false
+      end
+
+      # Requests a token through basic auth, raising
+      # `FmRest::APIError::AccountError` if auth fails
+      #
+      # @param (see #request_auth_token)
+      # @return The token if successful
+      # @raise [FmRest::APIError::AccountError] if authentication failed
+      def request_auth_token!(connection = FmRest.V1.auth_connection)
+        resp = connection.post(V1.session_path)
+        resp.body["response"]["token"]
+      end
+    end
+  end
+end

data/lib/fmrest/v1/connection.rb

@@ -7,21 +7,21 @@ module FmRest
     module Connection
       BASE_PATH = "/fmi/data/v1/databases"
 
+      AUTH_HEADERS = { "Content-Type" => "application/json" }.freeze
+
       # Builds a complete DAPI Faraday connection with middleware already
       # configured to handle authentication, JSON parsing, logging and DAPI
       # error handling. A block can be optionally given for additional
       # middleware configuration
       #
-      # @option options [String] :username The username for DAPI authentication
-      # @option options [String] :account_name Alias of :username for
-      #   compatibility with Rfm gem
-      # @option options [String] :password The password for DAPI authentication
       # @option (see #base_connection)
       # @return (see #base_connection)
-      def build_connection(options = FmRest.default_connection_settings, &block)
-        base_connection(options) do |conn|
+      def build_connection(settings = FmRest.default_connection_settings, &block)
+        settings = ConnectionSettings.wrap(settings)
+
+        base_connection(settings) do |conn|
           conn.use RaiseErrors
-          conn.use TokenSession, options
+          conn.use TokenSession, settings
 
           # The EncodeJson and Multipart middlewares only encode the request
           # when the content type matches, so we can have them both here and
@@ -33,32 +33,60 @@ module FmRest
 
           # Allow overriding the default response middleware
           if block_given?
-            yield conn, options
+            yield conn, settings
           else
-            conn.use TypeCoercer, options
+            conn.use TypeCoercer, settings
             conn.response :json
           end
 
-          if options[:log]
+          if settings.log
+            conn.response :logger, nil, bodies: true, headers: true
+          end
+
+          conn.adapter Faraday.default_adapter
+        end
+      end
+
+      # Builds a Faraday connection to use for DAPI basic auth login
+      #
+      # @option (see #base_connection)
+      # @return (see #base_connection)
+      def auth_connection(settings = FmRest.default_connection_settings)
+        settings = ConnectionSettings.wrap(settings)
+
+        base_connection(settings, { headers: AUTH_HEADERS }) do |conn|
+          conn.use RaiseErrors
+
+          conn.basic_auth settings.username!, settings.password!
+
+          if settings.log
             conn.response :logger, nil, bodies: true, headers: true
           end
 
+          conn.response :json
           conn.adapter Faraday.default_adapter
         end
       end
 
       # Builds a base Faraday connection with base URL constructed from
-      # connection options and passes it the given block
+      # connection settings and passes it the given block
       #
-      # @option options [String] :host The hostname for the FM server
-      # @option options [String] :database The FM database name
-      # @option options [String] :ssl SSL options to forward to the Faraday
+      # @option settings [String] :host The hostname for the FM server
+      # @option settings [String] :database The FM database name
+      # @option settings [String] :username The username for DAPI authentication
+      # @option settings [String] :account_name Alias of :username for
+      #   compatibility with Rfm gem
+      # @option settings [String] :password The password for DAPI authentication
+      # @option settings [String] :ssl SSL settings to forward to the Faraday
       #   connection
-      # @option options [String] :proxy Proxy options to forward to the Faraday
+      # @option settings [String] :proxy Proxy options to forward to the Faraday
       #   connection
+      # @param faraday_options [Hash] additional options for Faraday object
       # @return [Faraday] The new Faraday connection
-      def base_connection(options = FmRest.default_connection_settings, &block)
-        host = options.fetch(:host)
+      def base_connection(settings = FmRest.default_connection_settings, faraday_options = nil, &block)
+        settings = ConnectionSettings.wrap(settings)
+
+        host = settings.host!
 
         # Default to HTTPS
         scheme = "https"
@@ -70,11 +98,11 @@ module FmRest
           scheme = uri.scheme
         end
 
-        faraday_options = {}
-        faraday_options[:ssl] = options[:ssl] if options.key?(:ssl)
-        faraday_options[:proxy] = options[:proxy] if options.key?(:proxy)
+        faraday_options = (faraday_options || {}).dup
+        faraday_options[:ssl] = settings.ssl if settings.ssl?
+        faraday_options[:proxy] = settings.proxy if settings.proxy?
 
-        database = URI.encode_www_form_component(options.fetch(:database))
+        database = URI.encode_www_form_component(settings.database!)
 
         Faraday.new(
           "#{scheme}://#{host}#{BASE_PATH}/#{database}/".freeze,
@@ -85,7 +113,3 @@ module FmRest
     end
   end
 end
-
-require "fmrest/v1/token_session"
-require "fmrest/v1/raise_errors"
-require "fmrest/v1/type_coercer"

data/lib/fmrest/v1/raise_errors.rb

@@ -23,9 +23,11 @@ module FmRest
         402..499   => APIError::ParameterError,
         500..599   => APIError::ValidationError,
         800..899   => APIError::SystemError,
+        952        => APIError::InvalidToken,
+        953        => APIError::MaximumDataAPICallsExceeded,
         1200..1299 => APIError::ScriptError,
         1400..1499 => APIError::ODBCError
-      }
+      }.freeze
 
       def on_complete(env)
         # Sniff for either straight JSON parsing or Spyke's format

data/lib/fmrest/v1/token_session.rb

@@ -10,15 +10,15 @@ module FmRest
     class TokenSession < Faraday::Middleware
       class NoSessionTokenSet < FmRest::Error; end
 
-      HEADER_KEY = "Authorization".freeze
+      HEADER_KEY = "Authorization"
       TOKEN_STORE_INTERFACE = [:load, :store, :delete].freeze
       LOGOUT_PATH_MATCHER = %r{\A(#{FmRest::V1::Connection::BASE_PATH}/[^/]+/sessions/)[^/]+\Z}.freeze
 
       # @param app [#call]
-      # @param options [Hash]
-      def initialize(app, options = FmRest.default_connection_settings)
+      # @param settings [FmRest::ConnectionSettings]
+      def initialize(app, settings)
         super(app)
-        @options = options
+        @settings = settings
       end
 
       # Entry point for the middleware when sending a request
@@ -32,27 +32,37 @@ module FmRest
 
         @app.call(env).on_complete do |response_env|
           if response_env[:status] == 401 # Unauthorized
-            env[:body] = request_body
-            token_store.delete(token_store_key)
-            set_auth_header(env)
-            return @app.call(env)
+            delete_token_store_key
+
+            if @settings.autologin
+              env[:body] = request_body
+              set_auth_header(env)
+              return @app.call(env)
+            end
           end
         end
       end
 
       private
 
+      def delete_token_store_key
+        token_store.delete(token_store_key)
+        # Sometimes we may want to pass the :token in settings manually, and
+        # refrain from passing a :username. In that case the call to
+        # #token_store_key above would fail as it tries to fetch :username, so
+        # we purposely ignore that error.
+      rescue FmRest::ConnectionSettings::MissingSetting
+      end
+
       def handle_logout(env)
-        token = token_store.load(token_store_key)
+        token = @settings.token? ? @settings.token : token_store.load(token_store_key)
 
         raise NoSessionTokenSet, "Couldn't send logout request because no session token was set" unless token
 
         env.url.path = env.url.path.gsub(LOGOUT_PATH_MATCHER, "\\1#{token}")
 
         @app.call(env).on_complete do |response_env|
-          if response_env[:status] == 200
-            token_store.delete(token_store_key)
-          end
+          delete_token_store_key if response_env[:status] == 200
         end
       end
 
@@ -65,43 +75,33 @@ module FmRest
         env.request_headers[HEADER_KEY] = "Bearer #{token}"
       end
 
-      # Tries to get an existing token from the token store,
+      # Uses the token given in connection settings if available,
+      # otherwisek tries to get an existing token from the token store,
       # otherwise requests one through basic auth,
       # otherwise raises an exception.
       #
       def token
+        return @settings.token if @settings.token?
+
         token = token_store.load(token_store_key)
         return token if token
 
-        if token = request_token
-          token_store.store(token_store_key, token)
-          return token
-        end
+        return nil unless @settings.autologin
 
-        # TODO: Make this a custom exception class
-        raise "Filemaker auth failed"
+        token = V1.request_auth_token!(auth_connection)
+        token_store.store(token_store_key, token)
+        token
       end
 
-      # Requests a token through basic auth
-      #
-      def request_token
-        resp = auth_connection.post do |req|
-          req.url V1.session_path
-          req.headers["Content-Type"] = "application/json"
-        end
-        return resp.body["response"]["token"] if resp.success?
-        false
-      end
-
-      # The key to use to store a token, uses the format host:database
+      # The key to use to store a token, uses the format host:database:username
       #
       def token_store_key
         @token_store_key ||=
           begin
             # Strip the host part to just the hostname (i.e. no scheme or port)
-            host = @options.fetch(:host)
+            host = @settings.host!
             host = URI(host).hostname if host =~ /\Ahttps?:\/\//
-            "#{host}:#{@options.fetch(:database)}"
+            "#{host}:#{@settings.database!}:#{@settings.username!}"
           end
       end
 
@@ -111,31 +111,23 @@ module FmRest
             if TOKEN_STORE_INTERFACE.all? { |method| token_store_option.respond_to?(method) }
               token_store_option
             elsif token_store_option.kind_of?(Class)
-              token_store_option.new
+              if token_store_option.respond_to?(:instance)
+                token_store_option.instance
+              else
+                token_store_option.new
+              end
             else
-              require "fmrest/token_store/memory"
-              TokenStore::Memory.new
+              FmRest::TokenStore::Memory.new
             end
           end
       end
 
       def token_store_option
-        @options[:token_store] || FmRest.token_store
+        @settings.token_store || FmRest.token_store
       end
 
       def auth_connection
-        @auth_connection ||= V1.base_connection(@options) do |conn|
-          username = @options.fetch(:account_name) { @options.fetch(:username) }
-
-          conn.basic_auth username, @options.fetch(:password)
-
-          if @options[:log]
-            conn.response :logger, nil, bodies: true, headers: true
-          end
-
-          conn.response :json
-          conn.adapter Faraday.default_adapter
-        end
+        @auth_connection ||= V1.auth_connection(@settings)
       end
     end
   end

data/lib/fmrest/v1/type_coercer.rb

@@ -13,10 +13,10 @@ module FmRest
       COERCE_FULL = [:full, "full"].freeze
 
       # @param app [#call]
-      # @param options [Hash]
-      def initialize(app, options = FmRest.default_connection_settings)
+      # @param settings [FmRest::ConnectionSettings]
+      def initialize(app, settings)
         super(app)
-        @options = options
+        @settings = settings
       end
 
       def on_complete(env)
@@ -112,15 +112,15 @@ module FmRest
       end
 
       def date_fm_format
-        @options[:date_format] || DEFAULT_DATE_FORMAT
+        @settings.date_format
       end
 
       def timestamp_fm_format
-        @options[:timestamp_format] || DEFAULT_TIMESTAMP_FORMAT
+        @settings.timestamp_format
       end
 
       def time_fm_format
-        @options[:time_format] || DEFAULT_TIME_FORMAT
+        @settings.time_format
       end
 
       def date_strptime_format
@@ -179,11 +179,11 @@ module FmRest
       end
 
       def local_timezone?
-        @local_timezone ||= @options.fetch(:timezone, nil).try(:to_sym) == :local
+        @local_timezone ||= @settings.timezone.try(:to_sym) == :local
       end
 
       def coerce_dates
-        @options.fetch(:coerce_dates, false)
+        @settings.coerce_dates
       end
 
       alias_method :enabled?, :coerce_dates

data/lib/fmrest/v1/utils.rb

@@ -72,7 +72,6 @@ module FmRest
         params
       end
 
-
       private
 
       def convert_script_arguments(script_arguments, suffix = nil)

data/lib/fmrest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FmRest
-  VERSION = "0.10.1"
+  VERSION = "0.11.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fmrest
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Pedro Carbajal
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-15 00:00:00.000000000 Z
+date: 2020-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -226,6 +226,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -237,6 +238,7 @@ files:
 - Rakefile
 - fmrest.gemspec
 - lib/fmrest.rb
+- lib/fmrest/connection_settings.rb
 - lib/fmrest/errors.rb
 - lib/fmrest/spyke.rb
 - lib/fmrest/spyke/base.rb
@@ -264,6 +266,7 @@ files:
 - lib/fmrest/token_store/moneta.rb
 - lib/fmrest/token_store/redis.rb
 - lib/fmrest/v1.rb
+- lib/fmrest/v1/auth.rb
 - lib/fmrest/v1/connection.rb
 - lib/fmrest/v1/container_fields.rb
 - lib/fmrest/v1/dates.rb