graphiti 1.0.alpha.1

data/lib/graphiti/resource/dsl.rb

@@ -0,0 +1,138 @@
+module Graphiti
+  class Resource
+    module DSL
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def filter(name, *args, &blk)
+          opts = args.extract_options!
+
+          if att = get_attr(name, :filterable, raise_error: :only_unsupported)
+            aliases = [name, opts[:aliases]].flatten.compact
+            operators = FilterOperators.build(&blk)
+            config[:filters][name.to_sym] = {
+              aliases: aliases,
+              type: att[:type]
+            }.merge(operators.to_hash)
+          else
+            if type = args[0]
+              attribute name, type, only: [:filterable]
+              filter(name, opts, &blk)
+            else
+              raise Errors::ImplicitFilterTypeMissing.new(self, name)
+            end
+          end
+        end
+
+        def sort_all(&blk)
+          if block_given?
+            config[:_sort_all] = blk
+          else
+            config[:_sort_all]
+          end
+        end
+
+        def sort(name, *args, &blk)
+          opts = args.extract_options!
+
+          if get_attr(name, :sortable, raise_error: :only_unsupported)
+            config[:sorts][name] = blk
+          else
+            if type = args[0]
+              attribute name, type, only: [:sortable]
+              sort(name, opts, &blk)
+            else
+              raise Errors::ImplicitSortTypeMissing.new(self, name)
+            end
+          end
+        end
+
+        def paginate(&blk)
+          config[:pagination] = blk
+        end
+
+        def stat(symbol_or_hash, &blk)
+          dsl = Stats::DSL.new(adapter, symbol_or_hash)
+          dsl.instance_eval(&blk) if blk
+          config[:stats][dsl.name] = dsl
+        end
+
+        def default_filter(name = nil, &blk)
+          name ||= :__default
+          config[:default_filters][name.to_sym] = {
+            filter: blk
+          }
+        end
+
+        def before_commit(only: [:create, :update, :destroy], &blk)
+          Array(only).each do |verb|
+            config[:before_commit][verb] = blk
+          end
+        end
+
+        def attribute(name, type, options = {}, &blk)
+          raise Errors::TypeNotFound.new(self, name, type) unless Types[type]
+          attribute_option(options, :readable)
+          attribute_option(options, :writable)
+          attribute_option(options, :sortable)
+          attribute_option(options, :filterable)
+          options[:type] = type
+          options[:proc] = blk
+          config[:attributes][name] = options
+          apply_attributes_to_serializer
+          filter(name) if options[:filterable]
+        end
+
+        def extra_attribute(name, type, options = {}, &blk)
+          raise Errors::TypeNotFound.new(self, name, type) unless Types[type]
+          defaults = {
+            type: type,
+            proc: blk,
+            readable: true,
+            writable: false,
+            sortable: false,
+            filterable: false
+          }
+          options = defaults.merge(options)
+          config[:extra_attributes][name] = options
+          apply_extra_attributes_to_serializer
+        end
+
+        def all_attributes
+          attributes.merge(extra_attributes)
+        end
+
+        def apply_attributes_to_serializer
+          serializer.type(type)
+          Util::SerializerAttributes.new(self, attributes).apply
+        end
+        private :apply_attributes_to_serializer
+
+        def apply_extra_attributes_to_serializer
+          Util::SerializerAttributes.new(self, extra_attributes, true).apply
+        end
+
+        def attribute_option(options, name)
+          if options[name] != false
+            default = if only = options[:only]
+                        Array(only).include?(name) ? true : false
+                      elsif except = options[:except]
+                        Array(except).include?(name) ? false : true
+                      else
+                        send(:"attributes_#{name}_by_default")
+                      end
+            options[name] ||= default
+          end
+        end
+        private :attribute_option
+
+       def relationship_option(options, name)
+          if options[name] != false
+            options[name] ||= send(:"relationships_#{name}_by_default")
+          end
+        end
+        private :attribute_option
+      end
+    end
+  end
+end

data/lib/graphiti/resource/interface.rb

@@ -0,0 +1,32 @@
+module Graphiti
+  class Resource
+    module Interface
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def all(params = {}, base_scope = nil)
+          _all(params, {}, base_scope)
+        end
+
+        def _all(params, opts, base_scope)
+          runner = Runner.new(self, params)
+          runner.proxy(base_scope, opts)
+        end
+
+        def find(params, base_scope = nil)
+          id = params[:data].try(:[], :id) || params.delete(:id)
+          params[:filter] ||= {}
+          params[:filter].merge!(id: id)
+
+          runner = Runner.new(self, params)
+          runner.proxy(base_scope, single: true, raise_on_missing: true)
+        end
+
+        def build(params, base_scope = nil)
+          runner = Runner.new(self, params)
+          runner.proxy(base_scope, single: true, raise_on_missing: true)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/resource/polymorphism.rb

@@ -0,0 +1,68 @@
+# For "Rails STI" behavior
+# CreditCard.all # => [<Visa>, <Mastercard>, etc]
+module Graphiti
+  class Resource
+    module Polymorphism
+      def self.prepended(klass)
+        klass.extend ClassMethods
+      end
+
+      def serializer_for(model)
+        if polymorphic_child?
+          serializer
+        else
+          child = self.class.resource_for_model(model)
+          child.serializer
+        end
+      end
+
+      def associate_all(parent, children, association_name, type)
+        children.each do |c|
+          associate(parent, c, association_name, type)
+        end
+      end
+
+      def associate(parent, child, association_name, type)
+        child_resource = self.class.resource_for_model(parent)
+        if child_resource.sideloads[association_name]
+          child_resource.adapter
+            .associate(parent, child, association_name, type)
+        end
+      end
+
+      module ClassMethods
+        def inherited(klass)
+          klass.type = nil
+          klass.model = klass.infer_model
+          klass.polymorphic_child = true
+          super
+        end
+
+        def sideload(name)
+          sl = super
+          if !polymorphic_child? && sl.nil?
+            children.each do |c|
+              break if sl = c.sideloads[name]
+            end
+          end
+          sl
+        end
+
+        def children
+          @children ||= polymorphic.map do |klass|
+            klass.is_a?(String) ? klass.safe_constantize : klass
+          end
+        end
+
+        def resource_for_model(model)
+          resource = children.find { |c| model.is_a?(c.model) }
+          if resource.nil?
+            raise Errors::PolymorphicChildNotFound.new(self, model)
+          else
+            resource
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/resource/sideloading.rb

@@ -0,0 +1,102 @@
+module Graphiti
+  class Resource
+    module Sideloading
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def allow_sideload(name, opts = {}, &blk)
+          klass = Class.new(opts.delete(:class) || Sideload)
+          klass.class_eval(&blk) if blk
+          opts[:parent_resource] = self
+          relationship_option(opts, :readable)
+          relationship_option(opts, :writable)
+          sideload = klass.new(name, opts)
+          if parent = opts[:parent]
+            parent.children[name] = sideload
+          else
+            config[:sideloads][name] = sideload
+            apply_sideloads_to_serializer
+          end
+          sideload
+        end
+
+        def apply_sideloads_to_serializer
+          config[:sideloads].each_pair do |name, sideload|
+            if serializer.relationship_blocks[name].nil? && sideload.readable?
+              serializer.relationship(name)
+            end
+          end
+        end
+
+        def has_many(name, opts = {}, &blk)
+          opts[:class] = adapter.sideloading_classes[:has_many]
+          allow_sideload(name, opts, &blk)
+        end
+
+        def belongs_to(name, opts = {}, &blk)
+          opts[:class] = adapter.sideloading_classes[:belongs_to]
+          allow_sideload(name, opts, &blk)
+        end
+
+        def has_one(name, opts = {}, &blk)
+          opts[:class] = adapter.sideloading_classes[:has_one]
+          allow_sideload(name, opts, &blk)
+        end
+
+        def many_to_many(name, opts = {}, &blk)
+          opts[:class] = adapter.sideloading_classes[:many_to_many]
+          allow_sideload(name, opts, &blk)
+        end
+
+        def polymorphic_belongs_to(name, opts = {}, &blk)
+          opts[:resource] ||= Class.new(::Graphiti::Resource) do
+            self.polymorphic = []
+            self.abstract_class = true
+          end
+          # adapters *probably* don't need to override this, but it's allowed
+          opts[:class] ||= adapter.sideloading_classes[:polymorphic_belongs_to]
+          opts[:class] ||= ::Graphiti::Sideload::PolymorphicBelongsTo
+          allow_sideload(name, opts, &blk)
+        end
+
+        def sideload(name)
+          sideloads[name]
+        end
+
+        def all_sideloads(memo = {})
+          sideloads.each_pair do |name, sideload|
+            unless memo[name]
+              memo[name] = sideload
+              memo.merge!(sideload.resource.class.all_sideloads(memo))
+            end
+          end
+          memo
+        end
+
+        def association_names(memo = [])
+          all_sideloads.each_pair do |name, sl|
+            unless memo.include?(sl.name)
+              memo << sl.name
+              memo |= sl.resource.class.association_names(memo)
+            end
+          end
+
+          memo
+        end
+
+        def association_types(memo = [])
+          all_sideloads.each_pair do |name, sl|
+            unless memo.include?(sl.resource.type)
+              memo << sl.resource.type
+              memo |= sl.resource.class.association_types(memo)
+            end
+          end
+
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/resource_proxy.rb

@@ -0,0 +1,127 @@
+module Graphiti
+  class ResourceProxy
+    include Enumerable
+
+    attr_reader :resource, :query, :scope
+
+    def initialize(resource, scope, query, payload: nil, single: false, raise_on_missing: false)
+      @resource = resource
+      @scope = scope
+      @query = query
+      @payload = payload
+      @single = single
+      @raise_on_missing = raise_on_missing
+    end
+
+    def single?
+      !!@single
+    end
+
+    def raise_on_missing?
+      !!@raise_on_missing
+    end
+
+    def errors
+      data.errors
+    end
+
+    def [](val)
+      data[val]
+    end
+
+    def jsonapi_render_options(opts = {})
+      opts[:meta]   ||= {}
+      opts[:expose] ||= {}
+      opts[:expose][:context] = Graphiti.context[:object]
+      opts
+    end
+
+    def to_jsonapi(options = {})
+      options = jsonapi_render_options(options)
+      Renderer.new(self, options).to_jsonapi
+    end
+
+    def to_json(options = {})
+      Renderer.new(self, options).to_json
+    end
+
+    def to_xml(options = {})
+      Renderer.new(self, options).to_xml
+    end
+
+    def data
+      @data ||= begin
+        records = @scope.resolve
+        if records.empty? && raise_on_missing?
+          raise Graphiti::Errors::RecordNotFound
+        end
+        records = records[0] if single?
+        records
+      end
+    end
+    alias :to_a :data
+
+    def each(&blk)
+      to_a.each(&blk)
+    end
+
+    def stats
+      @stats ||= @scope.resolve_stats
+    end
+
+    def save(action: :create)
+      validator = persist do
+        @resource.persist_with_relationships \
+          @payload.meta(action: action),
+          @payload.attributes,
+          @payload.relationships
+      end
+      @data, success = validator.to_a
+      success
+    end
+
+    def destroy
+      validator = @resource.transaction do
+        model = @resource.destroy(@query.filters[:id])
+        model.instance_variable_set(:@__serializer_klass, @resource.serializer)
+        validator = ::Graphiti::Util::ValidationResponse.new \
+          model, @payload
+        validator.validate!
+        @resource.before_commit(model, :destroy)
+        validator
+      end
+      @data, success = validator.to_a
+      success
+    end
+
+    def update_attributes
+      save(action: :update)
+    end
+
+    def include_hash
+      @payload ? @payload.include_hash : @query.include_hash
+    end
+
+    def fields
+      query.fields
+    end
+
+    def extra_fields
+      query.extra_fields
+    end
+
+    private
+
+    def persist
+      @resource.transaction do
+        ::Graphiti::Util::Hooks.record do
+          model = yield
+          validator = ::Graphiti::Util::ValidationResponse.new \
+            model, @payload
+          validator.validate!
+          validator
+        end
+      end
+    end
+  end
+end