fmrest 0.1.0

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

@@ -0,0 +1,53 @@
+module FmRest
+  module Spyke
+    module Model
+      module Connection
+        extend ::ActiveSupport::Concern
+
+        included do
+          class_attribute :fmrest_config, instance_accessor: false, instance_predicate: false
+
+          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)
+          self.callback_methods = { create: :post, update: :patch }.freeze
+        end
+
+        class_methods do
+          def connection
+            super || fmrest_connection
+          end
+
+          # Sets a block for injecting custom middleware into the Faraday
+          # connection. Example usage:
+          #
+          #     class MyModel < FmRest::Spyke::Base
+          #       faraday do |conn|
+          #         # Set up a custom logger for the model
+          #         conn.response :logger, MyApp.logger, bodies: true
+          #       end
+          #     end
+          #
+          def faraday(&block)
+            self.faraday_block = block
+          end
+
+          private
+
+          def fmrest_connection
+            @fmrest_connection ||= FmRest::V1.build_connection(fmrest_config) do |conn|
+              faraday_block.call(conn) if faraday_block
+
+              # Pass the class to JsonParser'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::JsonParser, self
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require "fmrest/spyke/relation"
+
+module FmRest
+  module Spyke
+    module Model
+      module Orm
+        extend ::ActiveSupport::Concern
+
+        included do
+          # Allow overriding FM's default limit (by default it's 100)
+          class_attribute :default_limit, instance_accessor: false, instance_predicate: false
+
+          class_attribute :default_sort, instance_accessor: false, instance_predicate: false
+        end
+
+        class_methods do
+          delegate :limit, :offset, :sort, :query, :portal, to: :all
+
+          def all
+            # Use FmRest's Relation insdead of Spyke's vanilla one
+            current_scope || Relation.new(self, uri: uri)
+          end
+
+          # Extended fetch to allow properly setting limit, offset and other
+          # options, as well as using the appropriate HTTP method/URL depending
+          # on whether there's a query present in the current scope, e.g.:
+          #
+          #     Person.query(first_name: "Stefan").fetch # POST .../_find
+          #
+          def fetch
+            if current_scope.has_query?
+              scope = extend_scope_with_fm_params(current_scope, prefixed: false)
+              scope = scope.where(query: scope.query_params)
+              scope = scope.with(FmRest::V1::find_path(layout))
+            else
+              scope = extend_scope_with_fm_params(current_scope, prefixed: true)
+            end
+
+            previous, self.current_scope = current_scope, scope
+            current_scope.has_query? ? scoped_request(:post) : super
+          ensure
+            self.current_scope = previous
+          end
+
+          private
+
+          def extend_scope_with_fm_params(scope, prefixed: false)
+            prefix = prefixed ? "_" : nil
+
+            where_options = {}
+
+            where_options["#{prefix}limit"] = scope.limit_value if scope.limit_value
+            where_options["#{prefix}offset"] = scope.offset_value if scope.offset_value
+
+            if scope.sort_params.present? && scope.limit_value != 1
+              where_options["#{prefix}sort"] =
+                prefixed ? scope.sort_params.to_json : scope.sort_params
+            end
+
+            if scope.portal_params.present?
+              where_options["portal"] =
+                prefixed ? scope.portal_params.to_json : scope.portal_params
+            end
+
+            scope.where(where_options)
+          end
+        end
+
+        # Ensure save returns true/false, following ActiveRecord's convention
+        #
+        def save(options = {})
+          if options[:validate] == false || valid?
+            super().present? # Failed save returns empty hash
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module FmRest
+  module Spyke
+    module Model
+      module Uri
+        extend ::ActiveSupport::Concern
+
+        class_methods do
+          # Accessor for FM layout (helps with building the URI)
+          #
+          def layout(layout = nil)
+            @layout = layout if layout
+            @layout ||= model_name.name
+          end
+
+          # Extend uri acccessor to default to FM Data schema
+          #
+          def uri(uri_template = nil)
+            if @uri.nil? && uri_template.nil?
+              return FmRest::V1.record_path(layout) + "(/:id)"
+            end
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fmrest/spyke/portal.rb

@@ -0,0 +1,53 @@
+module FmRest
+  module Spyke
+    # Extend Spyke's HasMany association with custom options
+    #
+    class Portal < ::Spyke::Associations::HasMany
+      def initialize(*args)
+        super
+
+        # Portals are always embedded, so no special URI
+        @options[:uri] = ""
+      end
+
+      def portal_key
+        return @options[:portal_key] if @options[:portal_key]
+        name
+      end
+
+      def attribute_prefix
+        @options[:attribute_prefix] || portal_key
+      end
+
+      def parent_changes_applied
+        each do |record|
+          record.changes_applied
+          # Saving portal data doesn't provide new modIds for the
+          # portal records, so we clear them instead. We can still save
+          # portal data without a mod_id (it's optional in FM Data API)
+          record.mod_id = nil
+        end
+      end
+
+      private
+
+      # Spyke::Associations::HasMany#initialize calls primary_key to build the
+      # default URI, which causes a NameError, so this is here just to prevent
+      # that. We don't care what it returns as we override the URI with nil
+      # anyway
+      def primary_key; end
+
+      # Make sure the association doesn't try to fetch records through URI
+      def uri; nil; end
+
+      def embedded_data
+        parent.attributes[portal_key]
+      end
+
+      def add_to_parent(record)
+        find_some << record
+        record
+      end
+    end
+  end
+end

data/lib/fmrest/spyke/relation.rb

@@ -0,0 +1,140 @@
+module FmRest
+  module Spyke
+    class Relation < ::Spyke::Relation
+      SORT_PARAM_MATCHER = /(.*?)(!|__desc(?:end)?)?\Z/.freeze
+
+      # We need to keep these separate from regular params because FM Data API
+      # uses either "limit" or "_limit" (or "_offset", etc.) as param keys
+      # depending on the type of request, so we can't set the params until the
+      # last moment
+      attr_accessor :limit_value, :offset_value, :sort_params, :query_params,
+                    :portal_params
+
+      def initialize(*_args)
+        super
+
+        @limit_value = klass.default_limit
+
+        if klass.default_sort.present?
+          @sort_params = Array.wrap(klass.default_sort).map { |s| normalize_sort_param(s) }
+        end
+
+        @query_params = []
+        @portal_params = []
+      end
+
+      def limit(value)
+        with_clone { |r| r.limit_value = value }
+      end
+
+      def offset(value)
+        with_clone { |r| r.offset_value = value }
+      end
+
+      # Allows sort params given in either hash format (using FM Data API's
+      # format), or as a symbol, in which case the of the attribute must match
+      # a known mapped attribute, optionally suffixed with ! or __desc[end] to
+      # signify it should use descending order.
+      #
+      # E.g.
+      #
+      #     Person.sort(:first_name, :age!)
+      #     Person.sort(:first_name, :age__desc)
+      #     Person.sort(:first_name, :age__descend)
+      #     Person.sort({ fieldName: "FirstName" }, { fieldName: "Age", sortOrder: "descend" })
+      #
+      def sort(*args)
+        with_clone do |r|
+          r.sort_params = args.flatten.map { |s| normalize_sort_param(s) }
+        end
+      end
+      alias :order :sort
+
+      def portal(*args)
+        with_clone do |r|
+          r.portal_params += args.flatten.map { |p| normalize_portal_param(p) }
+          r.portal_params.uniq!
+        end
+      end
+      alias :includes :portal
+
+      def query(*params)
+        with_clone do |r|
+          r.query_params += params.flatten.map { |p| normalize_query_params(p) }
+        end
+      end
+
+      def omit(params)
+        query(params.merge(omit: true))
+      end
+
+      def has_query?
+        query_params.present?
+      end
+
+      def find_one
+        return super if params[klass.primary_key].present?
+        @find_one ||= klass.new_collection_from_result(limit(1).fetch).first
+      rescue ::Spyke::ConnectionError => error
+        fallback_or_reraise(error, default: nil)
+      end
+
+      private
+
+      def normalize_sort_param(param)
+        if param.kind_of?(Symbol) || param.kind_of?(String)
+          _, attr, descend = param.to_s.match(SORT_PARAM_MATCHER).to_a
+
+          unless field_name = klass.mapped_attributes[attr]
+            raise ArgumentError, "Unknown attribute `#{attr}' given to sort as #{param.inspect}. If you want to use a custom sort pass a hash in the Data API format"
+          end
+
+          hash = { fieldName: field_name }
+          hash[:sortOrder] = "descend" if descend
+          return hash
+        end
+
+        # TODO: Sanitize sort hash param for FM Data API conformity?
+        param
+      end
+
+      def normalize_portal_param(param)
+        if param.kind_of?(Symbol)
+          portal_key, = klass.portal_options.find { |_, opts| opts[:name].to_s == param.to_s }
+
+          unless portal_key
+            raise ArgumentError, "Unknown portal #{param.inspect}. If you want to include a portal not defined in the model pass it as a string instead"
+          end
+
+          return portal_key
+        end
+
+        param
+      end
+
+      def normalize_query_params(params)
+        params.each_with_object({}) do |(k, v), normalized|
+          if k == :omit || k == "omit"
+            # FM Data API wants omit values as strings, e.g. "true" or "false"
+            # rather than true/false
+            normalized["omit"] = v.to_s
+            next
+          end
+
+          # TODO: Raise ArgumentError if an attribute given as symbol isn't defiend
+          if k.kind_of?(Symbol) && klass.mapped_attributes.has_key?(k)
+            normalized[klass.mapped_attributes[k].to_s] = v
+          else
+            normalized[k.to_s] = v
+          end
+        end
+      end
+
+      def with_clone
+        clone.tap do |relation|
+          yield relation
+        end
+      end
+    end
+  end
+end

data/lib/fmrest/v1.rb

@@ -0,0 +1,54 @@
+require "fmrest/v1/token_session"
+require "uri"
+
+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
+  end
+end

data/lib/fmrest/v1/token_session.rb

@@ -0,0 +1,91 @@
+module FmRest
+  module V1
+    # FM Data API authentication middleware using the credentials strategy
+    #
+    class TokenSession < Faraday::Middleware
+      HEADER_KEY = "Authorization".freeze
+
+      def initialize(app, options = FmRest.config)
+        super(app)
+        @options = options
+      end
+
+      # Entry point for the middleware when sending a request
+      #
+      def call(env)
+        set_auth_header(env)
+
+        request_body = env[:body] # After failure env[:body] is set to the response body
+
+        @app.call(env).on_complete do |response_env|
+          if response_env[:status] == 401 # Unauthorized
+            env[:body] = request_body
+            token_store.clear
+            set_auth_header(env)
+            return @app.call(env)
+          end
+        end
+      end
+
+      private
+
+      def set_auth_header(env)
+        env.request_headers[HEADER_KEY] = "Bearer #{token}"
+      end
+
+      # Tries to get an existing token from the token store,
+      # otherwise requests one through basic auth,
+      # otherwise raises an exception.
+      #
+      def token
+        token = token_store.fetch
+        return token if token
+
+        if token = request_token
+          token_store.store(token)
+          return token
+        end
+
+        # TODO: Make this a custom exception class
+        raise "Filemaker auth failed"
+      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
+
+      def token_store
+        @token_store ||= token_store_class.new(@options.fetch(:host), @options.fetch(:database))
+      end
+
+      def token_store_class
+        FmRest.token_store ||
+          begin
+            # TODO: Make this less ugly
+            require "fmrest/v1/token_store/memory"
+            TokenStore::Memory
+          end
+      end
+
+      def auth_connection
+        @auth_connection ||= V1.base_connection(@options) do |conn|
+          conn.basic_auth @options.fetch(: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
+      end
+    end
+  end
+end