ar_serializer 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e9144cab6ef520e2c0734bbe98a13a046f3b7b8411310ccc522dc999bae5365
-  data.tar.gz: d938b8684bbb22937c97c2572994b6bd11b38c72011f1b19975d96c7633656c7
+  metadata.gz: f5dcdb4d958a8a3c5f45333e6d046d8070b817e9ace01ff9c5129421117a4d96
+  data.tar.gz: 3e37de9cd29f69b6a9fc98a297fc40eb700127403e01604cc779f0225ecd2196
 SHA512:
-  metadata.gz: a7ff7ed23abaabef6893c31dc259ce18eeb3111df652c4e4a2d717523853e4a4f27119ddb0d027583ae788b218fdea73abebfc5de99480447e51bbabe04929f9
-  data.tar.gz: 8bceb19d2f319772e575c440870d074431f21efeab16375dced2e87637791e3d94927f0024c01bfd9669f0e0fb9743539f17ac47b12233a056db64e12b952264
+  metadata.gz: e6f6050647dfe4baf84dd2801c3158447c91653dd70894a92a9eedd8c1a3b84e6da8182854ccf380f0c66ed4927774d83ed5dfc8c327d1d9ab9189c71d10d0bc
+  data.tar.gz: ac83b599db7be347c547b7bd1a6a3a2b0d28825220df5d862899151fe26d1aa4843a34851e3af683d7ff2245b4d904cfbf191a1a5e837dd7758b57cb7023fb83

data/Gemfile.lock

@@ -1,33 +1,32 @@
 PATH
   remote: .
   specs:
-    ar_serializer (1.0.0)
+    ar_serializer (1.1.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 (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)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (9.0.0)
+      zeitwerk (~> 2.2)
     coderay (1.1.2)
     concurrent-ruby (1.1.5)
     docile (1.3.1)
-    i18n (1.6.0)
+    i18n (1.7.0)
       concurrent-ruby (~> 1.0)
     json (2.1.0)
     method_source (0.9.2)
-    minitest (5.11.3)
+    minitest (5.13.0)
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -39,10 +38,11 @@ GEM
     simplecov-html (0.10.2)
     sqlite3 (1.4.0)
     thread_safe (0.3.6)
-    top_n_loader (1.0.0)
+    top_n_loader (1.0.1)
       activerecord
-    tzinfo (1.2.5)
+    tzinfo (1.2.6)
       thread_safe (~> 0.1)
+    zeitwerk (2.2.2)
 
 PLATFORMS
   ruby
@@ -56,4 +56,4 @@ DEPENDENCIES
   sqlite3
 
 BUNDLED WITH
-   1.17.2
+   2.1.2

data/README.md

@@ -85,11 +85,11 @@ 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: { id: :desc }, limit: 2 }] }
 
 # 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 +123,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/lib/ar_serializer.rb

@@ -4,8 +4,8 @@ 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
 end
 
@@ -50,7 +50,7 @@ module ArSerializer::Serializable
       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
@@ -64,8 +64,8 @@ module ArSerializer::Serializable
       _custom_preloaders[name] = block
     end
 
-    def serializer_defaults(*args, &block)
-      serializer_field :defaults, *args, &block
+    def serializer_defaults(**args, &block)
+      serializer_field :defaults, **args, &block
     end
   end
 end

data/lib/ar_serializer/field.rb

@@ -1,4 +1,5 @@
 require 'ar_serializer/error'
+require 'top_n_loader'
 
 class ArSerializer::Field
   attr_reader :includes, :preloaders, :data_block, :only, :except, :order_column
@@ -72,7 +73,7 @@ class ArSerializer::Field
 
   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}"
@@ -82,22 +83,12 @@ class ArSerializer::Field
     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
-  end
-
   def self.type_from_column_type(klass, name)
     type = type_from_attribute_type klass, name.to_s
     return :any if type.nil?
@@ -172,11 +163,11 @@ class ArSerializer::Field
       preloaders = []
       includes ||= name if klass.respond_to?(:reflect_on_association) && klass.reflect_on_association(name)
     end
-    data_block ||= ->(preloaded, _context, _params) { preloaded[id] } if preloaders.size == 1
+    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 }
+      data_block: data_block || ->(_context, **_params) { send name }
     )
   end
 
@@ -194,7 +185,7 @@ class ArSerializer::Field
     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, "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]
   end
@@ -206,11 +197,11 @@ class ArSerializer::Field
       end
       params_type = { limit?: :int, order?: [{ :* => %w[asc desc] }, 'asc', 'desc'] }
     else
-      preloader = lambda do |models, _context, _params|
+      preloader = lambda do |models, _context, **_params|
         preload_association klass, models, name
       end
     end
-    data_block = lambda do |preloaded, _context, _params|
+    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
@@ -219,16 +210,14 @@ class ArSerializer::Field
   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 }
-    end
+    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 limit.nil? && order.nil?
+    return if order.nil?
     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]
+      [model.id, 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

data/lib/ar_serializer/serializer.rb

@@ -37,9 +37,9 @@ module ArSerializer::Serializer
     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, include_id: false, use: 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
@@ -59,21 +59,22 @@ module ArSerializer::Serializer
       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[:*]
-        all_keys = klass._serializer_field_keys.map(&:to_sym)
+      if attributes.any? { |k, _| k == :* }
+        all_keys = klass._serializer_field_keys.map(&:to_sym) - [:defaults]
         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
+      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|
-        klass._serializer_field_info(name).preloaders.map do |p|
+        field_name = sub_args[:field_name] || name
+        klass._serializer_field_info(field_name).preloaders.map do |p|
           [p, sub_args[:params]]
         end
       end
@@ -84,9 +85,9 @@ module ArSerializer::Serializer
       preloader_values = preloader_params.compact.uniq.map do |key|
         preloader, params = key
         if preloader.arity < 0
-          [key, preloader.call(models, context, params || {})]
+          [key, preloader.call(models, context, **(params || {}))]
         else
-          [key, preloader.call(*[models, context, params || {}].take(preloader.arity))]
+          [key, preloader.call(*[models, context].take(preloader.arity), **(params || {}))]
         end
       end.to_h
 
@@ -102,11 +103,12 @@ module ArSerializer::Serializer
         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)
+          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 = {}
@@ -117,10 +119,6 @@ module ArSerializer::Serializer
             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
           elsif child.is_a? ArSerializer::Serializable
             data = {}
             sub_calls << [child, data]
@@ -151,27 +149,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
+          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
           else
-            attributes[sym_key] = value == true ? {} : parse_args(value)
+            attributes << [sym_key, value == true ? {} : parse_args(value)]
           end
         end
       else
@@ -179,6 +176,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.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_serializer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - tompng
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-11 00:00:00.000000000 Z
+date: 2020-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -153,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: ActiveRecord serializer, avoid N+1