active_model_serializers_pg 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61aa96dfaadcdbb0304b0a8ea50b05468ad7474c6d3b740419c8bf525f28c01
-  data.tar.gz: 1d5dfd08ff5168add108de4854246f48ed564b0548d8a66155068d26d41f4805
+  metadata.gz: 63d2090a2d7e9e33d8565156023d5c3dc75ea74c77baade84c5c0727d3ab917f
+  data.tar.gz: d1abc37c7a6dade9d9bacb7584b5e630f81652a87d28849dacc6bcbb5291c7d9
 SHA512:
-  metadata.gz: 32d433d676644d637de1cfda49d340f35221a6f1a08a5b8b74f605018e5f4169a45ec50bfcafe2c2fc20cb95e53cdaa98123e2b25b3246cafb276c2e68926301
-  data.tar.gz: d21913bd9baa516e016adcea39c28f4ce05446753553676485fd75cca1fbce1e36727df16bca2d6004b999ba6850d9ec14dc6bf29ac2f1c25660ee3b84dd31ae
+  metadata.gz: ec68d79eacdcbb257753fa6636236b406e2a57012aa68aba4d8f1ff564bd072653cfc6da4daa07ebe17bce5be0913d6e93da7cadccf6c4d637467d4026cdc21c
+  data.tar.gz: 0a7726480564582f54afcc91b8f7666ceb8416a772a8b34623b252723bb36b545a19491894b07b06372cbbfc5313473e8b12f80899e4c7d6705bdaef10ac8235

data/lib/active_model_serializers/adapter/json_api_pg.rb

@@ -8,7 +8,7 @@ module ActiveModel
   class Serializer
     class CollectionSerializer
       def element_serializer
-        options[:serializer]
+        options && options[:serializer]
       end
     end
   end
@@ -23,7 +23,16 @@ module ActiveModelSerializers
       end
 
       def to_json(options={})
-        connection.select_value serializer_sql
+        if relation.nil?
+          ret = { data: [] }
+          if includes.any?
+            # TODO: Can included ever be non-empty when the main data is empty?
+            ret[:included] = []
+          end
+          ret.to_json
+        else
+          connection.select_value serializer_sql
+        end
       end
 
       def relation
@@ -32,6 +41,10 @@ module ActiveModelSerializers
 
       private
 
+      def includes
+        instance_options && instance_options[:include] || []
+      end
+
       def connection
         @connection ||= relation.connection
       end
@@ -42,8 +55,12 @@ module ActiveModelSerializers
         when ActiveRecord::Relation
           o
         when Array
-          # TODO: determine what class it is, even if the array is empty
-          o.first.class.where(id: o.map(&:id))
+          o2 = o.first
+          if o2.nil?
+            nil
+          else
+            o2.class.where(id: o.map(&:id))
+          end
         when ActiveRecord::Base
           o.class.where(id: o.id)
         else
@@ -92,7 +109,7 @@ end
 # I think think older versions of Rails even used that internally,
 # but nowadays the method names use "reflection".)
 class JsonThing
-  attr_reader :ar_class, :full_name, :name, :serializer, :serializer_options, :json_key, :json_type, :reflection, :parent, :cte_name
+  attr_reader :ar_class, :full_name, :name, :serializer, :serializer_options, :json_key, :json_type, :reflection, :parent, :cte_name, :jbs_name
   delegate :table_name, :primary_key, to: :ar_class
   delegate :foreign_key, :belongs_to?, :has_many?, :has_one?, to: :reflection
 
@@ -113,6 +130,7 @@ class JsonThing
     @parent = parent_json_thing
 
     @cte_name = _cte_name
+    @jbs_name = _jbs_name
     @sql_methods = {}
   end
 
@@ -145,6 +163,15 @@ class JsonThing
     ]
   end
 
+  # Checks for alias_attribute and gets to the real attribute name.
+  def unaliased(field_name)
+    ret = field_name
+    while field_name = @ar_class.attribute_aliases[field_name.to_s]
+      ret = field_name
+    end
+    ret
+  end
+
   # TODO: tests
   def self.json_key(k)
     # TODO: technically the serializer could have an option overriding the default:
@@ -179,10 +206,38 @@ class JsonThing
     if parent.nil?
       't'
     else
-      "cte_#{Digest::SHA256.hexdigest(full_name).first(10)}"
+      "cte_#{_cte_name_human_part}_#{Digest::SHA256.hexdigest(full_name).first(10)}"
     end
   end
 
+  # Each thing has bother a `cte_foo` CTE and a `jbs_foo` CTE.
+  # (jbs stands for "JSONBs" and is meant to take 3 chars like `cte`.)
+  # The former is just the relevant records,
+  # and the second builds the JSON object for each record.
+  # We need to split things into phases like this
+  # because of the JSON:API `relationships` item,
+  # which can contain references in *both directions*.
+  # In that case Postgres will object to our circular dependency.
+  # But with two phases, every jbs_* CTE only depends on cte_* CTEs.
+  def _jbs_name
+    if parent.nil?
+      't'
+    else
+      "jbs_#{_cte_name_human_part}_#{Digest::SHA256.hexdigest(full_name).first(10)}"
+    end
+  end
+
+  # Gets a more informative name for the CTE based on the include key.
+  # This makes reading the big SQL query easier, especially for debugging.
+  # Note that Postgres's max identifier length is 63 chars (unless you compile yourself),
+  # and we are spending 4+4+11=19 chars elsewhere on `rel_cte_XXX_1234567890`.
+  # So this method can't return more than 63-19=44 chars.
+  #
+  # Since we quote the CTE names, we don't actually need to remove dots in the name!
+  def _cte_name_human_part
+    @cte_name_human_part ||= full_name[0, 44]
+  end
+
   def _sql_method(field)
     m = "#{field}__sql".to_sym
     if ar_class.respond_to?(m)
@@ -397,7 +452,7 @@ class JsonApiPgSql
     elsif resource.has_sql_method?(field)
       resource.sql_method(field)
     else
-      %Q{"#{resource.table_name}"."#{field}"}
+      %Q{"#{resource.table_name}"."#{resource.unaliased(field)}"}
     end
   end
 
@@ -423,7 +478,7 @@ class JsonApiPgSql
       refl = resource.reflection
       <<~EOQ
         '#{resource.json_key}',
-         jsonb_build_object(#{refl.include_data ? %Q{'data', rel_#{resource.cte_name}.j} : ''}
+         jsonb_build_object(#{refl.include_data ? %Q{'data', "rel_#{resource.cte_name}".j} : ''}
                             #{refl.include_data && refl.links.any? ? ',' : ''}
                             #{refl.links.any? ? %Q{'links',  jsonb_build_object(#{select_resource_relationship_links(resource, refl)})} : ''})
       EOQ
@@ -521,39 +576,51 @@ class JsonApiPgSql
       # e.g. buyer and seller for User.
       # But we could group those and union just them, or even better do a DISTINCT ON (id).
       # Since we don't get the id here that could be another CTE.
-      "UNION SELECT j FROM #{th.cte_name}"
+      %Q{UNION SELECT j FROM "#{th.jbs_name}"}
     }
   end
 
   def include_cte_join_condition(resource)
     parent = resource.parent
     if resource.belongs_to?
-      %Q{#{parent.cte_name}."#{resource.foreign_key}" = "#{resource.table_name}"."#{resource.primary_key}"}
+      %Q{"#{parent.cte_name}"."#{resource.foreign_key}" = "#{resource.table_name}"."#{resource.primary_key}"}
     elsif resource.has_many? or resource.has_one?
-      %Q{#{parent.cte_name}."#{parent.primary_key}" = "#{resource.table_name}"."#{resource.foreign_key}"}
+      %Q{"#{parent.cte_name}"."#{parent.primary_key}" = "#{resource.table_name}"."#{resource.foreign_key}"}
     else
       raise "not supported relationship: #{resource.full_name}"
     end
   end
 
+  # See note in _jbs_name method for why we split each thing into two CTEs.
   def include_cte(resource)
     # Sometimes options[:fields] has plural keys and sometimes singular,
     # so try both:
     parent = resource.parent
     <<~EOQ
       SELECT  DISTINCT ON ("#{resource.table_name}"."#{resource.primary_key}")
-              "#{resource.table_name}".*,
-              #{select_resource(resource)} AS j
+              "#{resource.table_name}".*
       FROM    "#{resource.table_name}"
-      JOIN    #{parent.cte_name}
+      JOIN    "#{parent.cte_name}"
       ON      #{include_cte_join_condition(resource)}
-      #{join_resource_relationships(resource)}
       ORDER BY "#{resource.table_name}"."#{resource.primary_key}"
     EOQ
   end
 
+  # See note in _jbs_name method for why we split each thing into two CTEs.
+  def include_jbs(resource)
+    <<~EOQ
+      SELECT  "#{resource.table_name}".*,
+              #{select_resource(resource)} AS j
+      FROM    "#{resource.cte_name}" AS "#{resource.table_name}"
+      #{join_resource_relationships(resource)}
+    EOQ
+  end
+
   def includes
-    @instance_options[:include] || []
+    @includes ||= (@instance_options[:include] || []).sort_by do |inc|
+      # Sort these by length so we never have bad foreign references in the CTEs:
+      inc.size
+    end
   end
 
   # Takes a dotted field name (not including the base resource)
@@ -572,13 +639,25 @@ class JsonApiPgSql
       # Be careful: inc might have dots:
       th = get_json_thing_from_base(inc)
       <<~EOQ
-        #{th.cte_name} AS (
+        "#{th.cte_name}" AS (
           #{include_cte(th)}
         ),
       EOQ
     }.join("\n")
   end
 
+  def include_jbsses
+    includes.map { |inc|
+      # Be careful: inc might have dots:
+      th = get_json_thing_from_base(inc)
+      <<~EOQ
+        "#{th.jbs_name}" AS (
+          #{include_jbs(th)}
+        ),
+      EOQ
+    }.join("\n")
+  end
+
   def base_resource
     @json_things[:base]
   end
@@ -687,14 +766,15 @@ class JsonApiPgSql
         #{join_resource_relationships(base_resource)}
       ),
       #{include_ctes}
-      all_ctes AS (
+      #{include_jbsses}
+      all_jbsses AS (
         SELECT  '{}'::jsonb AS j
         WHERE   1=0
         #{include_selects.join("\n")}
       ),
       inc AS (
         SELECT  COALESCE(jsonb_agg(j), '[]') AS j
-        FROM    all_ctes
+        FROM    all_jbsses
       )
 			SELECT	jsonb_build_object('data', t2.j
                                  #{maybe_included})

data/lib/active_model_serializers_pg/version.rb

@@ -1,3 +1,3 @@
 module ActiveModelSerializersPg
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/spec/serializer_spec.rb

@@ -113,6 +113,42 @@ describe 'ArraySerializer' do
     end
   end
 
+  context 'serialize an array instead of a relation' do
+    let(:relation)   { [Note.where(name: 'Title').first] }
+    let(:controller) { NotesController.new }
+    let(:options)    { }
+
+    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: @note.id.to_s,
+            type: 'notes',
+            attributes: { name: 'Title', content: 'Test' },
+            relationships: { tags: { data: [{id: @tag.id.to_s, type: 'tags'}] } }
+          }
+        ]
+      }.to_json
+      expect(json_data).to eq json_expected
+    end
+  end
+
+  context 'serialize an empty array' do
+    let(:relation)   { [] }
+    let(:controller) { NotesController.new }
+    let(:options)    { }
+
+    it 'generates the proper json output' do
+      json_expected = { data: [] }.to_json
+      expect(json_data).to eq json_expected
+    end
+  end
+
   context 'serialize singular record' do
     let(:relation)   { Note.where(name: 'Title').first }
     let(:controller) { NotesController.new }
@@ -134,7 +170,6 @@ describe 'ArraySerializer' do
       }.to_json
       expect(json_data).to eq json_expected
     end
-
   end
 
   context 'with dasherized keys and types' do
@@ -195,7 +230,29 @@ describe 'ArraySerializer' do
       }.to_json
       expect(json_data).to eq json_expected
     end
+  end
+
+  context 'with aliased attribute' do
+    let(:relation)   { Tag.first }
+    let(:controller) { TagsController.new }
+    let(:options)    { { serializer: TagWithAliasedNameSerializer } }
 
+    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: { 'aliased_name' => 'My tag' },
+          relationships: { 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

data/spec/spec_helper.rb

@@ -126,6 +126,7 @@ end
 class Tag < ActiveRecord::Base
   belongs_to :note
   alias :aliased_note :note
+  alias_attribute :aliased_name, :name
 end
 
 class SortedTag < Tag
@@ -164,6 +165,11 @@ class TagWithAliasedNoteSerializer < ActiveModel::Serializer
   has_one :aliased_note
 end
 
+class TagWithAliasedNameSerializer < ActiveModel::Serializer
+  attributes :aliased_name
+  has_one :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'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers_pg
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Paul A. Jungwirth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-16 00:00:00.000000000 Z
+date: 2019-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers