ar_serializer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7e9144cab6ef520e2c0734bbe98a13a046f3b7b8411310ccc522dc999bae5365
+  data.tar.gz: d938b8684bbb22937c97c2572994b6bd11b38c72011f1b19975d96c7633656c7
+SHA512:
+  metadata.gz: a7ff7ed23abaabef6893c31dc259ce18eeb3111df652c4e4a2d717523853e4a4f27119ddb0d027583ae788b218fdea73abebfc5de99480447e51bbabe04929f9
+  data.tar.gz: 8bceb19d2f319772e575c440870d074431f21efeab16375dced2e87637791e3d94927f0024c01bfd9669f0e0fb9743539f17ac47b12233a056db64e12b952264

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.sqlite3
+.ruby-version

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    ar_serializer (1.0.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)
+      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)
+      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)
+      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)
+      activerecord
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ar_serializer!
+  minitest
+  pry
+  rake
+  simplecov
+  sqlite3
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 tompng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,160 @@
+# ArSerializer
+
+- JSONの形をclientからリクエストできる
+- N+1 SQLを避ける
+
+## Install
+
+```ruby
+gem 'ar_serializer'
+```
+
+## Field定義
+```ruby
+class User < ActiveRecord::Base
+  has_many :posts
+  serializer_field :id, :name, :posts
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments
+  serializer_field :id, :title, :body, :comments
+  serializer_field :comment_count, count_of: :comments
+end
+
+class Comment < ActiveRecord::Base
+  serializer_field :id, :body
+end
+```
+
+## Serialize
+```ruby
+ArSerializer.serialize Post.find(params[:id]), params[:query]
+```
+
+## Query
+```ruby
+ArSerializer.serialize user, :*
+# => {
+#   id: 1,
+#   name: "user1",
+#   posts: [{}, {}]
+# }
+
+ArSerializer.serialize user, [:id, :name, posts: [:id, :title, comments: :id]]
+ArSerializer.serialize user, { id: true, name: true, posts: { id: true, title: true, comments: :id } }
+# => {
+#   id: 1,
+#   name: "user1",
+#   posts: [
+#     { id: 2, title: "title1", comments: [{ id: 5 }, { id: 17 }] },
+#     { id: 3, title: "title2", comments: [] }
+#   ]
+# }
+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 }
+# ]
+```
+
+## その他
+```ruby
+# data block, include
+class Comment < ActiveRecord::Base
+  serializer_field :username, includes: :user do
+    { ja: user.name + '先生', en: 'Dr.' + user.name }
+  end
+end
+
+# preloader
+class Foo < ActiveRecord::Base
+  define_preloader :bar_count_loader do |models|
+    Bar.where(foo_id: models.map(&:id)).group(:foo_id).count
+  end
+  serializer_field :bar_count, preload: preloader_name_or_proc do |preloaded|
+    preloaded[id] || 0
+  end
+  # data_blockが `do |preloaded| preloaded[id] end` の場合は省略可能
+end
+
+# order and limits
+class Post < ActiveRecord::Base
+  has_many :comments
+  serializer_field :comments
+end
+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|
+    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
+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
+end
+
+# namespace
+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], 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
+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
+class User < ActiveRecord::Base
+  serializer_field(:posts, params_type: { title: :string? }) do |title: nil|
+    title ? posts.where(title: title) : posts
+  end
+  serializer_field :foobar, type: ['foo', 'bar', { foobar: [:string, nil] }] do
+    ['foo', 'bar', { foobar: nil }, { foobar: 'foobar' }].sample
+  end
+  serializer_field :published_posts, type: -> { [Post] }
+end
+ArSerializer::TypeScript.generate_type_definition User
+# => export type TypeUser {...}; export type TypePost {...}; ...
+
+# graphql
+class MySchema
+  include ArSerializer::Serializable
+  serializer_field :post, type: Post do |context, id:|
+    Post.find id
+  end
+  serializer_field :user, type: :string, params_type: { name: :string } do |context, params|
+    User.find_by name: params[:name]
+  end
+  serializer_field :__schema do
+    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: {}
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/ar_serializer.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ar_serializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ar_serializer'
+  spec.version       = ArSerializer::VERSION
+  spec.authors       = ['tompng']
+  spec.email         = ['tomoyapenguin@gmail.com']
+
+  spec.summary       = %(ActiveRecord serializer, avoid N+1)
+  spec.description   = %(ActiveRecord serializer, avoid N+1)
+  spec.homepage      = "https://github.com/tompng/#{spec.name}"
+  spec.license       = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord'
+  spec.add_dependency 'top_n_loader'
+  %w[rake pry sqlite3 minitest simplecov].each do |gem_name|
+    spec.add_development_dependency gem_name
+  end
+end

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ar_serializer'
+require 'pry'
+require_relative '../test/db'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ar_serializer.rb

@@ -0,0 +1,77 @@
+require 'ar_serializer/version'
+require 'ar_serializer/serializer'
+require 'ar_serializer/field'
+require 'active_record'
+
+module ArSerializer
+  def self.serialize(*args)
+    Serializer.serialize(*args)
+  end
+end
+
+module ArSerializer::Serializable
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def _serializer_namespace(ns)
+      (@_serializer_field_info ||= {})[ns] ||= {}
+    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
+      end
+    end
+
+    def _serializer_field_keys
+      namespaces = ArSerializer::Serializer.current_namespaces
+      keys = []
+      if namespaces
+        Array(namespaces).each do |ns|
+          keys |= _serializer_namespace(ns).keys
+        end
+      end
+      keys |= _serializer_namespace(nil).keys
+      keys |= superclass._serializer_field_keys if superclass < ArSerializer::Serializable
+      keys
+    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)
+          _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
+    end
+
+    def serializer_defaults(*args, &block)
+      serializer_field :defaults, *args, &block
+    end
+  end
+end
+
+ActiveRecord::Base.include ArSerializer::Serializable
+ActiveRecord::Relation.include ArSerializer::ArrayLikeCompositeValue
+
+require 'ar_serializer/graphql'
+require 'ar_serializer/type_script'

data/lib/ar_serializer/error.rb

@@ -0,0 +1,3 @@
+module ArSerializer
+  class InvalidQuery < ::StandardError; end
+end

data/lib/ar_serializer/field.rb

@@ -0,0 +1,234 @@
+require 'ar_serializer/error'
+
+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
+    @includes = includes
+    @preloaders = preloaders
+    @only = only && [*only].map(&:to_s)
+    @except = except && [*except].map(&:to_s)
+    @data_block = data_block
+    @order_column = order_column
+    @type = type
+    @params_type = params_type
+  end
+
+  def type
+    type = @type.is_a?(Proc) ? @type.call : @type
+    splat = lambda do |t|
+      case t
+      when Array
+        if t.size == 1 || (t.size == 2 && t.compact.size == 1)
+          t.map(&splat)
+        else
+          t.map { |v| v.is_a?(String) ? v : splat.call(v) }
+        end
+      when Hash
+        t.transform_values(&splat)
+      else
+        t
+      end
+    end
+    splat.call type
+  end
+
+  def arguments
+    return @params_type if @params_type
+    @preloaders.size
+    @data_block.parameters
+    parameters_list = [@data_block.parameters.drop(@preloaders.size + 1)]
+    @preloaders.each do |preloader|
+      parameters_list << preloader.parameters.drop(2)
+    end
+    arguments = {}
+    any = false
+    parameters_list.each do |parameters|
+      ftype, fname = parameters.first
+      if %i[opt req rest].include? ftype
+        any = true unless fname.match?(/^_/)
+        next
+      end
+      parameters.each do |type, name|
+        case type
+        when :keyreq
+          arguments[name] ||= true
+        when :key
+          arguments[name] ||= false
+        when :keyrest
+          any = true unless name.match?(/^_/)
+        when :opt, :req
+          break
+        end
+      end
+    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]
+    end.to_h
+  end
+
+  def validate_attributes(attributes)
+    return unless @only || @except
+    keys = attributes.keys.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)
+    preloader = lambda do |models|
+      klass.joins(association_name).where(id: models.map(&:id)).group(:id).count
+    end
+    data_block = lambda do |preloaded, _context, _params|
+      preloaded[id] || 0
+    end
+    new preloaders: [preloader], data_block: data_block, type: :int
+  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?
+    klass.column_for_attribute(name).null ? [*type, nil] : type
+  end
+
+  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 = 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?
+      return values
+    end
+    {
+      boolean: :boolean,
+      integer: :int,
+      float: :float,
+      decimal: :float,
+      string: :string,
+      text: :string,
+      json: :string,
+      binary: :string,
+      time: :string,
+      date: :string,
+      datetime: :string
+    }[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)
+    if count_of
+      if includes || preload || data_block || only || except
+        raise ArgumentError, 'includes, preload block cannot be used with count_of'
+      end
+      return count_field klass, count_of
+    end
+    underscore_name = name.to_s.underscore
+    association = klass.reflect_on_association underscore_name if klass.respond_to? :reflect_on_association
+    if association
+      if association.collection?
+        type ||= -> { [association.klass] }
+      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
+    end
+    type ||= lambda do
+      if klass.respond_to? :column_for_attribute
+        type_from_column_type klass, underscore_name
+      elsif klass.respond_to? :attribute_types
+        type_from_attribute_type(klass, underscore_name) || :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
+  end
+
+  def self.custom_field(klass, name, includes:, preload:, only:, except:, order_column:, type:, params_type:, &data_block)
+    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
+    else
+      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
+    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 }
+    )
+  end
+
+  def self.parse_order(klass, order)
+    key, mode = begin
+      case order
+      when Hash
+        raise ArSerializer::InvalidQuery, 'invalid order' unless order.size == 1
+        order.first
+      when Symbol, 'asc', 'desc'
+        [klass.primary_key, order]
+      when NilClass
+        [klass.primary_key, :asc]
+      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]
+  end
+
+  def self.association_field(klass, name, only:, except:, type:, collection:)
+    if collection
+      preloader = lambda do |models, _context, limit: nil, order: nil, **_option|
+        preload_association klass, models, name, limit: limit, order: order
+      end
+      params_type = { limit?: :int, order?: [{ :* => %w[asc desc] }, 'asc', 'desc'] }
+    else
+      preloader = lambda do |models, _context, _params|
+        preload_association klass, models, 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
+  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 }
+    end
+    ActiveRecord::Associations::Preloader.new.preload models, name
+    return if limit.nil? && 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]
+    end.to_h
+  end
+end