active_model_serializers_pg 0.0.2 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bdfe8c6e1f9a0fbca6e444a7594474d43d9415008c86f6fe30964088fc8c1f7
-  data.tar.gz: 0e5a9f884cda2663bf2f36051ad42367381ea5f61798048cd4ae774c19c76265
+  metadata.gz: 709fe0bce48637cbd10e3f8a4cc66d9332da0a36ea2158153711c2f49bcdc82f
+  data.tar.gz: bbc3e6c16daf9b8c28ce8d105d1dc355c35b1188b935051447c6b5fab96acda0
 SHA512:
-  metadata.gz: 44df1b79df5306e323a62c6fd0a6d0b52e6f2da6da8d6a6eb494fb440a9e09909ecd476cf563fa873a42bddedc40dbdc0efefb95cf13982ca69684b11c93050d
-  data.tar.gz: d08476c02adb38cb0978910b0d2448c0f09019ba52592132105612846e51d883d5ab0f26c6ad0f3eaf66c3757f3a93ab59831bfb6652459d47cdf8de37ba342d
+  metadata.gz: c323f581ecea8145344d4fe95df91a76d548762de320a43513eb7081842d30b28e81fb33a4adc3cca173964d17ce5ba7c384e27043cf9aca68e0ca161b9b83b9
+  data.tar.gz: 076e6dad498e0d0533fe63f4a396099c61557c7b2a05a17ebe910f2caca61b11d4cf005351570e7a4579447e9c427ff7298b759f35a15bfe27749144bee44292

data/README.md

@@ -31,6 +31,13 @@ Or install it yourself as:
 
     gem install active_model_serializers_pg
 
+### Migrations
+
+This gem depends on a SQL function to dasherize hstore/json/jsonb columns, so you must add its migration to your project and run it, like this:
+
+    rails g active_model_serializers_pg
+    rake db:migrate
+
 ## Usage
 
 You can enable in-Postgres serialization for everything by putting this in a Rails initializer:
@@ -52,8 +59,10 @@ 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.
+- You can serialize an `alias_attribute`'d column.
 - We preserve SQL ordering from a model's `default_scope`.
 - We preserve SQL ordering attached to an association.
+- When dasherizing we also dasherize json/jsonb/hstore contents (like standard AMS).
 
 ### Methods in Serializers and Models
 

data/Rakefile

@@ -72,9 +72,17 @@ namespace :db do
   task :migrate => :load_db_settings do
     ActiveRecord::Base.establish_connection
 
+    ActiveRecord::Base.connection.execute "CREATE EXTENSION hstore"
+
     ActiveRecord::Base.connection.create_table :people, force: true do |t|
       t.string   "first_name"
       t.string   "last_name"
+      t.json     "options"
+      t.jsonb    "prefs"
+      t.hstore   "settings"
+      t.json     "selfies", array: true
+      t.jsonb    "portraits", array: true
+      t.hstore   "landscapes", array: true
       t.datetime "created_at"
       t.datetime "updated_at"
     end
@@ -131,6 +139,8 @@ namespace :db do
       t.datetime "updated_at"
     end
 
+    ActiveRecord::Base.connection.execute File.read(File.expand_path('../lib/generators/active_record/templates/jsonb_dasherize.sql', __FILE__))
+
     puts 'Database migrated'
   end
 end

data/active_model_serializers_pg.gemspec

@@ -25,6 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'actionpack', '> 4.0'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'generator_spec'
   spec.add_development_dependency 'bourne', '~> 1.3.0'
   spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'dotenv'

data/gemfiles/Gemfile.activerecord-5.0.x

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 
 gemspec :path => '..'
 
-gem "activerecord", "~>5.0.0"
+gem "rails", "~>5.0.0"

data/gemfiles/Gemfile.activerecord-5.1.x

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 
 gemspec :path => '..'
 
-gem "activerecord", "~>5.1.0"
+gem "rails", "~>5.1.0"

data/gemfiles/Gemfile.activerecord-5.2.x

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 
 gemspec :path => '..'
 
-gem "activerecord", "~>5.2.0"
+gem "rails", "~>5.2.0"

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
@@ -60,7 +77,7 @@ module ActiveModelSerializers
       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."
+          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 JSON-building query in Postgres."
           if Object.const_defined? 'Rails'
             Rails.logger.warn msg
           else
@@ -88,11 +105,11 @@ end
 # i.e. how you got here, not how you'd leave:
 # "Reflection" seems to be the internal ActiveRecord lingo
 # for a belongs_to or has_many relationship.
-# (The public documentation calls these "associations",
-# I think think older versions of Rails even used that internally,
+# (The public documentation calls these "associations".
+# I 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
 
@@ -123,26 +141,17 @@ class JsonThing
     JsonThing.new(refl.klass, "#{full_name}.#{reflection_name}", nil, serializer_options, refl, self)
   end
 
-  # Gets the attributes (i.e. scalar fields) on the AR class
-  # as a Set of symbols.
-  # TODO: tests
-	def declared_attributes
-    @declared_attributes ||= Set.new(@ar_class.attribute_types.keys.map(&:to_sym))
-  end
-
   def enum?(field)
     @ar_class.attribute_types[field.to_s].is_a? ActiveRecord::Enum::EnumType
   end
 
-  # Gets the reflections (aka associations) of the AR class
-  # as a Hash from symbol to a subclass of ActiveRecord::Reflection.
-  # TODO: tests
-  def declared_reflections
-    @declared_reflections ||= Hash[
-      @ar_class.reflections.map{|k, v|
-        [k.to_sym, v]
-      }
-    ]
+  # 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
@@ -179,10 +188,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 both 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)
@@ -321,6 +358,15 @@ end
 class JsonApiPgSql
   attr_reader :base_serializer, :base_relation
 
+  def self.json_column_type
+    # These classes may not exist, depending on the Rails version:
+    @@json_column_type = if Rails::VERSION::STRING >= '5.2'
+                           'ActiveRecord::Type::Json'
+                         else
+                           'ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Json'
+                         end.constantize
+  end
+
   def initialize(base_serializer, base_relation, instance_options, options)
     @base_relation = base_relation
     @instance_options = instance_options
@@ -397,10 +443,54 @@ class JsonApiPgSql
     elsif resource.has_sql_method?(field)
       resource.sql_method(field)
     else
-      %Q{"#{resource.table_name}"."#{field}"}
+      field = resource.unaliased(field)
+      # Standard AMS dasherizes json/jsonb/hstore columns,
+      # so we have to do the same:
+      if ActiveModelSerializers.config.key_transform == :dash
+        cl = resource.ar_class.attribute_types[field.to_s]
+        if column_is_jsonb? cl
+          %Q{jsonb_dasherize("#{resource.table_name}"."#{field}")}
+        elsif column_is_jsonb_array? cl
+          # TODO: Could be faster:
+          # If we made the jsonb_dasherize function smarter so it could handle jsonb[],
+          # we wouldn't have to build a json object from the array then cast to jsonb[].
+          %Q{jsonb_dasherize(array_to_json("#{resource.table_name}"."#{field}")::jsonb)}
+        elsif column_is_castable_to_jsonb? cl
+          # Fortunately we can cast hstore to jsonb,
+          # which gives us a solution that works whether or not the hstore extension is installed.
+          # Defining an hstore_dasherize function would work only if the extension were present.
+          %Q{jsonb_dasherize("#{resource.table_name}"."#{field}"::jsonb)}
+        elsif column_is_castable_to_jsonb_array? cl
+          # TODO: Could be faster (see above):
+          %Q{jsonb_dasherize(array_to_json("#{resource.table_name}"."#{field}"::jsonb[])::jsonb)}
+        else
+          %Q{"#{resource.table_name}"."#{field}"}
+        end
+      else
+        %Q{"#{resource.table_name}"."#{field}"}
+      end
     end
   end
 
+  def column_is_jsonb?(column_class)
+    column_class.is_a? ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb
+  end
+
+  def column_is_jsonb_array?(column_class)
+    column_class.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) and
+      column_class.subtype.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb)
+  end
+
+  def column_is_castable_to_jsonb?(column_class)
+    column_class.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore) or
+      column_class.is_a?(self.class.json_column_type)
+  end
+
+  def column_is_castable_to_jsonb_array?(column_class)
+    column_class.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) and
+      column_is_castable_to_jsonb?(column_class.subtype)
+  end
+
   def select_resource_relationship_links(resource, reflection)
     reflection.links.map {|link_name, link_parts|
       <<~EOQ
@@ -423,7 +513,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 +611,49 @@ 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 +672,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
@@ -609,7 +721,7 @@ class JsonApiPgSql
     resource.serializer._attributes.select{|f|
       if ms.include? "include_#{f}?".to_sym
         ser = resource.serializer.new(nil, @options)
-        ser.send("include_#{f}?".to_sym) # TODO: call the method
+        ser.send("include_#{f}?".to_sym)
       else
         true
       end
@@ -623,7 +735,7 @@ class JsonApiPgSql
     resource.serializer._reflections.keys.select{|f|
       if ms.include? "include_#{f}?".to_sym
         ser = resource.serializer.new(nil, @options)
-        ser.send("include_#{f}?".to_sym) # TODO: call the method
+        ser.send("include_#{f}?".to_sym)
       else
         true
       end
@@ -656,6 +768,9 @@ class JsonApiPgSql
 
   def _attribute_fields_for(resource)
     attrs = Set.new(serializer_attributes(resource))
+    # JSON:API always excludes the `id`
+    # even if it's part of the serializer:
+    attrs = attrs - [resource.primary_key.to_sym]
     fields_for(resource).select { |f| attrs.include? f }.to_a
   end
 
@@ -687,14 +802,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/collection_serializer.rb

@@ -15,6 +15,7 @@ module ActiveModelSerializersPg
     include Enumerable
     # PATCHED: implement this below so we don't need @serializers
     # delegate :each, to: :@serializers
+    delegate :each, to: :serializers
 
     attr_reader :object, :root
 
@@ -22,8 +23,13 @@ module ActiveModelSerializersPg
       @object                  = resources
       @options                 = options
       @root                    = options[:root]
-      # PATCHED: We don't want to iterate unless we have to:
-      # @serializers             = serializers_from_resources
+      # PATCHED: We don't want to materialize a Relation by iterating unless we have to.
+      # On the other hand, if we don't have a serializer we *do* want to `throw :no_serializer`
+      # right away. That should only happen for basic types (like a String or Hash),
+      # so we act lazy when we have a Relation, and eager otherwise:
+      unless resources.is_a? ActiveRecord::Relation
+        @serializers = serializers_from_resources
+      end
     end
 
     # PATCH: Give ourselves access to the serializer for the individual elements:
@@ -76,25 +82,17 @@ module ActiveModelSerializersPg
         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
+    attr_reader :options
+
+    def serializers
+      @serializers ||= serializers_from_resources
+    end
 
     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)

data/lib/active_model_serializers_pg/version.rb

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

data/lib/generators/active_model_serializers_pg/active_model_serializers_pg_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators'
+
+module ActiveModelSerializersPg
+  module Generators
+    class ActiveModelSerializersPgGenerator < Rails::Generators::NamedBase
+      Rails::Generators::ResourceHelpers
+
+      # The ORM generator assumes you're passing a name argument,
+      # but we don't need one, so we give it a default value:
+      argument :name, type: :string, default: "ignored"
+      source_root File.expand_path("../templates", __FILE__)
+
+      namespace :active_model_serializers_pg
+      hook_for :orm, required: true, name: "ignored"
+
+      desc "Creates an active_model_serialiers_pg database migration"
+
+    end
+  end
+end

data/lib/generators/active_record/active_model_serializers_pg_generator.rb

@@ -0,0 +1,43 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class ActiveModelSerializersPgGenerator < ActiveRecord::Generators::Base
+      argument :name, type: :string, default: "ignored"
+      source_root File.expand_path("../templates", __FILE__)
+
+      def write_migration
+        migration_template "migration.rb", "#{migration_path}/ams_pg_create_dasherize_functions.rb"
+      end
+
+      private
+
+      def read_sql(funcname)
+        File.read(File.join(File.expand_path('../templates', __FILE__), "#{funcname}.sql"))
+      end
+
+      def migration_exists?(table_name)
+        Dir.glob("#{File.join destination_root, migration_path}/[0-9]*_*.rb").grep(/\d+_ams_pg_create_dasherize_functions.rb$/).first
+      end
+
+      def migration_path
+        if Rails.version >= '5.0.3'
+          db_migrate_path
+        else
+          @migration_path ||= File.join "db", "migrate"
+        end
+      end
+
+      def migration_version
+        if Rails.version.start_with? '5'
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+
+      def jsonb_dasherize
+        read_sql('jsonb_dasherize')
+      end
+
+    end
+  end
+end

data/lib/generators/active_record/templates/jsonb_dasherize.sql

@@ -0,0 +1,32 @@
+CREATE FUNCTION jsonb_dasherize(j jsonb)
+RETURNS jsonb
+IMMUTABLE
+AS
+$$
+DECLARE
+t text;
+ret jsonb;
+BEGIN
+  t := jsonb_typeof(j);
+  IF t = 'object' THEN
+    SELECT  COALESCE(jsonb_object_agg(REPLACE(k, '_', '-'), jsonb_dasherize(v)), '{}')
+    INTO    ret
+    FROM    jsonb_each(j) AS t(k, v);
+    RETURN ret;
+  ELSIF t = 'array' THEN
+    SELECT  COALESCE(jsonb_agg(jsonb_dasherize(elem)), '[]')
+    INTO    ret
+    FROM    jsonb_array_elements(j) AS t(elem);
+    RETURN ret;
+  ELSIF t IS NULL THEN
+    -- This should never happen internally
+    -- (thankfully, lest jsonb_set return NULL and destroy everything),
+    -- but only from a passed-in NULL.
+    RETURN NULL;
+  ELSE
+    -- string/number/null:
+    RETURN j;
+  END IF;
+END;
+$$
+LANGUAGE plpgsql;

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,11 @@
+class AmsPgCreateDasherizeFunctions < ActiveRecord::Migration<%= migration_version %>
+
+  def up
+    execute %q{<%= jsonb_dasherize %>}
+  end
+
+  def down
+    execute "DROP FUNCTION jsonb_dasherize(jsonb)"
+  end
+
+end

data/spec/generators/main_generator_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'generators/active_model_serializers_pg/active_model_serializers_pg_generator'
+
+describe ActiveModelSerializersPg::Generators::ActiveModelSerializersPgGenerator, type: :generator do
+  destination File.expand_path "../../../tmp", __FILE__
+
+  before :each do
+    prepare_destination
+  end
+
+  it "creates the migration file" do
+    run_generator
+    expect(destination_root).to have_structure {
+      directory "db" do
+        directory "migrate" do
+          migration "ams_pg_create_dasherize_functions" do
+            contains "class AmsPgCreateDasherizeFunctions"
+          end
+        end
+      end
+    }
+  end
+end

data/spec/serializer_spec.rb

@@ -25,7 +25,7 @@ describe 'ArraySerializer' do
           {
             id: @note.id.to_s,
             type: 'notes',
-            attributes: {id: @note.id, name: 'Title'},
+            attributes: {name: 'Title'},
             relationships: {tags: {data: [{id: @tag.id.to_s, type: 'tags'}]}},
           }
         ]
@@ -65,7 +65,7 @@ describe 'ArraySerializer' do
           {
             id: person.id.to_s,
             type: 'people',
-            attributes: { id: person.id, full_name: 'Test User', attendance_name: 'User, Test' },
+            attributes: { full_name: 'Test User', attendance_name: 'User, Test' },
           }
         ]
       }.to_json
@@ -80,7 +80,7 @@ describe 'ArraySerializer' do
           {
             id: person.id.to_s,
             type: 'people',
-            attributes: {id: person.id, full_name: 'Test User', attendance_name: 'ADMIN User, Test'}
+            attributes: {full_name: 'Test User', attendance_name: 'ADMIN User, Test'}
           }
         ]
       }.to_json
@@ -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
@@ -174,6 +209,65 @@ describe 'ArraySerializer' do
     end
   end
 
+  context 'with dasherized json columns' do
+    let(:relation)   { Person.all }
+    let(:controller) { PeopleController.new }
+    let(:person)     {
+      Person.create first_name: 'Test',
+                    last_name: 'User',
+                    options:    { 'foo_foo': 'baz', bar: [{ 'jar_jar': 'binks' }] },
+                    prefs:      { 'foo_foo': 'baz', bar: [{ 'jar_jar': 'binks' }] },
+                    settings:   { 'foo_foo': 'bar' },
+                    selfies:    [ { 'photo_resolution': '200x200' } ],
+                    portraits:  [ { 'photo_resolution': '150x200' } ],
+                    landscapes: [ { 'photo_resolution': '200x150' } ]
+    }
+    let(:options)    { { each_serializer: PersonWithJsonSerializer } }
+
+    before do
+      @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: person.id.to_s,
+            type: 'people',
+            attributes: {
+              prefs: {
+                bar: [{ 'jar-jar' => 'binks'}],
+                'foo-foo' => 'baz',
+              },
+              options: {
+                bar: [{ 'jar-jar' => 'binks'}],
+                'foo-foo' => 'baz',
+              },
+              selfies: [
+                { 'photo-resolution' => '200x200' },
+              ],
+              settings: {
+                'foo-foo' => 'bar'
+              },
+              portraits: [
+                { 'photo-resolution' => '150x200' },
+              ],
+              landscapes: [
+                { 'photo-resolution' => '200x150' },
+              ],
+            },
+          }
+        ]
+      }.to_json
+      expect(json_data).to eq json_expected
+    end
+  end
+
   context 'with aliased association' do
     let(:relation)   { Tag.first }
     let(:controller) { TagsController.new }
@@ -195,7 +289,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
@@ -213,7 +329,7 @@ describe 'ArraySerializer' do
         data: {
           id: @note.id.to_s,
           type: 'notes',
-          attributes: { id: @note.id, name: 'Title' },
+          attributes: { name: 'Title' },
           relationships: { tags: { data: [{id: @tag.id.to_s, type: 'tags'}] } }
         }
       }.to_json
@@ -367,7 +483,7 @@ describe 'ArraySerializer' do
           {
             id: tag.id.to_s,
             type: 'tags',
-            attributes: { id: tag.id, name: 'My tag' },
+            attributes: { name: 'My tag' },
             relationships: { note: { data: { id: note.id.to_s, type: 'notes' } } },
           }
         ],
@@ -405,7 +521,7 @@ describe 'ArraySerializer' do
           {
             id: reviewer.id.to_s,
             type: 'users',
-            attributes: { id: reviewer.id, name: 'Peter' },
+            attributes: { name: 'Peter' },
             relationships: {
               offers: { data: [] },
               reviewed_offers: { data: [{id: offer.id.to_s, type: 'offers'}] },
@@ -414,7 +530,7 @@ describe 'ArraySerializer' do
           {
             id: user.id.to_s,
             type: 'users',
-            attributes: { id: user.id, name: 'John' },
+            attributes: { name: 'John' },
             relationships: {
               offers: { data: [{id: offer.id.to_s, type: 'offers'}] },
               reviewed_offers: { data: [] },
@@ -465,7 +581,7 @@ describe 'ArraySerializer' do
           {
             id: tag.id.to_s,
             type: 'tag_with_notes',
-            attributes: { id: tag.id, name: 'My tag' },
+            attributes: { name: 'My tag' },
             relationships: { note: { data: { id: note.id.to_s, type: 'notes' } } },
           }
         ]
@@ -524,7 +640,7 @@ describe 'ArraySerializer' do
           {
             id: @user.id.to_s,
             type: 'users',
-            attributes: {id: @user.id, name: 'John', mobile: '51111111'},
+            attributes: {name: 'John', mobile: '51111111'},
             relationships: {
               offers: {data: []},
               address: {data: {id: address.id.to_s, type: 'addresses'}},
@@ -544,7 +660,7 @@ describe 'ArraySerializer' do
           {
             id: @user.id.to_s,
             type: 'users',
-            attributes: {id: @user.id, name: 'John'},
+            attributes: {name: 'John'},
             relationships: {
               offers: {data: []},
               reviewed_offers: {data: []},
@@ -572,7 +688,7 @@ describe 'ArraySerializer' do
           {
             id: note.id.to_s,
             type: 'notes',
-            attributes: {id: note.id},
+            attributes: {},
             relationships: {
               sorted_tags: {
                 data: [
@@ -608,7 +724,7 @@ describe 'ArraySerializer' do
           {
             id: note.id.to_s,
             type: 'notes',
-            attributes: {id: note.id},
+            attributes: {},
             relationships: {
               custom_sorted_tags: {
                 data: [

data/spec/spec_helper.rb

@@ -1,11 +1,12 @@
-require 'active_record'
-require 'action_controller'
+require 'rails/all'
 require 'rspec'
+require 'rspec/rails'
 require 'bourne'
 require 'database_cleaner'
 require 'active_model_serializers'
 require 'action_controller/serialization'
 require 'active_model_serializers_pg'
+require 'generator_spec'
 if ENV['TEST_UNPATCHED_AMS']
   ActiveModelSerializers.config.adapter = :json_api
 else
@@ -24,6 +25,17 @@ end
 require 'dotenv'
 Dotenv.load
 
+# Need this or Rails.application is nil just below:
+module TestApp
+  class Application < ::Rails::Application
+    config.root = File.dirname(__FILE__)
+  end
+end
+
+# Need this line or `hook_for` in our generators is ignored,
+# so our migration generator doesn't run:
+Rails.application.load_generators
+
 ActiveRecord::Base.establish_connection(ENV['DATABASE_URL'])
 
 class TestController < ActionController::Base
@@ -56,6 +68,16 @@ class PersonSerializer < ActiveModel::Serializer
   end
 end
 
+class PersonWithJsonSerializer < ActiveModel::Serializer
+  attributes :id,
+    :options,     # json
+    :prefs,       # jsonb
+    :settings,    # hstore
+    :selfies,     # json[]
+    :portraits,   # jsonb[]
+    :landscapes   # hstore[]
+end
+
 class Note < ActiveRecord::Base
   has_many :tags
   has_many :sorted_tags
@@ -126,6 +148,7 @@ end
 class Tag < ActiveRecord::Base
   belongs_to :note
   alias :aliased_note :note
+  alias_attribute :aliased_name, :name
 end
 
 class SortedTag < Tag
@@ -164,6 +187,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.2
+  version: 0.0.7
 platform: ruby
 authors:
 - Paul A. Jungwirth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-15 00:00:00.000000000 Z
+date: 2020-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -94,6 +94,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  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'
+- !ruby/object:Gem::Dependency
+  name: generator_spec
+  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'
 - !ruby/object:Gem::Dependency
   name: bourne
   requirement: !ruby/object:Gem::Requirement
@@ -172,6 +200,11 @@ files:
 - lib/active_model_serializers_pg.rb
 - lib/active_model_serializers_pg/collection_serializer.rb
 - lib/active_model_serializers_pg/version.rb
+- lib/generators/active_model_serializers_pg/active_model_serializers_pg_generator.rb
+- lib/generators/active_record/active_model_serializers_pg_generator.rb
+- lib/generators/active_record/templates/jsonb_dasherize.sql
+- lib/generators/active_record/templates/migration.rb
+- spec/generators/main_generator_spec.rb
 - spec/serializer_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/pjungwir/active_model_serializers_pg
@@ -193,10 +226,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Harness the power of PostgreSQL when crafting JSON reponses
 test_files:
+- spec/generators/main_generator_spec.rb
 - spec/serializer_spec.rb
 - spec/spec_helper.rb