graphiti-rb 1.0.alpha.1

data/lib/graphiti/rails.rb

@@ -0,0 +1,28 @@
+module Graphiti
+  # Rails Integration. Mix this in to ApplicationController.
+  #
+  # * Mixes in Base
+  # * Adds a global around_action (see Base#wrap_context)
+  #
+  # @see Base#render_jsonapi
+  # @see Base#wrap_context
+  module Rails
+    def self.included(klass)
+      klass.class_eval do
+        include Graphiti::Context
+        include JsonapiErrorable
+        around_action :wrap_context
+      end
+    end
+
+    def wrap_context
+      Graphiti.with_context(jsonapi_context, action_name.to_sym) do
+        yield
+      end
+    end
+
+    def jsonapi_context
+      self
+    end
+  end
+end

data/lib/graphiti/railtie.rb

@@ -0,0 +1,74 @@
+module Graphiti
+  class Railtie < ::Rails::Railtie
+
+    initializer "graphiti.require_activerecord_adapter" do
+      config.after_initialize do |app|
+        ActiveSupport.on_load(:active_record) do
+          require 'graphiti/adapters/active_record'
+        end
+      end
+    end
+
+    initializer 'graphiti.init' do
+      if Mime[:jsonapi].nil? # rails 4
+        Mime::Type.register('application/vnd.api+json', :jsonapi)
+      end
+      register_parameter_parser
+      register_renderers
+      establish_concurrency
+    end
+
+    # from jsonapi-rails
+    PARSER = lambda do |body|
+      data = JSON.parse(body)
+      data[:format] = :jsonapi
+      data.with_indifferent_access
+    end
+
+    def register_parameter_parser
+      if ::Rails::VERSION::MAJOR >= 5
+        ActionDispatch::Request.parameter_parsers[:jsonapi] = PARSER
+      else
+        ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:jsonapi]] = PARSER
+      end
+    end
+
+    def register_renderers
+      ActiveSupport.on_load(:action_controller) do
+        ::ActionController::Renderers.add(:jsonapi) do |proxy, options|
+          self.content_type ||= Mime[:jsonapi]
+
+          opts = {}
+          if respond_to?(:default_jsonapi_render_options)
+            opts = default_jsonapi_render_options
+          end
+
+          if proxy.is_a?(Hash) # for destroy
+            render(options.merge(json: proxy))
+          else
+            proxy.to_jsonapi(options)
+          end
+        end
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        ::ActionController::Renderers.add(:jsonapi_errors) do |proxy, options|
+          self.content_type ||= Mime[:jsonapi]
+
+          validation = JsonapiErrorable::Serializers::Validation.new \
+            proxy.data, proxy.payload.relationships
+
+          render \
+            json: { errors: validation.errors },
+            status: :unprocessable_entity
+        end
+      end
+    end
+
+    # Only run concurrently if our environment supports it
+    def establish_concurrency
+      Graphiti.config.concurrency = !::Rails.env.test? &&
+        ::Rails.application.config.cache_classes
+    end
+  end
+end

data/lib/graphiti/renderer.rb

@@ -0,0 +1,60 @@
+module Graphiti
+  class Renderer
+    CONTENT_TYPE = 'application/vnd.api+json'
+
+    attr_reader :proxy, :options
+
+    def initialize(proxy, options)
+      @proxy = proxy
+      @options = options
+    end
+
+    def records
+      @records ||= @proxy.data
+    end
+
+    def to_jsonapi
+      render(JSONAPI::Renderer.new).to_json
+    end
+
+    def to_json
+      render(Graphiti::HashRenderer.new(@proxy.resource)).to_json
+    end
+
+    def to_xml
+      render(Graphiti::HashRenderer.new(@proxy.resource)).to_xml(root: :data)
+    end
+
+    private
+
+    def render(implementation)
+      notify do
+        instance = JSONAPI::Serializable::Renderer.new(implementation)
+        options[:fields] = proxy.fields
+        options[:expose] ||= {}
+        options[:expose][:extra_fields] = proxy.extra_fields
+        options[:include] = proxy.include_hash
+        options[:meta] ||= {}
+        options[:meta].merge!(stats: proxy.stats) unless proxy.stats.empty?
+        instance.render(records, options)
+      end
+    end
+
+    # TODO: more generic notification pattern
+    # Likely comes out of debugger work
+    def notify
+      if defined?(ActiveSupport::Notifications)
+        opts = [
+          'render.jsonapi-compliable',
+          records: records,
+          options: options
+        ]
+        ActiveSupport::Notifications.instrument(*opts) do
+          yield
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/graphiti/resource.rb

@@ -0,0 +1,110 @@
+module Graphiti
+  class Resource
+    include DSL
+    include Interface
+    include Configuration
+    include Sideloading
+
+    attr_reader :context
+
+    def around_scoping(scope, query_hash)
+      yield scope
+    end
+
+    def serializer_for(model)
+      serializer
+    end
+
+    def with_context(object, namespace = nil)
+      Graphiti.with_context(object, namespace) do
+        yield
+      end
+    end
+
+    def context
+      Graphiti.context[:object]
+    end
+
+    def context_namespace
+      Graphiti.context[:namespace]
+    end
+
+    def build_scope(base, query, opts = {})
+      Scope.new(base, self, query, opts)
+    end
+
+    def base_scope
+      adapter.base_scope(model)
+    end
+
+    def typecast(name, value, flag)
+      att = get_attr!(name, flag)
+      type = Graphiti::Types[att[:type]]
+      begin
+        flag = :read if flag == :readable
+        flag = :write if flag == :writable
+        flag = :params if [:sortable, :filterable].include?(flag)
+        type[flag][value]
+      rescue Exception => e
+        raise Errors::TypecastFailed.new(self, name, value, e)
+      end
+    end
+
+    def create(create_params)
+      adapter.create(model, create_params)
+    end
+
+    def update(update_params)
+      adapter.update(model, update_params)
+    end
+
+    def destroy(id)
+      adapter.destroy(model, id)
+    end
+
+    def associate_all(parent, children, association_name, type)
+      adapter.associate_all(parent, children, association_name, type)
+    end
+
+    def associate(parent, child, association_name, type)
+      adapter.associate(parent, child, association_name, type)
+    end
+
+    def disassociate(parent, child, association_name, type)
+      adapter.disassociate(parent, child, association_name, type)
+    end
+
+    def persist_with_relationships(meta, attributes, relationships, caller_model = nil)
+      persistence = Graphiti::Util::Persistence \
+        .new(self, meta, attributes, relationships, caller_model)
+      persistence.run
+    end
+
+    def stat(attribute, calculation)
+      stats_dsl = stats[attribute] || stats[attribute.to_sym]
+      raise Errors::StatNotFound.new(attribute, calculation) unless stats_dsl
+      stats_dsl.calculation(calculation)
+    end
+
+    def resolve(scope)
+      adapter.resolve(scope)
+    end
+
+    def before_commit(model, method)
+      hook = self.class.config[:before_commit][method]
+      hook.call(model) if hook
+    end
+
+    def transaction
+      response = nil
+      begin
+        adapter.transaction(model) do
+          response = yield
+        end
+      rescue Errors::ValidationError => e
+        response = e.validation_response
+      end
+      response
+    end
+  end
+end

data/lib/graphiti/resource/configuration.rb

@@ -0,0 +1,239 @@
+module Graphiti
+  class Resource
+    module Configuration
+      extend ActiveSupport::Concern
+
+      module Overrides
+        def serializer=(val)
+          if val
+            if super(Class.new(val))
+              apply_attributes_to_serializer
+              apply_sideloads_to_serializer
+            end
+          else
+            super
+          end
+        end
+
+        def polymorphic=(klasses)
+          super
+          send(:prepend, Polymorphism)
+        end
+
+        def type=(val)
+          if val = super
+            self.serializer.type(val)
+          end
+        end
+
+        def model
+          klass = super
+          unless klass || abstract_class?
+            if klass = infer_model
+              self.model = klass
+            else
+              raise Errors::ModelNotFound.new(self)
+            end
+          end
+          klass
+        end
+      end
+
+      included do
+        class << self
+          attr_writer :config
+        end
+
+        class_attribute :adapter,
+          :model,
+          :type,
+          :polymorphic,
+          :polymorphic_child,
+          :serializer,
+          :default_page_size,
+          :default_sort,
+          :attributes_readable_by_default,
+          :attributes_writable_by_default,
+          :attributes_sortable_by_default,
+          :attributes_filterable_by_default,
+          :relationships_readable_by_default,
+          :relationships_writable_by_default
+
+        class << self
+          prepend Overrides
+        end
+
+        def self.inherited(klass)
+          super
+          klass.config = Util::Hash.deep_dup(config)
+          klass.adapter ||= Adapters::Abstract.new
+          klass.default_sort ||= []
+          klass.default_page_size ||= 20
+          # re-assigning causes a new Class.new
+          if klass.serializer
+            klass.serializer = klass.serializer
+          else
+            klass.serializer = JSONAPI::Serializable::Resource
+          end
+          klass.type ||= klass.infer_type
+          default(klass, :attributes_readable_by_default, true)
+          default(klass, :attributes_writable_by_default, true)
+          default(klass, :attributes_sortable_by_default, true)
+          default(klass, :attributes_filterable_by_default, true)
+          default(klass, :relationships_readable_by_default, true)
+          default(klass, :relationships_writable_by_default, true)
+
+          unless klass.config[:attributes][:id]
+            klass.attribute :id, :integer_id
+          end
+          klass.stat total: [:count]
+        end
+      end
+
+      class_methods do
+        def get_attr!(name, flag, opts = {})
+          opts[:raise_error] = true
+          get_attr(name, flag, opts)
+        end
+
+        def get_attr(name, flag, opts = {})
+          defaults = { request: false }
+          opts = defaults.merge(opts)
+          new.get_attr(name, flag, opts)
+        end
+
+        def abstract_class?
+          !!abstract_class
+        end
+
+        def abstract_class
+          @abstract_class
+        end
+
+        def abstract_class=(val)
+          if @abstract_class = val
+            self.serializer = nil
+            self.type = nil
+          end
+        end
+
+        def infer_type
+          if name.present?
+            name.demodulize.gsub('Resource','').underscore.pluralize.to_sym
+          else
+            :undefined_jsonapi_type
+          end
+        end
+
+        def infer_model
+          name.gsub('Resource', '').safe_constantize if name
+        end
+
+        def default(object, attr, value)
+          prior = object.send(attr)
+          unless prior || prior == false
+            object.send(:"#{attr}=", value)
+          end
+        end
+        private :default
+
+        def config
+          @config ||=
+            {
+              filters: {},
+              default_filters: {},
+              stats: {},
+              sort_all: nil,
+              sorts: {},
+              pagination: nil,
+              before_commit: {},
+              attributes: {},
+              extra_attributes: {},
+              sideloads: {}
+            }
+        end
+
+        def attributes
+          config[:attributes]
+        end
+
+        def extra_attributes
+          config[:extra_attributes]
+        end
+
+        def all_attributes
+          attributes.merge(extra_attributes)
+        end
+
+        def sideloads
+          config[:sideloads]
+        end
+
+        def filters
+          config[:filters]
+        end
+
+        def sorts
+          config[:sorts]
+        end
+
+        def stats
+          config[:stats]
+        end
+
+        def pagination
+          config[:pagination]
+        end
+
+        def default_filters
+          config[:default_filters]
+        end
+      end
+
+      def get_attr!(name, flag, options = {})
+        options[:raise_error] = true
+        get_attr(name, flag, options)
+      end
+
+      def get_attr(name, flag, request: false, raise_error: false)
+        Util::AttributeCheck.run(self, name, flag, request, raise_error)
+      end
+
+      def filters
+        self.class.filters
+      end
+
+      def sort_all
+        self.class.sort_all
+      end
+
+      def sorts
+        self.class.sorts
+      end
+
+      def stats
+        self.class.stats
+      end
+
+      def pagination
+        self.class.pagination
+      end
+
+      def attributes
+        self.class.attributes
+      end
+
+      def extra_attributes
+        self.class.extra_attributes
+      end
+
+      def all_attributes
+        self.class.all_attributes
+      end
+
+      def default_filters
+        self.class.default_filters
+      end
+    end
+  end
+end