Fixup string bool handling

CHANGELOG.md

@@ -10,12 +10,30 @@ the compatibility issues you are likely to encounter.
 
 ## [Unreleased]
 
+### Compatibility
+
+* The error code `param_mismatch` was removed in lieu of
+  `type_mismatch` due to a rewrite in the type checker of error
+  handling.
+* The error code `non_null` will now report `type_mismatch` instead.
+* The error code `enum_not_found` will now be reported as
+  `unknown_enum`
+* If a string literal is given in place of an enum, the error code
+  will now be `enum_string_literal` rather than `enum_not_found`.
+
 ### Added
 
 * Add proper support for OTP release 21 (by getong, 18年梦醒). Detect the
   OTP 21 version, and if present, use the new stack-trace form. This
   ensures backwards compatibility as well as proper stack trace
   handling in new OTP releases.
+* New command `graphql:map/2`. Given a `Result` of the form `{ok, Val} |
+  {defer, Token}` the call to `graphql:map(F, Result)` will apply `F`
+  to the result. Either now, or in the case of a defer, when the defer
+  completes. This yields an alternative way to handle events which
+  cannot be completed right away. Long running work is usually better
+  handled in a spawned process, but simpler changes can be handled
+  within the context of the GraphQL process.
 * New command `graphql:sync/3`. Calling `graphql:sync(Ctx, Pid, Msg)`
   will place a message into the GraphQL mailbox. When this message
   occurs, we will send `Pid` a message `Msg`. This is useful for e.g.,
@@ -28,6 +46,11 @@ the compatibility issues you are likely to encounter.
 
 ### Fixed
 
+* Default variable value expansion has been fixed. If you have a
+  situation where a field-arg has a default value, you have supplied a
+  parameter for that value, say `foo(x: $k)` and you then omit `$k` in
+  your query, the underlying default (in this case the default for
+  `x`) is now picked up properly.
 * Re-instate the operation type in the callers context
 * Remove the occurrence of fragment names in `path` components of
   errors. These are not allowed per the Jun2018 specification and

README.md

@@ -28,7 +28,7 @@ specification, except for a few areas:
 In addition, we are working towards June 2018 compliance. We already
 implemented many of the changes in the system. But we are still
 missing some parts. The implementation plan is on a demand driven
-basis for Shopgun currently, in that we tend to implement things are
+basis for Shopgun currently, in that we tend to implement things when
 there is a need for them.
 
 # Documentation

src/graphql.erl

@@ -1,10 +1,11 @@
 -module(graphql).
 
-
 -include_lib("graphql/include/graphql.hrl").
 -include("graphql_internal.hrl").
 -include("graphql_schema.hrl").
 
+-compile({no_auto_import, [monitor/2]}).
+
 %% GraphQL Documents
 -export([
          parse/1,
@@ -26,7 +27,9 @@
 %% Deferred execution
 -export([
          token/1, reply_cast/2,
-         sync/3
+         sync/3,
+         monitor/2,
+         map/2
          ]).
 
 %% Schema Definitions
@@ -47,6 +50,10 @@
 -export_type([json/0, param_context/0]).
 
 -type token() :: {'$graphql_token', pid(), reference(), reference()}.
+-type defer_map() :: #{ worker => pid(),
+                        timeout => non_neg_integer(),
+                        apply => [fun()]}.
+-type result() :: {ok, term()} | {error, term()} | {defer, token()} | {defer, token(), defer_map()}.
 -type name() :: {name, pos_integer(), binary()} | binary().
 -type document() :: #document{}.
 -type directive() :: #directive{}.
@@ -74,6 +81,18 @@ token(#{ defer_process := Proc, defer_request_id := ReqId }) ->
 sync(#{ defer_process := Proc, defer_request_id := ReqId }, Pid, Msg) ->
     Proc ! {'$graphql_sync', ReqId, Pid, Msg}.
 
+-spec monitor(pid(), result()) -> result().
+monitor(_Worker, {ok, Value})                            -> {ok, Value};
+monitor(_Worker, {error, Reason})                        -> {error, Reason};
+monitor(Worker, {defer, Token})                          -> monitor(Worker, {defer, Token, #{}});
+monitor(Worker, {defer, Token, Map}) when is_pid(Worker) -> {defer, Token, Map#{ worker => Worker}}.
+
+map(F, {ok, Value})                          -> F({ok, Value});
+map(F, {error, Reason})                      -> F({error, Reason});
+map(F, {defer, Token})                       -> map(F, {defer, Token, #{}});
+map(F, {defer, Token, #{ apply := App} = M}) -> {defer, Token, M#{ apply := queue:in(F, App)}};
+map(F, {defer, Token, #{} = M})              -> {defer, Token, M#{ apply => queue:in(F, queue:new())}}.
+
 %% @private
 token_ref({'$graphql_token', _, _, Ref}) -> Ref.