graphiti 1.0.alpha.1 → 1.0.alpha.4

data/lib/graphiti/filter_operators.rb

@@ -3,8 +3,18 @@ module Graphiti
     class Catchall
       attr_reader :procs
 
-      def initialize
+      def initialize(resource, type_name, opts)
         @procs = {}
+        defaults = resource.adapter.default_operators[type_name] || []
+        if opts[:only]
+          defaults = defaults.select { |op| opts[:only].include?(op) }
+        end
+        if opts[:except]
+          defaults = defaults.reject { |op| opts[:except].include?(op) }
+        end
+        defaults.each do |op|
+          @procs[op] = nil
+        end
       end
 
       def method_missing(name, *args, &blk)
@@ -16,8 +26,8 @@ module Graphiti
       end
     end
 
-    def self.build(&blk)
-      c = Catchall.new
+    def self.build(resource, type_name, opts = {}, &blk)
+      c = Catchall.new(resource, type_name, opts)
       c.instance_eval(&blk) if blk
       c.to_hash
     end

data/lib/graphiti/query.rb

@@ -21,6 +21,14 @@ module Graphiti
       not association?
     end
 
+    def links?
+      if Graphiti.config.links_on_demand
+        [true, 'true'].include?(@params[:links])
+      else
+        true
+      end
+    end
+
     def to_hash
       {}.tap do |hash|
         hash[:filter] = filters unless filters.empty?

data/lib/graphiti/rails.rb

@@ -10,7 +10,7 @@ module Graphiti
     def self.included(klass)
       klass.class_eval do
         include Graphiti::Context
-        include JsonapiErrorable
+        include GraphitiErrors
         around_action :wrap_context
       end
     end

data/lib/graphiti/railtie.rb

@@ -1,6 +1,5 @@
 module Graphiti
   class Railtie < ::Rails::Railtie
-
     initializer "graphiti.require_activerecord_adapter" do
       config.after_initialize do |app|
         ActiveSupport.on_load(:active_record) do
@@ -16,6 +15,7 @@ module Graphiti
       register_parameter_parser
       register_renderers
       establish_concurrency
+      configure_endpoint_lookup
     end
 
     # from jsonapi-rails
@@ -55,7 +55,7 @@ module Graphiti
         ::ActionController::Renderers.add(:jsonapi_errors) do |proxy, options|
           self.content_type ||= Mime[:jsonapi]
 
-          validation = JsonapiErrorable::Serializers::Validation.new \
+          validation = GraphitiErrors::Serializers::Validation.new \
             proxy.data, proxy.payload.relationships
 
           render \
@@ -70,5 +70,24 @@ module Graphiti
       Graphiti.config.concurrency = !::Rails.env.test? &&
         ::Rails.application.config.cache_classes
     end
+
+    def configure_endpoint_lookup
+      Graphiti.config.context_for_endpoint = ->(path, action) {
+        method = :GET
+        case action
+          when :show then path = "#{path}/1"
+          when :create then method = :POST
+          when :update
+            path = "#{path}/1"
+            method = :PUT
+          when :destroy
+            path = "#{path}/1"
+            method = :DELETE
+        end
+
+        route = ::Rails.application.routes.recognize_path(path, method: method) rescue nil
+        "#{route[:controller]}_controller".classify.safe_constantize if route
+      }
+    end
   end
 end

data/lib/graphiti/renderer.rb

@@ -33,6 +33,7 @@ module Graphiti
         options[:fields] = proxy.fields
         options[:expose] ||= {}
         options[:expose][:extra_fields] = proxy.extra_fields
+        options[:expose][:proxy] = proxy
         options[:include] = proxy.include_hash
         options[:meta] ||= {}
         options[:meta].merge!(stats: proxy.stats) unless proxy.stats.empty?
@@ -45,7 +46,7 @@ module Graphiti
     def notify
       if defined?(ActiveSupport::Notifications)
         opts = [
-          'render.jsonapi-compliable',
+          'render.graphiti',
           records: records,
           options: options
         ]

data/lib/graphiti/resource.rb

@@ -4,6 +4,7 @@ module Graphiti
     include Interface
     include Configuration
     include Sideloading
+    include Links
 
     attr_reader :context
 
@@ -21,14 +22,22 @@ module Graphiti
       end
     end
 
-    def context
+    def self.context
       Graphiti.context[:object]
     end
 
-    def context_namespace
+    def context
+      self.class.context
+    end
+
+    def self.context_namespace
       Graphiti.context[:namespace]
     end
 
+    def context_namespace
+      self.class.context_namespace
+    end
+
     def build_scope(base, query, opts = {})
       Scope.new(base, self, query, opts)
     end

data/lib/graphiti/resource/configuration.rb

@@ -87,6 +87,7 @@ module Graphiti
             klass.attribute :id, :integer_id
           end
           klass.stat total: [:count]
+          Graphiti.resources << klass
         end
       end
 

data/lib/graphiti/resource/dsl.rb

@@ -9,11 +9,12 @@ module Graphiti
 
           if att = get_attr(name, :filterable, raise_error: :only_unsupported)
             aliases = [name, opts[:aliases]].flatten.compact
-            operators = FilterOperators.build(&blk)
+            operators = FilterOperators.build(self, att[:type], opts, &blk)
             config[:filters][name.to_sym] = {
               aliases: aliases,
-              type: att[:type]
-            }.merge(operators.to_hash)
+              type: att[:type],
+              operators: operators.to_hash
+            }
           else
             if type = args[0]
               attribute name, type, only: [:filterable]

data/lib/graphiti/resource/interface.rb

@@ -5,15 +5,18 @@ module Graphiti
 
       class_methods do
         def all(params = {}, base_scope = nil)
+          validate!
           _all(params, {}, base_scope)
         end
 
+        # @api private
         def _all(params, opts, base_scope)
           runner = Runner.new(self, params)
           runner.proxy(base_scope, opts)
         end
 
         def find(params, base_scope = nil)
+          validate!
           id = params[:data].try(:[], :id) || params.delete(:id)
           params[:filter] ||= {}
           params[:filter].merge!(id: id)
@@ -23,9 +26,21 @@ module Graphiti
         end
 
         def build(params, base_scope = nil)
+          validate!
           runner = Runner.new(self, params)
           runner.proxy(base_scope, single: true, raise_on_missing: true)
         end
+
+        private
+
+        def validate!
+          if context && context.respond_to?(:request)
+            path = context.request.env['PATH_INFO']
+            unless allow_request?(path, context_namespace)
+              raise Errors::InvalidEndpoint.new(self, path, context_namespace)
+            end
+          end
+        end
       end
     end
   end

data/lib/graphiti/resource/links.rb

@@ -0,0 +1,92 @@
+module Graphiti
+  module Links
+    extend ActiveSupport::Concern
+
+    DEFAULT_ACTIONS = [:index, :show, :create, :update, :destroy].freeze
+
+    module Overrides
+      def endpoint
+        if endpoint = super
+          endpoint
+        else
+          self.endpoint = infer_endpoint
+        end
+      end
+    end
+
+    included do
+      class_attribute :endpoint,
+        :base_url,
+        :endpoint_namespace,
+        :secondary_endpoints,
+        :autolink
+      self.secondary_endpoints = []
+      self.autolink = true
+
+      class << self
+        prepend Overrides
+      end
+    end
+
+    class_methods do
+      def infer_endpoint
+        return unless name
+
+        path = "/#{name.gsub('Resource', '').pluralize.underscore}".to_sym
+        {
+          path: path,
+          full_path: full_path_for(path),
+          url: url_for(path),
+          actions: DEFAULT_ACTIONS.dup
+        }
+      end
+
+      def primary_endpoint(path, actions = DEFAULT_ACTIONS.dup)
+        path = path.to_sym
+        self.endpoint = {
+          path: path,
+          full_path: full_path_for(path),
+          url: url_for(path),
+          actions: actions
+        }
+      end
+
+      # NB: avoid << b/c class_attribute
+      def secondary_endpoint(path, actions = DEFAULT_ACTIONS.dup)
+        path = path.to_sym
+        self.secondary_endpoints += [{
+          path: path,
+          full_path: full_path_for(path),
+          url: url_for(path),
+          actions: actions
+        }]
+      end
+
+      def endpoints
+        ([endpoint] + secondary_endpoints).compact
+      end
+
+      def allow_request?(path, action)
+        endpoints.any? do |e|
+          if [:update, :show, :destroy].include?(context_namespace)
+            path = path.split('/')
+            path.pop
+            path = path.join('/')
+          end
+
+          e[:full_path].to_s == path && e[:actions].include?(context_namespace)
+        end
+      end
+
+      private
+
+      def full_path_for(path)
+        [endpoint_namespace, path].join('').to_sym
+      end
+
+      def url_for(path)
+        [base_url, full_path_for(path)].join('').to_sym
+      end
+    end
+  end
+end

data/lib/graphiti/resource/polymorphism.rb

@@ -34,6 +34,7 @@ module Graphiti
         def inherited(klass)
           klass.type = nil
           klass.model = klass.infer_model
+          klass.endpoint = klass.infer_endpoint
           klass.polymorphic_child = true
           super
         end

data/lib/graphiti/resource/sideloading.rb

@@ -23,11 +23,7 @@ module Graphiti
         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
+          Util::SerializerRelationships.new(self, config[:sideloads]).apply
         end
 
         def has_many(name, opts = {}, &blk)
@@ -61,6 +57,18 @@ module Graphiti
           allow_sideload(name, opts, &blk)
         end
 
+        def belongs_to_many(name, resource: nil, as:, &blk)
+          resource = resource ||= Util::Class.infer_resource_class(self, name)
+          sideload = resource.sideload(as)
+
+          _adapter = adapter
+          filter sideload.true_foreign_key, resource.attributes[:id][:type] do
+            eq do |scope, value|
+              _adapter.belongs_to_many_filter(sideload, scope, value)
+            end
+          end
+        end
+
         def sideload(name)
           sideloads[name]
         end

data/lib/graphiti/resource_proxy.rb

@@ -2,7 +2,7 @@ module Graphiti
   class ResourceProxy
     include Enumerable
 
-    attr_reader :resource, :query, :scope
+    attr_reader :resource, :query, :scope, :payload
 
     def initialize(resource, scope, query, payload: nil, single: false, raise_on_missing: false)
       @resource = resource

data/lib/graphiti/schema.rb

@@ -0,0 +1,169 @@
+module Graphiti
+  class Schema
+    attr_reader :resources
+
+    def self.generate(resources = nil)
+      ::Rails.application.eager_load! if defined?(::Rails)
+      resources ||= Graphiti.resources.reject(&:abstract_class?)
+      new(resources).generate
+    end
+
+    def self.generate!(resources = nil)
+      schema = generate(resources)
+
+      if ENV['FORCE_SCHEMA'] != 'true' && File.exists?(Graphiti.config.schema_path)
+        old = JSON.parse(File.read(Graphiti.config.schema_path))
+        errors = Graphiti::SchemaDiff.new(old, schema).compare
+        return errors if errors.any?
+      end
+      File.write(Graphiti.config.schema_path, JSON.pretty_generate(schema))
+      []
+    end
+
+    def initialize(resources)
+      @resources = resources
+    end
+
+    def generate
+      {
+        resources: generate_resources,
+        endpoints: generate_endpoints,
+        types: generate_types
+      }
+    end
+
+    private
+
+    def generate_types
+      {}.tap do |types|
+        Graphiti::Types.map.each_pair do |name, config|
+          types[name] = config.slice(:kind, :description)
+        end
+      end
+    end
+
+    def generate_endpoints
+      {}.tap do |endpoints|
+        @resources.each do |r|
+          r.endpoints.each do |e|
+            actions = {}
+            e[:actions].each do |a|
+              next unless ctx = context_for(e[:full_path], a)
+
+              existing = endpoints[e[:full_path]]
+              if existing && config = existing[:actions][a]
+                raise Errors::ResourceEndpointConflict.new \
+                  e[:full_path], a, r.name, config[:resource]
+              end
+
+              actions[a] = { resource: r.name }
+              if whitelist = ctx.sideload_whitelist
+                if whitelist[a]
+                  actions[a].merge!(sideload_whitelist: whitelist[a])
+                end
+              end
+            end
+
+            unless actions.empty?
+              endpoints[e[:full_path]] ||= { actions: {} }
+              endpoints[e[:full_path]][:actions].merge!(actions)
+            end
+          end
+        end
+      end
+    end
+
+    def context_for(path, action)
+      Graphiti.config.context_for_endpoint.call(path.to_s, action)
+    end
+
+    def generate_resources
+      @resources.map do |r|
+        config = {
+          name: r.name,
+          type: r.type.to_s,
+          attributes: attributes(r),
+          extra_attributes: extra_attributes(r),
+          filters: filters(r),
+          relationships: relationships(r)
+        }
+
+        if r.polymorphic?
+          config.merge!(polymorphic: true, children: r.children.map(&:name))
+        end
+
+        config
+      end
+    end
+
+    def attributes(resource)
+      {}.tap do |attrs|
+        resource.attributes.each_pair do |name, config|
+          if config.values_at(:readable, :writable, :sortable).any?
+            attrs[name] = {
+              type:       config[:type].to_s,
+              readable:   flag(config[:readable]),
+              writable:   flag(config[:writable]),
+              sortable:   flag(config[:sortable])
+            }
+          end
+        end
+      end
+    end
+
+    def extra_attributes(resource)
+      {}.tap do |attrs|
+        resource.extra_attributes.each_pair do |name, config|
+          attrs[name] = {
+            type:     config[:type].to_s,
+            readable: flag(config[:readable])
+          }
+        end
+      end
+    end
+
+    def flag(value)value
+      if value.is_a?(Symbol)
+        'guarded'
+      else
+        !!value
+      end
+    end
+
+    def filters(resource)
+      {}.tap do |f|
+        resource.filters.each_pair do |name, config|
+          config = {
+            type: config[:type].to_s,
+            operators: config[:operators].keys.map(&:to_s)
+          }
+          attr = resource.attributes[name]
+          if attr[:filterable].is_a?(Symbol)
+            if attr[:filterable] == :required
+              config[:required] = true
+            else
+              config[:guard] = true
+            end
+          end
+          f[name] = config
+        end
+      end
+    end
+
+    def relationships(resource)
+      {}.tap do |r|
+        resource.sideloads.each_pair do |name, config|
+          schema = { type: config.type.to_s }
+          if config.type == :polymorphic_belongs_to
+            schema[:resources] = config.children.values
+              .map(&:resource).map(&:class).map(&:name)
+          else
+            schema[:resource] = config.resource.class.name
+          end
+
+          r[name] = schema
+        end
+      end
+    end
+  end
+end