graphiti 2.0.0.beta.11 → 2.0.0.beta.13

data/lib/graphiti/request_validators/update_validator.rb

@@ -13,11 +13,7 @@ module Graphiti
 
       def attribute_mismatch(attr_path)
         @error_class = Graphiti::Errors::ConflictRequest
-        @errors.add(
-          attr_path.join("."),
-          :attribute_mismatch,
-          message: "does not match the server endpoint"
-        )
+        @errors.add(attr_path.join("."), :attribute_mismatch)
       end
 
       def required_payload?
@@ -32,7 +28,7 @@ module Graphiti
       end
 
       def payload_matches_endpoint?
-        unless @params.dig(:data, :id) == @params.dig(:filter, :id)
+        unless @params.dig(:data, :id).to_s == @params.dig(:filter, :id).to_s
           attribute_mismatch([:data, :id])
         end
 

data/lib/graphiti/request_validators/validator.rb

@@ -54,14 +54,14 @@ module Graphiti
         page = @params[:page]
         return if page.nil? || page.respond_to?(:each_pair)
 
-        @errors.add(:page, :invalid, message: "must be an object")
+        @errors.add(:page, :invalid)
       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")
+        @errors.add(:data, :invalid)
         false
       end
 
@@ -69,7 +69,7 @@ module Graphiti
         relationships.each_key do |name|
           unless resource.class.sideload(name.to_sym)
             full_key = fully_qualified_key(name, payload_path, :relationships)
-            @errors.add(full_key, :invalid_relationship, message: "is not a valid relationship")
+            @errors.add(full_key, :invalid_relationship)
           end
         end
 
@@ -110,11 +110,11 @@ module Graphiti
             begin
               attributes[key] = resource.typecast(key, value, :writable)
             rescue Graphiti::Errors::UnknownAttribute
-              @errors.add(fully_qualified_key(key, payload_path), :unknown_attribute, message: "is an unknown attribute")
+              @errors.add(fully_qualified_key(key, payload_path), :unknown_attribute)
             rescue Graphiti::Errors::InvalidAttributeAccess
-              @errors.add(fully_qualified_key(key, payload_path), :unwritable_attribute, message: "cannot be written")
+              @errors.add(fully_qualified_key(key, payload_path), :unwritable_attribute)
             rescue Graphiti::Errors::TypecastFailed => e
-              @errors.add(fully_qualified_key(key, payload_path), :type_error, message: "should be type #{e.type_name}")
+              @errors.add(fully_qualified_key(key, payload_path), :type_error, type: e.type_name)
             end
           end
         end

data/lib/graphiti/resource.rb

@@ -37,8 +37,8 @@ module Graphiti
       end
     end
 
-    def with_context(object, namespace = nil)
-      Graphiti.with_context(object, namespace) do
+    def with_context(object, action = nil)
+      Graphiti.with_context(object, action) do
         yield
       end
     end
@@ -55,7 +55,7 @@ module Graphiti
     # is called, not a fixed list. Persistence overrides it with :create/:update
     # while saving, and :show while resolving sideloads afterwards.
     def self.current_action
-      Graphiti.context[:namespace]
+      Graphiti.context[:action]
     end
 
     def current_action

data/lib/graphiti/resource_proxy.rb

@@ -159,7 +159,7 @@ module Graphiti
       params = normalized_params_copy(params)
       add_endpoint_filter(params, action)
       validator = ::Graphiti::RequestValidator.new(@resource, params, action)
-      validator.validate!
+      with_context_action(action) { validator.validate! }
 
       if @assigned_model && same_write_payload?(validator.deserialized_payload)
         return @assigned_model
@@ -174,32 +174,36 @@ module Graphiti
       )
     end
 
+    # TODO: remove this. Only used for persisting many-to-many with AR
+    # (see activerecord adapter)
+    def with_context_action(action)
+      original = Graphiti.context[:action]
+      Graphiti.context[:action] = action
+      yield
+    ensure
+      Graphiti.context[:action] = original
+    end
+
     def save(action: :create)
-      # TODO: remove this. Only used for persisting many-to-many with AR
-      # (see activerecord adapter)
-      original = Graphiti.context[:namespace]
-      begin
-        Graphiti.context[:namespace] = action
+      validator = with_context_action(action) do
         # An assigned model can only come from #assign_attributes, which
         # validated the payload it stored - re-validating here would run the
         # writable guards (and their guard_model lookups) a redundant time.
         unless @assigned_model
           ::Graphiti::RequestValidator.new(@resource, @payload.params, action).validate!
         end
-        validator = persist {
+        persist {
           @resource.persist_with_relationships \
             @payload.meta(action: action),
             @payload.attributes,
             @payload.relationships,
             assigned_model: @assigned_model
         }
-      ensure
-        Graphiti.context[:namespace] = original
       end
       @data, success = validator.to_a
 
       if success
-        # If the context namespace is `update` or `create`, certain
+        # If the context action is `update` or `create`, certain
         # adapters will cause N+1 validation calls, so lets explicitly
         # switch to a lookup context.
         Graphiti.with_context(Graphiti.context[:object], :show) do

data/lib/graphiti/schema/check.rb

@@ -0,0 +1,69 @@
+module Graphiti
+  class Schema
+    class Check
+      attr_reader :path, :errors
+
+      def initialize(schema, path)
+        @path = path
+        @schema = schema
+        @generated = normalize(schema)
+        @committed = normalize(JSON.parse(File.read(path))) if File.exist?(path)
+        @errors = @committed ? SchemaDiff.new(@committed, @generated).compare : []
+      end
+
+      def missing?
+        @committed.nil?
+      end
+
+      def stale?
+        !missing? && @committed != @generated
+      end
+
+      def compatible?
+        errors.empty?
+      end
+
+      def ok?
+        !missing? && !stale? && compatible?
+      end
+
+      def write!
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(@schema))
+        path
+      end
+
+      def message
+        return "Schema is up to date: #{path}" if ok?
+        return "#{missing_message}\n\n#{regenerate}" if missing?
+        return "#{incompatible_message}\n\n#{errors.join("\n")}" unless compatible?
+
+        "Schema file is outdated: #{path}\n\n#{regenerate}"
+      end
+
+      private
+
+      def normalize(schema)
+        JSON.parse(JSON.generate(schema))
+      end
+
+      def missing_message
+        "Schema file not found: #{path}"
+      end
+
+      def incompatible_message
+        <<~MSG.chomp
+          Found backwards-incompatibilities in schema: #{path}
+
+          Re-run with FORCE_SCHEMA=true to accept them and overwrite the file.
+
+          Incompatibilities:
+        MSG
+      end
+
+      def regenerate
+        "Run `rake graphiti:schema:generate` and commit the file."
+      end
+    end
+  end
+end

data/lib/graphiti/schema.rb

@@ -11,19 +11,18 @@ module Graphiti
       new(resources).generate
     end
 
-    def self.generate!(resources = nil)
-      schema = generate(resources)
+    def self.generate!(resources = nil, path: Graphiti.config.schema_path, force: ENV["FORCE_SCHEMA"] == "true")
+      result = check(resources, path: path)
+      return result.errors if !force && !result.compatible?
 
-      if ENV["FORCE_SCHEMA"] != "true" && File.exist?(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
-      FileUtils.mkdir_p(Graphiti.config.schema_path.to_s.gsub("/schema.json", ""))
-      File.write(Graphiti.config.schema_path, JSON.pretty_generate(schema))
+      result.write!
       []
     end
 
+    def self.check(resources = nil, path: Graphiti.config.schema_path)
+      Check.new(generate(resources), path)
+    end
+
     def initialize(resources)
       @resources = resources.sort_by(&:name)
       @remote_resources = @resources.select(&:remote?)

data/lib/graphiti/scope.rb

@@ -39,18 +39,17 @@ module Graphiti
       !Graphiti.config.concurrency || on_pool_thread?
     end
 
-    # TODO: move to Fiber[] once the floor is Ruby 3.2
     def self.on_pool_thread?
-      Thread.current[POOL_THREAD] == true
+      Fiber[POOL_THREAD] == true
     end
 
     # Restores rather than clears because :caller_runs may have run the task on a request thread.
     def self.marking_pool_thread
-      previous = Thread.current[POOL_THREAD]
-      Thread.current[POOL_THREAD] = true
+      previous = Fiber[POOL_THREAD]
+      Fiber[POOL_THREAD] = true
       yield
     ensure
-      Thread.current[POOL_THREAD] = previous
+      Fiber[POOL_THREAD] = previous
     end
 
     def initialize(object, resource, query, opts = {})

data/lib/graphiti/sideload.rb

@@ -61,6 +61,27 @@ module Graphiti
       self.scope_proc = blk
     end
 
+    ASSIGNING_QUERY = :__graphiti_assigning_query
+    private_constant :ASSIGNING_QUERY
+
+    def self.assigning_node(query)
+      return yield if query.nil?
+
+      previous = Fiber[ASSIGNING_QUERY]
+      Fiber[ASSIGNING_QUERY] = query
+      yield
+    ensure
+      Fiber[ASSIGNING_QUERY] = previous unless query.nil?
+    end
+
+    def self.current_assigning_query
+      Fiber[ASSIGNING_QUERY]
+    end
+
+    def self.assigned?(query, record, association_name)
+      query.association_owners.key?([record.object_id, association_name])
+    end
+
     def self.assign(&blk)
       self.assign_proc = blk
     end
@@ -365,7 +386,7 @@ module Graphiti
 
       if self.class.scope_proc
         build_sideload_scope(parents, query, graph_parent).resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
+          fire_assign(parents, sideload_results, query)
         end
       else
         sync_load(parents, query, graph_parent, &proxy_block)
@@ -378,7 +399,7 @@ module Graphiti
 
       if self.class.scope_proc
         build_sideload_scope(parents, query, graph_parent).future_resolve do |sideload_results|
-          fire_assign(parents, sideload_results)
+          fire_assign(parents, sideload_results, query)
         end
       else
         future_load(parents, query, graph_parent, &proxy_block)
@@ -413,10 +434,14 @@ module Graphiti
     end
 
     def associate_all(parent, children)
+      return unless claim_association(parent)
+
       parent_resource.associate_all(parent, children, association_name, type)
     end
 
     def associate(parent, child)
+      return unless claim_association(parent)
+
       parent_resource.associate(parent, child, association_name, type)
     end
 
@@ -506,7 +531,7 @@ module Graphiti
         opts[:sideload_parent_length] = parents.length
         opts[:query] = query
         opts[:after_resolve] = ->(results) {
-          fire_assign(parents, results)
+          fire_assign(parents, results, query)
         }
       end
     end
@@ -519,16 +544,28 @@ module Graphiti
       end
     end
 
-    def fire_assign(parents, children)
-      with_error_handling Errors::SideloadAssignError do
-        if self.class.assign_proc
-          instance_exec(parents, children, &self.class.assign_proc)
-        else
-          assign(parents, children)
+    def fire_assign(parents, children, query = nil)
+      self.class.assigning_node(query) do
+        with_error_handling Errors::SideloadAssignError do
+          if self.class.assign_proc
+            instance_exec(parents, children, &self.class.assign_proc)
+          else
+            assign(parents, children)
+          end
         end
       end
     end
 
+    # A record can be shared by two nodes of the include tree, and a node that narrows
+    # differently returns different rows, so the first node to populate an association owns it.
+    def claim_association(parent)
+      query = self.class.current_assigning_query
+      return true if query.nil?
+
+      key = [parent.object_id, association_name]
+      query.association_owners.compute_if_absent(key) { query.hash } == query.hash
+    end
+
     def with_error_handling(error_class)
       begin
         result = yield

data/lib/graphiti/spec_helpers/matchers.rb

@@ -59,6 +59,7 @@ module Graphiti
 
       class RelationMatcher < BaseMatcher
         GRAPHITI_OPTS = %i[primary_key foreign_key resource readable writable link single].freeze
+        SIDELOAD_METHODS = {resource: :resource_class, readable: :readable?, writable: :writable?, single: :single?}.freeze
         GRAPHITI_CONFIG_KEY = :sideloads
         EXPECTED_ACTION = ""
 
@@ -73,7 +74,7 @@ module Graphiti
         attr_reader :target, :opts, :resource
 
         def assert_opt(opt)
-          asserted_opt = (opt == :resource) ? :resource_class : opt
+          asserted_opt = SIDELOAD_METHODS.fetch(opt, opt)
           return true if config.send(asserted_opt) == opts[opt]
 
           @opt_failures << opt_failure_message(opt, opts[opt], config.send(asserted_opt))

data/lib/graphiti/spec_helpers/rspec.rb

@@ -127,22 +127,14 @@ module Graphiti
         end
       end
 
-      def self.schema!(resources = nil)
+      def self.schema!(resources = nil, path: nil)
         ::RSpec.describe "Graphiti Schema" do
           it "generates a backwards-compatible schema" do
-            message = <<~MSG
-              Found backwards-incompatibilities in schema! Run with FORCE_SCHEMA=true to ignore.
+            check = Graphiti::Schema.check(resources, path: path || Graphiti.config.schema_path)
+            forced = ENV["FORCE_SCHEMA"] == "true"
+            check.write! if check.compatible? || forced
 
-              Incompatibilities:
-
-            MSG
-
-            errors = Graphiti::Schema.generate!(resources)
-            errors.each do |e|
-              message << "#{e}\n"
-            end
-
-            expect(errors.empty?).to eq(true), message
+            expect(check.compatible? || forced).to eq(true), check.message
           end
         end
       end

data/lib/graphiti/util/serializer_relationships.rb

@@ -71,7 +71,7 @@ module Graphiti
           # not predict, so the loaded records win. Only the un-included case
           # is worth short-circuiting.
           if sideload_ref.resource_ids_from_foreign_key? &&
-              !self_ref.send(:included_anywhere?, @proxy.query.include_hash, sideload_ref.name)
+              !::Graphiti::Sideload.assigned?(@proxy.query, @object, sideload_ref.association_name)
             linkage always: sideload_ref.render_resource_ids? do
               foreign_key = begin
                 @object.public_send(sideload_ref.foreign_key)
@@ -104,15 +104,6 @@ module Graphiti
         end
       end
 
-      # A relationship nested under another one is still loaded and can still
-      # be narrowed by a deep filter, so the foreign key is not a safe
-      # stand-in for what the request actually returns.
-      def included_anywhere?(include_hash, name)
-        include_hash.any? do |key, nested|
-          key == name || included_anywhere?(nested, name)
-        end
-      end
-
       def data_proc
         sideload_ref = @sideload
         resource_class_ref = @resource_class

data/lib/graphiti/util/simple_errors.rb

@@ -6,6 +6,21 @@ module Graphiti
     class SimpleErrors
       include Enumerable
 
+      # Overridable under graphiti.errors.messages.
+      DEFAULT_MESSAGES = {
+        missing: "is missing",
+        invalid: "must be an object",
+        invalid_relationship: "is not a valid relationship",
+        unwritable_relationship: "cannot be written",
+        unknown_attribute: "is an unknown attribute",
+        unwritable_attribute: "cannot be written",
+        type_error: "should be type %{type}",
+        attribute_mismatch: "does not match the server endpoint"
+      }.freeze
+
+      # Joins an attribute to its message, like Rails' own errors.format.
+      DEFAULT_FORMAT = "%{attribute} %{message}"
+
       attr_reader :messages, :details
 
       def initialize(validation_target)
@@ -50,11 +65,9 @@ module Graphiti
       end
       alias_method :blank?, :empty?
 
-      def add(attribute, code, message: nil)
-        message ||= "is #{code.to_s.humanize.downcase}"
-
+      def add(attribute, code, message: nil, **interpolations)
         details[attribute.to_sym] << {error: code}
-        messages[attribute.to_sym] << message
+        messages[attribute.to_sym] << translate(code, message, **interpolations, attribute: attribute)
       end
 
       def added?(attribute, code)
@@ -73,11 +86,19 @@ module Graphiti
 
       def full_message(attribute, message)
         return message if attribute == :base
-        "#{attribute} #{message}"
+
+        translate(:format, DEFAULT_FORMAT, [:graphiti, :errors], attribute: attribute, message: message)
       end
 
       private
 
+      def translate(key, fallback, scope = [:graphiti, :errors, :messages], **interpolations)
+        fallback ||= DEFAULT_MESSAGES.fetch(key) { "is #{key.to_s.humanize.downcase}" }
+        return fallback % interpolations unless defined?(::I18n)
+
+        ::I18n.t(key, scope: scope, default: fallback, **interpolations)
+      end
+
       def apply_default_array(hash)
         hash.default_proc = proc { |h, key| h[key] = [] }
         hash

data/lib/graphiti/util/transaction_hooks_recorder.rb

@@ -58,11 +58,11 @@ module Graphiti
         private
 
         def _hooks
-          Thread.current[:_graphiti_hooks]
+          Fiber[:_graphiti_hooks]
         end
 
         def reset_hooks
-          Thread.current[:_graphiti_hooks] = {
+          Fiber[:_graphiti_hooks] = {
             after_graph_persist: [],
             before_commit: [],
             after_commit: []

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "2.0.0.beta.11"
+  VERSION = "2.0.0.beta.13"
 end

data/lib/graphiti.rb

@@ -51,18 +51,20 @@ module Graphiti
 
   # @api private
   def self.context
-    Thread.current[:context] ||= {}
+    Fiber[:context] ||= ContextHash.new
   end
 
   # @api private
   def self.context=(val)
-    Thread.current[:context] = val
+    Fiber[:context] = ContextHash.new.tap do |hash|
+      val.each { |key, value| hash[key] = value }
+    end
   end
 
   # @api private
-  def self.with_context(obj, namespace = nil)
+  def self.with_context(obj, action = nil)
     prior = context
-    self.context = {object: obj, namespace: namespace}
+    self.context = {object: obj, action: action}
     yield
   ensure
     self.context = prior
@@ -169,12 +171,14 @@ require "graphiti/version"
 require "graphiti/jsonapi_serializable_ext"
 require "graphiti/configuration"
 require "graphiti/context"
+require "graphiti/context_hash"
 require "graphiti/errors"
 require "graphiti/types"
 require "graphiti/audit"
 require "graphiti/audit/report"
 require "graphiti/schema"
 require "graphiti/schema_diff"
+require "graphiti/schema/check"
 require "graphiti/adapters/abstract"
 require "graphiti/resource/sideloading"
 require "graphiti/resource/links"
@@ -238,6 +242,7 @@ require "graphiti/query"
 require "graphiti/debugger"
 require "graphiti/util/cache_debug"
 require "graphiti/util/uri_decoder"
+require "graphiti/error_serializers/translated_title"
 require "graphiti/error_serializers/validation"
 require "graphiti/error_serializers/invalid_request"
 require "graphiti/error_serializers/conflict_request"

data/lib/tasks/graphiti.rake

@@ -16,6 +16,24 @@ namespace :graphiti do
     Graphiti::Debugger.flush if debug
   end
 
+  namespace :schema do
+    desc "Write the schema file. Refuses backwards-incompatible changes unless FORCE_SCHEMA=true. Takes an optional path, defaulting to Graphiti.config.schema_path."
+    task :generate, [:path] => [:environment] do |_, args|
+      check = Graphiti::Schema.check(path: helpers.schema_path(args[:path]))
+      abort check.message unless check.compatible? || ENV["FORCE_SCHEMA"] == "true"
+
+      puts "Schema written: #{check.write!}"
+    end
+
+    desc "Fail unless the committed schema file exists, is up to date, and is backwards-compatible. Takes an optional path, defaulting to Graphiti.config.schema_path."
+    task :check, [:path] => [:environment] do |_, args|
+      check = Graphiti::Schema.check(path: helpers.schema_path(args[:path]))
+      abort check.message unless check.ok?
+
+      puts check.message
+    end
+  end
+
   desc "Audit every relationship: what will raise, what loads to render ids, which render no ids, and which checks passed."
   task audit: [:environment] do
     helpers.setup_rails!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta.11
+  version: 2.0.0.beta.13
 platform: ruby
 authors:
 - Lee Richmond
@@ -287,6 +287,7 @@ files:
 - lib/generators/graphiti/api_test_generator.rb
 - lib/generators/graphiti/generator_mixin.rb
 - lib/generators/graphiti/install_generator.rb
+- lib/generators/graphiti/locale_generator.rb
 - lib/generators/graphiti/resource_generator.rb
 - lib/generators/graphiti/resource_test_generator.rb
 - lib/generators/graphiti/templates/application_resource.rb.erb
@@ -294,6 +295,7 @@ files:
 - lib/generators/graphiti/templates/create_request_spec.rb.erb
 - lib/generators/graphiti/templates/destroy_request_spec.rb.erb
 - lib/generators/graphiti/templates/index_request_spec.rb.erb
+- lib/generators/graphiti/templates/locale.yml.erb
 - lib/generators/graphiti/templates/resource.rb.erb
 - lib/generators/graphiti/templates/resource_reads_spec.rb.erb
 - lib/generators/graphiti/templates/resource_writes_spec.rb.erb
@@ -316,12 +318,14 @@ files:
 - lib/graphiti/cli.rb
 - lib/graphiti/configuration.rb
 - lib/graphiti/context.rb
+- lib/graphiti/context_hash.rb
 - lib/graphiti/debugger.rb
 - lib/graphiti/delegates/pagination.rb
 - lib/graphiti/deserializer.rb
 - lib/graphiti/error_serializers/conflict_request.rb
 - lib/graphiti/error_serializers/deprecated_constants.rb
 - lib/graphiti/error_serializers/invalid_request.rb
+- lib/graphiti/error_serializers/translated_title.rb
 - lib/graphiti/error_serializers/validation.rb
 - lib/graphiti/errors.rb
 - lib/graphiti/extensions/boolean_attribute.rb
@@ -359,6 +363,7 @@ files:
 - lib/graphiti/responders.rb
 - lib/graphiti/runner.rb
 - lib/graphiti/schema.rb
+- lib/graphiti/schema/check.rb
 - lib/graphiti/schema_diff.rb
 - lib/graphiti/scope.rb
 - lib/graphiti/scoping/base.rb