finos#1167 refactor to use FP paradigm for schema validations

- allows for cleaner flow of code

example/apache-ignite/src/main/scala/org/finos/vuu/example/ignite/schema/IgniteEntitySchema.scala

@@ -84,9 +84,9 @@ case class IgniteEntitySchemaBuilder(private val fieldDef: mutable.LinkedHashMap
   private type ValidationError = Option[String]
   private def validateSchema = indexAppliedOnAbsentField()
   private def indexAppliedOnAbsentField(): ValidationError = {
-    index.foreach(_.getFieldNames.asScala.foreach(name =>
-      if (!fieldDef.contains(name)) return Some(s"Field `$name` not found in schema.")
-    ))
-    None
+    index.iterator
+      .flatMap(i => i.getFieldNames.asScala.map((i.getName, _)))
+      .find({case (_, f) => !fieldDef.contains(f)})
+      .map({case (indexName, f) => s"Field `$f` in index `$indexName` not found in schema."})
   }
 }

example/apache-ignite/src/test/scala/org/finos/vuu/example/ignite/schema/IgniteEntitySchemaTest.scala

@@ -33,7 +33,7 @@ class IgniteEntitySchemaTest extends AnyFeatureSpec with Matchers {
           .build()
       )
       exception shouldBe a[RuntimeException]
-      exception.getMessage should include regex "[Ff]ield `name` not found"
+      exception.getMessage should include regex s"[Ff]ield `name` in index `NAME_IDX`.*not found"
     }
 
     Scenario("Can build schema by passing each field") {

plugin/ignite-plugin/src/main/scala/org/finos/vuu/feature/ignite/schema/SchemaMapper.scala

@@ -32,33 +32,22 @@ object SchemaMapper {
   }
 
   private def hasUniqueColumnNames(columnNames: List[String]): ValidationError = {
-    if (columnNames.distinct.size != columnNames.size)
-      return Some(s"Fields map contains duplicated column names")
-
-    None
+    Option.when(columnNames.distinct.size != columnNames.size)(s"Fields map contains duplicated column names")
   }
 
   private def externalFieldsInMapConformsToExternalSchema(externalSchema: ExternalStoreEntitySchema,
                                                           externalFields: Iterable[String]): ValidationError = {
-    externalFields.foreach(field => {
-      val exists = externalSchema.schemaFields.exists(_.name == field)
-      if (!exists) return Some(s"Field `$field` not found in external schema")
-    })
-
-    None
+    externalFields
+      .find(field => externalSchema.schemaFields.forall(_.name != field))
+      .map(f => s"Field `$f` not found in external schema")
   }
 
   private def internalFieldsInMapMatchTableColumns(columns: Array[Column],
                                                    internalFields: Iterable[String]): ValidationError = {
-    internalFields.foreach(columnName =>
-      if (!columns.exists(_.name == columnName))
-        return Option(s"Column `$columnName` not found in internal columns")
-    )
-
-    if (columns.length > internalFields.size)
-      return Option(s"More internal columns passed than mapped fields")
-
-    None
+    internalFields
+      .find(columnName => columns.forall(_.name != columnName))
+      .map(columnName => s"Column `$columnName` not found in internal columns")
+      .orElse(Option.when(columns.length > internalFields.size)(s"More internal columns passed than mapped fields"))
   }
 
   final case class InvalidSchemaMapException(message: String) extends RuntimeException(message)
@@ -82,8 +71,7 @@ private class SchemaMapperImpl(private val externalSchema: ExternalStoreEntitySc
 
   private def getExternalSchemaFieldsByColumnName =
     externalSchema.schemaFields.flatMap(f =>
-      if (columnNameByExternalField.contains(f.name)) Some(columnNameByExternalField(f.name), f)
-      else None
+      Option.when(columnNameByExternalField.contains(f.name))(columnNameByExternalField(f.name), f)
     ).toMap
 
   private def getTableColumnByExternalField =