jsonapionify 0.0.1.pre

data/lib/jsonapionify/api/resource/definitions/actions.rb

@@ -0,0 +1,196 @@
+require 'active_support/core_ext/array/wrap'
+
+module JSONAPIonify::Api
+  module Resource::Definitions::Actions
+    ActionNotFound = Class.new StandardError
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_array_attribute :action_definitions
+        inherited_hash_attribute :callbacks
+
+        def self.inherited(subclass)
+          super
+          callbacks.each do |action_name, klass|
+            subclass.callbacks[action_name] = Class.new klass
+          end
+        end
+      end
+    end
+
+    def list(**options, &block)
+      define_action(:list, 'GET', **options, &block).tap do |action|
+        action.response status: 200 do |context|
+          context.response_object[:data] = build_collection(
+            context.request,
+            context.response_collection,
+            fields: context.fields
+          )
+          context.meta[:total_count]     = context.collection.count
+          context.response_object.to_json
+        end
+      end
+    end
+
+    def index(**options, &block)
+      warn 'the `index` action will soon be deprecated, use `list` instead!'
+      list(**options, &block)
+    end
+
+    def create(**options, &block)
+      define_action(:create, 'POST', **options, &block).tap do |action|
+        action.response status: 201 do |context|
+          context.response_object[:data] = build_resource(context.request, context.instance, fields: context.fields)
+          context.response_object.to_json
+        end
+      end
+    end
+
+    def read(**options, &block)
+      define_action(:read, 'GET', '/:id', **options, &block).tap do |action|
+        action.response status: 200 do |context|
+          context.response_object[:data] = build_resource(context.request, context.instance, fields: context.fields)
+          context.response_object.to_json
+        end
+      end
+    end
+
+    def update(**options, &block)
+      define_action(:update, 'PATCH', '/:id', **options, &block).tap do |action|
+        action.response status: 200 do |context|
+          context.response_object[:data] = build_resource(context.request, context.instance, fields: context.fields)
+          context.response_object.to_json
+        end
+      end
+    end
+
+    def delete(**options, &block)
+      define_action(:delete, 'DELETE', '/:id', **options, &block).tap do |action|
+        action.response status: 204
+      end
+    end
+
+    def process(request)
+      path_actions = self.path_actions(request)
+      if request.options? && path_actions.present?
+        Action.stub do
+          headers['Allow'] = path_actions.map(&:request_method).join(', ')
+          response(status: 200, accept: '*/*')
+        end.call(self, request)
+      elsif (action = find_supported_action(request))
+        action.call(self, request)
+      elsif (rel = find_supported_relationship(request))
+        relationship(rel.name).process(request)
+      else
+        no_action_response(request).call(self, request)
+      end
+    end
+
+    def before(action_name = nil, &block)
+      if action_name == :index
+        warn 'the `index` action will soon be deprecated, use `list` instead!'
+        action_name = :list
+      end
+      return base_callbacks.before_request(&block) if action_name == nil
+      callbacks_for(action_name).before_request(&block)
+    end
+
+    def base_callbacks
+      resource       = self
+      callbacks['*'] ||= Class.new do
+        def self.context(*)
+        end
+
+        include Resource::ErrorHandling
+
+        define_singleton_method(:error_definitions) do
+          resource.error_definitions
+        end
+
+        include JSONAPIonify::Callbacks
+        define_callbacks :request
+      end
+    end
+
+    def callbacks_for(action_name)
+      resource               = self
+      callbacks[action_name] ||= Class.new(base_callbacks)
+    end
+
+    def define_action(*args, **options, &block)
+      Action.new(*args, **options, &block).tap do |new_action|
+        action_definitions.delete new_action
+        action_definitions << new_action
+      end
+    end
+
+    def find_supported_action(request)
+      actions.find do |action|
+        action.supports?(request, base_path, path_name, supports_path?)
+      end
+    end
+
+    def no_action_response(request)
+      if request_method_actions(request).present?
+        Action.stub { error_now :unsupported_media_type }
+      elsif (path_actions = self.path_actions(request)).present?
+        Action.stub do
+          headers['Allow'] = path_actions.map(&:request_method).join(', ')
+          error_now :method_not_allowed
+        end
+      else
+        Action.stub { error_now :not_found }
+      end
+    end
+
+    def path_actions(request)
+      actions.select do |action|
+        action.supports_path?(request, base_path, path_name, supports_path?)
+      end
+    end
+
+    def request_method_actions(request)
+      path_actions(request).select do |action|
+        action.supports_request_method?(request)
+      end
+    end
+
+    def find_supported_relationship(request)
+      relationship_definitions.find do |rel|
+        relationship(rel.name).path_actions(request).present?
+      end
+    end
+
+    def remove_action(*names)
+      if names.include? :index
+        warn 'the `index` action will soon be deprecated, use `list` instead!'
+        names << :list
+      end
+      action_definitions.delete_if do |action_definition|
+        names.include? action_definition.name
+      end
+    end
+
+    def actions
+      action_definitions.select do |action|
+        action.only_associated == false ||
+          (respond_to?(:rel) && action.only_associated == true)
+      end
+    end
+
+    private
+
+    def base_path
+      ''
+    end
+
+    def supports_path?
+      true
+    end
+
+    def path_name
+      type.to_s
+    end
+  end
+end

data/lib/jsonapionify/api/resource/definitions/attributes.rb

@@ -0,0 +1,51 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Attributes
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        extend JSONAPIonify::Types
+        inherited_array_attribute :attributes
+        delegate :attributes, to: :class
+
+        context(:fields, readonly: true) do |context|
+          should_error = false
+          fields       = (context.request.params['fields'] || {}).each_with_object(self.class.api.fields) do |(type, fields), field_map|
+            type_sym            = type.to_sym
+            field_map[type_sym] =
+              fields.to_s.split(',').map(&:to_sym).each_with_object([]) do |field, field_list|
+                attribute = self.class.api.resource(type_sym).attributes.find do |attribute|
+                  attribute.read? && attribute.name == field
+                end
+                attribute ? field_list << attribute.name : error(:field_not_permitted, type, field) && (should_error = true)
+              end
+          end
+          raise error_exception if should_error
+          fields
+        end
+      end
+    end
+
+    def id(sym)
+      define_singleton_method :id_attribute do
+        sym
+      end
+    end
+
+    def attribute(name, type, description = '', **options)
+      Attribute.new(name, type, description, **options).tap do |new_attribute|
+        attributes.delete(new_attribute)
+        attributes << new_attribute
+      end
+    end
+
+    def fields
+      attributes.select(&:read?).map(&:name)
+    end
+
+    def field_valid?(name)
+      fields.include? name.to_sym
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/contexts.rb

@@ -0,0 +1,16 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Contexts
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_hash_attribute :context_definitions
+      end
+    end
+
+    def context(name, readonly: false, &block)
+      self.context_definitions[name.to_sym] = Context.new(block, readonly)
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/helpers.rb

@@ -0,0 +1,9 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Helpers
+
+    def helper(name, &block)
+      define_method(name, &block)
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/pagination.rb

@@ -0,0 +1,79 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Pagination
+
+    class PaginationLinksDelegate
+
+      def initialize(request, links)
+        @request = request
+        @links   = links
+      end
+
+      %i{first last next prev}.each do |method|
+        define_method method do |**options|
+          @links[method] = URI.parse(@request.url).tap do |uri|
+            page_params = { page: options }.deep_stringify_keys
+            uri.query   = @request.params.deep_merge(page_params).to_param
+          end.to_s
+        end
+      end
+
+    end
+
+    STRATEGIES         = {
+      active_record: proc do |collection, params, links|
+        page_number = Integer(params['number'] || 1)
+        page_number = 1 if page_number < 1
+        page_size   = Integer(params['size'] || 50)
+        raise PaginationError if page_size > 250
+        first_page = 1
+        last_page  = (collection.count / page_size).ceil
+        last_page  = 1 if last_page == 0
+
+        links.first number: 1 unless page_number == first_page
+        links.last number: last_page unless page_number == last_page
+        links.prev number: page_number - 1 unless page_number <= first_page
+        links.next number: page_number + 1 unless page_number >= last_page
+
+        slice_start = (page_number - 1) * page_size
+        collection.limit(page_size).offset(slice_start)
+      end,
+      enumerable:    proc do |collection, params, links|
+        page_number = Integer(params['number'] || 1)
+        page_number = 1 if page_number < 1
+        page_size   = Integer(params['size'] || 50)
+        first_page  = 1
+        last_page   = (collection.count / page_size).ceil
+        last_page   = 1 if last_page == 0
+
+        links.first number: 1 unless page_number == first_page
+        links.last number: last_page unless page_number == last_page
+        links.prev number: page_number - 1 unless page_number <= first_page
+        links.next number: page_number + 1 unless page_number >= last_page
+
+        slice_start = (page_number - 1) * page_size
+
+        collection.slice(slice_start, page_size)
+      end
+    }
+    STRATEGIES[:array] = STRATEGIES[:enumerable]
+    DEFAULT            = STRATEGIES[:enumerable]
+
+    def pagination(*params, strategy: nil, &block)
+      params = %i{number size} unless block
+      params.each { |p| param :page, p, actions: %i{list} }
+      context :paginated_collection do |context|
+        unless (actual_block = block)
+          actual_strategy = strategy || self.class.default_strategy
+          actual_block    = actual_strategy ? STRATEGIES[actual_strategy] : DEFAULT
+        end
+        Object.new.instance_exec(
+          context.respond_to?(:sorted_collection) ? context.sorted_collection : context.collection,
+          context.request.params['page'] || {},
+          PaginationLinksDelegate.new(context.request, context.links),
+          &actual_block
+        )
+      end
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/params.rb

@@ -0,0 +1,49 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Params
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_hash_attribute :param_definitions
+
+        before do |context|
+          context.params # pull params so they verify
+        end
+
+        context(:params, readonly: true) do |context|
+          should_error    = false
+
+          # Check for validity
+          params          = self.class.param_definitions.select do |_, v|
+            v.actions.blank? || v.actions.include?(action_name)
+          end
+          required_params = params.select do |_, v|
+            v.required
+          end
+          if (invalid_params = ParamOptions.invalid_parameters(context.request.params, params.values.map(&:keypath))).present?
+            should_error = true
+            invalid_params.each do |string|
+              error :parameter_not_permitted, string
+            end
+          end
+
+          # Check for requirement
+          if (missing_params = ParamOptions.missing_parameters(context.request.params, required_params.values.map(&:keypath))).present?
+            error :parameters_missing, missing_params
+          end
+
+          raise error_exception if should_error
+
+          # Return the params
+          context.request.params
+        end
+
+      end
+    end
+
+    def param(*keypath, **options)
+      param_definitions[keypath] = ParamOptions.new(*keypath, **options)
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/relationships.rb

@@ -0,0 +1,42 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Relationships
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_array_attribute :relationship_definitions
+      end
+    end
+
+    def relates_to_many(name, resource: nil, &block)
+      define_relationship(name, Relationship::Many, resource: resource, &block)
+    end
+
+    def relates_to_one(name, resource: nil, &block)
+      define_relationship(name, Relationship::One, resource: resource, &block)
+    end
+
+    def define_relationship(name, klass, resource: nil, &block)
+      const_name = name.to_s.camelcase + 'Relationship'
+      remove_const(const_name) if const_defined? const_name
+      klass.new(self, name, resource: resource, &block).tap do |new_relationship|
+        relationship_definitions.delete new_relationship
+        relationship_definitions << new_relationship
+      end
+    end
+
+    def relationships
+      relationship_definitions
+    end
+
+    def relationship(name)
+      name       = name.to_sym
+      const_name = name.to_s.camelcase + 'Relationship'
+      return const_get(const_name, false) if const_defined? const_name
+      relationship_definition = relationship_definitions.find { |rel| rel.name == name }
+      raise Errors::RelationshipNotDefined, "Relationship not defined: #{name}" unless relationship_definition
+      const_set const_name, relationship_definition.resource_class
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/request_headers.rb

@@ -0,0 +1,103 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::RequestHeaders
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_hash_attribute :request_header_definitions
+
+        # Standard HTTP Headers
+        # https://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Request_fields
+        request_header 'accept'
+        request_header 'accept-charset'
+        request_header 'accept-encoding'
+        request_header 'accept-language'
+        request_header 'accept-datetime'
+        request_header 'authorization'
+        request_header 'cache-control'
+        request_header 'connection'
+        request_header 'cookie'
+        request_header 'content-length'
+        request_header 'content-md5'
+        request_header 'content-type'
+        request_header 'date'
+        request_header 'expect'
+        request_header 'from'
+        request_header 'host'
+        request_header 'if-match'
+        request_header 'if-modified-since'
+        request_header 'if-none-match'
+        request_header 'if-range'
+        request_header 'if-unmodified-since'
+        request_header 'max-forwards'
+        request_header 'origin'
+        request_header 'pragma'
+        request_header 'proxy-authorization'
+        request_header 'range'
+        request_header 'referer'
+        request_header 'te'
+        request_header 'user-agent'
+        request_header 'upgrade'
+        request_header 'via'
+        request_header 'warning'
+
+        # Non-Standard, but widely used HTTP headers
+        request_header 'x-requested-with'
+        request_header 'dnt'
+        request_header 'x-forwarded-for'
+        request_header 'x-forwarded-host'
+        request_header 'x-forwarded-proto'
+        request_header 'front-end-https'
+        request_header 'x-att-device-id'
+        request_header 'x-wap-profile'
+        request_header 'proxy-connection'
+        request_header 'x-uidh'
+        request_header 'upgrade-insecure-requests'
+
+        # Don't allow method overrides
+        # request_header 'x-http-method-override'
+
+        # Don't allow CSRF tokens, as they should not be used
+        # in the api by default
+        # request_header 'x-csrf-token'
+
+        before do |context|
+          context.request_headers # pull request_headers so they verify
+        end
+
+        context(:request_headers) do |context|
+          should_error     = false
+
+          # Check for validity
+          headers          = self.class.request_header_definitions.select do |_, v|
+            v.actions.blank? || v.actions.include?(action_name)
+          end
+          required_headers = headers.select do |_, v|
+            v.required
+          end
+
+          if (invalid_keys = context.request.headers.keys.map(&:downcase) - headers.keys.map(&:downcase)).present?
+            should_error = true
+            invalid_keys.each do |key|
+              error :header_not_permitted, key
+            end
+          end
+
+          if (missing_keys = required_headers.keys.map(&:downcase) - context.request.headers.keys.map(&:downcase)).present?
+            should_error = true
+            error :headers_missing, missing_keys
+          end
+
+          raise error_exception if should_error
+
+          context.request.headers
+        end
+      end
+    end
+
+    def request_header(name, **options)
+      request_header_definitions[name] = HeaderOptions.new(name, **options)
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/response_headers.rb

@@ -0,0 +1,22 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::ResponseHeaders
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_hash_attribute :response_header_definitions
+
+        context(:response_headers) do |context|
+          self.class.response_header_definitions.each_with_object({}) do |(name, block), headers|
+            headers[name.to_s] = instance_exec(context, &block)
+          end
+        end
+      end
+    end
+
+    def response_header(name, &block)
+      self.response_header_definitions[name] = block
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/scopes.rb

@@ -0,0 +1,50 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Scopes
+
+    def self.extended(klass)
+      klass.class_eval do
+        id :id
+        scope { raise NotImplementedError, 'scope not implemented' }
+        collection { raise NotImplementedError, 'collection not implemented' }
+        instance { raise NotImplementedError, 'instance not implemented' }
+        new_instance { raise NotImplementedError, 'new instance not implemented' }
+        param :include
+      end
+    end
+
+    def scope(&block)
+      define_singleton_method(:current_scope) do
+        Object.new.instance_eval(&block)
+      end
+      context :scope do
+        self.class.current_scope
+      end
+    end
+
+    alias_method :resource_class, :scope
+
+    def instance(&block)
+      define_singleton_method(:find_instance) do |id|
+        Object.new.instance_exec(current_scope, id, &block)
+      end
+      context :instance do |context|
+        self.class.find_instance(context.id)
+      end
+    end
+
+    def collection(&block)
+      context :collection do |context|
+        Object.new.instance_exec(context.scope, context, &block)
+      end
+    end
+
+    def new_instance(&block)
+      define_singleton_method(:build_instance) do
+        Object.new.instance_exec(current_scope, &block)
+      end
+      context :new_instance do |context|
+        Object.new.instance_exec(context.scope, context, &block)
+      end
+    end
+  end
+end