wip: registerRootNode stuff

Author: Yogu

spec/dev/model/simple.graphqls

@@ -71,6 +71,7 @@ type Movie @rootEntity {
 type Director @rootEntity {
     name: String
     movies: [Movie] @relation(inverseOf: "director")
+    allMissions: [Mission] @collect(path: "movies.heroes.missions", aggregate: DISTINCT)
 }
 
 "A description of a hero suit"

src/schema-generation/field-nodes.ts

@@ -27,13 +27,20 @@ import { GraphQLOffsetDateTime } from '../schema/scalars/offset-date-time';
 import { getScalarFilterValueNode } from './filter-input-types/filter-fields';
 import { and } from './utils/input-types';
 
+export interface CreateFieldNodeOptions {
+    readonly skipNullFallbackForEntityExtensions?: boolean;
+    readonly rootEntityVar?: VariableQueryNode;
+
+    /**
+     * Call this on collect fields that traverse root entities to store a reference to the root entity in the stack
+     */
+    readonly registerRootNode?: (rootNode: QueryNode) => void;
+}
+
 export function createFieldNode(
     field: Field,
     sourceNode: QueryNode,
-    options: {
-        skipNullFallbackForEntityExtensions?: boolean;
-        rootEntityVar?: VariableQueryNode;
-    } = {},
+    options: CreateFieldNodeOptions = {},
 ): QueryNode {
     // make use of the fact that field access on non-objects is NULL, so that type checks for OBJECT are redundant
     // this e.g. reverses the effect of the isEntityExtensionType check below

src/schema-generation/output-type-generator.ts

@@ -256,6 +256,7 @@ export class OutputTypeGenerator {
 
         return createFieldNode(field, sourceNode, {
             skipNullFallbackForEntityExtensions: true,
+            registerRootNode: (rootNode) => rootHelperResult.registerRootNode(rootNode),
         });
     }
 

src/schema-generation/query-node-object-type/context.ts

@@ -7,7 +7,7 @@ import { FieldSelection } from '../../graphql/query-distiller';
  *
  * There usually is a 1:1 relationship between a FieldSelection/FieldRequest and the SelectionToken. However, instances
  * of a FieldSelection do not convey an identity per se. Usage of the SelectionToken class makes it clear that it's not
- * taken for its values bot for the identity within an execution. This is a useful property for caches and external
+ * taken for its values but for the identity within an execution. This is a useful property for caches and external
  * state management.
  */
 export class SelectionToken {

src/schema-generation/root-field-helper.ts

@@ -14,13 +14,20 @@ export interface ProcessFieldResult {
      * If the RootFieldHelper can already resolve this fields, this will be populated with the value.
      */
     readonly resultNode: QueryNode | undefined;
+
+    /**
+     * Call this on collect fields that traverse root entities to store a reference to the root entity in the stack
+     */
+    registerRootNode(rootNode: QueryNode): void;
 }
 
 interface HierarchyStackFrame {
     readonly currentEntityNode?: QueryNode;
     readonly parentEntityFrame?: HierarchyStackFrame;
+
     // keep root explicitly because sometimes, we might have the root entity, but not the parent entity
-    readonly rootEntityNode?: QueryNode;
+    // set by registerRootNode()
+    rootEntityNode?: QueryNode;
 }
 
 export class RootFieldHelper {
@@ -124,6 +131,14 @@ export class RootFieldHelper {
 
         return {
             resultNode: this.tryResolveField(field, hierarchyFrame),
+            registerRootNode(rootNode: QueryNode) {
+                if (hierarchyFrame.rootEntityNode) {
+                    throw new Error(
+                        `Root query node already registered for field "${field.declaringType.name}.${field.name}"`,
+                    );
+                }
+                hierarchyFrame.rootEntityNode = rootNode;
+            },
         };
     }