jsonapionify 0.9.0 → 0.9.1

data/lib/jsonapionify/api/base/resource_definitions.rb

@@ -17,33 +17,46 @@ module JSONAPIonify::Api
       klass = Class.new(resource_class, &resource_definitions[type]).set_type(type)
       param(:fields, type)
       const_set const_name, klass
-    rescue Errors::ResourceNotFound => e
-      raise e if resources_loaded?
-      load_resources
-      retry
+    rescue NameError => e
+      raise e unless e.instance_of?(NameError)
+      raise Errors::ResourceNotFound, "Resource not defined: #{type}"
     end
 
     def resource_defined?(name)
+      load_resources
       !!resource_definitions[name]
     end
 
     def resources
+      load_resources
       resource_definitions.map do |name, _|
         resource(name)
       end
     end
 
-    def define_resource(name, &block)
-      const_name = name.to_s.camelcase + 'Resource'
-      remove_const(const_name) if const_defined? const_name
-      resource_definitions[name.to_sym] = block
-    end
-
-    def extend_resource(name, &block)
-      old                               = resource_definitions[name.to_sym]
-      resource_definitions[name.to_sym] = proc do
-        [old, block].each { |b| class_eval(&b) }
-      end
+    def define_resource(name, extend: nil, &block)
+      resource_definitions[name.to_sym] =
+        if extend
+          sup = superclass
+          cur = self
+          proc do
+            extend_def =
+              if name.to_sym == extend.to_sym && sup.respond_to?(:resource)
+                sup.resource(extend)
+                sup.resource_definitions[extend.to_sym]
+              else
+                cur.resource(extend)
+                cur.resource_definitions[extend.to_sym]
+              end
+            class_eval &extend_def
+            class_eval &block
+          end
+        else
+          block
+        end
+      const_name                        = name.to_s.camelcase + 'Resource'
+      remove_const(const_name) if const_defined? const_name, false
+      name
     end
 
   end

data/lib/jsonapionify/api/base.rb

@@ -29,6 +29,12 @@ module JSONAPIonify::Api
       end
     end
 
+    def self.cache_key(**options)
+      Base64.urlsafe_encode64(
+        { **options, dsl: JSONAPIonify.digest, api: signature, }.to_json
+      )
+    end
+
     def self.resource_class
       if const_defined?(:ResourceBase, false)
         const_get(:ResourceBase, false)

data/lib/jsonapionify/api/context.rb

@@ -1,14 +1,27 @@
 module JSONAPIonify::Api
-  class Context < Struct.new :block, :readonly
+  class Context
+
+    def initialize(readonly: false, persisted: false, existing_context: nil, &block)
+      @readonly         = readonly
+      @persisted        = persisted
+      @existing_context = existing_context
+      @block            = block
+    end
 
     def call(instance, delegate)
-      block = self.block || proc {}
-      instance.instance_exec(delegate, &block)
+      existing_context = @existing_context || proc {}
+      existing_block   = proc { existing_context.call(instance, delegate) }
+      block            = @block || proc {}
+      instance.instance_exec(delegate, existing_block, &block)
     end
 
     def readonly?
-      !!readonly
+      !!@readonly
+    end
+
+    def persisted?
+      !!@persisted
     end
 
   end
-end
+end

data/lib/jsonapionify/api/context_delegate.rb

@@ -1,15 +1,22 @@
 module JSONAPIonify::Api
   class ContextDelegate
     class Mock
-      def method_missing(*args, &block)
+      def initialize(**attrs)
+        attrs.each do |attr, value|
+          define_singleton_method(attr) { value }
+        end
+      end
+
+      def method_missing(*)
         self
       end
     end
 
-    def initialize(request, instance, definitions)
-      memo         = {}
-      delegate     = self
-      @definitions = definitions
+    def initialize(request, instance, definitions, **overrides)
+      memo           = {}
+      persisted_memo = {}
+      delegate       = self
+      @definitions   = definitions
 
       define_singleton_method :request do
         request
@@ -27,13 +34,23 @@ module JSONAPIonify::Api
         memo.delete(key)
       end
 
+      define_singleton_method(:clear) do
+        memo.clear
+      end
+
       definitions.each do |name, context|
         define_singleton_method name do
-          memo[name] ||= context.call(instance, delegate)
+          return persisted_memo[name] if persisted_memo.has_key? name
+          (context.persisted? ? persisted_memo : memo)[name] ||=
+            if overrides.has_key?(name)
+              overrides[name]
+            else
+              context.call(instance, delegate)
+            end
         end
 
         define_singleton_method "#{name}=" do |value|
-          memo[name] = value
+          persisted_memo[name] = value
         end unless context.readonly?
       end
     end

data/lib/jsonapionify/api/errors.rb

@@ -6,6 +6,8 @@ module JSONAPIonify::Api
     RequestError         = Class.new JSONAPIonifyError
     CacheHit             = Class.new JSONAPIonifyError
     DoubleCacheError     = Class.new JSONAPIonifyError
+    DoubleRespondError   = Class.new JSONAPIonifyError
     InvalidCursor        = Class.new JSONAPIonifyError
+    MissingContentType   = Class.new JSONAPIonifyError
   end
 end

data/lib/jsonapionify/api/errors_object.rb

@@ -33,15 +33,16 @@ module JSONAPIonify
         end
       end
 
-      def evaluate(*args, error_block:, runtime_block:, backtrace: nil)
-        backtrace ||= caller
-        error     = Structure::Objects::Error.new
-        evaluator = Evaluator.new(error)
+      def evaluate(*args, error_block:, runtime_block: nil, backtrace: nil)
+        backtrace     ||= caller
+        runtime_block ||= proc {}
+        error         = Structure::Objects::Error.new
+        evaluator     = Evaluator.new(error)
         collection << error
         [runtime_block, error_block].each do |block|
           evaluator.instance_exec(*args, &block) if block
         end
-        unless ENV['RACK_ENV'] == 'production'
+        if JSONAPIonify.show_backtrace == true
           error[:meta]             ||= {}
           error[:meta][:backtrace] = backtrace
         end

data/lib/jsonapionify/api/relationship/blocks.rb

@@ -38,4 +38,4 @@ module JSONAPIonify::Api
       end
     end
   end
-end
+end

data/lib/jsonapionify/api/relationship/many.rb

@@ -8,17 +8,28 @@ module JSONAPIonify::Api
         undef_method :read
       end
 
-      define_singleton_method(:show) do |**options, &block|
-        options[:prepend] = 'relationships'
+      define_singleton_method(:show) do |content_type: nil, callbacks: true, &block|
+        options = {
+          content_type: content_type,
+          callbacks:    callbacks,
+          cacheable:    true,
+          prepend:      'relationships'
+        }
         define_action(:show, 'GET', **options, &block).response status: 200 do |context|
           context.response_object[:data] = build_identifier_collection(context.collection)
           context.response_object.to_json
         end
       end
 
-      define_singleton_method(:replace) do |**options, &block|
-        options[:prepend] = 'relationships'
-        define_action(:replace, 'PATCH', '', true, :resource_identifier, **options, &block).response status: 200 do |context|
+      define_singleton_method(:replace) do |content_type: nil, callbacks: true, &block|
+        options = {
+          content_type:  content_type,
+          callbacks:     callbacks,
+          cacheable:     false,
+          prepend:       'relationships',
+          example_input: :resource_identifier
+        }
+        define_action(:replace, 'PATCH', **options, &block).response status: 200 do |context|
           context.owner_context.reset(:instance)
           context.reset(:collection)
           context.response_object[:data] = build_identifier_collection(context.collection)
@@ -26,9 +37,15 @@ module JSONAPIonify::Api
         end
       end
 
-      define_singleton_method(:add) do |**options, &block|
-        options[:prepend] = 'relationships'
-        define_action(:add, 'POST', '', true, :resource_identifier, **options, &block).response status: 200 do |context|
+      define_singleton_method(:add) do |content_type: nil, callbacks: true, &block|
+        options = {
+          content_type:  content_type,
+          callbacks:     callbacks,
+          cacheable:     false,
+          prepend:       'relationships',
+          example_input: :resource_identifier
+        }
+        define_action(:add, 'POST', **options, &block).response status: 200 do |context|
           context.owner_context.reset(:instance)
           context.reset(:collection)
           context.response_object[:data] = build_identifier_collection(context.collection)
@@ -36,9 +53,16 @@ module JSONAPIonify::Api
         end
       end
 
-      define_singleton_method(:remove) do |**options, &block|
+      define_singleton_method(:remove) do |content_type: nil, callbacks: true, &block|
+        options           = {
+          content_type:  content_type,
+          callbacks:     callbacks,
+          cacheable:     false,
+          prepend:       'relationships',
+          example_input: :resource_identifier
+        }
         options[:prepend] = 'relationships'
-        define_action(:remove, 'DELETE', '', true, :resource_identifier, **options, &block).response status: 200 do |context|
+        define_action(:remove, 'DELETE', **options, &block).response status: 200 do |context|
           context.owner_context.reset(:instance)
           context.reset(:collection)
           context.response_object[:data] = build_identifier_collection(context.collection)
@@ -47,7 +71,7 @@ module JSONAPIonify::Api
       end
 
       context :scope do |context|
-        context.owner_context.instance.send(rel.name)
+        instance_exec rel.name, context.owner, context, &rel.resolve
       end
 
       show

data/lib/jsonapionify/api/relationship/one.rb

@@ -9,17 +9,27 @@ module JSONAPIonify::Api
         undef_method :list
       end
 
-      define_singleton_method(:show) do |**options, &block|
-        options[:prepend] = 'relationships'
-        define_action(:show, 'GET', '', nil, :resource_identifier, **options, &block).response status: 200 do |context|
+      define_singleton_method(:show) do |content_type: nil, callbacks: true, &block|
+        options = {
+          content_type: content_type,
+          callbacks:    callbacks,
+          cacheable:    true,
+          prepend:      'relationships'
+        }
+        define_action(:show, 'GET', **options, &block).response status: 200 do |context|
           context.response_object[:data] = build_resource_identifier(context.instance)
           context.response_object.to_json
         end
       end
 
-      define_singleton_method(:replace) do |**options, &block|
-        options[:prepend] = 'relationships'
-        define_action(:replace, 'PATCH', '', nil, :resource_identifier, **options, &block).response status: 200 do |context|
+      define_singleton_method(:replace) do |content_type: nil, callbacks: true, &block|
+        options = {
+          content_type: content_type,
+          callbacks:    callbacks,
+          cacheable:    false,
+          prepend:      'relationships'
+        }
+        define_action(:replace, 'PATCH', **options, &block).response status: 200 do |context|
           context.owner_context.reset(:instance)
           context.reset(:instance)
           context.response_object[:data] = build_resource_identifier(context.instance)
@@ -28,7 +38,7 @@ module JSONAPIonify::Api
       end
 
       context :instance do |context|
-        context.owner_context.instance.send(rel.name)
+        instance_exec rel.name, context.owner, context, &rel.resolve
       end
 
       show

data/lib/jsonapionify/api/relationship.rb

@@ -23,18 +23,18 @@ module JSONAPIonify::Api
       end
 
       owner_context_proc = Proc.new do |request|
-        ContextDelegate.new(request, rel.owner.new, rel.owner.context_definitions)
+        rel.owner.new(request: request).exec { |c| c }
       end
 
-      context(:owner_context) do |context|
+      context(:owner_context, readonly: true, persisted: true) do |context|
         owner_context_proc.call(context.request)
       end
 
-      context(:owner) do |context|
+      context(:owner, readonly: true, persisted: true) do |context|
         context.owner_context.instance
       end
 
-      context(:id) do
+      context(:id, readonly: true, persisted: true) do
         nil
       end
 
@@ -62,13 +62,23 @@ module JSONAPIonify::Api
       end
     end
 
-    attr_reader :owner, :class_proc, :name
+    attr_reader :owner, :class_proc, :name, :resolve
 
-    def initialize(owner, name, resource: nil, &block)
+    def initialize(owner, name, resource: nil, includable: false, resolve: proc { |name, owner| owner.send(name) }, &block)
       @class_proc = block || proc {}
       @owner      = owner
       @name       = name
+      @includable = includable
       @resource   = resource || name
+      @resolve    = resolve
+    end
+
+    def options_json
+      {
+        name:              name,
+        type:              resource.type,
+        relationship_type: self.class.name.split(':').last.downcase
+      }
     end
 
     def documentation_object
@@ -97,5 +107,9 @@ module JSONAPIonify::Api
       owner.api.resource(@resource)
     end
 
+    def includable?
+      !!@includable
+    end
+
   end
 end

data/lib/jsonapionify/api/resource/builders.rb

@@ -1,51 +1,98 @@
 module JSONAPIonify::Api
   module Resource::Builders
     extend ActiveSupport::Concern
+    FALSEY_STRINGS = JSONAPIonify::FALSEY_STRINGS
+    TRUTHY_STRINGS = JSONAPIonify::TRUTHY_STRINGS
+    Structure      = JSONAPIonify::Structure
 
     module ClassMethods
-      def build_resource(request, instance, fields: api.fields, relationships: true, links: true)
-        relationships = false if JSONAPIonify::FALSEY_STRINGS.include? request.params['include-relationships']
+
+      def build_resource(
+        context,
+        instance,
+        fields:,
+        relationships: true,
+        links: true,
+        include_cursor: false, &block
+      )
+        example_id        = generate_id
+        include_rel_param = context.params['include-relationships']
+        relationships     = false if FALSEY_STRINGS.include?(include_rel_param)
         return nil unless instance
-        resource_url = build_url(request, instance)
+        resource_url = build_url(context, instance)
         id           = build_id(instance)
-        JSONAPIonify::Structure::Objects::Resource.new.tap do |resource|
+        Structure::Objects::Resource.new.tap do |resource|
           resource[:id]   = id
           resource[:type] = type
 
-          resource[:attributes] = fields[type.to_sym].each_with_object(JSONAPIonify::Structure::Objects::Attributes.new) do |member, attributes|
-            attributes[member.to_sym] = instance.public_send(member)
+          resource[:attributes]    = fields[type.to_sym].each_with_object(
+            Structure::Objects::Attributes.new
+          ) do |member, attributes|
+            attribute = self.attributes.find { |a| a.name == member.to_sym }
+            unless attribute.supports_read_for_action?(context.action_name, context)
+              error_block =
+                context.resource.class.error_definitions[:internal_server_error]
+              context.errors.evaluate(
+                name,
+                error_block:   error_block,
+                runtime_block: proc {}
+              )
+            end
+            attributes[member.to_sym] = attribute.resolve(
+              instance, context, example_id: example_id
+            )
           end
 
-          resource[:links]      = JSONAPIonify::Structure::Objects::Links.new(
+          resource[:links]         = Structure::Objects::Links.new(
             self: resource_url
           ) if links
 
           resource[:meta]          = {
-            cursor: build_cursor_from_instance(request, instance)
-          }
+            cursor: build_cursor_from_instance(context, instance)
+          } if include_cursor
+
+          resource[:relationships] = relationship_definitions.each_with_object(
+            Structure::Maps::Relationships.new
+          ) do |rel, hash|
+            hash[rel.name] = build_relationship(context, instance, rel.name)
+          end if relationships || context.includes.present?
 
-          resource[:relationships] = relationship_definitions.each_with_object(JSONAPIonify::Structure::Maps::Relationships.new) do |rel, hash|
-            hash[rel.name] = build_relationship(request, instance, rel.name)
-          end if relationships
+          block.call(resource, instance) if block
         end
       end
 
       def build_resource_identifier(instance)
-        JSONAPIonify::Structure::Objects::ResourceIdentifier.new(
+        Structure::Objects::ResourceIdentifier.new(
           id:   build_id(instance),
           type: type.to_s
         )
       end
 
-      def build_collection(request, collection, fields: api.fields)
-        relationships = JSONAPIonify::TRUTHY_STRINGS.include? request.params['include-relationships']
-        collection.each_with_object(JSONAPIonify::Structure::Collections::Resources.new) do |instance, resources|
-          resources << build_resource(request, instance, fields: fields, relationships: relationships)
+      def build_collection(
+        context,
+        collection,
+        fields:,
+        include_cursors: false,
+        &block
+      )
+        include_rel_param = context.params['include-relationships']
+        relationships     = TRUTHY_STRINGS.include? include_rel_param
+        collection.each_with_object(
+          Structure::Collections::Resources.new
+        ) do |instance, resources|
+          resources << build_resource(
+            context,
+            instance,
+            fields:         fields,
+            relationships:  relationships,
+            include_cursor: include_cursors,
+            &block
+          )
         end
       end
 
-      def build_cursor_from_instance(request, instance)
-        sort_string       = request.params['sort']
+      def build_cursor_from_instance(context, instance)
+        sort_string       = context.params['sort']
         sort_fields       = sort_fields_from_sort_string(sort_string)
         attrs_with_values = sort_fields.each_with_object({}) do |field, hash|
           hash[field.name] = instance.send(field.name)
@@ -60,23 +107,25 @@ module JSONAPIonify::Api
       end
 
       def build_identifier_collection(collection)
-        collection.each_with_object(JSONAPIonify::Structure::Collections::ResourceIdentifiers.new) do |instance, resource_identifiers|
+        collection.each_with_object(
+          JSONAPIonify::Structure::Collections::ResourceIdentifiers.new
+        ) do |instance, resource_identifiers|
           resource_identifiers << build_resource_identifier(instance)
         end
       end
 
-      def build_relationship(request, instance, name, links: true, data: false)
-        resource_url = build_url(request, instance)
+      def build_relationship(context, instance, name, links: true, data: false)
+        resource_url = build_url(context, instance)
         relationship = self.relationship(name)
         JSONAPIonify::Structure::Objects::Relationship.new.tap do |rel|
           rel[:links] = relationship.build_links(resource_url) if links
-          if data
+          if data || context.includes.present?
             rel[:data] =
-              if relationship < Resource::RelationshipToMany
+              if relationship.rel.is_a? Relationship::Many
                 instance.send(name).map do |child|
                   relationship.build_resource_identifier(child)
                 end
-              elsif relationship < Resource::RelationshipToOne
+              elsif relationship.rel.is_a? Relationship::One
                 value = instance.send(name)
                 relationship.build_resource_identifier value if value
               end
@@ -84,15 +133,15 @@ module JSONAPIonify::Api
         end
       end
 
-      def build_url(request, instance = nil)
-        URI.parse(request.root_url).tap do |uri|
+      def build_url(context, instance = nil)
+        URI.parse(context.request.root_url).tap do |uri|
           uri.path      =
             if instance
               File.join(uri.path, type, build_id(instance))
             else
-              File.join(request.root_url, type)
+              File.join(context.request.root_url, type)
             end
-          sticky_params = self.sticky_params(request.params)
+          sticky_params = self.sticky_params(context.params)
           uri.query     = sticky_params.to_param if sticky_params.present?
         end.to_s
       end
@@ -103,7 +152,9 @@ module JSONAPIonify::Api
     end
 
     included do
-      delegate *(ClassMethods.instance_methods - JSONAPIonify::Api::Resource::Builders.instance_methods), to: :class
+      delegated_methods = ClassMethods.instance_methods -
+        JSONAPIonify::Api::Resource::Builders.instance_methods
+      delegate(*delegated_methods, to: :class)
     end
 
   end

data/lib/jsonapionify/api/resource/caching.rb

@@ -0,0 +1,28 @@
+module JSONAPIonify::Api
+  module Resource::Caching
+    def cache key, **options
+      raise Errors::DoubleCacheError, "Cache was already called for this action" if @cache_called
+      @cache_called = true
+      @cache_options.merge! options
+
+      # Build the cache key, and obscure it.
+      @__context.meta[:cache_key] = @cache_options[:key] = cache_key(
+        path:   @__context.request.path,
+        accept: @__context.request.accept,
+        params: @__context.params,
+        key:    key
+      )
+      # If the cache exists, then fail to cache miss
+      if self.class.cache_store.exist?(@cache_options[:key]) && !@__context.invalidate_cache?
+        raise Errors::CacheHit, @cache_options[:key]
+      end
+    end
+
+    def cache_key(**options)
+      self.class.cache_key(
+        **options,
+        action_name: action_name
+      )
+    end
+  end
+end

data/lib/jsonapionify/api/resource/caller.rb

@@ -0,0 +1,61 @@
+module JSONAPIonify::Api
+  module Resource::Caller
+    def call
+      do_respond = proc { __respond }
+      do_request = proc { __request }
+      response   = @callbacks ? run_callbacks(:request, @__context, &do_request) : do_request.call
+    rescue Errors::RequestError => e
+      raise e unless errors.present?
+      response = error_response
+    rescue Errors::CacheHit
+      JSONAPIonify.logger.info "Cache Hit: #{@cache_options[:key]}"
+      response = self.class.cache_store.read @cache_options[:key]
+    rescue Exception => exception
+      response = rescued_response exception, @__context, do_respond
+    ensure
+      self.class.cache_store.delete @cache_options[:key] unless response[0] < 300
+    end
+
+    def response_definition
+      action.responses.find { |response| response.accept_with_matcher? @__context } ||
+        action.responses.find { |response| response.accept_with_header? @__context } ||
+        error_now(:not_acceptable)
+    end
+
+    private
+
+    def __commit
+      instance_exec(@__context, &action.block)
+      halt if errors.present?
+    end
+
+    def __commit_and_respond
+      do_respond = proc { __respond }
+      do_commit  = proc { __commit }
+      halt if errors.present?
+      action.name && @callbacks ? run_callbacks("commit_#{action.name}", @__context, &do_commit) : do_commit.call
+      @callbacks ? run_callbacks(:response, @__context, &do_respond) : do_respond.call
+    end
+
+    def __request
+      do_commit_and_respond = proc { __commit_and_respond }
+      action.name && @callbacks ? run_callbacks(action.name, @__context, &do_commit_and_respond) : do_commit_and_respond.call
+    end
+
+    def __respond(**options)
+      raise Errors::DoubleRespondError if @response_called
+      @response_called = true
+      response_definition.call(self, @__context, **options).tap do |status, headers, body|
+        halt if errors.present?
+        if response_definition.cacheable && @cache_options.present?
+          JSONAPIonify.logger.info "Cache Miss: #{@cache_options[:key]}"
+          self.class.cache_store.write(
+            @cache_options[:key],
+            [status, headers, body.body],
+            **@cache_options.except(:key)
+          )
+        end
+      end
+    end
+  end
+end