some new semanticNullability execution tests

Author: twof

package.json

@@ -38,7 +38,7 @@
     "test": "npm run lint && npm run check && npm run testonly && npm run prettier:check && npm run check:spelling && npm run check:integrations",
     "lint": "eslint --cache --max-warnings 0 .",
     "check": "tsc --pretty",
-    "testonly": "mocha --full-trace src/**/__tests__/**/*-test.ts",
+    "testonly": "mocha --full-trace src/**/__tests__/**/*-test.ts -g 'SemanticNonNull halts null propagation'",
     "testonly:cover": "c8 npm run testonly",
     "prettier": "prettier --write --list-different .",
     "prettier:check": "prettier --check .",

src/execution/__tests__/executor-test.ts

@@ -16,12 +16,16 @@ import {
   GraphQLNonNull,
   GraphQLObjectType,
   GraphQLScalarType,
+  GraphQLSemanticNonNull,
+  GraphQLSemanticOptional,
   GraphQLUnionType,
 } from '../../type/definition';
 import { GraphQLBoolean, GraphQLInt, GraphQLString } from '../../type/scalars';
 import { GraphQLSchema } from '../../type/schema';
 
 import { execute, executeSync } from '../execute';
+import { GraphQLError } from '../../error';
+import { ExecutableDefinitionNode, FieldNode, SelectionSetNode } from '../../language';
 
 describe('Execute: Handles basic execution tasks', () => {
   it('throws if no document is provided', () => {
@@ -1323,3 +1327,152 @@ describe('Execute: Handles basic execution tasks', () => {
     expect(possibleTypes).to.deep.equal([fooObject]);
   });
 });
+
+describe('Execute: Handles Semantic Nullability', () => {
+  const DeepDataType = new GraphQLObjectType({
+    name: 'DeepDataType',
+    fields: {
+      f: { type: new GraphQLNonNull(GraphQLString) }
+    },
+  });
+
+  const DataType: GraphQLObjectType = new GraphQLObjectType({
+    name: 'DataType',
+    fields: () => ({
+      a: { type: new GraphQLSemanticOptional(GraphQLString) },
+      b: { type: new GraphQLSemanticNonNull(GraphQLString) },
+      c: { type: new GraphQLNonNull(GraphQLString) },
+      d: { type: new GraphQLSemanticNonNull(DeepDataType) }
+    }),
+  });
+
+  it('SemanticNonNull throws error on null without error', async () => {
+    const data = {
+      a: () => 'Apple',
+      b: () => null,
+      c: () => 'Cookie'
+    };
+  
+    const document = parse(`
+      query {
+        b
+      }
+    `);
+
+    const result = await execute({
+      schema: new GraphQLSchema({ query: DataType }),
+      document,
+      rootValue: data,
+    });
+
+    let executable = document.definitions?.values().next().value as ExecutableDefinitionNode;
+    let selectionSet = executable.selectionSet.selections.values().next().value;
+
+    expect(result).to.deep.equal({
+      data: {
+        b: null
+      },
+      errors: [
+        new GraphQLError(
+          'Cannot return null for semantic-non-nullable field DataType.b.',
+          {
+            nodes: selectionSet,
+            path: ['b']
+          }
+        )
+      ]
+    });
+  });
+
+  it('SemanticNonNull succeeds on null with error', async () => {
+    const data = {
+      a: () => 'Apple',
+      b: () => { throw new Error(
+        `Something went wrong`,
+      ); },
+      c: () => 'Cookie'
+    };
+  
+    const document = parse(`
+      query {
+        b
+      }
+    `);
+
+    let executable = document.definitions?.values().next().value as ExecutableDefinitionNode;
+    let selectionSet = executable.selectionSet.selections.values().next().value;
+
+    const result = await execute({
+      schema: new GraphQLSchema({ query: DataType }),
+      document,
+      rootValue: data,
+    });
+
+    expect(result).to.deep.equal({
+      data: {
+        b: null
+      },
+      errors: [
+        new GraphQLError(
+          'Something went wrong',
+          {
+            nodes: selectionSet,
+            path: ['b']
+          }
+        )
+      ]
+    });
+  });
+
+  it('SemanticNonNull halts null propagation', async () => {
+    const data = {
+      a: () => 'Apple',
+      b: () => null,
+      c: () => 'Cookie',
+      d: () => {
+        f: () => null
+      }
+    };
+  
+    const document = parse(`
+      query {
+        d {
+          f
+        }
+      }
+    `);
+
+    const result = await execute({
+      schema: new GraphQLSchema({ query: DataType }),
+      document,
+      rootValue: data,
+    });
+
+    let executable = document.definitions?.values().next().value as ExecutableDefinitionNode;
+    let dSelectionSet = executable.selectionSet.selections.values().next().value as FieldNode;
+    let fSelectionSet = dSelectionSet.selectionSet?.selections.values().next().value;
+
+    expect(result).to.deep.equal({
+      data: {
+        d: null
+      },
+      errors: [
+        new GraphQLError(
+          'Cannot return null for non-nullable field DeepDataType.f.',
+          {
+            nodes: fSelectionSet,
+            path: ['d', 'f']
+          }
+        )
+      ]
+    });
+  });
+
+  it('SemanticOptional allows null values', async () => {
+
+  });
+
+  it('SemanticOptional allows non-null values', async () => {
+
+  });
+});

src/execution/execute.ts

@@ -44,6 +44,7 @@ import {
   isNonNullType,
   isObjectType,
   isSemanticNonNullType,
+  isSemanticOptionalType,
 } from '../type/definition';
 import {
   SchemaMetaFieldDef,
@@ -650,9 +651,12 @@ function completeValue(
     throw result;
   }
 
+  console.log("anything", path);
+
   // If field type is NonNull, complete for inner type, and throw field error
   // if result is null.
   if (isNonNullType(returnType)) {
+    console.log("is non null");
     const completed = completeValue(
       exeContext,
       returnType.ofType,
@@ -670,8 +674,9 @@ function completeValue(
   }
 
   // If field type is SemanticNonNull, complete for inner type, and throw field error
-  // if result is null.
+  // if result is null and an error doesn't exist.
   if (isSemanticNonNullType(returnType)) {
+    console.log("Is semantic non null")
     const completed = completeValue(
       exeContext,
       returnType.ofType,
@@ -688,8 +693,21 @@ function completeValue(
     return completed;
   }
 
+  // If field type is SemanticOptional, complete for inner type
+  if (isSemanticOptionalType(returnType)) {
+    return completeValue(
+      exeContext,
+      returnType.ofType,
+      fieldNodes,
+      info,
+      path,
+      result,
+    );
+  }
+
   // If result value is null or undefined then return null.
   if (result == null) {
+    console.log("is null")
     return null;
   }
 
@@ -708,12 +726,14 @@ 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)) {
+    console.log("is leaf")
     return completeLeafValue(returnType, result);
   }
 
   // If field type is an abstract type, Interface or Union, determine the
   // runtime Object type and complete for that type.
   if (isAbstractType(returnType)) {
+    console.log("is abstract")
     return completeAbstractValue(
       exeContext,
       returnType,
@@ -726,6 +746,7 @@ function completeValue(
 
   // If field type is Object, execute and complete all sub-selections.
   if (isObjectType(returnType)) {
+    console.log("is object")
     return completeObjectValue(
       exeContext,
       returnType,

src/type/definition.ts

@@ -75,7 +75,16 @@ export type GraphQLType =
       | GraphQLEnumType
       | GraphQLInputObjectType
       | GraphQLList<GraphQLType>
-    >;
+    >
+  | GraphQLSemanticOptional<
+      | GraphQLScalarType
+      | GraphQLObjectType
+      | GraphQLInterfaceType
+      | GraphQLUnionType
+      | GraphQLEnumType
+      | GraphQLInputObjectType
+      | GraphQLList<GraphQLType>
+  >;
 
 export function isType(type: unknown): type is GraphQLType {
   return (
@@ -239,6 +248,32 @@ export function assertSemanticNonNullType(
   return type;
 }
 
+export function isSemanticOptionalType(
+  type: GraphQLInputType,
+): type is GraphQLSemanticOptional<GraphQLInputType>;
+export function isSemanticOptionalType(
+  type: GraphQLOutputType,
+): type is GraphQLSemanticOptional<GraphQLOutputType>;
+export function isSemanticOptionalType(
+  type: unknown,
+): type is GraphQLSemanticOptional<GraphQLType>;
+export function isSemanticOptionalType(
+  type: unknown,
+): type is GraphQLSemanticOptional<GraphQLType> {
+  return instanceOf(type, GraphQLSemanticOptional);
+}
+
+export function assertSemanticOptionalType(
+  type: unknown,
+): GraphQLSemanticOptional<GraphQLType> {
+  if (!isSemanticOptionalType(type)) {
+    throw new Error(
+      `Expected ${inspect(type)} to be a GraphQL Semantic-Non-Null type.`,
+    );
+  }
+  return type;
+}
+
 /**
  * These types may be used as input types for arguments and directives.
  */
@@ -502,7 +537,56 @@ export class GraphQLSemanticNonNull<T extends GraphQLNullableType> {
   }
 
   toString(): string {
-    return String(this.ofType) + '*';
+    return String(this.ofType);
+  }
+
+  toJSON(): string {
+    return this.toString();
+  }
+}
+
+/**
+ * Semantic-Non-Null Type Wrapper
+ *
+ * A semantic-non-null is a wrapping type which points to another type.
+ * Semantic-non-null types enforce that their values are never null unless
+ * caused by an error being raised. It is useful for fields which you can make
+ * a guarantee on non-nullability in a no-error case, for example when you know
+ * that a related entity must exist (but acknowledge that retrieving it may
+ * produce an error).
+ *
+ * Example:
+ *
+ * ```ts
+ * const RowType = new GraphQLObjectType({
+ *   name: 'Row',
+ *   fields: () => ({
+ *     email: { type: new GraphQLSemanticNonNull(GraphQLString) },
+ *   })
+ * })
+ * ```
+ * Note: the enforcement of non-nullability occurs within the executor.
+ *
+ * @experimental
+ */
+export class GraphQLSemanticOptional<T extends GraphQLNullableType> {
+  readonly ofType: T;
+
+  constructor(ofType: T) {
+    devAssert(
+      isNullableType(ofType),
+      `Expected ${inspect(ofType)} to be a GraphQL nullable type.`,
+    );
+
+    this.ofType = ofType;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'GraphQLSemanticOptional';
+  }
+
+  toString(): string {
+    return String(this.ofType) + '?';
   }
 
   toJSON(): string {
@@ -517,10 +601,11 @@ export class GraphQLSemanticNonNull<T extends GraphQLNullableType> {
 export type GraphQLWrappingType =
   | GraphQLList<GraphQLType>
   | GraphQLNonNull<GraphQLType>
-  | GraphQLSemanticNonNull<GraphQLType>;
+  | GraphQLSemanticNonNull<GraphQLType>
+  | GraphQLSemanticOptional<GraphQLType>;
 
 export function isWrappingType(type: unknown): type is GraphQLWrappingType {
-  return isListType(type) || isNonNullType(type) || isSemanticNonNullType(type);
+  return isListType(type) || isNonNullType(type) || isSemanticNonNullType(type) || isSemanticOptionalType(type);
 }
 
 export function assertWrappingType(type: unknown): GraphQLWrappingType {