ar_serializer 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7ba3188364c0f2ba77cd345116c161cb1586ba86f165ee8336266d3d69dc936
-  data.tar.gz: de1a1f08e2eb1cee584bb9f34663fc51d460dbb6283aa4773681fb8ff585df9d
+  metadata.gz: 87a5c3a6d707be1abec6c92335dbb5888b120a53b6e429eb1849b2aca42a1f1d
+  data.tar.gz: bdd382384bd5452fc909b26cb25fbefd252117fb552b0fc42bc4eddad016a13d
 SHA512:
-  metadata.gz: 987a6cad67b5db442cd5cbb0167fb754cf3cb841d0ea050bf148391ed6f4c61037e17e1448d50d89ebd6549541b4aa51566a233b42c578eded817f42bc77c156
-  data.tar.gz: f6c971e38b6e96673ddddcac94ee30e37d12eeb05ef68a8c878fff3490ec273e91cb1146a8ba6a185cac5fb313c6a429d07dd89986475e73454db6f6f187ed7e
+  metadata.gz: 86a9f5895dd2c9f5a9d3a1e51781d5286c4cfbb02687d2d6a9ec502ed85c0971a0343a08218ee0be3233a8f93e0be993e1ce7ab68b5fe75548a76e068247b3a9
+  data.tar.gz: 829e8871640abf2a4863d77df8ce703d9e85b38cf46496bd8573f6913572c5ebe18fc1a6c799e1b68124835abc1398841e810413b30cbddb5fe174b0301c85b1

data/.github/workflows/test.yml

@@ -0,0 +1,22 @@
+name: Test
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ '2.7', '3.0', '3.1' ]
+        gemfiles:
+          - gemfiles/Gemfile-rails-6
+          - gemfiles/Gemfile-rails-7
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - run: |
+        sudo apt-get update
+        sudo apt-get install -y libsqlite3-dev
+    - run: bundle install --gemfile ${{ matrix.gemfiles }} --jobs 4 --retry 3
+    - run: bundle exec --gemfile ${{ matrix.gemfiles }} rake

data/Gemfile.lock

@@ -1,48 +1,45 @@
 PATH
   remote: .
   specs:
-    ar_serializer (1.1.1)
+    ar_serializer (1.2.0)
       activerecord
       top_n_loader
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.0.2.1)
-      activesupport (= 6.0.2.1)
-    activerecord (6.0.2.1)
-      activemodel (= 6.0.2.1)
-      activesupport (= 6.0.2.1)
-    activesupport (6.0.2.1)
+    activemodel (7.0.2.3)
+      activesupport (= 7.0.2.3)
+    activerecord (7.0.2.3)
+      activemodel (= 7.0.2.3)
+      activesupport (= 7.0.2.3)
+    activesupport (7.0.2.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
-    docile (1.3.1)
-    i18n (1.7.0)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.10)
+    docile (1.4.0)
+    i18n (1.10.0)
       concurrent-ruby (~> 1.0)
-    json (2.1.0)
-    method_source (0.9.2)
-    minitest (5.13.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rake (12.3.2)
-    simplecov (0.16.1)
+    method_source (1.0.0)
+    minitest (5.15.0)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.0.6)
+    simplecov (0.21.2)
       docile (~> 1.1)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-    sqlite3 (1.4.0)
-    thread_safe (0.3.6)
-    top_n_loader (1.0.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    sqlite3 (1.4.2)
+    top_n_loader (1.0.2)
       activerecord
-    tzinfo (1.2.6)
-      thread_safe (~> 0.1)
-    zeitwerk (2.2.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
 
 PLATFORMS
   ruby
@@ -56,4 +53,4 @@ DEPENDENCIES
   sqlite3
 
 BUNDLED WITH
-   2.1.2
+   2.3.3

data/README.md

@@ -71,10 +71,10 @@ end
 
 # preloader
 class Foo < ActiveRecord::Base
-  define_preloader :bar_count_loader do |models|
+  bar_count_loader = ->(models) do
     Bar.where(foo_id: models.map(&:id)).group(:foo_id).count
   end
-  serializer_field :bar_count, preload: preloader_name_or_proc do |preloaded|
+  serializer_field :bar_count, preload: bar_count_loader do |preloaded|
     preloaded[id] || 0
   end
   # data_blockが `do |preloaded| preloaded[id] end` の場合は省略可能
@@ -85,7 +85,8 @@ class Post < ActiveRecord::Base
   has_many :comments
   serializer_field :comments
 end
-ArSerializer.serialize Post.all, { comments: [:id, params: { order: { id: :desc }, limit: 2 }] }
+ArSerializer.serialize Post.all, { comments: [:id, params: { order_by: :createdAt, direction: :desc, first: 10 }] }
+ArSerializer.serialize Post.all, { comments: [:id, params: { order_by: :updatedAt, last: 10 }] }
 
 # context and params
 class Post < ActiveRecord::Base

data/gemfiles/Gemfile-rails-6

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ar_serializer.gemspec
+gemspec path: ".."
+
+gem "activerecord", "~> 6.0.0"

data/gemfiles/Gemfile-rails-7

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ar_serializer.gemspec
+gemspec path: ".."
+
+gem "activerecord", "~> 7.0.0"

data/lib/ar_serializer/field.rb

@@ -1,19 +1,36 @@
 require 'ar_serializer/error'
 require 'top_n_loader'
+require 'set'
 
 class ArSerializer::Field
-  attr_reader :includes, :preloaders, :data_block, :only, :except, :order_column
-  def initialize includes: nil, preloaders: [], data_block:, only: nil, except: nil, order_column: nil, type: nil, params_type: nil
+  attr_reader :includes, :preloaders, :data_block, :only, :except, :scoped_access, :order_column, :permission, :fallback
+  def initialize klass, name, includes: nil, preloaders: [], data_block:, only: nil, except: nil, private: false, scoped_access: nil, permission: nil, fallback: nil, order_column: nil, orderable: nil, type: nil, params_type: nil
+    @klass = klass
+    @name = name
     @includes = includes
     @preloaders = preloaders
     @only = only && [*only].map(&:to_s)
     @except = except && [*except].map(&:to_s)
+    @private = private
+    @scoped_access = scoped_access.nil? ? true : scoped_access
+    @permission = permission
+    @fallback = fallback
     @data_block = data_block
     @order_column = order_column
+    @orderable = orderable
     @type = type
     @params_type = params_type
   end
 
+  def orderable?
+    return @orderable unless @orderable.nil?
+    @orderable = !@permission && @klass.has_attribute?((@order_column || @name).to_s.underscore)
+  end
+
+  def private?
+    @private
+  end
+
   def type
     type = @type.is_a?(Proc) ? @type.call : @type
     splat = lambda do |t|
@@ -34,7 +51,7 @@ class ArSerializer::Field
   end
 
   def arguments
-    return @params_type if @params_type
+    return @params_type.is_a?(Proc) ? @params_type.call : @params_type if @params_type
     @preloaders.size
     @data_block.parameters
     parameters_list = [@data_block.parameters.drop(@preloaders.size + 1)]
@@ -64,10 +81,19 @@ class ArSerializer::Field
     end
     return :any if any && arguments.empty?
     arguments.map do |key, req|
-      type = key.to_s.match?(/^(.+_)?id|Id$/) ? :int : :any
-      name = key.to_s.underscore
-      type = [type] if name.singularize.pluralize == name
-      [req ? key : "#{key}?", type]
+      camelcase = key.to_s.camelcase :lower
+      type = (
+        case key
+        when /^(.+_)?id$/
+          :int
+        when /^(.+_)?ids$/
+          [:int]
+        else
+          name = key.to_s.underscore
+          name.singularize.pluralize == name ? [:any] : :any
+        end
+      )
+      [req ? camelcase : "#{camelcase}?", type]
     end.to_h
   end
 
@@ -79,14 +105,14 @@ class ArSerializer::Field
     raise ArSerializer::InvalidQuery, "unpermitted attribute: #{invalid_keys}"
   end
 
-  def self.count_field(klass, association_name)
+  def self.count_field(klass, name, association_name, permission:)
     preloader = lambda do |models|
       klass.joins(association_name).where(id: models.map(&:id)).group(:id).count
     end
     data_block = lambda do |preloaded, _context, **_params|
       preloaded[id] || 0
     end
-    new preloaders: [preloader], data_block: data_block, type: :int
+    new klass, name, preloaders: [preloader], data_block: data_block, type: :int, orderable: false, permission: permission, fallback: 0
   end
 
   def self.type_from_column_type(klass, name)
@@ -98,7 +124,7 @@ class ArSerializer::Field
   def self.type_from_attribute_type(klass, name)
     attr_type = klass.attribute_types[name]
     if attr_type.is_a?(ActiveRecord::Enum::EnumType) && klass.respond_to?(name.pluralize)
-      values = klass.send(name.pluralize).keys.compact
+      values = klass.__send__(name.pluralize).keys.compact
       values = values.map { |v| v.is_a?(Symbol) ? v.to_s : v }.uniq
       valid_classes = [TrueClass, FalseClass, String, Integer, Float]
       return if values.empty? || (values.map(&:class) - valid_classes).present?
@@ -111,7 +137,7 @@ class ArSerializer::Field
       decimal: :float,
       string: :string,
       text: :string,
-      json: :string,
+      json: :unknown,
       binary: :string,
       time: :string,
       date: :string,
@@ -119,105 +145,145 @@ class ArSerializer::Field
     }[attr_type.type]
   end
 
-  def self.create(klass, name, type: nil, params_type: nil, count_of: nil, includes: nil, preload: nil, only: nil, except: nil, order_column: nil, &data_block)
+  def self.create(klass, name, type: nil, params_type: nil, count_of: nil, includes: nil, preload: nil, only: nil, except: nil, private: nil, scoped_access: nil, permission: nil, fallback: nil, order_column: nil, orderable: nil, &data_block)
+    name = name.to_s
     if count_of
-      if includes || preload || data_block || only || except
-        raise ArgumentError, 'includes, preload block cannot be used with count_of'
+      if includes || preload || data_block || only || except || order_column || orderable || scoped_access != nil || fallback
+        raise ArgumentError, 'wrong options for count_of field'
       end
-      return count_field klass, count_of
+      return count_field klass, name, count_of, permission: permission
     end
-    underscore_name = name.to_s.underscore
-    association = klass.reflect_on_association underscore_name if klass.respond_to? :reflect_on_association
+    association = klass.reflect_on_association name.underscore if klass.respond_to? :reflect_on_association
     if association
       if association.collection?
         type ||= -> { [association.klass] }
+        fallback ||= []
       elsif (association.belongs_to? && association.options[:optional] == true) || (association.has_one? && association.options[:required] != true)
         type ||= -> { [association.klass, nil] }
       else
         type ||= -> { association.klass }
       end
-      return association_field klass, underscore_name, only: only, except: except, type: type, collection: association.collection? if !includes && !preload && !data_block && !params_type
+      return association_field klass, name, only: only, except: except, scoped_access: scoped_access, permission: permission, fallback: fallback, type: type, collection: association.collection? if !includes && !preload && !data_block && !params_type
     end
     type ||= lambda do
       if klass.respond_to? :column_for_attribute
-        type_from_column_type klass, underscore_name
+        type_from_column_type klass, name.underscore
       elsif klass.respond_to? :attribute_types
-        type_from_attribute_type(klass, underscore_name) || :any
+        type_from_attribute_type(klass, name.underscore) || :any
       else
         :any
       end
     end
-    custom_field klass, underscore_name, includes: includes, preload: preload, only: only, except: except, order_column: order_column, type: type, params_type: params_type, &data_block
+    custom_field klass, name, includes: includes, preload: preload, only: only, except: except, private: private, scoped_access: scoped_access, permission: permission, fallback: fallback, order_column: order_column, orderable: orderable, type: type, params_type: params_type, &data_block
   end
 
-  def self.custom_field(klass, name, includes:, preload:, only:, except:, order_column:, type:, params_type:, &data_block)
+  def self.custom_field(klass, name, includes:, preload:, only:, except:, private:, scoped_access:, permission:, fallback:, order_column:, orderable:, type:, params_type:, &data_block)
+    underscore_name = name.underscore
     if preload
-      preloaders = Array(preload).map do |preloader|
-        next preloader if preloader.is_a? Proc
-        unless klass._custom_preloaders.has_key?(preloader)
-          raise ArgumentError, "preloader not found: #{preloader}"
-        end
-        klass._custom_preloaders[preloader]
-      end
+      preloaders = [*preload]
     else
       preloaders = []
-      includes ||= name if klass.respond_to?(:reflect_on_association) && klass.reflect_on_association(name)
+      includes ||= underscore_name if klass.respond_to?(:reflect_on_association) && klass.reflect_on_association(underscore_name)
+    end
+    if !data_block && preloaders.size == 1
+      data_block = ->(preloaded, _context, **_params) do
+        if preloaded.is_a? Set
+          preloaded.include? id
+        elsif fallback.nil?
+          preloaded[id] # returns preloaded.default unless preloaded.has_key?(id)
+        else
+          preloaded.has_key?(id) ? preloaded[id] : fallback
+        end
+      end
     end
-    data_block ||= ->(preloaded, _context, **_params) { preloaded[id] } if preloaders.size == 1
     raise ArgumentError, 'data_block needed if multiple preloaders are present' if !preloaders.empty? && data_block.nil?
     new(
-      includes: includes, preloaders: preloaders, only: only, except: except, order_column: order_column, type: type, params_type: params_type,
-      data_block: data_block || ->(_context, **_params) { send name }
+      klass,
+      name,
+      includes: includes, preloaders: preloaders, only: only, except: except,
+      private: private, scoped_access: scoped_access, permission: permission, fallback: fallback,
+      order_column: order_column, orderable: orderable, type: type, params_type: params_type,
+      data_block: data_block || ->(_context, **_params) { __send__ underscore_name }
     )
   end
 
-  def self.parse_order(klass, order)
-    key, mode = begin
+  def self.parse_order(klass, order: nil, order_by: nil, direction: nil, only: nil, except: nil)
+    raise ArSerializer::InvalidQuery, 'invalid order' if order && (order_by || direction)
+    primary_key = klass.primary_key.to_sym
+    order_by = order_by&.to_s&.to_sym || primary_key
+    direction = direction&.to_s&.to_sym || :asc
+    if order # deprecated
       case order
       when Hash
         raise ArSerializer::InvalidQuery, 'invalid order' unless order.size == 1
-        order.first
+        order_by, direction = order.first.map(&:to_sym)
       when Symbol, 'asc', 'desc'
-        [klass.primary_key, order]
-      when NilClass
-        [klass.primary_key, :asc]
+        direction = order.to_sym
+      else
+        raise ArSerializer::InvalidQuery, 'invalid order'
       end
     end
-    info = klass._serializer_field_info(key)
-    key = info&.order_column || key.to_s.underscore
-    raise ArSerializer::InvalidQuery, "unpermitted order key: #{key}" unless klass.primary_key == key.to_s || (klass.has_attribute?(key) && info)
-    raise ArSerializer::InvalidQuery, "invalid order mode: #{mode.inspect}" unless [:asc, :desc, 'asc', 'desc'].include? mode
-    [key.to_sym, mode.to_sym]
+    info = klass._serializer_field_info order_by
+    order_column = (info&.order_column || order_by).to_s.underscore.to_sym
+    raise ArSerializer::InvalidQuery, "invalid order direction: #{direction}" unless [:asc, :desc].include? direction
+    raise ArSerializer::InvalidQuery, "unpermitted order field: #{order_by}" unless order_by == primary_key || (info&.orderable? && (!only || only.include?(order_by)) && !except&.include?(order_by))
+    [order_column, direction]
   end
 
-  def self.association_field(klass, name, only:, except:, type:, collection:)
+  def self.association_field(klass, name, only:, except:, scoped_access:, permission:, fallback:, type:, collection:)
+    underscore_name = name.underscore
+    only = [*only] if only
+    except = [*except] if except
     if collection
-      preloader = lambda do |models, _context, limit: nil, order: nil, **_option|
-        preload_association klass, models, name, limit: limit, order: order
+      preloader = lambda do |models, _context, limit: nil, order: nil, first: nil, last: nil, order_by: nil, direction: nil, **_option|
+        preload_association klass, models, underscore_name, limit: limit, order: order, first: first, last: last, order_by: order_by, direction: direction, only: only, except: except
+      end
+      params_type = -> {
+        orderable_keys = klass.reflect_on_association(underscore_name).klass._serializer_orderable_field_keys
+        orderable_keys &= only.map(&:to_s) if only
+        orderable_keys -= except.map(&:to_s) if except
+        orderable_keys |= ['id']
+        orderable_keys.sort!
+        modes = %w[asc desc]
+        {
+          first?: :int,
+          last?: :int,
+          orderBy?: orderable_keys.size == 1 ? orderable_keys.first : orderable_keys,
+          direction?: modes
+        }
+      }
+      data_block = lambda do |preloaded, _context, **_params|
+        preloaded ? preloaded[id || self] || [] : __send__(underscore_name)
       end
-      params_type = { limit?: :int, order?: [{ :* => %w[asc desc] }, 'asc', 'desc'] }
     else
       preloader = lambda do |models, _context, **_params|
-        preload_association klass, models, name
+        preload_association klass, models, underscore_name
+      end
+      data_block = lambda do |preloaded, _context, **_params|
+        preloaded ? preloaded[id || self] : __send__(underscore_name)
       end
     end
-    data_block = lambda do |preloaded, _context, **_params|
-      preloaded ? preloaded[id] || [] : send(name)
-    end
-    new preloaders: [preloader], data_block: data_block, only: only, except: except, type: type, params_type: params_type
+    new klass, name, preloaders: [preloader], data_block: data_block, only: only, except: except, scoped_access: scoped_access, permission: permission, fallback: fallback, type: type, params_type: params_type, orderable: false
   end
 
-  def self.preload_association(klass, models, name, limit: nil, order: nil)
-    limit = limit&.to_i
-    order_key, order_mode = parse_order klass.reflect_on_association(name).klass, order
-    return TopNLoader.load_associations klass, models.map(&:id), name, limit: limit, order: { order_key => order_mode } if limit
-    ActiveRecord::Associations::Preloader.new.preload models, name
-    return if order.nil?
+  def self.preload_association(klass, models, name, limit: nil, order: nil, first: nil, last: nil, order_by: nil, direction: nil, only: nil, except: nil)
+    raise ArSerializer::InvalidQuery, 'invalid count option' if (limit && (first || last)) || (first && last)
+    first = (first || limit)&.to_i
+    last = last&.to_i
+    order_column, order_direction = parse_order klass.reflect_on_association(name).klass, order: order, order_by: order_by, direction: direction, only: only, except: except
+    if first || last
+      order_option = { order_column => first ? order_direction : (order_direction == :asc ? :desc : :asc) }
+      result = TopNLoader.load_associations klass, models.map(&:id), name, limit: first || last, order: order_option
+      result = result.transform_values!(&:reverse!) if last
+      return result
+    end
+    ArSerializer.preload_associations models, name
+    return models.map { |m| [m.id || m, m.__send__(name)] }.to_h if !order && !order_by && !direction
     models.map do |model|
-      records_nonnils, records_nils = model.send(name).partition(&order_key)
-      records = records_nils.sort_by(&:id) + records_nonnils.sort_by { |r| [r[order_key], r.id] }
-      records.reverse! if order_mode == :desc
-      [model.id, records]
+      records_nonnils, records_nils = model.__send__(name).partition(&order_column)
+      records = records_nils.sort_by(&:id) + records_nonnils.sort_by { |r| [r[order_column], r.id] }
+      records.reverse! if order_direction == :desc
+      [model.id || model, records]
     end.to_h
   end
 end

data/lib/ar_serializer/graphql/types.rb

@@ -103,7 +103,7 @@ module ArSerializer::GraphQL
     class InvalidType < StandardError; end
 
     def validate!
-      valid_symbols = %i[number int float string boolean any]
+      valid_symbols = %i[number int float string boolean any unknown]
       invalids = []
       recursive_validate = lambda do |t|
         case t
@@ -153,8 +153,8 @@ module ArSerializer::GraphQL
     end
 
     def self.from(type, only = nil, except = nil)
-      type = [type[0...-1].to_sym, nil] if type.is_a?(Symbol) && type.to_s.ends_with?('?')
-      type = [type[0...-1], nil] if type.is_a?(String) && type.ends_with?('?')
+      type = [type[0...-1].to_sym, nil] if type.is_a?(Symbol) && type.to_s.end_with?('?')
+      type = [type[0...-1], nil] if type.is_a?(String) && type.end_with?('?')
       case type
       when Class
         SerializableTypeClass.new type, only, except
@@ -195,6 +195,8 @@ module ArSerializer::GraphQL
         :boolean
       when :other
         :other
+      when :unknown
+        :unknown
       else
         :any
       end
@@ -216,7 +218,7 @@ module ArSerializer::GraphQL
         ''
       when 'boolean'
         true
-      when 'any'
+      when 'any', 'unknown'
         nil
       else
         type
@@ -227,7 +229,7 @@ module ArSerializer::GraphQL
       case type
       when :int, :float
         'number'
-      when :string, :number, :boolean
+      when :string, :number, :boolean, :unknown
         type.to_s
       when Symbol
         'any'
@@ -266,7 +268,7 @@ module ArSerializer::GraphQL
     end
 
     def sample
-      type.reject { |k| k.to_s.ends_with? '?' }.transform_values do |v|
+      type.reject { |k| k.to_s.end_with? '?' }.transform_values do |v|
         TypeClass.from(v).sample
       end
     end

data/lib/ar_serializer/serializer.rb

@@ -1,66 +1,55 @@
 require 'ar_serializer/error'
 
-class ArSerializer::CompositeValue
-  def initialize(pairs:, output:)
-    @pairs = pairs
-    @output = output
+class ArSerializer::CustomSerializable
+  attr_reader :ar_custom_serializable_models
+  def initialize(models, &block)
+    @ar_custom_serializable_models = models
+    @block = block
   end
 
-  def ar_serializer_build_sub_calls
-    [@output, @pairs]
+  def ar_custom_serializable_data(result)
+    @block.call result
   end
 end
 
-module ArSerializer::ArrayLikeCompositeValue
-  def ar_serializer_build_sub_calls
-    output = []
-    record_elements = []
-    each do |record|
-      data = {}
-      output << data
-      record_elements << [record, data]
-    end
-    [output, record_elements]
-  end
+module ArSerializer::ArrayLikeSerializable
 end
 
 module ArSerializer::Serializer
   def self.current_namespaces
-    Thread.current[:ar_serializer_current_namespaces]
+    Thread.current[:ar_serializer_current_namespaces] || [nil]
   end
 
   def self.with_namespaces(namespaces)
     namespaces_was = Thread.current[:ar_serializer_current_namespaces]
-    Thread.current[:ar_serializer_current_namespaces] = namespaces
+    Thread.current[:ar_serializer_current_namespaces] = Array(namespaces) | [nil]
     yield
   ensure
     Thread.current[:ar_serializer_current_namespaces] = namespaces_was
   end
 
-  def self.serialize(model, query, context: nil, include_id: false, use: nil)
+  def self.serialize(model, query, context: nil, use: nil, permission: true)
+    return nil if model.nil?
     with_namespaces use do
       attributes = parse_args(query)[:attributes]
       if model.is_a?(ArSerializer::Serializable)
-        output = {}
-        _serialize [[model, output]], attributes, context, include_id
-        output
+        result = _serialize [model], attributes, context, permission: permission
+        result[model]
       else
-        sets = model.to_a.map do |record|
-          [record, {}]
-        end
-        _serialize sets, attributes, context, include_id
-        sets.map(&:last)
+        models = model.to_a
+        result = _serialize models, attributes, context, permission: permission
+        models.map { |m| result[m] }.compact
       end
     end
   end
 
-  def self._serialize(mixed_value_outputs, attributes, context, include_id, only = nil, except = nil)
-    mixed_value_outputs.group_by { |v, _o| v.class }.each do |klass, value_outputs|
+  def self._serialize(mixed_models, attributes, context, only: nil, except: nil, permission: true)
+    output_for_model = {}
+    mixed_models.group_by(&:class).each do |klass, models|
       next unless klass.respond_to? :_serializer_field_info
-      models = value_outputs.map(&:first)
-      value_outputs.each { |value, output| output[:id] = value.id } if include_id && klass.method_defined?(:id)
+      models.uniq!
       if attributes.any? { |k, _| k == :* }
-        all_keys = klass._serializer_field_keys.map(&:to_sym) - [:defaults]
+        all_keys = klass._serializer_field_keys.map(&:to_sym)
         all_keys &= only.map(&:to_sym) if only
         all_keys -= except.map(&:to_sym) if except
         attributes = all_keys.map { |k| [k, {}] } + attributes.reject { |k, _| k == :* }
@@ -68,85 +57,147 @@ module ArSerializer::Serializer
       attributes.each do |name, sub_args|
         field_name = sub_args[:field_name] || name
         field = klass._serializer_field_info field_name
-        raise ArSerializer::InvalidQuery, "No serializer field `#{field_name}`#{" namespaces: #{current_namespaces}" if current_namespaces} for #{klass}" unless field
-        ActiveRecord::Associations::Preloader.new.preload models, field.includes if field.includes.present?
-      end
-
-      preloader_params = attributes.flat_map do |name, sub_args|
-        field_name = sub_args[:field_name] || name
-        klass._serializer_field_info(field_name).preloaders.map do |p|
-          [p, sub_args[:params]]
+        if field.nil? || field.private?
+          message = "No serializer field `#{field_name}`#{" namespaces: #{current_namespaces.compact}" if current_namespaces.any?} for #{klass}"
+          raise ArSerializer::InvalidQuery, message
         end
+        ArSerializer.preload_associations models, field.includes if field.includes.present?
       end
-      defaults = klass._serializer_field_info(:defaults)
-      if defaults
-        preloader_params += defaults.preloaders.map { |p| [p] }
-      end
-      preloader_values = preloader_params.compact.uniq.map do |key|
-        preloader, params = key
+
+      preload = lambda do |preloader, params|
         has_keyword = preloader.parameters.any? { |type, _name| %i[key keyreq keyrest].include? type }
         arity = preloader.arity.abs
         arguments = [models]
         if has_keyword
           arguments << context unless arity == 2
-          [key, preloader.call(*arguments, **(params || {}))]
+          preloader.call(*arguments, **(params || {}))
         else
           arguments << context unless arity == 1
-          [key, preloader.call(*arguments)]
+          preloader.call(*arguments)
         end
-      end.to_h
+      end
 
+      preloader_values = {}
+      if permission == true
+        permission_field = klass._serializer_field_info :permission
+      elsif permission
+        permission_field = klass._serializer_field_info permission
+        raise ArgumentError, "No permission field #{permission} for #{klass}" unless permission_field
+      end
+      if permission_field
+        preloadeds = permission_field.preloaders.map do |p|
+          preloader_values[[p, nil]] ||= preload.call p, nil
+        end
+        models = models.select do |model|
+          model.instance_exec(*preloadeds, context, {}, &permission_field.data_block)
+        end
+      end
+
+      defaults = klass._serializer_field_info :defaults
       if defaults
-        preloadeds = defaults.preloaders.map { |p| preloader_values[[p]] } || []
-        value_outputs.each do |value, output|
-          data = value.instance_exec(*preloadeds, context, {}, &defaults.data_block)
-          output.update data
+        defaults.preloaders.each do |p|
+          preloader_values[[p, nil]] ||= preload.call p, nil
+        end
+      end
+
+      attributes.each do |name, sub_args|
+        field_name = sub_args[:field_name] || name
+        klass._serializer_field_info(field_name).preloaders.each do |p|
+          params = sub_args[:params]
+          preloader_values[[p, params]] ||= preload.call p, params
         end
       end
 
+      models.each do |model|
+        output_for_model[model] = {}
+      end
+
       attributes.each do |name, sub_arg|
         params = sub_arg[:params]
-        sub_calls = []
         column_name = sub_arg[:column_name] || name
         field_name = sub_arg[:field_name] || name
         info = klass._serializer_field_info field_name
         preloadeds = info.preloaders.map { |p| preloader_values[[p, params]] } || []
         data_block = info.data_block
-        value_outputs.each do |value, output|
-          child = value.instance_exec(*preloadeds, context, **(params || {}), &data_block)
-          if child.is_a?(Array) && child.all? { |el| el.is_a? ArSerializer::Serializable }
-            output[column_name] = child.map do |record|
-              data = {}
-              sub_calls << [record, data]
-              data
-            end
-          elsif child.respond_to? :ar_serializer_build_sub_calls
-            sub_output, record_elements = child.ar_serializer_build_sub_calls
-            record_elements.each { |o| sub_calls << o }
-            output[column_name] = sub_output
+        permission_block = info.permission
+        fallback = info.fallback
+        sub_results = {}
+        sub_models = []
+        models.each do |model|
+          next if permission_block && !model.instance_exec(context, **(params || {}), &permission_block)
+          child = model.instance_exec(*preloadeds, context, **(params || {}), &data_block)
+          if child.is_a?(ArSerializer::ArrayLikeSerializable) || (child.is_a?(Array) && child.any? { |el| el.is_a? ArSerializer::Serializable })
+            sub_results[model] = [:multiple, child]
+            sub_models << child.grep(ArSerializer::Serializable)
+          elsif child.respond_to?(:ar_custom_serializable_models) && child.respond_to?(:ar_custom_serializable_data)
+            sub_results[model] = [:custom, child]
+            sub_models << child.ar_custom_serializable_models
           elsif child.is_a? ArSerializer::Serializable
-            data = {}
-            sub_calls << [child, data]
-            output[column_name] = data
+            sub_results[model] = [:single, child]
+            sub_models << child
+          else
+            sub_results[model] = [:data, child]
+          end
+        end
+
+        sub_models.flatten!
+        sub_models.uniq!
+        unless sub_models.empty?
+          sub_attributes = sub_arg[:attributes] || {}
+          info.validate_attributes sub_attributes
+          result = _serialize(
+            sub_models,
+            sub_attributes,
+            context,
+            only: info.only,
+            except: info.except,
+            permission: info.scoped_access
+          )
+        end
+
+        models.each do |model|
+          data = output_for_model[model]
+          type, res = sub_results[model]
+          case type
+          when :single
+            data[column_name] = result[res]
+          when :multiple
+            arr = data[column_name] = []
+            res.each do |r|
+              if r.is_a? ArSerializer::Serializable
+                arr << result[r] if result.key? r
+              else
+                arr << r
+              end
+            end
+          when :custom
+            data[column_name] = res.ar_custom_serializable_data result || {}
+          when :data
+            data[column_name] = res
           else
-            output[column_name] = child
+            data[column_name] = fallback
           end
         end
-        next if sub_calls.empty?
-        sub_attributes = sub_arg[:attributes] || {}
-        info.validate_attributes sub_attributes
-        _serialize sub_calls, sub_attributes, context, include_id, info.only, info.except
+      end
+
+      if defaults
+        preloadeds = defaults.preloaders.map { |p| preloader_values[[p]] } || []
+        models.each do |model|
+          data = model.instance_exec(*preloadeds, context, {}, &defaults.data_block)
+          output_for_model[model].update data
+        end
       end
     end
+    output_for_model
   end
 
-  def self.deep_with_indifferent_access params
+  def self.deep_underscore_keys params
     case params
     when Array
-      params.map { |v| deep_with_indifferent_access v }
+      params.map { |v| deep_underscore_keys v }
     when Hash
-      params.transform_keys(&:to_sym).transform_values! do |v|
-        deep_with_indifferent_access v
+      params.transform_keys { |k| k.to_s.underscore.to_sym }.transform_values! do |v|
+        deep_underscore_keys v
       end
     else
       params
@@ -171,7 +222,7 @@ module ArSerializer::Serializer
           elsif !only_attributes && %i[attributes query].include?(sym_key)
             attributes.concat parse_args(value, only_attributes: true)
           elsif !only_attributes && sym_key == :params
-            params = deep_with_indifferent_access value
+            params = deep_underscore_keys value
           else
             attributes << [sym_key, value == true ? {} : parse_args(value)]
           end

data/lib/ar_serializer/version.rb

@@ -1,3 +1,3 @@
 module ArSerializer
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

data/lib/ar_serializer.rb

@@ -7,6 +7,16 @@ module ArSerializer
   def self.serialize(model, query, **option)
     Serializer.serialize(model, query, **option)
   end
+
+  if ActiveRecord::VERSION::MAJOR >= 7
+    def self.preload_associations(models, associations)
+      ActiveRecord::Associations::Preloader.new(records: models, associations: associations).call
+    end
+  else
+    def self.preload_associations(models, associations)
+      ActiveRecord::Associations::Preloader.new.preload models, associations
+    end
+  end
 end
 
 module ArSerializer::Serializable
@@ -18,34 +28,32 @@ module ArSerializer::Serializable
     end
 
     def _serializer_field_info(name)
-      namespaces = ArSerializer::Serializer.current_namespaces
-      if namespaces
-        Array(namespaces).each do |ns|
-          field = _serializer_namespace(ns)[name.to_s]
-          return field if field
-        end
-      end
-      field = _serializer_namespace(nil)[name.to_s]
-      if field
-        field
-      elsif superclass < ArSerializer::Serializable
-        superclass._serializer_field_info name
+      ArSerializer::Serializer.current_namespaces.each do |ns|
+        field = _serializer_namespace(ns)[name.to_s]
+        return field if field
       end
+      superclass._serializer_field_info name if superclass < ArSerializer::Serializable
     end
 
-    def _serializer_field_keys
-      namespaces = ArSerializer::Serializer.current_namespaces
-      keys = []
-      if namespaces
-        Array(namespaces).each do |ns|
-          keys |= _serializer_namespace(ns).keys
+    def _serializer_field_keys(public_only = true)
+      keys = ArSerializer::Serializer.current_namespaces.map do |ns|
+        if public_only
+          fields = _serializer_namespace(ns)
+          fields.keys.reject { |key| fields[key].private? }
+        else
+          _serializer_namespace(ns).keys
         end
-      end
-      keys |= _serializer_namespace(nil).keys
-      keys |= superclass._serializer_field_keys if superclass < ArSerializer::Serializable
+      end.inject(:|)
+      keys |= superclass._serializer_field_keys(public_only) if superclass < ArSerializer::Serializable
       keys
     end
 
+    def _serializer_orderable_field_keys
+      _serializer_field_keys.select do |name|
+        _serializer_field_info(name).orderable?
+      end
+    end
+
     def serializer_field(*names, namespace: nil, association: nil, **option, &data_block)
       namespaces = namespace.is_a?(Array) ? namespace : [namespace]
       namespaces.each do |ns|
@@ -56,22 +64,18 @@ module ArSerializer::Serializable
       end
     end
 
-    def _custom_preloaders
-      @_custom_preloaders ||= {}
-    end
-
-    def define_preloader(name, &block)
-      _custom_preloaders[name] = block
+    def serializer_permission(**args, &data_block)
+      serializer_field(:permission, **args, private: true, &data_block)
     end
 
     def serializer_defaults(**args, &block)
-      serializer_field :defaults, **args, &block
+      serializer_field(:defaults, **args, private: true, &block)
     end
   end
 end
 
 ActiveRecord::Base.include ArSerializer::Serializable
-ActiveRecord::Relation.include ArSerializer::ArrayLikeCompositeValue
+ActiveRecord::Relation.include ArSerializer::ArrayLikeSerializable
 
 require 'ar_serializer/graphql'
 require 'ar_serializer/type_script'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_serializer
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - tompng
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-01-27 00:00:00.000000000 Z
+date: 2022-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -115,6 +115,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".travis.yml"
 - Gemfile
@@ -125,6 +126,8 @@ files:
 - ar_serializer.gemspec
 - bin/console
 - bin/setup
+- gemfiles/Gemfile-rails-6
+- gemfiles/Gemfile-rails-7
 - lib/ar_serializer.rb
 - lib/ar_serializer/error.rb
 - lib/ar_serializer/field.rb
@@ -138,7 +141,7 @@ homepage: https://github.com/tompng/ar_serializer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -153,8 +156,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: ActiveRecord serializer, avoid N+1
 test_files: []