feat: Support RDF blank nodes in attribute editor for fixed and default values (#22, RDFA-321)

Added RDF blank-node support for attribute `cims:isFixed` / `cims:isDefault` values, in addition to literals.

Signed-off-by: Jan-Hendrik Spahn <jan-hendrik.spahn@soptim.de>

Author: spah-soptim

backend/src/main/java/org/rdfarchitect/api/dto/attributes/AttributeMapper.java

@@ -17,6 +17,7 @@
 
 package org.rdfarchitect.api.dto.attributes;
 
+import org.apache.jena.datatypes.TypeMapper;
 import org.mapstruct.Mapper;
 import org.mapstruct.Mapping;
 import org.mapstruct.factory.Mappers;
@@ -31,6 +32,7 @@
 import org.rdfarchitect.models.cim.data.dto.relations.RDFSLabel;
 import org.rdfarchitect.models.cim.data.dto.relations.datatype.CIMSDataType;
 import org.rdfarchitect.models.cim.data.dto.relations.uri.URI;
+import org.rdfarchitect.shacl.XSDDatatypeMapper;
 
 import java.util.List;
 
@@ -94,18 +96,14 @@ default CIMSIsFixed buildFixedValue(AttributeDTO dto) {
         if (dto.getFixedValue() == null) {
             return null;
         }
-        return new CIMSIsFixed(
-                dto.getFixedValue(),
-                new URI(dto.getDataType().getPrefix() + dto.getDataType().getLabel()));
+        return new CIMSIsFixed(dto.getFixedValue(), buildXsdDatatype(dto));
     }
 
     default CIMSIsDefault buildDefaultValue(AttributeDTO dto) {
         if (dto.getDefaultValue() == null) {
             return null;
         }
-        return new CIMSIsDefault(
-                dto.getDefaultValue(),
-                new URI(dto.getDataType().getPrefix() + dto.getDataType().getLabel()));
+        return new CIMSIsDefault(dto.getDefaultValue(), buildXsdDatatype(dto));
     }
 
     default CIMSDataType buildDataType(DataTypeDTO dto) {
@@ -114,4 +112,24 @@ default CIMSDataType buildDataType(DataTypeDTO dto) {
                 new RDFSLabel(dto.getLabel(), "en"),
                 CIMSDataType.Type.valueOf(dto.getType().toString()));
     }
+
+    /**
+     * Resolves the canonical XSD datatype URI for an attribute fixed/default value. Only primitive
+     * datatypes map to an XSD URI; for non-primitive types (or unknown labels) the value is
+     * persisted without a typed datatype, leaving the type to be resolved server-side by {@link
+     * org.rdfarchitect.models.cim.queries.update.AttributeFixedDefaultResolver}.
+     */
+    private static URI buildXsdDatatype(AttributeDTO dto) {
+        if (dto.getDataType() == null || dto.getDataType().getLabel() == null) {
+            return null;
+        }
+        if (dto.getDataType().getType() != DataTypeDTO.Type.PRIMITIVE) {
+            return null;
+        }
+        var datatype = XSDDatatypeMapper.classLabelToDatatype(dto.getDataType().getLabel());
+        if (TypeMapper.getInstance().getTypeByName(datatype.getURI()) == null) {
+            return null;
+        }
+        return new URI(datatype.getURI());
+    }
 }

backend/src/main/java/org/rdfarchitect/database/inmemory/InMemorySparqlExecutor.java

@@ -25,15 +25,19 @@
 import org.apache.jena.query.ResultSet;
 import org.apache.jena.query.ResultSetFactory;
 import org.apache.jena.query.TxnType;
-import org.apache.jena.update.Update;
 import org.apache.jena.update.UpdateExecutionFactory;
+import org.apache.jena.update.UpdateRequest;
 import org.rdfarchitect.rdf.graph.wrapper.GraphRewindableWithUUIDs;
 
 @UtilityClass
 public class InMemorySparqlExecutor {
 
+    /**
+     * Opens a single WRITE transaction on {@code graph} and runs {@code update}. Use this only when
+     * the {@link UpdateRequest} can be fully prepared <em>before</em> the transaction opens.
+     */
     public void executeSingleUpdate(
-            GraphRewindableWithUUIDs graph, Update update, String graphUri) {
+            GraphRewindableWithUUIDs graph, UpdateRequest update, String graphUri) {
         try {
             graph.begin(TxnType.WRITE);
             var dataset = SessionDataStore.wrapGraphInDataset(graph, graphUri);

backend/src/main/java/org/rdfarchitect/models/cim/CIMQuerySolutionParser.java

@@ -21,8 +21,8 @@
 
 import org.apache.jena.graph.Node;
 import org.apache.jena.query.QuerySolution;
+import org.apache.jena.rdf.model.Literal;
 import org.apache.jena.rdf.model.RDFNode;
-import org.apache.jena.rdf.model.Resource;
 import org.rdfarchitect.models.cim.data.dto.relations.CIMSAssociationUsed;
 import org.rdfarchitect.models.cim.data.dto.relations.CIMSBelongsToCategory;
 import org.rdfarchitect.models.cim.data.dto.relations.CIMSInverseRoleName;
@@ -39,7 +39,6 @@
 import org.rdfarchitect.models.cim.data.dto.relations.datatype.RDFSRange;
 import org.rdfarchitect.models.cim.data.dto.relations.uri.URI;
 
-import java.util.AbstractMap;
 import java.util.UUID;
 
 /**
@@ -163,73 +162,72 @@ public CIMSInverseRoleName getInverseRoleName(String inverseRoleNameVar) {
     }
 
     /**
-     * Extracts the {@link CIMSIsDefault} from the query solution.
+     * Extracts the {@link CIMSIsDefault} from the query solution. The outer variable is bound
+     * either directly to the literal or to a blank-node wrapper; in the blank-node case the inner
+     * variable holds the wrapper's {@code rdfs:Literal} object (see {@link
+     * org.rdfarchitect.models.cim.queries.select.CIMQueryBuilder#appendIsDefaultQuery}).
      *
-     * @param isDefaultVar The variable name of the isDefault.
-     * @return The is default or null, if the given variables doesn't exist in the solution.
+     * @param isDefaultVar Outer variable name (literal or blank node).
+     * @param isDefaultInnerVar Inner variable name (literal inside the blank-node wrapper).
+     * @return The is default or {@code null} when the outer variable is not bound.
      */
-    public CIMSIsDefault getIsDefault(String isDefaultVar) {
-        if (!qs.contains(isDefaultVar)) {
+    public CIMSIsDefault getIsDefault(String isDefaultVar, String isDefaultInnerVar) {
+        var parsed = parseValueNode(isDefaultVar, isDefaultInnerVar);
+        if (parsed == null) {
             return null;
         }
-        var isDefaultRDFNode = qs.get(isDefaultVar);
-        var tuple = getValueDatatypePair(isDefaultRDFNode);
-        return new CIMSIsDefault(tuple.getKey(), tuple.getValue());
+        return new CIMSIsDefault(parsed.value(), parsed.dataType(), parsed.blankNode());
     }
 
     /**
-     * Extracts the {@link CIMSIsFixed} from the query solution.
+     * Extracts the {@link CIMSIsFixed} from the query solution. The outer variable is bound either
+     * directly to the literal or to a blank-node wrapper; in the blank-node case the inner variable
+     * holds the wrapper's {@code rdfs:Literal} object (see {@link
+     * org.rdfarchitect.models.cim.queries.select.CIMQueryBuilder#appendIsFixedQuery}).
      *
-     * @param isFixedVar The variable name of the isFixed.
-     * @return The is fixed or null, if the given variables doesn't exist in the solution.
+     * @param isFixedVar Outer variable name (literal or blank node).
+     * @param isFixedInnerVar Inner variable name (literal inside the blank-node wrapper).
+     * @return The is fixed or {@code null} when the outer variable is not bound.
      */
-    public CIMSIsFixed getIsFixed(String isFixedVar) {
-        if (!qs.contains(isFixedVar)) {
+    public CIMSIsFixed getIsFixed(String isFixedVar, String isFixedInnerVar) {
+        var parsed = parseValueNode(isFixedVar, isFixedInnerVar);
+        if (parsed == null) {
             return null;
         }
-        var isFixedRDFNode = qs.get(isFixedVar);
-        var tuple = getValueDatatypePair(isFixedRDFNode);
-        return new CIMSIsFixed(tuple.getKey(), tuple.getValue());
+        return new CIMSIsFixed(parsed.value(), parsed.dataType(), parsed.blankNode());
     }
 
+    private record ParsedValueNode(String value, URI dataType, boolean blankNode) {}
+
     /**
-     * Helper method to extract the value and datatype of a RDFNode.
+     * Resolves an attribute value-node from its outer/inner variable bindings:
      *
-     * @param node The RDFNode to extract the value and datatype from.
-     * @return A {@link AbstractMap.SimpleEntry} with the value as key and the datatype as value.
+     * <ul>
+     *   <li>outer literal → direct shape, datatype taken from the literal,
+     *   <li>outer blank node + bound inner literal → blank-node shape, datatype from the inner
+     *       literal,
+     *   <li>outer blank node without inner literal → ignored (malformed wrapper),
+     *   <li>outer not bound → {@code null}.
+     * </ul>
      */
-    private AbstractMap.SimpleEntry<String, URI> getValueDatatypePair(RDFNode node) {
-        URI datatype = null;
-        String value = null;
-        if (node.isLiteral()) {
-            value = node.asNode().getLiteralLexicalForm();
-            var dataTypeUri = node.asNode().getLiteralDatatypeURI();
-            datatype = dataTypeUri.isEmpty() ? null : new URI(dataTypeUri);
+    private ParsedValueNode parseValueNode(String outerVar, String innerVar) {
+        if (!qs.contains(outerVar)) {
+            return null;
+        }
+        RDFNode outer = qs.get(outerVar);
+        if (outer.isLiteral()) {
+            return fromLiteral(outer.asLiteral(), false);
         }
-        var tuple = getPredicateObjectPair(node);
-        value = tuple.getKey() != null ? tuple.getKey() : value;
-        datatype = tuple.getValue() != null ? tuple.getValue() : datatype;
-        return new AbstractMap.SimpleEntry<>(value, datatype);
+        if (outer.isAnon() && qs.contains(innerVar) && qs.get(innerVar).isLiteral()) {
+            return fromLiteral(qs.get(innerVar).asLiteral(), true);
+        }
+        return null;
     }
 
-    /**
-     * Helper method to extract the first predicate and object of a blankNode.
-     *
-     * @param node The RDFNode to extract the predicate and object from.
-     * @return A {@link AbstractMap.SimpleEntry} with the predicate as key and the object as value.
-     */
-    private AbstractMap.SimpleEntry<String, URI> getPredicateObjectPair(RDFNode node) {
-        URI datatype = null;
-        String value = null;
-        if (node.isAnon()) {
-            var it = ((Resource) node).listProperties();
-            if (it.hasNext()) {
-                var stmt = it.next().asTriple();
-                value = stmt.getObject().toString();
-                datatype = new URI(stmt.getPredicate().toString());
-            }
-        }
-        return new AbstractMap.SimpleEntry<>(value, datatype);
+    private ParsedValueNode fromLiteral(Literal literal, boolean blankNode) {
+        var dataTypeUri = literal.getDatatypeURI();
+        var dataType = dataTypeUri == null || dataTypeUri.isEmpty() ? null : new URI(dataTypeUri);
+        return new ParsedValueNode(literal.getLexicalForm(), dataType, blankNode);
     }
 
     /**

backend/src/main/java/org/rdfarchitect/models/cim/data/CIMObjectFactory.java

@@ -88,7 +88,9 @@ public static CIMClass createCIMClass(QuerySolution classQuerySolution) {
     }
 
     /**
-     * Creates a {@link CIMAttribute} from a given query solution.
+     * Creates a {@link CIMAttribute} from a given query solution. The query is expected to bind
+     * both the outer and the inner value-node variables for {@code isFixed} / {@code isDefault} so
+     * blank-node value wrappers can be resolved without a separate model lookup.
      *
      * @param querySolution The query solution to create the attribute from.
      * @return The created attribute.
@@ -110,8 +112,9 @@ public static CIMAttribute createCIMAttribute(QuerySolution querySolution) {
                 .dataType(dataType)
                 .stereotype(parser.getStereotype(CIMQueryVars.STEREOTYPE))
                 .comment(parser.getComment(CIMQueryVars.COMMENT))
-                .fixedValue(parser.getIsFixed(CIMQueryVars.IS_FIXED))
-                .defaultValue(parser.getIsDefault(CIMQueryVars.IS_DEFAULT))
+                .fixedValue(parser.getIsFixed(CIMQueryVars.IS_FIXED, CIMQueryVars.IS_FIXED_INNER))
+                .defaultValue(
+                        parser.getIsDefault(CIMQueryVars.IS_DEFAULT, CIMQueryVars.IS_DEFAULT_INNER))
                 .build();
     }
 

backend/src/main/java/org/rdfarchitect/models/cim/data/CIMObjectFetcher.java

@@ -137,7 +137,10 @@ public List<CIMClass> fetchCIMClassList(Query query) {
     }
 
     /**
-     * Fetches a List of {@link CIMAttribute CIMAttributes}.
+     * Fetches a List of {@link CIMAttribute CIMAttributes}. Blank-node fixed/default values are
+     * resolved by the SPARQL query itself (see {@link
+     * org.rdfarchitect.models.cim.queries.select.CIMQueryBuilder#appendIsFixedQuery}), so the
+     * factory only needs the {@link ResultSet}.
      *
      * @param query {@link Query} to fetch attributes.
      * @return List of {@link CIMAttribute CIMAttributes}.

backend/src/main/java/org/rdfarchitect/models/cim/data/dto/relations/AttributeValueNode.java

@@ -0,0 +1,55 @@
+/*
+ *    Copyright (c) 2024-2026 SOPTIM AG
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ */
+
+package org.rdfarchitect.models.cim.data.dto.relations;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import org.apache.jena.datatypes.TypeMapper;
+import org.apache.jena.rdf.model.Literal;
+import org.apache.jena.rdf.model.ResourceFactory;
+import org.rdfarchitect.models.cim.data.dto.relations.uri.URI;
+
+/**
+ * Shared base for attribute value nodes such as {@link CIMSIsFixed} and {@link CIMSIsDefault}.
+ *
+ * <p>Holds the literal lexical {@code value}, an optional XSD {@code dataType} and a {@code
+ * blankNode} flag indicating whether the value should be persisted as an RDF blank-node wrapper
+ * rather than as a direct literal.
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor(access = AccessLevel.PROTECTED)
+public abstract class AttributeValueNode {
+
+    private String value;
+
+    private URI dataType;
+
+    private boolean blankNode;
+
+    public Literal asLiteral() {
+        if (dataType == null) {
+            return ResourceFactory.createPlainLiteral(value);
+        }
+        return ResourceFactory.createTypedLiteral(
+                value, TypeMapper.getInstance().getSafeTypeByName(dataType.toString()));
+    }
+}

backend/src/main/java/org/rdfarchitect/models/cim/data/dto/relations/CIMSIsDefault.java

@@ -17,33 +17,26 @@
 
 package org.rdfarchitect.models.cim.data.dto.relations;
 
-import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
+import lombok.ToString;
 
-import org.apache.jena.datatypes.TypeMapper;
-import org.apache.jena.rdf.model.Literal;
-import org.apache.jena.rdf.model.ResourceFactory;
 import org.rdfarchitect.models.cim.data.dto.relations.uri.URI;
 
-@Data
-@AllArgsConstructor
+@EqualsAndHashCode(callSuper = true)
+@ToString(callSuper = true)
 @NoArgsConstructor
-public class CIMSIsDefault {
+public class CIMSIsDefault extends AttributeValueNode {
 
     public CIMSIsDefault(String value) {
-        this.value = value;
+        this(value, null, false);
     }
 
-    private String value;
-
-    private URI dataType;
+    public CIMSIsDefault(String value, URI dataType) {
+        this(value, dataType, false);
+    }
 
-    public Literal asLiteral() {
-        if (dataType == null) {
-            return ResourceFactory.createPlainLiteral(value);
-        }
-        return ResourceFactory.createTypedLiteral(
-                value, TypeMapper.getInstance().getSafeTypeByName(dataType.toString()));
+    public CIMSIsDefault(String value, URI dataType, boolean blankNode) {
+        super(value, dataType, blankNode);
     }
 }