@_linked/core 2.29.0 → 2.30.0

package/lib/esm/sparql/irToAlgebra.js

@@ -1421,18 +1421,65 @@ function fieldValueToTerms(value, options, datatype) {
     }
     return [];
 }
+/**
+ * The RDF-collection and SHACL-path predicates the cascade's blank-node block walks inside a
+ * blank structure: the syntax core writes as blank nodes (`serializePathToNodeData`).
+ */
+const BLANK_SYNTAX_PREDICATES = [
+    rdf.first.id,
+    rdf.rest.id,
+    shacl.inversePath.id,
+    shacl.alternativePath.id,
+    shacl.zeroOrMorePath.id,
+    shacl.oneOrMorePath.id,
+    shacl.zeroOrOnePath.id,
+];
+/**
+ * A blank node is removed only by the cascade's blank-node block, which reaches it through a
+ * `contains` edge, or, inside a blank structure, through a list / path syntax predicate
+ * (`rdf:first` of a blank list cell). A blank node held any other way could never be deleted:
+ * refuse to write one.
+ */
+function assertBlankIsOwned(data, propertyId, propertyTerm, parentIsBlank) {
+    var _a;
+    if (!data.blank || ((_a = findPropertyShapeById(propertyId)) === null || _a === void 0 ? void 0 : _a.contains))
+        return;
+    const syntaxEdge = parentIsBlank && propertyTerm.kind === 'iri' && BLANK_SYNTAX_PREDICATES.includes(propertyTerm.value);
+    if (syntaxEdge)
+        return;
+    throw new Error(`A blank nested node (__blank) must be the value of a \`contains\` property, or of a list / ` +
+        `path syntax predicate inside a blank node; ${propertyId} is neither, so nothing would ` +
+        `ever delete it.`);
+}
 /**
  * Recursively generate triples for an IRNodeData (used in create and nested creates).
- * Returns the URI used for this node and all generated triples.
+ * Returns the term used for this node and all generated triples.
+ *
+ * A node marked `blank` (nested only, see `NodeDescriptionValue.__blank`) becomes a fresh
+ * blank node with its field triples and NO `rdf:type`: it is RDF syntax, like a SHACL path
+ * operator, which the spec defines as a blank node that is the subject of exactly one triple.
+ * Without a `blanks` minter (the update paths) a blank node throws.
  */
-function generateNodeDataTriples(data, options) {
-    const uri = data.id || generateEntityUri(data.shape, options);
+function generateNodeDataTriples(data, options, blanks) {
     const triples = [];
-    const subjectTerm = iriTerm(uri);
-    // Type triple — resolve the SHACL NodeShapeData 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))));
+    let subjectTerm;
+    if (data.blank) {
+        if (data.id) {
+            throw new Error(`A blank nested node (__blank) cannot carry an id (${data.id}).`);
+        }
+        if (!blanks) {
+            throw new Error('A blank nested node (__blank) can only be written by a create. An update writes its ' +
+                'INSERT once per WHERE solution, which would duplicate the blank node.');
+        }
+        subjectTerm = { kind: 'blank', label: `b${blanks.next++}` };
+    }
+    else {
+        subjectTerm = iriTerm(data.id || generateEntityUri(data.shape, options));
+        // Type triple — resolve the SHACL NodeShapeData 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) {
         // Resolve the SHACL PropertyShapeData id to its declared `path` URI.
@@ -1445,8 +1492,9 @@ function generateNodeDataTriples(data, options) {
             for (const item of field.value) {
                 if (item && typeof item === 'object' && 'shape' in item && 'fields' in item) {
                     // Nested create
-                    const nested = generateNodeDataTriples(item, options);
-                    triples.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
+                    assertBlankIsOwned(item, field.property, propertyTerm, !!data.blank);
+                    const nested = generateNodeDataTriples(item, options, blanks);
+                    triples.push(tripleOf(subjectTerm, propertyTerm, nested.term));
                     triples.push(...nested.triples);
                 }
                 else {
@@ -1460,8 +1508,9 @@ function generateNodeDataTriples(data, options) {
         }
         // Handle nested IRNodeData
         if (typeof field.value === 'object' && 'shape' in field.value && 'fields' in field.value) {
-            const nested = generateNodeDataTriples(field.value, options);
-            triples.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
+            assertBlankIsOwned(field.value, field.property, propertyTerm, !!data.blank);
+            const nested = generateNodeDataTriples(field.value, options, blanks);
+            triples.push(tripleOf(subjectTerm, propertyTerm, nested.term));
             triples.push(...nested.triples);
             continue;
         }
@@ -1471,13 +1520,16 @@ function generateNodeDataTriples(data, options) {
             triples.push(tripleOf(subjectTerm, propertyTerm, term));
         }
     }
-    return { uri, triples };
+    return { term: subjectTerm, triples };
 }
 /**
  * Converts an IRCreateMutation to a SparqlInsertDataPlan.
  */
 export function createToAlgebra(query, options) {
-    const { triples } = generateNodeDataTriples(query.data, options);
+    if (query.data.blank) {
+        throw new Error('The root node of a create cannot be blank (__blank): it must be addressable.');
+    }
+    const { triples } = generateNodeDataTriples(query.data, options, { next: 0 });
     return {
         type: 'insert_data',
         triples,
@@ -1568,7 +1620,7 @@ function processUpdateFields(data, subjectTerm, options) {
                 for (const addItem of setMod.add) {
                     if (addItem && typeof addItem === 'object' && 'shape' in addItem && 'fields' in addItem) {
                         const nested = generateNodeDataTriples(addItem, options);
-                        insertPatterns.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
+                        insertPatterns.push(tripleOf(subjectTerm, propertyTerm, nested.term));
                         insertPatterns.push(...nested.triples);
                     }
                     else {
@@ -1606,7 +1658,7 @@ function processUpdateFields(data, subjectTerm, options) {
             for (const item of field.value) {
                 if (item && typeof item === 'object' && 'shape' in item && 'fields' in item) {
                     const nested = generateNodeDataTriples(item, options);
-                    insertPatterns.push(tripleOf(subjectTerm, propertyTerm, iriTerm(nested.uri)));
+                    insertPatterns.push(tripleOf(subjectTerm, propertyTerm, nested.term));
                     insertPatterns.push(...nested.triples);
                 }
                 else {
@@ -1624,7 +1676,7 @@ function processUpdateFields(data, subjectTerm, options) {
             deletePatterns.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(tripleOf(subjectTerm, propertyTerm, nested.term));
             insertPatterns.push(...nested.triples);
             continue;
         }
@@ -2080,6 +2132,50 @@ export function buildOwnedCascade(rootTerm, varPrefix, anchor, keep, onlyTypes)
             ],
         }, rootTerm, keep));
     });
+    // Blank nodes carry no type (a SHACL path operator must be the subject of exactly one
+    // triple), so the typed blocks above cannot see them. Every blank node owned through
+    // `contains` edges (`?b0`) is deleted, together with the RDF-list / SHACL-path syntax below it
+    // (`?bn`). That inner walk follows `rdf:first` too, because a sequence member that is itself a
+    // path operator is held by `rdf:first`, which is not a `contains` edge. It is restricted to the
+    // syntax predicates on purpose: SPARQL cannot require the nodes *between* `?b0` and `?bn` to be
+    // blank, so following every `contains` edge there would let a list's `rdf:first` lead into an
+    // entity it merely lists and delete that entity's blank children.
+    const insidePathExpr = { zeroOrMore: { alt: BLANK_SYNTAX_PREDICATES.map((id) => ({ id })) } };
+    const insidePathTerm = {
+        kind: 'path',
+        value: pathExprToSparql(insidePathExpr),
+        uris: collectPathUris(insidePathExpr),
+    };
+    const ownedBlank = varTerm(`${varPrefix}bn0`);
+    const blank = varTerm(`${varPrefix}bn`);
+    const bp = varTerm(`${varPrefix}bnp`);
+    const bo = varTerm(`${varPrefix}bno`);
+    const isBlank = (name) => ({
+        kind: 'function_expr',
+        name: 'isBlank',
+        args: [{ kind: 'variable_expr', name }],
+    });
+    deletePatterns.push(tripleOf(blank, bp, bo));
+    whereOptionals.push(keepFilter({
+        type: 'filter',
+        expression: isBlank(`${varPrefix}bn`),
+        inner: {
+            type: 'join',
+            // Filter the owned blank nodes before the inner walk runs from each of them.
+            left: {
+                type: 'filter',
+                expression: isBlank(`${varPrefix}bn0`),
+                inner: {
+                    type: 'bgp',
+                    triples: [...(anchor ? [anchor] : []), tripleOf(rootTerm, pathTerm, ownedBlank)],
+                },
+            },
+            right: {
+                type: 'bgp',
+                triples: [tripleOf(ownedBlank, insidePathTerm, blank), tripleOf(blank, bp, bo)],
+            },
+        },
+    }, rootTerm, keep));
     return { deletePatterns, whereOptionals };
 }
 /**