Add custom directives

Author: no1seman

graphql/execute.lua

@@ -278,14 +278,48 @@ local function getFieldEntry(objectType, object, fields, context)
       if argument and argument.value then
           positions[pos] = {
               name=argument.name.value,
-              value=arguments[argument.name.value]
+              value=arguments[argument.name.value],
           }
           pos = pos + 1
       end
   end
 
   arguments = setmetatable(arguments, {__index=positions,})
 
+  local directiveMap = {}
+  for _, directive in ipairs(firstField.directives or {}) do
+    directiveMap[directive.name.value] = directive
+  end
+
+  local directives = {}
+  local directivesDefaultValues = {}
+
+  if next(directiveMap) then
+    util.map_name(context.schema.directives or {}, function(directive, directive_name)
+      local supplied_directive = directiveMap[directive_name]
+      if supplied_directive ~= nil then
+        local directiveArgumentMap = {}
+        for _, argument in ipairs(supplied_directive.arguments or {}) do
+          directiveArgumentMap[argument.name.value] = argument
+        end
+
+        directives[directive_name] = util.map(directive.arguments or {}, function(argument, name)
+        local supplied = directiveArgumentMap[name] and directiveArgumentMap[name].value
+        local defaultValue = argument.defaultValue
+        if argument.kind then argument = argument.kind end
+        directivesDefaultValues[directive_name] = directivesDefaultValues[directive_name] or {}
+        if defaultValue ~= nil then directivesDefaultValues[directive_name][name] = defaultValue end
+        local res = util.coerceValue(supplied, argument, context.variables, {
+          strict_non_null = true,
+          defaultValues = defaultValues,
+        })
+
+        return res
+      end)
+      end
+    end)
+  end
+
   local info = {
     context = context,
     fieldName = fieldName,
@@ -298,6 +332,7 @@ local function getFieldEntry(objectType, object, fields, context)
     operation = context.operation,
     variableValues = context.variables,
     defaultValues = context.defaultValues,
+    directives = directives,
   }
 
   local resolvedObject, err = (fieldType.resolve or defaultResolver)(object, arguments, info)

graphql/introspection.lua

@@ -109,6 +109,18 @@ __Directive = types.object({
           if directive.onFragmentDefinition then table.insert(res, 'FRAGMENT_DEFINITION') end
           if directive.onFragmentSpread then table.insert(res, 'FRAGMENT_SPREAD') end
           if directive.onInlineFragment then table.insert(res, 'INLINE_FRAGMENT') end
+          if directive.onVariableDefinition then table.insert(res, 'VARIABLE_DEFINITION') end
+          if directive.onSchema then table.insert(res, 'SCHEMA') end
+          if directive.onScalar then table.insert(res, 'SCALAR') end
+          if directive.onObject then table.insert(res, 'OBJECT') end
+          if directive.onFieldDefinition then table.insert(res, 'FIELD_DEFINITION') end
+          if directive.onArgumentDefinition then table.insert(res, 'ARGUMENT_DEFINITION') end
+          if directive.onInterface then table.insert(res, 'INTERFACE') end
+          if directive.onUnion then table.insert(res, 'UNION') end
+          if directive.onEnum then table.insert(res, 'ENUM') end
+          if directive.onEnumValue then table.insert(res, 'ENUM_VALUE') end
+          if directive.onInputObject then table.insert(res, 'INPUT_OBJECT') end
+          if directive.onInputFieldDefinition then table.insert(res, 'INPUT_FIELD_DEFINITION') end
 
           return res
         end,
@@ -117,7 +129,14 @@ __Directive = types.object({
       args = {
         kind = types.nonNull(types.list(types.nonNull(__InputValue))),
         resolve = resolveArgs,
-      }
+      },
+
+      isRepeatable = {
+        kind = types.nonNull(types.boolean),
+        resolve = function(directive)
+          return directive.isRepeatable == true
+        end
+      },
     }
   end
 })
@@ -160,6 +179,66 @@ __DirectiveLocation = types.enum({
       value = 'INLINE_FRAGMENT',
       description = 'Location adjacent to an inline fragment.',
     },
+
+    VARIABLE_DEFINITION = {
+      value = 'VARIABLE_DEFINITION',
+      description = 'Location adjacent to a variable definition.',
+    },
+
+    SCHEMA = {
+      value = 'SCHEMA',
+      description = 'Location adjacent to schema.',
+    },
+
+    SCALAR = {
+      value = 'SCALAR',
+      description = 'Location adjacent to a scalar.',
+    },
+
+    OBJECT = {
+      value = 'OBJECT',
+      description = 'Location adjacent to an object.',
+    },
+
+    FIELD_DEFINITION = {
+      value = 'FIELD_DEFINITION',
+      description = 'Location adjacent to a field definition.',
+    },
+
+    ARGUMENT_DEFINITION = {
+      value = 'ARGUMENT_DEFINITION',
+      description = 'Location adjacent to an argument definition.',
+    },
+
+    INTERFACE = {
+      value = 'INTERFACE',
+      description = 'Location adjacent to an interface.',
+    },
+
+    UNION = {
+      value = 'UNION',
+      description = 'Location adjacent to an union.',
+    },
+
+    ENUM = {
+      value = 'ENUM',
+      description = 'Location adjacent to an enum.',
+    },
+
+    ENUM_VALUE = {
+      value = 'ENUM_VALUE',
+      description = 'Location adjacent to an enum value.',
+    },
+
+    INPUT_OBJECT = {
+      value = 'INPUT_OBJECT',
+      description = 'Location adjacent to an input object.',
+    },
+
+    INPUT_FIELD_DEFINITION = {
+      value = 'INPUT_FIELD_DEFINITION',
+      description = 'Location adjacent to an input field definition.',
+    },
   }
 })
 
@@ -272,7 +351,7 @@ __Type = types.object({
         kind = __Type,
       },
     }
-  end
+  end,
 })
 
 __Field = types.object({
@@ -309,7 +388,7 @@ __Field = types.object({
 
       deprecationReason = types.string,
     }
-  end
+  end,
 })
 
 __InputValue = types.object({
@@ -341,7 +420,7 @@ __InputValue = types.object({
         end,
       },
     }
-  end
+  end,
 })
 
 __EnumValue = types.object({
@@ -359,11 +438,11 @@ __EnumValue = types.object({
       description = types.string,
       isDeprecated = {
         kind = types.boolean.nonNull,
-        resolve = function(enumValue) return enumValue.deprecationReason ~= nil end
+        resolve = function(enumValue) return enumValue.deprecationReason ~= nil end,
       },
       deprecationReason = types.string,
     }
-  end
+  end,
 })
 
 __TypeKind = types.enum({
@@ -409,7 +488,7 @@ __TypeKind = types.enum({
       value = 'NON_NULL',
       description = 'Indicates this type is a non-null. `ofType` is a valid field.',
     },
-  }
+  },
 })
 
 local Schema = {

graphql/rules.lua

@@ -146,7 +146,7 @@ function rules.unambiguousSelections(node, context)
 
       table.insert(selectionMap[key], entry)
     else
-      selectionMap[key] = { entry }
+      selectionMap[key] = { entry, }
     end
   end
 
@@ -314,7 +314,7 @@ function rules.fragmentSpreadIsPossible(node, context)
 
   local function getTypes(kind)
     if kind.__type == 'Object' then
-      return { [kind] = kind }
+      return { [kind] = kind, }
     elseif kind.__type == 'Interface' then
       return context.schema:getImplementors(kind.name)
     elseif kind.__type == 'Union' then
@@ -332,7 +332,6 @@ function rules.fragmentSpreadIsPossible(node, context)
   local fragmentTypes = getTypes(fragmentType)
 
   local valid = util.find(parentTypes, function(kind)
-    local kind = kind
     -- Here is the check that type, mentioned in '... on some_type'
     -- conditional fragment expression is type of some field of parent object.
     -- In case of Union parent object and NonNull wrapped inner types

graphql/schema.lua

@@ -99,6 +99,26 @@ end
 function schema:generateDirectiveMap()
   for _, directive in ipairs(self.directives) do
     self.directiveMap[directive.name] = directive
+    if directive.arguments then
+      for name, argument in pairs(directive.arguments) do
+
+          -- BEGIN_HACK: resolve type names to real types
+          if type(argument) == 'string' then
+            argument = types.resolve(argument, self.name)
+            directive.arguments[name] = argument
+          end
+
+          if type(argument.kind) == 'string' then
+            argument.kind = types.resolve(argument.kind, self.name)
+          end
+          -- END_HACK: resolve type names to real types
+
+          local argumentType = argument.__type and argument or argument.kind
+          assert(argumentType, 'Must supply type for argument "' .. name .. '" on "' .. directive.name .. '"')
+          argumentType.defaultValue = argument.defaultValue
+          self:generateTypeMap(argumentType)
+      end
+    end
   end
 end
 

graphql/types.lua

@@ -419,6 +419,19 @@ function types.directive(config)
     onFragmentDefinition = config.onFragmentDefinition,
     onFragmentSpread = config.onFragmentSpread,
     onInlineFragment = config.onInlineFragment,
+    onVariableDefinition = config.onVariableDefinition,
+    onSchema = config.onSchema,
+    onScalar = config.onScalar,
+    onObject = config.onObject,
+    onFieldDefinition = config.onFieldDefinition,
+    onArgumentDefinition = config.onArgumentDefinition,
+    onInterface = config.onInterface,
+    onUnion = config.onUnion,
+    onEnum = config.onEnum,
+    onEnumValue = config.onEnumValue,
+    onInputObject = config.onInputObject,
+    onInputFieldDefinition = config.onInputFieldDefinition,
+    isRepeatable = config.isRepeatable or false
   }
 
   return instance
@@ -428,7 +441,7 @@ types.include = types.directive({
   name = 'include',
   description = 'Directs the executor to include this field or fragment only when the `if` argument is true.',
   arguments = {
-    ['if'] = { kind = types.boolean.nonNull, description = 'Included when true.'}
+    ['if'] = { kind = types.boolean.nonNull, description = 'Included when true.', },
   },
   onField = true,
   onFragmentSpread = true,
@@ -439,7 +452,7 @@ types.skip = types.directive({
   name = 'skip',
   description = 'Directs the executor to skip this field or fragment when the `if` argument is true.',
   arguments = {
-    ['if'] = { kind = types.boolean.nonNull, description = 'Skipped when true.' }
+    ['if'] = { kind = types.boolean.nonNull, description = 'Skipped when true.', },
   },
   onField = true,
   onFragmentSpread = true,

graphql/util.lua

@@ -11,6 +11,16 @@ local function map(t, fn)
   return res
 end
 
+local function map_name(t, fn)
+  local res = {}
+  for _, v in ipairs(t or {}) do
+    if v.name then
+      res[v.name] = fn(v, v.name)
+    end
+  end
+  return res
+end
+
 local function find(t, fn)
   for k, v in pairs(t) do
     if fn(v, k) then return v end
@@ -169,17 +179,17 @@ local function coerceValue(node, schemaType, variables, opts)
   end
 end
 
---- Check whether passed value has one of listed types.
----
---- @param obj value to check
----
---- @tparam string obj_name name of the value to form an error
----
---- @tparam string type_1
---- @tparam[opt] string type_2
---- @tparam[opt] string type_3
----
---- @return nothing
+-- Check whether passed value has one of listed types.
+--
+-- @param obj value to check
+--
+-- @tparam string obj_name name of the value to form an error
+--
+-- @tparam string type_1
+-- @tparam[opt] string type_2
+-- @tparam[opt] string type_3
+--
+-- @return nothing
 local function check(obj, obj_name, type_1, type_2, type_3)
     if type(obj) == type_1 or type(obj) == type_2 or type(obj) == type_3 then
         return
@@ -196,15 +206,15 @@ local function check(obj, obj_name, type_1, type_2, type_3)
     end
 end
 
---- Check whether table is an array.
----
---- Based on [that][1] implementation.
---- [1]: https://github.com/mpx/lua-cjson/blob/db122676/lua/cjson/util.lua
----
---- @tparam table table to check
---- @return[1] `true` if passed table is an array (includes the empty table
---- case)
---- @return[2] `false` otherwise
+-- Check whether table is an array.
+--
+-- Based on [that][1] implementation.
+-- [1]: https://github.com/mpx/lua-cjson/blob/db122676/lua/cjson/util.lua
+--
+-- @tparam table table to check
+-- @return[1] `true` if passed table is an array (includes the empty table
+-- case)
+-- @return[2] `false` otherwise
 local function is_array(table)
     if type(table) ~= 'table' then
         return false
@@ -270,6 +280,7 @@ end
 
 return {
   map = map,
+  map_name = map_name,
   find = find,
   filter = filter,
   values = values,