active_model_serializers_pg 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 749a92cbe1a5ef80dbfcf46cda82127108e0497465258e19a2023e0847b9696d
-  data.tar.gz: 32956f1353aa108fd173d02b2da79391ba45c286efc1e6080bb4e4927f630bf2
+  metadata.gz: 4bdfe8c6e1f9a0fbca6e444a7594474d43d9415008c86f6fe30964088fc8c1f7
+  data.tar.gz: 0e5a9f884cda2663bf2f36051ad42367381ea5f61798048cd4ae774c19c76265
 SHA512:
-  metadata.gz: f9861a254e392c60be71bb396497e2f9fb226c6c9b1054635d1bd6dcb3bbd04992e5126d084a2f80d277c1d78603e9f82fb9eb166f6d545c373576eefa8d7fc7
-  data.tar.gz: ac39133be71300ecea935c95f090e2282b48bd55cd00431e905e04cf32974efec50e8fa34f6b2b4ec10652ae24201eb33c55b7c0c6ef42d8731a35144d761f42
+  metadata.gz: 44df1b79df5306e323a62c6fd0a6d0b52e6f2da6da8d6a6eb494fb440a9e09909ecd476cf563fa873a42bddedc40dbdc0efefb95cf13982ca69684b11c93050d
+  data.tar.gz: d08476c02adb38cb0978910b0d2448c0f09019ba52592132105612846e51d883d5ab0f26c6ad0f3eaf66c3757f3a93ab59831bfb6652459d47cdf8de37ba342d

data/README.md

@@ -6,7 +6,7 @@ This gem adds support for Rails 5 and AMS 0.10.
 In addition we provide output in [JSON:API](https://jsonapi.org/) format.
 (I'd like to add normal JSON output too, so let me know if that would be helpful to you.)
 
-Building your JSON is Postgres can reduce your response time 10-100x.
+Building your JSON in Postgres can reduce your response time 10 – 100x.
 You skip instantiating thousands of Ruby objects (and garbage collecting them later),
 and Postgres can generate the JSON far more quickly than AMS.
 
@@ -45,6 +45,16 @@ You could also turn it on for everything but then set `adapter: :json_api` for a
 
 Note this gem also respects `ActiveModelSerializers.config.key_transform = :dash`, if you are using that.
 
+### Supports
+
+Here are some other details we support:
+
+- `belongs_to`, `has_one`, and `has_many` associations.
+- If you serialize an `enum` you get the string values, not integers.
+- You can serialize an `alias`'d association.
+- We preserve SQL ordering from a model's `default_scope`.
+- We preserve SQL ordering attached to an association.
+
 ### Methods in Serializers and Models
 
 If you are using methods to compute properties for your JSON responses
@@ -68,6 +78,26 @@ There is no instance of MyModel created so sql computed properties needs to be
 a class method. Right now, this string is used as a SQL literal, so be sure to
 *not* use untrusted values in the return value.
 
+Similarly we also look for a `foo__sql` method
+for relationships that aren't ActiveRecord associations.
+It must return an `ActiveRecord::Relation` (not a `String`),
+and we will run its SQL inside a `LEFT OUTER JOIN LATERAL`
+(so it has access to the parent table). For example:
+
+```ruby
+class Book < ActiveRecord::Base
+
+  def essays_by_same_author
+    Essay.where(author_id: author_id)
+  end
+
+  def self.essays_by_same_author__sql
+    Essay.where("books.author_id = essays.author_id")
+  end
+
+end
+```
+
 ## Developing
 
 To work on active\_model\_serializers\_pg locally, follow these steps:
@@ -89,6 +119,18 @@ Commands for building/releasing/installing:
 * `rake install`
 * `rake release`
 
+### TODO
+
+Here are things I'd like to support but don't yet:
+
+- Use Arel to generate all the SQL.
+- More support of custom scopes attached to associations.
+- Add a non-JSON:API adapter, for traditional JSON output.
+- Have all the tests verify they output the asme JSON as the built-in AMS serializers.
+- Look at AMS's own tests for more features we should support.
+- HABTM associations?
+- `has_many through:` associations?
+
 ## Authors
 
 Paul Jungwirth

data/Rakefile

@@ -82,6 +82,14 @@ namespace :db do
     ActiveRecord::Base.connection.create_table :notes, force: true do |t|
       t.string   "name"
       t.string   "content"
+      t.integer  "state", null: false, default: 0
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
+    ActiveRecord::Base.connection.create_table :long_notes, force: true do |t|
+      t.string   "name"
+      t.text     "long_content"
       t.datetime "created_at"
       t.datetime "updated_at"
     end
@@ -94,6 +102,14 @@ namespace :db do
       t.datetime "updated_at"
     end
 
+    ActiveRecord::Base.connection.create_table :long_tags, force: true do |t|
+      t.integer  "long_note_id"
+      t.string   "long_name"
+      t.boolean  "popular"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
     ActiveRecord::Base.connection.create_table :offers, force: true do |t|
       t.integer  "created_by_id"
       t.integer  "reviewed_by_id"

data/lib/active_model_serializers/adapter/json_api_pg.rb

@@ -1,10 +1,13 @@
 require 'active_model_serializers'
 
+# We don't really need this
+# because we try to inject our own CollectionSerializer,
+# but keeping it lets us give a nice warning message
+# instead of simply crashing:
 module ActiveModel
   class Serializer
     class CollectionSerializer
       def element_serializer
-        # TODO: This is probably not set every time
         options[:serializer]
       end
     end
@@ -56,6 +59,15 @@ module ActiveModelSerializers
         sql
       end
 
+      def self.warn_about_collection_serializer
+          msg = "You are using an ordinary AMS CollectionSerializer with the json_api_pg adapter, which probably means Rails is pointlessly loading all your ActiveRecord instances *and* running the build JSON-building query in Postgres."
+          if Object.const_defined? 'Rails'
+            Rails.logger.warn msg
+          else
+            puts "WARN: #{msg}"
+          end
+      end
+
     end
   end
 end
@@ -317,12 +329,15 @@ class JsonApiPgSql
     # Make a JsonThing for everything,
     # cached as the full_name:
 
-    # User.where is a Relation, but plain User is not:
+    # Watch out: User.where is a Relation, but plain User is not:
     ar_class = ActiveRecord::Relation === base_relation ? base_relation.klass : base_relation
 
     case base_serializer
     when ActiveModel::Serializer::CollectionSerializer
-      # base_serializer = base_serializer.to_a.first
+      ActiveModelSerializers::Adapter::JsonApiPg.warn_about_collection_serializer
+      base_serializer = base_serializer.element_serializer
+      @many = true
+    when ActiveModelSerializersPg::CollectionSerializer
       base_serializer = base_serializer.element_serializer
       @many = true
     else

data/lib/active_model_serializers_pg.rb

@@ -1 +1,6 @@
 require 'active_model_serializers/adapter/json_api_pg'
+require 'active_model_serializers_pg/collection_serializer'
+
+# We have to inject our own CollectionSerializer to avoid materializing ActiveRecord::Relations.
+# See more detailed notes in our class:
+ActiveModel::Serializer.config.collection_serializer = ActiveModelSerializersPg::CollectionSerializer

data/lib/active_model_serializers_pg/collection_serializer.rb

@@ -0,0 +1,117 @@
+# This is a near-verbatim copy of ActiveModel::Serializer::CollectionSerializer,
+# but we patch the `initialize` method to avoid loading the ActiveRecord::Relation.
+# It's still possible to load it if you call `each`, but we do it lazily.
+# This is based on AMS 0.10.8. For each of updates we mark each of our changes
+# with a `PATCHED` comment.
+#
+# It would be nicer to keep this class mostly empty
+# and just delegate to an ActiveModel::Serializer::CollectionSerializer instance when needed,
+# but then we'd still have to instantiate it eventually,
+# any time we proxy a call (not just each),
+# and that materializes the Relation.
+# TODO: Is it possible to replace its `initialize` class? Or is that too wild even for Ruby?
+module ActiveModelSerializersPg
+  class CollectionSerializer
+    include Enumerable
+    # PATCHED: implement this below so we don't need @serializers
+    # delegate :each, to: :@serializers
+
+    attr_reader :object, :root
+
+    def initialize(resources, options = {})
+      @object                  = resources
+      @options                 = options
+      @root                    = options[:root]
+      # PATCHED: We don't want to iterate unless we have to:
+      # @serializers             = serializers_from_resources
+    end
+
+    # PATCH: Give ourselves access to the serializer for the individual elements:
+    def element_serializer
+      options[:serializer]
+    end
+
+    def success?
+      true
+    end
+
+    # @api private
+    def serializable_hash(adapter_options, options, adapter_instance)
+      options[:include_directive] ||= ActiveModel::Serializer.include_directive_from_options(adapter_options)
+      options[:cached_attributes] ||= ActiveModel::Serializer.cache_read_multi(self, adapter_instance, options[:include_directive])
+      serializers.map do |serializer|
+        serializer.serializable_hash(adapter_options, options, adapter_instance)
+      end
+    end
+
+    # TODO: unify naming of root, json_key, and _type.  Right now, a serializer's
+    # json_key comes from the root option or the object's model name, by default.
+    # But, if a dev defines a custom `json_key` method with an explicit value,
+    # we have no simple way to know that it is safe to call that instance method.
+    # (which is really a class property at this point, anyhow).
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # Disabling cop since it's good to highlight the complexity of this method by
+    # including all the logic right here.
+    def json_key
+      return root if root
+      # 1. get from options[:serializer] for empty resource collection
+      key = object.empty? &&
+        (explicit_serializer_class = options[:serializer]) &&
+        explicit_serializer_class._type
+      # 2. get from first serializer instance in collection
+      key ||= (serializer = serializers.first) && serializer.json_key
+      # 3. get from collection name, if a named collection
+      key ||= object.respond_to?(:name) ? object.name && object.name.underscore : nil
+      # 4. key may be nil for empty collection and no serializer option
+      key &&= key.pluralize
+      # 5. fail if the key cannot be determined
+      key || fail(ArgumentError, 'Cannot infer root key from collection type. Please specify the root or each_serializer option, or render a JSON String')
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def paginated?
+      ActiveModelSerializers.config.jsonapi_pagination_links_enabled &&
+        object.respond_to?(:current_page) &&
+        object.respond_to?(:total_pages) &&
+        object.respond_to?(:size)
+    end
+
+    # PATCHED: Add a replacement to `each` so we don't change the interface:
+    def each
+      Rails.logger.debug caller.join("\n")
+      Enumerator.new do |y|
+        serializers_from_resources.each do |ser|
+          y.yield ser
+        end
+      end
+    end
+
+    protected
+
+    attr_reader :serializers, :options
+
+    private
+
+    def serializers_from_resources
+      puts "options here"
+      pp options
+      serializer_context_class = options.fetch(:serializer_context_class, ActiveModel::Serializer)
+      object.map do |resource|
+        serializer_from_resource(resource, serializer_context_class, options)
+      end
+    end
+
+    def serializer_from_resource(resource, serializer_context_class, options)
+      serializer_class = options.fetch(:serializer) do
+        serializer_context_class.serializer_for(resource, namespace: options[:namespace])
+      end
+
+      if serializer_class.nil?
+        ActiveModelSerializers.logger.debug "No serializer found for resource: #{resource.inspect}"
+        throw :no_serializer
+      else
+        serializer_class.new(resource, options.except(:serializer))
+      end
+    end
+  end
+end

data/lib/active_model_serializers_pg/version.rb

@@ -1,3 +1,3 @@
 module ActiveModelSerializersPg
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/serializer_spec.rb

@@ -134,6 +134,68 @@ describe 'ArraySerializer' do
       }.to_json
       expect(json_data).to eq json_expected
     end
+
+  end
+
+  context 'with dasherized keys and types' do
+    let(:relation)   { LongNote.where(name: 'Title').first }
+    let(:controller) { LongNotesController.new }
+    let(:options)    { { include: ['long_tags'] } }
+
+    before do
+      @note = LongNote.create long_content: 'Test', name: 'Title'
+      @tag = LongTag.create long_name: 'My tag', long_note: @note, popular: true
+      @old_key_setting = ActiveModelSerializers.config.key_transform
+      ActiveModelSerializers.config.key_transform = :dash
+    end
+
+    after do
+      ActiveModelSerializers.config.key_transform = @old_key_setting
+    end
+
+    it 'generates the proper json output' do
+      json_expected = {
+        data: {
+          id: @note.id.to_s,
+          type: 'long-notes',
+          attributes: { name: 'Title', 'long-content' => 'Test' },
+          relationships: { 'long-tags': { data: [{id: @tag.id.to_s, type: 'long-tags'}] } }
+        },
+        included: [
+          {
+            id: @tag.id.to_s,
+            type: 'long-tags',
+            attributes: { 'long-name' => 'My tag' },
+            relationships: { 'long-note' => { data: { id: @note.id.to_s, type: 'long-notes' } } },
+          }
+        ]
+      }.to_json
+      expect(json_data).to eq json_expected
+    end
+  end
+
+  context 'with aliased association' do
+    let(:relation)   { Tag.first }
+    let(:controller) { TagsController.new }
+    let(:options)    { { serializer: TagWithAliasedNoteSerializer } }
+
+    before do
+      @note = Note.create content: 'Test', name: 'Title'
+      @tag = Tag.create name: 'My tag', note: @note, popular: true
+    end
+
+    it 'generates the proper json output' do
+      json_expected = {
+        data: {
+          id: @tag.id.to_s,
+          type: 'tags',
+          attributes: { name: 'My tag' },
+          relationships: { aliased_note: { data: {id: @note.id.to_s, type: 'notes'} } }
+        }
+      }.to_json
+      expect(json_data).to eq json_expected
+    end
+
   end
 
   context 'serialize single record with custom serializer' do
@@ -241,7 +303,21 @@ describe 'ArraySerializer' do
     end
 
     it 'does not instantiate ruby objects for relations' do
-      expect(relation).not_to receive(:to_a)
+      # It would be nice to do this instead:
+      #
+      #     expect(relation).not_to receive(:load)
+      #
+      # or
+      #
+      #     expect(relation).not_to receive(:records)
+      #
+      # But that causes an infinite loop because rspec works by raising an exception,
+      # and ActiveRecord notices that and wants to print an error message,
+      # calling `inspect` on the Relation, which tries to load the relation, which....
+      # The test still fails, but not in an articulate or informative way.
+      # TODO: We could probably write our own customer matcher to work around that,
+      # but this does the job for now:
+      expect(ActiveModelSerializers::Adapter::JsonApiPg).not_to receive(:warn_about_collection_serializer)
       json_data
     end
   end
@@ -273,7 +349,7 @@ describe 'ArraySerializer' do
     end
 
     it 'does not instantiate ruby objects for relations' do
-      expect(relation).not_to receive(:to_a)
+      expect(ActiveModelSerializers::Adapter::JsonApiPg).not_to receive(:warn_about_collection_serializer)
       json_data
     end
   end
@@ -307,12 +383,11 @@ describe 'ArraySerializer' do
     end
 
     it 'generates the proper json output for the serializer' do
-      puts json_data
       expect(json_data).to eq @json_expected
     end
 
     it 'does not instantiate ruby objects for relations' do
-      expect(relation).not_to receive(:to_a)
+      expect(ActiveModelSerializers::Adapter::JsonApiPg).not_to receive(:warn_about_collection_serializer)
       json_data
     end
   end
@@ -354,7 +429,7 @@ describe 'ArraySerializer' do
     end
 
     it 'does not instantiate ruby objects for relations' do
-      expect(relation).not_to receive(:to_a)
+      expect(ActiveModelSerializers::Adapter::JsonApiPg).not_to receive(:warn_about_collection_serializer)
       json_data
     end
   end
@@ -373,7 +448,7 @@ describe 'ArraySerializer' do
     end
 
     it 'does not instantiate ruby objects for relations' do
-      expect(relation).not_to receive(:to_a)
+      expect(ActiveModelSerializers::Adapter::JsonApiPg).not_to receive(:warn_about_collection_serializer)
       json_data
     end
   end
@@ -402,11 +477,40 @@ describe 'ArraySerializer' do
     end
 
     it 'does not instantiate ruby objects for relations' do
-      expect(relation).not_to receive(:to_a)
+      expect(ActiveModelSerializers::Adapter::JsonApiPg).not_to receive(:warn_about_collection_serializer)
       json_data
     end
   end
 
+  context 'with enums' do
+    let(:relation)   { Note.order(:id) }
+    let(:controller) { NotesController.new }
+    let(:options)    { { each_serializer: NoteWithStateSerializer, fields: { note: [:name, :state] } } }
+
+    before do
+      @note1 = Note.create content: 'Test', name: 'Title 1', state: Note::Published
+      @note2 = Note.create content: 'Test', name: 'Title 2', state: Note::Deleted
+    end
+
+    it 'converts enum ints to strings' do
+      json_expected = {
+        data: [
+          {
+            id: @note1.id.to_s,
+            type: 'notes',
+            attributes: { name: 'Title 1', state: 'published' },
+          },
+          {
+            id: @note2.id.to_s,
+            type: 'notes',
+            attributes: { name: 'Title 2', state: 'deleted' },
+          }
+        ]
+      }.to_json
+      expect(json_data).to eq json_expected
+    end
+  end
+
   context 'support for include_[attrbute]' do
     let(:relation)   { User.all }
     let(:controller) { UsersController.new }
@@ -565,15 +669,7 @@ describe 'ArraySerializer' do
 
   pending 'obeys serializer option in has_many relationship'  # Does AMS 0.10 still support this?
 
-  pending 'obeys overall :include option'
-
   pending 'obeys :include option in serializer association'   # Does AMS 0.10 still support this?
 
-  pending 'figures out aliased associations'
-
-  pending 'makes dasherized keys and types'
-
-  pending 'serializes enums'
-
   pending 'uses __sql methods for relationships'
 end

data/spec/spec_helper.rb

@@ -61,6 +61,10 @@ class Note < ActiveRecord::Base
   has_many :sorted_tags
   has_many :custom_sorted_tags, lambda { order(:name) }, class_name: 'Tag'
   has_many :popular_tags, lambda { where(popular: true) }, class_name: 'Tag'
+  Draft     = :draft
+  Published = :published
+  Deleted   = :deleted
+  enum state: [Draft, Published, Deleted]
 end
 
 class NotesController < TestController; end
@@ -70,6 +74,22 @@ class NoteSerializer < ActiveModel::Serializer
   has_many   :tags
 end
 
+class NoteWithStateSerializer < ActiveModel::Serializer
+  attributes :content, :name, :state
+  has_many   :tags
+end
+
+class LongNote < ActiveRecord::Base
+  has_many :long_tags
+end
+
+class LongNotesController < TestController; end
+
+class LongNoteSerializer < ActiveModel::Serializer
+  attributes :long_content, :name
+  has_many :long_tags
+end
+
 class ShortTagSerializer < ActiveModel::Serializer
   attributes :id, :name
 end
@@ -105,6 +125,7 @@ end
 
 class Tag < ActiveRecord::Base
   belongs_to :note
+  alias :aliased_note :note
 end
 
 class SortedTag < Tag
@@ -112,6 +133,15 @@ class SortedTag < Tag
   default_scope { order(:name) }
 end
 
+class LongTag < ActiveRecord::Base
+  belongs_to :long_note
+end
+
+class LongTagSerializer < ActiveModel::Serializer
+  attributes :long_name
+  belongs_to :long_note
+end
+
 class TagWithNote < Tag
   belongs_to :note
   default_scope { joins(:note) }
@@ -129,6 +159,11 @@ class TagWithNoteSerializer < ActiveModel::Serializer
   has_one :note
 end
 
+class TagWithAliasedNoteSerializer < ActiveModel::Serializer
+  attributes :name
+  has_one :aliased_note
+end
+
 class User < ActiveRecord::Base
   has_many :offers, foreign_key: :created_by_id, inverse_of: :created_by
   has_many :reviewed_offers, foreign_key: :reviewed_by_id, inverse_of: :reviewed_by, class_name: 'Offer'
@@ -172,7 +207,6 @@ DatabaseCleaner.strategy = :deletion
 RSpec.configure do |config|
   config.before(:each) do
     DatabaseCleaner.start
-    # FactoryBot.lint
   end
 
   config.after(:each) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers_pg
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Paul A. Jungwirth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-12 00:00:00.000000000 Z
+date: 2019-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -170,6 +170,7 @@ files:
 - gemfiles/Gemfile.activerecord-5.2.x
 - lib/active_model_serializers/adapter/json_api_pg.rb
 - lib/active_model_serializers_pg.rb
+- lib/active_model_serializers_pg/collection_serializer.rb
 - lib/active_model_serializers_pg/version.rb
 - spec/serializer_spec.rb
 - spec/spec_helper.rb