ar_serializer 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de3115e702a13b938be93babf38a51d84da70ed9b69f24f4e785677b8a69c69a
-  data.tar.gz: 640e1bd6f87589be333e2f76885a351081461a95955cb746659dd77dcf1b0ad8
+  metadata.gz: ef5e6277909a8e2573068c3c8c2e19275c8763c9395f610cb0e8aebbce566eee
+  data.tar.gz: ad0b8f4f8961dcf576c402071f79b312e93c0a4da958bab46b420adb70ea5416
 SHA512:
-  metadata.gz: 5943c272b4a00c091fc002bec7aaa0c5f4ed4da98f0050da4b19fb7cbc3622e0dc539f9ef2c0f661bc7e0718c24f13f2ee84957392d5ea6f7bb12a4652cd2083
-  data.tar.gz: 39183107e382d5d8dbbfe157feba890e3d4a7b47bbadff80d524fa193db8d812125f44786a6056009b0bae57d52b39dd6f9b4e6aff5c716913bf055467f720ae
+  metadata.gz: 285562de1dc23efb39552eb7b184fb2004dfdf0a63314d161f5397060ca79c22136140612cde7f3d46bc76f3b649e016671fd15561d9829e4c14f22a42cf7c72
+  data.tar.gz: 3081e60e717cefe07b8629934babeacecef06c5ee059702cf8371e3214dd5c6fb7a489dd09cc8f5b31d9f8571ef4b8722c607dcce02145e2a5197bcd8a42c7cf

data/.github/workflows/test.yml

@@ -5,7 +5,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.2', '3.3', '3.4' ]
+        ruby: [ '3.2', '3.3', '3.4', '4.0' ]
         gemfiles:
           - gemfiles/Gemfile-rails-6
           - gemfiles/Gemfile-rails-7

data/Gemfile

@@ -5,3 +5,4 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in ar_serializer.gemspec
 gemspec
 gem "sqlite3"
+gem "irb"

data/README.md

@@ -1,15 +1,19 @@
 # ArSerializer
 
-- JSONの形をclientからリクエストできる
-- N+1 SQLを避ける
+A serializer for ActiveRecord (and plain Ruby objects) where the **client requests the shape of the JSON**, GraphQL-style.
 
-## Install
+- The client decides which fields and associations to fetch, with a query.
+- Associations are batch-loaded, so deeply nested queries avoid N+1 SQL.
+- Generates TypeScript type definitions and can serve a GraphQL endpoint.
+
+## Installation
 
 ```ruby
 gem 'ar_serializer'
 ```
 
-## Field定義
+## Defining fields
+
 ```ruby
 class User < ActiveRecord::Base
   has_many :posts
@@ -27,20 +31,26 @@ class Comment < ActiveRecord::Base
 end
 ```
 
-## Serialize
+## Serializing
+
+```ruby
+ArSerializer.serialize(model, query, context: nil, use: nil)
+```
+
 ```ruby
 ArSerializer.serialize Post.find(params[:id]), params[:query]
 ```
 
 ## Query
+
+A query selects fields. Use `:*` for all fields, an array, or a hash; nested
+associations take a nested query.
+
 ```ruby
 ArSerializer.serialize user, :*
-# => {
-#   id: 1,
-#   name: "user1",
-#   posts: [{}, {}]
-# }
+# => { id: 1, name: "user1", posts: [{}, {}] }
 
+# Array form and hash form are equivalent:
 ArSerializer.serialize user, [:id, :name, posts: [:id, :title, comments: :id]]
 ArSerializer.serialize user, { id: true, name: true, posts: { id: true, title: true, comments: :id } }
 # => {
@@ -51,25 +61,36 @@ ArSerializer.serialize user, { id: true, name: true, posts: { id: true, title: t
 #     { id: 3, title: "title2", comments: [] }
 #   ]
 # }
+```
+
+Rename a field in the output with `as:`:
+
+```ruby
 ArSerializer.serialize posts, [:title, :body, comment_count: { as: :num_replies }]
-# => [
-#   { title: "title1", body: "body1", num_replies: 3 },
-#   { title: "title2", body: "body2", num_replies: 2 },
-#   { title: "title3", body: "body3", num_replies: 0 },
-#   { title: "title4", body: "body4", num_replies: 4 }
-# ]
+# => [{ title: "title1", body: "body1", num_replies: 3 }, ...]
 ```
 
-## その他
+## Field options
+
+### Computed fields (`data block`, `includes`)
+
+Pass a block to compute the value. `includes:` eager-loads the associations the
+block needs.
+
 ```ruby
-# data block, include
 class Comment < ActiveRecord::Base
-  serializer_field :username, includes: :user do
-    { ja: user.name + '先生', en: 'Dr.' + user.name }
+  serializer_field :title, includes: :user do
+    "#{user.name}'s comment"
   end
 end
+```
+
+### Preloading (avoid N+1)
 
-# preloader
+`preload:` receives **all** records being serialized and returns a lookup; the
+data block then reads from it per record.
+
+```ruby
 class Foo < ActiveRecord::Base
   bar_count_loader = ->(models) do
     Bar.where(foo_id: models.map(&:id)).group(:foo_id).count
@@ -77,59 +98,136 @@ class Foo < ActiveRecord::Base
   serializer_field :bar_count, preload: bar_count_loader do |preloaded|
     preloaded[id] || 0
   end
-  # data_blockが `do |preloaded| preloaded[id] end` の場合は省略可能
+  # When the data block is exactly `do |preloaded| preloaded[id] end`, it can be omitted.
 end
+```
 
-# order and limits
-class Post < ActiveRecord::Base
-  has_many :comments
-  serializer_field :comments
-end
+### Counts
+
+```ruby
+serializer_field :comment_count, count_of: :comments
+```
+
+### Order and limits
+
+Associations accept `order_by`, `direction`, `first`/`last` params.
+
+```ruby
 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
 
-# context and params
+The block receives the serialize-time `context` and any query `params`.
+
+```ruby
 class Post < ActiveRecord::Base
   serializer_field :created_at do |context, **params|
     created_at.in_time_zone(context[:tz]).strftime params[:format]
   end
 end
 ArSerializer.serialize post, { created_at: { params: { format: '%H:%M:%S' } } }, context: { tz: 'Tokyo' }
+```
 
-# camelcase
+### camelCase field names
+
+```ruby
 class Foo < ActiveRecord::Base
   def foo_bar; end
   serializer_field :fooBar
 end
+```
 
-# non activerecord class
-class Foo
-  include ArSerializer::Serializable
-  def bar; end
-  serializer_field :bar
+### Aliasing an association (`association:`)
+
+Expose an association under a different name.
+
+```ruby
+class User < ActiveRecord::Base
+  serializer_field :articles, association: :posts
 end
+ArSerializer.serialize user, { articles: :title }
+```
 
-# namespace
+### Restricting fields (`only` / `except`)
+
+Limit which fields of the associated records may be queried. Combine with
+`association:` when the field name differs from the association.
+
+```ruby
+class User < ActiveRecord::Base
+  serializer_field :posts, only: :title                       # restrict
+  serializer_field :entries, association: :posts, except: :body  # alias + restrict
+end
+ArSerializer.serialize user, { posts: :title }    #=> ok
+ArSerializer.serialize user, { posts: :body }     #=> Error (not allowed by `only`)
+ArSerializer.serialize user, { entries: :title }  #=> ok
+ArSerializer.serialize user, { entries: :body }   #=> Error (excluded by `except`)
+```
+
+## Access control
+
+### Field-level: `permission:`
+
+Guards a single field. When the predicate returns false the field is omitted
+from the output.
+
+```ruby
+serializer_field :email, permission: ->(current_user) { current_user&.admin? }
+```
+
+### Model-level: `serializer_permission`
+
+Guards every instance of a class, **no matter which query path reaches it**.
+When serializing, each candidate object is checked and objects failing the
+predicate are dropped — a single reference becomes `null`, an array drops the
+element. Useful because any field reachable through the query graph is otherwise
+fetchable.
+
+```ruby
+class Document < ActiveRecord::Base
+  belongs_to :user
+  serializer_permission do |current_user|
+    current_user && current_user.id == user_id
+  end
+  serializer_field :id, :title
+end
+```
+
+## Namespaces
+
+Fields can be grouped into namespaces and exposed only when requested via `use:`.
+
+```ruby
 class User < ActiveRecord::Base
   serializer_field :name
   serializer_field(:foo, namespace: :admin) { :foo }
   serializer_field(:bar, namespace: :superadmin) { :bar }
 end
-ArSerializer.serialize user, [:name, :foo] #=> Error
+ArSerializer.serialize user, [:name, :foo]                          #=> Error
 ArSerializer.serialize user, [:name, :foo], use: :admin
 ArSerializer.serialize user, [:name, :foo, :bar], use: [:admin, :superadmin]
+```
 
-# only, except
-class User < ActiveRecord::Base
-  serializer_field :o_posts, association: :posts, only: :title
-  serializer_field :e_posts, association: :posts, except: :comments
+## Non-ActiveRecord classes
+
+Include `ArSerializer::Serializable` to use the DSL on plain Ruby objects.
+
+```ruby
+class Foo
+  include ArSerializer::Serializable
+  def bar; end
+  serializer_field :bar
 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
+```
 
-# types
+## TypeScript types
+
+Declare types with `type:` / `params_type:`, then generate `.d.ts`-style
+definitions.
+
+```ruby
 class User < ActiveRecord::Base
   serializer_field(:posts, params_type: { title: :string? }) do |title: nil|
     title ? posts.where(title: title) : posts
@@ -139,10 +237,16 @@ class User < ActiveRecord::Base
   end
   serializer_field :published_posts, type: -> { [Post] }
 end
+
 ArSerializer::TypeScript.generate_type_definition User
-# => export type TypeUser {...}; export type TypePost {...}; ...
+# => export type TypeUser = {...}; export type TypePost = {...}; ...
+```
+
+## GraphQL
 
-# graphql
+Expose a schema object and serve GraphQL queries against it.
+
+```ruby
 class MySchema
   include ArSerializer::Serializable
   serializer_field :post, type: Post do |context, id:|
@@ -155,7 +259,12 @@ class MySchema
     ArSerializer::GraphQL::SchemaClass.new self.class
   end
 end
+
 ArSerializer::GraphQL.definition MySchema # schema.graphql
-ArSerializer::GraphQL.serialize MySchema.new, '{post(id: 1){title} user(name: user1){id name}}'
-ArSerializer::GraphQL.serialize MySchema.new, '{__schema{types{name fields{ name}}}}', operation_name: nil, variables: {}
+ArSerializer::GraphQL.serialize MySchema.new, '{ post(id: 1){ title } user(name: "user1"){ id name } }'
+ArSerializer::GraphQL.serialize MySchema.new, '{ __schema { types { name fields { name } } } }', operation_name: nil, variables: {}
 ```
+
+## License
+
+[MIT](LICENSE.txt)

data/gemfiles/Gemfile-rails-6

@@ -12,3 +12,4 @@ gem "logger"
 gem "concurrent-ruby", "1.3.4"
 gem "sqlite3", "~> 1.4"
 gem "activerecord", "~> 6.0"
+gem "benchmark"

data/lib/ar_serializer/field.rb

@@ -4,7 +4,25 @@ require 'set'
 
 class ArSerializer::Field
   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
+  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,
+    ts_type: nil,
+    params_type: nil,
+    ts_params_type: nil
+  )
     @klass = klass
     @name = name
     @includes = includes
@@ -18,8 +36,8 @@ class ArSerializer::Field
     @data_block = data_block
     @order_column = order_column
     @orderable = orderable
-    @type = type
-    @params_type = params_type
+    @type = ts_type ? ArSerializer::TSType.new(ts_type) : type
+    @params_type = ts_params_type ? ArSerializer::TSType.new(ts_params_type) : params_type
   end
 
   def orderable?
@@ -50,8 +68,8 @@ class ArSerializer::Field
     splat.call type
   end
 
-  def arguments
-    return @params_type.is_a?(Proc) ? @params_type.call : @params_type if @params_type
+  def arguments_type
+    return ArSerializer::GraphQL::TypeClass.from(@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)]
@@ -79,8 +97,8 @@ class ArSerializer::Field
         end
       end
     end
-    return :any if any && arguments.empty?
-    arguments.map do |key, req|
+    return ArSerializer::GraphQL::TypeClass.from(:any) if any && arguments.empty?
+    hash_args = arguments.to_h do |key, req|
       camelcase = key.to_s.camelcase :lower
       type = (
         case key
@@ -94,7 +112,8 @@ class ArSerializer::Field
         end
       )
       [req ? camelcase : "#{camelcase}?", type]
-    end.to_h
+    end
+    ArSerializer::GraphQL::TypeClass.from(hash_args)
   end
 
   def validate_attributes(attributes)
@@ -145,7 +164,26 @@ 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, private: nil, scoped_access: nil, permission: nil, fallback: nil, order_column: nil, orderable: nil, &data_block)
+  def self.create(
+    klass,
+    name,
+    ts_type: nil,
+    type: nil,
+    ts_params_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 || order_column || orderable || scoped_access != nil || fallback
@@ -153,6 +191,10 @@ class ArSerializer::Field
       end
       return count_field klass, name, count_of, permission: permission
     end
+
+    type = ArSerializer::TSType.new(ts_type) if ts_type
+    params_type = ArSerializer::TSType.new(ts_params_type) if ts_params_type
+
     association = klass.reflect_on_association name.underscore if klass.respond_to? :reflect_on_association
     if association
       if association.collection?

data/lib/ar_serializer/graphql/types.rb

@@ -5,7 +5,7 @@ module ArSerializer::GraphQL
     def initialize(name, type)
       @optional = name.to_s.end_with? '?' # TODO: refactor
       @name = name.to_s.delete '?'
-      @type = TypeClass.from type
+      @type = type
     end
     serializer_field :name
     serializer_field :type, except: :fields
@@ -22,8 +22,10 @@ module ArSerializer::GraphQL
     end
 
     def args
-      return [] if field.arguments == :any
-      field.arguments.map do |key, type|
+      arguments = field.arguments_type
+      return [] unless arguments.is_a?(HashTypeClass)
+
+      arguments.type.map do |key, type|
         ArgClass.new key, type
       end
     end
@@ -33,24 +35,26 @@ module ArSerializer::GraphQL
     end
 
     def collect_types(types)
-      types[:any] = true if field.arguments == :any
-      args.each { |arg| arg.type.collect_types types }
+      field.arguments_type.collect_types types
       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))
+      arguments_type = field.arguments_type
+      case arguments_type
+      when TSTypeClass
+        true
+      when HashTypeClass
+        arguments_type.type.any? do |k, v|
+          !k.end_with?('?') && !v.is_a?(OptionalTypeClass)
+        end
+      else
+        false
       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
-      arg_types.empty? ? 'Record<string, never>' : "{ #{arg_types.join '; '} }"
+      field.arguments_type.ts_type
     end
 
     serializer_field :name, :args
@@ -92,46 +96,16 @@ module ArSerializer::GraphQL
 
   class TypeClass
     include ::ArSerializer::Serializable
-    attr_reader :type, :only, :except
-    def initialize(type, only = nil, except = nil)
+    attr_reader :type
+    def initialize(type)
       @type = type
-      @only = only
-      @except = except
-      validate!
     end
 
     class InvalidType < StandardError; end
 
-    def validate!
-      valid_symbols = %i[number int float string boolean any unknown]
-      invalids = []
-      recursive_validate = lambda do |t|
-        case t
-        when Array
-          t.each { |v| recursive_validate.call v }
-        when Hash
-          t.each_value { |v| recursive_validate.call v }
-        when String, Numeric, true, false, nil
-          return
-        when Class
-          invalids << t unless t.ancestors.include? ArSerializer::Serializable
-        when Symbol
-          invalids << t unless valid_symbols.include? t.to_s.gsub(/\?$/, '').to_sym
-        else
-          invalids << t
-        end
-      end
-      recursive_validate.call type
-      return if invalids.empty?
-      message = "Valid types are String, Numeric, Hash, Array, ArSerializer::Serializable, true, false, nil and Symbol#{valid_symbols}"
-      raise InvalidType, "Invalid type: #{invalids.map(&:inspect).join(', ')}. #{message}"
-    end
-
     def collect_types(types); end
 
-    def description
-      ts_type
-    end
+    def description = ts_type
 
     def name; end
 
@@ -139,8 +113,6 @@ module ArSerializer::GraphQL
 
     def fields; end
 
-    def sample; end
-
     def ts_type; end
 
     def association_type; end
@@ -154,35 +126,59 @@ module ArSerializer::GraphQL
 
     def self.from(type, only = nil, except = nil)
       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?('?')
+      type = [type[0...-1], nil] if type.is_a?(String) && type.end_with?('?') # ??
       case type
       when Class
+        raise InvalidType, "#{type} must include ArSerializer::Serializable" unless type.ancestors.include? ArSerializer::Serializable
+
         SerializableTypeClass.new type, only, except
-      when Symbol, String, Numeric, true, false, nil
+      when :number, :int, :float, :string, :boolean, :any, :unknown
+        ScalarTypeClass.new type
+      when String, Numeric, true, false, nil
         ScalarTypeClass.new type
       when Array
         if type.size == 1
-          ListTypeClass.new type.first, only, except
+          ListTypeClass.new from(type.first, only, except)
         elsif type.size == 2 && type.last.nil?
-          OptionalTypeClass.new type, only, except
+          OptionalTypeClass.new from(type.first, only, except)
         else
-          OrTypeClass.new type, only, except
+          OrTypeClass.new type.map {|v| from(v, only, except) }
         end
       when Hash
-        HashTypeClass.new type, only, except
+        HashTypeClass.new type.transform_values {|v| from(v, only, except) }
+      when ArSerializer::TSType
+        TSTypeClass.new type.type
+      else
+        raise InvalidType, "Invalid type: #{type}"
       end
     end
   end
 
-  class ScalarTypeClass < TypeClass
+  class TSTypeClass < TypeClass
     def initialize(type)
       @type = type
     end
 
-    def kind
-      'SCALAR'
+    def kind = 'SCALAR'
+
+    def name = :other
+
+    def collect_types(types)
+      types[:other] = true
+    end
+
+    def gql_type = 'SCALAR'
+
+    def ts_type = @type
+  end
+
+  class ScalarTypeClass < TypeClass
+    def initialize(type)
+      @type = type
     end
 
+    def kind = 'SCALAR'
+
     def name
       case type
       when String, :string
@@ -206,24 +202,7 @@ module ArSerializer::GraphQL
       types[name] = true
     end
 
-    def gql_type
-      type
-    end
-
-    def sample
-      case ts_type
-      when 'number'
-        0
-      when 'string'
-        ''
-      when 'boolean'
-        true
-      when 'any', 'unknown'
-        nil
-      else
-        type
-      end
-    end
+    def gql_type = type
 
     def ts_type
       case type
@@ -240,49 +219,53 @@ module ArSerializer::GraphQL
   end
 
   class HashTypeClass < TypeClass
-    def kind
-      'SCALAR'
-    end
+    def kind = 'SCALAR'
 
-    def name
-      :other
-    end
+    def name = :other
 
     def collect_types(types)
       types[:other] = true
-      type.values.map do |v|
-        TypeClass.from(v, only, except).collect_types(types)
+      type.values.each do |v|
+        v.collect_types(types)
       end
     end
 
     def association_type
       type.values.each do |v|
-        t = TypeClass.from(v, only, except).association_type
+        t = v.association_type
         return t if t
       end
       nil
     end
 
-    def gql_type
-      'OBJECT'
-    end
-
-    def sample
-      type.reject { |k| k.to_s.end_with? '?' }.transform_values do |v|
-        TypeClass.from(v).sample
-      end
-    end
+    def gql_type = 'OBJECT'
 
     def ts_type
+      return 'Record<string, never>' if type.empty?
+
       fields = type.map do |key, value|
         k = key.to_s == '*' ? '[key: string]' : key
-        "#{k}: #{TypeClass.from(value, only, except).ts_type}"
+        "#{k}: #{value.ts_type}"
       end
       "{ #{fields.join('; ')} }"
     end
+
+    def to_gql_args
+      type.map do |key, type|
+        ArgClass.new key, type
+      end
+    end
   end
 
   class SerializableTypeClass < TypeClass
+    attr_reader :only, :except
+
+    def initialize(type, only = nil, except = nil)
+      super type
+      @only = only
+      @except = except
+    end
+
     def field_only
       [*only].map(&:to_s)
     end
@@ -291,9 +274,7 @@ module ArSerializer::GraphQL
       [*except].map(&:to_s)
     end
 
-    def kind
-      'OBJECT'
-    end
+    def kind = 'OBJECT'
 
     def name
       name_segments = [type.name.delete(':')]
@@ -322,17 +303,11 @@ module ArSerializer::GraphQL
       fields.each { |field| field.collect_types types }
     end
 
-    def association_type
-      self
-    end
+    def association_type = self
 
-    def gql_type
-      name
-    end
+    def gql_type = name
 
-    def ts_type
-      "Type#{name}"
-    end
+    def ts_type = "Type#{name}"
 
     def eql?(t)
       self.class == t.class && self.compare_elements == t.compare_elements
@@ -352,101 +327,55 @@ module ArSerializer::GraphQL
   end
 
   class OptionalTypeClass < TypeClass
-    def kind
-      of_type.kind
-    end
+    def kind = type.kind
 
-    def name
-      of_type.name
-    end
+    def name = type.name
 
-    def of_type
-      TypeClass.from type.first, only, except
-    end
+    def of_type = type
 
-    def association_type
-      of_type.association_type
-    end
+    def association_type = type.association_type
 
     def collect_types(types)
-      of_type.collect_types types
+      type.collect_types types
     end
 
-    def gql_type
-      of_type.gql_type
-    end
+    def gql_type = type.gql_type
 
-    def sample
-      nil
-    end
-
-    def ts_type
-      "(#{of_type.ts_type} | null)"
-    end
+    def ts_type = "(#{type.ts_type} | null)"
   end
 
   class OrTypeClass < TypeClass
-    def kind
-      'OBJECT'
-    end
+    def kind = 'OBJECT'
 
-    def name
-      :other
-    end
+    def name = :other
 
-    def of_types
-      type.map { |t| TypeClass.from t, only, except }
-    end
+    def of_types = type
 
     def collect_types(types)
       types[:other] = true
-      of_types.map { |t| t.collect_types types }
-    end
-
-    def gql_type
-      kind
+      type.map { |t| t.collect_types types }
     end
 
-    def sample
-      of_types.first.sample
-    end
+    def gql_type = kind
 
-    def ts_type
-      '(' + of_types.map(&:ts_type).join(' | ') + ')'
-    end
+    def ts_type = "(#{type.map(&:ts_type).join(' | ')})"
   end
 
   class ListTypeClass < TypeClass
-    def kind
-      'LIST'
-    end
+    def kind = 'LIST'
 
-    def name
-      'LIST'
-    end
+    def name = 'LIST'
 
-    def of_type
-      TypeClass.from type, only, except
-    end
+    def of_type = type
 
     def collect_types(types)
-      of_type.collect_types types
-    end
-
-    def association_type
-      of_type.association_type
+      type.collect_types types
     end
 
-    def gql_type
-      "[#{of_type.gql_type}]"
-    end
+    def association_type = type.association_type
 
-    def sample
-      []
-    end
+    def gql_type = "[#{type.gql_type}]"
 
-    def ts_type
-      "(#{of_type.ts_type} [])"
-    end
+    def ts_type = "(#{type.ts_type} [])"
   end
 end

data/lib/ar_serializer/serializer.rb

@@ -85,6 +85,7 @@ module ArSerializer::Serializer
         raise ArgumentError, "No permission field #{permission} for #{klass}" unless permission_field
       end
       if permission_field
+        ArSerializer.preload_associations models, permission_field.includes if permission_field.includes.present?
         preloadeds = permission_field.preloaders.map do |p|
           preloader_values[[p, nil]] ||= preload.call p, nil
         end
@@ -95,6 +96,7 @@ module ArSerializer::Serializer
 
       defaults = klass._serializer_field_info :defaults
       if defaults
+        ArSerializer.preload_associations models, defaults.includes if defaults.includes.present?
         defaults.preloaders.each do |p|
           preloader_values[[p, nil]] ||= preload.call p, nil
         end
@@ -181,7 +183,7 @@ module ArSerializer::Serializer
       end
 
       if defaults
-        preloadeds = defaults.preloaders.map { |p| preloader_values[[p]] } || []
+        preloadeds = defaults.preloaders.map { |p| preloader_values[[p, nil]] } || []
         models.each do |model|
           data = model.instance_exec(*preloadeds, context, {}, &defaults.data_block)
           output_for_model[model].update data

data/lib/ar_serializer/type_script.rb

@@ -16,7 +16,7 @@ module ArSerializer::TypeScript
     field_definitions = type.fields.map do |field|
       association_type = field.type.association_type
       query_type = "Type#{association_type.name}Query" if association_type
-      params_type = field.args_ts_type unless field.args.empty?
+      params_type = field.args_ts_type
       params_required = field.args_required?
       attrs = []
       attrs << "query?: #{query_type}" if query_type

data/lib/ar_serializer/version.rb

@@ -1,3 +1,3 @@
 module ArSerializer
-  VERSION = '1.2.2'
+  VERSION = '1.2.4'
 end

data/lib/ar_serializer.rb

@@ -4,6 +4,8 @@ require 'ar_serializer/field'
 require 'active_record'
 
 module ArSerializer
+  TSType = Data.define(:type)
+
   def self.serialize(model, query, **option)
     Serializer.serialize(model, query, **option)
   end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ar_serializer
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.4
 platform: ruby
 authors:
 - tompng
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -127,7 +126,6 @@ homepage: https://github.com/tompng/ar_serializer
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -142,8 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: ActiveRecord serializer, avoid N+1
 test_files: []