ruby-graphql-java-client-generator 0.0.2

data/codegen/lib/graphql_java_gen/templates/Enum.java.erb

@@ -0,0 +1,70 @@
+<%= render_license %>
+
+package <%= package_name %>;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import poc.graphql.client.support.AbstractResponse;
+import poc.graphql.client.support.Arguments;
+import poc.graphql.client.support.Error;
+import poc.graphql.client.support.AbstractQuery;
+import poc.graphql.client.support.SchemaViolationError;
+import poc.graphql.client.support.TopLevelResponse;
+import poc.graphql.client.support.Input;
+<% imports.each do |import| %>
+  import <%= import %>;
+<% end %>
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+    <% case type.kind when 'OBJECT', 'INTERFACE', 'UNION' %>
+    <% when 'INPUT_OBJECT' %>
+    <% when 'ENUM' %>
+        <%= java_doc(type) %>
+        public enum <%= type.name %> {
+          <% enum_values = type.enum_values(include_deprecated: include_deprecated).sort_by{ |value| value.name } %>
+          <% enum_values.each do |value| %>
+            <%= java_doc(value) %>
+            <%= value.deprecated? ? "@Deprecated\n" : '' -%>
+            <%= value.upcase_name %>,
+          <% end %>
+
+          UNKNOWN_VALUE;
+
+          public static <%= type.name %> fromGraphQl(String value) {
+            if (value == null) {
+              return null;
+            }
+
+            switch (value) {
+              <% enum_values.each do |value| %>
+                case "<%= value.name %>": {
+                  return <%= value.upcase_name %>;
+                }
+              <% end %>
+                default: {
+                  return UNKNOWN_VALUE;
+                }
+            }
+          }
+          public String toString() {
+            switch (this) {
+              <% enum_values.each do |value| %>
+                case <%= value.upcase_name %>: {
+                  return "<%= value.name %>";
+                }
+              <% end %>
+                default: {
+                  return "";
+                }
+            }
+          }
+        }
+    <% else %>
+        <% raise NotImplementedError, "unhandled #{type.kind} type #{type.name}" %>
+    <% end %>

data/codegen/lib/graphql_java_gen/templates/GQLClient.java.erb

@@ -0,0 +1,66 @@
+<%= render_license %>
+
+package <%= package_name %>;
+
+import poc.graphql.client.support.SchemaViolationError;
+import poc.graphql.client.GraphQLRequest;
+import poc.graphql.client.impl.GraphQLClientImpl;
+import poc.graphql.client.impl.GraphqlClientConfiguration;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpStatus;
+import org.apache.http.StatusLine;
+import org.apache.http.util.EntityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+
+public class GQLClient extends GraphQLClientImpl {
+    private static final Logger LOGGER = LoggerFactory.getLogger(GQLClient.class);
+
+    public GQLClient(GraphqlClientConfiguration configuration) throws Exception {
+        super(configuration);
+    }
+
+    /**
+     * Execute() with link to generated DTO.
+     * @param query
+     * @return
+     * @throws SchemaViolationError
+     */
+    public QueryResponse execute(QueryQuery query) throws SchemaViolationError {
+        LOGGER.debug("Executing GraphQL query: " + query.toString());
+
+        GraphQLRequest request = new GraphQLRequest(query.toString());
+        HttpResponse httpResponse;
+        try {
+            httpResponse = client.execute(buildRequest(request, null));
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to send GraphQL request", e);
+        }
+
+        StatusLine statusLine = httpResponse.getStatusLine();
+        if (HttpStatus.SC_OK == statusLine.getStatusCode()) {
+            HttpEntity entity = httpResponse.getEntity();
+            String json;
+            try {
+                json = EntityUtils.toString(entity, StandardCharsets.UTF_8);
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to read HTTP response content", e);
+            }
+
+            QueryResponse response = QueryResponse.fromJson(json);
+
+            // We log GraphQL errors because they might otherwise get "silently" unnoticed
+            if (response.getErrors() != null) {
+                LOGGER.warn("GraphQL request {} returned some errors {}", request.getQuery(), response.getErrors());
+            }
+
+            return response;
+        } else {
+            EntityUtils.consumeQuietly(httpResponse.getEntity());
+            throw new RuntimeException("GraphQL query failed with response code " + statusLine.getStatusCode());
+        }
+    }
+}

data/codegen/lib/graphql_java_gen/templates/Input.java.erb

@@ -0,0 +1,103 @@
+<%= render_license %>
+
+package <%= package_name %>;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import poc.graphql.client.support.AbstractResponse;
+import poc.graphql.client.support.Arguments;
+import poc.graphql.client.support.Error;
+import poc.graphql.client.support.AbstractQuery;
+import poc.graphql.client.support.SchemaViolationError;
+import poc.graphql.client.support.TopLevelResponse;
+import poc.graphql.client.support.Input;
+<% imports.each do |import| %>
+  import <%= import %>;
+<% end %>
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+<% required_input_fields = type.required_input_fields.sort_by{ |field| field.name } || [] %>
+<% optional_input_fields = type.optional_input_fields.sort_by{ |field| field.name } || [] %>
+public class <%= type.name %> implements Serializable {
+    <% required_input_fields.each do |field| %>
+      private <%= java_input_type(field.type) %> <%= escape_reserved_word(field.camelize_name) %>;
+    <% end %>
+    <% optional_input_fields.each do |field| %>
+      private Input<<%= java_input_type(field.type) %>> <%= escape_reserved_word(field.camelize_name) %> = Input.undefined();
+    <% end %>
+
+    <% unless required_input_fields.empty? %>
+      public <%= type.name %>(<%= required_input_fields.map{ |field| "#{java_input_type(field.type)} #{escape_reserved_word(field.camelize_name)}" }.join(', ') %>) {
+          <% required_input_fields.each do |field| %>
+              this.<%= escape_reserved_word(field.camelize_name) %> = <%= escape_reserved_word(field.camelize_name) %>;
+          <% end %>
+      }
+    <% end %>
+
+    <% required_input_fields.each do |field| %>
+      <%= java_annotations(field) %>
+      public <%= java_input_type(field.type) %> get<%= field.classify_name %>() {
+          return <%= escape_reserved_word(field.camelize_name) %>;
+      }
+
+      public <%= type.name %> set<%= field.classify_name %>(<%= java_annotations(field, in_argument: true) %><%= java_input_type(field.type) %> <%= escape_reserved_word(field.camelize_name) %>) {
+          this.<%= escape_reserved_word(field.camelize_name) %> = <%= escape_reserved_word(field.camelize_name) %>;
+          return this;
+      }
+
+    <% end %>
+    <% optional_input_fields.each do |field| %>
+      <%= java_annotations(field) %>
+      public <%= java_input_type(field.type) %> get<%= field.classify_name %>() {
+          return <%= escape_reserved_word(field.camelize_name) %>.getValue();
+      }
+
+      public Input<<%= java_input_type(field.type) %>> get<%= field.classify_name %>Input() {
+          return <%= escape_reserved_word(field.camelize_name) %>;
+      }
+
+      public <%= type.name %> set<%= field.classify_name %>(<%= java_annotations(field, in_argument: true) %><%= java_input_type(field.type) %> <%= escape_reserved_word(field.camelize_name) %>) {
+          this.<%= escape_reserved_word(field.camelize_name) %> = Input.optional(<%= escape_reserved_word(field.camelize_name) %>);
+          return this;
+      }
+
+      public <%= type.name %> set<%= field.classify_name %>Input(Input<<%= java_input_type(field.type) %>> <%= escape_reserved_word(field.camelize_name) %>) {
+          if (<%= escape_reserved_word(field.camelize_name) %> == null) {
+              throw new IllegalArgumentException("Input can not be null");
+          }
+          this.<%= escape_reserved_word(field.camelize_name) %> = <%= escape_reserved_word(field.camelize_name) %>;
+          return this;
+      }
+
+    <% end %>
+
+    public void appendTo(StringBuilder _queryBuilder) {
+      String separator = "";
+      _queryBuilder.append('{');
+      <% required_input_fields.each do |field| %>
+        _queryBuilder.append(separator);
+        separator = ",";
+        _queryBuilder.append("<%= field.name %>:");
+        <%= generate_build_input_code(escape_reserved_word(field.camelize_name), field.type) %>
+      <% end %>
+      <% optional_input_fields.each do |field| %>
+        if (this.<%= escape_reserved_word(field.camelize_name) %>.isDefined()) {
+          _queryBuilder.append(separator);
+          separator = ",";
+          _queryBuilder.append("<%= field.name %>:");
+          if (<%= escape_reserved_word(field.camelize_name) %>.getValue() != null) {
+            <%= generate_build_input_code(escape_reserved_word(field.camelize_name).concat(".getValue()"), field.type) %>
+          } else {
+            _queryBuilder.append("null");
+          }
+        }
+      <% end %>
+      _queryBuilder.append('}');
+    }
+}

data/codegen/lib/graphql_java_gen/templates/Interface.java.erb

@@ -0,0 +1,39 @@
+<%= render_license %>
+
+package <%= package_name %>;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import poc.graphql.client.support.AbstractResponse;
+import poc.graphql.client.support.Arguments;
+import poc.graphql.client.support.CustomFieldInterface;
+import poc.graphql.client.support.Error;
+import poc.graphql.client.support.AbstractQuery;
+import poc.graphql.client.support.SchemaViolationError;
+import poc.graphql.client.support.TopLevelResponse;
+import poc.graphql.client.support.Input;
+<% imports.each do |import| %>
+  import <%= import %>;
+<% end %>
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+<% fields = type.fields(include_deprecated: include_deprecated).sort_by{ |field| field.name } || [] %>
+<%= java_doc(type) %>
+<% unless type.object? %>
+    <% if type.name == 'Node' %>
+      public interface <%= type.name %> extends com.shopify.graphql.support.Node {
+    <% else %>
+      public interface <%= type.name %> extends CustomFieldInterface {
+    <% end %>
+        String getGraphQlTypeName();
+        <% fields.each do |field| %>
+            <%= java_output_type(field.type) %> get<%= field.classify_name %>();
+        <% end %>
+    }
+<% end %>

data/codegen/lib/graphql_java_gen/templates/Object.java.erb

@@ -0,0 +1,113 @@
+<%= render_license %>
+
+package <%= package_name %>;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import poc.graphql.client.support.AbstractResponse;
+import poc.graphql.client.support.Arguments;
+import poc.graphql.client.support.Error;
+import poc.graphql.client.support.AbstractQuery;
+import poc.graphql.client.support.SchemaViolationError;
+import poc.graphql.client.support.TopLevelResponse;
+import poc.graphql.client.support.Input;
+<% imports.each do |import| %>
+  import <%= import %>;
+<% end %>
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+            <% fields = type.fields(include_deprecated: include_deprecated) || [] %>
+            <% fields.sort_by{ |field| field.name } %>
+            <% class_name = type.object? ? type.name : "Unknown#{type.name}" %>
+            <%= java_doc(type) %>
+            public class <%= class_name %> extends AbstractResponse<<%= class_name %>> <%= java_implements(type) %>{
+                public <%= class_name %>() {
+                }
+
+                public <%= class_name %>(JsonObject fields) throws SchemaViolationError {
+                  for (Map.Entry<String, JsonElement> field : fields.entrySet()) {
+                    String key = field.getKey();
+                    String fieldName = getFieldName(key);
+                    switch (fieldName) {
+                      <% fields.each do |field| %>
+                        case "<%= field.name %>": {
+                          <% generate_build_output_code("field.getValue()", field.type) do |statements, expr| %>
+                            <%= statements %>
+                            responseData.put(key, <%= expr %>);
+                          <% end %>
+                          break;
+                        }
+                      <% end %>
+                      case "__typename": {
+                        responseData.put(key, jsonAsString(field.getValue(), key));
+                        break;
+                      }
+                      
+                      default: {
+                        readCustomField(fieldName, field.getValue());
+                      }
+                    }
+                  }
+                }
+
+                <% if type.object? && type.implement?("Node") %>
+                    public <%= class_name %>(<%= scalars['ID'].non_nullable_type %> id) {
+                      this();
+                      optimisticData.put("id", id);
+                    }
+                <% end %>
+
+                <% if type.object? %>
+                    public String getGraphQlTypeName() {
+                        return "<%= type.name %>";
+                    }
+                <% else %>
+                    public static <%= type.name %> create(JsonObject fields) throws SchemaViolationError {
+                        String typeName = fields.getAsJsonPrimitive("__typename").getAsString();
+                        switch (typeName) {
+                            <% type.possible_types.each do |possible_type| %>
+                                case "<%= possible_type.name %>": {
+                                    return new <%= possible_type.name %>(fields);
+                                }
+                            <% end %>
+                            default: {
+                                return new <%= class_name %>(fields);
+                            }
+                        }
+                    }
+
+                    public String getGraphQlTypeName() {
+                        return (String) get("__typename");
+                    }
+                <% end %>
+
+                <% fields.each do |field| %>
+                    <%= java_doc(field) %>
+                    <%= java_annotations(field) %>
+                    public <%= java_output_type(field.type) %> get<%= field.classify_name %>() {
+                      return (<%= java_output_type(field.type) %>) get("<%= field.name %>");
+                    }
+
+                    <% next if field.name == "id" && type.object? && type.implement?("Node") %>
+                    public <%= class_name %> set<%= field.classify_name %>(<%= java_output_type(field.type) %> arg) {
+                      optimisticData.put(getKey("<%= field.name %>"), arg);
+                      return this;
+                    }
+                <% end %>
+
+                  public boolean unwrapsToObject(String key) {
+                    switch (getFieldName(key)) {
+                      <% fields.each do |field| %>
+                        case "<%= field.name %>": return <%= field.type.unwrap.object? %>;
+                      <% end %>
+                      default: return false;
+                    }
+                  }
+            }
+

data/codegen/lib/graphql_java_gen/templates/Operations.java.erb

@@ -0,0 +1,36 @@
+<%= render_license %>
+
+package <%= package_name %>;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import poc.graphql.client.support.AbstractResponse;
+import poc.graphql.client.support.Arguments;
+import poc.graphql.client.support.Error;
+import poc.graphql.client.support.AbstractQuery;
+import poc.graphql.client.support.SchemaViolationError;
+import poc.graphql.client.support.TopLevelResponse;
+import poc.graphql.client.support.Input;
+<% imports.each do |import| %>
+  import <%= import %>;
+<% end %>
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Operations {
+    <% [[:query, schema.query_root_name], [:mutation, schema.mutation_root_name]].each do |operation_type, root_name| %>
+        <% next unless root_name %>
+        public static <%= root_name %>Query <%= operation_type %>(<%= root_name %>QueryDefinition queryDef) {
+            StringBuilder queryString = new StringBuilder("<%= operation_type unless operation_type == :query %>{");
+            <%= root_name %>Query query = new <%= root_name %>Query(queryString);
+            queryDef.define(query);
+            queryString.append('}');
+            return query;
+        }
+    <% end %>
+}

data/codegen/lib/graphql_java_gen/templates/Query.java.erb

@@ -0,0 +1,113 @@
+<%= render_license %>
+
+package <%= package_name %>;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import poc.graphql.client.support.AbstractResponse;
+import poc.graphql.client.support.Arguments;
+import poc.graphql.client.support.Error;
+import poc.graphql.client.support.AbstractQuery;
+import poc.graphql.client.support.SchemaViolationError;
+import poc.graphql.client.support.TopLevelResponse;
+import poc.graphql.client.support.Input;
+<% imports.each do |import| %>
+  import <%= import %>;
+<% end %>
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+
+<% fields = type.fields(include_deprecated: include_deprecated).sort_by{ |field| field.name } || [] %>
+<%= java_doc(type) %>
+public class <%= type.name %>Query extends AbstractQuery<<%= type.name %>Query> {
+    <%= type.name %>Query(StringBuilder _queryBuilder) {
+        super(_queryBuilder);
+        <% if type.object? && type.implement?("Node") %>
+            startField("id");
+        <% end %>
+        <% unless type.object? %>
+            startField("__typename");
+        <% end %>
+    }
+
+    <% fields.each do |field| %>
+        <% next if field.name == "id" && type.object? && type.implement?("Node") %>
+        <% unless field.optional_args.empty? %>
+            public class <%= field.classify_name %>Arguments extends Arguments {
+                <%= field.classify_name %>Arguments(StringBuilder _queryBuilder) {
+                    super(_queryBuilder, <%= !!field.required_args.empty? %>);
+                }
+
+                <% field.optional_args.each do |arg| %>
+                    <%= java_doc(arg) %>
+                    public <%= field.classify_name %>Arguments <%= escape_reserved_word(arg.camelize_name) %>(<%= java_input_type(arg.type) %> value) {
+                        if (value != null) {
+                            startArgument("<%= arg.name %>");
+                            <%= generate_build_input_code('value', arg.type) %>
+                        }
+                        return this;
+                    }
+                <% end %>
+            }
+
+            public interface <%= field.classify_name %>ArgumentsDefinition {
+                void define(<%= field.classify_name %>Arguments args);
+            }
+
+            <%= java_doc(field) %>
+            public <%= type.name %>Query <%= escape_reserved_word(field.camelize_name) %>(<%= java_arg_defs(field, skip_optional: true) %>) {
+                return <%= escape_reserved_word(field.camelize_name) %>(<%= java_arg_expresions_with_empty_optional_args(field) %>);
+            }
+        <% end %>
+
+        <%= java_doc(field) %>
+        <%= field.deprecated? ? "@Deprecated\n" : '' -%>
+        public <%= type.name %>Query <%= escape_reserved_word(field.camelize_name) %>(<%= java_arg_defs(field) %>) {
+            startField("<%= field.name %>");
+            <% unless field.args.empty? %>
+                <% if field.required_args.empty? %>
+                    <%= field.classify_name %>Arguments args = new <%= field.classify_name %>Arguments(_queryBuilder);
+                    argsDef.define(args);
+                    <%= field.classify_name %>Arguments.end(args);
+                <% else %>
+                    <% field.required_args.each_with_index do |arg, i| %>
+                      _queryBuilder.append("<%= i == 0 ? "(" : "," %><%= arg.name %>:");
+                      <%= generate_build_input_code(escape_reserved_word(arg.camelize_name), arg.type) %>
+                    <% end %>
+                    <% unless field.optional_args.empty? %>
+                        argsDef.define(new <%= field.classify_name %>Arguments(_queryBuilder));
+                    <% end %>
+                    _queryBuilder.append(')');
+                <% end %>
+            <% end %>
+            <% if field.subfields? %>
+                _queryBuilder.append('{');
+                queryDef.define(new <%= field.type.unwrap.name %>Query(_queryBuilder));
+                _queryBuilder.append('}');
+            <% end %>
+            return this;
+        }
+    <% end %>
+    <% unless type.object? %>
+        <% type.possible_types.each do |possible_type| %>
+            public <%= type.name %>Query on<%= possible_type.name %>(<%= possible_type.name %>QueryDefinition queryDef) {
+                startInlineFragment("<%= possible_type.name %>");
+                queryDef.define(new <%= possible_type.name %>Query(_queryBuilder));
+                _queryBuilder.append('}');
+                return this;
+            }
+        <% end %>
+    <% end %>
+
+    <% if schema.root_name?(type.name) %>
+      public String toString() {
+          return _queryBuilder.toString();
+      }
+    <% end %>
+}