Allow scalar parse* and serialized methods to access context

src/execution/__tests__/executor-test.ts

@@ -3,6 +3,7 @@ import { describe, it } from 'mocha';
 
 import { expectJSON } from '../../__testUtils__/expectJSON';
 
+import { identityFunc } from '../../jsutils/identityFunc';
 import { inspect } from '../../jsutils/inspect';
 
 import { Kind } from '../../language/kinds';
@@ -1146,6 +1147,93 @@ describe('Execute: Handles basic execution tasks', () => {
     expect(asyncResult).to.deep.equal(result);
   });
 
+  it('passes context to custom scalar parseValue', () => {
+    const customScalar = new GraphQLScalarType({
+      name: 'CustomScalar',
+      parseValue: (_value, context) => context,
+    });
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          customScalar: {
+            type: GraphQLInt,
+            args: {
+              passThroughContext: {
+                type: customScalar,
+              },
+            },
+            resolve: (_source, _args, context) => context,
+          },
+        },
+      }),
+    });
+
+    const result = executeSync({
+      schema,
+      document: parse('{ customScalar(passThroughContext: 0) }'),
+      contextValue: 1,
+    });
+    expectJSON(result).toDeepEqual({
+      data: { customScalar: 1 },
+    });
+  });
+
+  it('passes context to custom scalar serialize', () => {
+    const customScalar = new GraphQLScalarType({
+      name: 'CustomScalar',
+      serialize: (_value, context) => context,
+      parseValue: identityFunc,
+    });
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          customScalar: {
+            type: customScalar,
+            resolve: () => 'CUSTOM_VALUE',
+          },
+        },
+      }),
+    });
+
+    const result = executeSync({
+      schema,
+      document: parse('{ customScalar }'),
+      contextValue: 1,
+    });
+    expectJSON(result).toDeepEqual({
+      data: { customScalar: 1 },
+    });
+  });
+
+  it('passes context to custom scalar serialize', () => {
+    const customScalar = new GraphQLScalarType({
+      name: 'CustomScalar',
+      serialize: (_value, context) => context,
+    });
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          customScalar: {
+            type: customScalar,
+            resolve: () => 'CUSTOM_VALUE',
+          },
+        },
+      }),
+    });
+
+    const result = executeSync({
+      schema,
+      document: parse('{ customScalar }'),
+      contextValue: 1,
+    });
+    expectJSON(result).toDeepEqual({
+      data: { customScalar: 1 },
+    });
+  });
+
   it('fails when serialize of custom scalar does not return a value', () => {
     const customScalar = new GraphQLScalarType({
       name: 'CustomScalar',

src/execution/__tests__/variables-test.ts

@@ -38,13 +38,19 @@ const TestComplexScalar = new GraphQLScalarType({
   },
 });
 
+const TestContextScalar = new GraphQLScalarType({
+  name: 'ContextScalar',
+  parseValue: (_value, context) => context,
+});
+
 const TestInputObject = new GraphQLInputObjectType({
   name: 'TestInputObject',
   fields: {
     a: { type: GraphQLString },
     b: { type: new GraphQLList(GraphQLString) },
     c: { type: new GraphQLNonNull(GraphQLString) },
     d: { type: TestComplexScalar },
+    e: { type: TestContextScalar },
   },
 });
 
@@ -126,9 +132,10 @@ const schema = new GraphQLSchema({ query: TestType });
 function executeQuery(
   query: string,
   variableValues?: { [variable: string]: unknown },
+  contextValue?: unknown,
 ) {
   const document = parse(query);
-  return executeSync({ schema, document, variableValues });
+  return executeSync({ schema, document, contextValue, variableValues });
 }
 
 describe('Execute: Handles inputs', () => {
@@ -366,6 +373,18 @@ describe('Execute: Handles inputs', () => {
         });
       });
 
+      it('executes with scalar access to context', () => {
+        const params = { input: { c: 'foo', e: false } };
+        const contextValue = true;
+        const result = executeQuery(doc, params, contextValue);
+
+        expect(result).to.deep.equal({
+          data: {
+            fieldWithObjectInput: '{ c: "foo", e: true }',
+          },
+        });
+      });
+
       it('errors on null for nested non-null', () => {
         const params = { input: { a: 'foo', b: 'bar', c: null } };
         const result = executeQuery(doc, params);
@@ -1044,6 +1063,7 @@ describe('Execute: Handles inputs', () => {
         schema,
         variableDefinitions,
         inputValue,
+        undefined,
         { maxErrors: 3 },
       );
 
@@ -1061,6 +1081,7 @@ describe('Execute: Handles inputs', () => {
         schema,
         variableDefinitions,
         inputValue,
+        undefined,
         { maxErrors: 2 },
       );
 

src/execution/execute.ts

@@ -323,6 +323,7 @@ export function buildExecutionContext(
     schema,
     variableDefinitions,
     rawVariableValues ?? {},
+    contextValue,
     { maxErrors: 50 },
   );
 
@@ -497,6 +498,11 @@ function executeField(
     path,
   );
 
+  // The resolve function's optional third argument is a context value that
+  // is provided to every resolve function within an execution. It is commonly
+  // used to represent an authenticated user, or request-specific caches.
+  const { contextValue, variableValues } = exeContext;
+
   // Get the resolve function, regardless of if its result is normal or abrupt (error).
   try {
     // Build a JS object of arguments from the field.arguments AST, using the
@@ -505,14 +511,10 @@ function executeField(
     const args = getArgumentValues(
       fieldDef,
       fieldNodes[0],
-      exeContext.variableValues,
+      contextValue,
+      variableValues,
     );
 
-    // The resolve function's optional third argument is a context value that
-    // is provided to every resolve function within an execution. It is commonly
-    // used to represent an authenticated user, or request-specific caches.
-    const contextValue = exeContext.contextValue;
-
     const result = resolveFn(source, args, contextValue, info);
 
     let completed;
@@ -662,7 +664,7 @@ function completeValue(
   // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
   // returning null if serialization is not possible.
   if (isLeafType(returnType)) {
-    return completeLeafValue(returnType, result);
+    return completeLeafValue(exeContext, returnType, result);
   }
 
   // If field type is an abstract type, Interface or Union, determine the
@@ -775,10 +777,14 @@ function completeListValue(
  * null if serialization is not possible.
  */
 function completeLeafValue(
+  exeContext: ExecutionContext,
   returnType: GraphQLLeafType,
   result: unknown,
 ): unknown {
-  const serializedResult = returnType.serialize(result);
+  const serializedResult = returnType.serialize(
+    result,
+    exeContext.contextValue,
+  );
   if (serializedResult == null) {
     throw new Error(
       `Expected \`${inspect(returnType)}.serialize(${inspect(result)})\` to ` +

src/execution/subscribe.ts

@@ -180,8 +180,17 @@ export async function createSourceEventStream(
 async function executeSubscription(
   exeContext: ExecutionContext,
 ): Promise<unknown> {
-  const { schema, fragments, operation, variableValues, rootValue } =
-    exeContext;
+  // The resolve function's optional third argument is a context value that
+  // is provided to every resolve function within an execution. It is commonly
+  // used to represent an authenticated user, or request-specific caches.
+  const {
+    schema,
+    fragments,
+    operation,
+    contextValue,
+    variableValues,
+    rootValue,
+  } = exeContext;
 
   const rootType = schema.getSubscriptionType();
   if (rootType == null) {
@@ -224,12 +233,12 @@ async function executeSubscription(
 
     // Build a JS object of arguments from the field.arguments AST, using the
     // variables scope to fulfill any variable references.
-    const args = getArgumentValues(fieldDef, fieldNodes[0], variableValues);
-
-    // The resolve function's optional third argument is a context value that
-    // is provided to every resolve function within an execution. It is commonly
-    // used to represent an authenticated user, or request-specific caches.
-    const contextValue = exeContext.contextValue;
+    const args = getArgumentValues(
+      fieldDef,
+      fieldNodes[0],
+      contextValue,
+      variableValues,
+    );
 
     // Call the `subscribe()` resolver or the default resolver to produce an
     // AsyncIterable yielding raw payloads.

src/execution/values.ts

@@ -36,17 +36,19 @@ type CoercedVariableValues =
  * exposed to user code. Care should be taken to not pull values from the
  * Object prototype.
  */
-export function getVariableValues(
+export function getVariableValues<TContext = any>(
   schema: GraphQLSchema,
   varDefNodes: ReadonlyArray<VariableDefinitionNode>,
   inputs: { readonly [variable: string]: unknown },
+  context?: Maybe<TContext>,
   options?: { maxErrors?: number },
 ): CoercedVariableValues {
   const errors = [];
   const maxErrors = options?.maxErrors;
   try {
     const coerced = coerceVariableValues(
       schema,
+      context,
       varDefNodes,
       inputs,
       (error) => {
@@ -69,8 +71,9 @@ export function getVariableValues(
   return { errors };
 }
 
-function coerceVariableValues(
+function coerceVariableValues<TContext>(
   schema: GraphQLSchema,
+  context: TContext,
   varDefNodes: ReadonlyArray<VariableDefinitionNode>,
   inputs: { readonly [variable: string]: unknown },
   onError: (error: GraphQLError) => void,
@@ -122,6 +125,7 @@ function coerceVariableValues(
     coercedValues[varName] = coerceInputValue(
       value,
       varType,
+      context,
       (path, invalidValue, error) => {
         let prefix =
           `Variable "$${varName}" got invalid value ` + inspect(invalidValue);
@@ -149,9 +153,10 @@ function coerceVariableValues(
  * exposed to user code. Care should be taken to not pull values from the
  * Object prototype.
  */
-export function getArgumentValues(
+export function getArgumentValues<TContext = any>(
   def: GraphQLField<unknown, unknown> | GraphQLDirective,
   node: FieldNode | DirectiveNode,
+  context?: TContext,
   variableValues?: Maybe<ObjMap<unknown>>,
 ): { [argument: string]: unknown } {
   const coercedValues: { [argument: string]: unknown } = {};
@@ -210,7 +215,12 @@ export function getArgumentValues(
       );
     }
 
-    const coercedValue = valueFromAST(valueNode, argType, variableValues);
+    const coercedValue = valueFromAST(
+      valueNode,
+      argType,
+      context,
+      variableValues,
+    );
     if (coercedValue === undefined) {
       // Note: ValuesOfCorrectTypeRule validation should catch this before
       // execution. This is a runtime check to ensure execution does not

src/type/__tests__/definition-test.ts

@@ -88,10 +88,25 @@ describe('Type System: Scalars', () => {
       'parseValue: { foo: "bar" }',
     );
     expect(
-      scalar.parseLiteral(parseValue('{ foo: { bar: $var } }'), { var: 'baz' }),
+      scalar.parseLiteral(parseValue('{ foo: { bar: $var } }'), undefined, {
+        var: 'baz',
+      }),
     ).to.equal('parseValue: { foo: { bar: "baz" } }');
   });
 
+  it('pass context to scalar methods', () => {
+    const scalar = new GraphQLScalarType({
+      name: 'Foo',
+      serialize: (_value, context) => context,
+      parseValue: (_value, context) => context,
+      parseLiteral: (_value, context) => context,
+    });
+
+    expect(scalar.serialize(undefined, 1)).to.equal(1);
+    expect(scalar.parseValue(undefined, 1)).to.equal(1);
+    expect(scalar.parseLiteral(parseValue('null'), 1)).to.equal(1);
+  });
+
   it('rejects a Scalar type without name', () => {
     // @ts-expect-error
     expect(() => new GraphQLScalarType({})).to.throw('Must provide name.');