@_linked/core 2.0.0 → 2.2.0-next.20260313111019

package/lib/esm/sparql/irToAlgebra.js

@@ -1,5 +1,23 @@
 import { generateEntityUri } from './sparqlUtils.js';
 import { selectPlanToSparql, insertDataPlanToSparql, deleteInsertPlanToSparql, } from './algebraToString.js';
+// Lazy-loaded to avoid circular dependency:
+// irToAlgebra → ShapeClass → Shape → CreateBuilder → … → SHACL → Shape (circular)
+let _getShapeClass;
+function lazyGetShapeClass(id) {
+    if (!_getShapeClass) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        _getShapeClass = require('../utils/ShapeClass.js').getShapeClass;
+    }
+    return _getShapeClass(id);
+}
+let _shacl;
+function lazyShacl() {
+    if (!_shacl) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        _shacl = require('../ontologies/shacl.js').shacl;
+    }
+    return _shacl;
+}
 import { rdf } from '../ontologies/rdf.js';
 import { xsd } from '../ontologies/xsd.js';
 // ---------------------------------------------------------------------------
@@ -43,6 +61,16 @@ function propertySuffix(propertyUri) {
 function sanitizeVarName(name) {
     return name.replace(/[^A-Za-z0-9_]/g, '_');
 }
+const IR_EXPRESSION_KINDS = new Set([
+    'literal_expr', 'property_expr', 'binary_expr', 'logical_expr',
+    'not_expr', 'function_expr', 'aggregate_expr', 'reference_expr',
+    'alias_expr', 'context_property_expr', 'exists_expr',
+]);
+function isIRExpression(value) {
+    return !!value && typeof value === 'object' && 'kind' in value &&
+        typeof value.kind === 'string' &&
+        IR_EXPRESSION_KINDS.has(value.kind);
+}
 /**
  * Wrap a single node in a LeftJoin, making `right` optional relative to `left`.
  */
@@ -228,6 +256,23 @@ export function selectToAlgebra(query, _options) {
             };
         }
     }
+    // 5b. MINUS patterns — wrap algebra in SparqlMinus for each minus pattern
+    for (const pattern of query.patterns) {
+        if (pattern.kind === 'minus') {
+            let minusAlgebra = convertExistsPattern(pattern.pattern, registry);
+            if (pattern.filter) {
+                const minusPropertyTriples = [];
+                processExpressionForProperties(pattern.filter, registry, minusPropertyTriples);
+                // Add property triples into the MINUS block
+                if (minusPropertyTriples.length > 0) {
+                    minusAlgebra = joinNodes(minusAlgebra, { type: 'bgp', triples: minusPropertyTriples });
+                }
+                const filterExpr = convertExpression(pattern.filter, registry, minusPropertyTriples);
+                minusAlgebra = { type: 'filter', expression: filterExpr, inner: minusAlgebra };
+            }
+            algebra = { type: 'minus', left: algebra, right: minusAlgebra };
+        }
+    }
     // 6. SubjectId → Filter / SubjectIds → VALUES
     if (query.subjectIds && query.subjectIds.length > 0) {
         // Multiple subjects: use VALUES clause for efficient filtering
@@ -393,6 +438,10 @@ function processPattern(pattern, registry, traverseTriples, optionalPropertyTrip
             processPattern(pattern.pattern, registry, traverseTriples, optionalPropertyTriples, filteredTraverseBlocks);
             break;
         }
+        case 'minus': {
+            // MINUS patterns are handled separately in selectToAlgebra — skip in processPattern.
+            break;
+        }
     }
 }
 // ---------------------------------------------------------------------------
@@ -604,6 +653,9 @@ function convertExistsPattern(pattern, registry) {
         case 'exists': {
             return convertExistsPattern(pattern.pattern, registry);
         }
+        case 'minus': {
+            return convertExistsPattern(pattern.pattern, registry);
+        }
         default:
             throw new Error(`Unsupported pattern kind in EXISTS: ${pattern.kind}`);
     }
@@ -723,15 +775,19 @@ export function createToAlgebra(query, options) {
         triples,
     };
 }
+// ---------------------------------------------------------------------------
+// Shared update field processing
+// ---------------------------------------------------------------------------
 /**
- * Converts an IRUpdateMutation to a SparqlDeleteInsertPlan.
+ * Processes IRNodeData fields into DELETE/INSERT/WHERE triples.
+ * Shared between updateToAlgebra (IRI subject) and updateWhereToAlgebra (variable subject).
  */
-export function updateToAlgebra(query, options) {
-    const subjectTerm = iriTerm(query.id);
+function processUpdateFields(data, subjectTerm, options) {
     const deletePatterns = [];
     const insertPatterns = [];
-    const whereTriples = [];
-    for (const field of query.data.fields) {
+    const oldValueTriples = [];
+    const extends_ = [];
+    for (const field of data.fields) {
         const propertyTerm = iriTerm(field.property);
         const suffix = propertySuffix(field.property);
         // Check for set modification ({add, remove})
@@ -743,19 +799,16 @@ export function updateToAlgebra(query, options) {
             !('shape' in field.value) &&
             ('add' in field.value || 'remove' in field.value)) {
             const setMod = field.value;
-            // Remove specific values
             if (setMod.remove) {
                 for (const removeItem of setMod.remove) {
                     const removeTerm = iriTerm(removeItem.id);
                     deletePatterns.push(tripleOf(subjectTerm, propertyTerm, removeTerm));
-                    whereTriples.push(tripleOf(subjectTerm, propertyTerm, removeTerm));
+                    oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, removeTerm));
                 }
             }
-            // Add new values
             if (setMod.add) {
                 for (const addItem of setMod.add) {
                     if (addItem && typeof addItem === 'object' && 'shape' in addItem && 'fields' in addItem) {
-                        // Nested create in add
                         const nested = generateNodeDataTriples(addItem, options);
                         insertPatterns.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
                         insertPatterns.push(...nested.triples);
@@ -774,14 +827,14 @@ export function updateToAlgebra(query, options) {
         if (field.value === undefined || field.value === null) {
             const oldVar = varTerm(`old_${suffix}`);
             deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            whereTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
+            oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
             continue;
         }
         // Array overwrite — delete old values + insert new ones
         if (Array.isArray(field.value)) {
             const oldVar = varTerm(`old_${suffix}`);
             deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            whereTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
+            oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
             for (const item of field.value) {
                 if (item && typeof item === 'object' && 'shape' in item && 'fields' in item) {
                     const nested = generateNodeDataTriples(item, options);
@@ -801,49 +854,109 @@ export function updateToAlgebra(query, options) {
         if (typeof field.value === 'object' && 'shape' in field.value && 'fields' in field.value) {
             const oldVar = varTerm(`old_${suffix}`);
             deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-            whereTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
+            oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
             const nested = generateNodeDataTriples(field.value, options);
             insertPatterns.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
             insertPatterns.push(...nested.triples);
             continue;
         }
+        // IRExpression — computed value update (e.g. p.age.plus(1))
+        if (isIRExpression(field.value)) {
+            const expr = field.value;
+            const oldVar = varTerm(`old_${suffix}`);
+            const computedVarName = `computed_${suffix}`;
+            const computedVar = varTerm(computedVarName);
+            // DELETE old value
+            deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
+            // WHERE: OPTIONAL for old value
+            oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
+            // Discover additional property references in the expression and add OPTIONAL triples
+            const registry = new VariableRegistry();
+            const mutationSubjectAlias = '__mutation_subject__';
+            // Pre-register the subject variable mapping for the field being updated
+            registry.set(mutationSubjectAlias, field.property, `old_${suffix}`);
+            const additionalOptionals = [];
+            processExpressionForProperties(expr, registry, additionalOptionals);
+            // Add any additional property OPTIONAL triples (for refs to other properties)
+            for (const triple of additionalOptionals) {
+                // Rewrite the subject from the placeholder variable to the actual subject term
+                if (triple.subject.kind === 'variable' && triple.subject.name === mutationSubjectAlias) {
+                    oldValueTriples.push(tripleOf(subjectTerm, triple.predicate, triple.object));
+                }
+                else {
+                    oldValueTriples.push(triple);
+                }
+            }
+            // Convert IRExpression to SparqlExpression
+            const sparqlExpr = convertExpression(expr, registry, additionalOptionals);
+            // BIND computed expression
+            extends_.push({ variable: computedVarName, expression: sparqlExpr });
+            // INSERT computed value
+            insertPatterns.push(tripleOf(subjectTerm, propertyTerm, computedVar));
+            continue;
+        }
         // Simple value update — delete old + insert new
         const oldVar = varTerm(`old_${suffix}`);
         deletePatterns.push(tripleOf(subjectTerm, propertyTerm, oldVar));
-        whereTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
+        oldValueTriples.push(tripleOf(subjectTerm, propertyTerm, oldVar));
         const terms = fieldValueToTerms(field.value, options);
         for (const term of terms) {
             insertPatterns.push(tripleOf(subjectTerm, propertyTerm, term));
         }
     }
-    // Wrap WHERE triples in OPTIONAL so UPDATE succeeds even when the old
-    // value doesn't exist (e.g. setting bestFriend when none was set before).
-    let whereAlgebra;
-    if (whereTriples.length === 0) {
-        whereAlgebra = { type: 'bgp', triples: [] };
+    return { deletePatterns, insertPatterns, oldValueTriples, extends: extends_ };
+}
+/**
+ * Wraps old-value triples in OPTIONAL (LEFT JOIN) so UPDATE succeeds
+ * even when the old value doesn't exist.
+ */
+function wrapOldValueOptionals(base, oldValueTriples) {
+    let algebra = base;
+    if (oldValueTriples.length === 0) {
+        return algebra;
     }
-    else if (whereTriples.length === 1) {
-        whereAlgebra = {
+    for (const triple of oldValueTriples) {
+        algebra = {
             type: 'left_join',
-            left: { type: 'bgp', triples: [] },
-            right: { type: 'bgp', triples: whereTriples },
+            left: algebra,
+            right: { type: 'bgp', triples: [triple] },
         };
     }
-    else {
-        // Wrap each triple in its own OPTIONAL for independent matching
-        whereAlgebra = { type: 'bgp', triples: [] };
-        for (const triple of whereTriples) {
+    return algebra;
+}
+/**
+ * Converts an IRUpdateMutation to a SparqlDeleteInsertPlan.
+ */
+export function updateToAlgebra(query, options) {
+    const subjectTerm = iriTerm(query.id);
+    const result = processUpdateFields(query.data, subjectTerm, options);
+    let whereAlgebra = wrapOldValueOptionals({ type: 'bgp', triples: [] }, result.oldValueTriples);
+    // Add traversal OPTIONAL patterns (for multi-segment expression refs)
+    // These must come BEFORE expression BINDs since the BINDs reference traversal variables.
+    if (query.traversalPatterns) {
+        for (const trav of query.traversalPatterns) {
+            const fromTerm = trav.from === '__mutation_subject__' ? subjectTerm : varTerm(trav.from);
+            const traversalTriple = tripleOf(fromTerm, iriTerm(trav.property), varTerm(trav.to));
             whereAlgebra = {
                 type: 'left_join',
                 left: whereAlgebra,
-                right: { type: 'bgp', triples: [triple] },
+                right: { type: 'bgp', triples: [traversalTriple] },
             };
         }
     }
+    // Add BIND expressions for computed fields
+    for (const ext of result.extends) {
+        whereAlgebra = {
+            type: 'extend',
+            inner: whereAlgebra,
+            variable: ext.variable,
+            expression: ext.expression,
+        };
+    }
     return {
         type: 'delete_insert',
-        deletePatterns,
-        insertPatterns,
+        deletePatterns: result.deletePatterns,
+        insertPatterns: result.insertPatterns,
         whereAlgebra,
     };
 }
@@ -884,11 +997,221 @@ export function deleteToAlgebra(query, _options) {
     };
 }
 // ---------------------------------------------------------------------------
+// Blank node tree walking for schema-aware delete cleanup
+// ---------------------------------------------------------------------------
+/**
+ * Checks whether a PropertyShape points to blank nodes (sh:BlankNode or
+ * sh:BlankNodeOrIRI). Returns true when the property's range *may* include
+ * blank node values that should be cleaned up on delete.
+ */
+function isBlankNodeProperty(prop) {
+    var _a;
+    const nk = (_a = prop.nodeKind) === null || _a === void 0 ? void 0 : _a.id;
+    if (!nk)
+        return false;
+    const s = lazyShacl();
+    return nk === s.BlankNode.id || nk === s.BlankNodeOrIRI.id;
+}
+/**
+ * Recursively builds DELETE + WHERE patterns for blank-node-typed properties.
+ *
+ * For each blank-node property on the shape:
+ * - DELETE: `?bnVar ?pN ?oN .`  (wildcard all triples on the blank node)
+ * - WHERE: `OPTIONAL { ?parent <property> ?bnVar . FILTER(isBlank(?bnVar)) . ?bnVar ?pN ?oN . }`
+ *
+ * Recurses into the property's valueShape to handle nested blank nodes
+ * (e.g. Person → Address (blank) → GeoPoint (blank)).
+ */
+function walkBlankNodeTree(shapeId, parentVar, depth, deletePatterns) {
+    var _a;
+    const shapeClass = lazyGetShapeClass(shapeId);
+    if (!(shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.shape))
+        return null;
+    let optionals = null;
+    const props = shapeClass.shape.getPropertyShapes(true);
+    for (const prop of props) {
+        if (!isBlankNodeProperty(prop))
+            continue;
+        const bnVar = `bn${depth}`;
+        const pVar = `p${depth}`;
+        const oVar = `o${depth}`;
+        // DELETE pattern: wildcard all triples on the blank node
+        deletePatterns.push(tripleOf(varTerm(bnVar), varTerm(pVar), varTerm(oVar)));
+        // WHERE: parent --<property>--> ?bnVar
+        const traverseTriple = tripleOf(varTerm(parentVar), iriTerm(prop.path[0].id), varTerm(bnVar));
+        // FILTER(isBlank(?bnVar))
+        const isBlankFilter = {
+            kind: 'function_expr',
+            name: 'isBlank',
+            args: [{ kind: 'variable_expr', name: bnVar }],
+        };
+        // ?bnVar ?pN ?oN
+        const wildcardTriple = tripleOf(varTerm(bnVar), varTerm(pVar), varTerm(oVar));
+        // Build inner pattern: traverse + filter + wildcard
+        let innerPattern = {
+            type: 'bgp',
+            triples: [traverseTriple, wildcardTriple],
+        };
+        innerPattern = { type: 'filter', expression: isBlankFilter, inner: innerPattern };
+        // Recurse into valueShape for nested blank nodes
+        if ((_a = prop.valueShape) === null || _a === void 0 ? void 0 : _a.id) {
+            const nestedOptional = walkBlankNodeTree(prop.valueShape.id, bnVar, depth + 1, deletePatterns);
+            if (nestedOptional) {
+                innerPattern = { type: 'left_join', left: innerPattern, right: nestedOptional };
+            }
+        }
+        // Wrap in OPTIONAL (left_join)
+        if (optionals) {
+            optionals = { type: 'left_join', left: optionals, right: innerPattern };
+        }
+        else {
+            optionals = innerPattern;
+        }
+        depth++;
+    }
+    return optionals;
+}
+/**
+ * Converts an IRDeleteAllMutation to a SparqlDeleteInsertPlan.
+ *
+ * Generates DELETE { ?a0 ?p ?o . [blank node wildcards] }
+ *          WHERE  { ?a0 a <Shape> . ?a0 ?p ?o . OPTIONAL { [blank node traversals] } }
+ */
+export function deleteAllToAlgebra(query, _options) {
+    const subjectVar = 'a0';
+    // DELETE patterns: root wildcard
+    const deletePatterns = [
+        tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o')),
+    ];
+    // WHERE: type triple + root wildcard
+    const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(query.shape));
+    const rootWildcard = tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o'));
+    let whereAlgebra = { type: 'bgp', triples: [typeTriple, rootWildcard] };
+    // Walk blank node tree for cleanup
+    const blankNodeOptional = walkBlankNodeTree(query.shape, subjectVar, 1, deletePatterns);
+    if (blankNodeOptional) {
+        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: blankNodeOptional };
+    }
+    return {
+        type: 'delete_insert',
+        deletePatterns,
+        insertPatterns: [],
+        whereAlgebra,
+    };
+}
+/**
+ * Converts an IRDeleteWhereMutation to a SparqlDeleteInsertPlan.
+ *
+ * Like deleteAllToAlgebra but adds filter conditions from the where clause.
+ */
+export function deleteWhereToAlgebra(query, _options) {
+    const subjectVar = 'a0';
+    const registry = new VariableRegistry();
+    // DELETE patterns: root wildcard
+    const deletePatterns = [
+        tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o')),
+    ];
+    // WHERE: type triple + root wildcard
+    const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(query.shape));
+    const rootWildcard = tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o'));
+    let whereAlgebra = { type: 'bgp', triples: [typeTriple, rootWildcard] };
+    // Process where patterns (traversals from the where clause)
+    const traverseTriples = [];
+    const optionalPropertyTriples = [];
+    for (const pattern of query.wherePatterns) {
+        processPattern(pattern, registry, traverseTriples, optionalPropertyTriples);
+    }
+    // Add traverse triples to required BGP
+    if (traverseTriples.length > 0) {
+        whereAlgebra = joinNodes(whereAlgebra, { type: 'bgp', triples: traverseTriples });
+    }
+    // Process expression to discover property triples
+    processExpressionForProperties(query.where, registry, optionalPropertyTriples);
+    // Add optional property triples
+    for (const triple of optionalPropertyTriples) {
+        whereAlgebra = joinNodes(whereAlgebra, { type: 'bgp', triples: [triple] });
+    }
+    // Convert and add filter expression
+    const filterExpr = convertExpression(query.where, registry, []);
+    whereAlgebra = { type: 'filter', expression: filterExpr, inner: whereAlgebra };
+    // Walk blank node tree for cleanup
+    const blankNodeOptional = walkBlankNodeTree(query.shape, subjectVar, 1, deletePatterns);
+    if (blankNodeOptional) {
+        whereAlgebra = { type: 'left_join', left: whereAlgebra, right: blankNodeOptional };
+    }
+    return {
+        type: 'delete_insert',
+        deletePatterns,
+        insertPatterns: [],
+        whereAlgebra,
+    };
+}
+/**
+ * Converts an IRUpdateWhereMutation to a SparqlDeleteInsertPlan.
+ *
+ * Like updateToAlgebra but uses a variable subject (?a0) instead of a
+ * hardcoded entity IRI, adds a type triple, and optionally includes
+ * filter conditions from the where clause.
+ */
+export function updateWhereToAlgebra(query, options) {
+    const subjectTerm = varTerm('a0');
+    const result = processUpdateFields(query.data, subjectTerm, options);
+    // WHERE: type triple is always required
+    const typeTriple = tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(query.data.shape));
+    let whereAlgebra = { type: 'bgp', triples: [typeTriple] };
+    // Process where filter conditions (if any)
+    if (query.where && query.wherePatterns) {
+        const registry = new VariableRegistry();
+        const traverseTriples = [];
+        const optionalPropertyTriples = [];
+        for (const pattern of query.wherePatterns) {
+            processPattern(pattern, registry, traverseTriples, optionalPropertyTriples);
+        }
+        if (traverseTriples.length > 0) {
+            whereAlgebra = joinNodes(whereAlgebra, { type: 'bgp', triples: traverseTriples });
+        }
+        processExpressionForProperties(query.where, registry, optionalPropertyTriples);
+        for (const triple of optionalPropertyTriples) {
+            whereAlgebra = joinNodes(whereAlgebra, { type: 'bgp', triples: [triple] });
+        }
+        const filterExpr = convertExpression(query.where, registry, []);
+        whereAlgebra = { type: 'filter', expression: filterExpr, inner: whereAlgebra };
+    }
+    whereAlgebra = wrapOldValueOptionals(whereAlgebra, result.oldValueTriples);
+    // Add traversal OPTIONAL patterns (for multi-segment expression refs)
+    // These must come BEFORE expression BINDs since the BINDs reference traversal variables.
+    if (query.traversalPatterns) {
+        for (const trav of query.traversalPatterns) {
+            const fromTerm = trav.from === '__mutation_subject__' ? varTerm('a0') : varTerm(trav.from);
+            const traversalTriple = tripleOf(fromTerm, iriTerm(trav.property), varTerm(trav.to));
+            whereAlgebra = {
+                type: 'left_join',
+                left: whereAlgebra,
+                right: { type: 'bgp', triples: [traversalTriple] },
+            };
+        }
+    }
+    // Add BIND expressions for computed fields
+    for (const ext of result.extends) {
+        whereAlgebra = {
+            type: 'extend',
+            inner: whereAlgebra,
+            variable: ext.variable,
+            expression: ext.expression,
+        };
+    }
+    return {
+        type: 'delete_insert',
+        deletePatterns: result.deletePatterns,
+        insertPatterns: result.insertPatterns,
+        whereAlgebra,
+    };
+}
+// ---------------------------------------------------------------------------
 // Convenience wrappers: IR → algebra → SPARQL string in one call
 // ---------------------------------------------------------------------------
 /**
  * Converts an IRSelectQuery to a SPARQL string.
- * Stub: will be implemented when algebraToString is available.
  */
 export function selectToSparql(query, options) {
     const plan = selectToAlgebra(query, options);
@@ -912,10 +1235,30 @@ export function updateToSparql(query, options) {
 }
 /**
  * Converts an IRDeleteMutation to a SPARQL string.
- * Stub: will be implemented when algebraToString is available.
  */
 export function deleteToSparql(query, options) {
     const plan = deleteToAlgebra(query, options);
     return deleteInsertPlanToSparql(plan, options);
 }
+/**
+ * Converts an IRDeleteAllMutation to a SPARQL string.
+ */
+export function deleteAllToSparql(query, options) {
+    const plan = deleteAllToAlgebra(query, options);
+    return deleteInsertPlanToSparql(plan, options);
+}
+/**
+ * Converts an IRDeleteWhereMutation to a SPARQL string.
+ */
+export function deleteWhereToSparql(query, options) {
+    const plan = deleteWhereToAlgebra(query, options);
+    return deleteInsertPlanToSparql(plan, options);
+}
+/**
+ * Converts an IRUpdateWhereMutation to a SPARQL string.
+ */
+export function updateWhereToSparql(query, options) {
+    const plan = updateWhereToAlgebra(query, options);
+    return deleteInsertPlanToSparql(plan, options);
+}
 //# sourceMappingURL=irToAlgebra.js.map