jsonapi-consumer 0.1.1 → 1.0.0

data/lib/jsonapi/consumer/resource.rb

@@ -1,92 +1,552 @@
+require 'forwardable'
+require 'active_support/all'
+require 'active_model'
+
 module JSONAPI::Consumer
-  module Resource
-    extend ActiveSupport::Concern
+  class Resource
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    include ActiveModel::Serialization
 
-    included do
-      extend ActiveModel::Naming
+    include Helpers::DynamicAttributes
+    include Helpers::Dirty
 
-      attr_reader :errors
-      class_attribute :host, :connection, :ssl
-    end
+    attr_accessor :last_result_set,
+                  :links,
+                  :relationships
+    class_attribute :site,
+                    :primary_key,
+                    :parser,
+                    :paginator,
+                    :connection_class,
+                    :connection_object,
+                    :connection_options,
+                    :query_builder,
+                    :linker,
+                    :relationship_linker,
+                    :read_only_attributes,
+                    :requestor_class,
+                    :associations,
+                    :json_key_format,
+                    :route_format,
+                    instance_accessor: false
+    self.primary_key          = :id
+    self.parser               = Parsers::Parser
+    self.paginator            = Paginating::Paginator
+    self.connection_class     = Connection
+    self.connection_options   = {}
+    self.query_builder        = Query::Builder
+    self.linker               = Linking::Links
+    self.relationship_linker  = Relationships::Relations
+    self.read_only_attributes = [:id, :type, :links, :meta, :relationships]
+    self.requestor_class      = Query::Requestor
+    self.associations         = []
+
+    #:underscored_key, :camelized_key, :dasherized_key, or custom
+    self.json_key_format = :underscored_key
+
+    #: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
+
+      # The table name for this resource. i.e. Article -> articles, Person -> people
+      #
+      # @return [String] The table name for this resource
+      def table_name
+        route_formatter.format(resource_name.pluralize)
+      end
+
+      # The name of a single resource. i.e. Article -> article, Person -> person
+      #
+      # @return [String]
+      def resource_name
+        name.demodulize.underscore
+      end
+
+      # Specifies the JSON API resource type. By default this is inferred
+      # from the resource class name.
+      #
+      # @return [String] Resource path
+      def type
+        table_name
+      end
+
+      # Specifies the relative path that should be used for this resource;
+      # by default, this is inferred from the resource class name.
+      #
+      # @return [String] Resource path
+      def resource_path
+        table_name
+      end
+
+      # Load a resource object from attributes and consider it persisted
+      #
+      # @return [Resource] Persisted resource object
+      def load(params)
+        new(params).tap do |resource|
+          resource.mark_as_persisted!
+          resource.clear_changes_information
+        end
+      end
+
+      # Return/build a connection object
+      #
+      # @return [Connection] The connection to the json api server
+      def connection(rebuild = false, &block)
+        _build_connection(rebuild, &block)
+        connection_object
+      end
+
+      # Param names that will be considered path params. They will be used
+      # to build the resource path rather than treated as attributes
+      #
+      # @return [Array] Param name symbols of parameters that will be treated as path parameters
+      def prefix_params
+        _belongs_to_associations.map(&:param)
+      end
+
+      # Return the path or path pattern for this resource
+      def path(params = nil)
+        parts = [resource_path]
+        if params && _prefix_path.present?
+          path_params = params.delete(:path) || params
+          parts.unshift(_set_prefix_path(path_params.symbolize_keys))
+        else
+          parts.unshift(_prefix_path)
+        end
+        parts.reject!(&:blank?)
+        File.join(*parts)
+      rescue KeyError
+        raise ArgumentError, "Not all prefix parameters specified"
+      end
+
+      # Create a new instance of this resource class
+      #
+      # @param attributes [Hash] The attributes to create this resource with
+      # @return [Resource] The instance you tried to create. You will have to check the persisted state or errors on this object to see success/failure.
+      def create(attributes = {})
+        new(attributes).tap do |resource|
+          resource.save
+        end
+      end
+
+      # Within the given block, add these headers to all requests made by
+      # the resource class
+      #
+      # @param headers [Hash] The headers to send along
+      # @param block [Block] The block where headers will be set for
+      def with_headers(headers)
+        self._custom_headers = headers
+        yield
+      ensure
+        self._custom_headers = {}
+      end
+
+      # The current custom headers to send with any request made by this
+      # resource class. This supports inheritance so it only needs to be
+      # set on the base class.
+      #
+      # @return [Hash] Headers
+      def custom_headers
+        return _header_store.to_h if superclass == Object
+
+        superclass.custom_headers.merge(_header_store.to_h)
+      end
+
+      # Run a command wrapped in an Authorization header
+      #
+      def authorize_with(jwt, &block)
+        with_headers(authorization: %(Bearer #{jwt}), &block)
+      end
+
+      # Set the Authorization header to a JWT value
+      #
+      def authorize_with=(jwt)
+        if jwt.nil?
+          self._custom_headers = {authorization: nil}
+        else
+          self._custom_headers = {authorization: %(Bearer #{jwt})}
+        end
+      end
+
+      # Clears the Authorization header
+      #
+      def clear_authorization!
+        self.authorize_with = nil
+      end
+
+      # @return [String] The Authorization header
+      def authorized_as
+        custom_headers[:authorization]
+      end
+
+      # Returns based on the presence of an Authorization header
+      #
+      # @return [Boolean]
+      def authorized?
+        !custom_headers[:authorization].nil?
+      end
+
+      # Returns the requestor for this resource class
+      #
+      # @return [Requestor] The requestor for this resource class
+      def requestor
+        @requestor ||= requestor_class.new(self)
+      end
+
+      # Default attributes that every instance of this resource should be
+      # initialized with. Optionally, override this method in a subclass.
+      #
+      # @return [Hash] Default attributes
+      def default_attributes
+        {type: type}
+      end
+
+      # Returns the schema for this resource class
+      #
+      # @return [Schema] The schema for this resource class
+      def schema
+        @schema ||= Schema.new
+      end
+
+      def key_formatter
+        JSONAPI::Consumer::Formatter.formatter_for(json_key_format)
+      end
+
+      def route_formatter
+        JSONAPI::Consumer::Formatter.formatter_for(route_format)
+      end
+
+      protected
+
+      # Declares a new class/instance method that acts on the collection/member
+      #
+      # @param name [Symbol] the name of the endpoint
+      # @param options [Hash] endpoint options
+      # @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 :collection == options.delete(:on)
+          collection_endpoint(name, options)
+        else
+          member_endpoint(name, options)
+        end
+      end
+
+      # Declares a new class method that acts on the collection
+      #
+      # @param name [Symbol] the name of the endpoint and the method name
+      # @param options [Hash] endpoint options
+      # @option options [Symbol] :request_method The request method (:get, :post, etc)
+      def collection_endpoint(name, options = {})
+        metaclass = class << self
+          self
+        end
+        metaclass.instance_eval do
+          define_method(name) do |*params|
+            request_params = params.first || {}
+            requestor.custom(name, options, request_params)
+          end
+        end
+      end
 
-    include ObjectBuildConcern
-    include AttributesConcern
-    include AssociationConcern
-    include FindersConcern
-    include SerializerConcern
-    include ConnectionConcern
+      # Declares a new instance method that acts on the member object
+      #
+      # @param name [Symbol] the name of the endpoint and the method name
+      # @param options [Hash] endpoint options
+      # @option options [Symbol] :request_method The request method (:get, :post, etc)
+      def member_endpoint(name, options = {})
+        define_method name do |*params|
+          request_params = params.first || {}
+          request_params[self.class.primary_key] = attributes.fetch(self.class.primary_key)
+          self.class.requestor.custom(name, options, request_params)
+        end
+      end
 
-    module ClassMethods
-      def middleware(&block)
-        _connection(true, &block)
+      # Declares a new property by name
+      #
+      # @param name [Symbol] the name of the property
+      # @param options [Hash] property options
+      # @option options [Symbol] :type The property type
+      # @option options [Symbol] :default The default value for the property
+      def property(name, options = {})
+        schema.add(name, options)
       end
 
-      def json_key
-        self.name.demodulize.pluralize.underscore
+      # Declare multiple properties with the same optional options
+      #
+      # @param [Array<Symbol>] names
+      # @param options [Hash] property options
+      # @option options [Symbol] :type The property type
+      # @option options [Symbol] :default The default value for the property
+      def properties(*names)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+        names.each do |name|
+          property name, options
+        end
       end
 
-      def host
-        @host || raise(NotImplementedError, 'host was not set')
+      def _belongs_to_associations
+        associations.select{|association| association.is_a?(Associations::BelongsTo::Association) }
       end
 
-      def path
-        json_key
+      def _prefix_path
+        paths = _belongs_to_associations.map do |a|
+          a.to_prefix_path(route_formatter)
+        end
+
+        paths.join("/")
+      end
+
+      def _set_prefix_path(attrs)
+        paths = _belongs_to_associations.map do |a|
+          a.set_prefix_path(attrs, route_formatter)
+        end
+
+        paths.join("/")
       end
 
-      def ssl
-        {}
+      def _new_scope
+        query_builder.new(self)
       end
 
-    private
+      def _custom_headers=(headers)
+        _header_store.replace(headers)
+      end
 
-      def human_attribute_name(attr, options = {})
-        attr
+      def _header_store
+        Thread.current["json_api_client-#{resource_name}"] ||= {}
       end
 
-      def lookup_ancestors
-        [self]
+      def _build_connection(rebuild = false)
+        return connection_object unless connection_object.nil? || rebuild
+        self.connection_object = connection_class.new(connection_options.merge(site: site)).tap do |conn|
+          yield(conn) if block_given?
+        end
       end
     end
 
-    def initialize(params={})
-      (params || {}).slice(*association_names).each do |key, value|
-        send(:"#{key}=", value)
+    # Instantiate a new resource object
+    #
+    # @param params [Hash] Attributes, links, and relationships
+    def initialize(params = {})
+      @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 = self.class.default_attributes.merge(params)
+
+      self.class.schema.each_property do |property|
+        attributes[property.name] = property.default unless attributes.has_key?(property.name) || property.default.nil?
       end
 
-      self.attributes = params.except(*association_names) if params
-      @errors = ActiveModel::Errors.new(self)
-      super()
+      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
+    end
+
+    # Set the current attributes and try to save them
+    #
+    # @param attrs [Hash] Attributes to update
+    # @return [Boolean] Whether the update succeeded or not
+    def update_attributes(attrs = {})
+      self.attributes = attrs
+      save
+    end
+
+    # Alias to update_attributes
+    #
+    # @param attrs [Hash] Attributes to update
+    # @return [Boolean] Whether the update succeeded or not
+    def update(attrs = {})
+      update_attributes(attrs)
+    end
+
+    # Mark the record as persisted
+    def mark_as_persisted!
+      @persisted = true
+    end
+
+    # Whether or not this record has been persisted to the database previously
+    #
+    # @return [Boolean]
+    def persisted?
+      !!@persisted && has_attribute?(self.class.primary_key)
+    end
+
+    # Returns true if this is a new record (never persisted to the database)
+    #
+    # @return [Boolean]
+    def new_record?
+      !persisted?
     end
 
-    # Returns an Enumerable of all key attributes if any is set, regardless
-    # if the object is persisted or not.
-    # Returns nil if there are no key attributes.
+    # When we represent this resource as a relationship, we do so with id & type
     #
-    # (see ActiveModel::Conversion#to_key)
-    def to_key
-      to_param ? [to_param] : nil
+    # @return [Hash] Representation of this object as a relation
+    def as_relation
+      attributes.slice(:type, self.class.primary_key)
+    end
+
+    # When we represent this resource for serialization (create/update), we do so
+    # with this implementation
+    #
+    # @return [Hash] Representation of this object as JSONAPI object
+    def as_json_api(*)
+      attributes.slice(:id, :type).tap do |h|
+        relationships_for_serialization.tap do |r|
+          h[:relationships] = self.class.key_formatter.format_keys(r) unless r.empty?
+        end
+        h[:attributes] = self.class.key_formatter.format_keys(attributes_for_serialization)
+      end
+    end
+
+    def as_json(*)
+      attributes.slice(:id, :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
+      end
+    end
+
+    # Mark all attributes for this record as dirty
+    def set_all_dirty!
+      set_all_attributes_dirty
+      relationships.set_all_attributes_dirty if relationships
     end
 
-  private
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      super(context)
+    end
+
+    # Commit the current changes to the resource to the remote server.
+    # If the resource was previously loaded from the server, we will
+    # try to update the record. Otherwise if it's a new record, then
+    # we will try to create it
+    #
+    # @return [Boolean] Whether or not the save succeeded
+    def save
+      return false unless valid?
+
+      self.last_result_set = if persisted?
+        self.class.requestor.update(self)
+      else
+        self.class.requestor.create(self)
+      end
 
-    def read_attribute_for_validation(attr)
-      read_attribute(attr)
+      if last_result_set.has_errors?
+        fill_errors
+        false
+      else
+        self.errors.clear if self.errors
+        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
+        end
+        true
+      end
     end
 
-    def method_missing(method, *args, &block)
-      if respond_to_without_attributes?(method, true)
-        super
+    # Try to destroy this resource
+    #
+    # @return [Boolean] Whether or not the destroy succeeded
+    def destroy
+      self.last_result_set = self.class.requestor.destroy(self)
+      if last_result_set.has_errors?
+        fill_errors
+        false
       else
-        if method.to_s =~ /^(.*)=$/
-          set_attribute($1, args.first)
-        elsif has_attribute?(method)
-          read_attribute(method)
-        elsif has_association?(method)
-          read_assocation(method)
+        self.attributes.clear
+        true
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}:@attributes=#{attributes.inspect}>"
+    end
+
+    protected
+
+    def method_missing(method, *args)
+      association = association_for(method)
+
+      return super unless association || (relationships && relationships.has_attribute?(method))
+
+      return nil unless relationship_definitions = relationships[method]
+
+      # look in included data
+      if relationship_definitions.key?("data")
+        # included.data_for returns an array, if the association is a has_one, then pick the first, otherise return the whole array
+        if association.is_a?(JSONAPI::Consumer::Associations::HasOne::Association)
+          return last_result_set.included.data_for(method, relationship_definitions).try(:first)
         else
-          super
+          return last_result_set.included.data_for(method, relationship_definitions)
+        end
+      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)
         end
       end
+      nil
+    end
+
+    def respond_to_missing?(symbol, include_all = false)
+      return true if relationships && relationships.has_attribute?(symbol)
+      return true if association_for(symbol)
+      super
+    end
+
+    def set_attribute(name, value)
+      property = property_for(name)
+      value = property.cast(value) if property
+      super(name, value)
+    end
+
+    def has_attribute?(attr_name)
+      !!property_for(attr_name) || super
+    end
+
+    def property_for(name)
+      self.class.schema.find(name)
+    end
+
+    def association_for(name)
+      self.class.associations.detect do |association|
+        association.attr_name.to_s == self.class.key_formatter.unformat(name)
+      end
+    end
+
+    def attributes_for_serialization
+      attributes.except(*self.class.read_only_attributes).slice(*changed)
+    end
+
+    def relationships_for_serialization
+      relationships.as_json_api
+    end
+
+    def fill_errors
+      last_result_set.errors.each do |error|
+        key = self.class.key_formatter.unformat(error.error_key)
+        errors.add(key, error.error_msg)
+      end
     end
   end
 end

data/lib/jsonapi/consumer/result_set.rb

@@ -0,0 +1,25 @@
+require 'forwardable'
+
+module JSONAPI::Consumer
+  class ResultSet < Array
+    extend Forwardable
+
+    attr_accessor :errors,
+                  :record_class,
+                  :meta,
+                  :pages,
+                  :uri,
+                  :links,
+                  :implementation,
+                  :relationships,
+                  :included
+
+    # pagination methods are handled by the paginator
+    def_delegators :pages, :total_pages, :total_entries, :total_count, :offset, :per_page, :current_page, :limit_value, :next_page, :previous_page, :out_of_bounds?
+
+    def has_errors?
+      errors.present?
+    end
+
+  end
+end