flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/gateways/jsonapi/data/join_descriptor.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'sinatra/base'
+
+# klass and type are set for those relationships that call methods rather
+# than regular Zermelo associations. Maybe this should be a separate descriptor type?
+
+module Flapjack
+  module Gateways
+    class JSONAPI < Sinatra::Base
+      module Data
+        class JoinDescriptor
+          attr_reader :post, :get, :patch, :delete, :number, :link, :includable, :klass, :descriptions
+          attr_accessor :association_data
+
+          def initialize(opts = {})
+            @association_data = nil
+            %w{post get patch delete number link includable type klass callback_classes descriptions}.each do |a|
+              instance_variable_set("@#{a}", opts[a.to_sym])
+            end
+            @callback_classes ||= []
+          end
+
+          def lock_klasses
+            if @association_data.nil?
+              [@klass] | @callback_classes
+            else
+              [@association_data.data_klass] |
+                @association_data.related_klasses | @callback_classes
+            end
+          end
+
+          def data_klass
+            @association_data.nil? ? @klass : @association_data.data_klass
+          end
+
+          def type
+            @association_data.nil? ? @type : data_klass.short_model_name.singular
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flapjack/gateways/jsonapi/data/method_descriptor.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'sinatra/base'
+
+module Flapjack
+  module Gateways
+    class JSONAPI < Sinatra::Base
+      module Data
+        class MethodDescriptor
+          attr_reader :attributes, :lock_klasses, :descriptions
+
+          def initialize(opts = {})
+            %w{attributes lock_klasses descriptions}.each do |a|
+              instance_variable_set("@#{a}", opts[a.to_sym])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flapjack/gateways/jsonapi/helpers/headers.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+module Flapjack
+  module Gateways
+    class JSONAPI < Sinatra::Base
+      module Helpers
+        module Headers
+
+          def cors_headers
+            allow_headers  = %w(* Content-Type Accept Authorization Cache-Control)
+            allow_methods  = %w(GET POST PATCH DELETE OPTIONS)
+            expose_headers = %w(Cache-Control Content-Language Content-Type Expires Last-Modified Pragma)
+            ch   = {
+              'Access-Control-Allow-Origin'   => '*',
+              'Access-Control-Allow-Methods'  => allow_methods.join(', '),
+              'Access-Control-Allow-Headers'  => allow_headers.join(', '),
+              'Access-Control-Expose-Headers' => expose_headers.join(', '),
+              'Access-Control-Max-Age'        => '1728000'
+            }
+            ch.each_pair {|k, v| response[k] = v}
+          end
+
+          def err(status_code, *msg)
+            Flapjack.logger.info "Error: #{msg.inspect}"
+
+            if 'DELETE'.eql?(request.request_method)
+              # not set by default for delete, but the error structure is JSON
+              response['Content-Type'] = media_type_produced(:with_charset => true)
+            end
+
+            # TODO include more relevant data
+            error_data = {
+              :errors => msg.collect {|m|
+                {
+                  :status => status_code.to_s,
+                  :detail => m
+                }
+              }
+            }
+
+            # Rack::CommonLogger doesn't log requests which result in exceptions.
+            # If you want something done properly, do it yourself...
+            result = Flapjack.dump_json(error_data)
+            access_log = self.class.instance_variable_get('@middleware').detect {|mw|
+              mw.first.is_a?(::Rack::CommonLogger)
+            }
+            unless access_log.nil?
+              access_log.first.send(:log, status_code,
+                ::Rack::Utils::HeaderHash.new(headers), result,
+                env['request_timestamp'])
+            end
+            [status_code, headers, result]
+          end
+
+          def is_jsonapi_request?
+            return false if request.content_type.nil?
+            Flapjack::Gateways::JSONAPI::JSONAPI_MEDIA_TYPE.eql?(request.content_type.split(/\s*[;,]\s*/, 2).first)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flapjack/gateways/jsonapi/helpers/miscellaneous.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+
+module Flapjack
+  module Gateways
+    class JSONAPI < Sinatra::Base
+      module Helpers
+        module Miscellaneous
+
+          def request_url
+            rurl = request.url.split('?').first
+            rurl << "?#{request.params.to_param}" unless request.params.empty?
+            rurl
+          end
+
+          def wrapped_params(options = {})
+            result = params['data']
+
+            if result.nil?
+              return([nil, false]) if options[:allow_nil].is_a?(TrueClass)
+              logger.debug("No 'data' object found in the supplied JSON:")
+              logger.debug(request.body.is_a?(StringIO) ? request.body.read : request.body)
+              halt(err(403, "Data object must be provided"))
+            end
+
+            ext_bulk = !(request.content_type =~ /^(?:.+;)?\s*ext=bulk(?:\s*;\s*.+)?$/).nil?
+            case result
+            when Array
+              halt(err(406, "JSONAPI Bulk Extension not set in headers")) unless ext_bulk
+              [result, false]
+            when Hash
+              halt(err(406, "JSONAPI Bulk Extension was set in headers")) if ext_bulk
+              [[result], true]
+            else
+              halt(err(403, "The received data object is not an Array or a Hash"))
+            end
+          end
+
+          def wrapped_link_params(options = {})
+            result = params['data']
+
+            assoc = options[:association]
+            number = assoc.number
+
+            if result.nil?
+              return([nil, false]) if :singular.eql?(number) && options[:allow_nil].is_a?(TrueClass)
+              logger.debug("No 'data' object found in the following supplied JSON:")
+              logger.debug(request.body.is_a?(StringIO) ? request.body.read : request.body)
+              halt err(403, "No 'data' object received")
+            end
+
+            case number
+            when :multiple
+              unless result.is_a?(Array) && result.all? {|r| assoc.type.eql?(r['type']) && !r['id'].nil? }
+                halt(err(403, "Malformed data for multiple link endpoint"))
+              end
+              [result.map {|r| r[:id]}, false]
+            when :singular
+              unless result.is_a?(Hash) && assoc.type.eql?(result['type'])
+                halt(err(403, "Malformed data for singular link endpoint"))
+              end
+              [[result[:id]], true]
+            else
+              halt(err(403, "Invalid endpoint definition"))
+            end
+          end
+
+          def validate_data(data, options = {})
+            valid_keys = ['id', 'type', 'attributes', 'relationships']
+            valid_attrs = (options[:attributes] || []).map(&:to_s)
+            sl = options[:singular_links] ? options[:singular_links].keys.map(&:to_s) : []
+            ml = options[:multiple_links] ? options[:multiple_links].keys.map(&:to_s) : []
+            all_links = sl + ml
+
+            # FIXME check error codes against JSONAPI spec
+
+            data.each do |d|
+              invalid_keys = d.keys - valid_keys
+              halt(err(403, "Invalid key(s): #{invalid_keys.join(', ')}")) unless invalid_keys.empty?
+              if d.has_key?('attributes')
+                attrs = d['attributes']
+                halt(err(403, "Attributes must be a Hash with String keys")) unless attrs.is_a?(Hash) &&
+                  attrs.keys.all? {|k| k.is_a?(String)}
+                invalid_attrs = attrs.keys - valid_attrs
+                halt(err(403, "Invalid attribute(s): #{invalid_attrs.join(', ')}")) unless invalid_attrs.empty?
+              end
+              if d.has_key?('relationships')
+                links = d['relationships']
+                halt(err(403, "Relationships(s) must be a Hash with String keys")) unless links.is_a?(Hash) &&
+                  links.keys.all? {|k| k.is_a?(String)}
+                invalid_links = links.keys - all_links
+                halt(err(404, "Unknown relationship type(s): #{invalid_links.join(', ')}")) unless invalid_links.empty?
+                links.each_pair do |k, v|
+                  halt(err(403, "Related data for '#{k}' must be a Hash with String keys")) unless v.is_a?(Hash) && v.keys.all? {|vk| vk.is_a?(String)}
+                  halt(err(403, "Related data for '#{k}' must have data references")) unless links[k].has_key?('data')
+
+                  if sl.include?(k)
+                    halt(err(403, "Data reference for '#{k}' must be a Hash with 'id' & 'type' String values")) unless links[k]['data'].is_a?(Hash) &&
+                      v['data'].has_key?('id') &&
+                      v['data'].has_key?('type') &&
+                      v['data']['id'].is_a?(String) &&
+                      v['data']['type'].is_a?(String)
+
+                    unless options[:singular_links][k.to_sym].type == v['data']['type']
+                      halt(err(403, "Related '#{k}' has wrong type #{v['data']['type']}"))
+                    end
+                  else
+                    halt(err(403, "Data reference for '#{k}' must be an Array of Hashes with 'id' & 'type' String values")) unless v['data'].is_a?(Array) &&
+                      v['data'].all? {|l| l.has_key?('id') } &&
+                      v['data'].all? {|l| l.has_key?('type') } &&
+                      v['data'].all? {|l| l['id'].is_a?(String) } &&
+                      v['data'].all? {|l| l['type'].is_a?(String) }
+
+                    t = options[:multiple_links][k.to_sym].type
+                    bad_type = v['data'].detect {|l| !t.eql?(l['type'])}
+                    unless bad_type.nil?
+                      halt(403, "Data reference for '#{k}' has invalid type '#{bad_type}', should be '#{t}")
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def validate_and_parsetime(value)
+            return unless value
+            Time.iso8601(value).getutc
+          rescue ArgumentError
+            logger.error "Couldn't parse time from '#{value}'"
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/flapjack/gateways/jsonapi/helpers/resources.rb

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby
+
+require 'active_support/inflector'
+
+module Flapjack
+  module Gateways
+    class JSONAPI < Sinatra::Base
+      module Helpers
+        module Resources
+
+          ISO8601_PAT = "(?:[1-9][0-9]*)?[0-9]{4}-" \
+                        "(?:1[0-2]|0[1-9])-" \
+                        "(?:3[0-1]|0[1-9]|[1-2][0-9])T" \
+                        "(?:2[0-3]|[0-1][0-9]):" \
+                        "[0-5][0-9]:[0-5][0-9](?:\\.[0-9]+)?" \
+                        "(?:Z|[+-](?:2[0-3]|[0-1][0-9]):[0-5][0-9])?"
+
+          # TODO refactor some of these methods into a module, included in data/ classes
+
+          def normalise_json_data(attribute_types, data)
+            record_data = data.dup
+            attribute_types.each_pair do |name, type|
+              t = record_data[name.to_s]
+              next unless t.is_a?(String) && :timestamp.eql?(type)
+              begin
+                record_data[name.to_s] = DateTime.parse(t)
+              rescue ArgumentError
+                record_data[name.to_s] = nil
+              end
+            end
+            symbolize(record_data)
+          end
+
+          def parse_range_or_value(name, pattern, v, opts = {}, &block)
+            rangeable = opts[:rangeable]
+
+            if rangeable && (v =~ /\A(?:(#{pattern})\.\.(#{pattern})|(#{pattern})\.\.|\.\.(#{pattern}))\z/)
+              start = nil
+              start_s = Regexp.last_match(1) || Regexp.last_match(3)
+              unless start_s.nil?
+                start = yield(start_s)
+                halt(err(403, "Couldn't parse #{name} '#{start_s}'")) if start.nil?
+              end
+
+              finish = nil
+              finish_s = Regexp.last_match(2) || Regexp.last_match(4)
+              unless finish_s.nil?
+                finish = yield(finish_s)
+                halt(err(403, "Couldn't parse #{name} '#{finish_s}'")) if finish.nil?
+              end
+
+              if !start.nil? && !finish.nil? && (start > finish)
+                halt(err(403, "Range order cannot be inversed"))
+              else
+                Zermelo::Filters::IndexRange.new(start, finish, :by_score => true)
+              end
+
+            elsif v =~ /\A#{pattern}\z/
+              t = yield(v)
+              halt(err(403, "Couldn't parse #{name} '#{v}'")) if t.nil?
+              t
+            else
+              halt(err(403, "Invalid #{name} parameter '#{v}'"))
+            end
+          end
+
+          def filter_params(klass, filter)
+            attributes = if klass.respond_to?(:jsonapi_methods)
+              (klass.jsonapi_methods[:get] || {}).attributes || []
+            else
+              []
+            end
+
+            attribute_types = klass.attribute_types
+
+            rangeable_attrs = []
+            attrs_by_type = {}
+
+            klass.send(:with_index_data) do |idx_data|
+              idx_data.each do |k, d|
+                next unless d.index_klass == ::Zermelo::Associations::RangeIndex
+                rangeable_attrs << k
+              end
+            end
+
+            Zermelo::ATTRIBUTE_TYPES.keys.each do |at|
+              attrs_by_type[at] = attributes.select do |a|
+                at.eql?(attribute_types[a])
+              end
+            end
+
+            filter.each_with_object({}) do |filter_str, memo|
+              k, v = filter_str.split(':', 2)
+              halt(err(403, "Single filter parameters must be 'key:value'")) if k.nil? || v.nil?
+
+              value = if attrs_by_type[:string].include?(k.to_sym) || :id.eql?(k.to_sym)
+                if v =~ %r{^/(.+)/$}
+                  Regexp.new(Regexp.last_match(1))
+                elsif v =~ /\|/
+                  v.split('|')
+                else
+                  v
+                end
+              elsif attrs_by_type[:boolean].include?(k.to_sym)
+                case v.downcase
+                when '0', 'f', 'false', 'n', 'no'
+                  false
+                when '1', 't', 'true', 'y', 'yes'
+                  true
+                end
+
+              elsif attrs_by_type[:timestamp].include?(k.to_sym)
+                parse_range_or_value('timestamp', ISO8601_PAT, v, :rangeable => rangeable_attrs.include?(k.to_sym)) {|s|
+                  begin; DateTime.parse(s); rescue ArgumentError; nil; end
+                }
+              elsif attrs_by_type[:integer].include?(k.to_sym)
+                parse_range_or_value('integer', '\d+', v, :rangeable => rangeable_attrs.include?(k.to_sym)) {|s|
+                  s.to_i
+                }
+              elsif attrs_by_type[:float].include?(k.to_sym)
+                parse_range_or_value('float', '\d+(\.\d+)?', v, :rangeable => rangeable_attrs.include?(k.to_sym)) {|s|
+                  s.to_f
+                }
+              end
+
+              halt(err(403, "Invalid filter key '#{k}'")) if value.nil?
+              memo[k.to_sym] = value
+            end
+          end
+
+          def resource_filter_sort(klass, options = {})
+            options[:sort] ||= 'id'
+            scope = klass
+
+            unless params[:filter].nil?
+              unless params[:filter].is_a?(Array)
+                halt(err(403, "Filter parameters must be passed as an Array"))
+              end
+              filter_ops = filter_params(klass, params[:filter])
+              scope = scope.intersect(filter_ops)
+            end
+
+            sort_opts = if params[:sort].nil?
+              options[:sort].to_sym
+            else
+              sort_params = params[:sort].split(',')
+
+              if sort_params.any? {|sp| sp !~ /^(?:\+|-)/ }
+                halt(err(403, "Sort parameters must start with +/-"))
+              end
+
+              sort_params.each_with_object({}) do |sort_param, memo|
+                sort_param =~ /^(\+|\-)([a-z_]+)$/i
+                rev  = Regexp.last_match(1)
+                term = Regexp.last_match(2)
+                memo[term.to_sym] = (rev == '-') ? :desc : :asc
+              end
+            end
+
+            scope = scope.sort(sort_opts)
+            scope
+          end
+
+          def paginate_get(dataset, options = {})
+            return([[], {}, {}]) if dataset.nil?
+
+            total = dataset.count
+            return([[], {}, {}]) if total == 0
+
+            page = options[:page].to_i
+            page = (page > 0) ? page : 1
+
+            per_page = options[:per_page].to_i
+            per_page = (per_page > 0) ? per_page : 20
+
+            total_pages = (total.to_f / per_page).ceil
+
+            pages = set_page_numbers(page, total_pages)
+            links = create_links(pages)
+            headers['Link']        = create_link_header(links) unless links.empty?
+            headers['Total-Count'] = total_pages.to_s
+
+            [dataset.page(page, :per_page => per_page),
+              links,
+              {
+                :pagination => {
+                  :page        => page,
+                  :per_page    => per_page,
+                  :total_pages => total_pages,
+                  :total_count => total
+                }
+              }
+            ]
+          end
+
+          def set_page_numbers(page, total_pages)
+            pages = {}
+            pages[:first] = 1 # if (total_pages > 1) && (page > 1)
+            pages[:prev]  = page - 1 if (page > 1)
+            pages[:next]  = page + 1 if page < total_pages
+            pages[:last]  = total_pages # if (total_pages > 1) && (page < total_pages)
+            pages
+          end
+
+          def create_links(pages)
+            url_without_params = request.url.split('?').first
+            per_page = params[:per_page] # ? params[:per_page].to_i : 20
+
+            links = {}
+            pages.each do |key, value|
+              page_params = {'page' => value }
+              page_params.update('per_page' => per_page) unless per_page.nil?
+              new_params = request.params.merge(page_params)
+              links[key] = "#{url_without_params}?#{new_params.to_query}"
+            end
+            links
+          end
+
+          def create_link_header(links)
+            links.collect {|(k, v)| "<#{v}; rel=\"#{k}\"" }.join(', ')
+          end
+
+        end
+      end
+    end
+  end
+end