@_linked/core 2.6.0-next.20260509053822 → 2.6.0

package/lib/cjs/sparql/irToAlgebra.js

@@ -17,26 +17,11 @@ exports.updateWhereToSparql = updateWhereToSparql;
 const pathExprToSparql_js_1 = require("../paths/pathExprToSparql.js");
 const sparqlUtils_js_1 = require("./sparqlUtils.js");
 const algebraToString_js_1 = require("./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;
-}
 const rdf_js_1 = require("../ontologies/rdf.js");
+const shacl_js_1 = require("../ontologies/shacl.js");
 const xsd_js_1 = require("../ontologies/xsd.js");
+const normalizePropertyPath_js_1 = require("../paths/normalizePropertyPath.js");
+const ShapeClass_js_1 = require("../utils/ShapeClass.js");
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -63,6 +48,30 @@ function literalTerm(value, datatype) {
 function tripleOf(subject, predicate, object) {
     return { subject, predicate, object };
 }
+function shouldResolveShapeOrPropertyId(resolvedId) {
+    return !!resolvedId && !resolvedId.startsWith('linked://tmp/');
+}
+function resolveShapeScanIri(shapeId) {
+    var _a;
+    const shapeClass = (0, ShapeClass_js_1.getShapeClass)(shapeId);
+    const targetClassId = (_a = shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.targetClass) === null || _a === void 0 ? void 0 : _a.id;
+    return shouldResolveShapeOrPropertyId(targetClassId) ? targetClassId : shapeId;
+}
+function resolvePropertyPredicateIri(propertyId) {
+    var _a, _b, _c;
+    const shapeClasses = (0, ShapeClass_js_1.getAllShapeClasses)();
+    for (const shapeClass of shapeClasses.values()) {
+        const propertyShape = (_c = (_b = (_a = shapeClass.shape) === null || _a === void 0 ? void 0 : _a.getPropertyShapes) === null || _b === void 0 ? void 0 : _b.call(_a, true)) === null || _c === void 0 ? void 0 : _c.find((prop) => prop.id === propertyId);
+        if (!propertyShape)
+            continue;
+        const simplePathId = (0, normalizePropertyPath_js_1.getSimplePathId)(propertyShape.path);
+        if (shouldResolveShapeOrPropertyId(simplePathId)) {
+            return simplePathId;
+        }
+        break;
+    }
+    return propertyId;
+}
 /** Produce variable name suffix from the last segment of a property URI. */
 function propertySuffix(propertyUri) {
     const hashIdx = propertyUri.lastIndexOf('#');
@@ -157,6 +166,147 @@ function collectTraversalAliases(patterns) {
     }
     return aliases;
 }
+function buildTraverseTriple(pattern) {
+    const predicate = pattern.pathExpr
+        ? {
+            kind: 'path',
+            value: (0, pathExprToSparql_js_1.pathExprToSparql)(pattern.pathExpr),
+            uris: (0, pathExprToSparql_js_1.collectPathUris)(pattern.pathExpr),
+        }
+        : iriTerm(resolvePropertyPredicateIri(pattern.property));
+    return tripleOf(varTerm(pattern.from), predicate, varTerm(pattern.to));
+}
+function collectTraversePatternsInOrder(patterns, out = []) {
+    for (const pattern of patterns) {
+        switch (pattern.kind) {
+            case 'traverse':
+                out.push(pattern);
+                break;
+            case 'join':
+                collectTraversePatternsInOrder(pattern.patterns, out);
+                break;
+            case 'optional':
+            case 'exists':
+                collectTraversePatternsInOrder([pattern.pattern], out);
+                break;
+            case 'union':
+                for (const branch of pattern.branches) {
+                    collectTraversePatternsInOrder([branch], out);
+                }
+                break;
+            case 'shape_scan':
+            case 'minus':
+                break;
+        }
+    }
+    return out;
+}
+function collectDirectProjectionAliases(query, rootAlias) {
+    const aliases = new Set();
+    for (const item of query.projection) {
+        if (item.expression.kind === 'property_expr') {
+            if (item.expression.sourceAlias !== rootAlias) {
+                aliases.add(item.expression.sourceAlias);
+            }
+        }
+        else if (item.expression.kind === 'alias_expr') {
+            if (item.expression.alias !== rootAlias) {
+                aliases.add(item.expression.alias);
+            }
+        }
+    }
+    return aliases;
+}
+function collectExpressionAliases(expr, aliases) {
+    switch (expr.kind) {
+        case 'property_expr':
+            aliases.add(expr.sourceAlias);
+            break;
+        case 'alias_expr':
+            aliases.add(expr.alias);
+            break;
+        case 'binary_expr':
+            collectExpressionAliases(expr.left, aliases);
+            collectExpressionAliases(expr.right, aliases);
+            break;
+        case 'logical_expr':
+            for (const sub of expr.expressions) {
+                collectExpressionAliases(sub, aliases);
+            }
+            break;
+        case 'not_expr':
+            collectExpressionAliases(expr.expression, aliases);
+            break;
+        case 'function_expr':
+        case 'aggregate_expr':
+            for (const arg of expr.args) {
+                collectExpressionAliases(arg, aliases);
+            }
+            break;
+        case 'exists_expr':
+            if (expr.filter) {
+                collectExpressionAliases(expr.filter, aliases);
+            }
+            break;
+        case 'literal_expr':
+        case 'reference_expr':
+        case 'context_property_expr':
+            break;
+    }
+}
+function markAliasAndAncestors(alias, traversePatternMap, target) {
+    var _a;
+    let currentAlias = alias;
+    while (currentAlias && traversePatternMap.has(currentAlias)) {
+        if (target.has(currentAlias)) {
+            return;
+        }
+        target.add(currentAlias);
+        currentAlias = (_a = traversePatternMap.get(currentAlias)) === null || _a === void 0 ? void 0 : _a.from;
+    }
+}
+function collectRequiredTraversalAliases(query, traversePatternMap) {
+    const directAliases = new Set();
+    if (query.where) {
+        collectExpressionAliases(query.where, directAliases);
+    }
+    if (query.orderBy) {
+        for (const item of query.orderBy) {
+            collectExpressionAliases(item.expression, directAliases);
+        }
+    }
+    for (const pattern of traversePatternMap.values()) {
+        if (pattern.filter) {
+            directAliases.add(pattern.to);
+        }
+    }
+    const requiredAliases = new Set();
+    for (const alias of directAliases) {
+        markAliasAndAncestors(alias, traversePatternMap, requiredAliases);
+    }
+    return requiredAliases;
+}
+function buildOptionalTraversalSubtree(alias, traversePatternMap, childOptionalAliasesByParent, propertyTriplesByAlias) {
+    var _a, _b;
+    const pattern = traversePatternMap.get(alias);
+    if (!pattern) {
+        throw new Error(`Missing traverse pattern for alias "${alias}"`);
+    }
+    let subtree = {
+        type: 'bgp',
+        triples: [buildTraverseTriple(pattern)],
+    };
+    for (const propTriple of (_a = propertyTriplesByAlias.get(alias)) !== null && _a !== void 0 ? _a : []) {
+        subtree = wrapOptional(subtree, {
+            type: 'bgp',
+            triples: [propTriple],
+        });
+    }
+    for (const childAlias of (_b = childOptionalAliasesByParent.get(alias)) !== null && _b !== void 0 ? _b : []) {
+        subtree = wrapOptional(subtree, buildOptionalTraversalSubtree(childAlias, traversePatternMap, childOptionalAliasesByParent, propertyTriplesByAlias));
+    }
+    return subtree;
+}
 // ---------------------------------------------------------------------------
 // Variable Registry
 // ---------------------------------------------------------------------------
@@ -229,6 +379,7 @@ function containsAggregate(expr) {
  * Converts an IRSelectQuery to a SparqlSelectPlan.
  */
 function selectToAlgebra(query, _options) {
+    var _a, _b;
     const registry = new VariableRegistry();
     // Promote bindings only when the top-level WHERE would reject rows without
     // them. This keeps human-like SPARQL for null-rejecting filters without
@@ -248,10 +399,12 @@ function selectToAlgebra(query, _options) {
     }
     const rootAlias = query.root.alias;
     const shapeUri = query.root.shape;
-    const typeTriple = tripleOf(varTerm(rootAlias), iriTerm(RDF_TYPE), iriTerm(shapeUri));
+    const typeTriple = tripleOf(varTerm(rootAlias), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(shapeUri)));
     const requiredTriples = [typeTriple];
     // Track traverse triples (required pattern)
     const traverseTriples = [];
+    const traversePatternsInOrder = collectTraversePatternsInOrder(query.patterns);
+    const traversePatternMap = new Map(traversePatternsInOrder.map((pattern) => [pattern.to, pattern]));
     // 2. Process patterns → traverse triples, populate variable registry
     for (const pattern of query.patterns) {
         processPattern(pattern, registry, traverseTriples, optionalPropertyTriples, filteredTraverseBlocks);
@@ -279,12 +432,53 @@ function selectToAlgebra(query, _options) {
             processExpressionForProperties(orderItem.expression, registry, optionalPropertyTriples, requiredPropertyTriples, requiredPropertyKeys);
         }
     }
+    const projectedTraversalAliases = new Set();
+    const directProjectionAliases = collectDirectProjectionAliases(query, rootAlias);
+    for (const alias of directProjectionAliases) {
+        markAliasAndAncestors(alias, traversePatternMap, projectedTraversalAliases);
+    }
+    const requiredTraversalAliases = collectRequiredTraversalAliases(query, traversePatternMap);
+    const optionalTraversalAliases = new Set([...projectedTraversalAliases].filter((alias) => {
+        const pattern = traversePatternMap.get(alias);
+        return !!pattern &&
+            typeof pattern.maxCount === 'number' &&
+            pattern.maxCount <= 1 &&
+            !pattern.filter &&
+            !requiredTraversalAliases.has(alias);
+    }));
+    const requiredTraverseTriples = traverseTriples.filter((triple) => !(triple.object.kind === 'variable' &&
+        optionalTraversalAliases.has(triple.object.name)));
+    const nestedOptionalPropertyTriplesByAlias = new Map();
+    const topLevelOptionalPropertyTriples = [];
+    for (const propTriple of optionalPropertyTriples) {
+        if (propTriple.subject.kind === 'variable' &&
+            optionalTraversalAliases.has(propTriple.subject.name)) {
+            const triples = (_a = nestedOptionalPropertyTriplesByAlias.get(propTriple.subject.name)) !== null && _a !== void 0 ? _a : [];
+            triples.push(propTriple);
+            nestedOptionalPropertyTriplesByAlias.set(propTriple.subject.name, triples);
+        }
+        else {
+            topLevelOptionalPropertyTriples.push(propTriple);
+        }
+    }
+    const childOptionalAliasesByParent = new Map();
+    for (const pattern of traversePatternsInOrder) {
+        if (!optionalTraversalAliases.has(pattern.to))
+            continue;
+        const siblings = (_b = childOptionalAliasesByParent.get(pattern.from)) !== null && _b !== void 0 ? _b : [];
+        siblings.push(pattern.to);
+        childOptionalAliasesByParent.set(pattern.from, siblings);
+    }
+    const rootOptionalTraversalAliases = traversePatternsInOrder
+        .filter((pattern) => optionalTraversalAliases.has(pattern.to) &&
+        !optionalTraversalAliases.has(pattern.from))
+        .map((pattern) => pattern.to);
     // 5. Build the algebra tree
     //    - Start with the required BGP (type triple + traverse triples)
     //    - Wrap each optional property triple in a LeftJoin
     const requiredBgp = {
         type: 'bgp',
-        triples: [...requiredTriples, ...traverseTriples, ...requiredPropertyTriples],
+        triples: [...requiredTriples, ...requiredTraverseTriples, ...requiredPropertyTriples],
     };
     let algebra = requiredBgp;
     // 5b. Build filtered OPTIONAL blocks for inline where traversals.
@@ -304,8 +498,11 @@ function selectToAlgebra(query, _options) {
         const filteredBlock = { type: 'filter', expression: filterExpr, inner: blockInner };
         algebra = wrapOptional(algebra, filteredBlock);
     }
+    for (const alias of rootOptionalTraversalAliases) {
+        algebra = wrapOptional(algebra, buildOptionalTraversalSubtree(alias, traversePatternMap, childOptionalAliasesByParent, nestedOptionalPropertyTriplesByAlias));
+    }
     // Wrap each optional property triple in its own OPTIONAL (LeftJoin)
-    for (const propTriple of optionalPropertyTriples) {
+    for (const propTriple of topLevelOptionalPropertyTriples) {
         algebra = wrapOptional(algebra, {
             type: 'bgp',
             triples: [propTriple],
@@ -474,10 +671,7 @@ function processPattern(pattern, registry, traverseTriples, optionalPropertyTrip
             // Register the traverse variable: (from, property) → to
             registry.set(pattern.from, pattern.property, pattern.to);
             // Add traverse triple to required pattern (or filtered block if inline where)
-            const predicate = pattern.pathExpr
-                ? { kind: 'path', value: (0, pathExprToSparql_js_1.pathExprToSparql)(pattern.pathExpr), uris: (0, pathExprToSparql_js_1.collectPathUris)(pattern.pathExpr) }
-                : iriTerm(pattern.property);
-            const triple = tripleOf(varTerm(pattern.from), predicate, varTerm(pattern.to));
+            const triple = buildTraverseTriple(pattern);
             if (pattern.filter && filteredTraverseBlocks) {
                 filteredTraverseBlocks.push({
                     traverseTriple: triple,
@@ -527,7 +721,7 @@ function processExpressionForProperties(expr, registry, optionalPropertyTriples,
                 const varName = registry.getOrCreate(expr.sourceAlias, expr.property);
                 const predicate = expr.pathExpr
                     ? { kind: 'path', value: (0, pathExprToSparql_js_1.pathExprToSparql)(expr.pathExpr), uris: (0, pathExprToSparql_js_1.collectPathUris)(expr.pathExpr) }
-                    : iriTerm(expr.property);
+                    : iriTerm(resolvePropertyPredicateIri(expr.property));
                 const triple = tripleOf(varTerm(expr.sourceAlias), predicate, varTerm(varName));
                 const triples = requiredPropertyKeys.has(bindingKey(expr.sourceAlias, expr.property))
                     ? requiredPropertyTriples
@@ -570,7 +764,7 @@ function processExpressionForProperties(expr, registry, optionalPropertyTriples,
             const ctxKey = contextAliasKey(expr.contextIri);
             if (!registry.has(ctxKey, expr.property)) {
                 const varName = registry.getOrCreate(ctxKey, expr.property);
-                const triple = tripleOf(iriTerm(expr.contextIri), iriTerm(expr.property), varTerm(varName));
+                const triple = tripleOf(iriTerm(expr.contextIri), iriTerm(resolvePropertyPredicateIri(expr.property)), varTerm(varName));
                 const triples = requiredPropertyKeys.has(bindingKey(ctxKey, expr.property))
                     ? requiredPropertyTriples
                     : optionalPropertyTriples;
@@ -739,7 +933,7 @@ function convertExistsPattern(pattern, registry) {
         case 'traverse': {
             const existsPredicate = pattern.pathExpr
                 ? { kind: 'path', value: (0, pathExprToSparql_js_1.pathExprToSparql)(pattern.pathExpr), uris: (0, pathExprToSparql_js_1.collectPathUris)(pattern.pathExpr) }
-                : iriTerm(pattern.property);
+                : iriTerm(resolvePropertyPredicateIri(pattern.property));
             const triple = tripleOf(varTerm(pattern.from), existsPredicate, varTerm(pattern.to));
             return { type: 'bgp', triples: [triple] };
         }
@@ -755,7 +949,7 @@ function convertExistsPattern(pattern, registry) {
             return {
                 type: 'bgp',
                 triples: [
-                    tripleOf(varTerm(pattern.alias), iriTerm(RDF_TYPE), iriTerm(pattern.shape)),
+                    tripleOf(varTerm(pattern.alias), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(pattern.shape))),
                 ],
             };
         }
@@ -850,11 +1044,14 @@ function generateNodeDataTriples(data, options) {
     const uri = data.id || (0, sparqlUtils_js_1.generateEntityUri)(data.shape, options);
     const triples = [];
     const subjectTerm = iriTerm(uri);
-    // Type triple
-    triples.push(tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(data.shape)));
+    // Type triple — resolve the SHACL NodeShape id in the IR to the ontology
+    // targetClass URI (sibling of PR #77's SELECT-side resolveShapeScanIri).
+    // Mutations were not covered by #77; see mutation-uri-fidelity.test.ts.
+    triples.push(tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(data.shape))));
     // Field triples
     for (const field of data.fields) {
-        const propertyTerm = iriTerm(field.property);
+        // Resolve the SHACL PropertyShape id to its declared `path` URI.
+        const propertyTerm = iriTerm(resolvePropertyPredicateIri(field.property));
         if (field.value === null || field.value === undefined) {
             continue;
         }
@@ -914,7 +1111,7 @@ function processUpdateFields(data, subjectTerm, options) {
     const oldValueTriples = [];
     const extends_ = [];
     for (const field of data.fields) {
-        const propertyTerm = iriTerm(field.property);
+        const propertyTerm = iriTerm(resolvePropertyPredicateIri(field.property));
         const suffix = propertySuffix(field.property);
         // Check for set modification ({add, remove})
         if (field.value &&
@@ -1098,7 +1295,7 @@ function deleteToAlgebra(query, _options) {
         const idx = query.ids.length > 1 ? `_${i}` : '';
         const subjWild = tripleOf(subjectTerm, varTerm(`p${idx}`), varTerm(`o${idx}`));
         const objWild = tripleOf(varTerm(`s${idx}`), varTerm(`p2${idx}`), subjectTerm);
-        const typeGuard = tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(query.shape));
+        const typeGuard = tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.shape)));
         // DELETE block: all patterns (subject-wildcard, object-wildcard, type)
         deletePatterns.push(subjWild, objWild, typeGuard);
         // WHERE block: subject-wildcard and type guard are required;
@@ -1135,8 +1332,7 @@ function isBlankNodeProperty(prop) {
     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;
+    return nk === shacl_js_1.shacl.BlankNode.id || nk === shacl_js_1.shacl.BlankNodeOrIRI.id;
 }
 /**
  * Recursively builds DELETE + WHERE patterns for blank-node-typed properties.
@@ -1150,7 +1346,7 @@ function isBlankNodeProperty(prop) {
  */
 function walkBlankNodeTree(shapeId, parentVar, depth, deletePatterns) {
     var _a;
-    const shapeClass = lazyGetShapeClass(shapeId);
+    const shapeClass = (0, ShapeClass_js_1.getShapeClass)(shapeId);
     if (!(shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.shape))
         return null;
     let optionals = null;
@@ -1164,7 +1360,7 @@ function walkBlankNodeTree(shapeId, parentVar, depth, deletePatterns) {
         // 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));
+        const traverseTriple = tripleOf(varTerm(parentVar), iriTerm(resolvePropertyPredicateIri(prop.id)), varTerm(bnVar));
         // FILTER(isBlank(?bnVar))
         const isBlankFilter = {
             kind: 'function_expr',
@@ -1210,7 +1406,7 @@ function deleteAllToAlgebra(query, _options) {
         tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o')),
     ];
     // WHERE: type triple + root wildcard
-    const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(query.shape));
+    const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.shape)));
     const rootWildcard = tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o'));
     let whereAlgebra = { type: 'bgp', triples: [typeTriple, rootWildcard] };
     // Walk blank node tree for cleanup
@@ -1238,7 +1434,7 @@ function deleteWhereToAlgebra(query, _options) {
         tripleOf(varTerm(subjectVar), varTerm('p'), varTerm('o')),
     ];
     // WHERE: type triple + root wildcard
-    const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(query.shape));
+    const typeTriple = tripleOf(varTerm(subjectVar), iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(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)
@@ -1283,7 +1479,7 @@ 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));
+    const typeTriple = tripleOf(subjectTerm, iriTerm(RDF_TYPE), iriTerm(resolveShapeScanIri(query.data.shape)));
     let whereAlgebra = { type: 'bgp', triples: [typeTriple] };
     // Process where filter conditions (if any)
     if (query.where && query.wherePatterns) {