@undefineds.co/xpod 0.3.54 → 0.3.56

package/dist/storage/rdf/RdfSparqlAdapter.d.ts

@@ -132,6 +132,7 @@ export declare class RdfSparqlAdapter {
     private havingAggregateVariableOrUndefined;
     private assertGroupProjection;
     private compileOrder;
+    private addSolutionBind;
     private compileOrderExpression;
     private compileFilter;
     private compileOrFilter;

package/dist/storage/rdf/RdfSparqlAdapter.js

@@ -1215,13 +1215,14 @@ class RdfSparqlAdapter {
                 const alias = variable.variable.value;
                 if (variables.includes(alias)
                     || visibleVariables.includes(alias)
-                    || (rdfQuery.binds ?? []).some((bind) => bind.variable === alias)) {
+                    || (rdfQuery.binds ?? []).some((bind) => bind.variable === alias)
+                    || (rdfQuery.postOptionalBinds ?? []).some((bind) => bind.variable === alias)) {
                     throw new UnsupportedSparqlQueryError('SELECT expression alias is already bound locally');
                 }
-                state.addBind({
+                this.addSolutionBind(state, {
                     variable: alias,
                     expression: this.compileSelectProjectionExpression(variable.expression, state.basePath),
-                }, false);
+                });
                 variables.push(alias);
                 continue;
             }
@@ -1452,16 +1453,26 @@ class RdfSparqlAdapter {
                 };
             }
             const orderVariable = state.nextOrderVariable(index);
-            state.addBind({
+            this.addSolutionBind(state, {
                 variable: orderVariable,
                 expression: this.compileOrderExpression(entry.expression, state.basePath),
-            }, false);
+            });
             return {
                 variable: orderVariable,
                 direction: entry.descending ? 'desc' : 'asc',
             };
         });
     }
+    addSolutionBind(state, bind) {
+        const optionalVariables = new Set(variablesBoundByNestedOptionalGroups(state.query.optional ?? []));
+        const dependsOnOptionalVariable = variablesInBindExpression(bind.expression)
+            .some((variableName) => optionalVariables.has(variableName));
+        if (dependsOnOptionalVariable) {
+            state.addPostOptionalBind(bind);
+            return;
+        }
+        state.addBind(bind, false);
+    }
     compileOrderExpression(expression, basePath) {
         return this.compileBindLikeExpression(expression, basePath, 'ORDER BY');
     }
@@ -2222,6 +2233,10 @@ class CompileState {
         this.query.binds ??= [];
         this.query.binds.push(bind);
     }
+    addPostOptionalBind(bind) {
+        this.query.postOptionalBinds ??= [];
+        this.query.postOptionalBinds.push(bind);
+    }
     addOptionalUnion(branches) {
         this.currentOptionalFrame().unions.push({ branches });
     }
@@ -2317,6 +2332,18 @@ class CompileState {
         for (const rawOptionalGroup of this.query.optional ?? []) {
             assertOptionalBindVariablesSafe(rawOptionalGroup, bound);
         }
+        const postOptionalBound = new Set(bound);
+        for (const variableName of variablesBoundByNestedOptionalGroups(this.query.optional ?? [])) {
+            postOptionalBound.add(variableName);
+        }
+        for (const bind of this.query.postOptionalBinds ?? []) {
+            for (const dependency of variablesInBindExpression(bind.expression)) {
+                if (!postOptionalBound.has(dependency)) {
+                    throw new UnsupportedSparqlQueryError('BIND dependency must be bound before use locally');
+                }
+            }
+            postOptionalBound.add(bind.variable);
+        }
     }
     assertDependentGroupsShareRequiredVariables() {
         if (this.skipMinusSharedVariableCheck) {