fmrest 0.11.0 → 0.14.0

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    module Model
-      module Auth
-        extend ::ActiveSupport::Concern
-
-        class_methods do
-          # Logs out the database session for this model (and other models
-          # using the same credentials).
-          #
-          # @raise [FmRest::V1::TokenSession::NoSessionTokenSet] if no session
-          #   token was set (and no request is sent).
-          def logout!
-            connection.delete(FmRest::V1.session_path("dummy-token"))
-          end
-
-          # Logs out the database session for this model (and other models
-          # using the same credentials). Unlike `logout!`, no exception is
-          # raised in case of missing session token.
-          #
-          # @return [Boolean] Whether the logout request was sent (it's only
-          #   sent if a session token was previously set)
-          def logout
-            logout!
-            true
-          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
-  end
-end

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

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    module Model
-      module Connection
-        extend ActiveSupport::Concern
-
-        included do
-          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 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
-
-          # 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
-            memoize = false
-
-            # 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
-
-            config = ConnectionSettings.wrap(fmrest_config)
-
-            connection =
-              FmRest::V1.build_connection(config) do |conn|
-                faraday_block.call(conn) if faraday_block
-
-                # 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
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/spyke/container_field"
-
-module FmRest
-  module Spyke
-    module Model
-      module ContainerFields
-        extend ::ActiveSupport::Concern
-
-        class_methods do
-          def container(name, options = {})
-            field_name = options[:field_name] || name
-
-            define_method(name) do
-              @container_fields ||= {}
-              @container_fields[name.to_sym] ||= ContainerField.new(self, field_name)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    module Model
-      module GlobalFields
-        extend ::ActiveSupport::Concern
-
-        FULLY_QUALIFIED_FIELD_NAME_MATCHER = /\A[^:]+::[^:]+\Z/.freeze
-
-        class_methods do
-          def set_globals(values_hash)
-            connection.patch(FmRest::V1.globals_path, {
-              globalFields: normalize_globals_hash(values_hash)
-            })
-          end
-
-          private
-
-          def normalize_globals_hash(hash)
-            hash.each_with_object({}) do |(k, v), normalized|
-              if v.kind_of?(Hash)
-                v.each do |k2, v2|
-                  normalized["#{k}::#{k2}"] = v2
-                end
-                next
-              end
-
-              unless FULLY_QUALIFIED_FIELD_NAME_MATCHER === k.to_s
-                raise ArgumentError, "global fields must be given in fully qualified format (table name::field name)"
-              end
-
-              normalized[k] = v
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/spyke/relation"
-
-module FmRest
-  module Spyke
-    module Model
-      module Http
-        extend ::ActiveSupport::Concern
-
-        class_methods do
-
-          # Override Spyke's request method to keep a thread-local copy of the
-          # last request's metadata, so that we can access things like script
-          # execution results after a save, etc.
-
-
-          def request(*args)
-            super.tap do |r|
-              Thread.current[last_request_metadata_key] = r.metadata
-            end
-          end
-
-          def last_request_metadata(key: last_request_metadata_key)
-            Thread.current[key]
-          end
-
-          private
-
-          def last_request_metadata_key
-            "#{to_s}.last_request_metadata"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/spyke/relation"
-require "fmrest/spyke/validation_error"
-
-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
-
-          # Whether to raise an FmRest::APIError::NoMatchingRecordsError when a
-          # _find request has no results
-          class_attribute :raise_on_no_matching_records, instance_accessor: false, instance_predicate: false
-        end
-
-        class_methods do
-          # Methods delegated to FmRest::Spyke::Relation
-          delegate :limit, :offset, :sort, :order, :query, :omit, :portal,
-                   :portals, :includes, :with_all_portals, :without_portals,
-                   :script, :find_one, :first, :any, :find_some,
-                   :find_in_batches, :find_each, to: :all
-
-          def all
-            # Use FmRest's Relation instead 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
-
-            # The DAPI returns a 401 "No records match the request" error when
-            # nothing matches a _find request, so we need to catch it in order
-            # to provide sane behavior (i.e. return an empty resultset)
-            begin
-              current_scope.has_query? ? scoped_request(:post) : super
-            rescue FmRest::APIError::NoMatchingRecordsError => e
-              raise e if raise_on_no_matching_records
-              ::Spyke::Result.new({})
-            end
-          ensure
-            self.current_scope = previous
-          end
-
-          # API-error-raising version of #create
-          #
-          def create!(attributes = {})
-            new(attributes).tap(&:save!)
-          end
-
-          def execute_script(script_name, param: nil)
-            params = {}
-            params = {"script.param" => param} unless param.nil?
-            request(:get, FmRest::V1::script_path(layout, script_name), params)
-          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?
-              where_options["#{prefix}sort"] =
-                prefixed ? scope.sort_params.to_json : scope.sort_params
-            end
-
-            unless scope.included_portals.nil?
-              where_options["portal"] =
-                prefixed ? scope.included_portals.to_json : scope.included_portals
-            end
-
-            if scope.portal_params.present?
-              scope.portal_params.each do |portal_param, value|
-                where_options["#{prefix}#{portal_param}"] = value
-              end
-            end
-
-            if scope.script_params.present?
-              where_options.merge!(scope.script_params)
-            end
-
-            scope.where(where_options)
-          end
-        end
-
-        # Overwrite Spyke's save to provide a number of features:
-        #
-        # * Validations
-        # * Data API scripts execution
-        # * Refresh of dirty attributes
-        #
-        def save(options = {})
-          callback = persisted? ? :update : :create
-
-          return false unless perform_save_validations(callback, options)
-          return false unless perform_save_persistence(callback, options)
-
-          true
-        end
-
-        def save!(options = {})
-          save(options.merge(raise_validation_errors: true))
-        end
-
-        # Overwrite Spyke's destroy to provide Data API script execution
-        #
-        def destroy(options = {})
-          # For whatever reason the Data API wants the script params as query
-          # string params for DELETE requests, making this more complicated
-          # than it should be
-          script_query_string = if options.has_key?(:script)
-                                  "?" + Faraday::Utils.build_query(FmRest::V1.convert_script_params(options[:script]))
-                                else
-                                  ""
-                                end
-
-          self.attributes = delete(uri.to_s + script_query_string)
-        end
-
-        # API-error-raising version of #update
-        #
-        def update!(new_attributes, options = {})
-          self.attributes = new_attributes
-          save!(options)
-        end
-
-        def reload(options = {})
-          scope = self.class
-          scope = scope.script(options[:script]) if options.has_key?(:script)
-          reloaded = scope.find(id)
-          self.attributes = reloaded.attributes
-          self.mod_id = reloaded.mod_id
-        end
-
-        # ActiveModel 5+ implements this method, so we only needed if we're in
-        # the older AM4
-        if ActiveModel::VERSION::MAJOR == 4
-          def validate!(context = nil)
-            valid?(context) || raise_validation_error
-          end
-        end
-
-        private
-
-        def perform_save_validations(context, options)
-          return true if options[:validate] == false
-          options[:raise_validation_errors] ? validate!(context) : validate(context)
-        end
-
-        def perform_save_persistence(callback, options)
-          run_callbacks :save do
-            run_callbacks(callback) do
-
-              begin
-                send self.class.method_for(callback), build_params_for_save(options)
-
-              rescue APIError::ValidationError => e
-                if options[:raise_validation_errors]
-                  raise e
-                else
-                  return false
-                end
-              end
-
-            end
-          end
-
-          true
-        end
-
-        def build_params_for_save(options)
-          to_params.tap do |params|
-            if options.has_key?(:script)
-              params.merge!(FmRest::V1.convert_script_params(options[:script]))
-            end
-          end
-        end
-
-        # Overwrite ActiveModel's raise_validation_error to use our own class
-        #
-        def raise_validation_error # :doc:
-          raise(ValidationError.new(self))
-        end
-      end
-    end
-  end
-end