quiver 0.21.0

data/lib/quiver/action/invalid_request_body_error.rb

@@ -0,0 +1,30 @@
+module Quiver::Action
+  class InvalidRequestBodyError < Quiver::Error
+    def initialize
+    end
+
+    def title
+      'invalid_request_body'
+    end
+
+    def detail
+      'request body must be valid json'
+    end
+
+    def path
+      "/"
+    end
+
+    def status
+      400
+    end
+
+    def code
+      :invalid_request_body
+    end
+
+    def serialization_type
+      'Error'
+    end
+  end
+end

data/lib/quiver/action/pagination_link_builder.rb

@@ -0,0 +1,67 @@
+module Quiver
+  module Action
+    class PaginationLinkBuilder
+      def initialize(request_path_with_query, offset, limit, total_count)
+        self.request_path_with_query = request_path_with_query
+        self.offset = offset
+        self.limit = limit
+        self.total_count = total_count
+      end
+
+      def pagination_links
+        links = {}
+        links[:self] = request_path_with_query
+        links[:last] = build_link(last_page)
+
+        links[:next] = build_link(next_page) if next_page
+        links[:prev] = build_link(previous_page) if previous_page
+
+        links
+      end
+
+      private
+
+      attr_accessor :request_path_with_query, :offset, :limit, :total_count
+
+      def build_link(offset)
+        uri = parsed_uri
+        query_params = Rack::Utils.parse_nested_query(uri.query)
+        query_params['page'] ||= {}
+        query_params['page']['limit'] = limit
+        query_params['page']['offset'] = offset
+        uri.query = Rack::Utils.build_nested_query(query_params)
+        uri.to_s
+      end
+
+      def parsed_uri
+        URI.parse(request_path_with_query)
+      end
+
+      def next_page
+        if limit != -1 && total_count > offset + limit
+          offset + limit
+        end
+      end
+
+      def previous_page
+        if offset > 0
+          if limit == -1
+            0
+          else
+            [offset - limit, 0].max
+          end
+        end
+      end
+
+      def last_page
+        if limit == -1
+          0
+        else
+          # rounds total_count down to the offset that
+          # represents the last page of the resources
+          (total_count / limit) * limit
+        end
+      end
+    end
+  end
+end

data/lib/quiver/adapter.rb

@@ -0,0 +1,51 @@
+module Quiver
+  module Adapter
+    class AdapterResult
+      include Quiver::Result
+    end
+
+    def self.included(host)
+      host.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def adapter_type(val=nil)
+        if val
+          @adapter_type = val
+        end
+
+        @adapter_type
+      end
+
+      def primary_key_name(val=nil)
+        if val
+          @primary_key_name = val
+        end
+
+        if @primary_key_name.nil?
+          raise RuntimeError, 'mapper adapters must specify primary_key_name'
+        end
+
+        @primary_key_name
+      end
+    end
+
+    def adapter_type
+      self.class.adapter_type
+    end
+
+    private
+
+    attr_accessor :mapper_klass
+
+    def primary_key_name
+      self.class.primary_key_name
+    end
+  end
+end
+
+require 'quiver/adapter/filter_helpers'
+require 'quiver/adapter/helpers_helpers'
+require 'quiver/adapter/memory_helpers'
+require 'quiver/adapter/memory_uuid_primary_key'
+require 'quiver/adapter/active_record_helpers'

data/lib/quiver/adapter/active_record_adapter_filter.rb

@@ -0,0 +1,102 @@
+module Quiver
+  module Adapter
+    module ActiveRecordAdapterFilterDefaults
+      include FilterHelpers
+
+      def self.included(host)
+        host.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def find(attr_name, opts)
+          raise ArgumentError, ':on must be a table name specified as a symbol' unless opts[:on].is_a?(Symbol)
+          # in the future we want to support arrays, but right now we don't need
+          # it so it is hard to justify the extra time it would take
+          #
+          # tables = opts[:on].is_a?(Array) ? opts[:on] : [opts[:on]]
+          attr_lookup_table[attr_name.to_sym] = opts[:on]
+        end
+
+        private
+
+        def attr_lookup_table
+          @attr_lookup_table ||= {}
+        end
+      end
+
+      def equal_filter(memo, attr, value)
+        memo.where(hash_style_attr(attr, value))
+      end
+
+      def not_equal_filter(memo, attr, value)
+        memo.where.not(hash_style_attr(attr, value))
+      end
+
+      def in_filter(memo, attr, value)
+        memo.where(hash_style_attr(attr, value))
+      end
+
+      def not_in_filter(memo, attr, value)
+        memo.where.not(hash_style_attr(attr, value))
+      end
+
+      def less_than_filter(memo, attr, value)
+        memo.where("#{string_style_attr(attr)} < ?", value)
+      end
+
+      def greater_than_filter(memo, attr, value)
+        memo.where("#{string_style_attr(attr)} > ?", value)
+      end
+
+      def less_than_or_equal_filter(memo, attr, value)
+        memo.where("#{string_style_attr(attr)} <= ?", value)
+      end
+
+      def greater_than_or_equal_filter(memo, attr, value)
+        memo.where("#{string_style_attr(attr)} >= ?", value)
+      end
+
+      def nil_filter(memo, attr, value)
+        if value == 'true' || value == true
+          memo.where("#{string_style_attr(attr)} IS NULL")
+        else
+          memo.where("#{string_style_attr(attr)} IS NOT NULL")
+        end
+      end
+
+      def not_nil_filter(memo, attr, value)
+        if value == 'true' || value == true
+          memo.where("#{string_style_attr(attr)} IS NOT NULL")
+        else
+          memo.where("#{string_style_attr(attr)} IS NULL")
+        end
+      end
+
+      private
+
+      def attr_lookup(attr)
+        self.class.send(:attr_lookup_table)[attr]
+      end
+
+      def hash_style_attr(attr, value)
+        if table = attr_lookup(attr)
+          {table => {attr => value}}
+        else
+          {attr => value}
+        end
+      end
+
+      def string_style_attr(attr)
+        if table = attr_lookup(attr)
+          "#{table}.#{attr}"
+        else
+          attr
+        end
+      end
+    end
+
+    class ActiveRecordAdapterFilter
+      include ActiveRecordAdapterFilterDefaults
+    end
+  end
+end

data/lib/quiver/adapter/active_record_helpers.rb

@@ -0,0 +1,258 @@
+require 'quiver/adapter/active_record_adapter_filter'
+require 'quiver/adapter/arec_low_level_creator'
+require 'quiver/adapter/arec_low_level_updater'
+require 'quiver/adapter/arec_low_level_deleter'
+require 'quiver/mappers'
+
+module Quiver
+  module Adapter
+    module ActiveRecord
+      include Quiver::Adapter::HelpersHelpers
+
+      def self.included(host)
+        super
+
+        host.adapter_type(:active_record)
+        host.send(:extend, ClassMethods)
+      end
+
+      module ClassMethods
+        def define_record_class(name, options)
+          return if !self.parents[-2]::Application.using_active_record
+
+          table_name = options.fetch(:table)
+
+          record_classes[name] = Class.new(::ActiveRecord::Base) do
+            self.table_name = table_name
+            self.inheritance_column = 'a_name_that_will_never_be_used'
+
+            def self.name=(val)
+              @reported_name = val
+            end
+
+            def self.name
+              @reported_name
+            end
+          end.tap do |klass|
+            klass.name = name
+          end
+        end
+
+        def record_classes
+          @record_classes ||= {}
+        end
+
+        def use_record_class(val=nil)
+          if val
+            @use_record_class = val
+          end
+
+          @use_record_class
+        end
+      end
+
+      def find(primary_key)
+        Quiver::Adapter::AdapterResult.new do |errors|
+          if record = base_query.find_by(primary_key_name => primary_key)
+            load_additional([record.attributes.symbolize_keys]).first
+          else
+            errors << Quiver::Mapper::NotFoundError.new('record', 'not_found')
+            nil
+          end
+        end
+      end
+
+      def count
+        count = default_record_class.count
+
+        Quiver::Adapter::AdapterResult.new(count)
+      end
+
+      def create(attributes, transaction)
+        persister = ARecLowLevelCreator.new(self.class, attributes)
+
+        if attributes[:__type__]
+          attributes = attributes.merge(
+            attributes[:__type__][:name] => attributes[:__type__][:value]
+          )
+
+          attributes.delete(:__type__)
+        end
+
+        begin
+          create_mappings(attributes, persister)
+        rescue ::ActiveRecord::ActiveRecordError
+          transaction.rollback!
+          persister.failed!
+        end
+
+        Quiver::Adapter::AdapterResult.new do |errors|
+          if persister.success?
+            persister.result
+          else
+            errors << Quiver::Error.new('record', 'not_persisted')
+            nil
+          end
+        end
+      end
+
+      def update(attributes, transaction)
+        persister = ARecLowLevelUpdater.new(self.class, attributes)
+
+        if attributes[:__type__]
+          attributes = attributes.merge(
+            attributes[:__type__][:name] => attributes[:__type__][:value]
+          )
+
+          attributes.delete(:__type__)
+        end
+
+        begin
+          update_mappings(attributes, persister)
+        rescue ::ActiveRecord::ActiveRecordError
+          transaction.rollback!
+          persister.failed!
+        end
+
+        Quiver::Adapter::AdapterResult.new do |errors|
+          if persister.success?
+            persister.result
+          else
+            errors << Quiver::Error.new('record', 'not_updated')
+            nil
+          end
+        end
+      end
+
+      def hard_delete(attributes, transaction)
+        unpersister = ARecLowLevelDeleter.new(self.class, attributes)
+
+        if attributes[:__type__]
+          attributes = attributes.merge(
+            attributes[:__type__][:name] => attributes[:__type__][:value]
+          )
+
+          attributes.delete(:__type__)
+        end
+
+        begin
+          delete_mappings(attributes, unpersister)
+        rescue ::ActiveRecord::ActiveRecordError
+          transaction.rollback!
+          unpersister.failed!
+        end
+
+        Quiver::Adapter::AdapterResult.new do |errors|
+          if unpersister.success?
+            {}
+          else
+            errors << Quiver::Error.new('record', 'not_deleted')
+            nil
+          end
+        end
+      end
+
+      def query(q={})
+        filter_params = q[:filter] || {}
+        sort_params = q[:sort] || {}
+        pagination_params = q[:page] || {}
+
+        query = filter_klass.new(
+          base_query,
+          filter_params
+        ).filter
+
+        count_query = filter_klass.new(
+          base_count_query,
+          filter_params
+        ).filter
+
+        sort_params.each do |attr, asc|
+          order = asc ? 'ASC' : 'DESC'
+          query = query.order("#{attr} #{order}")
+          count_query = count_query.order("#{attr} #{order}")
+        end
+
+        total_count = count_query.count
+
+        if pagination_params['limit'] && pagination_params['limit'] != -1
+          query = query.limit(pagination_params['limit'])
+        end
+
+        if pagination_params['offset']
+          query = query.offset(pagination_params['offset'])
+        end
+
+        objects = load_additional(query.map(&:attributes).map(&:symbolize_keys))
+        result = Quiver::Adapter::AdapterResult.new(objects)
+
+        if pagination_params.any?
+          result.data[:pagination_offset] = pagination_params['offset'] || 0
+          result.data[:pagination_limit] = pagination_params['limit'] || -1
+          result.data[:total_count] = total_count
+        end
+
+        result
+      end
+
+      private
+
+      def default_record_class
+        self.class.record_classes[self.class.use_record_class]
+      end
+
+      def fetch_and_hydrate(record_klass, primary_key)
+        errors = Quiver::ErrorCollection.new
+
+        if record = record_klass.find_by(primary_key_name => primary_key)
+          attributes = load_additional([record.attributes]).first
+
+          object = hydrate(attributes)
+        else
+          errors << Quiver::Mapper::NotFoundError.new('record', 'not_found')
+          object = nil
+        end
+
+        Quiver::Mapper::MapperResult.new(object, errors)
+      end
+
+      def base_query
+        default_record_class.where({})
+      end
+
+      def base_count_query
+        default_record_class.where({})
+      end
+
+      def filter_klass
+        Quiver::Adapter::ActiveRecordAdapterFilter
+      end
+
+      def load_additional(items)
+        items
+      end
+
+      def mappings(attributes, p)
+        p.map(
+          attributes,
+          to: self.class.use_record_class,
+          primary: true
+        )
+      end
+
+      def create_mappings(attributes, p)
+        mappings(attributes, p)
+      end
+
+      def update_mappings(attributes, p)
+        mappings(attributes, p)
+      end
+
+      def delete_mappings(attributes, p)
+        mappings(attributes, p)
+      end
+    end
+
+    ActiveRecordHelpers = ActiveRecord
+  end
+end