ar_serializer 1.0.0

data/lib/ar_serializer/graphql.rb

@@ -0,0 +1,41 @@
+require_relative 'graphql/types'
+require_relative 'graphql/parser'
+
+module ArSerializer::GraphQL
+  def self.definition(klass, use: nil)
+    ArSerializer::Serializer.with_namespaces(use) { _definition klass }
+  end
+
+  def self._definition(klass)
+    schema = SchemaClass.new(klass)
+    definitions = schema.types.map do |type|
+      next "scalar #{type.name}" if type.is_a? ScalarTypeClass
+      fields = type.fields.map do |field|
+        args = field.args.map { |arg| "#{arg.name}: #{arg.type.gql_type}" }
+        args_exp = "(#{args.join(', ')})" unless args.empty?
+        "  #{field.name}#{args_exp}: #{field.type.gql_type}"
+      end
+      <<~TYPE
+        type #{type.name} {
+        #{fields.join("\n")}
+        }
+      TYPE
+    end
+    <<~SCHEMA
+      schema {
+        query: #{schema.query_type.name}
+      }
+
+      #{definitions.map(&:strip).join("\n\n")}
+    SCHEMA
+  end
+
+  def self.serialize(schema, gql_query, operation_name: nil, variables: {}, **args)
+    query = ArSerializer::GraphQL::Parser.parse(
+      gql_query,
+      operation_name: operation_name,
+      variables: variables
+    )
+    { data: ArSerializer::Serializer.serialize(schema, query, **args) }
+  end
+end

data/lib/ar_serializer/graphql/parser.rb

@@ -0,0 +1,269 @@
+class ArSerializer::GraphQL::Parser
+  class ParseError < StandardError; end
+
+  attr_reader :query, :operation_name, :variables, :chars
+  def initialize(query, operation_name: nil, variables: {})
+    @query = query
+    @operation_name = operation_name
+    @variables = variables
+    @chars = query.chars
+  end
+
+  def self.parse(*args)
+    new(*args).parse
+  end
+
+  def parse
+    definitions = []
+    consume_blank
+    loop do
+      definition = parse_definition
+      consume_blank
+      consume_text ','
+      consume_blank
+      break unless definition
+      definitions << definition
+    end
+    raise_expected_not_found 'definition or EOF' unless chars.empty?
+    query = definitions.find do |definition|
+      next unless definition[:type] == 'query'
+      operation_name.nil? || operation_name == definition[:args].first
+    end
+    raise ParseError, 'empty query' unless query
+    fragments = definitions.select { |definition| definition[:type] == 'fragment' }
+    fragments_by_name = fragments.index_by { |frag| frag[:args].first }
+    embed_fragment query[:fields], fragments_by_name
+  end
+
+  private
+
+  def consume_comment
+    return false if chars.first != '#'
+    until chars.blank?
+      c = chars.first
+      break if c == "\n"
+      chars.shift
+    end
+    true
+  end
+
+  def consume_blank
+    loop do
+      chars.shift while chars.first&.match?(/\s/)
+      return unless consume_comment
+    end
+  end
+
+  def consume_text(s)
+    return false unless chars.take(s.size).join == s
+    chars.shift s.size
+    true
+  end
+
+  def consume_text!(s)
+    return if consume_text s
+    raise_expected_not_found s.inspect
+  end
+
+  def raise_expected_not_found(expected, found = nil)
+    raise(
+      ParseError,
+      "expected #{expected} but found #{found || chars.first.inspect} #{current_position_message}"
+    )
+  end
+
+  def parse_name
+    name = ''
+    name << chars.shift while chars.first && chars.first =~ /[a-zA-Z0-9_]/
+    name unless name.empty?
+  end
+
+  def parse_name_alias
+    name = parse_name
+    return unless name
+    consume_blank
+    if consume_text ':'
+      consume_blank
+      [parse_name, name]
+    else
+      name
+    end
+  end
+
+  def parse_arg_value
+    case chars.first
+    when '"'
+      chars.shift
+      s = ''
+      loop do
+        if chars.first == '\\'
+          s << chars.shift
+          s << chars.shift
+        elsif chars.first == '"'
+          break
+        else
+          s << chars.shift
+        end
+      end
+      chars.shift
+      unescape_string s
+    when '['
+      chars.shift
+      result = []
+      loop do
+        consume_blank
+        value = parse_arg_value
+        consume_blank
+        consume_text ','
+        break if value == :none
+        result << value
+      end
+      consume_text! ']'
+      result
+    when '{'
+      chars.shift
+      consume_blank
+      result = parse_arg_fields
+      consume_blank
+      consume_text! '}'
+      result
+    when '$'
+      chars.shift
+      name = parse_name
+      variables[name]
+    when /[0-9+\-]/
+      s = ''
+      s << chars.shift while chars.first.match?(/[0-9.e+\-]/)
+      s.match?(/\.|e/) ? s.to_f : s.to_i
+    when /[a-zA-Z]/
+      s = parse_name
+      converts = { 'true' => true, 'false' => false, 'null' => nil }
+      converts.key?(s) ? converts[s] : s
+    else
+      :none
+    end
+  end
+
+  def unescape_string(s)
+    JSON.parse %("#{s}")
+  rescue JSON::ParserError # for old json gem
+    JSON.parse(%(["#{s}"])).first
+  end
+
+  def parse_arg_fields
+    result = {}
+    loop do
+      name = parse_name
+      break unless name
+      consume_blank
+      consume_text! ':'
+      consume_blank
+      value = parse_arg_value
+      if value == :none
+        raise(
+          ParseError,
+          "expected hash value but nothing found #{current_position_message}"
+        )
+      end
+      result[name] = value
+      consume_blank
+      consume_text ','
+      consume_blank
+    end
+    result
+  end
+
+  def parse_args
+    return unless consume_text '('
+    consume_blank
+    args = parse_arg_fields
+    consume_blank
+    consume_text! ')'
+    args
+  end
+
+  def parse_field
+    if chars[0, 3].join == '...'
+      3.times { chars.shift }
+      name = parse_name
+      return ['...' + name, { fragment: name }]
+    end
+    name, alias_name = parse_name_alias
+    return unless name
+    consume_blank
+    args = parse_args
+    consume_blank
+    fields = parse_fields
+    [name, { as: alias_name, params: args, attributes: fields }.compact]
+  end
+
+  def parse_fields
+    return unless consume_text '{'
+    consume_blank
+    fields = {}
+    loop do
+      name, field = parse_field
+      consume_blank
+      consume_text ','
+      consume_blank
+      break unless name
+      fields[name] = field
+    end
+    consume_text! '}'
+    fields
+  end
+
+  def parse_definition
+    type = parse_name
+    consume_blank
+    args_text = ''
+    if type
+      args_text << chars.shift while chars.first && chars.first != '{'
+    end
+    args = args_text.split(/[\s()]+/)
+    fields = parse_fields
+    return if type.nil? && fields.nil?
+    type ||= 'query'
+    raise_expected_not_found '{'.inspect if fields.nil?
+    { type: type, args: args, fields: fields }
+  end
+
+  def current_position_message
+    pos = query.size - chars.size
+    code = query[[pos - 10, 0].max..pos + 10]
+    line_num = 0
+    query.each_line.with_index 1 do |l, i|
+      line_num = i
+      break if pos < l.size
+      pos -= l.size
+    end
+    "at #{line_num}:#{pos} near #{code.inspect}"
+  end
+
+  def embed_fragment(fields, fragments)
+    output = {}
+    fields.each do |key, value|
+      if value.is_a?(Hash) && (fragment_name = value[:fragment])
+        fragment = fragments[fragment_name]
+        extract_fragment fragment_name, fragments
+        output.update fragment[:fields]
+      else
+        output[key] = value
+        if (attrs = value[:attributes])
+          value[:attributes] = embed_fragment attrs, fragments
+        end
+      end
+    end
+    output
+  end
+
+  def extract_fragment(fragment_name, fragments)
+    fragment = fragments[fragment_name]
+    raise ParseError, "fragment named #{fragment_name.inspect} was not found" if fragment.nil?
+    raise ParseError, "fragment circular definition detected in #{fragment_name.inspect}" if fragment[:state] == :start
+    return if fragment[:state] == :done
+    fragment[:state] = :start
+    fragment[:fields] = embed_fragment fragment[:fields], fragments
+    fragment[:state] = :done
+  end
+end

data/lib/ar_serializer/graphql/types.rb

@@ -0,0 +1,442 @@
+module ArSerializer::GraphQL
+  class ArgClass
+    include ::ArSerializer::Serializable
+    attr_reader :name, :type
+    def initialize(name, type)
+      @optional = name.to_s.end_with? '?' # TODO: refactor
+      @name = name.to_s.delete '?'
+      @type = TypeClass.from type
+    end
+    serializer_field :name
+    serializer_field :type, except: :fields
+    serializer_field(:defaultValue) { nil }
+    serializer_field(:description) { "#{'Optional: ' if @optional}#{type.description}" }
+  end
+
+  class FieldClass
+    include ::ArSerializer::Serializable
+    attr_reader :name, :field
+    def initialize(name, field)
+      @name = name
+      @field = field
+    end
+
+    def args
+      return [] if field.arguments == :any
+      field.arguments.map do |key, type|
+        ArgClass.new key, type
+      end
+    end
+
+    def type
+      TypeClass.from field.type, field.only, field.except
+    end
+
+    def collect_types(types)
+      types[:any] = true if field.arguments == :any
+      args.each { |arg| arg.type.collect_types types }
+      type.collect_types types
+    end
+
+    def args_ts_type
+      arg_types = field.arguments.map do |key, type|
+        "#{key}: #{TypeClass.from(type).ts_type}"
+      end
+      "{ #{arg_types.join '; '} }"
+    end
+
+    serializer_field :name, :args
+    serializer_field :type, except: :fields
+    serializer_field(:isDeprecated) { false }
+    serializer_field(:description) { type.description }
+    serializer_field(:deprecationReason) { nil }
+  end
+
+  class SchemaClass
+    include ::ArSerializer::Serializable
+    attr_reader :klass, :query_type
+    def initialize(klass)
+      @klass = klass
+      @query_type = SerializableTypeClass.new klass
+    end
+
+    def collect_types
+      types = {}
+      klass._serializer_field_keys.each do |name|
+        fc = FieldClass.new name, klass._serializer_field_info(name)
+        fc.collect_types types
+      end
+      type_symbols, type_classes = types.keys.partition { |t| t.is_a? Symbol }
+      type_classes << TypeClass.from(klass)
+      [type_symbols.sort, type_classes.sort_by(&:name)]
+    end
+
+    def types
+      types_symbols, klass_types = collect_types
+      types_symbols.map { |t| ScalarTypeClass.new t } + klass_types
+    end
+
+    serializer_field(:mutationType) { nil }
+    serializer_field(:subscriptionType) { nil }
+    serializer_field(:directives) { [] }
+    serializer_field :types, :queryType
+  end
+
+  class TypeClass
+    include ::ArSerializer::Serializable
+    attr_reader :type, :only, :except
+    def initialize(type, only = nil, except = nil)
+      @type = type
+      @only = only
+      @except = except
+      validate!
+    end
+
+    class InvalidType < StandardError; end
+
+    def validate!
+      valid_symbols = %i[number int float string boolean any]
+      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 name; end
+
+    def of_type; end
+
+    def fields; end
+
+    def sample; end
+
+    def ts_type; end
+
+    def association_type; end
+
+    serializer_field :kind, :name, :description, :fields
+    serializer_field :ofType, except: :fields
+    serializer_field(:interfaces) { [] }
+    %i[inputFields enumValues possibleTypes].each do |name|
+      serializer_field(name) { nil }
+    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?('?')
+      case type
+      when Class
+        SerializableTypeClass.new type, only, except
+      when Symbol, String, Numeric, true, false, nil
+        ScalarTypeClass.new type
+      when Array
+        if type.size == 1
+          ListTypeClass.new type.first, only, except
+        elsif type.size == 2 && type.last.nil?
+          OptionalTypeClass.new type
+        else
+          OrTypeClass.new type, only, except
+        end
+      when Hash
+        HashTypeClass.new type, only, except
+      end
+    end
+  end
+
+  class ScalarTypeClass < TypeClass
+    def initialize(type)
+      @type = type
+    end
+
+    def kind
+      'SCALAR'
+    end
+
+    def name
+      case type
+      when String, :string
+        :string
+      when Integer, :int
+        :int
+      when Float, :float
+        :float
+      when true, false, :boolean
+        :boolean
+      when :other
+        :other
+      else
+        :any
+      end
+    end
+
+    def collect_types(types)
+      types[name] = true
+    end
+
+    def gql_type
+      type
+    end
+
+    def sample
+      case ts_type
+      when 'number'
+        0
+      when 'string'
+        ''
+      when 'boolean'
+        true
+      when 'any'
+        nil
+      else
+        type
+      end
+    end
+
+    def ts_type
+      case type
+      when :int, :float
+        'number'
+      when :string, :number, :boolean
+        type.to_s
+      when Symbol
+        'any'
+      else
+        type.to_json
+      end
+    end
+  end
+
+  class HashTypeClass < TypeClass
+    def kind
+      'SCALAR'
+    end
+
+    def name
+      :other
+    end
+
+    def collect_types(types)
+      types[:other] = true
+      type.values.map do |v|
+        TypeClass.from(v, only, except).collect_types(types)
+      end
+    end
+
+    def association_type
+      type.values.each do |v|
+        t = TypeClass.from(v, only, except).association_type
+        return t if t
+      end
+      nil
+    end
+
+    def gql_type
+      'OBJECT'
+    end
+
+    def sample
+      type.reject { |k| k.to_s.ends_with? '?' }.transform_values do |v|
+        TypeClass.from(v).sample
+      end
+    end
+
+    def ts_type
+      fields = type.map do |key, value|
+        k = key.to_s == '*' ? '[key: string]' : key
+        "#{k}: #{TypeClass.from(value, only, except).ts_type}"
+      end
+      "{ #{fields.join('; ')} }"
+    end
+  end
+
+  class SerializableTypeClass < TypeClass
+    def field_only
+      [*only].map(&:to_s)
+    end
+
+    def field_except
+      [*except].map(&:to_s)
+    end
+
+    def kind
+      'OBJECT'
+    end
+
+    def name
+      name_segments = [type.name.delete(':')]
+      unless field_only.empty?
+        name_segments << 'Only'
+        name_segments << field_only.map(&:camelize)
+      end
+      unless field_except.empty?
+        name_segments << 'Except'
+        name_segments << field_except.map(&:camelize)
+      end
+      name_segments.join
+    end
+
+    def fields
+      keys = type._serializer_field_keys - ['__schema'] - field_except
+      keys = field_only & keys unless field_only.empty?
+      keys.map do |name|
+        FieldClass.new name, type._serializer_field_info(name)
+      end
+    end
+
+    def collect_types(types)
+      return if types[self]
+      types[self] = true
+      fields.each { |field| field.collect_types types }
+    end
+
+    def association_type
+      self
+    end
+
+    def gql_type
+      name
+    end
+
+    def ts_type
+      "Type#{name}"
+    end
+
+    def eql?(t)
+      self.class == t.class && self.compare_elements == t.compare_elements
+    end
+
+    def == t
+      eql? t
+    end
+
+    def compare_elements
+      [type, field_only, field_except]
+    end
+
+    def hash
+      compare_elements.hash
+    end
+  end
+
+  class OptionalTypeClass < TypeClass
+    def kind
+      of_type.kind
+    end
+
+    def name
+      of_type.name
+    end
+
+    def of_type
+      TypeClass.from type.first, only, except
+    end
+
+    def association_type
+      of_type.association_type
+    end
+
+    def collect_types(types)
+      of_type.collect_types types
+    end
+
+    def gql_type
+      of_type.gql_type
+    end
+
+    def sample
+      nil
+    end
+
+    def ts_type
+      "(#{of_type.ts_type} | null)"
+    end
+  end
+
+  class OrTypeClass < TypeClass
+    def kind
+      'OBJECT'
+    end
+
+    def name
+      :other
+    end
+
+    def of_types
+      type.map { |t| TypeClass.from t, only, except }
+    end
+
+    def collect_types(types)
+      types[:other] = true
+      of_types.map { |t| t.collect_types types }
+    end
+
+    def gql_type
+      kind
+    end
+
+    def sample
+      of_types.first.sample
+    end
+
+    def ts_type
+      '(' + of_types.map(&:ts_type).join(' | ') + ')'
+    end
+  end
+
+  class ListTypeClass < TypeClass
+    def kind
+      'LIST'
+    end
+
+    def name
+      'LIST'
+    end
+
+    def of_type
+      TypeClass.from type, only, except
+    end
+
+    def collect_types(types)
+      of_type.collect_types types
+    end
+
+    def association_type
+      of_type.association_type
+    end
+
+    def gql_type
+      "[#{of_type.gql_type}]"
+    end
+
+    def sample
+      []
+    end
+
+    def ts_type
+      "(#{of_type.ts_type} [])"
+    end
+  end
+end