refactor: remove root entity capture logic

Yogu · Yogu · commit ce146c32b15c · 2025-10-30T16:18:56.000+01:00
Will replace this with a different approach where we just keep root entities in a variable instead
diff --git a/spec/dev/model/simple.graphqls b/spec/dev/model/simple.graphqls
@@ -50,7 +50,7 @@ type Skill @valueObject {
 }
 
 "A superhero movie"
-type Movie @rootEntity @roles(read: ["logistics-reader"]) {
+type Movie @rootEntity {
     name: String
     "All the heroes starring in this movie"
     heroes: [Hero] @relation
diff --git a/spec/regression/traversal-performance/tests/traversal-performance/aql/RelationAndFieldTraversalWithParent.aql b/spec/regression/traversal-performance/tests/traversal-performance/aql/RelationAndFieldTraversalWithParent.aql
@@ -13,17 +13,11 @@ RETURN {
       IN (
         FOR v_node1, v_edge1, v_path1 IN @var3..@var4 OUTBOUND v_super1 @@supers_roots
         FILTER v_node1 != null
-        RETURN (
-          FOR v_entity1 IN v_node1.`children`[*]
-          RETURN { obj: v_entity1, root: v_node1 }
-        )
+        RETURN v_node1.`children`[*]
       )[**]
-      LET v_root1 = v_child1.`root`
       RETURN {
-        "key": v_child1.`obj`.`key`,
-        "parent": (IS_NULL(v_root1) ? null : {
-          "key": v_root1.`key`
-        })
+        "key": v_child1.`key`,
+        "parent": { __cruddl_runtime_error_code: @var5, __cruddl_runtime_error: @var6 }
       }
     )
   })
diff --git a/spec/regression/traversal-performance/tests/traversal-performance/result.json b/spec/regression/traversal-performance/tests/traversal-performance/result.json
@@ -21,7 +21,7 @@
   "RelationAndFieldTraversalWithParent": {
     "errors": [
       {
-        "message": "AQL: query would use more memory than allowed [node #17: TraversalNode] [node #18: CalculationNode] [node #19: FilterNode] [node #43: SubqueryStartNode] [node #22: FilterNode] [node #23: CalculationNode] [node #24: EnumerateListNode] [node #25: CalculationNode] [node #44: SubqueryEndNode] [node #42: SubqueryEndNode] [node #39: SubqueryStartNode] [node #13: FilterNode] [node #30: CalculationNode] [node #31: EnumerateListNode] [node #33: CalculationNode] [node #40: SubqueryEndNode] [node #36: CalculationNode] [node #37: ReturnNode] (while executing)",
+        "message": "AQL: query would use more memory than allowed [node #17: TraversalNode] [node #18: CalculationNode] [node #19: FilterNode] [node #20: CalculationNode] [node #34: SubqueryEndNode] [node #31: SubqueryStartNode] [node #13: FilterNode] [node #23: CalculationNode] [node #24: EnumerateListNode] [node #25: CalculationNode] [node #32: SubqueryEndNode] [node #28: CalculationNode] [node #29: ReturnNode] (while executing)",
         "locations": [
           {
             "line": 10,
diff --git a/src/authorization/transformers/traversal.ts b/src/authorization/transformers/traversal.ts
@@ -82,7 +82,6 @@ export function transformTraversalQueryNode(
             sourceEntityNode: node.sourceEntityNode,
             relationSegments: filteredRelationSegments,
             fieldSegments: fieldSegments,
-            captureRootEntities: node.captureRootEntity,
         });
     }
 
diff --git a/src/database/arangodb/aql-generator.ts b/src/database/arangodb/aql-generator.ts
@@ -1406,45 +1406,8 @@ register(TraversalQueryNode, (node, context) => {
             // if we have both, it might be beneficial to do the field traversal within the mapping node
             // because it may allow ArangoDB to figure out that only one particular field is of interest, and e.g.
             // discard the root entities earlier
-
-            if (node.captureRootEntity) {
-                if (fieldDepth === 0) {
-                    // fieldSegments.length && fieldDepth === 0 means we only traverse through entity extensions
-                    // actually, shouldn't really occur because a collect path can't end with an entity extension and
-                    // value objects don't capture root entities
-                    // however, we can easily implement this so let's do it
-                    mapFrag = (nodeFrag) =>
-                        aql`{ obj: ${getFieldTraversalFragmentWithoutFlattening(
-                            node.fieldSegments,
-                            nodeFrag,
-                        )}, root: ${nodeFrag}) }`;
-                } else {
-                    // the result of getFieldTraversalFragmentWithoutFlattening() now is a list, so we need to iterate
-                    // over it. if the depth is > 1, we need to flatten the deeper ones so we can do one FOR loop over them
-                    // we still return a list, so we just reduce the depth to 1 and not to 0
-                    const entityVar = aql.variable('entity');
-                    mapFrag = (rootEntityFrag) =>
-                        aqlExt.parenthesizeList(
-                            aql`FOR ${entityVar} IN ${getFlattenFrag(
-                                getFieldTraversalFragmentWithoutFlattening(
-                                    node.fieldSegments,
-                                    rootEntityFrag,
-                                ),
-                                fieldDepth - 1,
-                            )}`,
-                            aql`RETURN { obj: ${entityVar}, root: ${rootEntityFrag} }`,
-                        );
-                    remainingDepth = 1;
-                }
-            } else {
-                mapFrag = (nodeFrag) =>
-                    getFieldTraversalFragmentWithoutFlattening(node.fieldSegments, nodeFrag);
-            }
-        } else {
-            if (node.captureRootEntity) {
-                // doesn't make sense to capture the root entity if we're returning the root entities
-                throw new Error(`captureRootEntity without fieldSegments detected`);
-            }
+            mapFrag = (nodeFrag) =>
+                getFieldTraversalFragmentWithoutFlattening(node.fieldSegments, nodeFrag);
         }
 
         // traversal requires real ids
@@ -1480,11 +1443,6 @@ register(TraversalQueryNode, (node, context) => {
         return getFlattenFrag(frag, remainingDepth - 1);
     }
 
-    if (node.captureRootEntity) {
-        // doesn't make sense (and isn't possible) to capture the root entity if we're not even crossing root entities
-        throw new Error(`captureRootEntity without relationSegments detected`);
-    }
-
     if (node.sourceIsList) {
         // don't need, don't bother
         throw new Error(`sourceIsList without relationSegments detected`);
diff --git a/src/database/inmemory/js-generator.ts b/src/database/inmemory/js-generator.ts
@@ -857,12 +857,6 @@ register(TraversalQueryNode, (node, context) => {
     const relationTraversalReturnsList = isList;
     let rootVar: JSVariable | undefined;
     let relationFrag: JSFragment | undefined;
-    if (node.captureRootEntity) {
-        relationFrag = currentFrag;
-        rootVar = js.variable('root');
-        currentFrag = rootVar;
-        isList = false; // we're going to be within the mapper, so not in a list
-    }
 
     for (const segment of node.fieldSegments) {
         if (isList) {
@@ -897,37 +891,6 @@ register(TraversalQueryNode, (node, context) => {
         }
     }
 
-    if (relationFrag && rootVar && node.captureRootEntity) {
-        if (relationTraversalReturnsList) {
-            if (node.fieldSegments.some((f) => f.isListSegment)) {
-                const accVar = js.variable('acc');
-                const objVar = js.variable('obj');
-                const mapper = js`${objVar} => ({ obj: ${objVar}, root: ${rootVar} })`;
-                const reducer = js`(${accVar}, ${rootVar}) => ${accVar}.concat((${currentFrag}).map(${mapper}))`;
-                currentFrag = js`${relationFrag}.reduce(${reducer}, [])`;
-            } else {
-                const mapper = js`${rootVar} => ({ obj: ${currentFrag}, root: ${rootVar} })`;
-                currentFrag = js`${relationFrag}.map(${mapper})`;
-            }
-        } else {
-            if (node.fieldSegments.some((f) => f.isListSegment)) {
-                const objVar = js.variable('obj');
-                const mapper = js`${objVar} => ({ obj: ${objVar}, root: ${rootVar} })`;
-                currentFrag = jsExt.evaluatingLambda(
-                    rootVar,
-                    js`(${currentFrag}).map(${mapper})`,
-                    relationFrag,
-                );
-            } else {
-                currentFrag = jsExt.evaluatingLambda(
-                    rootVar,
-                    js`({ obj: ${currentFrag}, root: ${rootVar} })`,
-                    relationFrag,
-                );
-            }
-        }
-    }
-
     if (node.alwaysProduceList && !isList) {
         const resultVar = js.variable('result');
         currentFrag = jsExt.evaluatingLambda(
diff --git a/src/query-tree/queries.ts b/src/query-tree/queries.ts
@@ -163,7 +163,6 @@ interface TraversalQueryNodeParams {
     readonly alwaysProduceList?: boolean;
     readonly relationSegments: ReadonlyArray<RelationSegment>;
     readonly fieldSegments: ReadonlyArray<FieldSegment>;
-    readonly captureRootEntities: boolean;
 }
 
 /**
@@ -174,7 +173,6 @@ export class TraversalQueryNode extends QueryNode {
     readonly sourceEntityNode: QueryNode;
     readonly relationSegments: ReadonlyArray<RelationSegment>;
     readonly fieldSegments: ReadonlyArray<FieldSegment>;
-    readonly captureRootEntity: boolean;
 
     /**
      * Specifies if sourceEntityNode resolves to a list of entities instead of a single entity
@@ -189,12 +187,6 @@ export class TraversalQueryNode extends QueryNode {
     constructor(params: TraversalQueryNodeParams) {
         super();
 
-        if (params.captureRootEntities && (!params.relationSegments || !params.fieldSegments)) {
-            throw new Error(
-                `A TraversalQueryNode with captureRootEntity=true requires both relationSegments and fieldSegments`,
-            );
-        }
-
         if (params.sourceIsList && !params.relationSegments) {
             // only need this, so keep it simpler
             throw new Error(
@@ -205,7 +197,6 @@ export class TraversalQueryNode extends QueryNode {
         this.sourceEntityNode = params.sourceEntityNode;
         this.relationSegments = params.relationSegments;
         this.fieldSegments = params.fieldSegments;
-        this.captureRootEntity = params.captureRootEntities;
         this.sourceIsList = params.sourceIsList ?? false;
         this.alwaysProduceList = params.alwaysProduceList ?? false;
         this.entitiesIdentifierKind =
@@ -216,9 +207,7 @@ export class TraversalQueryNode extends QueryNode {
         const segments = [...this.relationSegments, ...this.fieldSegments];
         return (
             `traverse ${segments.map((s) => this.describeSegment(s)).join('.')}` +
-            `from ${this.sourceEntityNode.describe()}${this.sourceIsList ? ' (as list)' : ''}${
-                this.captureRootEntity ? ` into { obj, root }` : ''
-            }${this.alwaysProduceList ? ` as list` : ''}`
+            `from ${this.sourceEntityNode.describe()}${this.sourceIsList ? ' (as list)' : ''}${this.alwaysProduceList ? ` as list` : ''}`
         );
     }
 
diff --git a/src/schema-generation/field-nodes.ts b/src/schema-generation/field-nodes.ts
@@ -14,7 +14,6 @@ import {
     FollowEdgeQueryNode,
     NullQueryNode,
     ObjectQueryNode,
-    PropertyAccessQueryNode,
     QueryNode,
     RootEntityIDQueryNode,
     SafeListQueryNode,
@@ -24,7 +23,7 @@ import {
     VariableQueryNode,
 } from '../query-tree';
 import { ID_FIELD } from '../schema/constants';
-import { GraphQLOffsetDateTime, TIMESTAMP_PROPERTY } from '../schema/scalars/offset-date-time';
+import { GraphQLOffsetDateTime } from '../schema/scalars/offset-date-time';
 import { getScalarFilterValueNode } from './filter-input-types/filter-fields';
 import { and } from './utils/input-types';
 
@@ -33,7 +32,7 @@ export function createFieldNode(
     sourceNode: QueryNode,
     options: {
         skipNullFallbackForEntityExtensions?: boolean;
-        captureRootEntitiesOnCollectFields?: boolean;
+        rootEntityVar?: VariableQueryNode;
     } = {},
 ): QueryNode {
     // make use of the fact that field access on non-objects is NULL, so that type checks for OBJECT are redundant
@@ -61,7 +60,6 @@ export function createFieldNode(
             sourceEntityNode: sourceNode,
             relationSegments,
             fieldSegments,
-            captureRootEntities: !!options.captureRootEntitiesOnCollectFields,
         });
 
         if (!field.aggregationOperator) {
diff --git a/src/schema-generation/filter-augmentation.ts b/src/schema-generation/filter-augmentation.ts
@@ -36,8 +36,6 @@ export class FilterAugmentation {
                     filterValue: args[FILTER_ARG],
                     filterType,
                     itemType,
-                    objectNodeCallback: (itemNode) =>
-                        this.rootFieldHelper.getRealItemNode(itemNode, info),
                 });
             },
         };
diff --git a/src/schema-generation/flex-search-post-filter-augmentation.ts b/src/schema-generation/flex-search-post-filter-augmentation.ts
@@ -68,8 +68,6 @@ export class FlexSearchPostFilterAugmentation {
                     filterValue: filterValue || legacyFilterValue,
                     filterType,
                     itemType,
-                    objectNodeCallback: (itemNode) =>
-                        this.rootFieldHelper.getRealItemNode(itemNode, info),
                 });
             },
         };
diff --git a/src/schema-generation/order-by-and-pagination-augmentation.ts b/src/schema-generation/order-by-and-pagination-augmentation.ts
@@ -10,8 +10,8 @@ import {
     ConstBoolQueryNode,
     INVALID_CURSOR_ERROR,
     LiteralQueryNode,
-    NOT_SUPPORTED_ERROR,
     NoImplicitlyTruncatedListValidator,
+    NOT_SUPPORTED_ERROR,
     OrderDirection,
     OrderSpecification,
     PreExecQueryParms,
@@ -134,7 +134,6 @@ export class OrderByAndPaginationAugmentation {
             resolve: (sourceNode, args, info) => {
                 let listNode = schemaField.resolve(sourceNode, args, info);
                 let itemVariable = new VariableQueryNode(decapitalize(type.name));
-                let objectNode = this.rootFieldHelper.getRealItemNode(itemVariable, info);
 
                 let maxCount: number | undefined = args[FIRST_ARG];
 
@@ -190,7 +189,6 @@ export class OrderByAndPaginationAugmentation {
                         ? undefined
                         : listNode.filterNode;
                     itemVariable = listNode.itemVariable;
-                    objectNode = this.rootFieldHelper.getRealItemNode(itemVariable, info);
                     listNode = listNode.listNode;
                 }
 
@@ -259,7 +257,7 @@ export class OrderByAndPaginationAugmentation {
                         afterArg,
                         // pagination acts on the listNode (which is a FlexSearchQueryNode) and not on the resulting
                         // TransformListQueryNode, so we need to use listNode.itemVariable in the pagination filter
-                        itemNode: this.rootFieldHelper.getRealItemNode(listNode.itemVariable, info),
+                        itemNode: listNode.itemVariable,
                         orderByValues,
                         isFlexSearch: true,
                     });
@@ -280,7 +278,7 @@ export class OrderByAndPaginationAugmentation {
                         : getOrderByValues(args, orderByType, { isAbsoluteOrderRequired });
                     paginationFilter = this.createPaginationFilterNode({
                         afterArg,
-                        itemNode: objectNode,
+                        itemNode: itemVariable,
                         orderByValues,
                         isFlexSearch: false,
                     });
@@ -290,7 +288,7 @@ export class OrderByAndPaginationAugmentation {
                 const orderBy = !orderByType
                     ? OrderSpecification.UNORDERED
                     : new OrderSpecification(
-                          orderByValues.map((value) => value.getClause(objectNode)),
+                          orderByValues.map((value) => value.getClause(itemVariable)),
                       );
 
                 if (
@@ -336,7 +334,6 @@ export class OrderByAndPaginationAugmentation {
                     const optimizedQueryNode = this.getPaginatedNodeUsingMultiIndexOptimization({
                         orderBy,
                         itemVariable,
-                        objectNode,
                         orderByType,
                         listNode,
                         args,
@@ -406,7 +403,6 @@ export class OrderByAndPaginationAugmentation {
         args,
         orderByType,
         itemVariable,
-        objectNode,
         listNode,
         orderBy,
         maxCount,
@@ -415,7 +411,6 @@ export class OrderByAndPaginationAugmentation {
         args: { [name: string]: any };
         orderByType: OrderByEnumType;
         itemVariable: VariableQueryNode;
-        objectNode: QueryNode;
         listNode: QueryNode;
         orderBy: OrderSpecification;
         maxCount: number | undefined;
@@ -454,7 +449,7 @@ export class OrderByAndPaginationAugmentation {
                 );
             }
             const cursorValue = cursorObj[cursorProperty];
-            const valueNode = clause.getValueNode(objectNode);
+            const valueNode = clause.getValueNode(itemVariable);
 
             const operator =
                 clause.direction == OrderDirection.ASCENDING
diff --git a/src/schema-generation/output-type-generator.ts b/src/schema-generation/output-type-generator.ts
@@ -254,9 +254,8 @@ export class OutputTypeGenerator {
             return rootHelperResult.resultNode;
         }
 
-        return createFieldNode(field, rootHelperResult.sourceNode, {
+        return createFieldNode(field, sourceNode, {
             skipNullFallbackForEntityExtensions: true,
-            captureRootEntitiesOnCollectFields: rootHelperResult.captureRootEntitiesOnCollectFields,
         });
     }
 
diff --git a/src/schema-generation/root-field-helper.ts b/src/schema-generation/root-field-helper.ts
diff --git a/src/schema-generation/utils/filtering.ts b/src/schema-generation/utils/filtering.ts
diff --git a/src/schema-generation/utils/relations.ts b/src/schema-generation/utils/relations.ts

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ type Skill @valueObject {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`"A superhero movie"`
`53`		`-type Movie @rootEntity @roles(read: ["logistics-reader"]) {`
	`53`	`+type Movie @rootEntity {`
`54`	`54`	`name: String`
`55`	`55`	`"All the heroes starring in this movie"`
`56`	`56`	`heroes: [Hero] @relation`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`	`"RelationAndFieldTraversalWithParent": {`
`22`	`22`	`"errors": [`
`23`	`23`	`{`
`24`		- "message": "AQL: query would use more memory than allowed [node #17: TraversalNode] [node #18: CalculationNode] [node #19: FilterNode] [node #43: SubqueryStartNode] [node #22: FilterNode] [node #23: CalculationNode] [node #24: EnumerateListNode] [node #25: CalculationNode] [node #44: SubqueryEndNode] [node #42: SubqueryEndNode] [node #39: SubqueryStartNode] [node #13: FilterNode] [node #30: CalculationNode] [node #31: EnumerateListNode] [node #33: CalculationNode] [node #40: SubqueryEndNode] [node #36: CalculationNode] [node #37: ReturnNode] (while executing)",
	`24`	`+ "message": "AQL: query would use more memory than allowed [node #17: TraversalNode] [node #18: CalculationNode] [node #19: FilterNode] [node #20: CalculationNode] [node #34: SubqueryEndNode] [node #31: SubqueryStartNode] [node #13: FilterNode] [node #23: CalculationNode] [node #24: EnumerateListNode] [node #25: CalculationNode] [node #32: SubqueryEndNode] [node #28: CalculationNode] [node #29: ReturnNode] (while executing)",`
`25`	`25`	`"locations": [`
`26`	`26`	`{`
`27`	`27`	`"line": 10,`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,6 @@ export function transformTraversalQueryNode(`
`82`	`82`	`sourceEntityNode: node.sourceEntityNode,`
`83`	`83`	`relationSegments: filteredRelationSegments,`
`84`	`84`	`fieldSegments: fieldSegments,`
`85`		`- captureRootEntities: node.captureRootEntity,`
`86`	`85`	`});`
`87`	`86`	`}`
`88`	`87`