cruddl 5.0.0-alpha.1 → 5.0.0

package/.github/workflows/ci.yml

@@ -5,7 +5,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        arango-image: ['arangodb:3.12']
+        arango-image: ['arangodb:3.12', 'arangodb:3.12.6']
         node-version: [20.x, 22.x, 24.x, 25.x]
     steps:
       - uses: actions/checkout@v2
@@ -26,11 +26,14 @@ jobs:
     if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     needs: test
+    permissions:
+      id-token: write
+      contents: read
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
-          node-version: 22.x
+          node-version: '24'
           registry-url: https://registry.npmjs.org/
       - run: npm ci
       - run: npm publish --tag next

package/dist/src/cruddl-version.js

@@ -3,5 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CRUDDL_VERSION = void 0;
 // do not modify - this is parsed and changed by the build script
 // explicitly annotating with "string" so typescript won't infer a string literal type
-exports.CRUDDL_VERSION = '5.0.0-alpha.1';
+exports.CRUDDL_VERSION = '5.0.0';
 //# sourceMappingURL=cruddl-version.js.map

package/dist/src/database/arangodb/aql-generator.d.ts

@@ -1,7 +1,7 @@
+import { Clock, IDGenerator } from '../../execution/execution-options';
 import { QueryNode } from '../../query-tree';
 import { FlexSearchTokenizable } from '../database-adapter';
 import { AQLCompoundQuery, AQLFragment } from './aql';
-import { Clock, IDGenerator } from '../../execution/execution-options';
 export interface QueryGenerationOptions {
     /**
      * An interface to determine the current date/time

package/dist/src/database/arangodb/aql-generator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAQLQuery = getAQLQuery;
 exports.generateTokenizationQuery = generateTokenizationQuery;
+const execution_options_1 = require("../../execution/execution-options");
 const model_1 = require("../../model");
 const flex_search_1 = require("../../model/implementation/flex-search");
 const query_tree_1 = require("../../query-tree");
@@ -14,7 +15,6 @@ const like_helpers_1 = require("../like-helpers");
 const aql_1 = require("./aql");
 const arango_basics_1 = require("./arango-basics");
 const arango_search_helpers_1 = require("./schema-migration/arango-search-helpers");
-const execution_options_1 = require("../../execution/execution-options");
 const traversal_helpers_1 = require("./traversal-helpers");
 var AccessType;
 (function (AccessType) {
@@ -299,6 +299,10 @@ register(query_tree_1.ConcatListsQueryNode, (node, context) => {
 register(query_tree_1.VariableQueryNode, (node, context) => {
     return context.getVariable(node);
 });
+register(query_tree_1.HoistableQueryNode, (node, context) => {
+    // if we process a HoistableQueryNode here, the node did not get hoisted, but that's fine too
+    return processNode(node.node, context);
+});
 register(query_tree_1.VariableAssignmentQueryNode, (node, context) => {
     const newContext = context.bindVariable(node.variableNode);
     const tmpVar = newContext.getVariable(node.variableNode);
@@ -367,27 +371,60 @@ register(flex_search_2.FlexSearchQueryNode, (node, context) => {
     return aqlExt.subquery((0, aql_1.aql) `FOR ${itemContext.getVariable(node.itemVariable)}`, (0, aql_1.aql) `IN ${aql_1.aql.collection(viewName)}`, (0, aql_1.aql) `SEARCH ${processNode(node.flexFilterNode, itemContext)}`, node.isOptimisationsDisabled ? (0, aql_1.aql) `OPTIONS { conditionOptimization: 'none' }` : (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemContext.getVariable(node.itemVariable)}`);
 });
 register(query_tree_1.TransformListQueryNode, (node, context) => {
-    let itemContext = context.bindVariable(node.itemVariable);
-    const itemVar = itemContext.getVariable(node.itemVariable);
-    let itemProjectionContext = itemContext;
     // move LET statements up
     // they often occur for value objects / entity extensions
     // this avoids the FIRST() and the subquery which reduces load on the AQL query optimizer
-    let variableAssignments = [];
+    const hoistedAssignments = [];
+    const loopScopedAssignmentNodes = [];
+    const loopScopedVariables = new Set();
+    let currentContext = context;
     let innerNode = node.innerNode;
     const variableAssignmentNodes = [];
     innerNode = (0, utils_1.extractVariableAssignments)(innerNode, variableAssignmentNodes);
     for (const assignmentNode of variableAssignmentNodes) {
+        const referencedVariables = (0, utils_1.getReferencedVariables)(assignmentNode.variableValueNode);
+        const referencesItemVariable = referencedVariables.has(node.itemVariable);
+        let referencesLoopScopedVariable = false;
+        for (const variableNode of loopScopedVariables) {
+            if (referencedVariables.has(variableNode)) {
+                referencesLoopScopedVariable = true;
+                break;
+            }
+        }
+        if (!referencesItemVariable && !referencesLoopScopedVariable) {
+            currentContext = currentContext.bindVariable(assignmentNode.variableNode);
+            const tmpVar = currentContext.getVariable(assignmentNode.variableNode);
+            // ArangoDB will try to move the hoisted variable down to their usages again, even
+            // though that increases memory usage because it requires the subquery to hold the whole
+            // source (root) variable. NOEVAL() forces the optimizer to keep the variable where it's
+            // declared
+            hoistedAssignments.push((0, aql_1.aql) `LET ${tmpVar} = NOEVAL(${processNode(assignmentNode.variableValueNode, currentContext)})`);
+        }
+        else {
+            loopScopedAssignmentNodes.push(assignmentNode);
+            loopScopedVariables.add(assignmentNode.variableNode);
+        }
+    }
+    let itemContext = currentContext.bindVariable(node.itemVariable);
+    const itemVar = itemContext.getVariable(node.itemVariable);
+    let itemProjectionContext = itemContext;
+    const loopScopedAssignments = [];
+    for (const assignmentNode of loopScopedAssignmentNodes) {
         itemProjectionContext = itemProjectionContext.bindVariable(assignmentNode.variableNode);
         const tmpVar = itemProjectionContext.getVariable(assignmentNode.variableNode);
-        variableAssignments.push((0, aql_1.aql) `LET ${tmpVar} = ${processNode(assignmentNode.variableValueNode, itemProjectionContext)}`);
+        loopScopedAssignments.push((0, aql_1.aql) `LET ${tmpVar} = ${processNode(assignmentNode.variableValueNode, itemProjectionContext)}`);
     }
     // TODO aql-perf: set maxProjects to a value > 5?
     // The reduce-extraction-to-projection optimization is crucial to reduce memory usage of queries
     // over large root entities if only some of the fields are queried. The default is to only apply
     // it if 5 or less fields are selected. We probably want to increase this limit
     // (also applies to FollowEdgeQueryNode and TraversalQueryNode)
-    return aqlExt.subquery((0, aql_1.aql) `FOR ${itemVar}`, generateInClauseWithFilterAndOrderAndLimit({ node, context, itemContext, itemVar }), ...variableAssignments, (0, aql_1.aql) `RETURN ${processNode(innerNode, itemProjectionContext)}`);
+    return aqlExt.subquery(...hoistedAssignments, (0, aql_1.aql) `FOR ${itemVar}`, generateInClauseWithFilterAndOrderAndLimit({
+        node,
+        context: currentContext,
+        itemContext,
+        itemVar,
+    }), ...loopScopedAssignments, (0, aql_1.aql) `RETURN ${processNode(innerNode, itemProjectionContext)}`);
 });
 /**
  * Generates an IN... clause for a TransformListQueryNode to be used within a query / subquery (FOR ... IN ...)
@@ -1060,7 +1097,7 @@ register(query_tree_1.TraversalQueryNode, (node, context) => {
                 return processTraversalWithNonListRelationSegmentsAndNonListFieldSegments(node, context);
             }
         }
-        if (node.innerNode && (0, traversal_helpers_1.mightGenerateSubquery)(node.innerNode)) {
+        if (!(0, traversal_helpers_1.supportedAsArrayExpansion)(node, { skipTopLevelChecks: true })) {
             // cannot have subqueries within array expansions, so we need to use a subquery here
             return processTraversalWithRelationAndListFieldSegmentsUsingSubquery(node, context);
         }
@@ -1087,8 +1124,7 @@ register(query_tree_1.TraversalQueryNode, (node, context) => {
         // In the simple case, we can use an array expansion expression instead of a subquery
         // - SORT is not supported by array expressions (documented)
         // - subqueries in array expressions currently cause an internal error in arangodb (3.12.6)
-        if (node.orderBy.isUnordered() &&
-            (!node.innerNode || !(0, traversal_helpers_1.mightGenerateSubquery)(node.innerNode))) {
+        if ((0, traversal_helpers_1.supportedAsArrayExpansion)(node)) {
             return processTraversalWithOnlyFieldSegmentsUsingArrayExpansion(node, context);
         }
         else {
@@ -1100,14 +1136,109 @@ register(query_tree_1.TraversalQueryNode, (node, context) => {
         throw new Error(`TraversalQueryNode must have at least one segment`);
     }
 });
+/**
+ * Extracts three kinds of VariableAssignmentQueryNode from the traversal's innerNode
+ *
+ * Variables that depend on nested traversals etc. are not extracted.
+ */
+function extractTraversalAssignments(node) {
+    if (!node.innerNode) {
+        return {
+            innerNode: undefined,
+            traversalIndependentAssignments: [],
+            rootScopedAssignments: [],
+            itemScopedAssignments: [],
+        };
+    }
+    const extractedAssignments = [];
+    const processedInnerNode = (0, utils_1.extractVariableAssignments)(node.innerNode, extractedAssignments);
+    const traversalIndependentAssignments = [];
+    const rootScopedAssignments = [];
+    const itemScopedAssignments = [];
+    const rootScopedVariables = [node.rootEntityVariable];
+    const itemScopedVariables = [node.itemVariable];
+    for (const assignmentNode of extractedAssignments) {
+        const referencedVariables = (0, utils_1.getReferencedVariables)(assignmentNode.variableValueNode);
+        if (itemScopedVariables.some((v) => referencedVariables.has(v))) {
+            itemScopedAssignments.push(assignmentNode);
+            itemScopedVariables.push(assignmentNode.variableNode);
+        }
+        else if (rootScopedVariables.some((v) => referencedVariables.has(v))) {
+            rootScopedAssignments.push(assignmentNode);
+            rootScopedVariables.push(assignmentNode.variableNode);
+        }
+        else {
+            traversalIndependentAssignments.push(assignmentNode);
+        }
+    }
+    return {
+        innerNode: processedInnerNode,
+        traversalIndependentAssignments,
+        rootScopedAssignments,
+        itemScopedAssignments,
+    };
+}
+/**
+ * Extracts variable assignments from the traversal's innerNode and produces LET statements
+ */
+function extractTraversalAssignmentsAsAql({ node, context, rootVar, itemVar, wrapRootVarsInNoEval = true, }) {
+    // TODO aql-perf: can there also be VariableAssignments in filterNode? If yes, should we hoist them?
+    const { innerNode: processedInnerNode, traversalIndependentAssignments, rootScopedAssignments, itemScopedAssignments, } = extractTraversalAssignments(node);
+    if (rootScopedAssignments.length > 0 && !rootVar) {
+        throw new Error('Found variable assignments that depend on the root variable, but the current traversal variant does not support them.');
+    }
+    if (itemScopedAssignments.length > 0 && !itemVar) {
+        throw new Error('Found variable assignments that depend on the loop variable, but the current traversal variant does not support them.');
+    }
+    const { fragments: independentAssignmentFrags, context: baseContext } = buildAssignmentFragments(traversalIndependentAssignments, context, {
+        wrapWithNoEval: true,
+    });
+    const rootBaseContext = rootVar
+        ? baseContext.bindVariable(node.rootEntityVariable, rootVar)
+        : baseContext;
+    const { fragments: rootAssignmentFrags, context: rootContext } = buildAssignmentFragments(rootScopedAssignments, rootBaseContext, {
+        wrapWithNoEval: wrapRootVarsInNoEval,
+    });
+    const itemBaseContext = itemVar
+        ? rootContext.bindVariable(node.itemVariable, itemVar)
+        : rootContext;
+    const { fragments: itemAssignmentFrags, context: itemContext } = buildAssignmentFragments(itemScopedAssignments, itemBaseContext);
+    const innerFrag = itemVar && processedInnerNode
+        ? processNode(processedInnerNode, itemContext)
+        : (itemVar ?? (0, aql_1.aql) `NULL`);
+    return {
+        processedInnerNode,
+        innerFrag,
+        independentAssignmentFrags,
+        rootAssignmentFrags,
+        itemAssignmentFrags,
+        rootContext,
+        itemBaseContext,
+        itemContext,
+    };
+}
+function buildAssignmentFragments(assignments, startContext, { wrapWithNoEval = false } = {}) {
+    let currentContext = startContext;
+    const fragments = [];
+    for (const assignmentNode of assignments) {
+        currentContext = currentContext.bindVariable(assignmentNode.variableNode);
+        const tmpVar = currentContext.getVariable(assignmentNode.variableNode);
+        const valueFrag = processNode(assignmentNode.variableValueNode, currentContext);
+        fragments.push(wrapWithNoEval
+            ? (0, aql_1.aql) `LET ${tmpVar} = NOEVAL(${valueFrag})`
+            : (0, aql_1.aql) `LET ${tmpVar} = ${valueFrag}`);
+    }
+    return { fragments, context: currentContext };
+}
 /**
  * Produces:
  *
  *     FIRST(
  *         FOR node1 IN OUTBOUND source_hop1
  *         FOR node2 in OUTBOUND hop1_hop2
- *         FOR result IN OUTBOUND hop2_target
- *         RETURN innerNode(result)
+ *         FOR item IN OUTBOUND hop2_target
+ *         LET extractedVar = variableValueExpr(item)
+ *         RETURN innerNode(item)
  *     )
  *
  * or, if preserveNullValues is true and hop2_target is a to-1 relation:
@@ -1115,8 +1246,9 @@ register(query_tree_1.TraversalQueryNode, (node, context) => {
  *     FIRST(
  *         FOR node1 IN OUTBOUND source_hop1
  *         FOR node2 in OUTBOUND hop1_hop2
- *         LET result = FIRST(FOR node3 IN OUTBOUND hop2_target RETURNN node3)
- *         RETURN innerNode(result)
+ *         LET item = FIRST(FOR node3 IN OUTBOUND hop2_target RETURNN node3)
+ *         LET extractedVar = variableValueExpr(item)
+ *         RETURN innerNode(item)
  *     )
  */
 function processTraversalWithOnlyRelationSegmentsNoList(node, context) {
@@ -1129,15 +1261,15 @@ function processTraversalWithOnlyRelationSegmentsNoList(node, context) {
         node.maxCount !== undefined) {
         throw new Error(`Cannot have filter, orderBy, skip or maxCount on non-list relation traversal`);
     }
-    const innerContext = context.bindVariable(node.itemVariable);
-    const itemVar = innerContext.getVariable(node.itemVariable);
+    const itemVar = aql_1.aql.variable(node.itemVariable.label ?? 'item');
     const forStatementsFrag = getRelationTraversalForStatements({
         node,
         innermostItemVar: itemVar,
         preserveNullValues: node.preserveNullValues,
         context,
     });
-    return aqlExt.firstOfSubquery(forStatementsFrag, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : itemVar}`);
+    const { independentAssignmentFrags, itemAssignmentFrags, innerFrag } = extractTraversalAssignmentsAsAql({ node, context, itemVar });
+    return aqlExt.firstOfSubquery(...independentAssignmentFrags, forStatementsFrag, ...itemAssignmentFrags, (0, aql_1.aql) `RETURN ${innerFrag}`);
 }
 /**
  * Produces:
@@ -1145,6 +1277,7 @@ function processTraversalWithOnlyRelationSegmentsNoList(node, context) {
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
  *     FOR item IN OUTBOUND hop2_target
+ *     LET extractedVar = variableValueExpr(item)
  *     FILTER filterExpr(item)
  *     SORT item.field1 ASC
  *     LIMIT skip, maxCount
@@ -1155,6 +1288,7 @@ function processTraversalWithOnlyRelationSegmentsNoList(node, context) {
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
  *     LET item = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     LET extractedVar = variableValueExpr(item)
  *     FILTER filterExpr(item)
  *     SORT item.field1 ASC
  *     LIMIT skip, maxCount
@@ -1170,39 +1304,43 @@ function processTraversalWithOnlyRelationSegmentsAsList(node, context) {
     // - alwaysProduceList is automatically handled because we always RETURN a list here
     // we could refactor the single usage so it does not use a TraversalQueryNode in the first place
     const itemVar = aql_1.aql.variable(`node`);
-    const innerContext = context.bindVariable(node.itemVariable, itemVar);
     const forStatementsFrag = getRelationTraversalForStatements({
         node,
         innermostItemVar: itemVar,
         context,
         preserveNullValues: node.preserveNullValues,
     });
-    return aqlExt.subquery(forStatementsFrag, node.filterNode ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, context)}` : (0, aql_1.aql) ``, 
+    const { independentAssignmentFrags, itemAssignmentFrags, itemBaseContext, innerFrag } = extractTraversalAssignmentsAsAql({ node, context, itemVar });
+    return aqlExt.subquery(...independentAssignmentFrags, forStatementsFrag, node.filterNode ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, itemBaseContext)}` : (0, aql_1.aql) ``, 
     // yes, we can SORT and LIMIT like this even if there are multiple FOR statements
     // because there is one result set for the cross product of all FOR statements
     // see https://docs.arangodb.com/3.12/aql/high-level-operations/for/#usage
-    generateSortAQL(node.orderBy, innerContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : itemVar}`);
+    generateSortAQL(node.orderBy, itemBaseContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, ...itemAssignmentFrags, (0, aql_1.aql) `RETURN ${innerFrag}`);
 }
 /**
  * Produces:
  *
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
- *     FOR item IN OUTBOUND hop2_target
- *     FILTER filterExpr(item.fieldSegment1.fieldSegment2)
- *     SORT item.fieldSegment1.fieldSegment2.sortField ASC
+ *     FOR root IN OUTBOUND hop2_target
+ *     LET extractedVar1 = variable1ValueExpr(root))
+ *     LET extractedVar2 = variable2ValueExpr(root.fieldSegment1.fieldSegment2)
+ *     FILTER filterExpr(root.fieldSegment1.fieldSegment2)
+ *     SORT root.fieldSegment1.fieldSegment2.sortField ASC
  *     LIMIT skip, maxCount
- *     RETURN innerNode(item.fieldSegment1.fieldSegment2, { root: node2 })
+ *     RETURN innerNode(root.fieldSegment1.fieldSegment2, { root: node2 })
  *
  * or, if preserveNullValues is true and hop2_target is a to-1 relation:
  *
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
- *     LET item = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
- *     FILTER filterExpr(item.fieldSegment1.fieldSegment2)
- *     SORT item.fieldSegment1.fieldSegment2.sortField ASC
+ *     LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     LET extractedVar1 = variable1ValueExpr(root)
+ *     LET extractedVar2 = variable2ValueExpr(root.fieldSegment1.fieldSegment2)
+ *     FILTER filterExpr(root.fieldSegment1.fieldSegment2)
+ *     SORT root.fieldSegment1.fieldSegment2.sortField ASC
  *     LIMIT skip, maxCount
- *     RETURN innerNode(item.fieldSegment1.fieldSegment2, { root: node2 })
+ *     RETURN innerNode(root.fieldSegment1.fieldSegment2, { root: node2 })
  */
 function processTraversalWithListRelationSegmentsAndNonListFieldSegments(node, context) {
     if (!node.relationSegments.some((f) => f.isListSegment)) {
@@ -1224,11 +1362,19 @@ function processTraversalWithListRelationSegmentsAndNonListFieldSegments(node, c
         segments: node.fieldSegments,
         sourceFrag: rootVar,
     });
-    const innerContext = context.bindVariable(node.itemVariable, fieldTraversalFrag);
+    const { independentAssignmentFrags, itemBaseContext, itemAssignmentFrags, rootAssignmentFrags, innerFrag, } = extractTraversalAssignmentsAsAql({
+        node,
+        context,
+        rootVar,
+        itemVar: fieldTraversalFrag,
+        // there is no loop within the context of a root item where the root var assignment could
+        // be pushed down into, so we don't need to guard against that
+        wrapRootVarsInNoEval: false,
+    });
     // note: we don't filter out NULL values even if preserveNullValues is false because that's currently
     // only a flag for performance - actually filtering out NULLs is done by a surrounding AggregationQueryNode
     // TODO aql-perf remove this note once the NULL filtering / preserving has moved out of AggregationQueryNode
-    return aqlExt.subquery(forStatementsFrag, node.filterNode ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, innerContext)}` : (0, aql_1.aql) ``, generateSortAQL(node.orderBy, innerContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : fieldTraversalFrag}`);
+    return aqlExt.subquery(...independentAssignmentFrags, (0, aql_1.aql) `${forStatementsFrag}`, node.filterNode ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, itemBaseContext)}` : (0, aql_1.aql) ``, generateSortAQL(node.orderBy, itemBaseContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, ...rootAssignmentFrags, ...itemAssignmentFrags, (0, aql_1.aql) `RETURN ${innerFrag}`);
 }
 /**
  * Produces:
@@ -1236,8 +1382,10 @@ function processTraversalWithListRelationSegmentsAndNonListFieldSegments(node, c
  *     FIRST(
  *         FOR node1 IN OUTBOUND source_hop1
  *         FOR node2 in OUTBOUND hop1_hop2
- *         FOR item IN OUTBOUND hop2_target
- *         RETURN innerNode(item.fieldSegment1.fieldSegment2, { root: node2 })
+ *         FOR root IN OUTBOUND hop2_target
+ *         LET extractedVar1 = variable1ValueExpr(root)
+ *         LET extractedVar2 = variable2ValueExpr(root.fieldSegment1.fieldSegment2)
+ *         RETURN innerNode(root.fieldSegment1.fieldSegment2, { root: node2 })
  *     )
  *
  * or, if preserveNullValues is true and hop2_target is a to-1 relation:
@@ -1245,8 +1393,10 @@ function processTraversalWithListRelationSegmentsAndNonListFieldSegments(node, c
  *     FIRST(
  *         FOR node1 IN OUTBOUND source_hop1
  *         FOR node2 in OUTBOUND hop1_hop2
- *         LET item = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
- *         RETURN innerNode(item.fieldSegment1.fieldSegment2, { root: node2 })
+ *         LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *         LET extractedVar1 = variable1ValueExpr(root)
+ *         LET extractedVar2 = variable2ValueExpr(root.fieldSegment1.fieldSegment2)
+ *         RETURN innerNode(root.fieldSegment1.fieldSegment2, { root: node2 })
  *     )
  */
 function processTraversalWithNonListRelationSegmentsAndNonListFieldSegments(node, context) {
@@ -1264,7 +1414,7 @@ function processTraversalWithNonListRelationSegmentsAndNonListFieldSegments(node
     }
     // this is very similar to processTraversalWithOnlyRelationSegmentsNoList(),
     // but instead of using the rootVar in mapping, we use the field traversal result
-    const rootVar = aql_1.aql.variable(`root`);
+    const rootVar = aql_1.aql.variable('root');
     const forStatementsFrag = getRelationTraversalForStatements({
         node,
         innermostItemVar: rootVar,
@@ -1275,8 +1425,16 @@ function processTraversalWithNonListRelationSegmentsAndNonListFieldSegments(node
         segments: node.fieldSegments,
         sourceFrag: rootVar,
     });
-    const innerContext = context.bindVariable(node.itemVariable, fieldTraversalFrag);
-    return aqlExt.firstOfSubquery(forStatementsFrag, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : fieldTraversalFrag}`);
+    const { independentAssignmentFrags, itemAssignmentFrags, rootAssignmentFrags, innerFrag } = extractTraversalAssignmentsAsAql({
+        node,
+        context,
+        rootVar,
+        itemVar: fieldTraversalFrag,
+        // there is no loop within the context of a root item where the root var assignment could
+        // be pushed down into, so we don't need to guard against that
+        wrapRootVarsInNoEval: false,
+    });
+    return aqlExt.firstOfSubquery(...independentAssignmentFrags, (0, aql_1.aql) `${forStatementsFrag}`, ...rootAssignmentFrags, ...itemAssignmentFrags, (0, aql_1.aql) `RETURN ${innerFrag}`);
 }
 /**
  * Produces:
@@ -1284,7 +1442,9 @@ function processTraversalWithNonListRelationSegmentsAndNonListFieldSegments(node
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
  *     FOR root IN OUTBOUND hop2_target
+ *     LET extractedVar1 = NOEVAL(variable1ValueExpr(root))
  *     FOR item IN root.fieldSegment1[*].fieldSegment2[** FILTER filterExpr(CURRENT)][*]
+ *     LET extractedVar2 = variable1ValueExpr(item)
  *     SORT item.sortValues[0]
  *     LIMIT skip, maxCount
  *     RETURN innerNode(item, { root })
@@ -1294,7 +1454,9 @@ function processTraversalWithNonListRelationSegmentsAndNonListFieldSegments(node
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
  *     LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     LET extractedVar1 = NOEVAL(variable1ValueExpr(root))
  *     FOR item IN root.fieldSegment1[*].fieldSegment2[** FILTER filterExpr(CURRENT)][*]
+ *     LET extractedVar2 = variable1ValueExpr(item)
  *     SORT item.sortValues[0]
  *     LIMIT skip, maxCount
  *     RETURN innerNode(item, { root })
@@ -1331,13 +1493,11 @@ function processTraversalWithRelationAndListFieldSegmentsUsingSubquery(node, con
         sourceFrag: rootVar,
         filterFrag: innerFilterFrag,
     });
-    const itemVar = aql_1.aql.variable(`item`);
-    const innerContext = context
-        .bindVariable(node.itemVariable, itemVar)
-        .bindVariable(node.rootEntityVariable, rootVar);
+    const itemVar = aql_1.aql.variable(node.itemVariable.label ?? 'item');
+    const { independentAssignmentFrags, rootAssignmentFrags, itemAssignmentFrags, itemBaseContext, innerFrag, } = extractTraversalAssignmentsAsAql({ node, context, rootVar, itemVar });
     // The fieldTraversalFrag will produce a list, so a simple RETURN mapFrag would result in nested lists
     // -> we iterate over the items again to flatten the lists (the FOR ${itemVar} ...)
-    return aqlExt.subquery((0, aql_1.aql) `${forStatementsFrag}`, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, generateSortAQL(node.orderBy, innerContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${node.innerNode ? processNode(node.innerNode, innerContext) : itemVar}`);
+    return aqlExt.subquery(...independentAssignmentFrags, (0, aql_1.aql) `${forStatementsFrag}`, ...rootAssignmentFrags, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, generateSortAQL(node.orderBy, itemBaseContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, ...itemAssignmentFrags, (0, aql_1.aql) `RETURN ${innerFrag}`);
 }
 /**
  * Produces this if the result of the relation traversal is a single item:
@@ -1345,6 +1505,7 @@ function processTraversalWithRelationAndListFieldSegmentsUsingSubquery(node, con
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
  *     FOR root IN OUTBOUND hop2_target
+ *     LET extractedVar = NOEVAL(variableValueExpr(root))
  *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
  *         FILTER filterExpr(CURRENT)
  *         LIMIT skip, maxCount
@@ -1371,6 +1532,7 @@ function processTraversalWithRelationAndListFieldSegmentsUsingSubquery(node, con
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
  *     LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     LET extractedVar = NOEVAL(variableValueExpr(root))
  *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
  *         FILTER filterExpr(CURRENT)
  *         LIMIT skip, maxCount
@@ -1408,15 +1570,6 @@ function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWith
         preserveNullValues: node.preserveNullValues,
         context,
     });
-    const innerNode = node.innerNode;
-    const innerMapFrag = innerNode
-        ? (itemFrag) => {
-            const innerContext = context
-                .bindVariable(node.itemVariable, itemFrag)
-                .bindVariable(node.rootEntityVariable, rootVar);
-            return processNode(innerNode, innerContext);
-        }
-        : undefined;
     // We can do the LIMIT within the field traversal's mapping function using an array expansion,
     // but only if the relation traversal yields at most one result (i.e. if it only follows 1:1 relations)
     const lastRelationSegment = node.relationSegments[node.relationSegments.length - 1];
@@ -1436,8 +1589,10 @@ function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWith
             maxCount: node.maxCount,
         };
     }
-    let innerFilterFrag;
+    // There is no place to put item-dependent LET statements in this variant, so we don't pass an itemVar
+    const { independentAssignmentFrags, rootAssignmentFrags, rootContext, processedInnerNode } = extractTraversalAssignmentsAsAql({ node, context, rootVar });
     const filterNode = node.filterNode;
+    let innerFilterFrag;
     if (filterNode) {
         innerFilterFrag = (itemFrag) => {
             // don't map rootEntityVariable
@@ -1446,6 +1601,9 @@ function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWith
             return processNode(filterNode, innerContext);
         };
     }
+    const innerMapFrag = processedInnerNode
+        ? (itemFrag) => processNode(processedInnerNode, rootContext.bindVariable(node.itemVariable, itemFrag))
+        : undefined;
     const fieldTraversalFrag = getFieldTraversalFragment({
         segments: node.fieldSegments,
         sourceFrag: rootVar,
@@ -1465,8 +1623,8 @@ function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWith
     //     FOR item IN root.children
     //     RETURN item
     // (could also use FLATTEN(), but since we're already using nested FORs, this is probably cleaner)
-    const itemVar = aql_1.aql.variable(`item`);
-    return aqlExt.subquery((0, aql_1.aql) `${forStatementsFrag}`, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, generateLimitClause(limitArgs) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemVar}`);
+    const itemVar = aql_1.aql.variable('item');
+    return aqlExt.subquery(...independentAssignmentFrags, (0, aql_1.aql) `${forStatementsFrag}`, ...rootAssignmentFrags, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, generateLimitClause(limitArgs) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemVar}`);
 }
 /**
  * Produces:
@@ -1474,6 +1632,7 @@ function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWith
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
  *     FOR root IN OUTBOUND hop2_target
+ *     LET extractedVar = NOEVAL(variableValueExpr(root))
  *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
  *         FILTER filterExpr(CURRENT)
  *         RETURN {
@@ -1493,6 +1652,7 @@ function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWith
  *     FOR node1 IN OUTBOUND source_hop1
  *     FOR node2 in OUTBOUND hop1_hop2
  *     LET root = FIRST(FOR node3 IN OUTBOUND hop2_target RETURN node3)
+ *     LET extractedVar = NOEVAL(variableValueExpr(root))
  *     FOR item IN root.fieldSegment1[*].fieldSegment2[**][*
  *         FILTER filterExpr(CURRENT)
  *         RETURN {
@@ -1558,14 +1718,17 @@ function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWith
       if there are many / large fields in the items that are not needed at all
       (because sorting probably copies the whole item into some temporary structure)
      */
+    // There is no place to put item-dependent LET statements in this variant, so we don't pass an itemVar
+    const { processedInnerNode, independentAssignmentFrags, rootAssignmentFrags, rootContext } = extractTraversalAssignmentsAsAql({ node, context, rootVar });
     // we sort after mapping roots to items, so we need to preserve the sort values that are based on the item
     // -> we produce items like this: { value: ..., sortValues: [...] }
     const innerMapFrag = (itemFrag) => {
-        const innerContext = context
-            .bindVariable(node.itemVariable, itemFrag)
-            .bindVariable(node.rootEntityVariable, rootVar);
-        const valueFrag = node.innerNode ? processNode(node.innerNode, innerContext) : itemFrag;
-        return aql_1.aql.lines((0, aql_1.aql) `{`, aql_1.aql.indent(aql_1.aql.lines((0, aql_1.aql) `value: ${valueFrag},`, (0, aql_1.aql) `sortValues: [`, aql_1.aql.indent(aql_1.aql.join(node.orderBy.clauses.map((c) => processNode(c.valueNode, innerContext)), (0, aql_1.aql) `,\n`)), (0, aql_1.aql) `]`)), (0, aql_1.aql) `}`);
+        const innerContext = rootContext.bindVariable(node.itemVariable, itemFrag);
+        const valueFrag = processedInnerNode
+            ? processNode(processedInnerNode, innerContext)
+            : itemFrag;
+        const sortValueFrags = node.orderBy.clauses.map((c) => processNode(c.valueNode, innerContext));
+        return aql_1.aql.lines((0, aql_1.aql) `{`, aql_1.aql.indent(aql_1.aql.lines((0, aql_1.aql) `value: ${valueFrag},`, (0, aql_1.aql) `sortValues: [`, aql_1.aql.indent(aql_1.aql.join(sortValueFrags, (0, aql_1.aql) `,\n`)), (0, aql_1.aql) `]`)), (0, aql_1.aql) `}`);
     };
     const filterNode = node.filterNode;
     const innerFilterFrag = filterNode
@@ -1587,7 +1750,7 @@ function processTraversalWithRelationAndListFieldSegmentsUsingArrayExpansionWith
     const clauseFrags = node.orderBy.clauses.map((clause, index) => (0, aql_1.aql) `${itemVar}.sortValues[${aql_1.aql.integer(index)}]${dirAQL(clause.direction)}`);
     // The fieldTraversalFrag will produce a list, so a simple RETURN mapFrag would result in nested lists
     // -> we iterate over the items again to flatten the lists (the FOR ${itemVar} ...)
-    return aqlExt.subquery((0, aql_1.aql) `${forStatementsFrag}`, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, (0, aql_1.aql) `SORT ${aql_1.aql.join(clauseFrags, (0, aql_1.aql) `, `)}`, generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemVar}.value`);
+    return aqlExt.subquery(...independentAssignmentFrags, (0, aql_1.aql) `${forStatementsFrag}`, ...rootAssignmentFrags, (0, aql_1.aql) `FOR ${itemVar} IN ${fieldTraversalFrag}`, (0, aql_1.aql) `SORT ${aql_1.aql.join(clauseFrags, (0, aql_1.aql) `, `)}`, generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${itemVar}.value`);
 }
 /**
  * Produces:
@@ -1640,6 +1803,7 @@ function processTraversalWithOnlyFieldSegmentsUsingArrayExpansion(node, context)
  *     FILTER filterExpr(item)
  *     SORT item.sortField1 ASC, item.sortField1 DESC
  *     LIMIT skip, maxCount
+ *     LET extractedVar = variableValueExpr(item)
  *     RETURN innerNode(item)
  */
 function processTraversalWithOnlyFieldSegmentsUsingSubquery(node, context) {
@@ -1668,15 +1832,14 @@ function processTraversalWithOnlyFieldSegmentsUsingSubquery(node, context) {
         segments: node.fieldSegments,
         sourceFrag,
     });
-    const itemVar = aql_1.aql.variable('item');
-    const innerContext = context.bindVariable(node.itemVariable, itemVar);
-    const returnValueFrag = node.innerNode ? processNode(node.innerNode, innerContext) : itemVar;
+    const itemVar = aql_1.aql.variable(node.itemVariable.label ?? 'item');
+    const { independentAssignmentFrags, itemAssignmentFrags, itemBaseContext, innerFrag } = extractTraversalAssignmentsAsAql({ node, context, itemVar });
     // filter in the subquery instead of in getFieldTraversalFragment() because the filter
     // expression might use subqueries
     const filterFrag = node.filterNode
-        ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, innerContext)}`
+        ? (0, aql_1.aql) `FILTER ${processNode(node.filterNode, itemBaseContext)}`
         : (0, aql_1.aql) ``;
-    return aqlExt.subquery((0, aql_1.aql) `FOR ${itemVar}`, (0, aql_1.aql) `IN ${fieldTraversalFrag}`, filterFrag, generateSortAQL(node.orderBy, innerContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, (0, aql_1.aql) `RETURN ${returnValueFrag}`);
+    return aqlExt.subquery(...independentAssignmentFrags, (0, aql_1.aql) `FOR ${itemVar}`, (0, aql_1.aql) `IN ${fieldTraversalFrag}`, filterFrag, generateSortAQL(node.orderBy, itemBaseContext), generateLimitClause(node) ?? (0, aql_1.aql) ``, ...itemAssignmentFrags, (0, aql_1.aql) `RETURN ${innerFrag}`);
 }
 function getRelationTraversalForStatements({ node, innermostItemVar, context, preserveNullValues = false, }) {
     if (!node.relationSegments.length) {