Merge pull request #420 from cerebris/pr/160

Key type config option

Author: dgeb

README.md

@@ -29,6 +29,7 @@ backed by ActiveRecord models or by custom objects.
     * [Namespaces] (#namespaces)
     * [Error Codes] (#error-codes)
   * [Serializer] (#serializer)
+* [Configuration] (#configuration)
 * [Contributing] (#contributing)
 * [License] (#license)
 
@@ -230,19 +231,36 @@ If the underlying model does not use `id` as the primary key _and_ does not supp
 must use the `primary_key` method to tell the resource which field on the model to use as the primary key. **Note:**
 this _must_ be the actual primary key of the model.
 
-By default only integer values are allowed for primary key. To change this behavior you can override
-`verify_key` class method:
+By default only integer values are allowed for primary key. To change this behavior you can set the `resource_key_type`
+configuration option:
 
 ```ruby
-class CurrencyResource < JSONAPI::Resource
-  primary_key :code
-  attributes :code, :name
+JSONAPI.configure do |config|
+  # Allowed values are :integer(default), :uuid, :string, or a proc
+  config.resource_key_type = :uuid
+end
+```
 
-  has_many :expense_entries
+##### Override key type on a resource
 
-  def self.verify_key(key, context = nil)
-    key && String(key)
-  end
+You can override the default resource key type on a per-resource basis by calling `key_type` in the resource class,
+with the same allowed values as the `resource_key_type` configuration option.
+
+```ruby
+class ContactResource < JSONAPI::Resource
+  attribute :id
+  attributes :name_first, :name_last, :email, :twitter
+  key_type :uuid
+end
+```
+
+##### Custom resource key validators
+
+If you need more control over the key, you can override the #verify_key method on your resource, or set a lambda that accepts key and context arguments in `config/initializers/jsonapi_resources.rb`:
+
+```ruby
+JSONAPI.configure do |config|
+  config.resource_key_type = -> (key, context) { key && String(key) }
 end
 ```
 
@@ -1398,6 +1416,9 @@ JSONAPI.configure do |config|
   #:basic, :active_record, or custom
   config.operations_processor = :active_record
 
+  #:integer, :uuid, :string, or custom (provide a proc)
+  config.resource_key_type = :integer
+
   # optional request features
   config.allow_include = true
   config.allow_sort = true

lib/jsonapi/configuration.rb

@@ -5,6 +5,7 @@
 module JSONAPI
   class Configuration
     attr_reader :json_key_format,
+                :resource_key_type,
                 :key_formatter,
                 :route_format,
                 :route_formatter,
@@ -34,6 +35,9 @@ def initialize
       #:basic, :active_record, or custom
       self.operations_processor = :active_record
 
+      #:integer, :uuid, :string, or custom (provide a proc)
+      self.resource_key_type = :integer
+
       # optional request features
       self.allow_include = true
       self.allow_sort = true
@@ -77,6 +81,10 @@ def json_key_format=(format)
       @key_formatter = JSONAPI::Formatter.formatter_for(format)
     end
 
+    def resource_key_type=(key_type)
+      @resource_key_type = key_type
+    end
+
     def route_format=(format)
       @route_format = format
       @route_formatter = JSONAPI::Formatter.formatter_for(format)

lib/jsonapi/resource.rb

@@ -545,9 +545,50 @@ def verify_filter(filter, raw, context = nil)
         end
       end
 
-      # override to allow for key processing and checking
-      def verify_key(key, _context = nil)
-        key && Integer(key)
+      def key_type(key_type)
+        @_resource_key_type = key_type
+      end
+
+      def resource_key_type
+        @_resource_key_type || JSONAPI.configuration.resource_key_type
+      end
+
+      def verify_key(key, context = nil)
+        key_type = resource_key_type
+        verification_proc = case key_type
+
+        when :integer
+          -> (key, context) {
+            begin
+              return key if key.nil?
+              Integer(key)
+            rescue
+              raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
+            end
+          }
+        when :string
+          -> (key, context) {
+            return key if key.nil?
+            if key.to_s.include?(',')
+              raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
+            else
+              key
+            end
+          }
+        when :uuid
+          -> (key, context) {
+            return key if key.nil?
+            if key.to_s.match(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
+              key
+            else
+              raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
+            end
+          }
+        else
+          key_type
+        end
+
+        verification_proc.call(key, context)
       rescue
         raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
       end

lib/jsonapi/routing_ext.rb

@@ -68,6 +68,10 @@ def jsonapi_resources(*resources, &_block)
 
           options[:path] = format_route(@resource_type)
 
+          if res.resource_key_type == :uuid
+            options[:constraints] = {id: /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(,[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})*/}
+          end
+
           if options[:except]
             options[:except] = Array(options[:except])
             options[:except] << :new unless options[:except].include?(:new) || options[:except].include?('new')

test/fixtures/active_record.rb

@@ -800,16 +800,8 @@ def self.verify_custom_filter(filter, values, context = nil)
     return filter, values
   end
 
-  def self.is_num?(str)
-    begin
-      !!Integer(str)
-    rescue ArgumentError, TypeError
-      false
-    end
-  end
-
   def self.verify_key(key, context = nil)
-    raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key) unless is_num?(key)
+    super(key)
     raise JSONAPI::Exceptions::RecordNotFound.new(key) unless find_by_key(key, context: context)
     return key
   end
@@ -825,9 +817,7 @@ class IsoCurrencyResource < JSONAPI::Resource
 
   filter :country_name
 
-  def self.verify_key(key, context = nil)
-    key && String(key)
-  end
+  key_type :string
 end
 
 class ExpenseEntryResource < JSONAPI::Resource

test/integration/routes/routes_test.rb

@@ -52,6 +52,17 @@ def test_routing_posts_links_tags_update_acts_as_set
                    {controller: 'posts', action: 'update_relationship', post_id: '1', relationship: 'tags'})
   end
 
+  def test_routing_uuid
+    assert_routing({path: '/pets/v1/cats/f1a4d5f2-e77a-4d0a-acbb-ee0b98b3f6b5', method: :get},
+                   {action: 'show', controller: 'pets/v1/cats', id: 'f1a4d5f2-e77a-4d0a-acbb-ee0b98b3f6b5'})
+  end
+
+  # ToDo: refute this routing
+  # def test_routing_uuid_bad_format
+  #   assert_routing({path: '/pets/v1/cats/f1a4d5f2-e77a-4d0a-acbb-ee0b9', method: :get},
+  #                  {action: 'show', controller: 'pets/v1/cats', id: 'f1a4d5f2-e77a-4d0a-acbb-ee0b98'})
+  # end
+
   # Polymorphic
   def test_routing_polymorphic_get_related_resource
     assert_routing(

test/test_helper.rb

@@ -95,6 +95,22 @@ def show_queries
 
 require File.expand_path('../fixtures/active_record', __FILE__)
 
+module Pets
+  module V1
+    class CatsController < JSONAPI::ResourceController
+
+    end
+
+    class CatResource < JSONAPI::Resource
+      attribute :id
+      attribute :name
+      attribute :breed
+
+      key_type :uuid
+    end
+  end
+end
+
 JSONAPI.configuration.route_format = :underscored_route
 TestApp.routes.draw do
   jsonapi_resources :people
@@ -214,6 +230,12 @@ def show_queries
     end
   end
 
+  namespace :pets do
+    namespace :v1 do
+      jsonapi_resources :cats
+    end
+  end
+
   mount MyEngine::Engine => "/boomshaka", as: :my_engine
 end
 

test/unit/resource/resource_test.rb

@@ -195,6 +195,7 @@ def apply_filters(records, filters, options)
     filtered_comments = post_resource.comments({ filters: { body: 'i liked it' } })
     assert_equal(1, filtered_comments.size)
 
+  ensure
     # reset method to original implementation
     PostResource.instance_eval do
       def apply_filters(records, filters, options)
@@ -222,6 +223,7 @@ def apply_sort(records, criteria)
     sorted_comment_ids = post_resource.comments(sort_criteria: [{ field: 'id', direction: 'desc'}]).map{|c| c.model.id }
     assert_equal [2,1], sorted_comment_ids
 
+  ensure
     # reset method to original implementation
     PostResource.instance_eval do
       def apply_sort(records, criteria)
@@ -260,6 +262,7 @@ def apply(relation, order_options)
     paged_comments = post_resource.comments(paginator: paginator_class.new(1))
     assert_equal 1, paged_comments.size
 
+  ensure
     # reset method to original implementation
     PostResource.instance_eval do
       def apply_pagination(records, criteria, order_options)
@@ -269,4 +272,81 @@ def apply_pagination(records, criteria, order_options)
       end
     end
   end
+
+  def test_key_type_integer
+    CatResource.instance_eval do
+      key_type :integer
+    end
+
+    assert CatResource.verify_key('45')
+    assert CatResource.verify_key(45)
+
+    assert_raises JSONAPI::Exceptions::InvalidFieldValue do
+      CatResource.verify_key('45,345')
+    end
+
+  ensure
+    CatResource.instance_eval do
+      key_type nil
+    end
+  end
+
+  def test_key_type_string
+    CatResource.instance_eval do
+      key_type :string
+    end
+
+    assert CatResource.verify_key('45')
+    assert CatResource.verify_key(45)
+
+    assert_raises JSONAPI::Exceptions::InvalidFieldValue do
+      CatResource.verify_key('45,345')
+    end
+
+  ensure
+    CatResource.instance_eval do
+      key_type nil
+    end
+  end
+
+  def test_key_type_uuid
+    CatResource.instance_eval do
+      key_type :uuid
+    end
+
+    assert CatResource.verify_key('f1a4d5f2-e77a-4d0a-acbb-ee0b98b3f6b5')
+
+    assert_raises JSONAPI::Exceptions::InvalidFieldValue do
+      CatResource.verify_key('f1a-e77a-4d0a-acbb-ee0b98b3f6b5')
+    end
+
+  ensure
+    CatResource.instance_eval do
+      key_type nil
+    end
+  end
+
+  def test_key_type_proc
+    CatResource.instance_eval do
+      key_type -> (key, context) {
+        return key if key.nil?
+        if key.to_s.match(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
+          key
+        else
+          raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
+        end
+      }
+    end
+
+    assert CatResource.verify_key('f1a4d5f2-e77a-4d0a-acbb-ee0b98b3f6b5')
+
+    assert_raises JSONAPI::Exceptions::InvalidFieldValue do
+      CatResource.verify_key('f1a-e77a-4d0a-acbb-ee0b98b3f6b5')
+    end
+
+  ensure
+    CatResource.instance_eval do
+      key_type nil
+    end
+  end
 end