ar_serializer 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee32f3c64753466283134306f9c8bcae7435cd8cfb337591455de2455de5fc15
-  data.tar.gz: eab2dc2c198ef804b6d0f1070057131480dae5fcae0f394d2a4aee065b647e0b
+  metadata.gz: 82a536d1726d005b8fe7606ba04dd252bd169a88686d67b6eb6fdb5f4f2e791d
+  data.tar.gz: fe03fd5cc99e41f4b9002fe43351f619e65f8a692049bd0af959432fe301e1d8
 SHA512:
-  metadata.gz: 2d1aef11e66bca294d04217f7046d902063ba382e0ccbd4c11c0e843ad527929941f22b874753fefc24c550efbc28a3226939c61dc82fe81ed7e0352963f0e7e
-  data.tar.gz: 6f62a16b9bf8f971f9379c0860772e921844e8123506cbbb89e92f759d8f97f1b686ac803cfd1092bce8078be656d96ff2ceaa66377cc080685fdcf19b072a7d
+  metadata.gz: 86729d4da8d17051e42dcab42dec965163ed478e738459eed8633942f29ff5262e7691b726d785db4fdcbc2781c286d93d4972b400fa8bbfaf62d4dc8e196b30
+  data.tar.gz: 13d2d9d8c85004a4c02cb0988797395a1d2819535c03d8cb753ee0a2882177ea8a8d090cc1902289afc96ca89440a6530a71f840308d8e33ce9983af16203062

data/.github/workflows/test.yml

@@ -5,11 +5,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.1', '3.2', '3.3' ]
+        ruby: [ '3.2', '3.3', '3.4', '4.0' ]
         gemfiles:
           - gemfiles/Gemfile-rails-6
-          - gemfiles/Gemfile-rails-7-0
-          - gemfiles/Gemfile-rails-7-1
+          - gemfiles/Gemfile-rails-7
+          - gemfiles/Gemfile-rails-8
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4

data/Gemfile

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

data/gemfiles/Gemfile-rails-6

@@ -5,5 +5,11 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in ar_serializer.gemspec
 gemspec path: ".."
 
+gem "bigdecimal"
+gem "base64"
+gem "mutex_m"
+gem "logger"
+gem "concurrent-ruby", "1.3.4"
 gem "sqlite3", "~> 1.4"
 gem "activerecord", "~> 6.0"
+gem "benchmark"

data/gemfiles/{Gemfile-rails-7-0 → Gemfile-rails-7}

@@ -6,4 +6,5 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 gemspec path: ".."
 
 gem "sqlite3", "~> 1.4"
-gem "activerecord", "~> 7.0.0"
+gem "activerecord", "~> 7.0"
+gem "benchmark"

data/gemfiles/{Gemfile-rails-7-1 → Gemfile-rails-8}

@@ -5,5 +5,6 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in ar_serializer.gemspec
 gemspec path: ".."
 
-gem "sqlite3", "~> 1.4"
-gem "activerecord", "~> 7.1.0"
+gem "sqlite3"
+gem "activerecord", "~> 8.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/parser.rb

@@ -73,7 +73,7 @@ class ArSerializer::GraphQL::Parser
   end
 
   def parse_name
-    name = ''
+    name = +''
     name << chars.shift while chars.first && chars.first =~ /[a-zA-Z0-9_]/
     name unless name.empty?
   end
@@ -94,7 +94,7 @@ class ArSerializer::GraphQL::Parser
     case chars.first
     when '"'
       chars.shift
-      s = ''
+      s = +''
       loop do
         if chars.first == '\\'
           s << chars.shift
@@ -132,7 +132,7 @@ class ArSerializer::GraphQL::Parser
       name = parse_name
       variables[name]
     when /[0-9+\-]/
-      s = ''
+      s = +''
       s << chars.shift while chars.first.match?(/[0-9.e+\-]/)
       s.match?(/\.|e/) ? s.to_f : s.to_i
     when /[a-zA-Z]/
@@ -216,7 +216,7 @@ class ArSerializer::GraphQL::Parser
   def parse_definition
     type = parse_name
     consume_blank
-    args_text = ''
+    args_text = +''
     if type
       args_text << chars.shift while chars.first && chars.first != '{'
     end

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.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/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.1'
+  VERSION = '1.2.3'
 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.1
+  version: 1.2.3
 platform: ruby
 authors:
 - tompng
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -112,8 +111,8 @@ files:
 - bin/console
 - bin/setup
 - gemfiles/Gemfile-rails-6
-- gemfiles/Gemfile-rails-7-0
-- gemfiles/Gemfile-rails-7-1
+- gemfiles/Gemfile-rails-7
+- gemfiles/Gemfile-rails-8
 - lib/ar_serializer.rb
 - lib/ar_serializer/error.rb
 - lib/ar_serializer/field.rb
@@ -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: []