graphql_swift_gen 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d1bd610a6536380a8b7d44d7dd68f218977b122f
+  data.tar.gz: 4ef1d09670a2998b0003cebf2a7c42cf481b4936
+SHA512:
+  metadata.gz: 489e21ce87384e75d5e795ebd37d5d2dc25556ecbd7791c8e6c9613c942154ebb3c67701eced6de4a0cbbcce5ca8edd9c2990beb1811baa9181176a10ae7849e
+  data.tar.gz: d89e560d4a5d20f27140db68b41a3beb182f3e176a9bb486bfa186e2a95ee1ec81bd101e857d9b972117a421d23eb10ddb6d3c14a0f754b874705261138326b9

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Shopify
+
+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,108 @@
+# GraphQLSwiftGen
+[![Build Status](https://travis-ci.org/Shopify/graphql_swift_gen.svg?branch=master)](https://travis-ci.org/Shopify/graphql_swift_gen)
+
+Generate swift code for any specific GraphQL schema that provides
+query builders and response classes.
+
+## Installation
+
+The code generator requires ruby version 2.1 or later.
+
+Until this project is released, it is recommended to include it into
+a project as a git submodule.
+
+    $ git submodule https://github.com/Shopify/graphql_swift_gen.git
+
+It is recommended to use [bundler](http://bundler.io/) to install
+the code generators ruby package.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphql_swift_gen', path: 'graphql_swift_gen'
+```
+
+And then execute:
+
+    $ bundle
+
+The generated code depends on support/Sources/GraphQL.swift from
+this repo which should be added to the project along with the
+generated code.
+
+## Usage
+
+Create a script that generates the code for a GraphQL API
+
+```ruby
+require 'graphql_swift_gen'
+require 'graphql_schema'
+require 'json'
+
+introspection_result = File.read("graphql_schema.json")
+schema = GraphQLSchema.new(JSON.parse(introspection_result))
+
+GraphQLSwiftGen.new(schema,
+  nest_under: 'ExampleSchema',
+  custom_scalars: [
+    GraphQLSwiftGen::Scalar.new(
+      type_name: 'Money',
+      swift_type: 'NSDecimalNumber',
+      deserialize_expr: ->(expr) { "NSDecimalNumber(string: #{expr}, locale: GraphQL.posixLocale)" },
+      serialize_expr: ->(expr) { "#{expr}.description(withLocale: GraphQL.posixLocale)" },
+    ),
+  ]
+).save("#{Dir.pwd}/../MyApp/Source")
+```
+
+That generated code depends on the GraphQLSupport package.
+
+The generated code includes a query builder that can be used to
+create a GraphQL query in a type-safe mannar.
+
+```swift
+let queryString = ExampleSchema.buildQuerya { $0
+    .user { $0
+        .firstName()
+        .lastName()
+    }
+}
+```
+
+The generated code also includes response classes that will deserialize the response
+and provide methods for accessing the field data with it already coerced to the
+correct type.
+
+```swift
+guard let response = try? GraphQLResponse<ExampleSchema.QueryRoot>(jsonData: response) else {
+    print("Invalid GraphQL response")
+    return
+}
+if let errors = response.errors {
+    for error in errors {
+        print("GraphQL error: \(error.message)")
+    }
+}
+if let data = response.data {
+    let user = data.user
+    print("\(user.firstName) \(user.lastName)")
+}
+```
+
+## Development
+
+After checking out the repo, run `bundle` to install ruby dependencies.
+Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake
+install` or reference it from a Gemfile using the path option
+(e.g. `gem 'graphql_swift_gen', path: '~/src/graphql_swift_gen'`).
+
+## Contributing
+
+See our [contributing guidelines](CONTRIBUTING.md) for more information.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).

data/codegen/lib/graphql_swift_gen.rb

@@ -0,0 +1,257 @@
+require 'graphql_swift_gen/reformatter'
+require 'graphql_swift_gen/scalar'
+
+require 'erb'
+
+class GraphQLSwiftGen
+  attr_reader :schema, :scalars, :script_name, :schema_name, :import_graphql_support
+
+  def initialize(schema, custom_scalars: [], nest_under:, script_name: 'graphql_swift_gen gem', import_graphql_support: false)
+    @schema = schema
+    @schema_name = nest_under
+    @script_name = script_name
+    @scalars = (BUILTIN_SCALARS + custom_scalars).reduce({}) { |hash, scalar| hash[scalar.type_name] = scalar; hash }
+    @scalars.default_proc = ->(hash, key) { DEFAULT_SCALAR }
+    @import_graphql_support = import_graphql_support
+  end
+
+  def save(path)
+    output = generate
+    begin
+      Dir.mkdir("#{path}/#{schema_name}")
+    rescue Errno::EEXIST
+    end
+    output.each do |relative_path, file_contents|
+      File.write("#{path}/#{relative_path}", file_contents)
+    end
+  end
+
+  def generate
+    output = {}
+    output["#{schema_name}.swift"] = generate_schema_file
+    schema.types.reject{ |type| type.name.start_with?('__') || type.scalar? }.each do |type|
+      output["#{schema_name}/#{type.name}.swift"] = generate_type(type)
+    end
+    output
+  end
+
+  private
+
+  class << self
+    private
+
+    def erb_for(template_filename)
+      path = File.expand_path("../graphql_swift_gen/templates/#{template_filename}", __FILE__)
+      erb = ERB.new(File.read(path))
+      erb.filename = path
+      erb
+    end
+  end
+
+  SCHEMA_ERB = erb_for("ApiSchema.swift.erb")
+  TYPE_ERB = erb_for("type.swift.erb")
+  private_constant :SCHEMA_ERB, :TYPE_ERB
+
+  DEFAULT_SCALAR = Scalar.new(type_name: nil, swift_type: 'String', json_type: 'String')
+  private_constant :DEFAULT_SCALAR
+
+  BUILTIN_SCALARS = [
+    Scalar.new(
+      type_name: 'Int',
+      swift_type: 'Int32',
+      json_type: 'Int',
+      deserialize_expr: ->(expr) { "Int32(#{expr})" },
+    ),
+    Scalar.new(
+      type_name: 'Float',
+      swift_type: 'Double',
+      json_type: 'Double',
+    ),
+    Scalar.new(
+      type_name: 'String',
+      swift_type: 'String',
+      json_type: 'String',
+    ),
+    Scalar.new(
+      type_name: 'Boolean',
+      swift_type: 'Bool',
+      json_type: 'Bool',
+    ),
+    Scalar.new(
+      type_name: 'ID',
+      swift_type: 'GraphQL.ID',
+      json_type: 'String',
+      serialize_expr: ->(expr) { "#{expr}.rawValue" },
+      deserialize_expr: ->(expr) { "GraphQL.ID(rawValue: #{expr})" },
+    ),
+  ]
+  private_constant :BUILTIN_SCALARS
+
+  # From: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html
+  RESERVED_WORDS = [
+    "associatedtype", "class", "deinit", "enum", "extension", "fileprivate", "func", "import", "init", "inout", "internal", "let", "open", "operator", "private", "protocol", "public", "static", "struct", "subscript", "typealias", "var",
+    "break", "case", "continue", "default", "defer", "do", "else", "fallthrough", "for", "guard", "if", "in", "repeat", "return", "switch", "where", "while",
+    "as", "Any", "catch", "false", "is", "nil", "rethrows", "super", "self", "Self", "throw", "throws", "true", "try",
+    "associativity", "convenience", "dynamic", "didSet", "final", "get", "infix", "indirect", "lazy", "left", "mutating", "none", "nonmutating", "optional", "override", "postfix", "precedence", "prefix", "Protocol", "required", "right", "set", "Type", "unowned", "weak", "willSet"
+  ]
+  private_constant :RESERVED_WORDS
+
+  def escape_reserved_word(word)
+    return word unless RESERVED_WORDS.include?(word)
+    return "`#{word}`"
+  end
+
+  def generate_schema_file
+    reformat(SCHEMA_ERB.result(binding))
+  end
+
+  def generate_type(type)
+    reformat(TYPE_ERB.result(binding))
+  end
+
+  def reformat(code)
+    Reformatter.new(indent: "\t").reformat(code)
+  end
+
+  def swift_input_type(type, non_null: false)
+    code = case type.kind
+    when 'NON_NULL'
+      return swift_input_type(type.of_type, non_null: true)
+    when 'SCALAR'
+      scalars[type.name].swift_type
+    when 'LIST'
+      "[#{swift_input_type(type.of_type, non_null: true)}]"
+    when 'INPUT_OBJECT', 'ENUM'
+      type.name
+    else
+      raise NotImplementedError, "Unhandled #{type.kind} input type"
+    end
+    code += "?" unless non_null
+    code
+  end
+
+  def swift_json_type(type, non_null: false)
+    if !non_null && !type.non_null?
+      return 'Any'
+    end
+    case type.kind
+    when "NON_NULL"
+      swift_json_type(type.of_type, non_null: true)
+    when 'SCALAR'
+      scalars[type.name].json_type
+    when 'OBJECT', 'INTERFACE', 'UNION'
+      "[String: Any]"
+    when 'LIST'
+      "[#{swift_json_type(type.of_type)}]"
+    when 'ENUM'
+      'String'
+    else
+      raise NotImplementedError, "Unexpected #{type.kind} response type"
+    end
+  end
+
+  def swift_output_type(type, non_null: false)
+    code = case type.kind
+    when 'NON_NULL'
+      return swift_output_type(type.of_type, non_null: true)
+    when 'SCALAR'
+      scalars[type.name].swift_type
+    when 'LIST'
+      "[#{swift_output_type(type.of_type)}]"
+    when 'OBJECT', 'ENUM'
+      "#{schema_name}.#{type.name}"
+    when 'INTERFACE', 'UNION'
+      type.name
+    else
+      raise NotImplementedError, "Unhandled #{type.kind} response type"
+    end
+    code += "?" unless non_null
+    code
+  end
+
+  def generate_build_input_code(expr, type, wrap: true)
+    case type.kind
+    when 'SCALAR'
+      scalars[type.name].serialize_expr(expr)
+    when 'ENUM'
+      "\\(#{expr}.rawValue)"
+    when 'LIST'
+      map_block = generate_build_input_code('$0', type.of_type.unwrap_non_null)
+      map_code = map_block == '$0' ? expr : "#{expr}.map{ \"#{map_block}\" }"
+      elements = "#{map_code}.joined(separator: \",\")"
+      "[\\(#{elements})]"
+    when 'INPUT_OBJECT'
+      "\\(#{expr}.serialize())"
+    else
+      raise NotImplementedError, "Unexpected #{type.kind} argument type"
+    end
+  end
+
+  def deserialize_value_code(field_name, expr, type, untyped: true)
+    statements = ""
+
+    if untyped
+      json_type = swift_json_type(type.unwrap_non_null, non_null: true)
+      statements << "if #{expr} is NSNull { return nil }\n" unless type.non_null?
+      statements << <<-SWIFT
+        guard let value = #{expr} as? #{json_type} else {
+          throw SchemaViolationError(type: type(of: self), field: fieldName, value: fieldValue)
+        }
+      SWIFT
+      expr = 'value'
+    end
+    type = type.unwrap_non_null
+
+    statements << "return " + case type.kind
+    when 'SCALAR'
+      scalars[type.name].deserialize_expr(expr)
+    when 'LIST'
+      rethrow = "try " if %w(OBJECT INTERFACE UNION).include?(type.unwrap.kind)
+      "#{rethrow}#{expr}.map { #{deserialize_value_code(field_name, '$0', type.of_type, untyped: !type.of_type.non_null?)} }"
+    when 'OBJECT'
+      "try #{type.name}(fields: #{expr})"
+    when 'INTERFACE', 'UNION'
+      "try Unknown#{type.name}.create(fields: #{expr})"
+    when 'ENUM'
+      "#{escape_reserved_word(type.name)}(rawValue: #{expr}) ?? .unknownValue"
+    else
+      raise NotImplementedError, "Unexpected #{type.kind} argument type"
+    end
+  end
+
+  def swift_arg_defs(field)
+    defs = ["aliasSuffix: String? = nil"]
+    field.args.each do |arg|
+      arg_def = "#{escape_reserved_word(arg.name)}: #{swift_input_type(arg.type)}"
+      arg_def << " = nil" unless arg.type.non_null?
+      defs << arg_def
+    end
+    if field.subfields?
+      defs << "_ subfields: (#{field.type.unwrap.name}Query) -> Void"
+    end
+    defs.join(', ')
+  end
+
+  def generate_append_objects_code(expr, type, non_null: false)
+    if type.non_null?
+      non_null = true
+      type = type.of_type
+    end
+    unless non_null
+      return "if let value = #{expr} {\n#{generate_append_objects_code('value', type, non_null: true)}\n}"
+    end
+    return "#{expr}.forEach {\n#{generate_append_objects_code('$0', type.of_type)}\n}" if type.list?
+
+    abstract_response = type.object? ? expr : "#{expr} as! GraphQL.AbstractResponse"
+    "response.append(#{abstract_response})\n" \
+      "response.append(contentsOf: #{expr}.childResponseObjectMap())"
+  end
+
+  def swift_attributes(deprecatable)
+    return unless deprecatable.deprecated?
+    if deprecatable.deprecation_reason
+      message_argument = ", message:#{deprecatable.deprecation_reason.inspect}"
+    end
+    "@available(*, deprecated#{message_argument})"
+  end
+end

data/codegen/lib/graphql_swift_gen/reformatter.rb

@@ -0,0 +1,43 @@
+class GraphQLSwiftGen
+  # Reformat code that uses curly brace blocks
+  class Reformatter
+    INDENT_START_CHARS = ["{", "("]
+    INDENT_END_CHARS = ["}", ")"]
+
+    def initialize(indent: "\t")
+      @indent = indent
+    end
+
+    def reformat(code)
+      output = ""
+      indent_level = 0
+      squeeze_newlines = true
+
+      code.lines.each do |line|
+        stripped_line = line.strip
+
+        if INDENT_END_CHARS.include?(stripped_line[0])
+          indent_level -= 1
+          # no blank lines immediately preceding end of block
+          output.rstrip!
+          output << "\n"
+        end
+
+        if stripped_line.empty?
+          output << "\n" unless squeeze_newlines
+          squeeze_newlines = true
+        else
+          output << @indent * indent_level << line.lstrip
+          squeeze_newlines = false
+        end
+
+        if INDENT_START_CHARS.include?(stripped_line[-1])
+          indent_level += 1
+          # no blank lines following start of block
+          squeeze_newlines = true
+        end
+      end
+      output
+    end
+  end
+end

data/codegen/lib/graphql_swift_gen/scalar.rb

@@ -0,0 +1,26 @@
+class GraphQLSwiftGen
+  class Scalar
+    attr_reader :type_name, :swift_type, :json_type
+
+    def initialize(type_name:, swift_type:, json_type: 'String', serialize_expr: nil, deserialize_expr: nil)
+      @type_name = type_name
+      @swift_type = swift_type
+      @json_type = json_type
+      @serialize_expr = serialize_expr || ->(expr) { expr }
+      @deserialize_expr = deserialize_expr || ->(expr) { expr }
+    end
+
+    def serialize_expr(expr)
+      expr = @serialize_expr.call(expr)
+      if json_type == 'String'
+        expr = "\"\\(#{expr})\"" unless swift_type == 'String'
+        expr = "GraphQL.quoteString(input: #{expr})"
+      end
+      "\\(#{expr})"
+    end
+
+    def deserialize_expr(expr)
+      @deserialize_expr.call(expr)
+    end
+  end
+end

data/codegen/lib/graphql_swift_gen/templates/ApiSchema.swift.erb

@@ -0,0 +1,11 @@
+// Generated from <%= script_name %>
+
+open class <%= schema_name %> {
+  <% [['Query', schema.query_root_name], ['Mutation', schema.mutation_root_name]].each do |operation_type, root_name| %>
+   open static func build<%= operation_type %>(_ subfields: (<%= root_name %>Query) -> Void) -> <%= root_name %>Query {
+      let root = <%= root_name %>Query()
+      subfields(root)
+      return root
+    }
+  <% end %>
+}

data/codegen/lib/graphql_swift_gen/templates/type.swift.erb

@@ -0,0 +1,248 @@
+// Generated from <%= script_name %>
+import Foundation
+<% if import_graphql_support %>
+  import GraphQLSupport
+<% end %>
+
+<% if type.interface? || type.union? %>
+  public protocol <%= type.name %> {
+    var typeName: String { get }
+    <% type.fields(include_deprecated: true).each do |field| %>
+      <%= swift_attributes(field) %>
+      var <%= escape_reserved_word(field.camelize_name) %>: <%= swift_output_type(field.type) %> { get }
+    <% end %>
+    func childResponseObjectMap() -> [GraphQL.AbstractResponse]
+
+    func responseObject() -> GraphQL.AbstractResponse
+  }
+<% end %>
+
+extension <%= schema_name %> {
+  <% case type.kind; when 'OBJECT', 'INTERFACE', 'UNION' %>
+    open class <%= type.name %>Query: GraphQL.AbstractQuery {
+      <% if type.name == schema.mutation_root_name %>
+        open override var description: String {
+          return "mutation" + super.description
+        }
+      <% end %>
+      <% type.fields(include_deprecated: true).each do |field| %>
+        <%= swift_attributes(field) %>
+        @discardableResult
+        open func <%= escape_reserved_word(field.camelize_name) %>(<%= swift_arg_defs(field) %>) -> <%= type.name %>Query {
+          <% unless field.args.empty? %>
+            var args: [String] = []
+            <% field.required_args.each do |arg| %>
+              args.append("<%= arg.name %>:<%= generate_build_input_code(arg.name, arg.type.unwrap_non_null) %>")
+            <% end %>
+            <% field.optional_args.each do |arg| %>
+              if let <%= escape_reserved_word(arg.name) %> = <%= escape_reserved_word(arg.name) %> {
+                args.append("<%= arg.name %>:<%= generate_build_input_code(arg.name, arg.type) %>")
+              }
+            <% end %>
+            <% if field.optional_args.empty? %>
+              let argsString = "(\(args.joined(separator: ",")))"
+            <% else %>
+              let argsString: String? = args.isEmpty ? nil : "(\(args.joined(separator: ",")))"
+            <% end %>
+          <% end %>
+
+          <% if field.subfields? %>
+            let subquery = <%= field.type.unwrap.name %>Query()
+            subfields(subquery)
+          <% end %>
+
+          addField(field: "<%= field.name %>", aliasSuffix: aliasSuffix<% unless field.args.empty? %>, args: argsString<% end %><% if field.subfields? %>, subfields: subquery<% end %>)
+          return self
+        }
+      <% end %>
+      <% unless type.object? %>
+        override init() {
+          super.init()
+          addField(field: "__typename")
+        }
+        <% type.possible_types.each do |possible_type| %>
+          @discardableResult
+          open func on<%= possible_type.name %>(subfields: (<%= possible_type.name %>Query) -> Void) -> <%= type.name %>Query {
+            let subquery = <%= possible_type.name %>Query()
+            subfields(subquery)
+            addInlineFragment(on: "<%= possible_type.name %>", subfields: subquery)
+            return self
+          }
+        <% end %>
+      <% end %>
+    }
+
+    <% class_name = type.object? ? type.name : "Unknown#{type.name}" %>
+    <% protocols = type.object? ? type.interfaces.map { |iface| ", #{iface.name}" }.join : ", #{type.name}" %>
+    open class <%= class_name %>: GraphQL.AbstractResponse<%= protocols %>
+    {
+      open override func deserializeValue(fieldName: String, value: Any) throws -> Any? {
+        let fieldValue = value
+        switch fieldName {
+          <% type.fields(include_deprecated: true).each do |field| %>
+            case "<%= field.name %>":
+              <%= deserialize_value_code(field.name, 'value', field.type) %>
+          <% end %>
+          default:
+            throw SchemaViolationError(type: type(of: self), field: fieldName, value: fieldValue)
+        }
+      }
+
+      <% if type.object? %>
+        open var typeName: String { return "<%= type.name %>" }
+      <% else %>
+        open var typeName: String { return field(field: "__typename") as! String }
+
+        open static func create(fields: [String: Any]) throws -> <%= type.name %> {
+          guard let typeName = fields["__typename"] as? String else {
+            throw SchemaViolationError(type: <%= class_name %>.self, field: "__typename", value: fields["__typename"] ?? NSNull())
+          }
+          switch typeName {
+            <% type.possible_types.each do |possible_type| %>
+              case "<%= possible_type.name %>":
+                return try <%= possible_type.name %>.init(fields: fields)
+            <% end %>
+            default:
+              return try <%= class_name %>.init(fields: fields)
+          }
+        }
+      <% end %>
+
+      <% type.fields(include_deprecated: true).each do |field| %>
+        <%= swift_attributes(field) %>
+        open var <%= escape_reserved_word(field.camelize_name) %>: <%= swift_output_type(field.type) %> {
+          return internalGet<%= field.classify_name %>()
+        }
+
+        <% unless field.args.empty? %>
+          <%= swift_attributes(field) %>
+          open func aliased<%= field.classify_name %>(aliasSuffix: String) -> <%= swift_output_type(field.type) %> {
+            return internalGet<%= field.classify_name %>(aliasSuffix: aliasSuffix)
+          }
+        <% end %>
+
+        func internalGet<%= field.classify_name %>(aliasSuffix: String? = nil) -> <%= swift_output_type(field.type) %> {
+          return field(field: "<%= field.name %>", aliasSuffix: aliasSuffix) as! <%= swift_output_type(field.type) %>
+        }
+      <% end %>
+
+      override open func childObjectType(key: String) -> GraphQL.ChildObjectType {
+        switch(key) {
+          <% type.fields(include_deprecated: true).each do |field| %>
+          case "<%= field.name %>":
+          <% if ['OBJECT', 'INTERFACE'].include?(field.type.unwrap_non_null.kind) %>
+              return .Object
+            <% elsif field.type.unwrap_non_null.kind == 'LIST' && ['OBJECT', 'INTERFACE'].include?(field.type.unwrap.kind) %>
+              return .ObjectList
+            <% elsif field.type.unwrap_non_null.kind == 'LIST' && field.type.unwrap.kind != 'OBJECT' %>
+              return .ScalarList
+            <% else %>
+              return .Scalar
+            <% end %>
+          <% end %>
+          default:
+            return .Scalar
+        }
+      }
+
+      override open func fetchChildObject(key: String) -> GraphQL.AbstractResponse? {
+        switch(key) {
+          <% type.fields(include_deprecated: true).each do |field| %>
+            <% if field.type.unwrap_non_null.kind == 'OBJECT' %>
+                case "<%= field.name %>":
+                  return internalGet<%= field.classify_name %>()
+              <% elsif field.type.unwrap_non_null.kind == 'INTERFACE' %>
+                case "<%= field.name %>":
+                  return internalGet<%= field.classify_name %>()<%= field.type.non_null? ? '' : '?' %>.responseObject()
+              <% end %>
+            <% end %>
+            default:
+              break
+            }
+        return nil
+      }
+
+      override open func fetchChildObjectList(key: String) -> [GraphQL.AbstractResponse] {
+        switch(key) {
+          <% type.fields(include_deprecated: true).each do |field| %>
+            <% if field.type.unwrap_non_null.kind == 'LIST' && field.type.unwrap.kind == 'OBJECT' %>
+              case "<%= field.name %>":
+                return internalGet<%= field.classify_name %>()<% if !field.type.non_null? %> ?? []<% end %>
+              <% end %>
+          <% end %>
+              default:
+                return []
+        }
+      }
+
+      open func childResponseObjectMap() -> [GraphQL.AbstractResponse]  {
+        <% if type.fields(include_deprecated: true).any? { |field| ['OBJECT', 'INTERFACE'].include?(field.type.unwrap_non_null.kind) } %>
+          var response: [GraphQL.AbstractResponse] = []
+          objectMap.keys.forEach({
+          key in
+            switch(key) {
+            <% type.fields(include_deprecated: true).each do |field| %>
+              <% if %w(OBJECT INTERFACE UNION).include?(field.type.unwrap.kind) %>
+                case "<%= field.name %>":
+                  <%= generate_append_objects_code("internalGet#{field.classify_name}()", field.type) %>
+              <% end %>
+            <% end %>
+            default:
+              break
+            }
+          })
+          return response
+        <% else %>
+          return []
+        <% end %>
+      }
+
+      open func responseObject() -> GraphQL.AbstractResponse {
+        return self as GraphQL.AbstractResponse
+      }
+    }
+  <% when 'INPUT_OBJECT' %>
+    open class <%= type.name %> {
+      <% type.input_fields.each do |field| %>
+       open var <%= escape_reserved_word(field.camelize_name) %>: <%= swift_input_type(field.type) %>
+      <% end %>
+
+      public init(
+        <% input_fields = type.required_input_fields + type.optional_input_fields %>
+        <% input_fields.each do |field| %>
+          <% default = field.type.non_null? ? "" : " = nil" %>
+          <% seperator = field == input_fields.last ? "" : "," %>
+          <%= escape_reserved_word(field.camelize_name) %>: <%= swift_input_type(field.type) %><%= default %><%= seperator %>
+        <% end %>
+      ) {
+        <% type.input_fields.each do |field| %>
+          self.<%= escape_reserved_word(field.camelize_name) %> = <%= escape_reserved_word(field.camelize_name) %>
+        <% end %>
+      }
+
+      func serialize() -> String {
+        var fields: [String] = []
+        <% type.input_fields.each do |field| %>
+          <% unless field.type.non_null? %>
+            if let <%= escape_reserved_word(field.camelize_name) %> = <%= escape_reserved_word(field.camelize_name) %> {
+          <% end %>
+              fields.append("<%= field.name %>:<%= generate_build_input_code(field.camelize_name, field.type.unwrap_non_null) %>")
+          <% unless field.type.non_null? %>
+            }
+          <% end %>
+        <% end %>
+        return "{\(fields.joined(separator: ","))}"
+      }
+    }
+  <% when 'ENUM' %>
+    public enum <%= type.name %>: String {
+      <% type.enum_values.each do |value| %>
+        <%= swift_attributes(value) %>
+        case <%= escape_reserved_word(value.camelize_name) %> = "<%= value.name %>"
+      <% end %>
+      case unknownValue = ""
+    }
+  <% else %>
+    <% raise NotImplementedError, "unhandled #{type.kind} type #{type.name}" %>
+  <% end %>
+}

data/codegen/lib/graphql_swift_gen/version.rb

@@ -0,0 +1,3 @@
+class GraphQLSwiftGen
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: graphql_swift_gen
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dylan Thacker-Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql_schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Generates swift code based on the GraphQL schema to provide type-safe
+  API for building GraphQL queries and using their responses.
+email:
+- gems@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- codegen/lib/graphql_swift_gen.rb
+- codegen/lib/graphql_swift_gen/reformatter.rb
+- codegen/lib/graphql_swift_gen/scalar.rb
+- codegen/lib/graphql_swift_gen/templates/ApiSchema.swift.erb
+- codegen/lib/graphql_swift_gen/templates/type.swift.erb
+- codegen/lib/graphql_swift_gen/version.rb
+homepage: https://github.com/Shopify/graphql_swift_gen
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- codegen/lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: GraphQL swift client code generator
+test_files: []