fmrest 0.1.0 → 0.2.0

data/lib/fmrest/token_store.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FmRest
+  module TokenStore
+  end
+end

data/lib/fmrest/token_store/active_record.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "fmrest/token_store/base"
+require "active_record"
+
+module FmRest
+  module TokenStore
+    # Heavily inspired by Moneta's ActiveRecord store:
+    #
+    #   https://github.com/minad/moneta/blob/master/lib/moneta/adapters/activerecord.rb
+    #
+    class ActiveRecord < Base
+      DEFAULT_TABLE_NAME = "fmrest_session_tokens".freeze
+
+      @connection_lock = ::Mutex.new
+      class << self
+        attr_reader :connection_lock
+      end
+
+      attr_reader :connection_pool, :model
+
+      delegate :with_connection, to: :connection_pool
+
+      def initialize(options = {})
+        super
+
+        @connection_pool = ::ActiveRecord::Base.connection_pool
+
+        create_table
+
+        @model = Class.new(::ActiveRecord::Base)
+        @model.table_name = table_name
+      end
+
+      def delete(key)
+        model.where(scope: key).delete_all
+      end
+
+      def load(key)
+        model.where(scope: key).pluck(:token).first
+      end
+
+      def store(key, value)
+        record = model.find_or_initialize_by(scope: key)
+        record.token = value
+        record.save!
+        value
+      end
+
+      private
+
+      def create_table
+        with_connection do |conn|
+          return if conn.table_exists?(table_name)
+
+          # Prevent multiple connections from attempting to create the table simultaneously.
+          self.class.connection_lock.synchronize do
+            conn.create_table(table_name, id: false) do |t|
+              t.string :scope, null: false
+              t.string :token, null: false
+              t.datetime :updated_at
+            end
+            conn.add_index(table_name, :scope, unique: true)
+            conn.add_index(table_name, [:scope, :token])
+          end
+        end
+      end
+
+      def table_name
+        options[:table_name] || DEFAULT_TABLE_NAME
+      end
+    end
+  end
+end

data/lib/fmrest/token_store/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FmRest
+  module TokenStore
+    class Base
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def load(key)
+        raise "Not implemented"
+      end
+
+      def store(key, value)
+        raise "Not implemented"
+      end
+
+      def delete(key)
+        raise "Not implemented"
+      end
+    end
+  end
+end

data/lib/fmrest/token_store/memory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "fmrest/token_store/base"
+
+module FmRest
+  module TokenStore
+    class Memory < Base
+      def initialize(*args)
+        super
+        @tokens = {}
+      end
+
+      def delete(key)
+        @tokens.delete(key)
+      end
+
+      def load(key)
+        @tokens[key]
+      end
+
+      def store(key, value)
+        @tokens[key] = value
+      end
+    end
+  end
+end

data/lib/fmrest/token_store/redis.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "fmrest/token_store/base"
+require "redis" unless defined?(MockRedis)
+
+module FmRest
+  module TokenStore
+    class Redis < Base
+      DEFAULT_PREFIX = "fmrest-token:".freeze
+
+      STORE_OPTIONS = [:redis, :prefix].freeze
+
+      def initialize(options = {})
+        super
+        @redis = @options[:redis] || ::Redis.new(options_for_redis)
+        @prefix = @options[:prefix] || DEFAULT_PREFIX
+      end
+
+      def load(key)
+        @redis.get(prefix_key(key))
+      end
+
+      def store(key, value)
+        @redis.set(prefix_key(key), value)
+        value
+      end
+
+      def delete(key)
+        @redis.del(prefix_key(key))
+      end
+
+      private
+
+      def options_for_redis
+        @options.dup.tap do |options|
+          STORE_OPTIONS.each { |opt| options.delete(opt) }
+        end
+      end
+
+      def prefix_key(key)
+        "#{@prefix}#{key}"
+      end
+    end
+  end
+end

data/lib/fmrest/v1.rb

@@ -1,54 +1,15 @@
-require "fmrest/v1/token_session"
-require "uri"
+# frozen_string_literal: true
+
+require "fmrest/v1/connection"
+require "fmrest/v1/paths"
+require "fmrest/v1/container_fields"
+require "fmrest/v1/utils"
 
 module FmRest
   module V1
-    BASE_PATH = "/fmi/data/v1/databases".freeze
-
-    class << self
-      def build_connection(options = FmRest.config, &block)
-        base_connection(options) do |conn|
-          conn.use      TokenSession, options
-          conn.request  :json
-
-          if options[:log]
-            conn.response :logger, nil, bodies: true, headers: true
-          end
-
-          # Allow overriding the default response middleware
-          if block_given?
-            yield conn
-          else
-            conn.response :json
-          end
-
-          conn.adapter  Faraday.default_adapter
-        end
-      end
-
-      def base_connection(options = FmRest.config, &block)
-        # TODO: Make HTTPS optional
-        Faraday.new("https://#{options.fetch(:host)}#{BASE_PATH}/#{URI.escape(options.fetch(:database))}/".freeze, &block)
-      end
-
-      def session_path(token = nil)
-        url = "sessions"
-        url += "/#{token}" if token
-        url
-      end
-
-      def record_path(layout, id = nil)
-        url = "layouts/#{URI.escape(layout.to_s)}/records"
-        url += "/#{id}" if id
-        url
-      end
-
-      def find_path(layout)
-        "layouts/#{URI.escape(layout.to_s)}/_find"
-      end
-
-      #def globals_path
-      #end
-    end
+    extend Connection
+    extend Paths
+    extend ContainerFields
+    extend Utils
   end
 end

data/lib/fmrest/v1/connection.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "uri"
+require "fmrest/v1/token_session"
+require "fmrest/v1/raise_errors"
+
+module FmRest
+  module V1
+    module Connection
+      BASE_PATH = "/fmi/data/v1/databases".freeze
+
+      def build_connection(options = FmRest.config, &block)
+        base_connection(options) do |conn|
+          conn.use RaiseErrors
+          conn.use TokenSession, options
+
+          # The EncodeJson and Multipart middlewares only encode the request
+          # when the content type matches, so we can have them both here and
+          # still play nice with each other, we just need to set the content
+          # type to multipart/form-data when we want to submit a container
+          # field
+          conn.request :multipart
+          conn.request :json
+
+          if options[:log]
+            conn.response :logger, nil, bodies: true, headers: true
+          end
+
+          # Allow overriding the default response middleware
+          if block_given?
+            yield conn
+          else
+            conn.response :json
+          end
+
+          conn.adapter Faraday.default_adapter
+        end
+      end
+
+      def base_connection(options = FmRest.config, &block)
+        host = options.fetch(:host)
+
+        # Default to HTTPS
+        scheme = "https"
+
+        if host.match(/\Ahttps?:\/\//)
+          uri = URI(host)
+          host = uri.hostname
+          host += ":#{uri.port}" if uri.port != uri.default_port
+          scheme = uri.scheme
+        end
+
+        Faraday.new("#{scheme}://#{host}#{BASE_PATH}/#{URI.escape(options.fetch(:database))}/".freeze, &block)
+      end
+    end
+  end
+end

data/lib/fmrest/v1/container_fields.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module FmRest
+  module V1
+    module ContainerFields
+      DEFAULT_UPLOAD_CONTENT_TYPE = "application/octet-stream".freeze
+
+      # Given a container field URL it tries to fetch it and returns an IO
+      # object with its body content (see Ruby's OpenURI for how the IO object
+      # is extended with useful HTTP response information).
+      #
+      # This method uses Net::HTTP and OpenURI instead of Faraday.
+      #
+      # @raise [FmRest::ContainerFieldError] if any step fails
+      # @param container_field_url [String] the URL to the container to
+      #   download
+      # @return [IO] the contents of the container
+      def fetch_container_data(container_field_url)
+        require "open-uri"
+
+        begin
+          url = URI(container_field_url)
+        rescue ::URI::InvalidURIError
+          raise FmRest::ContainerFieldError, "Invalid container field URL `#{container_field_url}'"
+        end
+
+        # Make sure we don't try to open anything on the file:/ URI scheme
+        unless url.scheme.match(/\Ahttps?\Z/)
+          raise FmRest::ContainerFieldError, "Container URL is not HTTP (#{container_field_url})"
+        end
+
+        require "net/http"
+
+        # Requesting the container URL with no cookie set will respond with a
+        # redirect and a session cookie
+        cookie_response = ::Net::HTTP.get_response(url)
+
+        unless cookie = cookie_response["Set-Cookie"]
+          raise FmRest::ContainerFieldError, "Container field's initial request didn't return a session cookie, the URL may be stale (try downloading it again immediately after retrieving the record)"
+        end
+
+        # Now request the URL again with the proper session cookie using
+        # OpenURI, which wraps the response in an IO object which also responds
+        # to #content_type
+        url.open("Cookie" => cookie)
+      end
+
+      # Handles the core logic of uploading a file into a container field
+      #
+      # @param connection [Faraday] the Faraday connection to use
+      # @param container_path [String] the path to the container
+      # @param filename_or_io [String, IO] a path to the file to upload or an
+      #   IO object
+      # @param options [Hash]
+      # @option options [String] :content_type (DEFAULT_UPLOAD_CONTENT_TYPE)
+      #   The content type for the uploaded file
+      # @option options [String] :filename The filename to use for the uploaded
+      #   file, defaults to `filename_or_io.original_filename` if available
+      def upload_container_data(connection, container_path, filename_or_io, options = {})
+        content_type = options[:content_type] || DEFAULT_UPLOAD_CONTENT_TYPE
+
+        connection.post do |request|
+          request.url container_path
+          request.headers['Content-Type'] = ::Faraday::Request::Multipart.mime_type
+
+          filename = options[:filename] || filename_or_io.try(:original_filename)
+
+          request.body = { upload: Faraday::UploadIO.new(filename_or_io, content_type, filename) }
+        end
+      end
+    end
+  end
+end

data/lib/fmrest/v1/paths.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module FmRest
+  module V1
+    module Paths
+      def session_path(token = nil)
+        url = "sessions"
+        url += "/#{token}" if token
+        url
+      end
+
+      def record_path(layout, id = nil)
+        url = "layouts/#{URI.escape(layout.to_s)}/records"
+        url += "/#{id}" if id
+        url
+      end
+
+      def container_field_path(layout, id, field_name, field_repetition = 1)
+        url = record_path(layout, id)
+        url += "/containers/#{URI.escape(field_name.to_s)}"
+        url += "/#{field_repetition}" if field_repetition
+        url
+      end
+
+      def find_path(layout)
+        "layouts/#{URI.escape(layout.to_s)}/_find"
+      end
+
+      def globals_path
+        "globals"
+      end
+    end
+  end
+end

data/lib/fmrest/v1/raise_errors.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "fmrest/errors"
+
+module FmRest
+  module V1
+    # FM Data API response middleware for raising exceptions on API response
+    # errors
+    #
+    # https://fmhelp.filemaker.com/help/17/fmp/en/index.html#page/FMP_Help/error-codes.html
+    #
+    class RaiseErrors < Faraday::Response::Middleware
+      # https://fmhelp.filemaker.com/help/17/fmp/en/index.html#page/FMP_Help/error-codes.html
+      ERROR_RANGES = {
+        -1         => APIError::UnknownError,
+        100        => APIError::ResourceMissingError,
+        101        => APIError::RecordMissingError,
+        102..199   => APIError::ResourceMissingError,
+        200..299   => APIError::AccountError,
+        300..399   => APIError::LockError,
+        400..499   => APIError::ParameterError,
+        500..599   => APIError::ValidationError,
+        800..899   => APIError::SystemError,
+        1200..1299 => APIError::ScriptError,
+        1400..1499 => APIError::ODBCError
+      }
+
+      def on_complete(env)
+        # Sniff for either straight JSON parsing or Spyke's format
+        if env.body[:metadata] && env.body[:metadata][:messages]
+          check_errors(env.body[:metadata][:messages])
+        elsif env.body["messages"]
+          check_errors(env.body["messages"])
+        end
+      end
+
+      private
+
+      def check_errors(messages)
+        messages.each do |message|
+          error_code = (message["code"] || message[:code]).to_i
+
+          # Code 0 means "No Error"
+          next if error_code.zero?
+
+          error_message = message["message"] || message[:message]
+
+          *, exception_class = ERROR_RANGES.find { |k, v| k === error_code }
+
+          raise (exception_class || APIError).new(error_code, error_message)
+        end
+      end
+    end
+  end
+end