Silently accept an unknown designated type.

When the value of a type designator slot does not correspond to any
known class, instead of erroring out with a "unknown type" error, simply
fallback to converting the raw object to the type we initially expected,
and pass the type designator value as it is.

This will allow an application to accept data that may contain objects
that have been defined in an extension to the schema, that the
application is not aware of. In that case, any slot that is unknown in
the originally expected type will be treated as an extension slot, and
stored in the extension holders slot (assuming the originally expected
type does have an extension holder slot).

When serialising, if the type designator slot has a value, we do _not_
override it with the actual runtime type of the object -- we simply pass
it along. This way, an application that was given an unknown object can
still write it back unmodified.

Author: gouttegd

core/src/main/java/org/incenp/linkml/core/ObjectConverter.java

@@ -57,7 +57,6 @@ public class ObjectConverter implements IConverter {
     private final static String STRING_EXPECTED = "Invalid value type, string expected";
     private final static String OBJECT_EXPECTED = "Invalid value type, '%s' expected";
     private final static String NO_IDENTIFIER = "Missing identifier for type '%s'";
-    private final static String UNKNOWN_TYPE = "Unknown designated type '%s'";
     private final static String INVALID_CLASS_URI = "Missing or invalid class URI for type '%s'";
 
     protected ClassInfo klass;
@@ -188,13 +187,15 @@ public Object convert(Map<String, Object> raw, ConverterContext ctx) throws Link
                     try {
                         designatedType = Class.forName(pkgName + "." + designatedName);
                     } catch ( ClassNotFoundException e ) {
-                        // We treat that as a value error because providing a correct name in the class
-                        // designator is the responsibility of whoever produced the data
-                        throw new LinkMLValueError(String.format(UNKNOWN_TYPE, designatedName));
+                        // Do nothing, simply fallback to the type we were originally expecting. This is
+                        // so an application has a chance to process data that would use an unknown
+                        // subclass (possibly defined by an extension).
                     }
                 }
 
-                conv = (ObjectConverter) ctx.getConverter(designatedType);
+                if ( designatedType != null ) {
+                    conv = (ObjectConverter) ctx.getConverter(designatedType);
+                }
             }
         }
         String id = null;
@@ -350,9 +351,9 @@ public Map<String, Object> serialise(Object object, boolean withIdentifier, Conv
                 continue;
             }
 
-            Object slotValue;
-            if ( slot.isTypeDesignator() ) {
-                // Ignore whatever may be contained in the slot and use the actual type name
+            Object slotValue = slot.getValue(object);
+            if ( slotValue == null && slot.isTypeDesignator() ) {
+                // Set the slot to the actual type name
                 if ( slot.getInnerType().equals(URI.class) ) {
                     // URI-typed designator slot, it requires the class URI
                     try {
@@ -370,11 +371,9 @@ public Map<String, Object> serialise(Object object, boolean withIdentifier, Conv
                     // Assume a name-based type designator slot
                     slotValue = getType().getSimpleName();
                 }
-            } else {
-                slotValue = slot.getValue(object);
-                if ( slotValue == null ) {
-                    continue;
-                }
+            } else if ( slotValue == null ) {
+                // Ignore all other empty slots
+                continue;
             }
 
             if ( slot.isExtensionStore() ) {

core/src/test/java/org/incenp/linkml/core/ObjectConverterTest.java

@@ -411,6 +411,19 @@ void testCurieTypeDesignator() throws IOException, LinkMLRuntimeException {
         Assertions.assertEquals("EX:DerivedCurieSelfDesignatedClass", raw.get("type"));
     }
 
+    @Test
+    void testUnknownTypeDesignator() throws IOException, LinkMLRuntimeException {
+        String text = "foo: A string\nbaz: Another string\ntype: UnknownDerivedSelfDesignatedClass\n";
+        DerivedSelfDesignatedClass dsdc = parseString(text, DerivedSelfDesignatedClass.class);
+
+        Assertions.assertEquals("A string", dsdc.getFoo());
+        Assertions.assertEquals("UnknownDerivedSelfDesignatedClass", dsdc.getType());
+        Assertions.assertNotNull(dsdc.getExtraSlots());
+        Assertions.assertEquals("Another string", dsdc.getExtraSlots().get("baz"));
+
+        roundtrip(dsdc);
+    }
+
     @Test
     void testReferenceToIRIIdentifiers() throws IOException, LinkMLRuntimeException {
         ctx.addPrefix("PFX", "https://example.org/");

core/src/test/lombok/org/incenp/linkml/core/sample/BaseSelfDesignatedClass.java

@@ -34,6 +34,9 @@
 
 package org.incenp.linkml.core.sample;
 
+import java.util.Map;
+
+import org.incenp.linkml.core.annotations.ExtensionHolder;
 import org.incenp.linkml.core.annotations.TypeDesignator;
 
 import lombok.AccessLevel;
@@ -53,4 +56,6 @@ public class BaseSelfDesignatedClass {
     private String foo;
     @TypeDesignator
     private String type;
+    @ExtensionHolder
+    private Map<String, Object> extraSlots;
 }