json_api_client 1.5.2 → 1.22.0

data/lib/json_api_client/query/requestor.rb

@@ -10,37 +10,44 @@ module JsonApiClient
 
       # expects a record
       def create(record)
-        request(:post, klass.path(record.attributes), {
-          data: record.as_json_api
-        })
+        request(
+          :post,
+          klass.path(record.path_attributes),
+          body: { data: record.as_json_api },
+          params: record.request_params.to_params
+        )
       end
 
       def update(record)
-        request(:patch, resource_path(record.attributes), {
-          data: record.as_json_api
-        })
+        request(
+          :patch,
+          resource_path(record.path_attributes),
+          body: { data: record.as_json_api },
+          params: record.request_params.to_params
+        )
       end
 
       def get(params = {})
         path = resource_path(params)
         params.delete(klass.primary_key)
-        request(:get, path, params)
+        request(:get, path, params: params)
       end
 
       def destroy(record)
-        request(:delete, resource_path(record.attributes), {})
+        request(:delete, resource_path(record.path_attributes))
       end
 
       def linked(path)
-        request(:get, path, {})
+        request(:get, path)
       end
 
       def custom(method_name, options, params)
         path = resource_path(params)
         params.delete(klass.primary_key)
         path = File.join(path, method_name.to_s)
-
-        request(options.fetch(:request_method, :get), path, params)
+        request_method = options.fetch(:request_method, :get).to_sym
+        query_params, body_params = [:get, :delete].include?(request_method) ? [params, nil] : [nil, params]
+        request(request_method, path, params: query_params, body: body_params)
       end
 
       protected
@@ -56,8 +63,9 @@ module JsonApiClient
         end
       end
 
-      def request(type, path, params)
-        klass.parser.parse(klass, connection.run(type, path, params, klass.custom_headers))
+      def request(type, path, params: nil, body: nil)
+        response = connection.run(type, path, params: params, body: body, headers: klass.custom_headers)
+        klass.parser.parse(klass, response)
       end
 
     end

data/lib/json_api_client/relationships/relations.rb

@@ -11,7 +11,6 @@ module JsonApiClient
       def initialize(record_class, relations)
         @record_class = record_class
         self.attributes = relations
-        clear_changes_information
       end
 
       def present?

data/lib/json_api_client/request_params.rb

@@ -0,0 +1,57 @@
+module JsonApiClient
+  class RequestParams
+    attr_reader :klass, :includes, :fields
+
+    def initialize(klass, includes: [], fields: {})
+      @klass = klass
+      @includes = includes
+      @fields = fields
+    end
+
+    def add_includes(includes)
+      Utils.parse_includes(klass, *includes).each do |name|
+        name = name.to_sym
+        self.includes.push(name) unless self.includes.include?(name)
+      end
+    end
+
+    def reset_includes!
+      @includes = []
+    end
+
+    def set_fields(type, field_names)
+      self.fields[type.to_sym] = field_names.map(&:to_sym)
+    end
+
+    def remove_fields(type)
+      self.fields.delete(type.to_sym)
+    end
+
+    def field_types
+      self.fields.keys
+    end
+
+    def clear
+      reset_includes!
+      @fields = {}
+    end
+
+    def to_params
+      return nil if field_types.empty? && includes.empty?
+      parsed_fields.merge(parsed_includes)
+    end
+
+    private
+
+    def parsed_includes
+      return {} if includes.empty?
+      {include: includes.join(",")}
+    end
+
+    def parsed_fields
+      return {} if field_types.empty?
+      {fields: fields.map { |type, names| [type, names.join(",")] }.to_h}
+    end
+
+  end
+end

data/lib/json_api_client/resource.rb

@@ -12,10 +12,12 @@ module JsonApiClient
 
     include Helpers::DynamicAttributes
     include Helpers::Dirty
+    include Helpers::Associatable
 
     attr_accessor :last_result_set,
                   :links,
-                  :relationships
+                  :relationships,
+                  :request_params
     class_attribute :site,
                     :primary_key,
                     :parser,
@@ -28,10 +30,21 @@ module JsonApiClient
                     :relationship_linker,
                     :read_only_attributes,
                     :requestor_class,
-                    :associations,
                     :json_key_format,
                     :route_format,
+                    :request_params_class,
+                    :keep_request_params,
+                    :search_included_in_result_set,
+                    :custom_type_to_class,
+                    :raise_on_blank_find_param,
                     instance_accessor: false
+    class_attribute :add_defaults_to_changes,
+                    instance_writer: false
+
+    class_attribute :_immutable,
+                    instance_writer: false,
+                    default: false
+
     self.primary_key          = :id
     self.parser               = Parsers::Parser
     self.paginator            = Paginating::Paginator
@@ -42,7 +55,12 @@ module JsonApiClient
     self.relationship_linker  = Relationships::Relations
     self.read_only_attributes = [:id, :type, :links, :meta, :relationships]
     self.requestor_class      = Query::Requestor
-    self.associations         = []
+    self.request_params_class = RequestParams
+    self.keep_request_params = false
+    self.add_defaults_to_changes = false
+    self.search_included_in_result_set = false
+    self.custom_type_to_class = {}
+    self.raise_on_blank_find_param = false
 
     #:underscored_key, :camelized_key, :dasherized_key, or custom
     self.json_key_format = :underscored_key
@@ -50,14 +68,15 @@ module JsonApiClient
     #:underscored_route, :camelized_route, :dasherized_route, or custom
     self.route_format = :underscored_route
 
-    include Associations::BelongsTo
-    include Associations::HasMany
-    include Associations::HasOne
-
     class << self
       extend Forwardable
       def_delegators :_new_scope, :where, :order, :includes, :select, :all, :paginate, :page, :with_params, :first, :find, :last
 
+      def resolve_custom_type(type_name, class_name)
+        classified_type = key_formatter.unformat(type_name.to_s).singularize.classify
+        self.custom_type_to_class = custom_type_to_class.merge(classified_type => class_name.to_s)
+      end
+
       # The table name for this resource. i.e. Article -> articles, Person -> people
       #
       # @return [String] The table name for this resource
@@ -80,6 +99,19 @@ module JsonApiClient
         table_name
       end
 
+      # Indicates whether this resource is mutable or immutable;
+      # by default, all resources are mutable.
+      #
+      # @return [Boolean]
+      def immutable(flag = true)
+        self._immutable = flag
+      end
+
+      def inherited(subclass)
+        subclass._immutable = false
+        super
+      end
+
       # Specifies the relative path that should be used for this resource;
       # by default, this is inferred from the resource class name.
       #
@@ -95,6 +127,7 @@ module JsonApiClient
         new(params).tap do |resource|
           resource.mark_as_persisted!
           resource.clear_changes_information
+          resource.relationships.clear_changes_information
         end
       end
 
@@ -139,6 +172,12 @@ module JsonApiClient
         end
       end
 
+      def create!(attributes = {})
+        new(attributes).tap do |resource|
+          raise(Errors::RecordNotSaved.new("Failed to save the record", resource)) unless resource.save
+        end
+      end
+
       # Within the given block, add these headers to all requests made by
       # the resource class
       #
@@ -156,7 +195,9 @@ module JsonApiClient
       #
       # @return [Hash] Headers
       def custom_headers
-        _header_store.to_h
+        return _header_store.to_h if superclass == Object
+
+        superclass.custom_headers.merge(_header_store.to_h)
       end
 
       # Returns the requestor for this resource class
@@ -167,7 +208,7 @@ module JsonApiClient
       end
 
       # Default attributes that every instance of this resource should be
-      # intialized with. Optionally, override this method in a subclass.
+      # initialized with. Optionally, override this method in a subclass.
       #
       # @return [Hash] Default attributes
       def default_attributes
@@ -198,6 +239,11 @@ module JsonApiClient
       # @option [Symbol] :on One of [:collection or :member] to decide whether it's a collect or member method
       # @option [Symbol] :request_method The request method (:get, :post, etc)
       def custom_endpoint(name, options = {})
+        if _immutable
+          request_method = options.fetch(:request_method, :get).to_sym
+          raise JsonApiClient::Errors::ResourceImmutableError if request_method != :get
+        end
+
         if :collection == options.delete(:on)
           collection_endpoint(name, options)
         else
@@ -243,6 +289,12 @@ module JsonApiClient
       # @option options [Symbol] :default The default value for the property
       def property(name, options = {})
         schema.add(name, options)
+        define_method(name) do
+          attributes[name]
+        end
+        define_method("#{name}=") do |value|
+          set_attribute(name, value)
+        end
       end
 
       # Declare multiple properties with the same optional options
@@ -272,7 +324,7 @@ module JsonApiClient
 
       def _set_prefix_path(attrs)
         paths = _belongs_to_associations.map do |a|
-          a.set_prefix_path(attrs, route_formatter) 
+          a.set_prefix_path(attrs, route_formatter)
         end
 
         paths.join("/")
@@ -302,20 +354,23 @@ module JsonApiClient
     #
     # @param params [Hash] Attributes, links, and relationships
     def initialize(params = {})
+      params = params.with_indifferent_access
       @persisted = nil
-      self.links = self.class.linker.new(params.delete("links") || {})
-      self.relationships = self.class.relationship_linker.new(self.class, params.delete("relationships") || {})
-      self.attributes = params.merge(self.class.default_attributes)
+      @destroyed = nil
+      self.links = self.class.linker.new(params.delete(:links) || {})
+      self.relationships = self.class.relationship_linker.new(self.class, params.delete(:relationships) || {})
+      self.attributes = self.class.default_attributes.merge params.except(*self.class.prefix_params)
+      self.forget_change!(:type)
+      self.__belongs_to_params = params.slice(*self.class.prefix_params)
 
-      self.class.schema.each_property do |property|
-        attributes[property.name] = property.default unless attributes.has_key?(property.name) || property.default.nil?
-      end
+      setup_default_properties
 
       self.class.associations.each do |association|
         if params.has_key?(association.attr_name.to_s)
           set_attribute(association.attr_name, params[association.attr_name.to_s])
         end
       end
+      self.request_params = self.class.request_params_class.new(self.class)
     end
 
     # Set the current attributes and try to save them
@@ -327,6 +382,11 @@ module JsonApiClient
       save
     end
 
+    def update_attributes!(attrs = {})
+      self.attributes = attrs
+      save ? true : raise(Errors::RecordNotSaved.new("Failed to update the record", self))
+    end
+
     # Alias to update_attributes
     #
     # @param attrs [Hash] Attributes to update
@@ -335,6 +395,10 @@ module JsonApiClient
       update_attributes(attrs)
     end
 
+    def update!(attrs = {})
+      update_attributes!(attrs)
+    end
+
     # Mark the record as persisted
     def mark_as_persisted!
       @persisted = true
@@ -344,14 +408,26 @@ module JsonApiClient
     #
     # @return [Boolean]
     def persisted?
-      !!@persisted && has_attribute?(self.class.primary_key)
+      !!@persisted && !destroyed? && has_attribute?(self.class.primary_key)
+    end
+
+    # Mark the record as destroyed
+    def mark_as_destroyed!
+      @destroyed = true
+    end
+
+    # Whether or not this record has been destroyed to the database previously
+    #
+    # @return [Boolean]
+    def destroyed?
+      !!@destroyed
     end
 
     # Returns true if this is a new record (never persisted to the database)
     #
     # @return [Boolean]
     def new_record?
-      !persisted?
+      !persisted? && !destroyed?
     end
 
     # When we represent this resource as a relationship, we do so with id & type
@@ -366,7 +442,7 @@ module JsonApiClient
     #
     # @return [Hash] Representation of this object as JSONAPI object
     def as_json_api(*)
-      attributes.slice(:id, :type).tap do |h|
+      attributes.slice(self.class.primary_key, :type).tap do |h|
         relationships_for_serialization.tap do |r|
           h[:relationships] = self.class.key_formatter.format_keys(r) unless r.empty?
         end
@@ -375,11 +451,11 @@ module JsonApiClient
     end
 
     def as_json(*)
-      attributes.slice(:id, :type).tap do |h|
+      attributes.slice(self.class.primary_key, :type).tap do |h|
         relationships.as_json.tap do |r|
           h[:relationships] = r unless r.empty?
         end
-        h[:attributes] = attributes.except(:id, :type).as_json
+        h[:attributes] = attributes.except(self.class.primary_key, :type).as_json
       end
     end
 
@@ -402,6 +478,7 @@ module JsonApiClient
     # @return [Boolean] Whether or not the save succeeded
     def save
       return false unless valid?
+      raise JsonApiClient::Errors::ResourceImmutableError if _immutable
 
       self.last_result_set = if persisted?
         self.class.requestor.update(self)
@@ -410,22 +487,19 @@ module JsonApiClient
       end
 
       if last_result_set.has_errors?
-        last_result_set.errors.each do |error|
-          if error.source_parameter
-            errors.add(self.class.key_formatter.unformat(error.source_parameter), error.title || error.detail)
-          else
-            errors.add(:base, error.title || error.detail)
-          end
-        end
+        fill_errors
         false
       else
         self.errors.clear if self.errors
+        self.request_params.clear unless self.class.keep_request_params
         mark_as_persisted!
         if updated = last_result_set.first
           self.attributes = updated.attributes
           self.links.attributes = updated.links.attributes
           self.relationships.attributes = updated.relationships.attributes
           clear_changes_information
+          self.relationships.clear_changes_information
+          _clear_cached_relationships
         end
         true
       end
@@ -435,12 +509,17 @@ module JsonApiClient
     #
     # @return [Boolean] Whether or not the destroy succeeded
     def destroy
+      raise JsonApiClient::Errors::ResourceImmutableError if _immutable
+
       self.last_result_set = self.class.requestor.destroy(self)
-      if !last_result_set.has_errors?
-        self.attributes.clear
-        true
-      else
+      if last_result_set.has_errors?
+        fill_errors
         false
+      else
+        mark_as_destroyed!
+        _clear_cached_relationships
+        _clear_belongs_to_params
+        true
       end
     end
 
@@ -448,27 +527,83 @@ module JsonApiClient
       "#<#{self.class.name}:@attributes=#{attributes.inspect}>"
     end
 
-    protected
+    def request_includes(*includes)
+      self.request_params.add_includes(includes)
+      self
+    end
 
-    def method_missing(method, *args)
-      association = association_for(method)
+    def reset_request_includes!
+      self.request_params.reset_includes!
+      self
+    end
 
-      return super unless association || (relationships && relationships.has_attribute?(method))
+    def request_select(*fields)
+      fields_by_type = fields.extract_options!
+      fields_by_type[type.to_sym] = fields if fields.any?
+      fields_by_type.each do |field_type, field_names|
+        self.request_params.set_fields(field_type, field_names)
+      end
+      self
+    end
 
-      return nil unless relationship_definitions = relationships[method]
+    def reset_request_select!(*resource_types)
+      resource_types = self.request_params.field_types if resource_types.empty?
+      resource_types.each { |resource_type| self.request_params.remove_fields(resource_type) }
+      self
+    end
 
-      # look in included data
-      if relationship_definitions.key?("data")
-        return last_result_set.included.data_for(method, relationship_definitions)
+    def path_attributes
+      _belongs_to_params.merge attributes.slice( self.class.primary_key ).with_indifferent_access
+    end
+
+    protected
+
+    def setup_default_properties
+      self.class.schema.each_property do |property|
+        unless attributes.has_key?(property.name) || property.default.nil?
+          attribute_will_change!(property.name) if add_defaults_to_changes
+          attributes[property.name] = property.default
+        end
       end
+    end
+
+    def relationship_definition_for(name)
+      relationships[name] if relationships && relationships.has_attribute?(name)
+    end
+
+    def included_data_for(name, relationship_definition)
+      last_result_set.included.data_for(name, relationship_definition)
+    end
 
-      if association = association_for(method)
-        # look for a defined relationship url
-        if relationship_definitions["links"] && url = relationship_definitions["links"]["related"]
-          return association.data(url)
+    def relationship_data_for(name, relationship_definition)
+      # look in included data
+      if relationship_definition.key?("data")
+        if relationships.attribute_changed?(name)
+          return relation_objects_for(name, relationship_definition)
+        else
+          return included_data_for(name, relationship_definition)
         end
       end
-      nil
+
+      return unless links = relationship_definition["links"]
+      return unless url = links["related"]
+
+      association_for(name).data(url)
+    end
+
+    def relation_objects_for(name, relationship_definition)
+      data = relationship_definition["data"]
+      assoc = association_for(name)
+      return if data.nil? || assoc.nil?
+      assoc.load_records(data)
+    end
+
+    def method_missing(method, *args)
+      relationship_definition = relationship_definition_for(method)
+
+      return super unless relationship_definition
+
+      relationship_data_for(method, relationship_definition)
     end
 
     def respond_to_missing?(symbol, include_all = false)
@@ -497,12 +632,27 @@ module JsonApiClient
       end
     end
 
+    def non_serializing_attributes
+      self.class.read_only_attributes
+    end
+
     def attributes_for_serialization
-      attributes.except(*self.class.read_only_attributes).slice(*changed)
+      attributes.except(*non_serializing_attributes).slice(*changed)
     end
 
     def relationships_for_serialization
       relationships.as_json_api
     end
+
+    def error_message_for(error)
+      error.error_msg
+    end
+
+    def fill_errors
+      last_result_set.errors.each do |error|
+        key = self.class.key_formatter.unformat(error.error_key)
+        errors.add(key, error_message_for(error))
+      end
+    end
   end
 end

data/lib/json_api_client/schema.rb

@@ -29,7 +29,7 @@ module JsonApiClient
 
       class Decimal
         def self.cast(value, _)
-          BigDecimal.new(value)
+          BigDecimal(value)
         end
       end
 
@@ -67,11 +67,11 @@ module JsonApiClient
       #      end
       #   end
       #
-      #   JsonApiClient::Schema::Types.register money: MyMoneyCaster
+      #   JsonApiClient::Schema::TypeFactory.register money: MyMoneyCaster
       #
       # You can setup several at once:
       #
-      #   JsonApiClient::Schema::Types.register money: MyMoneyCaster,
+      #   JsonApiClient::Schema::TypeFactory.register money: MyMoneyCaster,
       #                                         date: MyJsonDateTypeCaster
       #
       #

data/lib/json_api_client/utils.rb

@@ -2,10 +2,16 @@ module JsonApiClient
   module Utils
 
     def self.compute_type(klass, type_name)
+      return klass.custom_type_to_class.fetch(type_name).constantize if klass.custom_type_to_class.key?(type_name)
       # If the type is prefixed with a scope operator then we assume that
       # the type_name is an absolute reference.
       return type_name.constantize if type_name.match(/^::/)
 
+      # Check the klass association definitions
+      association_klass_match = klass.associations.find { |a| a.attr_name.to_s.singularize == type_name.underscore }
+      association_klass = association_klass_match.options[:class] if association_klass_match
+      return association_klass if association_klass
+
       # Build a list of candidates to search for
       candidates = []
       klass.name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
@@ -24,5 +30,24 @@ module JsonApiClient
       raise NameError, "uninitialized constant #{candidates.first}"
     end
 
+    def self.parse_includes(klass, *tables)
+      tables.map do |table|
+        case table
+        when Hash
+          table.map do |k, v|
+            parse_includes(klass, *v).map do |sub|
+              "#{k}.#{sub}"
+            end
+          end
+        when Array
+          table.map do |v|
+            parse_includes(klass, *v)
+          end
+        else
+          klass.key_formatter.format(table)
+        end
+      end.flatten
+    end
+
   end
-end
+end

data/lib/json_api_client/version.rb

@@ -1,3 +1,3 @@
 module JsonApiClient
-  VERSION = "1.5.2"
+  VERSION = "1.22.0"
 end

data/lib/json_api_client.rb

@@ -2,6 +2,7 @@ require 'faraday'
 require 'faraday_middleware'
 require 'json'
 require 'addressable/uri'
+require 'json_api_client/formatter'
 
 module JsonApiClient
   autoload :Associations, 'json_api_client/associations'
@@ -9,7 +10,6 @@ module JsonApiClient
   autoload :Connection, 'json_api_client/connection'
   autoload :Errors, 'json_api_client/errors'
   autoload :ErrorCollector, 'json_api_client/error_collector'
-  autoload :Formatter, 'json_api_client/formatter'
   autoload :Helpers, 'json_api_client/helpers'
   autoload :Implementation, 'json_api_client/implementation'
   autoload :IncludedData, 'json_api_client/included_data'
@@ -21,6 +21,7 @@ module JsonApiClient
   autoload :Paginating, 'json_api_client/paginating'
   autoload :Parsers, 'json_api_client/parsers'
   autoload :Query, 'json_api_client/query'
+  autoload :RequestParams, 'json_api_client/request_params'
   autoload :Resource, 'json_api_client/resource'
   autoload :ResultSet, 'json_api_client/result_set'
   autoload :Schema, 'json_api_client/schema'