graphiti 2.0.0.beta.8 → 2.0.0.beta.10

data/lib/graphiti/rails/controller.rb

@@ -30,14 +30,34 @@ module Graphiti
 
         register_exception Graphiti::Errors::InvalidRequest,
           status: 400, handler: Graphiti::Rails::InvalidRequestHandler
-        register_exception Graphiti::Errors::ConflictRequest,
-          status: 409, handler: Graphiti::Rails::ConflictRequestHandler
-        register_exception Graphiti::Errors::RecordNotFound,
-          status: 404, handler: Graphiti::Rails::ExceptionHandler
         register_exception Graphiti::Errors::RemoteWrite,
-          status: 400, handler: Graphiti::Rails::ExceptionHandler
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
         register_exception Graphiti::Errors::SingularSideload,
-          status: 400, handler: Graphiti::Rails::ExceptionHandler
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::InvalidInclude,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::UnsupportedSort,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::UnsupportedOperator,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::InvalidFilterValue,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::RequiredFilter,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::UnsupportedPageSize,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::UnsupportedBeforeCursor,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::UnsupportedPagination,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+        register_exception Graphiti::Errors::FilterGroupMissingRequiredFilters,
+          status: 400, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+
+        register_exception Graphiti::Errors::RecordNotFound,
+          status: 404, detail: :exception, handler: Graphiti::Rails::ExceptionHandler
+
+        register_exception Graphiti::Errors::ConflictRequest,
+          status: 409, handler: Graphiti::Rails::ConflictRequestHandler
       end
     end
   end

data/lib/graphiti/rails/rake_helpers.rb

@@ -21,6 +21,23 @@ module Graphiti
         ::Rails.application.config.action_controller.perform_caching = false
       end
 
+      # The pool and RAILS_MAX_THREADS are read from this environment, and production may size both differently.
+      def connection_pool_advisory
+        return unless defined?(ActiveRecord::Base)
+
+        pool = ActiveRecord::Base.connection_db_config.pool
+        threads = ENV.fetch("RAILS_MAX_THREADS", 5).to_i
+        sideload_threads = Graphiti.config.concurrency_max_threads
+        needed = threads + sideload_threads + 1
+        return if pool.nil? || pool >= needed
+
+        "WARNING database.yml pool is #{pool} in this environment. With concurrency on (the production default), " \
+          "each sideload holds its own connection, so pool should be at least " \
+          "web threads (#{threads}) + concurrency_max_threads (#{sideload_threads}) + 1 = #{needed}. " \
+          "If production sizes these differently, check the numbers there. " \
+          "See graphiti.dev/concepts/resources#concurrency-pool-sizing."
+      end
+
       def make_request(path, debug = false)
         if path.split("/").length == 2
           path = "#{ApplicationResource.endpoint_namespace}#{path}"

data/lib/graphiti/rails.rb

@@ -31,6 +31,13 @@ module Graphiti
     autoload :Responders, "graphiti/rails/responders"
     autoload :TestHelpers, "graphiti/rails/test_helpers"
 
+    # Deprecated. Backed graphiti-rails' enable!/disable! spec toggles. Remove in 3.0.
+    GraphitiErrorsTesting = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+      "Graphiti::Rails::GraphitiErrorsTesting",
+      "Graphiti::Rails::TestHelpers",
+      DEPRECATOR
+    )
+
     # @!attribute self.handled_exception_formats
     # A list of formats as symbols whose exceptions will be handled by Graphiti. See {Railtie}.
     cattr_accessor :handled_exception_formats, default: []
@@ -47,6 +54,13 @@ module Graphiti
     "Graphiti::Rails::Responders",
     DEPRECATOR
   )
+
+  # Deprecated. Core's railtie merged into graphiti-rails'. Remove in 3.0.
+  Railtie = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+    "Graphiti::Railtie",
+    "Graphiti::Rails::Railtie",
+    DEPRECATOR
+  )
 end
 
 ActiveSupport.on_load(:active_record) do

data/lib/graphiti/railtie.rb

@@ -0,0 +1,8 @@
+# Deprecated require path, kept so a leftover 1.x require does not raise.
+# The railtie lives in Graphiti::Rails as of 2.0. Remove in 3.0.
+require "graphiti"
+
+Graphiti::DEPRECATOR.warn(
+  'require "graphiti/railtie" is no longer needed. The railtie is part of the Rails ' \
+  "integration as of 2.0, and loads with graphiti when Rails is present."
+)

data/lib/graphiti/request_validators/update_validator.rb

@@ -2,7 +2,7 @@ module Graphiti
   module RequestValidators
     class UpdateValidator < Validator
       def validate
-        if required_payload? && payload_matches_endpoint?
+        if validate_data_shape && required_payload? && payload_matches_endpoint?
           super
         else
           false

data/lib/graphiti/request_validators/validator.rb

@@ -17,6 +17,7 @@ module Graphiti
         # In the future these should have their own validation logic, but
         # for now we can just bypass
         return errors.blank? unless @params.has_key?(:data)
+        return false unless validate_data_shape
 
         resource = @root_resource
         if @params[:data].has_key?(:type)
@@ -56,6 +57,14 @@ module Graphiti
         @errors.add(:page, :invalid, message: "must be an object")
       end
 
+      def validate_data_shape
+        data = @params[:data]
+        return true if data.nil? || data.respond_to?(:each_pair)
+
+        @errors.add(:data, :invalid, message: "must be an object")
+        false
+      end
+
       def process_relationships(resource, relationships, payload_path)
         relationships.each_key do |name|
           unless resource.class.sideload(name.to_sym)

data/lib/graphiti/resource/configuration.rb

@@ -4,16 +4,75 @@ module Graphiti
       extend ActiveSupport::Concern
 
       DEFAULT_MAX_PAGE_SIZE = 1_000
+      LINK_MODES = [true, false, :on_demand].freeze
+      BELONGS_TO_RESOURCE_IDS_MODES = [:foreign_key, :always, :never].freeze
+      BLANK_MODES = [:as_literal, :as_nil, :reject].freeze
+
+      # Grouped for the ApplicationResource the install generator writes.
+      SETTING_GROUPS = { # :nodoc:
+        attributes: {
+          attributes_readable_by_default: {default: true},
+          attributes_writable_by_default: {default: true},
+          attributes_sortable_by_default: {default: true},
+          attributes_filterable_by_default: {default: true},
+          attributes_schema_by_default: {default: true},
+          typecast_reads: {default: true}
+        },
+        relationships: {
+          relationships_readable_by_default: {default: true},
+          relationships_writable_by_default: {default: true},
+          belongs_to_resource_ids_by_default: {
+            default: :foreign_key,
+            values: BELONGS_TO_RESOURCE_IDS_MODES,
+            invalid: ->(klass, value) { Errors::InvalidBelongsToResourceIds.new(klass, value) }
+          }
+        },
+        filters: {
+          filters_blanks_by_default: {
+            default: :as_literal,
+            values: BLANK_MODES,
+            invalid: ->(klass, value) { Errors::InvalidFilterBlanks.new(klass, :filters_blanks_by_default, value) }
+          }
+        },
+        sorting: {
+          default_sort: {default: nil, note: "per resource, e.g. [{id: :desc}]"}
+        },
+        pagination: {
+          page_default_size: {default: nil, note: "unset falls back to 20"},
+          page_max_size: {default: DEFAULT_MAX_PAGE_SIZE, format: "1_000"},
+          page_cursors: {default: false, note: "render cursors for pagination"},
+          page_links: {
+            default: false,
+            values: LINK_MODES,
+            invalid: ->(klass, value) { Errors::InvalidLinkRendering.new(klass, :page_links, value) }
+          }
+        },
+        endpoints: {
+          validate_requests: {default: true, note: "refuse requests to undeclared endpoints"}
+        },
+        links: {
+          relationship_links: {
+            default: true,
+            values: LINK_MODES,
+            invalid: ->(klass, value) { Errors::InvalidLinkRendering.new(klass, :relationship_links, value) }
+          },
+          validate_links: {default: true, note: "refuse to render links to unroutable endpoints"}
+        }
+      }.freeze
+
+      SETTINGS = SETTING_GROUPS.values.reduce(:merge).freeze # :nodoc:
 
       module Overrides
-        BELONGS_TO_RESOURCE_IDS_VALUES = [:foreign_key, :always, :never].freeze
+        SETTINGS.each_pair do |name, setting|
+          next unless setting[:values]
 
-        def belongs_to_resource_ids_by_default=(val)
-          unless BELONGS_TO_RESOURCE_IDS_VALUES.include?(val)
-            raise Errors::InvalidBelongsToResourceIds.new(self, val)
-          end
+          define_method(:"#{name}=") do |val|
+            unless setting[:values].include?(val)
+              raise setting[:invalid].call(self, val)
+            end
 
-          super
+            super(val)
+          end
         end
 
         def serializer=(val)
@@ -95,51 +154,37 @@ module Graphiti
           :polymorphic,
           :polymorphic_child,
           :serializer,
-          :default_page_size,
-          :default_sort,
-          :max_page_size,
-          :attributes_readable_by_default,
-          :attributes_writable_by_default,
-          :attributes_sortable_by_default,
-          :attributes_filterable_by_default,
-          :attributes_schema_by_default,
-          :relationships_readable_by_default,
-          :relationships_writable_by_default,
-          :belongs_to_resource_ids_by_default,
-          :filters_accept_nil_by_default,
-          :filters_deny_empty_by_default,
           :graphql_entrypoint,
-          :cursor_paginatable
+          *SETTINGS.keys
 
         class << self
           prepend Overrides
         end
 
+        SETTINGS.each_pair do |name, setting|
+          public_send(:"#{name}=", setting[:default])
+        end
+
         def self.inherited(klass)
           super
           klass.config = Util::Hash.deep_dup(config)
           klass.adapter ||= Adapters::Abstract
-          klass.max_page_size ||= DEFAULT_MAX_PAGE_SIZE
           # re-assigning causes a new Class.new
           klass.serializer = (klass.serializer || klass.infer_serializer_superclass)
           klass.type ||= klass.infer_type
           klass.graphql_entrypoint = klass.type.to_s.pluralize.to_sym
-          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, :attributes_schema_by_default, true)
-          default(klass, :relationships_readable_by_default, true)
-          default(klass, :relationships_writable_by_default, true)
-          default(klass, :belongs_to_resource_ids_by_default, :foreign_key)
-          default(klass, :filters_accept_nil_by_default, false)
-          default(klass, :filters_deny_empty_by_default, false)
-
           unless klass.config[:attributes][:id]
             klass.attribute :id, :integer_id
           end
           klass.stat total: [:count]
 
+          # An abstract parent has no serializer for its sideloads, so the subclass applies them here.
+          if abstract_class?
+            klass.config[:sideloads].each_pair do |name, sideload|
+              klass.apply_sideload_to_serializer(name) if klass.eagerly_apply_sideload?(sideload)
+            end
+          end
+
           if defined?(::Rails) && ::Rails.env.development?
             # Avoid adding dupe resources when re-autoloading
             Graphiti.resources.reject! { |r| r.name == klass.name }
@@ -149,6 +194,52 @@ module Graphiti
       end
 
       class_methods do
+        # Deprecated. Both folded into filters_blanks_by_default. Remove in 3.0.
+        def filters_accept_nil_by_default
+          filters_blanks_by_default == :as_nil
+        end
+
+        def filters_accept_nil_by_default=(val)
+          self.filters_blanks_by_default = val ? :as_nil : :as_literal
+        end
+
+        def filters_deny_empty_by_default
+          filters_blanks_by_default == :reject
+        end
+
+        def filters_deny_empty_by_default=(val)
+          self.filters_blanks_by_default = val ? :reject : :as_literal
+        end
+
+        # Deprecated. Renamed to the page_ family. Remove in 3.0.
+        def default_page_size
+          page_default_size
+        end
+
+        def default_page_size=(val)
+          self.page_default_size = val
+        end
+
+        def max_page_size
+          page_max_size
+        end
+
+        def max_page_size=(val)
+          self.page_max_size = val
+        end
+
+        def cursor_paginatable
+          page_cursors
+        end
+
+        def cursor_paginatable=(val)
+          self.page_cursors = val
+        end
+
+        def cursor_paginatable?
+          !!page_cursors
+        end
+
         def get_attr!(name, flag, opts = {})
           opts[:raise_error] = true
           get_attr(name, flag, opts)
@@ -205,14 +296,6 @@ module Graphiti
           serializer_class
         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 ||=
             {
@@ -332,5 +415,20 @@ module Graphiti
         self.class.default_filters
       end
     end
+
+    blanks_msg = "Use `self.filters_blanks_by_default` (:as_literal, :as_nil, or :reject)"
+    page_msg = "Use `self.page_default_size`, `self.page_max_size` and `self.page_cursors`"
+    DEPRECATOR.deprecate_methods(Configuration::ClassMethods,
+      filters_accept_nil_by_default: blanks_msg,
+      "filters_accept_nil_by_default=": blanks_msg,
+      filters_deny_empty_by_default: blanks_msg,
+      "filters_deny_empty_by_default=": blanks_msg,
+      default_page_size: page_msg,
+      "default_page_size=": page_msg,
+      max_page_size: page_msg,
+      "max_page_size=": page_msg,
+      cursor_paginatable: page_msg,
+      "cursor_paginatable=": page_msg,
+      cursor_paginatable?: page_msg)
   end
 end

data/lib/graphiti/resource/dsl.rb

@@ -40,8 +40,7 @@ module Graphiti
               required: required,
               schema: schema,
               operators: operators.to_hash,
-              allow_nil: opts.fetch(:allow_nil, filters_accept_nil_by_default),
-              deny_empty: opts.fetch(:deny_empty, filters_deny_empty_by_default)
+              blanks: blanks_for(name, opts)
             }
           elsif (type = args[0])
             attribute name, type, only: [:filterable], allow: opts[:allow]
@@ -206,6 +205,26 @@ module Graphiti
           end
         end
         private :relationship_option
+
+        def blanks_for(name, opts)
+          if opts.key?(:deny_empty)
+            DEPRECATOR.warn("The deny_empty: filter option is deprecated. Use blanks: :reject.")
+            return :reject if opts[:deny_empty]
+          end
+
+          if opts.key?(:allow_nil)
+            DEPRECATOR.warn("The allow_nil: filter option is deprecated. Use blanks: :as_nil.")
+            return opts[:allow_nil] ? :as_nil : :as_literal
+          end
+
+          blanks = opts.fetch(:blanks, filters_blanks_by_default)
+          unless Resource::BLANK_MODES.include?(blanks)
+            raise Errors::InvalidFilterBlanks.new(self, name, blanks)
+          end
+
+          blanks
+        end
+        private :blanks_for
       end
     end
   end

data/lib/graphiti/resource/interface.rb

@@ -80,7 +80,7 @@ module Graphiti
         end
 
         def validate_request!(params)
-          return if Graphiti.context[:graphql] || !validate_endpoints?
+          return if Graphiti.context[:graphql] || !validate_requests?
 
           if context&.respond_to?(:request)
             path = context.request.env["PATH_INFO"]

data/lib/graphiti/resource/links.rb

@@ -25,12 +25,8 @@ module Graphiti
       class_attribute :endpoint,
         :base_url,
         :endpoint_namespace,
-        :secondary_endpoints,
-        :autolink,
-        :validate_endpoints
+        :secondary_endpoints
       self.secondary_endpoints = []
-      self.autolink = true
-      self.validate_endpoints = true
 
       class << self
         prepend Overrides
@@ -38,6 +34,33 @@ module Graphiti
     end
 
     class_methods do
+      # Deprecated. Folded into relationship_links. Remove in 3.0.
+      def autolink
+        relationship_links != false
+      end
+
+      def autolink=(val)
+        self.relationship_links = val ? true : false
+      end
+
+      def autolink?
+        autolink
+      end
+
+      # Deprecated. Split into validate_requests and validate_links. Remove in 3.0.
+      def validate_endpoints
+        validate_requests && validate_links
+      end
+
+      def validate_endpoints=(val)
+        self.validate_requests = val
+        self.validate_links = val
+      end
+
+      def validate_endpoints?
+        validate_endpoints
+      end
+
       def infer_endpoint
         return unless name
 
@@ -101,4 +124,12 @@ module Graphiti
       end
     end
   end
+
+  msg = "Use `self.relationship_links` (true, false, or :on_demand)"
+  endpoints_msg = "Use `self.validate_requests` for inbound requests, `self.validate_links` for rendered links"
+  DEPRECATOR.deprecate_methods(Links::ClassMethods,
+    autolink: msg, "autolink=": msg, autolink?: msg,
+    validate_endpoints: endpoints_msg,
+    "validate_endpoints=": endpoints_msg,
+    validate_endpoints?: endpoints_msg)
 end

data/lib/graphiti/resource/remote.rb

@@ -6,7 +6,8 @@ module Graphiti
       included do
         self.adapter = Graphiti::Adapters::GraphitiAPI
         self.model = OpenStruct
-        self.validate_endpoints = false
+        self.validate_requests = false
+        self.validate_links = false
 
         class_attribute :timeout,
           :open_timeout

data/lib/graphiti/resource/sideloading.rb

@@ -126,11 +126,11 @@ module Graphiti
         end
 
         # If eager loading, ensure routes are loaded first, then apply
-        # This happens in Railtie
+        # This happens in Railtie. Setup runs once, so classes redefined by a reload apply at definition.
         def eagerly_apply_sideload?(sideload)
           # TODO: Maybe handle this in the Rails integration
           if defined?(::Rails) && (app = ::Rails.application)
-            app.config.eager_load ? false : true
+            app.config.eager_load ? Graphiti.setup? : true
           else
             sideload.resource_class_loaded?
           end

data/lib/graphiti/schema.rb

@@ -111,8 +111,8 @@ module Graphiti
           config[:default_sort] = default_sort
         end
 
-        if r.default_page_size
-          config[:default_page_size] = r.default_page_size
+        if r.page_default_size
+          config[:default_page_size] = r.page_default_size
         end
 
         if r.polymorphic? && !r.polymorphic_child?