Update VectorStoreRecordCollection

Author: Milder Hernandez Cagua

semantickernel-experimental/src/main/java/com/microsoft/semantickernel/connectors/data/azureaisearch/AzureAISearchVectorStoreRecordCollection.java

@@ -90,12 +90,15 @@ public AzureAISearchVectorStoreRecordCollection(
             : options.getRecordDefinition();
 
         // Validate supported types
-        VectorStoreRecordDefinition.validateSupportedKeyTypes(this.options.getRecordClass(),
-            this.recordDefinition, supportedKeyTypes);
-        VectorStoreRecordDefinition.validateSupportedDataTypes(this.options.getRecordClass(),
-            this.recordDefinition, supportedDataTypes);
-        VectorStoreRecordDefinition.validateSupportedVectorTypes(this.options.getRecordClass(),
-            this.recordDefinition, supportedVectorTypes);
+        VectorStoreRecordDefinition.validateSupportedTypes(
+                Collections.singletonList(recordDefinition.getKeyDeclaredField(this.options.getRecordClass())),
+                supportedKeyTypes);
+        VectorStoreRecordDefinition.validateSupportedTypes(
+                recordDefinition.getDataDeclaredFields(this.options.getRecordClass()),
+                supportedDataTypes);
+        VectorStoreRecordDefinition.validateSupportedTypes(
+                recordDefinition.getVectorDeclaredFields(this.options.getRecordClass()),
+                supportedVectorTypes);
 
         // Add non-vector fields to the list
         nonVectorFields.add(this.recordDefinition.getKeyField().getName());

semantickernel-experimental/src/main/java/com/microsoft/semantickernel/connectors/data/redis/RedisVectorStoreRecordCollection.java

@@ -81,10 +81,12 @@ public RedisVectorStoreRecordCollection(
         }
 
         // Validate supported types
-        VectorStoreRecordDefinition.validateSupportedKeyTypes(options.getRecordClass(),
-            recordDefinition, supportedKeyTypes);
-        VectorStoreRecordDefinition.validateSupportedVectorTypes(options.getRecordClass(),
-            recordDefinition, supportedVectorTypes);
+        VectorStoreRecordDefinition.validateSupportedTypes(
+                Collections.singletonList(recordDefinition.getKeyDeclaredField(this.options.getRecordClass())),
+                supportedKeyTypes);
+        VectorStoreRecordDefinition.validateSupportedTypes(
+                recordDefinition.getVectorDeclaredFields(this.options.getRecordClass()),
+                supportedVectorTypes);
 
         // If mapper is not provided, set a default one
         if (options.getVectorStoreRecordMapper() == null) {

semantickernel-experimental/src/main/java/com/microsoft/semantickernel/data/VectorStoreRecordCollection.java

@@ -9,41 +9,40 @@
 import java.util.List;
 
 public interface VectorStoreRecordCollection<Key, Record> {
-
     /**
      * Gets the name of the collection.
      *
      * @return The name of the collection.
      */
-    public String getCollectionName();
+    String getCollectionName();
 
     /**
      * Checks if the collection exists in the store.
      *
      * @return A Mono emitting a boolean indicating if the collection exists.
      */
-    public Mono<Boolean> collectionExistsAsync();
+    Mono<Boolean> collectionExistsAsync();
 
     /**
      * Creates the collection in the store.
      *
      * @return A Mono representing the completion of the creation operation.
      */
-    public Mono<Void> createCollectionAsync();
+    Mono<Void> createCollectionAsync();
 
     /**
      * Creates the collection in the store if it does not exist.
      *
      * @return A Mono representing the completion of the creation operation.
      */
-    public Mono<Void> createCollectionIfNotExistsAsync();
+    Mono<Void> createCollectionIfNotExistsAsync();
 
     /**
      * Deletes the collection from the store.
      *
      * @return A Mono representing the completion of the deletion operation.
      */
-    public Mono<Void> deleteCollectionAsync();
+    Mono<Void> deleteCollectionAsync();
 
     /**
      * Gets a record from the store.

semantickernel-experimental/src/main/java/com/microsoft/semantickernel/data/VolatileVectorStoreRecordCollection.java

@@ -43,8 +43,9 @@ public VolatileVectorStoreRecordCollection(String collectionName,
         }
 
         // Validate the key type
-        VectorStoreRecordDefinition.validateSupportedKeyTypes(options.getRecordClass(),
-            recordDefinition, supportedKeyTypes);
+        VectorStoreRecordDefinition.validateSupportedTypes(
+            Collections.singletonList(recordDefinition.getKeyDeclaredField(options.getRecordClass())),
+            supportedKeyTypes);
     }
 
     VolatileVectorStoreRecordCollection(String collectionName,

semantickernel-experimental/src/main/java/com/microsoft/semantickernel/data/recorddefinition/VectorStoreRecordDefinition.java

@@ -5,13 +5,12 @@
 import com.microsoft.semantickernel.data.recordattributes.VectorStoreRecordKeyAttribute;
 import com.microsoft.semantickernel.data.recordattributes.VectorStoreRecordVectorAttribute;
 
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -50,6 +49,50 @@ public List<VectorStoreRecordField> getAllFields() {
         return fields;
     }
 
+    public List<VectorStoreRecordField> getNonVectorFields() {
+        List<VectorStoreRecordField> fields = new ArrayList<>();
+        fields.add(keyField);
+        fields.addAll(dataFields);
+        return fields;
+    }
+
+    private List<Field> getDeclaredFields(Class<?> recordClass, List<VectorStoreRecordField> fields, String fieldType) {
+        List<Field> declaredFields = new ArrayList<>();
+        for (VectorStoreRecordField field : fields) {
+            try {
+                Field declaredField = recordClass.getDeclaredField(field.getName());
+                declaredFields.add(declaredField);
+            } catch (NoSuchFieldException e) {
+                throw new IllegalArgumentException(
+                        String.format("%s field not found in record class: %s", fieldType, field.getName()));
+            }
+        }
+        return declaredFields;
+    }
+
+    public Field getKeyDeclaredField(Class<?> recordClass) {
+        try {
+            return recordClass.getDeclaredField(keyField.getName());
+        } catch (NoSuchFieldException e) {
+            throw new IllegalArgumentException(
+                    "Key field not found in record class: " + keyField.getName());
+        }
+    }
+
+    public List<Field> getDataDeclaredFields(Class<?> recordClass) {
+        return getDeclaredFields(
+                recordClass,
+                dataFields.stream().map(f -> (VectorStoreRecordField) f).collect(Collectors.toList()),
+                "Data");
+    }
+
+    public List<Field> getVectorDeclaredFields(Class<?> recordClass) {
+        return getDeclaredFields(
+                recordClass,
+                vectorFields.stream().map(f -> (VectorStoreRecordField) f).collect(Collectors.toList()),
+                "Vector");
+    }
+
     private VectorStoreRecordDefinition(
         VectorStoreRecordKeyField keyField,
         List<VectorStoreRecordDataField> dataFields,
@@ -148,71 +191,19 @@ public static VectorStoreRecordDefinition fromRecordClass(Class<?> recordClass)
         return checkFields(keyFields, dataFields, vectorFields);
     }
 
-    private static String getSupportedTypesString(@Nullable HashSet<Class<?>> types) {
-        if (types == null || types.isEmpty()) {
-            return "";
-        }
-        return types.stream().map(Class::getName).collect(Collectors.joining(", "));
-    }
-
-    public static void validateSupportedKeyTypes(@Nonnull Class<?> recordClass,
-        @Nonnull VectorStoreRecordDefinition recordDefinition,
-        @Nonnull HashSet<Class<?>> supportedTypes) {
-        String supportedTypesString = getSupportedTypesString(supportedTypes);
-
-        try {
-            Field declaredField = recordClass.getDeclaredField(recordDefinition.keyField.getName());
 
+    public static void validateSupportedTypes(List<Field> declaredFields, Set<Class<?>> supportedTypes) {
+        Set<Class<?>> unsupportedTypes = new HashSet<>();
+        for (Field declaredField : declaredFields) {
             if (!supportedTypes.contains(declaredField.getType())) {
-                throw new IllegalArgumentException(
-                    "Unsupported key field type: " + declaredField.getType().getName()
-                        + ". Supported types are: " + supportedTypesString);
-            }
-        } catch (NoSuchFieldException e) {
-            throw new IllegalArgumentException(
-                "Key field not found in record class: " + recordDefinition.keyField.getName());
-        }
-    }
-
-    public static void validateSupportedDataTypes(@Nonnull Class<?> recordClass,
-        @Nonnull VectorStoreRecordDefinition recordDefinition,
-        @Nonnull HashSet<Class<?>> supportedTypes) {
-        String supportedTypesString = getSupportedTypesString(supportedTypes);
-
-        for (VectorStoreRecordDataField field : recordDefinition.dataFields) {
-            try {
-                Field declaredField = recordClass.getDeclaredField(field.getName());
-
-                if (!supportedTypes.contains(declaredField.getType())) {
-                    throw new IllegalArgumentException(
-                        "Unsupported data field type: " + declaredField.getType().getName()
-                            + ". Supported types are: " + supportedTypesString);
-                }
-            } catch (NoSuchFieldException e) {
-                throw new IllegalArgumentException(
-                    "Data field not found in record class: " + field.getName());
+                unsupportedTypes.add(declaredField.getType());
             }
         }
-    }
-
-    public static void validateSupportedVectorTypes(@Nonnull Class<?> recordClass,
-        @Nonnull VectorStoreRecordDefinition recordDefinition,
-        @Nonnull HashSet<Class<?>> supportedTypes) {
-        String supportedTypesString = getSupportedTypesString(supportedTypes);
-
-        for (VectorStoreRecordVectorField field : recordDefinition.vectorFields) {
-            try {
-                Field declaredField = recordClass.getDeclaredField(field.getName());
-
-                if (!supportedTypes.contains(declaredField.getType())) {
-                    throw new IllegalArgumentException(
-                        "Unsupported vector field type: " + declaredField.getType().getName()
-                            + ". Supported types are: " + supportedTypesString);
-                }
-            } catch (NoSuchFieldException e) {
-                throw new IllegalArgumentException(
-                    "Vector field not found in record class: " + field.getName());
-            }
+        if (!unsupportedTypes.isEmpty()) {
+            throw new IllegalArgumentException(
+                    String.format("Unsupported field types found in record class: %s. Supported types: %s",
+                            unsupportedTypes.stream().map(Class::getName).collect(Collectors.joining(", ")),
+                            supportedTypes.stream().map(Class::getName).collect(Collectors.joining(", "))));
         }
     }
 }