sanger-jsonapi-resources 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bf908bb5423dd9c31362ed50c78a5089fd02fa120278d543d90d83d99690acb1
+  data.tar.gz: 1118019c84568daf2ee120327d821dc1e930d210947bf7c9ab0ff6006adec87e
+SHA512:
+  metadata.gz: bfff352e247bb4b77eab4df52557e91768498155f60084cb20b0e1e66b38a50f4199c07a27af97df97d9672394ff2cf7ef320bde343de7ebd206bb6fa899b4c0
+  data.tar.gz: cf361701487602881c1f2271165be8295f187cf520efcf3324a47b2265efc2926b5642dc33d6cf89da6a63daf196a863aa472ee59436db04ecd5647a64abb5d0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Larry Gebhardt
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,53 @@
+# JSONAPI::Resources [![Gem Version](https://badge.fury.io/rb/jsonapi-resources.svg)](https://badge.fury.io/rb/jsonapi-resources) [![Build Status](https://secure.travis-ci.org/cerebris/jsonapi-resources.svg?branch=beta)](http://travis-ci.org/cerebris/jsonapi-resources) [![Code Climate](https://codeclimate.com/github/cerebris/jsonapi-resources/badges/gpa.svg)](https://codeclimate.com/github/cerebris/jsonapi-resources)
+
+[![Join the chat at https://gitter.im/cerebris/jsonapi-resources](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/cerebris/jsonapi-resources?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+`JSONAPI::Resources`, or "JR", provides a framework for developing an API server that complies with the
+[JSON:API](http://jsonapi.org/) specification.
+
+Like JSON:API itself, JR's design is focused on the resources served by an API. JR needs little more than a definition
+of your resources, including their attributes and relationships, to make your server compliant with JSON API.
+
+JR is designed to work with Rails 4.2+, and provides custom routes, controllers, and serializers. JR's resources may be
+backed by ActiveRecord models or by custom objects.
+
+## Documentation
+
+Full documentation can be found at [http://jsonapi-resources.com](http://jsonapi-resources.com), including the [v0.9 beta Guide](http://jsonapi-resources.com/v0.9/guide/) specific to this version. 
+
+## Demo App
+
+We have a simple demo app, called [Peeps](https://github.com/cerebris/peeps), available to show how JR is used.
+
+## Client Libraries
+
+JSON:API maintains a (non-verified) listing of [client libraries](http://jsonapi.org/implementations/#client-libraries)
+which *should* be compatible with JSON:API compliant server implementations such as JR.
+
+## Installation
+
+Add JR to your application's `Gemfile`:
+
+    gem 'jsonapi-resources'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jsonapi-resources
+
+**For further usage see the [v0.9 beta Guide](http://jsonapi-resources.com/v0.9/guide/)**
+
+## Contributing
+
+1. Fork it ( http://github.com/cerebris/jsonapi-resources/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+Copyright 2014-2016 Cerebris Corporation. MIT License (see LICENSE for details).

data/lib/generators/jsonapi/USAGE

@@ -0,0 +1,13 @@
+Description:
+    Generator for JSONAPI Resources
+
+Examples:
+    rails generate jsonapi:resource Post
+
+    This will create:
+        app/resources/post_resource.rb
+
+    rails generate jsonapi:controller Post
+
+    This will create:
+        app/controllers/posts_controller.rb

data/lib/generators/jsonapi/controller_generator.rb

@@ -0,0 +1,14 @@
+module Jsonapi
+  class ControllerGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_resource
+      template_file = File.join(
+        'app/controllers',
+        class_path,
+        "#{file_name.pluralize}_controller.rb"
+      )
+      template 'jsonapi_controller.rb', template_file
+    end
+  end
+end

data/lib/generators/jsonapi/resource_generator.rb

@@ -0,0 +1,14 @@
+module Jsonapi
+  class ResourceGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_resource
+      template_file = File.join(
+        'app/resources',
+        class_path,
+        "#{file_name.singularize}_resource.rb"
+      )
+      template 'jsonapi_resource.rb', template_file
+    end
+  end
+end

data/lib/generators/jsonapi/templates/jsonapi_controller.rb

@@ -0,0 +1,4 @@
+<% module_namespacing do -%>
+class <%= class_name.pluralize %>Controller < JSONAPI::ResourceController
+end
+<% end -%>

data/lib/generators/jsonapi/templates/jsonapi_resource.rb

@@ -0,0 +1,4 @@
+<% module_namespacing do -%>
+class <%= class_name.singularize %>Resource < JSONAPI::Resource
+end
+<% end -%>

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -0,0 +1,320 @@
+require 'csv'
+
+module JSONAPI
+  module ActsAsResourceController
+    MEDIA_TYPE_MATCHER = /.+".+"[^,]*|[^,]+/
+    ALL_MEDIA_TYPES = '*/*'
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.include Callbacks
+      base.cattr_reader :server_error_callbacks
+      base.define_jsonapi_resources_callbacks :process_operations
+    end
+
+    def index
+      process_request
+    end
+
+    def show
+      process_request
+    end
+
+    def show_relationship
+      process_request
+    end
+
+    def create
+      return unless verify_content_type_header
+      process_request
+    end
+
+    def create_relationship
+      return unless verify_content_type_header
+      process_request
+    end
+
+    def update_relationship
+      return unless verify_content_type_header
+      process_request
+    end
+
+    def update
+      return unless verify_content_type_header
+      process_request
+    end
+
+    def destroy
+      process_request
+    end
+
+    def destroy_relationship
+      process_request
+    end
+
+    def get_related_resource
+      process_request
+    end
+
+    def get_related_resources
+      process_request
+    end
+
+    def process_request
+      return unless verify_accept_header
+
+      @request = JSONAPI::RequestParser.new(params, context: context,
+                                            key_formatter: key_formatter,
+                                            server_error_callbacks: (self.class.server_error_callbacks || []))
+
+      unless @request.errors.empty?
+        render_errors(@request.errors)
+      else
+        operations = @request.operations
+        unless JSONAPI.configuration.resource_cache.nil?
+          operations.each {|op| op.options[:cache_serializer] = resource_serializer }
+        end
+        results = process_operations(operations)
+        render_results(results)
+      end
+    rescue => e
+      handle_exceptions(e)
+    end
+
+    def process_operations(operations)
+      run_callbacks :process_operations do
+        operation_dispatcher.process(operations)
+      end
+    end
+
+    def transaction
+      lambda { |&block|
+        ActiveRecord::Base.transaction do
+          block.yield
+        end
+      }
+    end
+
+    def rollback
+      lambda {
+        fail ActiveRecord::Rollback
+      }
+    end
+
+    def operation_dispatcher
+      @operation_dispatcher ||= JSONAPI::OperationDispatcher.new(transaction: transaction,
+                                                                 rollback: rollback,
+                                                                 server_error_callbacks: @request.server_error_callbacks)
+    end
+
+    private
+
+    def resource_klass
+      @resource_klass ||= resource_klass_name.safe_constantize
+    end
+
+    def resource_serializer_klass
+      @resource_serializer_klass ||= JSONAPI::ResourceSerializer
+    end
+
+    def resource_serializer
+      @resource_serializer ||= resource_serializer_klass.new(
+        resource_klass,
+        include_directives: @request ? @request.include_directives : nil,
+        fields: @request ? @request.fields : {},
+        base_url: base_url,
+        key_formatter: key_formatter,
+        route_formatter: route_formatter,
+        serialization_options: serialization_options
+      )
+      @resource_serializer
+    end
+
+    def base_url
+      @base_url ||= request.protocol + request.host_with_port
+    end
+
+    def resource_klass_name
+      @resource_klass_name ||= "#{self.class.name.underscore.sub(/_controller$/, '').singularize}_resource".camelize
+    end
+
+    def verify_content_type_header
+      unless request.content_type == JSONAPI::MEDIA_TYPE
+        fail JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.content_type)
+      end
+      true
+    rescue => e
+      handle_exceptions(e)
+      false
+    end
+
+    def verify_accept_header
+      unless valid_accept_media_type?
+        fail JSONAPI::Exceptions::NotAcceptableError.new(request.accept)
+      end
+      true
+    rescue => e
+      handle_exceptions(e)
+      false
+    end
+
+    def valid_accept_media_type?
+      media_types = media_types_for('Accept')
+
+      media_types.blank? ||
+        media_types.any? do |media_type|
+          (media_type == JSONAPI::MEDIA_TYPE || media_type.start_with?(ALL_MEDIA_TYPES))
+        end
+    end
+
+    def media_types_for(header)
+      (request.headers[header] || '')
+        .scan(MEDIA_TYPE_MATCHER)
+        .to_a
+        .map(&:strip)
+    end
+
+    # override to set context
+    def context
+      {}
+    end
+
+    def serialization_options
+      {}
+    end
+
+    # Control by setting in an initializer:
+    #     JSONAPI.configuration.json_key_format = :camelized_key
+    #     JSONAPI.configuration.route = :camelized_route
+    #
+    # Override if you want to set a per controller key format.
+    # Must return an instance of a class derived from KeyFormatter.
+    def key_formatter
+      JSONAPI.configuration.key_formatter
+    end
+
+    def route_formatter
+      JSONAPI.configuration.route_formatter
+    end
+
+    def base_response_meta
+      {}
+    end
+
+    def base_meta
+      if @request.nil? || @request.warnings.empty?
+        base_response_meta
+      else
+        base_response_meta.merge(warnings: @request.warnings)
+      end
+    end
+
+    def base_response_links
+      {}
+    end
+
+    def render_errors(errors)
+      operation_results = JSONAPI::OperationResults.new
+      result = JSONAPI::ErrorsOperationResult.new(errors[0].status, errors)
+      operation_results.add_result(result)
+
+      render_results(operation_results)
+    end
+
+    def render_results(operation_results)
+      response_doc = create_response_document(operation_results)
+      content = response_doc.contents
+
+      render_options = {}
+      if operation_results.has_errors?
+        render_options[:json] = content
+      else
+        # Bypasing ActiveSupport allows us to use CompiledJson objects for cached response fragments
+        render_options[:body] = JSON.generate(content)
+      end
+
+      render_options[:location] = content[:data]["links"][:self] if (
+        response_doc.status == :created && content[:data].class != Array
+      )
+
+      # For whatever reason, `render` ignores :status and :content_type when :body is set.
+      # But, we can just set those values directly in the Response object instead.
+      response.status = response_doc.status
+      response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
+
+      render(render_options)
+    end
+
+    def create_response_document(operation_results)
+      JSONAPI::ResponseDocument.new(
+        operation_results,
+        operation_results.has_errors? ? nil : resource_serializer,
+        key_formatter: key_formatter,
+        base_meta: base_meta,
+        base_links: base_response_links,
+        request: @request
+      )
+    end
+
+    # override this to process other exceptions
+    # Note: Be sure to either call super(e) or handle JSONAPI::Exceptions::Error and raise unhandled exceptions
+    def handle_exceptions(e)
+      case e
+      when JSONAPI::Exceptions::Error
+        render_errors(e.errors)
+      else
+        if JSONAPI.configuration.exception_class_whitelisted?(e)
+          fail e
+        else
+          (self.class.server_error_callbacks || []).each { |callback|
+            safe_run_callback(callback, e)
+          }
+
+          internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+          Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
+          render_errors(internal_server_error.errors)
+        end
+      end
+    end
+
+    def safe_run_callback(callback, error)
+      begin
+        callback.call(error)
+      rescue => e
+        Rails.logger.error { "Error in error handling callback: #{e.message} #{e.backtrace.join("\n")}" }
+        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+        render_errors(internal_server_error.errors)
+      end
+    end
+
+    # Pass in a methods or a block to be run when an exception is
+    # caught that is not a JSONAPI::Exceptions::Error
+    # Useful for additional logging or notification configuration that
+    # would normally depend on rails catching and rendering an exception.
+    # Ignores whitelist exceptions from config
+
+    module ClassMethods
+
+      def on_server_error(*args, &callback_block)
+        callbacks ||= []
+
+        if callback_block
+          callbacks << callback_block
+        end
+
+        method_callbacks = args.map do |method|
+          ->(error) do
+            if self.respond_to? method
+              send(method, error)
+            else
+              Rails.logger.warn("#{method} not defined on #{self}, skipping error callback")
+            end
+          end
+        end.compact
+        callbacks += method_callbacks
+        self.class_variable_set :@@server_error_callbacks, callbacks
+      end
+
+    end
+  end
+end

data/lib/jsonapi/cached_resource_fragment.rb

@@ -0,0 +1,127 @@
+module JSONAPI
+  class CachedResourceFragment
+    def self.fetch_fragments(resource_klass, serializer, context, cache_ids)
+      serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")
+      context_json = resource_klass.attribute_caching_context(context).to_json
+      context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)
+      context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"
+
+      results = self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
+
+      miss_ids = results.select{|k,v| v.nil? }.keys
+      unless miss_ids.empty?
+        find_filters = {resource_klass._primary_key => miss_ids.uniq}
+        find_options = {context: context}
+        resource_klass.find(find_filters, find_options).each do |resource|
+          (id, cr) = write(resource_klass, resource, serializer, serializer_config_key, context, context_key)
+          results[id] = cr
+        end
+      end
+
+      if JSONAPI.configuration.resource_cache_usage_report_function
+        JSONAPI.configuration.resource_cache_usage_report_function.call(
+          resource_klass.name,
+          cache_ids.size - miss_ids.size,
+          miss_ids.size
+        )
+      end
+
+      return results
+    end
+
+    attr_reader :resource_klass, :id, :type, :context, :fetchable_fields, :relationships,
+                :links_json, :attributes_json, :meta_json,
+                :preloaded_fragments
+
+    def initialize(resource_klass, id, type, context, fetchable_fields, relationships,
+                   links_json, attributes_json, meta_json)
+      @resource_klass = resource_klass
+      @id = id
+      @type = type
+      @context = context
+      @fetchable_fields = Set.new(fetchable_fields)
+
+      # Relationships left uncompiled because we'll often want to insert included ids on retrieval
+      @relationships = relationships
+
+      @links_json = CompiledJson.of(links_json)
+      @attributes_json = CompiledJson.of(attributes_json)
+      @meta_json = CompiledJson.of(meta_json)
+
+      # A hash of hashes
+      @preloaded_fragments ||= Hash.new
+    end
+
+    def to_cache_value
+      {
+        id: id,
+        type: type,
+        fetchable: fetchable_fields,
+        rels: relationships,
+        links: links_json.try(:to_s),
+        attrs: attributes_json.try(:to_s),
+        meta: meta_json.try(:to_s)
+      }
+    end
+
+    def to_real_resource
+      rs = Resource.resource_for(self.type).find_by_keys([self.id], {context: self.context})
+      return rs.try(:first)
+    end
+
+    private
+
+    def self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
+      type = resource_klass._type
+
+      keys = cache_ids.map do |(id, cache_key)|
+        [type, id, cache_key, serializer_config_key, context_key]
+      end
+
+      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject{|_,v| v.nil? }
+      return keys.each_with_object({}) do |key, hash|
+        (_, id, _, _) = key
+        if hits.has_key?(key)
+          hash[id] = self.from_cache_value(resource_klass, context, hits[key])
+        else
+          hash[id] = nil
+        end
+      end
+    end
+
+    def self.from_cache_value(resource_klass, context, h)
+      new(
+        resource_klass,
+        h.fetch(:id),
+        h.fetch(:type),
+        context,
+        h.fetch(:fetchable),
+        h.fetch(:rels, nil),
+        h.fetch(:links, nil),
+        h.fetch(:attrs, nil),
+        h.fetch(:meta, nil)
+      )
+    end
+
+    def self.write(resource_klass, resource, serializer, serializer_config_key, context, context_key)
+      (id, cache_key) = resource.cache_id
+      json = serializer.object_hash(resource) # No inclusions passed to object_hash
+      cr = self.new(
+        resource_klass,
+        json['id'],
+        json['type'],
+        context,
+        resource.fetchable_fields,
+        json['relationships'],
+        json['links'],
+        json['attributes'],
+        json['meta']
+      )
+
+      key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
+      JSONAPI.configuration.resource_cache.write(key, cr.to_cache_value)
+      return [id, cr]
+    end
+
+  end
+end

data/lib/jsonapi/callbacks.rb

@@ -0,0 +1,51 @@
+require 'active_support/callbacks'
+
+module JSONAPI
+  module Callbacks
+    def self.included(base)
+      base.class_eval do
+        include ActiveSupport::Callbacks
+        base.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def define_jsonapi_resources_callbacks(*callbacks)
+        options = callbacks.extract_options!
+        options = {
+          only: [:before, :around, :after]
+        }.merge!(options)
+
+        types = Array(options.delete(:only))
+
+        callbacks.each do |callback|
+          define_callbacks(callback, options)
+
+          types.each do |type|
+            send("_define_#{type}_callback", self, callback)
+          end
+        end
+      end
+
+      private
+
+      def _define_before_callback(klass, callback) #:nodoc:
+        klass.define_singleton_method("before_#{callback}") do |*args, &block|
+          set_callback(:"#{callback}", :before, *args, &block)
+        end
+      end
+
+      def _define_around_callback(klass, callback) #:nodoc:
+        klass.define_singleton_method("around_#{callback}") do |*args, &block|
+          set_callback(:"#{callback}", :around, *args, &block)
+        end
+      end
+
+      def _define_after_callback(klass, callback) #:nodoc:
+        klass.define_singleton_method("after_#{callback}") do |*args, &block|
+          set_callback(:"#{callback}", :after, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/compiled_json.rb

@@ -0,0 +1,36 @@
+module JSONAPI
+  class CompiledJson
+    def self.compile(h)
+      new(JSON.generate(h), h)
+    end
+
+    def self.of(obj)
+      case obj
+        when NilClass then nil
+        when CompiledJson then obj
+        when String then CompiledJson.new(obj)
+        when Hash then CompiledJson.compile(obj)
+        else raise "Can't figure out how to turn #{obj.inspect} into CompiledJson"
+      end
+    end
+
+    def initialize(json, h = nil)
+      @json = json
+      @h = h
+    end
+
+    def to_json(*args)
+      @json
+    end
+
+    def to_s
+      @json
+    end
+
+    def to_h
+      @h ||= JSON.parse(@json)
+    end
+
+    undef_method :as_json
+  end
+end