ar_serializer 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e9144cab6ef520e2c0734bbe98a13a046f3b7b8411310ccc522dc999bae5365
-  data.tar.gz: d938b8684bbb22937c97c2572994b6bd11b38c72011f1b19975d96c7633656c7
+  metadata.gz: 87a5c3a6d707be1abec6c92335dbb5888b120a53b6e429eb1849b2aca42a1f1d
+  data.tar.gz: bdd382384bd5452fc909b26cb25fbefd252117fb552b0fc42bc4eddad016a13d
 SHA512:
-  metadata.gz: a7ff7ed23abaabef6893c31dc259ce18eeb3111df652c4e4a2d717523853e4a4f27119ddb0d027583ae788b218fdea73abebfc5de99480447e51bbabe04929f9
-  data.tar.gz: 8bceb19d2f319772e575c440870d074431f21efeab16375dced2e87637791e3d94927f0024c01bfd9669f0e0fb9743539f17ac47b12233a056db64e12b952264
+  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.0.0)
+    ar_serializer (1.2.0)
       activerecord
       top_n_loader
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.2.3)
-      activesupport (= 5.2.3)
-    activerecord (5.2.3)
-      activemodel (= 5.2.3)
-      activesupport (= 5.2.3)
-      arel (>= 9.0)
-    activesupport (5.2.3)
+    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)
-    arel (9.0.0)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
-    docile (1.3.1)
-    i18n (1.6.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.11.3)
-    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.0)
+      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.5)
-      thread_safe (~> 0.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
 
 PLATFORMS
   ruby
@@ -56,4 +53,4 @@ DEPENDENCIES
   sqlite3
 
 BUNDLED WITH
-   1.17.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,11 +85,12 @@ 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
-  serializer_field :created_at do |context, params|
+  serializer_field :created_at do |context, **params|
     created_at.in_time_zone(context[:tz]).strftime params[:format]
   end
 end
@@ -123,10 +124,10 @@ class User < ActiveRecord::Base
   serializer_field :o_posts, association: :posts, only: :title
   serializer_field :e_posts, association: :posts, except: :comments
 end
-ArSerializer.serialize user, o_posts: :title, e_posts: :body
-ArSerializer.serialize user, o_posts: :*, e_posts: :*
-ArSerializer.serialize user, o_posts: :body #=> Error
-ArSerializer.serialize user, e_posts: :comments #=> Error
+ArSerializer.serialize user, { o_posts: :title, e_posts: :body }
+ArSerializer.serialize user, { o_posts: :*, e_posts: :* }
+ArSerializer.serialize user, { o_posts: :body } #=> Error
+ArSerializer.serialize user, { e_posts: :comments } #=> Error
 
 # types
 class User < 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,18 +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|
@@ -33,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)]
@@ -63,39 +81,38 @@ 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
 
   def validate_attributes(attributes)
     return unless @only || @except
-    keys = attributes.keys.map(&:to_s) - ['*']
+    keys = attributes.map(&:first).map(&:to_s) - ['*']
     return unless (@only && (keys - @only).present?) || (@except && (keys & @except).present?)
     invalid_keys = [*(@only && keys - @only), *(@except && keys & @except)].uniq
     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|
+    data_block = lambda do |preloaded, _context, **_params|
       preloaded[id] || 0
     end
-    new preloaders: [preloader], data_block: data_block, type: :int
-  end
-
-  def self.top_n_loader_available?
-    return @top_n_loader_available unless @top_n_loader_available.nil?
-    @top_n_loader_available = begin
-      require 'top_n_loader'
-      true
-    rescue LoadError
-      nil
-    end
+    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)
@@ -107,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?
@@ -120,7 +137,7 @@ class ArSerializer::Field
       decimal: :float,
       string: :string,
       text: :string,
-      json: :string,
+      json: :unknown,
       binary: :string,
       time: :string,
       date: :string,
@@ -128,107 +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.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
+      preloader = lambda do |models, _context, **_params|
+        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
-    if limit && top_n_loader_available?
-      return TopNLoader.load_associations klass, models.map(&:id), name, limit: limit, order: { order_key => order_mode }
+  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
-    ActiveRecord::Associations::Preloader.new.preload models, name
-    return if limit.nil? && order.nil?
+    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, limit ? records.take(limit) : 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/parser.rb

@@ -9,8 +9,8 @@ class ArSerializer::GraphQL::Parser
     @chars = query.chars
   end
 
-  def self.parse(*args)
-    new(*args).parse
+  def self.parse(query, **option)
+    new(query, **option).parse
   end
 
   def parse
@@ -194,7 +194,7 @@ class ArSerializer::GraphQL::Parser
     args = parse_args
     consume_blank
     fields = parse_fields
-    [name, { as: alias_name, params: args, attributes: fields }.compact]
+    [(alias_name || name), { field: name, params: args, attributes: fields }.compact]
   end
 
   def parse_fields

data/lib/ar_serializer/graphql/types.rb

@@ -38,7 +38,15 @@ module ArSerializer::GraphQL
       type.collect_types types
     end
 
+    def args_required?
+      return false if field.arguments == :any
+      field.arguments.any? do |key, type|
+        !key.match?(/\?$/) && !(type.is_a?(Array) && type.include?(nil))
+      end
+    end
+
     def args_ts_type
+      return 'any' if field.arguments == :any
       arg_types = field.arguments.map do |key, type|
         "#{key}: #{TypeClass.from(type).ts_type}"
       end
@@ -95,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
@@ -145,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
@@ -187,6 +195,8 @@ module ArSerializer::GraphQL
         :boolean
       when :other
         :other
+      when :unknown
+        :unknown
       else
         :any
       end
@@ -208,7 +218,7 @@ module ArSerializer::GraphQL
         ''
       when 'boolean'
         true
-      when 'any'
+      when 'any', 'unknown'
         nil
       else
         type
@@ -219,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'
@@ -258,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,149 +1,203 @@
 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, args, 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(args)[:attributes]
+      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)
-      if attributes[:*]
+      models.uniq!
+      if attributes.any? { |k, _| k == :* }
         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, {}] }.to_h.merge attributes
-        attributes.delete :*
+        attributes = all_keys.map { |k| [k, {}] } + attributes.reject { |k, _| k == :* }
       end
-      attributes.each_key do |name|
-        field = klass._serializer_field_info name
-        raise ArSerializer::InvalidQuery, "No serializer field `#{name}`#{" namespaces: #{current_namespaces}" if current_namespaces} for #{klass}" unless field
-        ActiveRecord::Associations::Preloader.new.preload models, field.includes if field.includes.present?
+      attributes.each do |name, sub_args|
+        field_name = sub_args[:field_name] || name
+        field = klass._serializer_field_info field_name
+        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
 
-      preloader_params = attributes.flat_map do |name, sub_args|
-        klass._serializer_field_info(name).preloaders.map do |p|
-          [p, sub_args[:params]]
+      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
+          preloader.call(*arguments, **(params || {}))
+        else
+          arguments << context unless arity == 1
+          preloader.call(*arguments)
         end
       end
-      defaults = klass._serializer_field_info(:defaults)
-      if defaults
-        preloader_params += defaults.preloaders.map { |p| [p] }
+
+      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
-      preloader_values = preloader_params.compact.uniq.map do |key|
-        preloader, params = key
-        if preloader.arity < 0
-          [key, preloader.call(models, context, params || {})]
-        else
-          [key, preloader.call(*[models, context, params || {}].take(preloader.arity))]
+      if permission_field
+        preloadeds = permission_field.preloaders.map do |p|
+          preloader_values[[p, nil]] ||= preload.call p, nil
         end
-      end.to_h
+        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
-        info = klass._serializer_field_info 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
-          elsif child.is_a? ArSerializer::CompositeValue
-            sub_output, record_elements = child.build
-            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
-            output[column_name] = child
+            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
+            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
@@ -151,27 +205,26 @@ module ArSerializer::Serializer
   end
 
   def self.parse_args(args, only_attributes: false)
-    attributes = {}
+    attributes = []
     params = nil
     column_name = nil
+    field_name = nil
     (args.is_a?(Array) ? args : [args]).each do |arg|
       if arg.is_a?(Symbol) || arg.is_a?(String)
-        attributes[arg.to_sym] = {}
+        attributes << [arg.to_sym, {}]
       elsif arg.is_a? Hash
         arg.each do |key, value|
           sym_key = key.to_sym
-          if only_attributes
-            attributes[sym_key] = value == true ? {} : parse_args(value)
-            next
-          end
-          if sym_key == :as
+          if !only_attributes && sym_key == :field
+            field_name = value
+          elsif !only_attributes && sym_key == :as
             column_name = value
-          elsif sym_key == :attributes
-            attributes.update parse_args(value, only_attributes: true)
-          elsif sym_key == :params
-            params = deep_with_indifferent_access value
+          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_underscore_keys value
           else
-            attributes[sym_key] = value == true ? {} : parse_args(value)
+            attributes << [sym_key, value == true ? {} : parse_args(value)]
           end
         end
       else
@@ -179,6 +232,6 @@ module ArSerializer::Serializer
       end
     end
     return attributes if only_attributes
-    { attributes: attributes, column_name: column_name, params: params || {} }
+    { attributes: attributes, column_name: column_name, field_name: field_name, params: params || {} }
   end
 end

data/lib/ar_serializer/type_script.rb

@@ -4,32 +4,60 @@ module ArSerializer::TypeScript
   def self.generate_type_definition(*classes)
     types = related_serializer_types classes.flatten
     [
+      'type NonAliasQuery = true | string | string[] | ({ field?: undefined } & { [key: string]: any })',
       types.map { |t| data_type_definition t },
       types.map { |t| query_type_definition t }
     ].join "\n"
   end
 
+  FieldInfo = Struct.new :name, :params_required?, :params_type, :query_type, :sub_query_params
+
   def self.query_type_definition(type)
     field_definitions = type.fields.map do |field|
       association_type = field.type.association_type
-      if association_type
-        qname = "Type#{association_type.name}Query"
-        if field.args.empty?
-          "#{field.name}?: true | #{qname} | { as?: string; attributes?: #{qname} }"
-        else
-          "#{field.name}?: true | #{qname} | { as?: string; params: #{field.args_ts_type}; attributes?: #{qname} }"
-        end
-      else
-        "#{field.name}?: true | { as: string }"
-      end
+      query_type = "Type#{association_type.name}Query" if association_type
+      params_type = field.args_ts_type unless field.args.empty?
+      params_required = field.args_required?
+      attrs = []
+      attrs << "query?: #{query_type}" if query_type
+      attrs << "params#{'?' unless params_required}: #{params_type}" if params_type
+      sub_query_params = attrs
+      FieldInfo.new field.name, params_required, params_type, query_type, sub_query_params
     end
-    field_definitions << "'*'?: true"
+    accept_wildcard = !field_definitions.any?(&:params_required?)
     query_type_name = "Type#{type.name}Query"
+    standalone_fields_name = "Type#{type.name}StandaloneFields"
+    alias_query_type_name = "Type#{type.name}AliasFieldQuery"
     base_query_type_name = "Type#{type.name}QueryBase"
+    standalone_fields_definition = field_definitions.reject(&:params_required?).map do |info|
+      "'#{info.name}'"
+    end.join(' | ')
+    standalone_fields_definition += " | '*'" if accept_wildcard
+    alias_query_type_definition = field_definitions.map do |info|
+      attrs = ["field: '#{info.name}'", *info.sub_query_params].join('; ')
+      "  | { #{attrs} }\n"
+    end.join
+    base_query_type_definition = field_definitions.map do |info|
+      types = []
+      unless info.params_required?
+        types << true
+        types << info.query_type if info.query_type
+      end
+      types << "{ field: never; #{info.sub_query_params.join('; ')} }" unless info.sub_query_params.empty?
+      "  #{info.name}: #{types.join(' | ')}"
+    end.join("\n")
+    base_query_type_definition += "\n  '*': true" if accept_wildcard
     <<~TYPE
-      export type #{query_type_name} = keyof (#{base_query_type_name}) | Readonly<(keyof (#{base_query_type_name}))[]> | #{base_query_type_name}
+      export type #{query_type_name} = #{standalone_fields_name} | Readonly<#{standalone_fields_name}[]>
+        | (
+          { [key in keyof #{base_query_type_name}]?: key extends '*' ? true : #{base_query_type_name}[key] | #{alias_query_type_name} }
+          & { [key: string]: #{alias_query_type_name} | NonAliasQuery }
+        )
+      export type #{standalone_fields_name} = #{standalone_fields_definition.presence || 'never'}
+      export type #{alias_query_type_name} =
+      #{alias_query_type_definition.presence || 'never'}
       export interface #{base_query_type_name} {
-      #{field_definitions.map { |line| "  #{line}" }.join("\n")}
+      #{base_query_type_definition}
       }
     TYPE
   end

data/lib/ar_serializer/version.rb

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

data/lib/ar_serializer.rb

@@ -4,8 +4,18 @@ require 'ar_serializer/field'
 require 'active_record'
 
 module ArSerializer
-  def self.serialize(*args)
-    Serializer.serialize(*args)
+  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
 
@@ -18,60 +28,54 @@ 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|
         names.each do |name|
-          field = ArSerializer::Field.create(self, association || name, option, &data_block)
+          field = ArSerializer::Field.create(self, association || name, **option, &data_block)
           _serializer_namespace(ns)[name.to_s] = field
         end
       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
+    def serializer_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.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - tompng
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-05-11 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.0.1
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: ActiveRecord serializer, avoid N+1
 test_files: []