acts_as_having_string_id 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 203f83e904e3610801246812ab5c46d198d050c7
-  data.tar.gz: def4ce48a2648ad8badf8fc8599f71a4495e99e9
+  metadata.gz: 4049e75011844a99033b1fd85084942748925201
+  data.tar.gz: 68060d24a7ad487dcd45291835d69b143f06537e
 SHA512:
-  metadata.gz: 99a188bf7ee46b217d20293c0e0faf5208c24c05f50a8f77a28fe478da77cb2bafb1d583724eb1c8f172e38c34d5f134ad8fe9955f48c6027aeafa9ec32ceb12
-  data.tar.gz: f768f3a63fd24fd5fdee863ac4e2e3319d6f2eace227cb4c1d88b9f81cf84285b5c40018eedf54eab1b22067575dca4c41375831a51b81f78cddb01617f03153
+  metadata.gz: a3372a5c525692612ba7ca80000ec6b0c515a3f413ce2324281e722e295aa3627845d8bc6e6638ab5b1e4bc798885abcf65b0989d32a8bce302eef5155dbd1f6
+  data.tar.gz: 053b131ac064ae39f64c9a0ae9fbbd794cde0a1b8e0a2d612f2f0b42b2df85b0642afee540843b2aa8e67c2436037b3b002680884814fd79da9f78496c619799

data/README.md

@@ -17,12 +17,25 @@ After
       "name": "Alice O'User"
     }
 
+## Problem
 Exposing sequential integer IDs has several drawbacks:
 
 * Javascript has a 53-bit limit for integers (see https://dev.twitter.com/overview/api/twitter-ids-json-and-snowflake), which is a problem if you have large IDs
 * Perhaps you don't want objects to be easily enumerable, even if they're public (if you know about http://example.com/documents/104, it's way too easy to find document 105)
 * Sequential IDs make it easy to know how much usage your product gets (if my newly created user is http://example.com/users/1337, your product probably has 1,337 users)
 
+## Why not use UUIDs?
+"But why not just use UUIDs", you ask? Rails has built-in support for them. But they are very long. Exposing them in an API is okay, but in a URL just doesn't look nice
+
+    http://example.com/objects/be398f64-320f-4731-be73-74699e6795bc
+    
+Even base62 encoding that ID is very long
+
+    http://example.com/objects/27WzQMxpvINgio2w5Xt0hk
+    
+64-bit integers would be optimal, but they can't be random: the risk of collisions would be too high.
+
+## Our solution
 Rails makes heavy use of sequential integer IDs internally, but there's no need of exposing them. `ActsAsHavingStringId` provides an alternative string representation of your IDs. This representation is
 
     base62(tea(id, md5(ModelClass.name + Rails.application.secrets.string_id_key)))
@@ -33,8 +46,6 @@ The representation looks something like "E0znqip4mRA".
 
 Your controllers will continue to work without modification, but will start to accept string IDs. So if http://example.com/orders/104 worked before, something like http://example.com/orders/E0znqip4mRA should magically work.
 
-You do however need to take care never to expose the `id` member of your models. Instead, use `id_string`.
-
 ## Usage
 First, set up your `secrets.yml`:
 
@@ -47,43 +58,51 @@ First, set up your `secrets.yml`:
     production:
       string_id_key: <%= ENV["STRING_ID_KEY"] %>
 
-Then, call the method in your model class:
+Then, call the method in your model class, after any relations to other models:
 
     class MyModel < ApplicationRecord
+       has_many :my_other_model
        acts_as_having_string_id
     end
 
-The string representation is now available as `id_string` on your model object. As an example:
+The id of your model will now not be an int, but rather an instance of `ActsAsHavingStringId::StringId`. As an example:
 
     > m = MyModel.create!
     > m.id
+    => 1/7EajpSfdWIf
+    > m.id.to_i
     => 1
-    > m.id_string
+    > m.id.to_s
     => "7EajpSfdWIf"
 
-All ActiveRecord functions will also accept the string representation as input:
+All ActiveRecord functions will continue to accept int IDs, but will now also accept the string representation as input:
 
     > MyModel.find("7EajpSfdWIf")
-    => #<MyModel id: 1, created_at: "2016-08-31 13:27:02", updated_at: "2016-08-31 13:27:02">
+    => #<MyModel id: 1/7EajpSfdWIf, created_at: "2016-08-31 13:27:02", updated_at: "2016-08-31 13:27:02">
     > MyModel.where(id: "7EajpSfdWIf")
-    => #<ActiveRecord::Relation [#<MyModel id: 1, created_at: "2016-08-31 13:27:02", updated_at: "2016-08-31 13:27:02">]>
+    => #<ActiveRecord::Relation [#<MyModel id: 1/7EajpSfdWIf, created_at: "2016-08-31 13:27:02", updated_at: "2016-08-31 13:27:02">]>
+    
+In all associated models, foreign keys to your model will also be this new type of id.
+
+    > MyOtherModel.create! my_model: MyModel.first
+    => #<MyOtherModel id: 1, my_model_id: 1/GBpjdLndSR0, created_at: "2016-09-07 10:32:24", updated_at: "2016-09-07 10:32:24"> 
 
-Then, for exposing your string ID, use the `id_string` method. For example, if you're using [ActiveModelSerializers](https://github.com/rails-api/active_model_serializers):
+Then, for exposing your string ID, make sure to always use `id.to_s`. For example, if you're using [ActiveModelSerializers](https://github.com/rails-api/active_model_serializers):
 
     class UserSerializer < ActiveModel::Serializer
       attributes :id, :name
 
       def id
-        object.id_string
+        object.id.to_s
       end
     end
 
-You can also get the string representation of an id without having the instance
+You can get the string representation of an ID from a class without having the instance
 
     > MyModel.id_string(1)
     => "7EajpSfdWIf"
 
-And, conversely, getting the id from the string representation
+And, conversely, getting the ID from the string representation
 
     > MyModel.id_int("7EajpSfdWIf")
     => 1
@@ -91,10 +110,8 @@ And, conversely, getting the id from the string representation
 And that's just about it!
 
 ## TODO
-* You should be able to do `MyOtherModel.create! my_model_id: "KuUnDvpJYS2"` and `my_other_model.my_model_id = "KuUnDvpJYS2"`
 * Since the `MyModel.find("7EajpSfdWIf")` functionality depends on the argument now being a string, `MyModel.find("5")` will no longer mean `MyModel.find(5)`, but rather `MyModel.find(4387534)` or something. Is that a problem?
 * It's a potential security problem that we don't force strings from controllers (integer id coming from JSON postdata will make it find by original id)
-* Although TEA handles (and outputs) 64-bit ids, we currently limit the input to 32-bit
 
 ## Installation
 Add this line to your application's Gemfile:

data/lib/acts_as_having_string_id/railtie.rb

@@ -1,13 +1,13 @@
 module ActsAsHavingStringId
   class Railtie < Rails::Railtie
     initializer "railtie.include_in_application_record" do
+      ApplicationRecord.include(ActsAsHavingStringId)
+
       if defined?(Spring)
         Spring.after_fork do
           # This needs to happen every time Spring reloads
           ApplicationRecord.include(ActsAsHavingStringId)
         end
-      else
-        ApplicationRecord.include(ActsAsHavingStringId)
       end
     end
   end

data/lib/acts_as_having_string_id/string_id.rb

@@ -1,24 +1,74 @@
 module ActsAsHavingStringId
-  class StringId < ActiveRecord::Type::Value
-    def initialize(tea)
-      @tea = tea
+  class StringId
+    attr_reader :string_value, :int_value
+
+    def initialize(klass, value)
+      if value == nil
+        @string_value = nil
+        @int_value = nil
+      elsif value.is_a? String
+        @string_value = value
+        @int_value = klass.id_int(value)
+      else
+        @int_value = value
+        @string_value = klass.id_string(value)
+      end
+    end
+
+    def inspect
+      "#{int_value}/#{string_value}"
+    end
+
+    def to_s
+      string_value
+    end
+
+    def to_i
+      int_value
     end
 
-    def serialize(value)
-      if value.is_a? String
-        i = @tea.decrypt(value.base62_decode)
-        if i >= 2**31
-          # Since Postgres SERIAL is a signed 32-bit integer, we can
-          # only represent integers up until (2**32)-1. If we're
-          # serializing a larger id, we want a not found rather than
-          # a postgres datatype out of bounds error. WHERE id = -1
-          # will definitely not be found.
-          return -1
+    def ==(other)
+      other.is_a?(StringId) && other.int_value == int_value
+    end
+
+    class Type < ActiveRecord::Type::Value
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def type
+        :integer
+      end
+
+      def cast(value)
+        if value == nil
+          nil
+        else
+          ActsAsHavingStringId::StringId(@klass, value)
+        end
+      end
+
+      def deserialize(value)
+        if value.is_a?(String) || value.is_a?(Fixnum)
+          ActsAsHavingStringId::StringId(@klass, value)
+        elsif value == nil
+          nil
+        else
+          super
+        end
+      end
+
+      def serialize(value)
+        if value == nil
+          nil
+        else
+          ActsAsHavingStringId::StringId(@klass, value).int_value
         end
-        return i
-      else
-        value
       end
     end
   end
+
+  def self.StringId(klass, value)
+    value.is_a?(StringId) ? value : StringId.new(klass, value)
+  end
 end

data/lib/acts_as_having_string_id/version.rb

@@ -1,3 +1,3 @@
 module ActsAsHavingStringId
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/lib/acts_as_having_string_id.rb

@@ -9,7 +9,15 @@ module ActsAsHavingStringId
   module ClassMethods
     def acts_as_having_string_id(options = {})
       class_eval do
-        attribute :id, ActsAsHavingStringId::StringId.new(_tea)
+        attrib_type = ActsAsHavingStringId::StringId::Type.new(self)
+        attribute :id, attrib_type
+
+        self.reflections.each_value do |r|
+          # Attribute all foreign keys pointing here as well
+          r.klass.class_eval do
+            attribute r.foreign_key.to_sym, attrib_type
+          end
+        end
 
         def self.id_string(id)
           # Return the string representation of id
@@ -21,8 +29,6 @@ module ActsAsHavingStringId
           _tea.decrypt(id_string.base62_decode)
         end
       end
-
-      include ActsAsHavingStringId::LocalInstanceMethods
     end
 
     def _tea
@@ -30,10 +36,4 @@ module ActsAsHavingStringId
       @_tea ||= ActsAsHavingStringId::TEA.new(pass_phrase)
     end
   end
-
-  module LocalInstanceMethods
-    def id_string
-      self.class.id_string(id)
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_having_string_id
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Magnus Hult
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-05 00:00:00.000000000 Z
+date: 2016-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -58,6 +58,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Makes a model accept and expose a seemingly random string id
 email:
 - magnus@magnushult.se