represent root path as an object rather than undefined

so that the root path can also be weakly memoized

Author: yaacovCR

src/execution/__tests__/executor-test.ts

@@ -5,7 +5,7 @@ import { expectJSON } from '../../__testUtils__/expectJSON.js';
 import { resolveOnNextTick } from '../../__testUtils__/resolveOnNextTick.js';
 
 import { inspect } from '../../jsutils/inspect.js';
-import type { Path } from '../../jsutils/Path.js';
+import type { Path, Root } from '../../jsutils/Path.js';
 
 import { Kind } from '../../language/kinds.js';
 import { parse } from '../../language/parser.js';
@@ -251,14 +251,13 @@ describe('Execute: Handles basic execution tasks', () => {
     ]);
 
     expect(resolvedInfo?.path).to.deep.include({
-      prev: undefined,
       key: 'result',
       typename: 'Test',
     });
   });
 
   it('populates path correctly with complex types', () => {
-    let path: Path | undefined;
+    let path: Path | Root | undefined;
     const someObject = new GraphQLObjectType({
       name: 'SomeObject',
       fields: {
@@ -306,15 +305,14 @@ describe('Execute: Handles basic execution tasks', () => {
       typename: 'SomeObject',
     });
 
-    expect(path?.prev).to.deep.include({
+    expect((path as Path).prev).to.deep.include({
       key: 0,
       typename: undefined,
     });
 
-    expect(path?.prev?.prev).to.deep.include({
+    expect(((path as Path).prev as Path).prev).to.deep.include({
       key: 'l1',
       typename: 'SomeQuery',
-      prev: undefined,
     });
   });
 

src/execution/execute.ts

@@ -7,8 +7,8 @@ import { isPromise } from '../jsutils/isPromise.js';
 import type { Maybe } from '../jsutils/Maybe.js';
 import { memoize3 } from '../jsutils/memoize3.js';
 import type { ObjMap } from '../jsutils/ObjMap.js';
-import type { Path, PathFactory } from '../jsutils/Path.js';
-import { createPathFactory, pathToArray } from '../jsutils/Path.js';
+import type { Path } from '../jsutils/Path.js';
+import { pathToArray, Root } from '../jsutils/Path.js';
 import { promiseForObject } from '../jsutils/promiseForObject.js';
 import type { PromiseOrValue } from '../jsutils/PromiseOrValue.js';
 import { promiseReduce } from '../jsutils/promiseReduce.js';
@@ -121,10 +121,10 @@ export interface ExecutionContext {
   fieldResolver: GraphQLFieldResolver<any, any>;
   typeResolver: GraphQLTypeResolver<any, any>;
   subscribeFieldResolver: GraphQLFieldResolver<any, any>;
-  addPath: PathFactory;
+  root: Root;
   errors: Array<GraphQLError>;
   subsequentPayloads: Set<AsyncPayloadRecord>;
-  branches: WeakMap<GroupedFieldSet, Set<Path | undefined>>;
+  branches: WeakMap<GroupedFieldSet, Set<Path | Root>>;
 }
 
 /**
@@ -502,7 +502,7 @@ export function buildExecutionContext(
     fieldResolver: fieldResolver ?? defaultFieldResolver,
     typeResolver: typeResolver ?? defaultTypeResolver,
     subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
-    addPath: createPathFactory(),
+    root: new Root(),
     subsequentPayloads: new Set(),
     branches: new WeakMap(),
     errors: [],
@@ -516,7 +516,7 @@ function buildPerEventExecutionContext(
   return {
     ...exeContext,
     rootValue: payload,
-    addPath: createPathFactory(),
+    root: new Root(),
     subsequentPayloads: new Set(),
     branches: new WeakMap(),
     errors: [],
@@ -526,7 +526,7 @@ function buildPerEventExecutionContext(
 function shouldBranch(
   groupedFieldSet: GroupedFieldSet,
   exeContext: ExecutionContext,
-  path: Path | undefined,
+  path: Path | Root,
 ): boolean {
   const set = exeContext.branches.get(groupedFieldSet);
   if (set === undefined) {
@@ -563,7 +563,7 @@ function executeOperation(
     rootType,
     operation,
   );
-  const path = undefined;
+  const path = new Root();
   let result;
 
   switch (operation.operation) {
@@ -622,13 +622,13 @@ function executeFieldsSerially(
   exeContext: ExecutionContext,
   parentType: GraphQLObjectType,
   sourceValue: unknown,
-  path: Path | undefined,
+  path: Path | Root,
   groupedFieldSet: GroupedFieldSet,
 ): PromiseOrValue<ObjMap<unknown>> {
   return promiseReduce(
     groupedFieldSet,
     (results, [responseName, fieldGroup]) => {
-      const fieldPath = exeContext.addPath(path, responseName, parentType.name);
+      const fieldPath = path.addPath(responseName, parentType.name);
 
       if (!shouldExecute(fieldGroup)) {
         return results;
@@ -672,7 +672,7 @@ function executeFields(
   exeContext: ExecutionContext,
   parentType: GraphQLObjectType,
   sourceValue: unknown,
-  path: Path | undefined,
+  path: Path | Root,
   groupedFieldSet: GroupedFieldSet,
   asyncPayloadRecord?: AsyncPayloadRecord,
 ): PromiseOrValue<ObjMap<unknown>> {
@@ -681,7 +681,7 @@ function executeFields(
 
   try {
     for (const [responseName, fieldGroup] of groupedFieldSet) {
-      const fieldPath = exeContext.addPath(path, responseName, parentType.name);
+      const fieldPath = path.addPath(responseName, parentType.name);
 
       if (shouldExecute(fieldGroup, asyncPayloadRecord?.deferDepth)) {
         const result = executeField(
@@ -1121,7 +1121,7 @@ async function completeAsyncIteratorValue(
       break;
     }
 
-    const itemPath = exeContext.addPath(path, index, undefined);
+    const itemPath = path.addPath(index, undefined);
     let iteration;
     try {
       // eslint-disable-next-line no-await-in-loop
@@ -1207,7 +1207,7 @@ function completeListValue(
   for (const item of result) {
     // No need to modify the info object containing the path,
     // since from here on it is not ever accessed by resolver functions.
-    const itemPath = exeContext.addPath(path, index, undefined);
+    const itemPath = path.addPath(index, undefined);
 
     if (
       stream &&
@@ -1798,7 +1798,7 @@ function executeSubscription(
     );
   }
 
-  const path = exeContext.addPath(undefined, responseName, rootType.name);
+  const path = exeContext.root.addPath(responseName, rootType.name);
   const info = buildResolveInfo(
     exeContext,
     fieldDef,
@@ -1859,7 +1859,7 @@ function executeDeferredFragment(
   sourceValue: unknown,
   groupedFieldSet: GroupedFieldSet,
   newDeferDepth: number,
-  path?: Path,
+  path: Path | Root,
   parentContext?: AsyncPayloadRecord,
 ): void {
   const asyncPayloadRecord = new DeferredFragmentRecord({
@@ -2079,7 +2079,7 @@ async function executeStreamIterator(
   let previousAsyncPayloadRecord = parentContext ?? undefined;
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    const itemPath = exeContext.addPath(path, index, undefined);
+    const itemPath = path.addPath(index, undefined);
     const asyncPayloadRecord = new StreamRecord({
       path: itemPath,
       deferDepth,
@@ -2282,7 +2282,7 @@ class DeferredFragmentRecord {
   _exeContext: ExecutionContext;
   _resolve?: (arg: PromiseOrValue<ObjMap<unknown> | null>) => void;
   constructor(opts: {
-    path: Path | undefined;
+    path: Path | Root;
     deferDepth: number | undefined;
     parentContext: AsyncPayloadRecord | undefined;
     exeContext: ExecutionContext;
@@ -2330,7 +2330,7 @@ class StreamRecord {
   _exeContext: ExecutionContext;
   _resolve?: (arg: PromiseOrValue<Array<unknown> | null>) => void;
   constructor(opts: {
-    path: Path | undefined;
+    path: Path | Root;
     deferDepth: number | undefined;
     iterator?: AsyncIterator<unknown>;
     parentContext: AsyncPayloadRecord | undefined;

src/jsutils/Path.ts

@@ -1,17 +1,40 @@
-import type { Maybe } from './Maybe.js';
+/**
+ * @internal
+ */
+export class Root {
+  readonly _subPaths: Map<string | number, Path>;
+
+  constructor() {
+    this._subPaths = new Map();
+  }
+
+  /**
+   * Given a Path and a key, return a new Path containing the new key.
+   */
+  addPath(key: string | number, typeName: string | undefined): Path {
+    let path = this._subPaths.get(key);
+    if (path !== undefined) {
+      return path;
+    }
+
+    path = new Path(this, key, typeName);
+    this._subPaths.set(key, path);
+    return path;
+  }
+}
 
 /**
  * @internal
  */
 export class Path {
-  readonly prev: Path | undefined;
+  readonly prev: Path | Root;
   readonly key: string | number;
   readonly typename: string | undefined;
 
   readonly _subPaths: Map<string | number, Path>;
 
   constructor(
-    prev: Path | undefined,
+    prev: Path | Root,
     key: string | number,
     typename: string | undefined,
   ) {
@@ -40,37 +63,13 @@ export class Path {
  * Given a Path, return an Array of the path keys.
  */
 export function pathToArray(
-  path: Maybe<Readonly<Path>>,
+  path: Readonly<Path | Root>,
 ): Array<string | number> {
   const flattened = [];
   let curr = path;
-  while (curr) {
+  while (curr instanceof Path) {
     flattened.push(curr.key);
     curr = curr.prev;
   }
   return flattened.reverse();
 }
-
-export type PathFactory = (
-  path: Path | undefined,
-  key: string | number,
-  typeName: string | undefined,
-) => Path;
-
-export function createPathFactory(): PathFactory {
-  const paths = new Map<string, Path>();
-  return (path, key, typeName) => {
-    if (path !== undefined) {
-      return path.addPath(key, typeName);
-    }
-
-    let newPath = paths.get(key as string);
-    if (newPath !== undefined) {
-      return newPath;
-    }
-
-    newPath = new Path(undefined, key, typeName);
-    paths.set(key as string, newPath);
-    return newPath;
-  };
-}

src/jsutils/__tests__/Path-test.ts

@@ -1,21 +1,22 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
-import { Path, pathToArray } from '../Path.js';
+import { Path, pathToArray, Root } from '../Path.js';
 
 describe('Path', () => {
   it('can create a Path', () => {
-    const first = new Path(undefined, 1, 'First');
+    const root = new Root();
+    const first = new Path(root, 1, 'First');
 
     expect(first).to.deep.include({
-      prev: undefined,
+      prev: root,
       key: 1,
       typename: 'First',
     });
   });
 
   it('can add a new key to an existing Path', () => {
-    const first = new Path(undefined, 1, 'First');
+    const first = new Path(new Root(), 1, 'First');
     const second = first.addPath('two', 'Second');
 
     expect(second).to.deep.include({
@@ -26,7 +27,7 @@ describe('Path', () => {
   });
 
   it('can convert a Path to an array of its keys', () => {
-    const root = new Path(undefined, 0, 'Root');
+    const root = new Path(new Root(), 0, 'Root');
     const first = root.addPath('one', 'First');
     const second = first.addPath(2, 'Second');
 

src/utilities/coerceInputValue.ts

@@ -3,7 +3,8 @@ import { inspect } from '../jsutils/inspect.js';
 import { invariant } from '../jsutils/invariant.js';
 import { isIterableObject } from '../jsutils/isIterableObject.js';
 import { isObjectLike } from '../jsutils/isObjectLike.js';
-import { Path, pathToArray } from '../jsutils/Path.js';
+import type { Path } from '../jsutils/Path.js';
+import { pathToArray, Root } from '../jsutils/Path.js';
 import { printPathArray } from '../jsutils/printPathArray.js';
 import { suggestionList } from '../jsutils/suggestionList.js';
 
@@ -31,7 +32,7 @@ export function coerceInputValue(
   type: GraphQLInputType,
   onError: OnErrorCB = defaultOnError,
 ): unknown {
-  return coerceInputValueImpl(inputValue, type, onError, undefined);
+  return coerceInputValueImpl(inputValue, type, onError, new Root());
 }
 
 function defaultOnError(
@@ -47,21 +48,11 @@ function defaultOnError(
   throw error;
 }
 
-function addPath(
-  path: Path | undefined,
-  key: string | number,
-  typeName: string | undefined,
-): Path {
-  return path
-    ? path.addPath(key, typeName)
-    : new Path(undefined, key, typeName);
-}
-
 function coerceInputValueImpl(
   inputValue: unknown,
   type: GraphQLInputType,
   onError: OnErrorCB,
-  path: Path | undefined,
+  path: Path | Root,
 ): unknown {
   if (isNonNullType(type)) {
     if (inputValue != null) {
@@ -86,7 +77,7 @@ function coerceInputValueImpl(
     const itemType = type.ofType;
     if (isIterableObject(inputValue)) {
       return Array.from(inputValue, (itemValue, index) => {
-        const itemPath = addPath(path, index, undefined);
+        const itemPath = path.addPath(index, undefined);
         return coerceInputValueImpl(itemValue, itemType, onError, itemPath);
       });
     }
@@ -130,7 +121,7 @@ function coerceInputValueImpl(
         fieldValue,
         field.type,
         onError,
-        addPath(path, field.name, type.name),
+        path.addPath(field.name, type.name),
       );
     }