@undefineds.co/xpod 0.3.29 → 0.3.31

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

@@ -1,8 +1,8 @@
 import type { SparqlQuery } from 'sparqljs';
 import type { NamedNode, Quad, Term } from '@rdfjs/types';
-import type { RdfLocalQuery, RdfBindingRow, RdfConstructTemplate, RdfQueryTermPattern } from './types';
+import type { RdfQuery, RdfBindingRow, RdfConstructTemplate, RdfQueryTermPattern } from './types';
 export interface RdfSparqlCompileResult {
-    query: RdfLocalQuery;
+    query: RdfQuery;
     variables: string[];
     queryType: 'SELECT' | 'ASK' | 'CONSTRUCT' | 'DESCRIBE';
     constructTemplate?: RdfConstructTemplate[];
@@ -25,18 +25,18 @@ export interface RdfSparqlDeleteWhereTemplate {
 export type RdfSparqlUpdateTemplate = RdfSparqlDeleteWhereTemplate;
 export interface RdfSparqlDeleteWhereOperation {
     type: 'deleteWhere';
-    query: RdfLocalQuery;
+    query: RdfQuery;
     template: RdfSparqlUpdateTemplate[];
 }
 export interface RdfSparqlInsertDeleteWhereOperation {
     type: 'insertDeleteWhere';
-    query: RdfLocalQuery;
+    query: RdfQuery;
     deletes: RdfSparqlUpdateTemplate[];
     inserts: RdfSparqlUpdateTemplate[];
 }
 export interface RdfSparqlInsertWhereOperation {
     type: 'insertWhere';
-    query: RdfLocalQuery;
+    query: RdfQuery;
     inserts: RdfSparqlUpdateTemplate[];
 }
 export type RdfSparqlUpdateDeltaOperation = RdfSparqlInsertOperation | RdfSparqlDeleteOperation | RdfSparqlDeleteWhereOperation | RdfSparqlInsertDeleteWhereOperation | RdfSparqlInsertWhereOperation;

package/dist/storage/rdf/RdfSparqlAdapter.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RdfSparqlAdapter = exports.DisabledSparqlFeatureError = exports.UnsupportedSparqlQueryError = void 0;
 const n3_1 = require("n3");
 const sparqljs_1 = require("sparqljs");
-const RdfLocalQueryEngine_1 = require("./RdfLocalQueryEngine");
+const RdfQueryExecutor_1 = require("./RdfQueryExecutor");
 const PATH_JOIN_VARIABLE_PREFIX = '__rdf_path';
 const XPATH_FUNCTION_NS = 'http://www.w3.org/2005/xpath-functions#';
 class UnsupportedSparqlQueryError extends Error {
@@ -324,7 +324,7 @@ class RdfSparqlAdapter {
                     if (!options.graphVariables?.has(item.name.value)) {
                         throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
                     }
-                    graph = (0, RdfLocalQueryEngine_1.variable)(item.name.value);
+                    graph = (0, RdfQueryExecutor_1.variable)(item.name.value);
                 }
                 else if (item.name.termType !== 'NamedNode') {
                     throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
@@ -1077,7 +1077,7 @@ class RdfSparqlAdapter {
     }
     compileGraphTerm(term, basePath) {
         if (term.termType === 'Variable') {
-            return (0, RdfLocalQueryEngine_1.variable)(term.value);
+            return (0, RdfQueryExecutor_1.variable)(term.value);
         }
         if (!term.value.startsWith(basePath)) {
             return null;
@@ -1086,7 +1086,7 @@ class RdfSparqlAdapter {
     }
     compileTerm(term) {
         if (term.termType === 'Variable') {
-            return (0, RdfLocalQueryEngine_1.variable)(term.value);
+            return (0, RdfQueryExecutor_1.variable)(term.value);
         }
         if (term.termType === 'Quad') {
             throw new UnsupportedSparqlQueryError('RDF-star terms fallback to compatibility engine');
@@ -1154,24 +1154,24 @@ class RdfSparqlAdapter {
             };
         });
     }
-    compileDescribeTargets(query, localQuery) {
+    compileDescribeTargets(query, rdfQuery) {
         if (query.variables.length === 1 && query.variables[0] instanceof sparqljs_1.Wildcard) {
             const variables = visibleSelectVariables(query);
             if (variables.length === 0) {
                 throw new UnsupportedSparqlQueryError('DESCRIBE wildcard without visible variables fallback to compatibility engine');
             }
-            const unboundVariable = variables.find((variable) => !queryBindsVariableInRequiredShape(localQuery, variable));
+            const unboundVariable = variables.find((variable) => !queryBindsVariableInRequiredShape(rdfQuery, variable));
             if (unboundVariable) {
                 throw new UnsupportedSparqlQueryError('DESCRIBE wildcard variables must be bound by required embedded query patterns');
             }
-            return variables.map((variable) => (0, RdfLocalQueryEngine_1.variable)(variable));
+            return variables.map((variable) => (0, RdfQueryExecutor_1.variable)(variable));
         }
         const targets = query.variables.map((target) => {
             if (target.termType === 'Variable') {
-                if (!queryBindsVariableInRequiredShape(localQuery, target.value)) {
+                if (!queryBindsVariableInRequiredShape(rdfQuery, target.value)) {
                     throw new UnsupportedSparqlQueryError('DESCRIBE variables must be bound by required embedded query patterns');
                 }
-                return (0, RdfLocalQueryEngine_1.variable)(target.value);
+                return (0, RdfQueryExecutor_1.variable)(target.value);
             }
             if (target.termType === 'NamedNode') {
                 return target;
@@ -1190,9 +1190,9 @@ class RdfSparqlAdapter {
         return term;
     }
     compileSelectVariables(query, state) {
-        const localQuery = state.query;
+        const rdfQuery = state.query;
         if (query.variables.length === 1 && query.variables[0] instanceof sparqljs_1.Wildcard) {
-            if ((localQuery.groupBy?.length ?? 0) > 0) {
+            if ((rdfQuery.groupBy?.length ?? 0) > 0) {
                 throw new UnsupportedSparqlQueryError('Wildcard grouped SELECT fallback to compatibility engine');
             }
             return visibleSelectVariables(query);
@@ -1209,13 +1209,13 @@ class RdfSparqlAdapter {
                 throw new UnsupportedSparqlQueryError('Wildcard mixed with explicit SELECT projections fallback to compatibility engine');
             }
             if (!isAggregateExpression(variable.expression)) {
-                if ((localQuery.groupBy?.length ?? 0) > 0) {
+                if ((rdfQuery.groupBy?.length ?? 0) > 0) {
                     throw new UnsupportedSparqlQueryError('Grouped SELECT expression projection fallback to compatibility engine');
                 }
                 const alias = variable.variable.value;
                 if (variables.includes(alias)
                     || visibleVariables.includes(alias)
-                    || (localQuery.binds ?? []).some((bind) => bind.variable === alias)) {
+                    || (rdfQuery.binds ?? []).some((bind) => bind.variable === alias)) {
                     throw new UnsupportedSparqlQueryError('SELECT expression alias is already bound locally');
                 }
                 state.addBind({
@@ -1227,11 +1227,11 @@ class RdfSparqlAdapter {
             }
             const aggregate = variable.expression;
             const compiledAggregate = this.compileAggregateProjection(aggregate, variable.variable.value, state);
-            localQuery.aggregates = [...(localQuery.aggregates ?? []), compiledAggregate];
-            localQuery.aggregate ??= compiledAggregate;
+            rdfQuery.aggregates = [...(rdfQuery.aggregates ?? []), compiledAggregate];
+            rdfQuery.aggregate ??= compiledAggregate;
             variables.push(variable.variable.value);
         }
-        this.assertGroupProjection(query, localQuery, variables);
+        this.assertGroupProjection(query, rdfQuery, variables);
         return variables;
     }
     compileAggregateProjection(aggregate, as, state) {
@@ -1319,8 +1319,8 @@ class RdfSparqlAdapter {
         if (having.length === 0) {
             return undefined;
         }
-        const localQuery = state.query;
-        if ((localQuery.aggregates?.length ?? 0) === 0 && !localQuery.aggregate) {
+        const rdfQuery = state.query;
+        if ((rdfQuery.aggregates?.length ?? 0) === 0 && !rdfQuery.aggregate) {
             throw new UnsupportedSparqlQueryError('HAVING without aggregate fallback to compatibility engine');
         }
         const filters = having.flatMap((expression) => this.compileHavingFilter(expression, state));
@@ -1363,8 +1363,8 @@ class RdfSparqlAdapter {
         throw new UnsupportedSparqlQueryError('HAVING must compare one aggregate with one RDF term locally');
     }
     havingAggregateVariableOrUndefined(expression, state) {
-        const localQuery = state.query;
-        const aggregates = localQuery.aggregates ?? (localQuery.aggregate ? [localQuery.aggregate] : []);
+        const rdfQuery = state.query;
+        const aggregates = rdfQuery.aggregates ?? (rdfQuery.aggregate ? [rdfQuery.aggregate] : []);
         if (aggregates.length === 0) {
             return undefined;
         }
@@ -1397,21 +1397,21 @@ class RdfSparqlAdapter {
                 ? { distinctVariables: state.visibleSolutionVariables }
                 : {}),
         };
-        localQuery.aggregates = [...(localQuery.aggregates ?? []), hiddenAggregate];
+        rdfQuery.aggregates = [...(rdfQuery.aggregates ?? []), hiddenAggregate];
         return hiddenAggregate.as;
     }
-    assertGroupProjection(query, localQuery, variables) {
-        const groupBy = localQuery.groupBy ?? [];
+    assertGroupProjection(query, rdfQuery, variables) {
+        const groupBy = rdfQuery.groupBy ?? [];
         if (groupBy.length === 0) {
             return;
         }
-        const aggregates = localQuery.aggregates ?? (localQuery.aggregate ? [localQuery.aggregate] : []);
+        const aggregates = rdfQuery.aggregates ?? (rdfQuery.aggregate ? [rdfQuery.aggregate] : []);
         if (aggregates.length === 0) {
             throw new UnsupportedSparqlQueryError('GROUP BY without aggregate fallback to compatibility engine');
         }
         const groupableVariables = new Set([
-            ...localQuery.patterns.flatMap((pattern) => variablesInPattern(pattern)),
-            ...(localQuery.binds ?? []).map((bind) => bind.variable),
+            ...rdfQuery.patterns.flatMap((pattern) => variablesInPattern(pattern)),
+            ...(rdfQuery.binds ?? []).map((bind) => bind.variable),
         ]);
         if (groupBy.some((variableName) => !groupableVariables.has(variableName))) {
             throw new UnsupportedSparqlQueryError('GROUP BY variables must come from required BGP patterns or local binds');
@@ -2252,7 +2252,7 @@ class CompileState {
     }
     nextPathJoinVariable() {
         this.pathJoinVariableIndex += 1;
-        return (0, RdfLocalQueryEngine_1.variable)(`${PATH_JOIN_VARIABLE_PREFIX}_${this.pathJoinVariableIndex}`);
+        return (0, RdfQueryExecutor_1.variable)(`${PATH_JOIN_VARIABLE_PREFIX}_${this.pathJoinVariableIndex}`);
     }
     nextGroupVariable(index) {
         this.groupVariableIndex += 1;