diff --git a/README.md b/README.md
index 7efda9d3..52fcba26 100644
--- a/README.md
+++ b/README.md
@@ -822,7 +822,7 @@ Example of configuration with the use of a ticket cache:
 
 #### Quick Start Confluent Cloud Example
 
-Check out the [adapters.xml](/examples/vendors/confluent/quickstart-confluent-cloud/adapters.xml#L22) file of the [_Quick Start Confluent Cloud_](/examples/vendors/confluent/quickstart-confluent-cloud/) app, where you can find an example of an authentication configuration that uses SASL/PLAIN.
+Check out the [adapters.xml](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L454) file of the [_Quick Start Confluent Cloud_](/examples/vendors/confluent/quickstart-confluent/) app, where you can find an example of an authentication configuration that uses SASL/PLAIN.
 
 #### Quick Start Redpanda Serverless Example
 
@@ -870,6 +870,42 @@ Example:
 <param name="record.consume.from">EARLIEST</param>
 ```
 
+#### `record.consume.with.num.threads`
+
+_Optional_. The number of threads to be used for concurrent processing of the incoming deserialized records. If set to `-1`, the number of threads will be automatically determined based on the number of available CPU cores.
+
+Default value: `1`.
+
+Example:
+
+```xml
+<param name="record.consume.with.num.threads">4</param>
+```
+
+#### `record.consume.with.order.strategy`
+
+_Optional but only effective if [`record.consume.with.num.threads`](#recordconsumewithnumthreads) is set to a value greater than `1` (which includes hte default value)_. The order strategy to be used for concurrent processing of the incoming deserialized records. Can be one of the following:
+
+- `ORDER_BY_PARTITION`: maintain the order of records within each partition.
+
+   If you have multiple partitions, records from different partitions can be processed concurrently by different threads, but the order of records from a single partition will always be preserved. This is the default and generally a good balance between performance and order.
+
+- `ORDER_BY_KEY`: maintain the order among the records sharing the same key.
+
+  Different keys can be processed concurrently by different threads. So, while all records with key "A" are processed in order, and all records with key "B" are processed in order, the processing of "A" and "B" records can happen concurrently and interleaved in time. There's no guaranteed order between records of different keys.
+
+- `UNORDERED`: provide no ordering guarantees.
+
+  Records from any partition and with any key can be processed by any thread at any time. This offers the highest throughput when an high number of subscriptions is involved, but the order in which records are delivered to Lightstreamer clients might not match the order they were written to Kafka. This is suitable for use cases where message order is not important.
+
+Default value: `ORDER_BY_PARTITION`.
+
+Example:
+
+```xml
+<param name="record.consume.with.order.strategyy">ORDER_BY_KEY</param>
+```
+
 #### `record.key.evaluator.type` and `record.value.evaluator.type`
 
 _Optional_. The format to be used to deserialize respectively the key and value of a Kafka record. Can be one of the following:
@@ -1066,7 +1102,7 @@ To configure the mapping, you define the set of all subscribable fields through
 
 The configuration specifies that the field `fieldNameX` will contain the value extracted from the deserialized Kafka record through the `extractionExpressionX`, written using the [_Data Extraction Language_](#data-extraction-language). This approach makes it possible to transform a Kafka record of any complexity to the flat structure required by Lightstreamer.
 
-The `QuickStart` [factory configuration](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L352) shows a basic example, where a simple _direct_ mapping has been defined between every attribute of the JSON record value and a Lightstreamer field with the corresponding name. Of course, thanks to the _Data Extraction Language_, more complex mapping can be employed.
+The `QuickStart` [factory configuration](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L374) shows a basic example, where a simple _direct_ mapping has been defined between every attribute of the JSON record value and a Lightstreamer field with the corresponding name. Of course, thanks to the _Data Extraction Language_, more complex mapping can be employed.
 
 ```xml
 ...
diff --git a/docs/javadoc/allclasses-index.html b/docs/javadoc/allclasses-index.html
index 4831ee4a..50ee01f9 100644
--- a/docs/javadoc/allclasses-index.html
+++ b/docs/javadoc/allclasses-index.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>All Classes and Interfaces (kafka-connector 1.0.7 API)</title>
+<title>All Classes and Interfaces (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="class index">
diff --git a/docs/javadoc/allpackages-index.html b/docs/javadoc/allpackages-index.html
index 0dfa3321..d2dc80af 100644
--- a/docs/javadoc/allpackages-index.html
+++ b/docs/javadoc/allpackages-index.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>All Packages (kafka-connector 1.0.7 API)</title>
+<title>All Packages (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="package index">
diff --git a/docs/javadoc/com/lightstreamer/kafka/adapters/pub/KafkaConnectorMetadataAdapter.html b/docs/javadoc/com/lightstreamer/kafka/adapters/pub/KafkaConnectorMetadataAdapter.html
index 688ff5f1..37681ac6 100644
--- a/docs/javadoc/com/lightstreamer/kafka/adapters/pub/KafkaConnectorMetadataAdapter.html
+++ b/docs/javadoc/com/lightstreamer/kafka/adapters/pub/KafkaConnectorMetadataAdapter.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>KafkaConnectorMetadataAdapter (kafka-connector 1.0.7 API)</title>
+<title>KafkaConnectorMetadataAdapter (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="declaration: package: com.lightstreamer.kafka.adapters.pub, class: KafkaConnectorMetadataAdapter">
diff --git a/docs/javadoc/com/lightstreamer/kafka/adapters/pub/package-summary.html b/docs/javadoc/com/lightstreamer/kafka/adapters/pub/package-summary.html
index f1bbc15c..c5497ba5 100644
--- a/docs/javadoc/com/lightstreamer/kafka/adapters/pub/package-summary.html
+++ b/docs/javadoc/com/lightstreamer/kafka/adapters/pub/package-summary.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>com.lightstreamer.kafka.adapters.pub (kafka-connector 1.0.7 API)</title>
+<title>com.lightstreamer.kafka.adapters.pub (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="declaration: package: com.lightstreamer.kafka.adapters.pub">
diff --git a/docs/javadoc/com/lightstreamer/kafka/adapters/pub/package-tree.html b/docs/javadoc/com/lightstreamer/kafka/adapters/pub/package-tree.html
index 3238d2a0..1c27e16b 100644
--- a/docs/javadoc/com/lightstreamer/kafka/adapters/pub/package-tree.html
+++ b/docs/javadoc/com/lightstreamer/kafka/adapters/pub/package-tree.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>com.lightstreamer.kafka.adapters.pub Class Hierarchy (kafka-connector 1.0.7 API)</title>
+<title>com.lightstreamer.kafka.adapters.pub Class Hierarchy (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="tree: package: com.lightstreamer.kafka.adapters.pub">
diff --git a/docs/javadoc/help-doc.html b/docs/javadoc/help-doc.html
index 386b2910..306009db 100644
--- a/docs/javadoc/help-doc.html
+++ b/docs/javadoc/help-doc.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>API Help (kafka-connector 1.0.7 API)</title>
+<title>API Help (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="help">
diff --git a/docs/javadoc/index-all.html b/docs/javadoc/index-all.html
index f425ff56..1d9cb650 100644
--- a/docs/javadoc/index-all.html
+++ b/docs/javadoc/index-all.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>Index (kafka-connector 1.0.7 API)</title>
+<title>Index (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="index">
diff --git a/docs/javadoc/index.html b/docs/javadoc/index.html
index 0133597f..e0854ca3 100644
--- a/docs/javadoc/index.html
+++ b/docs/javadoc/index.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>Overview (kafka-connector 1.0.7 API)</title>
+<title>Overview (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="package index">
diff --git a/docs/javadoc/overview-summary.html b/docs/javadoc/overview-summary.html
index e6511112..f1505b10 100644
--- a/docs/javadoc/overview-summary.html
+++ b/docs/javadoc/overview-summary.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>kafka-connector 1.0.7 API</title>
+<title>kafka-connector 1.1.0 API</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="index redirect">
diff --git a/docs/javadoc/overview-tree.html b/docs/javadoc/overview-tree.html
index cbe3b4e0..5a047e0f 100644
--- a/docs/javadoc/overview-tree.html
+++ b/docs/javadoc/overview-tree.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
 <!-- Generated by javadoc (17) -->
-<title>Class Hierarchy (kafka-connector 1.0.7 API)</title>
+<title>Class Hierarchy (kafka-connector 1.1.0 API)</title>
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <meta name="description" content="class tree">
diff --git a/examples/compose-templates/log4j.properties b/examples/compose-templates/log4j.properties
index 6620bcb6..87640a34 100644
--- a/examples/compose-templates/log4j.properties
+++ b/examples/compose-templates/log4j.properties
@@ -17,7 +17,7 @@ log4j.logger.com.lightstreamer.kafka.adapters.pub.KafkaConnectorMetadataAdapter
 log4j.logger.org.apache.kafka=WARN, stdout
 log4j.appender.stdout=org.apache.log4j.ConsoleAppender
 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
-log4j.appender.stdout.layout.ConversionPattern=[%d] [%-10c{1}] %-5p %m%n
+log4j.appender.stdout.layout.ConversionPattern=[%d] [%-20t] [%-10c{1}] %-5p %m%n
 log4j.appender.stdout.Target=System.out
 
 # QuickStart logger
diff --git a/examples/vendors/confluent/README.md b/examples/vendors/confluent/README.md
index 309a43c6..3bff990c 100644
--- a/examples/vendors/confluent/README.md
+++ b/examples/vendors/confluent/README.md
@@ -237,7 +237,7 @@ To quickly complete the installation and verify the successful integration with
 
   To enable a generic Lightstreamer client to receive real-time updates, it needs to subscribe to one or more items. Therefore, the Kafka Connector provides suitable mechanisms to map Kafka topics to Lightstreamer items effectively.
 
-  The `QuickStartConfluentCloud` [factory configuration](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L419) comes with a straightforward mapping defined through the following settings:
+  The `QuickStartConfluentCloud` [factory configuration](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L441) comes with a straightforward mapping defined through the following settings:
 
   - An item template:
     ```xml
@@ -878,7 +878,7 @@ Example of configuration with the use of a ticket cache:
 <param name="authentication.gssapi.ticket.cache.enable">true</param>
 ```
 
-Check out the `QuickStartConfluentCloud` [factory configuration](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L432) file, where you can find an example of an authentication configuration that uses SASL/PLAIN.
+Check out the `QuickStartConfluentCloud` [factory configuration](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L454) file, where you can find an example of an authentication configuration that uses SASL/PLAIN.
 
 ### Record Evaluation
 
@@ -922,6 +922,42 @@ Example:
 <param name="record.consume.from">EARLIEST</param>
 ```
 
+#### `record.consume.with.num.threads`
+
+_Optional_. The number of threads to be used for concurrent processing of the incoming deserialized records. If set to `-1`, the number of threads will be automatically determined based on the number of available CPU cores.
+
+Default value: `1`.
+
+Example:
+
+```xml
+<param name="record.consume.with.num.threads">4</param>
+```
+
+#### `record.consume.with.order.strategy`
+
+_Optional but only effective if [`record.consume.with.num.threads`](#recordconsumewithnumthreads) is set to a value greater than `1` (which includes hte default value)_. The order strategy to be used for concurrent processing of the incoming deserialized records. Can be one of the following:
+
+- `ORDER_BY_PARTITION`: maintain the order of records within each partition.
+
+   If you have multiple partitions, records from different partitions can be processed concurrently by different threads, but the order of records from a single partition will always be preserved. This is the default and generally a good balance between performance and order.
+
+- `ORDER_BY_KEY`: maintain the order among the records sharing the same key.
+
+  Different keys can be processed concurrently by different threads. So, while all records with key "A" are processed in order, and all records with key "B" are processed in order, the processing of "A" and "B" records can happen concurrently and interleaved in time. There's no guaranteed order between records of different keys.
+
+- `UNORDERED`: provide no ordering guarantees.
+
+  Records from any partition and with any key can be processed by any thread at any time. This offers the highest throughput when an high number of subscriptions is involved, but the order in which records are delivered to Lightstreamer clients might not match the order they were written to Kafka. This is suitable for use cases where message order is not important.
+
+Default value: `ORDER_BY_PARTITION`.
+
+Example:
+
+```xml
+<param name="record.consume.with.order.strategyy">ORDER_BY_KEY</param>
+```
+
 #### `record.key.evaluator.type` and `record.value.evaluator.type`
 
 _Optional_. The format to be used to deserialize respectively the key and value of a Kafka record. Can be one of the following:
@@ -1118,7 +1154,7 @@ To configure the mapping, you define the set of all subscribable fields through
 
 The configuration specifies that the field `fieldNameX` will contain the value extracted from the deserialized Kafka record through the `extractionExpressionX`, written using the [_Data Extraction Language_](#data-extraction-language). This approach makes it possible to transform a Kafka record of any complexity to the flat structure required by Lightstreamer.
 
-The `QuickStartConfluentCloud` [factory configuration](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L448) shows a basic example, where a simple _direct_ mapping has been defined between every attribute of the JSON record value and a Lightstreamer field with the corresponding name. Of course, thanks to the _Data Extraction Language_, more complex mapping can be employed.
+The `QuickStartConfluentCloud` [factory configuration](/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml#L469) shows a basic example, where a simple _direct_ mapping has been defined between every attribute of the JSON record value and a Lightstreamer field with the corresponding name. Of course, thanks to the _Data Extraction Language_, more complex mapping can be employed.
 
 ```xml
 ...
diff --git a/kafka-connector-project/buildSrc/src/main/groovy/lightstreamer-kafka-connector.gradle b/kafka-connector-project/buildSrc/src/main/groovy/lightstreamer-kafka-connector.gradle
index c810d194..32f5f0f2 100644
--- a/kafka-connector-project/buildSrc/src/main/groovy/lightstreamer-kafka-connector.gradle
+++ b/kafka-connector-project/buildSrc/src/main/groovy/lightstreamer-kafka-connector.gradle
@@ -16,7 +16,7 @@ spotless {
         greclipse()
     }
     java {
-        target 'src/main/**/*.java','src/test/**/*.java'
+        target 'src/main/**/*.java','src/test/**/*.java','src/jmh/**/*.java'
         googleJavaFormat()
                 .aosp()
                 .reorderImports(true)
diff --git a/kafka-connector-project/gradle.properties b/kafka-connector-project/gradle.properties
index c0f92edc..ff434e19 100644
--- a/kafka-connector-project/gradle.properties
+++ b/kafka-connector-project/gradle.properties
@@ -1,5 +1,5 @@
-version=1.0.7
+version=1.1.0
 brandedProjectName=Lightstreamer Kafka Connector
-release_date=2024-06-11
+release_date=UNRELEASED
 connect_owner=lightstreamer
 connect_componentName=kafka-connect-lightstreamer
diff --git a/kafka-connector-project/gradle/wrapper/gradle-wrapper.properties b/kafka-connector-project/gradle/wrapper/gradle-wrapper.properties
index 9355b415..e2847c82 100644
--- a/kafka-connector-project/gradle/wrapper/gradle-wrapper.properties
+++ b/kafka-connector-project/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml b/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml
index f204591d..4bda9d09 100644
--- a/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml
+++ b/kafka-connector-project/kafka-connector/src/adapter/dist/adapters.xml
@@ -259,6 +259,28 @@
              Default value: LATEST. -->
         <param name="record.consume.from">EARLIEST</param>
 
+        <!-- Optional. The number of threads to be used for concurrent processing of the
+             incoming deserialized records. If set to `-1`, the number of threads will be automatically
+             determined based on the number of available CPU cores.
+
+             Default value: 1. -->
+        <!--
+        <param name="record.consume.with.num.threads">4</param>
+        -->
+
+        <!-- Optional but only effective if "record.consume.with.num.threads" is set to a value greater than 1 (which includes hte default value).
+             The order strategy to be used for concurrent processing of the incoming
+             deserialized records. Can be one of the following:
+
+             - ORDER_BY_PARTITION: maintain the order of records within each partition
+             - ORDER_BY_KEY: maintain the order among the records sharing the same key
+             - UNORDERED: provide no ordering guarantees
+
+             Default value: ORDER_BY_PARTITION. -->
+        <!--
+        <param name="record.consume.with.order.strategy">ORDER_BY_KEY</param>
+        -->
+
         <!-- Optional. The format to be used to deserialize respectively the key and value of a Kafka record.
              Can be one of the following:
              - AVRO
@@ -464,6 +486,6 @@
         <param name="field.offset">#{OFFSET}</param>
         <param name="field.partition">#{PARTITION}</param>
 
-    </data_provider>    
+    </data_provider>
 
 </adapters_conf>
diff --git a/kafka-connector-project/kafka-connector/src/connect/manifest.json.tpl b/kafka-connector-project/kafka-connector/src/connect/manifest.json.tpl
index 719b392a..de028bf0 100644
--- a/kafka-connector-project/kafka-connector/src/connect/manifest.json.tpl
+++ b/kafka-connector-project/kafka-connector/src/connect/manifest.json.tpl
@@ -24,7 +24,7 @@
     "kafka_connect_api": true
   },
   "logo": "assets/lightstreamer.png",
-  "documentation_url": "https://github.com/Lightstreamer/Lightstreamer-kafka-connector",
+  "documentation_url": "https://lightstreamer.com/confluent-docs",
   "source_url" : "https://github.com/Lightstreamer/Lightstreamer-kafka-connector",  
   "docker_image" : {
     "name" : "lightstreamer"
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/ConnectorConfigurator.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/ConnectorConfigurator.java
index b86d21ab..7f1da417 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/ConnectorConfigurator.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/ConnectorConfigurator.java
@@ -19,7 +19,12 @@
 
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig;
+import com.lightstreamer.kafka.adapters.mapping.selectors.KeyValueSelectorSuppliersMaker;
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers;
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers.KeyValueDeserializers;
 import com.lightstreamer.kafka.adapters.mapping.selectors.avro.GenericRecordSelectorsSuppliers;
 import com.lightstreamer.kafka.adapters.mapping.selectors.json.JsonNodeSelectorsSuppliers;
 import com.lightstreamer.kafka.adapters.mapping.selectors.others.OthersSelectorSuppliers;
@@ -30,46 +35,31 @@
 import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
 import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
-import com.lightstreamer.kafka.common.mapping.selectors.SelectorSuppliers;
-import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
 
-import org.apache.kafka.common.serialization.Deserializer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
+import java.util.function.Function;
 
 public class ConnectorConfigurator {
 
-    public interface ConsumerLoopConfig<K, V> {
-
-        String connectionName();
-
-        Properties consumerProperties();
-
-        DataExtractor<K, V> fieldsExtractor();
-
-        ItemTemplates<K, V> itemTemplates();
-
-        Deserializer<K> keyDeserializer();
-
-        Deserializer<V> valueDeserializer();
-
-        RecordErrorHandlingStrategy recordErrorHandlingStrategy();
-    }
-
-    private static record ConsumerLoopConfigImpl<K, V>(
+    private static record ConsumerTriggerConfigImpl<K, V>(
             String connectionName,
             Properties consumerProperties,
             ItemTemplates<K, V> itemTemplates,
             DataExtractor<K, V> fieldsExtractor,
-            Deserializer<K> keyDeserializer,
-            Deserializer<V> valueDeserializer,
-            RecordErrorHandlingStrategy recordErrorHandlingStrategy)
-            implements ConsumerLoopConfig<K, V> {}
+            KeyValueDeserializers<K, V> deserializers,
+            RecordErrorHandlingStrategy errorHandlingStrategy,
+            Concurrency concurrency)
+            implements ConsumerTriggerConfig<K, V> {}
+
+    private static record ConcurrencyConfig(
+            RecordConsumeWithOrderStrategy orderStrategy, int threads)
+            implements ConsumerTriggerConfig.Concurrency {}
 
     private final ConnectorConfig config;
     private final Logger log;
@@ -88,63 +78,55 @@ public ConnectorConfig getConfig() {
         return config;
     }
 
-    protected ConsumerLoopConfig<?, ?> configure() throws ConfigException {
-        // Process "field.<field-name>=#{...}"
-        // Map<String, String> fieldsMapping = config.getFieldMappings();
-        FieldConfigs fieldConfigs = config.getFieldConfigs();
-
+    public ConsumerTriggerConfig<?, ?> configure() throws ConfigException {
         try {
-            TopicConfigurations topicsConfig =
-                    TopicConfigurations.of(
-                            config.getItemTemplateConfigs(), config.getTopicMappings());
-            SelectorSuppliers<?, ?> sSuppliers =
-                    SelectorSuppliers.of(
-                            mkKeySelectorSupplier(config), mkValueSelectorSupplier(config));
-
-            ItemTemplates<?, ?> itemTemplates = initItemTemplates(sSuppliers, topicsConfig);
-            DataExtractor<?, ?> fieldsExtractor = fieldConfigs.extractor(sSuppliers);
-
-            return new ConsumerLoopConfigImpl(
-                    config.getAdapterName(),
-                    config.baseConsumerProps(),
-                    itemTemplates,
-                    fieldsExtractor,
-                    sSuppliers.keySelectorSupplier().deseralizer(),
-                    sSuppliers.valueSelectorSupplier().deseralizer(),
-                    config.getRecordExtractionErrorHandlingStrategy());
+            return doConfigure(config, mkKeyValueSelectorSuppliers(config));
         } catch (Exception e) {
             log.atError().setCause(e).log();
             throw new ConfigException(e.getMessage());
         }
     }
 
-    private ItemTemplates<?, ?> initItemTemplates(
-            SelectorSuppliers<?, ?> selected, TopicConfigurations topicsConfig)
-            throws ExtractionException {
-        return initItemTemplatesHelper(topicsConfig, selected);
-    }
-
-    private <K, V> ItemTemplates<K, V> initItemTemplatesHelper(
-            TopicConfigurations topicsConfig, SelectorSuppliers<K, V> selected)
+    private static <K, V> ConsumerTriggerConfigImpl<K, V> doConfigure(
+            ConnectorConfig config, WrapperKeyValueSelectorSuppliers<K, V> sSuppliers)
             throws ExtractionException {
-        return Items.from(topicsConfig, selected);
-    }
+        FieldConfigs fieldConfigs = config.getFieldConfigs();
 
-    private KeySelectorSupplier<?> mkKeySelectorSupplier(ConnectorConfig config) {
-        EvaluatorType evaluatorType = config.getKeyEvaluator();
-        return switch (evaluatorType) {
-            case AVRO -> GenericRecordSelectorsSuppliers.keySelectorSupplier(config);
-            case JSON -> JsonNodeSelectorsSuppliers.keySelectorSupplier(config);
-            default -> OthersSelectorSuppliers.keySelectorSupplier(evaluatorType);
-        };
+        TopicConfigurations topicsConfig =
+                TopicConfigurations.of(config.getItemTemplateConfigs(), config.getTopicMappings());
+
+        ItemTemplates<K, V> itemTemplates = Items.templatesFrom(topicsConfig, sSuppliers);
+        DataExtractor<K, V> fieldsExtractor = fieldConfigs.extractor(sSuppliers);
+
+        return new ConsumerTriggerConfigImpl<>(
+                config.getAdapterName(),
+                config.baseConsumerProps(),
+                itemTemplates,
+                fieldsExtractor,
+                sSuppliers.deserializers(),
+                config.getRecordExtractionErrorHandlingStrategy(),
+                new ConcurrencyConfig(
+                        config.getRecordConsumeWithOrderStrategy(),
+                        config.getRecordConsumeWithNumThreads()));
     }
 
-    private ValueSelectorSupplier<?> mkValueSelectorSupplier(ConnectorConfig config) {
-        EvaluatorType evaluatorType = config.getValueEvaluator();
-        return switch (evaluatorType) {
-            case AVRO -> GenericRecordSelectorsSuppliers.valueSelectorSupplier(config);
-            case JSON -> JsonNodeSelectorsSuppliers.valueSelectorSupplier(config);
-            default -> OthersSelectorSuppliers.valueSelectorSupplier(evaluatorType);
-        };
+    static WrapperKeyValueSelectorSuppliers<?, ?> mkKeyValueSelectorSuppliers(
+            ConnectorConfig config) {
+        Map<EvaluatorType, KeyValueSelectorSuppliersMaker<?>> t = new HashMap<>();
+        Function<? super EvaluatorType, ? extends KeyValueSelectorSuppliersMaker<?>> getMaker =
+                type -> {
+                    return switch (type) {
+                        case JSON -> new JsonNodeSelectorsSuppliers(config);
+                        case AVRO -> new GenericRecordSelectorsSuppliers(config);
+                        default -> new OthersSelectorSuppliers(config);
+                    };
+                };
+        KeyValueSelectorSuppliersMaker<?> keyMaker =
+                t.computeIfAbsent(config.getKeyEvaluator(), getMaker);
+        KeyValueSelectorSuppliersMaker<?> valueMaker =
+                t.computeIfAbsent(config.getValueEvaluator(), getMaker);
+
+        return new WrapperKeyValueSelectorSuppliers<>(
+                keyMaker.makeKeySelectorSupplier(), valueMaker.makeValueSelectorSupplier());
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/KafkaConnectorDataAdapter.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/KafkaConnectorDataAdapter.java
index 37e0025d..749193f6 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/KafkaConnectorDataAdapter.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/KafkaConnectorDataAdapter.java
@@ -22,11 +22,11 @@
 import com.lightstreamer.interfaces.data.ItemEventListener;
 import com.lightstreamer.interfaces.data.SmartDataProvider;
 import com.lightstreamer.interfaces.data.SubscriptionException;
-import com.lightstreamer.kafka.adapters.ConnectorConfigurator.ConsumerLoopConfig;
 import com.lightstreamer.kafka.adapters.commons.LogFactory;
 import com.lightstreamer.kafka.adapters.commons.MetadataListener;
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
-import com.lightstreamer.kafka.adapters.consumers.ConsumerLoop;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig;
 import com.lightstreamer.kafka.adapters.pub.KafkaConnectorMetadataAdapter;
 
 import org.slf4j.Logger;
@@ -39,8 +39,8 @@
 public final class KafkaConnectorDataAdapter implements SmartDataProvider {
 
     private Logger log;
-    private Loop loop;
-    private ConsumerLoopConfig<?, ?> loopConfig;
+    private ConsumerTrigger consumerTrigger;
+    private ConsumerTriggerConfig<?, ?> consumerTriggerConfig;
     private ConnectorConfig connectorConfig;
     private MetadataListener metadataListener;
 
@@ -57,7 +57,7 @@ public void init(@Nonnull Map params, @Nonnull File configDir) throws DataProvid
                         connectorConfig.getAdapterName(), connectorConfig.isEnabled());
 
         log.info("Configuring Kafka Connector");
-        loopConfig = configurator.configure();
+        consumerTriggerConfig = configurator.configure();
         log.info("Configuration complete");
     }
 
@@ -66,17 +66,10 @@ public boolean isSnapshotAvailable(@Nonnull String itemName) throws Subscription
         return false;
     }
 
-    private <K, V> Loop loop(ConsumerLoopConfig<K, V> config, ItemEventListener eventListener) {
-        return new ConsumerLoop<>(config, metadataListener, eventListener);
-    }
-
-    private Loop makeLoop(ConsumerLoopConfig<?, ?> config, ItemEventListener eventListener) {
-        return loop(config, eventListener);
-    }
-
     @Override
     public void setListener(@Nonnull ItemEventListener eventListener) {
-        this.loop = makeLoop(loopConfig, eventListener);
+        this.consumerTrigger =
+                ConsumerTrigger.create(consumerTriggerConfig, metadataListener, eventListener);
     }
 
     @Override
@@ -88,13 +81,13 @@ public void subscribe(
             @Nonnull String itemName, @Nonnull Object itemHandle, boolean needsIterator)
             throws SubscriptionException, FailureException {
         log.info("Trying subscription to item [{}]", itemName);
-        loop.subscribe(itemName, itemHandle);
+        consumerTrigger.subscribe(itemName, itemHandle);
     }
 
     @Override
     public void unsubscribe(@Nonnull String itemName)
             throws SubscriptionException, FailureException {
         log.info("Unsubscribing from item [{}]", itemName);
-        loop.unsubscribe(itemName);
+        consumerTrigger.unsubscribe(itemName);
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/Loop.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/Loop.java
deleted file mode 100644
index dd3fa550..00000000
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/Loop.java
+++ /dev/null
@@ -1,30 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.adapters;
-
-import com.lightstreamer.interfaces.data.SubscriptionException;
-import com.lightstreamer.kafka.common.mapping.Items.Item;
-
-public interface Loop {
-
-    Item subscribe(String item, Object itemHandle) throws SubscriptionException;
-
-    Item unsubscribe(String topic) throws SubscriptionException;
-
-    void unsubscribeInfoItem();
-}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/AbstractConfig.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/AbstractConfig.java
index ef03cc29..d0ba5454 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/AbstractConfig.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/AbstractConfig.java
@@ -63,6 +63,10 @@ public final String getInt(String configKey) {
         return get(configKey, ConfType.INT, false);
     }
 
+    public final String getThreads(String configKey) {
+        return get(configKey, ConfType.THREADS, false);
+    }
+
     public final String getText(String configKey) {
         return get(configKey, TEXT, false);
     }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/ConnectorConfig.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/ConnectorConfig.java
index 80c27525..7999d6b5 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/ConnectorConfig.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/ConnectorConfig.java
@@ -23,8 +23,10 @@
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.ConfType.EVALUATOR;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.ConfType.FILE;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.ConfType.INT;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.ConfType.ORDER_STRATEGY;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.ConfType.TEXT;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.ConfType.TEXT_LIST;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.ConfType.THREADS;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.DefaultHolder.defaultValue;
 
 import static org.apache.kafka.clients.consumer.ConsumerConfig.AUTO_OFFSET_RESET_CONFIG;
@@ -48,7 +50,8 @@
 import com.lightstreamer.kafka.adapters.commons.NonNullKeyProperties;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.KeystoreType;
-import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordComsumeFrom;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeFrom;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.SaslMechanism;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.SslProtocol;
@@ -106,6 +109,11 @@ public final class ConnectorConfig extends AbstractConfig {
     public static final String RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY =
             "record.extraction.error.strategy";
 
+    public static final String RECORD_CONSUME_WITH_ORDER_STRATEGY =
+            "record.consume.with.order.strategy";
+
+    public static final String RECORD_CONSUME_WITH_NUM_THREADS = "record.consume.with.num.threads";
+
     public static final String ITEM_INFO_NAME = "info.item";
 
     public static final String ITEM_INFO_FIELD = "info.field";
@@ -214,6 +222,18 @@ public final class ConnectorConfig extends AbstractConfig {
                                 false,
                                 ERROR_STRATEGY,
                                 defaultValue("IGNORE_AND_CONTINUE"))
+                        .add(
+                                RECORD_CONSUME_WITH_NUM_THREADS,
+                                false,
+                                false,
+                                THREADS,
+                                defaultValue("1"))
+                        .add(
+                                RECORD_CONSUME_WITH_ORDER_STRATEGY,
+                                false,
+                                false,
+                                ORDER_STRATEGY,
+                                defaultValue("ORDER_BY_PARTITION"))
                         .add(ENCYRPTION_ENABLE, false, false, BOOL, defaultValue("false"))
                         .add(AUTHENTICATION_ENABLE, false, false, BOOL, defaultValue("false"))
                         .add(
@@ -221,7 +241,7 @@ public final class ConnectorConfig extends AbstractConfig {
                                 false,
                                 false,
                                 CONSUME_FROM,
-                                defaultValue(RecordComsumeFrom.LATEST.toString()))
+                                defaultValue(RecordConsumeFrom.LATEST.toString()))
                         .add(
                                 CONSUMER_CLIENT_ID,
                                 false,
@@ -253,7 +273,6 @@ public final class ConnectorConfig extends AbstractConfig {
                         .add(CONSUMER_RECONNECT_BACKOFF_MAX_MS_CONFIG, false, false, INT)
                         .add(CONSUMER_RECONNECT_BACKOFF_MS_CONFIG, false, false, INT)
                         .add(CONSUMER_FETCH_MIN_BYTES_CONFIG, false, false, INT)
-                        .add(CONSUMER_FETCH_MIN_BYTES_CONFIG, false, false, INT)
                         .add(CONSUMER_FETCH_MAX_BYTES_CONFIG, false, false, INT)
                         .add(CONSUMER_FETCH_MAX_WAIT_MS_CONFIG, false, false, INT)
                         .add(CONSUMER_MAX_POLL_RECORDS, false, false, INT)
@@ -414,8 +433,8 @@ public final EvaluatorType getEvaluator(String configKey) {
         return EvaluatorType.valueOf(get(configKey, EVALUATOR, false));
     }
 
-    public final RecordComsumeFrom getRecordConsumeFrom() {
-        return RecordComsumeFrom.valueOf(get(RECORD_CONSUME_FROM, CONSUME_FROM, false));
+    public final RecordConsumeFrom getRecordConsumeFrom() {
+        return RecordConsumeFrom.valueOf(get(RECORD_CONSUME_FROM, CONSUME_FROM, false));
     }
 
     public final RecordErrorHandlingStrategy getRecordExtractionErrorHandlingStrategy() {
@@ -423,6 +442,15 @@ public final RecordErrorHandlingStrategy getRecordExtractionErrorHandlingStrateg
                 get(RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY, ERROR_STRATEGY, false));
     }
 
+    public final RecordConsumeWithOrderStrategy getRecordConsumeWithOrderStrategy() {
+        return RecordConsumeWithOrderStrategy.valueOf(
+                get(RECORD_CONSUME_WITH_ORDER_STRATEGY, ORDER_STRATEGY, false));
+    }
+
+    public final int getRecordConsumeWithNumThreads() {
+        return Integer.parseInt(getThreads(RECORD_CONSUME_WITH_NUM_THREADS));
+    }
+
     public boolean hasKeySchemaFile() {
         return getFile(RECORD_KEY_EVALUATOR_SCHEMA_PATH) != null;
     }
@@ -439,6 +467,10 @@ public boolean isSchemaRegistryEnabledForValue() {
         return getBoolean(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
     }
 
+    public boolean hasSchemaFile() {
+        return hasKeySchemaFile() || hasValueSchemaFile();
+    }
+
     public boolean isSchemaRegistryEnabled() {
         return isSchemaRegistryEnabledForKey() || isSchemaRegistryEnabledForValue();
     }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/specs/ConfigTypes.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/specs/ConfigTypes.java
index d4389a89..3803d82b 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/specs/ConfigTypes.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/specs/ConfigTypes.java
@@ -160,7 +160,7 @@ public String toString() {
         }
     }
 
-    public enum RecordComsumeFrom {
+    public enum RecordConsumeFrom {
         LATEST,
         EARLIEST;
 
@@ -197,9 +197,29 @@ public enum EvaluatorType {
         SHORT,
         UUID;
 
+        public boolean is(EvaluatorType type) {
+            return this == type;
+        }
+
         public static Set<String> names() {
             return enumNames(values());
         }
+
+        public static EvaluatorType fromClass(Class<?> klass) {
+            return switch (klass.getSimpleName()) {
+                case "String" -> EvaluatorType.STRING;
+                case "Integer" -> EvaluatorType.INTEGER;
+                case "Boolean" -> EvaluatorType.BOOLEAN;
+                case "byte[]" -> EvaluatorType.BYTE_ARRAY;
+                case "ByteBuffer" -> EvaluatorType.BYTE_BUFFER;
+                case "Bytes" -> EvaluatorType.BYTES;
+                case "Double" -> EvaluatorType.DOUBLE;
+                case "Float" -> EvaluatorType.FLOAT;
+                case "SHORT" -> EvaluatorType.SHORT;
+                case "UUID" -> EvaluatorType.UUID;
+                default -> throw new IllegalArgumentException();
+            };
+        }
     }
 
     public enum RecordErrorHandlingStrategy {
@@ -211,6 +231,16 @@ public static Set<String> names() {
         }
     }
 
+    public enum RecordConsumeWithOrderStrategy {
+        ORDER_BY_KEY,
+        ORDER_BY_PARTITION,
+        UNORDERED;
+
+        public static Set<String> names() {
+            return enumNames(values());
+        }
+    }
+
     private static Set<String> enumNames(Enum<?>[] e) {
         return Arrays.stream(e).map(Enum::toString).collect(Collectors.toUnmodifiableSet());
     }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/specs/ConfigsSpec.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/specs/ConfigsSpec.java
index ff81aa7b..4f5ec651 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/specs/ConfigsSpec.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/config/specs/ConfigsSpec.java
@@ -19,7 +19,8 @@
 
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.KeystoreType;
-import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordComsumeFrom;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeFrom;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.SaslMechanism;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.SecurityProtocol;
@@ -84,6 +85,18 @@ public boolean checkValidity(String param) {
             }
         },
 
+        THREADS {
+            @Override
+            public boolean checkValidity(String param) {
+                try {
+                    Integer threads = Integer.valueOf(param);
+                    return threads == -1 || threads > 0;
+                } catch (NumberFormatException e) {
+                    return false;
+                }
+            }
+        },
+
         HOST {
             private static Pattern HOST = Pattern.compile("^([0-9a-zA-Z-.%_]+):([1-9]\\d*)$");
 
@@ -101,6 +114,8 @@ public boolean checkValidity(String param) {
 
         ERROR_STRATEGY(Options.errorStrategies()),
 
+        ORDER_STRATEGY(Options.orderStrategies()),
+
         URL {
             @Override
             public boolean checkValidity(String param) {
@@ -340,7 +355,7 @@ void populate(Map<String, String> source, Map<String, String> destination)
     static class Options implements Type {
 
         public static Options consumeEventsFrom() {
-            return new Options(RecordComsumeFrom.names());
+            return new Options(RecordConsumeFrom.names());
         }
 
         static Options booleans() {
@@ -355,6 +370,10 @@ static Options errorStrategies() {
             return new Options(RecordErrorHandlingStrategy.names());
         }
 
+        static Options orderStrategies() {
+            return new Options(RecordConsumeWithOrderStrategy.names());
+        }
+
         static Options securityProtocols() {
             return new Options(SecurityProtocol.names());
         }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/AbstractConsumerLoop.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/AbstractConsumerLoop.java
deleted file mode 100644
index e8540ab6..00000000
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/AbstractConsumerLoop.java
+++ /dev/null
@@ -1,90 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.adapters.consumers;
-
-import com.lightstreamer.interfaces.data.SubscriptionException;
-import com.lightstreamer.kafka.adapters.ConnectorConfigurator.ConsumerLoopConfig;
-import com.lightstreamer.kafka.adapters.Loop;
-import com.lightstreamer.kafka.adapters.commons.LogFactory;
-import com.lightstreamer.kafka.common.expressions.ExpressionException;
-import com.lightstreamer.kafka.common.mapping.Items;
-import com.lightstreamer.kafka.common.mapping.Items.Item;
-import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
-
-import org.slf4j.Logger;
-
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
-
-public abstract class AbstractConsumerLoop<K, V> implements Loop {
-
-    protected final Logger log;
-    protected final ConsumerLoopConfig<K, V> config;
-    protected final ConcurrentHashMap<String, SubscribedItem> subscribedItems =
-            new ConcurrentHashMap<>();
-    protected final AtomicInteger itemsCounter = new AtomicInteger(0);
-    protected Object infoItemhande;
-
-    protected AbstractConsumerLoop(ConsumerLoopConfig<K, V> config) {
-        this.config = config;
-        this.log = LogFactory.getLogger(config.connectionName());
-    }
-
-    public final int getItemsCounter() {
-        return itemsCounter.get();
-    }
-
-    @Override
-    public final Item subscribe(String item, Object itemHandle) throws SubscriptionException {
-        try {
-            SubscribedItem newItem = Items.susbcribedFrom(item, itemHandle);
-            if (!config.itemTemplates().matches(newItem)) {
-                log.atWarn().log("Item [{}] does not match any defined item templates", item);
-                throw new SubscriptionException("Item does not match any defined item templates");
-            }
-
-            log.atInfo().log("Subscribed to item [{}]", item);
-            subscribedItems.put(item, newItem);
-            if (itemsCounter.addAndGet(1) == 1) {
-                startConsuming();
-            }
-            return newItem;
-        } catch (ExpressionException e) {
-            log.atError().setCause(e).log();
-            throw new SubscriptionException(e.getMessage());
-        }
-    }
-
-    abstract void startConsuming() throws SubscriptionException;
-
-    @Override
-    public final Item unsubscribe(String item) throws SubscriptionException {
-        Item removedItem = subscribedItems.remove(item);
-        if (removedItem == null) {
-            throw new SubscriptionException(
-                    "Unsubscribing from unexpected item [%s]".formatted(item));
-        }
-
-        if (itemsCounter.decrementAndGet() == 0) {
-            stopConsuming();
-        }
-        return removedItem;
-    }
-
-    abstract void stopConsuming();
-}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerLoop.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerLoop.java
deleted file mode 100644
index d7d5e350..00000000
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerLoop.java
+++ /dev/null
@@ -1,368 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.adapters.consumers;
-
-import com.lightstreamer.interfaces.data.ItemEventListener;
-import com.lightstreamer.interfaces.data.SubscriptionException;
-import com.lightstreamer.kafka.adapters.ConnectorConfigurator.ConsumerLoopConfig;
-import com.lightstreamer.kafka.adapters.commons.MetadataListener;
-import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
-import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
-import com.lightstreamer.kafka.common.mapping.RecordMapper;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
-import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
-
-import org.apache.kafka.clients.admin.Admin;
-import org.apache.kafka.clients.admin.AdminClient;
-import org.apache.kafka.clients.admin.ListTopicsOptions;
-import org.apache.kafka.clients.admin.ListTopicsResult;
-import org.apache.kafka.clients.consumer.ConsumerConfig;
-import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.apache.kafka.clients.consumer.ConsumerRecords;
-import org.apache.kafka.clients.consumer.KafkaConsumer;
-import org.apache.kafka.clients.consumer.OffsetAndMetadata;
-import org.apache.kafka.common.KafkaException;
-import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.errors.WakeupException;
-
-import java.time.Duration;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.stream.Collectors;
-
-public class ConsumerLoop<K, V> extends AbstractConsumerLoop<K, V> {
-
-    private final MetadataListener metadataListener;
-    private final ItemEventListener eventListener;
-    private final RecordMapper<K, V> recordRemapper;
-    private final DataExtractor<K, V> fieldsExtractor;
-    private final ReentrantLock consumerLock = new ReentrantLock();
-    private volatile ConsumerWrapper consumer;
-    private AtomicBoolean infoLock = new AtomicBoolean(false);
-
-    private final ExecutorService pool;
-
-    public ConsumerLoop(
-            ConsumerLoopConfig<K, V> config,
-            MetadataListener metadataListener,
-            ItemEventListener eventListener) {
-        super(config);
-        this.metadataListener = metadataListener;
-        this.fieldsExtractor = config.fieldsExtractor();
-        this.recordRemapper =
-                RecordMapper.<K, V>builder()
-                        .withExtractor(config.itemTemplates().extractors())
-                        .withExtractor(fieldsExtractor)
-                        .build();
-        this.eventListener = eventListener;
-        this.pool = Executors.newFixedThreadPool(2);
-    }
-
-    @Override
-    void startConsuming() throws SubscriptionException {
-        log.atTrace().log("Acquiring consumer lock...");
-        consumerLock.lock();
-        log.atTrace().log("Lock acquired...");
-        try {
-            consumer = new ConsumerWrapper(config.recordErrorHandlingStrategy());
-            CompletableFuture.runAsync(consumer, pool);
-        } catch (KafkaException ke) {
-            log.atError().setCause(ke).log("Unable to start consuming from the Kafka brokers");
-            metadataListener.forceUnsubscriptionAll();
-        } finally {
-            log.atTrace().log("Releasing consumer lock...");
-            consumerLock.unlock();
-            log.atTrace().log("Released consumer lock");
-        }
-    }
-
-    @Override
-    void stopConsuming() {
-        log.atDebug().log("No more subscribed items");
-        log.atTrace().log("Acquiring consumer lock to stop consuming...");
-        consumerLock.lock();
-        log.atTrace().log("Lock acquired to stop consuming...");
-        try {
-            if (consumer != null) {
-                log.atDebug().log("Stopping consumer...");
-                consumer.close();
-                log.atDebug().log("Stopped consumer");
-            } else {
-                log.atDebug().log("Consumer not yet started");
-            }
-        } finally {
-            log.atTrace().log("Releasing consumer lock to stop consuming");
-            consumerLock.unlock();
-            log.atTrace().log("Releases consumer lock to stop consuming");
-        }
-    }
-
-    @Override
-    public void unsubscribeInfoItem() {
-        while (!infoLock.compareAndSet(false, true)) {
-            this.infoItemhande = null;
-        }
-    }
-
-    class ConsumerWrapper implements Runnable {
-
-        private static final Duration POLL_DURATION = Duration.ofMillis(Long.MAX_VALUE);
-        private final KafkaConsumer<K, V> consumer;
-        private final OffsetManager offsetManager;
-        private final CountDownLatch latch = new CountDownLatch(1);
-        private final Thread hook;
-        private final RecordErrorHandlingStrategy errorStrategy;
-
-        ConsumerWrapper(RecordErrorHandlingStrategy errorStrategy) throws KafkaException {
-            this.errorStrategy = errorStrategy;
-            String bootStrapServers =
-                    config.consumerProperties()
-                            .getProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG);
-            log.atInfo().log("Starting connection to Kafka broker(s) at {}", bootStrapServers);
-
-            consumer =
-                    new KafkaConsumer<>(
-                            config.consumerProperties(),
-                            config.keyDeserializer(),
-                            config.valueDeserializer());
-            log.atInfo().log("Established connection to Kafka broker(s) at {}", bootStrapServers);
-
-            this.offsetManager = new OffsetManager(consumer);
-            this.hook = setShutdownHook();
-            log.atDebug().log("Set shutdown kook");
-        }
-
-        private Thread setShutdownHook() {
-            Runnable shutdownTask =
-                    () -> {
-                        log.atInfo().log("Invoked shutdown hook");
-                        shutdown();
-                    };
-
-            Thread hook = new Thread(shutdownTask);
-            Runtime.getRuntime().addShutdownHook(hook);
-            return hook;
-        }
-
-        @Override
-        public void run() {
-            try {
-                if (subscribed()) {
-                    poll();
-                }
-            } catch (WakeupException e) {
-                log.atDebug().log("Kafka Consumer woken up");
-            } finally {
-                log.atDebug().log("Start closing Kafka Consumer");
-                offsetManager.commitSyncAndIgnoreErrors();
-                consumer.close();
-                latch.countDown();
-                log.atDebug().log("Kafka Consumer closed");
-            }
-        }
-
-        private boolean subscribed() {
-            // Original requested topics.
-            Set<String> topics = new HashSet<>(config.itemTemplates().topics());
-            log.atInfo().log("Subscribing to requested topics [{}]", topics);
-            log.atDebug().log("Checking existing topics on Kafka");
-
-            // Check the actual available topics on Kafka.
-            try (Admin admin = AdminClient.create(config.consumerProperties())) {
-                ListTopicsOptions options = new ListTopicsOptions();
-                options.timeoutMs(30000);
-                ListTopicsResult listTopics = admin.listTopics(options);
-                boolean notAllPresent = false;
-
-                // Retain from the original requestes topics the available ones.
-                Set<String> existingTopics = listTopics.names().get();
-                notAllPresent = topics.retainAll(existingTopics);
-
-                // Can't subscribe at all. Force unsubscription and exit the loop.
-                if (topics.isEmpty()) {
-                    log.atWarn().log("Not found requested topics");
-                    metadataListener.forceUnsubscriptionAll();
-                    return false;
-                }
-
-                // Just warn that not all requested topics can be subscribed.
-                if (notAllPresent) {
-                    String loggableTopics =
-                            topics.stream()
-                                    .map(s -> "\"%s\"".formatted(s))
-                                    .collect(Collectors.joining(","));
-                    log.atWarn()
-                            .log(
-                                    "Actually subscribing to the following existing topics [{}]",
-                                    loggableTopics);
-                }
-                consumer.subscribe(topics, offsetManager);
-                return true;
-            } catch (Exception e) {
-                log.atError().setCause(e).log();
-                metadataListener.forceUnsubscriptionAll();
-                return false;
-            }
-        }
-
-        private void poll() throws WakeupException {
-            while (true) {
-                log.atInfo().log("Polling records");
-                try {
-                    ConsumerRecords<K, V> records = consumer.poll(POLL_DURATION);
-                    log.atDebug().log("Received records");
-                    records.forEach(this::consume);
-                    offsetManager.commitAsync();
-                    log.atInfo().log("Consumed {} records", records.count());
-                } catch (WakeupException we) {
-                    // Catch and rethrow the Exception here because of the next KafkaException
-                    throw we;
-                } catch (KafkaException ke) {
-                    log.atError().setCause(ke).log("Unrecoverable exception");
-                    metadataListener.forceUnsubscriptionAll();
-                    break;
-                }
-            }
-        }
-
-        protected void consume(ConsumerRecord<K, V> record) {
-            log.atDebug().log("Mapping incoming Kafka record");
-            log.atTrace().log("Kafka record: {}", record.toString());
-            try {
-                MappedRecord mappedRecord = recordRemapper.map(KafkaRecord.from(record));
-
-                // Logging the mapped record is expensive, log lazly it only at trace level.
-                log.atTrace().log(() -> "Mapped Kafka record to %s".formatted(mappedRecord));
-                log.atDebug().log("Mapped Kafka record");
-
-                Set<SubscribedItem> routables =
-                        config.itemTemplates().routes(mappedRecord, subscribedItems.values());
-
-                log.atDebug().log("Filtering updates");
-                Map<String, String> updates = mappedRecord.filter(fieldsExtractor);
-
-                log.atInfo().log("Routing record to {} items", routables.size());
-                for (SubscribedItem sub : routables) {
-                    log.atDebug().log("Sending updates: {}", updates);
-                    eventListener.smartUpdate(sub.itemHandle(), updates, false);
-                }
-
-                offsetManager.updateOffsets(record);
-            } catch (ValueException ve) {
-                log.atWarn().log("Error while extracting record: {}", ve.getMessage());
-                log.atWarn().log("Applying the {} strategy", errorStrategy);
-
-                switch (errorStrategy) {
-                    case IGNORE_AND_CONTINUE -> {
-                        log.atWarn().log("Ignoring error");
-                        offsetManager.updateOffsets(record);
-                    }
-
-                    case FORCE_UNSUBSCRIPTION -> {
-                        log.atWarn().log("Forcing unsubscription");
-                        throw new KafkaException(ve);
-                    }
-                }
-            }
-        }
-
-        void close() {
-            shutdown();
-            Runtime.getRuntime().removeShutdownHook(this.hook);
-        }
-
-        private void shutdown() {
-            log.atInfo().log("Shutting down Kafka consumer");
-            log.atDebug().log("Waking up consumer");
-            consumer.wakeup();
-            log.atDebug().log("Consumer woken up");
-            try {
-                log.atTrace().log("Waiting for graceful thread completion");
-                latch.await();
-                log.atTrace().log("Completed thread");
-            } catch (InterruptedException e) {
-                // Ignore
-            }
-            log.atInfo().log("Shut down Kafka consumer");
-        }
-    }
-
-    class OffsetManager implements ConsumerRebalanceListener {
-
-        private final Map<TopicPartition, OffsetAndMetadata> currentOffsets = new HashMap<>();
-        private final KafkaConsumer<?, ?> consumer;
-
-        OffsetManager(KafkaConsumer<?, ?> consumer) {
-            this.consumer = consumer;
-        }
-
-        @Override
-        public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
-            log.atWarn().log("Partions revoked, committing offsets {}", currentOffsets);
-            commitSync();
-        }
-
-        void commitSync() {
-            commitSync(false);
-        }
-
-        void commitSyncAndIgnoreErrors() {
-            commitSync(true);
-        }
-
-        private void commitSync(boolean ignoreErrors) {
-            try {
-                log.atDebug().log("Start commiting offset synchronously");
-                consumer.commitSync(currentOffsets);
-                log.atInfo().log("Offsets commited");
-            } catch (KafkaException e) {
-                log.atError().setCause(e).log("Unable to commit offsets");
-                if (!ignoreErrors) {
-                    throw e;
-                }
-            }
-        }
-
-        void commitAsync() {
-            consumer.commitAsync(currentOffsets, null);
-        }
-
-        @Override
-        public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
-            log.atDebug().log("Assigned partiions {}", partitions);
-        }
-
-        void updateOffsets(ConsumerRecord<?, ?> record) {
-            currentOffsets.put(
-                    new TopicPartition(record.topic(), record.partition()),
-                    new OffsetAndMetadata(record.offset() + 1, null));
-        }
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTrigger.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTrigger.java
new file mode 100644
index 00000000..210cfd87
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTrigger.java
@@ -0,0 +1,68 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers;
+
+import com.lightstreamer.interfaces.data.ItemEventListener;
+import com.lightstreamer.interfaces.data.SubscriptionException;
+import com.lightstreamer.kafka.adapters.commons.MetadataListener;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers.KeyValueDeserializers;
+import com.lightstreamer.kafka.common.mapping.Items.Item;
+import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
+import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
+
+import java.util.Properties;
+import java.util.concurrent.CompletableFuture;
+
+public interface ConsumerTrigger {
+
+    public interface ConsumerTriggerConfig<K, V> {
+
+        String connectionName();
+
+        Properties consumerProperties();
+
+        ItemTemplates<K, V> itemTemplates();
+
+        DataExtractor<K, V> fieldsExtractor();
+
+        KeyValueDeserializers<K, V> deserializers();
+
+        RecordErrorHandlingStrategy errorHandlingStrategy();
+
+        Concurrency concurrency();
+
+        interface Concurrency {
+            RecordConsumeWithOrderStrategy orderStrategy();
+
+            int threads();
+        }
+    }
+
+    CompletableFuture<Void> subscribe(String item, Object itemHandle) throws SubscriptionException;
+
+    Item unsubscribe(String topic) throws SubscriptionException;
+
+    static ConsumerTrigger create(
+            ConsumerTriggerConfig<?, ?> config,
+            MetadataListener metadataListener,
+            ItemEventListener eventListener) {
+        return new ConsumerTriggerImpl<>(config, metadataListener, eventListener);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTriggerImpl.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTriggerImpl.java
new file mode 100644
index 00000000..921dc300
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTriggerImpl.java
@@ -0,0 +1,163 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers;
+
+import com.lightstreamer.interfaces.data.ItemEventListener;
+import com.lightstreamer.interfaces.data.SubscriptionException;
+import com.lightstreamer.kafka.adapters.commons.LogFactory;
+import com.lightstreamer.kafka.adapters.commons.MetadataListener;
+import com.lightstreamer.kafka.adapters.consumers.wrapper.ConsumerWrapper;
+import com.lightstreamer.kafka.common.expressions.ExpressionException;
+import com.lightstreamer.kafka.common.mapping.Items;
+import com.lightstreamer.kafka.common.mapping.Items.Item;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+
+import org.apache.kafka.common.KafkaException;
+import org.slf4j.Logger;
+
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Function;
+
+public class ConsumerTriggerImpl<K, V> implements ConsumerTrigger {
+
+    private final ConsumerTriggerConfig<K, V> config;
+    private final MetadataListener metadataListener;
+    private final Function<Collection<SubscribedItem>, ConsumerWrapper<K, V>> consumerWrapper;
+    private final Logger log;
+    private final ExecutorService pool;
+    private final ConcurrentHashMap<String, SubscribedItem> subscribedItems;
+    private final AtomicInteger itemsCounter;
+    private final ReentrantLock consumerLock;
+    private volatile ConsumerWrapper<K, V> consumer;
+    private CompletableFuture<Void> consuming;
+
+    public ConsumerTriggerImpl(
+            ConsumerTriggerConfig<K, V> config,
+            MetadataListener metadataListener,
+            ItemEventListener eventListener) {
+        this(
+                config,
+                metadataListener,
+                items -> ConsumerWrapper.create(config, eventListener, metadataListener, items));
+    }
+
+    ConsumerTriggerImpl(
+            ConsumerTriggerConfig<K, V> config,
+            MetadataListener metadataListener,
+            Function<Collection<SubscribedItem>, ConsumerWrapper<K, V>> consumerWrapper) {
+        this.config = config;
+        this.metadataListener = metadataListener;
+        this.consumerWrapper = consumerWrapper;
+        this.log = LogFactory.getLogger(config.connectionName());
+        this.pool = Executors.newSingleThreadExecutor(r -> new Thread(r, "ConsumerTrigger"));
+        this.subscribedItems = new ConcurrentHashMap<>();
+        this.itemsCounter = new AtomicInteger(0);
+        this.consumerLock = new ReentrantLock();
+    }
+
+    public final int getItemsCounter() {
+        return itemsCounter.get();
+    }
+
+    @Override
+    public final CompletableFuture<Void> subscribe(String item, Object itemHandle)
+            throws SubscriptionException {
+        try {
+            SubscribedItem newItem = Items.subscribedFrom(item, itemHandle);
+            if (!config.itemTemplates().matches(newItem)) {
+                log.atWarn().log("Item [{}] does not match any defined item templates", item);
+                throw new SubscriptionException("Item does not match any defined item templates");
+            }
+
+            log.atInfo().log("Subscribed to item [{}]", item);
+            subscribedItems.put(item, newItem);
+            if (itemsCounter.incrementAndGet() == 1) {
+                consuming = startConsuming();
+            }
+            return consuming;
+        } catch (ExpressionException e) {
+            log.atError().setCause(e).log();
+            throw new SubscriptionException(e.getMessage());
+        }
+    }
+
+    CompletableFuture<Void> startConsuming() throws SubscriptionException {
+        log.atTrace().log("Acquiring consumer lock...");
+        consumerLock.lock();
+        log.atTrace().log("Lock acquired...");
+        try {
+            consumer = consumerWrapper.apply(subscribedItems.values());
+            return CompletableFuture.runAsync(consumer, pool);
+        } catch (KafkaException ke) {
+            log.atError().setCause(ke).log("Unable to start consuming from the Kafka brokers");
+            metadataListener.forceUnsubscriptionAll();
+            itemsCounter.set(0);
+            return CompletableFuture.failedFuture(ke);
+        } finally {
+            log.atTrace().log("Releasing consumer lock...");
+            consumerLock.unlock();
+            log.atTrace().log("Released consumer lock");
+        }
+    }
+
+    @Override
+    public final Item unsubscribe(String item) throws SubscriptionException {
+        Item removedItem = subscribedItems.remove(item);
+        if (removedItem == null) {
+            throw new SubscriptionException(
+                    "Unsubscribing from unexpected item [%s]".formatted(item));
+        }
+
+        if (itemsCounter.decrementAndGet() == 0) {
+            stopConsuming();
+        }
+        return removedItem;
+    }
+
+    void stopConsuming() {
+        log.atDebug().log("No more subscribed items");
+        log.atTrace().log("Acquiring consumer lock to stop consuming...");
+        consumerLock.lock();
+        log.atTrace().log("Lock acquired to stop consuming...");
+        try {
+            if (consumer != null) {
+                log.atDebug().log("Stopping consumer...");
+                consumer.close();
+                consumer = null;
+                log.atDebug().log("Stopped consumer");
+            } else {
+                log.atDebug().log("Consumer not yet started");
+            }
+        } finally {
+            log.atTrace().log("Releasing consumer lock to stop consuming");
+            consumerLock.unlock();
+            log.atTrace().log("Releases consumer lock to stop consuming");
+        }
+    }
+
+    // Only for testing purposes
+    Item getSubscribeditem(String itemName) {
+        return subscribedItems.get(itemName);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/offsets/Offsets.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/offsets/Offsets.java
new file mode 100644
index 00000000..3664fd41
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/offsets/Offsets.java
@@ -0,0 +1,303 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.offsets;
+
+import com.lightstreamer.kafka.common.utils.Split;
+
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicPartition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+public class Offsets {
+
+    static String SEPARATOR = ",";
+    static Supplier<Collection<Long>> SUPPLIER = ArrayList::new;
+    static Predicate<String> NOT_EMPTY_STRING = ((Predicate<String>) String::isEmpty).negate();
+
+    static String encode(Collection<Long> offsets) {
+        return offsets.stream().map(String::valueOf).collect(Collectors.joining(SEPARATOR));
+    }
+
+    static Collection<Long> decode(String str) {
+        if (str.isBlank()) {
+            return Collections.emptyList();
+        }
+        return Split.byComma(str).stream()
+                .filter(NOT_EMPTY_STRING)
+                .map(Long::valueOf)
+                .sorted()
+                .collect(Collectors.toCollection(SUPPLIER));
+    }
+
+    static String append(String str, long offset) {
+        String prefix = str.isEmpty() ? "" : str + SEPARATOR;
+        return prefix + offset;
+    }
+
+    public static OffsetService OffsetService(Consumer<?, ?> consumer) {
+        return new OffsetServiceImpl(consumer, LoggerFactory.getLogger(OffsetService.class));
+    }
+
+    public static OffsetService OffsetService(Consumer<?, ?> consumer, Logger log) {
+        return new OffsetServiceImpl(consumer, log);
+    }
+
+    public static OffsetStore OffsetStore(Map<TopicPartition, OffsetAndMetadata> committed) {
+        return new OffsetStoreImpl(committed);
+    }
+
+    public interface OffsetStore {
+
+        void save(ConsumerRecord<?, ?> record);
+
+        default Map<TopicPartition, OffsetAndMetadata> current() {
+            return Collections.emptyMap();
+        }
+    }
+
+    public interface OffsetService extends ConsumerRebalanceListener {
+
+        @FunctionalInterface
+        interface OffsetStoreSupplier {
+
+            OffsetStore newOffsetStore(Map<TopicPartition, OffsetAndMetadata> offsets);
+        }
+
+        default void initStore(boolean fromLatest) {
+            initStore(fromLatest, Offsets.OffsetStoreImpl::new);
+        }
+
+        void initStore(boolean flag, OffsetStoreSupplier storeSupplier);
+
+        default void initStore(
+                Map<TopicPartition, Long> startOffsets,
+                Map<TopicPartition, OffsetAndMetadata> committed) {
+            initStore(Offsets.OffsetStoreImpl::new, startOffsets, committed);
+        }
+
+        void initStore(
+                OffsetStoreSupplier storeSupplier,
+                Map<TopicPartition, Long> startOffsets,
+                Map<TopicPartition, OffsetAndMetadata> committed);
+
+        boolean notHasPendingOffset(ConsumerRecord<?, ?> record);
+
+        void commitSync();
+
+        void commitSyncAndIgnoreErrors();
+
+        void commitAsync();
+
+        void updateOffsets(ConsumerRecord<?, ?> record);
+
+        void onAsyncFailure(Throwable th);
+
+        Throwable getFirstFailure();
+
+        Optional<OffsetStore> offsetStore();
+    }
+
+    private static class OffsetServiceImpl implements OffsetService {
+
+        private volatile Throwable firstFailure;
+        private final Consumer<?, ?> consumer;
+        private final Logger log;
+
+        // Initialize the OffsetStore with a NOP implementation
+        private OffsetStore offsetStore = record -> {};
+
+        private Map<TopicPartition, Collection<Long>> pendingOffsetsMap = new ConcurrentHashMap<>();
+
+        OffsetServiceImpl(Consumer<?, ?> consumer, Logger logger) {
+            this.consumer = consumer;
+            this.log = logger;
+        }
+
+        @Override
+        public void initStore(boolean fromLatest, OffsetStoreSupplier storeSupplier) {
+            Set<TopicPartition> partitions = consumer.assignment();
+            // Retrieve the offset to start from, which has to be used in case no commited offset is
+            // available for a given partition.
+            // The start offset depends on the auto.offset.reset property.
+            Map<TopicPartition, Long> startOffsets =
+                    fromLatest
+                            ? consumer.endOffsets(partitions)
+                            : consumer.beginningOffsets(partitions);
+            // Get the current commited offsets for all the assigned partitions
+            Map<TopicPartition, OffsetAndMetadata> committed = consumer.committed(partitions);
+            initStore(storeSupplier, startOffsets, committed);
+        }
+
+        @Override
+        public void initStore(
+                OffsetStoreSupplier storeSupplier,
+                Map<TopicPartition, Long> startOffsets,
+                Map<TopicPartition, OffsetAndMetadata> committed) {
+            Map<TopicPartition, OffsetAndMetadata> offsetRepo = new HashMap<>(committed);
+            // If a partition misses a commited offset for a partition, just put the
+            // the current offset.
+            for (TopicPartition partition : startOffsets.keySet()) {
+                OffsetAndMetadata offsetAndMetadata =
+                        offsetRepo.computeIfAbsent(
+                                partition, p -> new OffsetAndMetadata(startOffsets.get(p)));
+                // Store the offsets that have been already delivered to clients,
+                // bot not yet committed (most likely due to an exception while processing in
+                // parallel).
+                pendingOffsetsMap.put(partition, decode(offsetAndMetadata.metadata()));
+            }
+            offsetStore = storeSupplier.newOffsetStore(offsetRepo);
+        }
+
+        @Override
+        public boolean notHasPendingOffset(ConsumerRecord<?, ?> record) {
+            Collection<Long> pendingOffsetsList =
+                    pendingOffsetsMap.getOrDefault(
+                            new TopicPartition(record.topic(), record.partition()),
+                            Collections.emptyList());
+            return !pendingOffsetsList.contains(record.offset());
+        }
+
+        @Override
+        public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
+            log.atDebug().log("Assigned partiions {}", partitions);
+        }
+
+        @Override
+        public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
+            log.atWarn().log("Partions revoked");
+            commitSync();
+        }
+
+        @Override
+        public void commitSync() {
+            commitSync(false);
+        }
+
+        @Override
+        public void commitSyncAndIgnoreErrors() {
+            commitSync(true);
+        }
+
+        private void commitSync(boolean ignoreErrors) {
+            try {
+                log.atDebug().log("Start commiting offset synchronously");
+                consumer.commitSync(offsetStore.current());
+                log.atInfo().log("Offsets commited");
+            } catch (KafkaException e) {
+                log.atError().setCause(e).log("Unable to commit offsets");
+                if (!ignoreErrors) {
+                    log.atDebug().log("Rethrowing the error");
+                    throw e;
+                }
+            }
+        }
+
+        @Override
+        public void commitAsync() {
+            consumer.commitAsync(offsetStore.current(), null);
+        }
+
+        @Override
+        public void updateOffsets(ConsumerRecord<?, ?> record) {
+            offsetStore.save(record);
+        }
+
+        @Override
+        public void onAsyncFailure(Throwable th) {
+            if (firstFailure == null) {
+                firstFailure = th; // any of the first exceptions got should be enough
+            }
+        }
+
+        public Throwable getFirstFailure() {
+            return firstFailure;
+        }
+
+        @Override
+        public Optional<OffsetStore> offsetStore() {
+            return Optional.of(offsetStore);
+        }
+    }
+
+    private static class OffsetStoreImpl implements OffsetStore {
+
+        private final Map<TopicPartition, OffsetAndMetadata> offsets;
+
+        OffsetStoreImpl(Map<TopicPartition, OffsetAndMetadata> committed) {
+            this.offsets = new ConcurrentHashMap<>(committed);
+        }
+
+        @Override
+        public Map<TopicPartition, OffsetAndMetadata> current() {
+            return Collections.unmodifiableMap(offsets);
+        }
+
+        @Override
+        public void save(ConsumerRecord<?, ?> record) {
+            TopicPartition topicPartition = new TopicPartition(record.topic(), record.partition());
+            offsets.compute(topicPartition, (p, O) -> mkNewOffsetAndMetadata(record, O));
+        }
+
+        private OffsetAndMetadata mkNewOffsetAndMetadata(
+                ConsumerRecord<?, ?> record, OffsetAndMetadata lastOffsetAndMetadata) {
+            String lastMetadata = lastOffsetAndMetadata.metadata();
+            long lastOffset = lastOffsetAndMetadata.offset();
+            long consumedOffset = record.offset();
+            if (consumedOffset == lastOffset) {
+                Collection<Long> orderedConsumedList = decode(lastMetadata);
+                Iterator<Long> iterator = orderedConsumedList.iterator();
+
+                long newOffset = lastOffset;
+                while (iterator.hasNext()) {
+                    long offset = iterator.next();
+                    if (offset == newOffset + 1) {
+                        newOffset = offset;
+                        iterator.remove();
+                        continue;
+                    }
+                    break;
+                }
+                String newMetadata =
+                        newOffset == lastOffset ? lastMetadata : encode(orderedConsumedList);
+                return new OffsetAndMetadata(newOffset + 1, newMetadata);
+            }
+            String newMetadata = append(lastMetadata, consumedOffset);
+            return new OffsetAndMetadata(lastOffset, newMetadata);
+        }
+    }
+
+    private Offsets() {}
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/Multiplexer.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/Multiplexer.java
new file mode 100644
index 00000000..e7d08813
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/Multiplexer.java
@@ -0,0 +1,315 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.processor;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class Multiplexer<S> implements TaskExecutor<S> {
+
+    private final ExecutorService executor;
+
+    /*
+     * The Map associates each sequence to the queue of tasks to be run.
+     * The queue is implemented through the "next" element of each task.
+     *
+     * Associated invariant:
+     * - As long as a sequence is present in the Map, its queue is being processed by a dequeuing activity.
+     *   When the dequeueing activity consumes the queue, it removes the sequence from the Map.
+     *   Hence, at most one dequeueing activity can be active at any time.
+     * - The element currently mapped corresponds to the last task of the queue if its "next" element is null;
+     *   otherwise, it is a transient state MOD in which the queue is currently being modified.
+     *
+     * Associated constraints:
+     * - Only the task that can add its sequence to the Map can also schedule a dequeueing activity.
+     *   If the sequence is already present in the Map, other tasks can only add themselves to the queue.
+     *   The dequeueing activity can take care of added tasks either immediately or by rescheduling;
+     *   the latter is done by delegating the new scheduling to the next task left in the queue.
+     *   If the end of the queue is reached, the dequeueing activity should remove the sequence from the Map.
+     *
+     * - Only one task at a time can add itself to an existing queue.
+     *   In fact, the addition is a two-step process:
+     *   first, the task sets itself as the next of the task associated in the Map, thus bringing state MOD;
+     *   then, the task sets itself as the associated element in the Map, thus terminating state MOD.
+     *   During state MOD, other tasks willing to add themselves must wait.
+     *   On the other hand, the first step is enough for the dequeueing activity to process the task;
+     *   hence the task may even be mapped after it has already been processed.
+     *
+     * - Moreover, during sequence removal by the dequeueing activity, new task additions cannot be run.
+     *   In fact, sequence removal is also a two-step process:
+     *   first, the last task of the queue is set as the next of itself;
+     *   then, the sequence is removed from the Map.
+     *   The first step either brings state MOD, or occurs while already in state MOD.
+     *   In the latter case, the last task is still to be associated in the Map;
+     *   anyway, after association, the state MOD persists, thus new additions are still prevented;
+     *   on the other hand, the second step (the removal) may occur before the reassociation;
+     *   in this case, the reassociation is just redundant and should be prevented;
+     *   hence, an adding task must always check this possibility when trying to associate itself.
+     *   Obviously, the second step terminates state MOD and enables new additions;
+     *   but now, pending task additions will also readd the sequence.
+     */
+    private final ConcurrentMap<S, LinkableTask> queues;
+
+    private final MyCountDownLatch emptinessChecker;
+
+    private static final int CPU_BOUND_BATCH = 1000; // experimental
+
+    public Multiplexer(ExecutorService executor, boolean batchSupport) {
+        this.executor = executor;
+
+        if (batchSupport) {
+            emptinessChecker = new MyCountDownLatch();
+        } else {
+            emptinessChecker = null;
+        }
+
+        queues = new ConcurrentHashMap<>();
+    }
+
+    public boolean supportsBatching() {
+        return emptinessChecker != null;
+    }
+
+    private void runTask(Runnable task) {
+        try {
+            task.run();
+        } finally {
+            if (emptinessChecker != null) {
+                emptinessChecker.decrement();
+            }
+        }
+    }
+
+    @Override
+    public void shutdown() {
+        executor.shutdown();
+        try {
+            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
+                executor.shutdownNow();
+                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
+                    throw new RuntimeException("Executor not terminated!");
+                }
+            }
+        } catch (InterruptedException e) {
+            // (Re-)Cancel if current thread also interrupted
+            executor.shutdownNow();
+            // Preserve interrupt status
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private class LinkableTask implements Runnable {
+        private final S sequence;
+        private final Runnable deferredTask;
+        private final AtomicReference<LinkableTask> next;
+
+        public LinkableTask(S sequence, Runnable deferredTask) {
+            this.sequence = sequence;
+            this.deferredTask = deferredTask;
+            next = new AtomicReference<>(null);
+        }
+
+        public void attach() {
+            while (true) {
+                LinkableTask last = queues.putIfAbsent(sequence, this);
+                if (last == null) {
+                    // there were no tasks in queue for the sequence;
+                    // I can safely schedule the dequeuing activity:
+                    // other requests will work on this.next
+                    executor.execute(this);
+                    break;
+                } else {
+                    // there was a task queue in place and last is the last task,
+                    // but only as long as last.next is null
+                    if (last.next.compareAndSet(null, this)) {
+                        // [A]
+                        // there was no next and now state MOD is established;
+                        // I can safely notify myself as the new last:
+                        // other requests must get back to the map and wait there;
+                        // the only contention is with my own getNext in [B],
+                        // which may have already removed the element
+
+                        if (!queues.replace(sequence, last, this)) {
+                            // if a removal came first, this was not necessary
+                        }
+                        break;
+                    } else {
+                        // there is another addition in place (state MOD);
+                        // I could follow the queue, but it is better to retry from the beginning,
+                        // because in the meantime the queue may also be executed and removed
+                        continue;
+                    }
+                }
+            }
+        }
+
+        @Override
+        public void run() {
+            // dequeuing activity
+            LinkableTask last = this;
+
+            try {
+                runTask(deferredTask);
+
+                // Check if there are other waiting tasks for this sequence;
+                // assuming CPU-bound tasks, we can execute them immediately,
+                // provided that we avoid starvation
+                for (int i = 0; i < CPU_BOUND_BATCH; i++) {
+                    last = last.getNext();
+                    if (last != null) {
+                        runTask(last.deferredTask);
+                    } else {
+                        // the task queue has been completed and the sequence already removed
+                        // (a new queue may be concurrently being initiated)
+                        last = null;
+                        break;
+                    }
+                }
+
+            } catch (RuntimeException | Error e) {
+                // this is unexpected; the Runnable received is supposed to check its own exceptions
+                throw e;
+
+            } finally {
+                if (last != null) {
+                    // We haven't finished the dequeuing for this sequence;
+                    // to continue, we resort to the executor, for fairness;
+                    // in case of exception executing last, we will skip it
+                    last.launchNext();
+                }
+            }
+        }
+
+        protected LinkableTask getNext() {
+            if (next.compareAndSet(null, this)) {
+                // [B]
+                // there was no next and further additions are now blocked;
+                // I can safely remove the queue as completed:
+                // other requests must get back to the map and wait there (state MOD);
+                // the only contention is with my own attach in [A],
+                // which may haven't set the element yet in the map;
+                // in this case, that mapping will no longer be needed
+
+                queues.remove(sequence);
+                return null;
+            } else {
+                // there was a next and it is now immutable
+                return next.get();
+            }
+        }
+
+        protected void launchNext() {
+            LinkableTask nextTask = getNext();
+            if (nextTask != null) {
+                // the next task will take care of itself and the rest of the task queue
+                executor.execute(nextTask);
+            } else {
+                // the task queue was completed and the sequence already removed
+                // (a new queue may be concurrently being initiated)
+            }
+        }
+    }
+
+    @Override
+    public void execute(S sequence, Runnable task) {
+        if (emptinessChecker != null) {
+            emptinessChecker.increment();
+        }
+        if (sequence == null) {
+            // No requirement to sequentialize tasks that have no key set
+            if (emptinessChecker != null) {
+                executor.execute(() -> runTask(task));
+            } else {
+                executor.execute(task);
+            }
+        } else {
+            // Create the task and attach it to the task queue for the sequence;
+            // this will also take care of ensuring that the task will be dequeued
+            LinkableTask linkableTask = new LinkableTask(sequence, task);
+            linkableTask.attach();
+        }
+    }
+
+    private class MyCountDownLatch {
+        // couldn't find this functionality in the JDK
+
+        private final AtomicLong count = new AtomicLong(0);
+
+        private final Semaphore semaphore = new Semaphore(0);
+
+        private final AtomicBoolean waiting = new AtomicBoolean(false);
+
+        private void increment() {
+            count.incrementAndGet();
+        }
+
+        private void decrement() {
+            long val = count.decrementAndGet();
+            if (val == 0) {
+                if (waiting.compareAndSet(true, false)) {
+                    semaphore.release();
+                }
+            }
+        }
+
+        private void waitEmpty() {
+            if (!waiting.compareAndSet(false, true)) {
+                throw new IllegalStateException();
+            }
+            if (count.get() == 0) {
+                if (waiting.compareAndSet(true, false)) {
+                    assert (semaphore.availablePermits() == 0);
+                    return;
+                } else {
+                    // race condition: semaphore being released
+                }
+            }
+            try {
+                semaphore.acquire();
+                // assert (count.get() == 0); unless other producers are still running
+                assert (semaphore.availablePermits() == 0);
+                assert (waiting.get() == false);
+            } catch (InterruptedException e) {
+                if (waiting.compareAndSet(true, false)) {
+                    assert (semaphore.availablePermits() == 0);
+                    throw new IllegalStateException();
+                } else {
+                    // race condition
+                    while (semaphore.drainPermits() == 0)
+                        ;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void waitBatch() {
+        if (emptinessChecker == null) {
+            throw new UnsupportedOperationException();
+        }
+        synchronized (emptinessChecker) {
+            emptinessChecker.waitEmpty();
+        }
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumer.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumer.java
new file mode 100644
index 00000000..482d3120
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumer.java
@@ -0,0 +1,141 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.processor;
+
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.toList;
+
+import com.lightstreamer.interfaces.data.ItemEventListener;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
+import com.lightstreamer.kafka.adapters.consumers.offsets.Offsets.OffsetService;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+import com.lightstreamer.kafka.common.mapping.RecordMapper;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.common.TopicPartition;
+import org.slf4j.Logger;
+
+import java.util.Collection;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.StreamSupport;
+
+public interface RecordConsumer<K, V> {
+
+    enum OrderStrategy {
+        ORDER_BY_KEY(record -> Objects.toString(record.key(), null)),
+        ORDER_BY_PARTITION(record -> String.valueOf(record.partition())),
+        UNORDERED(record -> null);
+
+        private Function<ConsumerRecord<?, ?>, String> sequence;
+
+        OrderStrategy(Function<ConsumerRecord<?, ?>, String> sequence) {
+            this.sequence = sequence;
+        }
+
+        String getSequence(ConsumerRecord<?, ?> record) {
+            return sequence.apply(record);
+        }
+
+        public static OrderStrategy from(RecordConsumeWithOrderStrategy strategy) {
+            return switch (strategy) {
+                case ORDER_BY_KEY -> ORDER_BY_KEY;
+                case ORDER_BY_PARTITION -> ORDER_BY_PARTITION;
+                case UNORDERED -> UNORDERED;
+            };
+        }
+    }
+
+    interface RecordProcessor<K, V> {
+
+        void process(ConsumerRecord<K, V> record) throws ValueException;
+
+        void useLogger(Logger logger);
+    }
+
+    public interface StartBuildingProcessor<K, V> {
+
+        WithSubscribedItems<K, V> subscribedItems(Collection<SubscribedItem> subscribedItems);
+    }
+
+    interface WithSubscribedItems<K, V> {
+
+        StartBuildingConsumer<K, V> eventListener(ItemEventListener listener);
+    }
+
+    public interface StartBuildingConsumer<K, V> {
+
+        WihtOffsetService<K, V> offsetService(OffsetService offsetService);
+    }
+
+    interface WihtOffsetService<K, V> {
+
+        WithLogger<K, V> errorStrategy(RecordErrorHandlingStrategy stragey);
+    }
+
+    interface WithLogger<K, V> {
+
+        WithOptionals<K, V> logger(Logger logger);
+    }
+
+    interface WithOptionals<K, V> {
+
+        WithOptionals<K, V> threads(int threads);
+
+        WithOptionals<K, V> ordering(OrderStrategy orderStrategy);
+
+        WithOptionals<K, V> preferSingleThread(boolean singleThread);
+
+        RecordConsumer<K, V> build();
+    }
+
+    public static <K, V> StartBuildingProcessor<K, V> recordMapper(RecordMapper<K, V> mapper) {
+        return RecordConsumerSupport.startBuildingProcessor(mapper);
+    }
+
+    public static <K, V> StartBuildingConsumer<K, V> recordProcessor(
+            RecordProcessor<K, V> recordProcessor) {
+        return RecordConsumerSupport.startBuildingConsumer(recordProcessor);
+    }
+
+    static <K, V> ConsumerRecords<K, V> filter(
+            ConsumerRecords<K, V> records, Predicate<ConsumerRecord<K, V>> predicate) {
+        return new ConsumerRecords<>(
+                StreamSupport.stream(records.spliterator(), false)
+                        .filter(predicate)
+                        .collect(
+                                groupingBy(
+                                        r -> new TopicPartition(r.topic(), r.partition()),
+                                        toList())));
+    }
+
+    default ConsumerRecords<K, V> consumeFilteredRecords(
+            ConsumerRecords<K, V> records, Predicate<ConsumerRecord<K, V>> predicate) {
+        ConsumerRecords<K, V> filtered = filter(records, predicate);
+        consumeRecords(filtered);
+        return filtered;
+    }
+
+    void consumeRecords(ConsumerRecords<K, V> records);
+
+    default void close() {}
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumerSupport.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumerSupport.java
new file mode 100644
index 00000000..0e4caa67
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumerSupport.java
@@ -0,0 +1,408 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.processor;
+
+import static java.util.concurrent.Executors.newFixedThreadPool;
+
+import com.lightstreamer.interfaces.data.ItemEventListener;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
+import com.lightstreamer.kafka.adapters.consumers.offsets.Offsets.OffsetService;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.OrderStrategy;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.RecordProcessor;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.StartBuildingConsumer;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.StartBuildingProcessor;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.WihtOffsetService;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.WithLogger;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.WithOptionals;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.WithSubscribedItems;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+import com.lightstreamer.kafka.common.mapping.RecordMapper;
+import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.common.KafkaException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+class RecordConsumerSupport {
+
+    public static <K, V> StartBuildingProcessor<K, V> startBuildingProcessor(
+            RecordMapper<K, V> mapper) {
+        return new StartBuildingProcessorBuilderImpl<>(mapper);
+    }
+
+    public static <K, V> StartBuildingConsumer<K, V> startBuildingConsumer(
+            RecordProcessor<K, V> recordProcessor) {
+        return new StartBuildingConsumerImpl<>(recordProcessor);
+    }
+
+    private static class StartBuildingConsumerImpl<K, V> implements StartBuildingConsumer<K, V> {
+
+        protected RecordProcessor<K, V> processor;
+        protected OffsetService offsetService;
+        protected RecordErrorHandlingStrategy errorStrategy;
+        protected Logger logger;
+
+        // Optional and defaulted fields
+        protected int threads = 1;
+        protected OrderStrategy orderStrategy = OrderStrategy.ORDER_BY_PARTITION;
+        protected boolean prefereSingleThread = false;
+
+        StartBuildingConsumerImpl(RecordProcessor<K, V> processor) {
+            this.processor = processor;
+        }
+
+        @Override
+        public WihtOffsetService<K, V> offsetService(OffsetService offsetService) {
+            this.offsetService = offsetService;
+            return new WithOffsetServiceImpl<>(this);
+        }
+    }
+
+    private static class StartBuildingProcessorBuilderImpl<K, V>
+            implements StartBuildingProcessor<K, V> {
+
+        protected RecordMapper<K, V> mapper;
+        protected Collection<SubscribedItem> subscribed;
+        protected ItemEventListener listener;
+
+        StartBuildingProcessorBuilderImpl(RecordMapper<K, V> mapper) {
+            this.mapper = mapper;
+        }
+
+        @Override
+        public WithSubscribedItems<K, V> subscribedItems(
+                Collection<SubscribedItem> subscribedItems) {
+            this.subscribed = subscribedItems;
+            return new WithSubscribedItemsImpl<>(this);
+        }
+    }
+
+    private static class WithSubscribedItemsImpl<K, V> implements WithSubscribedItems<K, V> {
+        final StartBuildingProcessorBuilderImpl<K, V> parentBuilder;
+
+        WithSubscribedItemsImpl(StartBuildingProcessorBuilderImpl<K, V> b) {
+            this.parentBuilder = b;
+        }
+
+        @Override
+        public StartBuildingConsumer<K, V> eventListener(ItemEventListener listener) {
+            this.parentBuilder.listener = listener;
+            Objects.requireNonNull(this.parentBuilder.mapper);
+            Objects.requireNonNull(this.parentBuilder.subscribed);
+            Objects.requireNonNull(this.parentBuilder.listener);
+            RecordProcessor<K, V> recordProcessor =
+                    new DefaultRecordProcessor<>(
+                            this.parentBuilder.mapper,
+                            this.parentBuilder.subscribed,
+                            this.parentBuilder.listener);
+            return new StartBuildingConsumerImpl<>(recordProcessor);
+        }
+    }
+
+    private static class WithOffsetServiceImpl<K, V> implements WihtOffsetService<K, V> {
+
+        final StartBuildingConsumerImpl<K, V> parentBuilder;
+
+        WithOffsetServiceImpl(StartBuildingConsumerImpl<K, V> b) {
+            this.parentBuilder = b;
+        }
+
+        @Override
+        public WithLogger<K, V> errorStrategy(RecordErrorHandlingStrategy stragey) {
+            this.parentBuilder.errorStrategy = stragey;
+            return new WithLoggerImpl<>(parentBuilder);
+        }
+    }
+
+    private static class WithLoggerImpl<K, V> implements WithLogger<K, V> {
+
+        final StartBuildingConsumerImpl<K, V> b;
+
+        WithLoggerImpl(StartBuildingConsumerImpl<K, V> b) {
+            this.b = b;
+        }
+
+        @Override
+        public WithOptionals<K, V> logger(Logger logger) {
+            this.b.logger = logger;
+            return new WithOptionalsImpl<>(b);
+        }
+    }
+
+    private static class WithOptionalsImpl<K, V> implements WithOptionals<K, V> {
+        final StartBuildingConsumerImpl<K, V> parentBuilder;
+
+        WithOptionalsImpl(StartBuildingConsumerImpl<K, V> b) {
+            this.parentBuilder = b;
+        }
+
+        @Override
+        public WithOptionals<K, V> threads(int threads) {
+            this.parentBuilder.threads = threads;
+            return this;
+        }
+
+        @Override
+        public WithOptionals<K, V> ordering(OrderStrategy orderStrategy) {
+            this.parentBuilder.orderStrategy = orderStrategy;
+            return this;
+        }
+
+        @Override
+        public WithOptionals<K, V> preferSingleThread(boolean singleThread) {
+            this.parentBuilder.prefereSingleThread = singleThread;
+            return this;
+        }
+
+        @Override
+        public RecordConsumer<K, V> build() {
+            Objects.requireNonNull(parentBuilder.errorStrategy);
+            Objects.requireNonNull(parentBuilder.logger);
+            Objects.requireNonNull(parentBuilder.orderStrategy);
+            if (parentBuilder.threads < 1 && parentBuilder.threads != -1) {
+                throw new IllegalArgumentException("Threads number must be greater than zero");
+            }
+            if (parentBuilder.threads == 1 && parentBuilder.prefereSingleThread) {
+                return new SingleThreadedRecordConsumer<>(parentBuilder);
+            }
+            return new ParallelRecordConsumer<>(parentBuilder);
+        }
+    }
+
+    static class DefaultRecordProcessor<K, V> implements RecordProcessor<K, V> {
+
+        protected final RecordMapper<K, V> recordMapper;
+        protected final Collection<SubscribedItem> subscribedItems;
+        protected final ItemEventListener listener;
+        protected Logger log = LoggerFactory.getLogger(DefaultRecordProcessor.class);
+
+        DefaultRecordProcessor(
+                RecordMapper<K, V> recordMapper,
+                Collection<SubscribedItem> subscribedItems,
+                ItemEventListener listener) {
+            this.recordMapper = recordMapper;
+            this.subscribedItems = subscribedItems;
+            this.listener = listener;
+        }
+
+        @Override
+        public void useLogger(Logger logger) {
+            this.log = Objects.requireNonNullElse(logger, this.log);
+        }
+
+        @Override
+        public void process(ConsumerRecord<K, V> record) throws ValueException {
+            log.atDebug().log(() -> "Mapping incoming Kafka record");
+            log.atTrace().log(() -> "Kafka record: %s".formatted(record.toString()));
+
+            MappedRecord mappedRecord = recordMapper.map(KafkaRecord.from(record));
+
+            // As logging the mapped record is expensive, log lazly it only at trace level.
+            log.atTrace().log(() -> "Mapped Kafka record to %s".formatted(mappedRecord));
+            log.atDebug().log(() -> "Mapped Kafka record");
+
+            Set<SubscribedItem> routables = mappedRecord.route(subscribedItems);
+
+            log.atDebug().log(() -> "Filtering updates");
+            Map<String, String> updates = mappedRecord.fieldsMap();
+
+            for (SubscribedItem sub : routables) {
+                log.atDebug().log(() -> "Sending updates: %s".formatted(updates));
+                listener.smartUpdate(sub.itemHandle(), updates, false);
+            }
+        }
+    }
+
+    private abstract static class AbstractRecordConsumer<K, V> implements RecordConsumer<K, V> {
+
+        protected final OffsetService offsetService;
+        protected final RecordProcessor<K, V> recordProcessor;
+        protected final RecordErrorHandlingStrategy errorStrategy;
+        protected final Logger logger;
+
+        AbstractRecordConsumer(StartBuildingConsumerImpl<K, V> builder) {
+            this.errorStrategy = builder.errorStrategy;
+            this.offsetService = builder.offsetService;
+            this.logger = builder.logger;
+            this.recordProcessor = builder.processor;
+            // Enforce usage of the same logger
+            this.recordProcessor.useLogger(logger);
+        }
+
+        @Override
+        public void close() {
+            offsetService.commitSyncAndIgnoreErrors();
+        }
+    }
+
+    static class SingleThreadedRecordConsumer<K, V> extends AbstractRecordConsumer<K, V> {
+
+        SingleThreadedRecordConsumer(StartBuildingConsumerImpl<K, V> builder) {
+            super(builder);
+        }
+
+        @Override
+        public void consumeRecords(ConsumerRecords<K, V> records) {
+            records.forEach(this::consumeRecord);
+            offsetService.commitAsync();
+        }
+
+        void consumeRecord(ConsumerRecord<K, V> record) {
+            try {
+                recordProcessor.process(record);
+                offsetService.updateOffsets(record);
+            } catch (ValueException ve) {
+                logger.atWarn().log("Error while extracting record: {}", ve.getMessage());
+                logger.atWarn().log("Applying the {} strategy", errorStrategy);
+
+                switch (errorStrategy) {
+                    case IGNORE_AND_CONTINUE -> {
+                        logger.atWarn().log("Ignoring error");
+                        offsetService.updateOffsets(record);
+                    }
+
+                    case FORCE_UNSUBSCRIPTION -> {
+                        logger.atWarn().log("Forcing unsubscription");
+                        throw new KafkaException(ve);
+                    }
+                }
+            }
+        }
+    }
+
+    static class ParallelRecordConsumer<K, V> extends AbstractRecordConsumer<K, V> {
+
+        protected final OrderStrategy orderStrategy;
+        protected final int configuredThreads;
+        protected final TaskExecutor<String> taskExecutor;
+        protected final int actualThreads;
+
+        ParallelRecordConsumer(StartBuildingConsumerImpl<K, V> builder) {
+            super(builder);
+            this.orderStrategy = builder.orderStrategy;
+            this.configuredThreads = builder.threads;
+            this.actualThreads = getActualThreadsNumber(configuredThreads);
+
+            AtomicInteger threadCount = new AtomicInteger();
+            this.taskExecutor =
+                    TaskExecutor.create(
+                            newFixedThreadPool(actualThreads, r -> newThread(r, threadCount)));
+        }
+
+        private static int getActualThreadsNumber(int configuredThreads) {
+            if (configuredThreads == -1) {
+                return Runtime.getRuntime().availableProcessors();
+            }
+            return configuredThreads;
+        }
+
+        private Thread newThread(Runnable r, AtomicInteger threadCount) {
+            return new Thread(r, "ParallelConsumer-" + threadCount.getAndIncrement());
+        }
+
+        @Override
+        public void consumeRecords(ConsumerRecords<K, V> records) {
+            List<ConsumerRecord<K, V>> allRecords = flatRecords(records);
+            taskExecutor.executeBatch(allRecords, orderStrategy::getSequence, this::consume);
+            // NOTE: this may be inefficient if, for instance, a single task
+            // should keep the executor engaged while all other threads are idle,
+            // but this is not expected when all tasks are short and cpu-bound
+            offsetService.commitAsync();
+            Throwable failure = offsetService.getFirstFailure();
+            if (failure != null) {
+                logger.atWarn().log("Forcing unsubscription");
+                throw new KafkaException(failure);
+            }
+        }
+
+        void consume(String sequence, ConsumerRecord<K, V> record) {
+            try {
+                logger.atDebug().log(
+                        () ->
+                                "Processing record with sequence %s [%s]"
+                                        .formatted(sequence, orderStrategy));
+                recordProcessor.process(record);
+                offsetService.updateOffsets(record);
+            } catch (ValueException ve) {
+                logger.atWarn().log("Error while extracting record: {}", ve.getMessage());
+                logger.atWarn().log("Applying the {} strategy", errorStrategy);
+                handleError(record, ve);
+            } catch (Throwable t) {
+                logger.atError().log("Serious error while processing record!");
+                offsetService.onAsyncFailure(t);
+            }
+        }
+
+        private void handleError(ConsumerRecord<K, V> record, ValueException ve) {
+            switch (errorStrategy) {
+                case IGNORE_AND_CONTINUE -> {
+                    logger.atWarn().log("Ignoring error");
+                    offsetService.updateOffsets(record);
+                }
+
+                case FORCE_UNSUBSCRIPTION -> {
+                    // Trying to emulate the behavior of the above synchronous case, whereas the
+                    // first record which gets an error ends the commits; hence we will keep track
+                    // of the first error found on each partition; then, when committing each
+                    // partition after the termination of the current poll, we will end before
+                    // the first failed record found; this, obviously, is not possible in the
+                    // fire-and-forget policy, but requires the batching one.
+                    //
+                    // There is a difference, though: in the synchronous case, the first error also
+                    // stops the elaboration on the whole topic and all partitions are committed to
+                    // the current point; in this case, instead, the elaboration continues until
+                    // the end of the poll, hence, partitions with errors are committed up to
+                    // the first error, but subsequent records, though not committed, may have
+                    // been processed all the same (even records with the same key of a previously
+                    // failed  record) and only then is the elaboration stopped.
+                    // On the other hand, partitions without errors are processed and committed
+                    // entirely, which is good, although, then, the elaboration stops also for them.
+                    logger.atWarn().log("Will force unsubscription");
+                    offsetService.onAsyncFailure(ve);
+                }
+            }
+        }
+
+        @Override
+        public void close() {
+            super.close();
+            taskExecutor.shutdown();
+        }
+    }
+
+    public static <K, V> List<ConsumerRecord<K, V>> flatRecords(ConsumerRecords<K, V> records) {
+        List<ConsumerRecord<K, V>> allRecords = new ArrayList<>();
+        records.partitions()
+                .forEach(topicPartition -> allRecords.addAll(records.records(topicPartition)));
+        return allRecords;
+    }
+
+    private RecordConsumerSupport() {}
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/TaskExecutor.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/TaskExecutor.java
new file mode 100644
index 00000000..5cfc2aed
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/processor/TaskExecutor.java
@@ -0,0 +1,68 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.processor;
+
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+public interface TaskExecutor<S> {
+
+    void shutdown();
+
+    void execute(S sequence, Runnable task);
+
+    default <E> void execute(E event, S sequence, BiConsumer<? super S, ? super E> task) {
+        execute(sequence, () -> task.accept(sequence, event));
+    }
+
+    default <E> void executeBatch(
+            List<? extends E> events,
+            Function<? super E, ? extends S> sequence,
+            BiConsumer<? super S, ? super E> task) {
+        CountDownLatch latch = new CountDownLatch(events.size());
+        for (E event : events) {
+            S seq = sequence.apply(event);
+            execute(event, seq, wrapTask(task, latch));
+        }
+        try {
+            latch.await();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    default <E> BiConsumer<? super S, ? super E> wrapTask(
+            BiConsumer<? super S, ? super E> task, CountDownLatch latch) {
+        return (s, e) -> {
+            try {
+                task.accept(s, e);
+            } finally {
+                latch.countDown();
+            }
+        };
+    }
+
+    default void waitBatch() {}
+
+    static <S> TaskExecutor<S> create(ExecutorService pool) {
+        return new Multiplexer<>(pool, false);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/wrapper/ConsumerWrapper.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/wrapper/ConsumerWrapper.java
new file mode 100644
index 00000000..508a003d
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/wrapper/ConsumerWrapper.java
@@ -0,0 +1,119 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.wrapper;
+
+import com.lightstreamer.interfaces.data.ItemEventListener;
+import com.lightstreamer.kafka.adapters.commons.MetadataListener;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+
+import org.apache.kafka.clients.admin.Admin;
+import org.apache.kafka.clients.admin.ListTopicsOptions;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+
+import java.util.Collection;
+import java.util.Properties;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public interface ConsumerWrapper<K, V> extends Runnable {
+
+    void consumeRecords(ConsumerRecords<K, V> records);
+
+    default void close() {}
+
+    interface AdminInterface extends AutoCloseable {
+
+        static AdminInterface newAdmin(Properties properties) {
+            return new DefaultAdminInterface(properties);
+        }
+
+        Set<String> listTopics(ListTopicsOptions options) throws Exception;
+
+        static class DefaultAdminInterface implements AdminInterface {
+
+            private final Admin admin;
+
+            DefaultAdminInterface(Properties properties) {
+                admin = Admin.create(properties);
+            }
+
+            @Override
+            public Set<String> listTopics(ListTopicsOptions options) throws Exception {
+                return admin.listTopics(options).names().get();
+            }
+
+            @Override
+            public void close() throws Exception {
+                admin.close();
+            }
+        }
+    }
+
+    static <K, V> ConsumerWrapper<K, V> create(
+            ConsumerTriggerConfig<K, V> config,
+            ItemEventListener eventListener,
+            MetadataListener metadataListener,
+            Collection<SubscribedItem> subscribedItems) {
+        return create(
+                config,
+                eventListener,
+                metadataListener,
+                subscribedItems,
+                () ->
+                        new KafkaConsumer<>(
+                                config.consumerProperties(),
+                                config.deserializers().keyDeserializer(),
+                                config.deserializers().valueDeserializer()),
+                AdminInterface::newAdmin);
+    }
+
+    static <K, V> ConsumerWrapper<K, V> create(
+            ConsumerTriggerConfig<K, V> config,
+            ItemEventListener eventListener,
+            MetadataListener metadataListener,
+            Collection<SubscribedItem> subscribedItems,
+            Supplier<Consumer<K, V>> consumerSupplier) {
+        return create(
+                config,
+                eventListener,
+                metadataListener,
+                subscribedItems,
+                consumerSupplier,
+                AdminInterface::newAdmin);
+    }
+
+    static <K, V> ConsumerWrapper<K, V> create(
+            ConsumerTriggerConfig<K, V> config,
+            ItemEventListener eventListener,
+            MetadataListener metadataListener,
+            Collection<SubscribedItem> subscribedItems,
+            Supplier<Consumer<K, V>> consumerSupplier,
+            Function<Properties, AdminInterface> adminFactory) {
+        return new ConsumerWrapperImpl<>(
+                config,
+                eventListener,
+                metadataListener,
+                subscribedItems,
+                consumerSupplier,
+                adminFactory);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/wrapper/ConsumerWrapperImpl.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/wrapper/ConsumerWrapperImpl.java
new file mode 100644
index 00000000..4fad97ce
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/consumers/wrapper/ConsumerWrapperImpl.java
@@ -0,0 +1,264 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.wrapper;
+
+import static org.apache.kafka.clients.consumer.ConsumerConfig.AUTO_OFFSET_RESET_CONFIG;
+import static org.apache.kafka.clients.consumer.ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG;
+
+import com.lightstreamer.interfaces.data.ItemEventListener;
+import com.lightstreamer.kafka.adapters.commons.LogFactory;
+import com.lightstreamer.kafka.adapters.commons.MetadataListener;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig.Concurrency;
+import com.lightstreamer.kafka.adapters.consumers.offsets.Offsets;
+import com.lightstreamer.kafka.adapters.consumers.offsets.Offsets.OffsetService;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.OrderStrategy;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+import com.lightstreamer.kafka.common.mapping.RecordMapper;
+
+import org.apache.kafka.clients.admin.ListTopicsOptions;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.errors.WakeupException;
+import org.slf4j.Logger;
+
+import java.time.Duration;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+class ConsumerWrapperImpl<K, V> implements ConsumerWrapper<K, V> {
+
+    private static final Duration POLL_DURATION = Duration.ofMillis(Long.MAX_VALUE);
+
+    private final ConsumerTriggerConfig<K, V> config;
+    private final MetadataListener metadataListener;
+    private final Logger log;
+    private final RecordMapper<K, V> recordMapper;
+    private final Consumer<K, V> consumer;
+    private final OffsetService offsetService;
+    private final CountDownLatch latch = new CountDownLatch(1);
+    private final Function<Properties, AdminInterface> adminFactory;
+    private final RecordConsumer<K, V> recordConsumer;
+    private Thread hook;
+
+    ConsumerWrapperImpl(
+            ConsumerTriggerConfig<K, V> config,
+            ItemEventListener eventListener,
+            MetadataListener metadataListener,
+            Collection<SubscribedItem> subscribedItems,
+            Supplier<Consumer<K, V>> consumerSupplier,
+            Function<Properties, AdminInterface> admin)
+            throws KafkaException {
+        this.config = config;
+        this.metadataListener = metadataListener;
+        this.log = LogFactory.getLogger(config.connectionName());
+        this.adminFactory = admin;
+        this.recordMapper =
+                RecordMapper.<K, V>builder()
+                        .withTemplateExtractors(config.itemTemplates().extractorsByTopicName())
+                        .withFieldExtractor(config.fieldsExtractor())
+                        .build();
+        String bootStrapServers = getProperty(BOOTSTRAP_SERVERS_CONFIG);
+
+        log.atInfo().log("Starting connection to Kafka broker(s) at {}", bootStrapServers);
+
+        // Instantiate the Kafka Consumer
+        this.consumer = consumerSupplier.get();
+        log.atInfo().log("Established connection to Kafka broker(s) at {}", bootStrapServers);
+
+        this.offsetService = Offsets.OffsetService(consumer, log);
+
+        // Make a new instance of RecordConsumer, single-threaded or parallel on the basis of
+        // the configured number of threads.
+        Concurrency concurrency = config.concurrency();
+        this.recordConsumer =
+                RecordConsumer.<K, V>recordMapper(recordMapper)
+                        .subscribedItems(subscribedItems)
+                        .eventListener(eventListener)
+                        .offsetService(offsetService)
+                        .errorStrategy(config.errorHandlingStrategy())
+                        .logger(log)
+                        .threads(concurrency.threads())
+                        .ordering(OrderStrategy.from(concurrency.orderStrategy()))
+                        .preferSingleThread(true)
+                        .build();
+    }
+
+    private String getProperty(String key) {
+        return config.consumerProperties().getProperty(key);
+    }
+
+    @Override
+    public void run() {
+        // Install the shutdown hook
+        this.hook = setShutdownHook();
+        log.atDebug().log("Set shutdown kook");
+        try {
+            if (subscribed()) {
+                pollOnce(this::initStoreAndConsume);
+                pollForEver(this::consumeRecords);
+            } else {
+                log.atWarn().log("No subcriptons happended");
+            }
+        } catch (WakeupException e) {
+            log.atDebug().log("Kafka Consumer woken up");
+        } finally {
+            log.atDebug().log("Start closing Kafka Consumer");
+            recordConsumer.close();
+            consumer.close();
+            latch.countDown();
+            log.atDebug().log("Kafka Consumer closed");
+        }
+    }
+
+    public void close() {
+        shutdown();
+        if (this.hook != null) {
+            Runtime.getRuntime().removeShutdownHook(this.hook);
+        }
+    }
+
+    private boolean isFromLatest() {
+        return getProperty(AUTO_OFFSET_RESET_CONFIG).equals("latest");
+    }
+
+    ConsumerRecords<K, V> initStoreAndConsume(ConsumerRecords<K, V> records) {
+        offsetService.initStore(isFromLatest());
+        // Consume all the records that don't have a pending offset, which have therefore
+        // already delivered to the clients.
+        return recordConsumer.consumeFilteredRecords(records, offsetService::notHasPendingOffset);
+    }
+
+    // Only for testing purposes
+    OffsetService getOffsetService() {
+        return offsetService;
+    }
+
+    @Override
+    public void consumeRecords(ConsumerRecords<K, V> records) {
+        recordConsumer.consumeRecords(records);
+    }
+
+    private Thread setShutdownHook() {
+        Runnable shutdownTask =
+                () -> {
+                    log.atInfo().log("Invoked shutdown hook");
+                    shutdown();
+                };
+
+        Thread hook = new Thread(shutdownTask);
+        Runtime.getRuntime().addShutdownHook(hook);
+        return hook;
+    }
+
+    protected boolean subscribed() {
+        // Original requested topics.
+        Set<String> topics = new HashSet<>(config.itemTemplates().topics());
+        log.atInfo().log("Subscribing to requested topics [{}]", topics);
+        log.atDebug().log("Checking existing topics on Kafka");
+
+        // Check the actual available topics on Kafka.
+        try (AdminInterface admin = adminFactory.apply(config.consumerProperties())) {
+            ListTopicsOptions options = new ListTopicsOptions();
+            options.timeoutMs(30000);
+
+            // Retain from the original requestes topics the available ones.
+            Set<String> existingTopics = admin.listTopics(options);
+            boolean notAllPresent = topics.retainAll(existingTopics);
+
+            // Can't subscribe at all. Force unsubscription and exit the loop.
+            if (topics.isEmpty()) {
+                log.atWarn().log("Not found requested topics");
+                metadataListener.forceUnsubscriptionAll();
+                return false;
+            }
+
+            // Just warn that not all requested topics can be subscribed.
+            if (notAllPresent) {
+                String loggableTopics =
+                        topics.stream()
+                                .map(s -> "\"%s\"".formatted(s))
+                                .collect(Collectors.joining(","));
+                log.atWarn()
+                        .log(
+                                "Actually subscribing to the following existing topics [{}]",
+                                loggableTopics);
+            }
+            consumer.subscribe(topics, offsetService);
+            return true;
+        } catch (Exception e) {
+            log.atError().setCause(e).log();
+            metadataListener.forceUnsubscriptionAll();
+            return false;
+        }
+    }
+
+    void pollOnce(java.util.function.Consumer<ConsumerRecords<K, V>> recordConsumer) {
+        log.atInfo().log(
+                "Starting first poll to initialize the offset store and skipping the records already consumed");
+        doPoll(recordConsumer);
+        log.atInfo().log("First poll completed");
+    }
+
+    void pollForEver(java.util.function.Consumer<ConsumerRecords<K, V>> recordConsumer) {
+        log.atInfo().log("Starting polling forever");
+        for (; ; ) {
+            doPoll(recordConsumer);
+        }
+    }
+
+    private void doPoll(java.util.function.Consumer<ConsumerRecords<K, V>> recordConsumer) {
+        log.atInfo().log("Polling records");
+        try {
+            ConsumerRecords<K, V> records = consumer.poll(POLL_DURATION);
+            log.atDebug().log("Received records");
+            recordConsumer.accept(records);
+            log.atInfo().log("Consumed {} records", records.count());
+        } catch (WakeupException we) {
+            // Catch and rethrow the exception here because of the next KafkaException
+            throw we;
+        } catch (KafkaException ke) {
+            log.atError().setCause(ke).log("Unrecoverable exception");
+            metadataListener.forceUnsubscriptionAll();
+            throw ke;
+        }
+    }
+
+    private void shutdown() {
+        log.atInfo().log("Shutting down Kafka consumer");
+        log.atDebug().log("Waking up consumer");
+        consumer.wakeup();
+        log.atDebug().log("Consumer woken up");
+        try {
+            log.atTrace().log("Waiting for graceful thread completion");
+            latch.await();
+            log.atTrace().log("Completed thread");
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        log.atInfo().log("Shut down Kafka consumer");
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/AbstractLocalSchemaDeserializer.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/AbstractLocalSchemaDeserializer.java
index b3122895..1da6327c 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/AbstractLocalSchemaDeserializer.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/AbstractLocalSchemaDeserializer.java
@@ -17,6 +17,9 @@
 
 package com.lightstreamer.kafka.adapters.mapping.selectors;
 
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH;
+
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
 import com.lightstreamer.kafka.common.config.ConfigException;
 
@@ -24,22 +27,43 @@
 
 import java.io.File;
 import java.nio.file.Path;
+import java.util.Optional;
+import java.util.function.Supplier;
 
 public abstract class AbstractLocalSchemaDeserializer<T> implements Deserializer<T> {
 
-    protected final File schemaFile;
-
-    protected AbstractLocalSchemaDeserializer(ConnectorConfig config, boolean isKey) {
-        String schemaFileKey =
-                isKey
-                        ? ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH
-                        : ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH;
-        String schemaFileName = config.getFile(schemaFileKey);
-        if (schemaFileName == null) {
-            // Never happens
-            throw new ConfigException(schemaFileKey + " setting is mandatory");
+    private String keySchemaFileName;
+    private String valueShemaFileName;
+
+    public void preConfigure(ConnectorConfig config) {
+        keySchemaFileName = config.getFile(RECORD_KEY_EVALUATOR_SCHEMA_PATH);
+        valueShemaFileName = config.getFile(RECORD_VALUE_EVALUATOR_SCHEMA_PATH);
+    }
+
+    public final File getSchemaFile(boolean isKey) {
+        if (isKey) {
+            return keySchemaFile().orElseThrow(getException(RECORD_KEY_EVALUATOR_SCHEMA_PATH));
+        }
+        return valueSchemaFile().orElseThrow(getException(RECORD_VALUE_EVALUATOR_SCHEMA_PATH));
+    }
+
+    private Supplier<ConfigException> getException(String messagePrefix) {
+        return () -> new ConfigException(messagePrefix + " setting is mandatory");
+    }
+
+    private Optional<File> keySchemaFile() {
+        return schemaFile(keySchemaFileName);
+    }
+
+    private Optional<File> valueSchemaFile() {
+        return schemaFile(valueShemaFileName);
+    }
+
+    private Optional<File> schemaFile(String schemaFile) {
+        if (schemaFile == null) { // Actually never happens
+            return Optional.empty();
         }
-        Path path = Path.of(schemaFileName);
-        schemaFile = path.toFile();
+
+        return Optional.of(Path.of(schemaFile).toFile());
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectValueSelector.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/KeyValueSelectorSuppliersMaker.java
similarity index 67%
rename from kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectValueSelector.java
rename to kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/KeyValueSelectorSuppliersMaker.java
index e2b9e6d9..dd03b252 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectValueSelector.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/KeyValueSelectorSuppliersMaker.java
@@ -15,8 +15,14 @@
  * limitations under the License.
 */
 
-package com.lightstreamer.kafka.connect.mapping.selectors;
+package com.lightstreamer.kafka.adapters.mapping.selectors;
 
-import com.lightstreamer.kafka.common.mapping.selectors.ValueSelector;
+import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
 
-public interface ConnectValueSelector extends ValueSelector<Object> {}
+public interface KeyValueSelectorSuppliersMaker<T> {
+
+    KeySelectorSupplier<T> makeKeySelectorSupplier();
+
+    ValueSelectorSupplier<T> makeValueSelectorSupplier();
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/WrapperKeyValueSelectorSuppliers.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/WrapperKeyValueSelectorSuppliers.java
new file mode 100644
index 00000000..577b0861
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/WrapperKeyValueSelectorSuppliers.java
@@ -0,0 +1,84 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.mapping.selectors;
+
+import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
+
+import org.apache.kafka.common.serialization.Deserializer;
+
+/** Default implementation of the {@code KeyValueSelectorSuppliers} interface. */
+public class WrapperKeyValueSelectorSuppliers<K, V> implements KeyValueSelectorSuppliers<K, V> {
+
+    public interface KeyValueDeserializers<K, V> {
+
+        Deserializer<K> keyDeserializer();
+
+        Deserializer<V> valueDeserializer();
+    }
+
+    private static class WrapperDeserializers<K, V> implements KeyValueDeserializers<K, V> {
+
+        private final Deserializer<K> keyDeserializer;
+        private final Deserializer<V> valueDeserializer;
+
+        WrapperDeserializers(Deserializer<K> keyDeserializer, Deserializer<V> valueDeserializer) {
+            this.keyDeserializer = keyDeserializer;
+            this.valueDeserializer = valueDeserializer;
+        }
+
+        @Override
+        public Deserializer<K> keyDeserializer() {
+            return keyDeserializer;
+        }
+
+        @Override
+        public Deserializer<V> valueDeserializer() {
+            return valueDeserializer;
+        }
+    }
+
+    protected final KeySelectorSupplier<K> keySelectorSupplier;
+    protected final ValueSelectorSupplier<V> valueSelectorSupplier;
+    private final KeyValueDeserializers<K, V> deserializers;
+
+    public WrapperKeyValueSelectorSuppliers(
+            KeySelectorSupplier<K> keySelectorSupplier,
+            ValueSelectorSupplier<V> valueSelectorSupplier) {
+        this.keySelectorSupplier = keySelectorSupplier;
+        this.valueSelectorSupplier = valueSelectorSupplier;
+        this.deserializers =
+                new WrapperDeserializers<>(
+                        keySelectorSupplier.deseralizer(), valueSelectorSupplier.deseralizer());
+    }
+
+    @Override
+    public KeySelectorSupplier<K> keySelectorSupplier() {
+        return keySelectorSupplier;
+    }
+
+    @Override
+    public ValueSelectorSupplier<V> valueSelectorSupplier() {
+        return valueSelectorSupplier;
+    }
+
+    public KeyValueDeserializers<K, V> deserializers() {
+        return deserializers;
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializer.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializer.java
deleted file mode 100644
index 0a4e252f..00000000
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializer.java
+++ /dev/null
@@ -1,111 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.adapters.mapping.selectors.avro;
-
-import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
-import com.lightstreamer.kafka.adapters.mapping.selectors.AbstractLocalSchemaDeserializer;
-import com.lightstreamer.kafka.common.config.ConfigException;
-
-import io.confluent.kafka.serializers.KafkaAvroDeserializer;
-
-import org.apache.avro.Schema;
-import org.apache.avro.generic.GenericDatumReader;
-import org.apache.avro.generic.GenericRecord;
-import org.apache.avro.io.BinaryDecoder;
-import org.apache.avro.io.DatumReader;
-import org.apache.avro.io.DecoderFactory;
-import org.apache.kafka.common.errors.SerializationException;
-import org.apache.kafka.common.serialization.Deserializer;
-import org.apache.kafka.common.utils.Utils;
-
-import java.io.IOException;
-
-public class GenericRecordDeserializer implements Deserializer<GenericRecord> {
-
-    private Deserializer<?> deserializer;
-    private final boolean isKey;
-
-    GenericRecordDeserializer(ConnectorConfig config, boolean isKey) {
-        this.isKey = isKey;
-        if ((isKey && config.hasKeySchemaFile()) || (!isKey && config.hasValueSchemaFile())) {
-            deserializer = new GenericRecordLocalSchemaDeserializer(config, isKey);
-        } else {
-            if (isKey) {
-                if (config.isSchemaRegistryEnabledForKey()) {
-                    deserializer = new KafkaAvroDeserializer();
-                }
-            } else {
-                if (config.isSchemaRegistryEnabledForValue()) {
-                    deserializer = new KafkaAvroDeserializer();
-                }
-            }
-        }
-        if (deserializer == null) {
-            throw new ConfigException("No AVRO deserializer could be instantiated");
-        }
-        deserializer.configure(Utils.propsToMap(config.baseConsumerProps()), isKey);
-    }
-
-    public boolean isKey() {
-        return isKey;
-    }
-
-    public String deserializerClassName() {
-        return deserializer.getClass().getName();
-    }
-
-    @Override
-    public GenericRecord deserialize(String topic, byte[] data) {
-        GenericRecord deserialize = (GenericRecord) deserializer.deserialize(topic, data);
-        return deserialize;
-    }
-
-    @Override
-    public void close() {
-        deserializer.close();
-    }
-}
-
-class GenericRecordLocalSchemaDeserializer extends AbstractLocalSchemaDeserializer<GenericRecord> {
-
-    private Schema schema;
-
-    GenericRecordLocalSchemaDeserializer(ConnectorConfig config, boolean isKey) {
-        super(config, isKey);
-        try {
-            schema = new Schema.Parser().parse(schemaFile);
-        } catch (IOException e) {
-            throw new SerializationException(e.getMessage());
-        }
-    }
-
-    @Override
-    public GenericRecord deserialize(String topic, byte[] data) {
-        DatumReader<GenericRecord> datumReader = new GenericDatumReader<GenericRecord>(schema);
-        // ByteBuffer b = ByteBuffer.wrap(data);
-        // b.position(5);
-        // byte[] newBytes = new byte[data.length - 5];
-        // b.get(newBytes);
-        BinaryDecoder binaryDecoder = DecoderFactory.get().binaryDecoder(data, null);
-        try {
-            return datumReader.read(null, binaryDecoder);
-        } catch (IOException e) {
-            throw new RuntimeException(e.getMessage());
-        }
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializers.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializers.java
new file mode 100644
index 00000000..de708638
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializers.java
@@ -0,0 +1,148 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.mapping.selectors.avro;
+
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.AVRO;
+
+import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
+import com.lightstreamer.kafka.adapters.mapping.selectors.AbstractLocalSchemaDeserializer;
+import com.lightstreamer.kafka.common.config.ConfigException;
+
+import io.confluent.kafka.serializers.KafkaAvroDeserializer;
+
+import org.apache.avro.Schema;
+import org.apache.avro.generic.GenericDatumReader;
+import org.apache.avro.generic.GenericRecord;
+import org.apache.avro.io.BinaryDecoder;
+import org.apache.avro.io.DatumReader;
+import org.apache.avro.io.DecoderFactory;
+import org.apache.kafka.common.errors.SerializationException;
+import org.apache.kafka.common.serialization.Deserializer;
+import org.apache.kafka.common.utils.Utils;
+
+import java.io.IOException;
+import java.util.Map;
+
+public class GenericRecordDeserializers {
+
+    static class WrapperKafkaAvroDeserializer implements Deserializer<GenericRecord> {
+
+        private final KafkaAvroDeserializer innerDeserializer;
+
+        WrapperKafkaAvroDeserializer() {
+            this.innerDeserializer = new KafkaAvroDeserializer();
+        }
+
+        @Override
+        public void configure(Map<String, ?> configs, boolean isKey) {
+            innerDeserializer.configure(configs, isKey);
+        }
+
+        @Override
+        public GenericRecord deserialize(String topic, byte[] data) {
+            return (GenericRecord) innerDeserializer.deserialize(topic, data);
+        }
+    }
+
+    static class GenericRecordLocalSchemaDeserializer
+            extends AbstractLocalSchemaDeserializer<GenericRecord> {
+
+        private Schema schema;
+
+        @Override
+        public void configure(Map<String, ?> configs, boolean isKey) {
+            try {
+                schema = new Schema.Parser().parse(getSchemaFile(isKey));
+            } catch (IOException e) {
+                throw new SerializationException(e.getMessage());
+            }
+        }
+
+        @Override
+        public GenericRecord deserialize(String topic, byte[] data) {
+            DatumReader<GenericRecord> datumReader = new GenericDatumReader<GenericRecord>(schema);
+            // ByteBuffer b = ByteBuffer.wrap(data);
+            // b.position(5);
+            // byte[] newBytes = new byte[data.length - 5];
+            // b.get(newBytes);
+            BinaryDecoder binaryDecoder = DecoderFactory.get().binaryDecoder(data, null);
+            try {
+                return datumReader.read(null, binaryDecoder);
+            } catch (IOException e) {
+                throw new RuntimeException(e.getMessage());
+            }
+        }
+    }
+
+    static Deserializer<GenericRecord> ValueDeserializer(ConnectorConfig config) {
+        return configuredDeserializer(config, false);
+    }
+
+    static Deserializer<GenericRecord> KeyDeserializer(ConnectorConfig config) {
+        return configuredDeserializer(config, true);
+    }
+
+    private static Deserializer<GenericRecord> configuredDeserializer(
+            ConnectorConfig config, boolean isKey) {
+        checkEvaluator(config, isKey);
+        Deserializer<GenericRecord> deserializer = newDeserializer(config, isKey);
+        deserializer.configure(Utils.propsToMap(config.baseConsumerProps()), isKey);
+        return deserializer;
+    }
+
+    private static Deserializer<GenericRecord> newDeserializer(
+            ConnectorConfig config, boolean isKey) {
+        if ((isKey && config.hasKeySchemaFile()) || (!isKey && config.hasValueSchemaFile())) {
+            GenericRecordLocalSchemaDeserializer genericRecordLocalDeserializer =
+                    new GenericRecordLocalSchemaDeserializer();
+            genericRecordLocalDeserializer.preConfigure(config);
+            return genericRecordLocalDeserializer;
+        }
+        if ((isKey && config.isSchemaRegistryEnabledForKey())
+                || (!isKey && config.isSchemaRegistryEnabledForValue())) {
+            return new WrapperKafkaAvroDeserializer();
+        }
+
+        // Never happens
+        throw new ConfigException("No AVRO deserializer could be instantiated");
+    }
+
+    private static void checkEvaluator(ConnectorConfig config, boolean isKey) {
+        if (isAvroKeyEvaluator(config, isKey)) {
+            return;
+        }
+        if (isAvroValueEvaluator(config, isKey)) {
+            return;
+        }
+        throw new IllegalArgumentException("Evaluator type is not AVRO");
+    }
+
+    private static boolean isAvroKeyEvaluator(ConnectorConfig config, boolean isKey) {
+        if (!isKey) {
+            return false;
+        }
+        return config.getKeyEvaluator().is(AVRO);
+    }
+
+    private static boolean isAvroValueEvaluator(ConnectorConfig config, boolean isKey) {
+        if (isKey) {
+            return false;
+        }
+        return config.getValueEvaluator().is(AVRO);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorsSuppliers.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorsSuppliers.java
index 129c2bc8..cc21a224 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorsSuppliers.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorsSuppliers.java
@@ -18,6 +18,7 @@
 package com.lightstreamer.kafka.adapters.mapping.selectors.avro;
 
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
+import com.lightstreamer.kafka.adapters.mapping.selectors.KeyValueSelectorSuppliersMaker;
 import com.lightstreamer.kafka.common.expressions.Constant;
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
 import com.lightstreamer.kafka.common.mapping.selectors.Data;
@@ -42,7 +43,8 @@
 
 import java.util.Map;
 
-public class GenericRecordSelectorsSuppliers {
+public class GenericRecordSelectorsSuppliers
+        implements KeyValueSelectorSuppliersMaker<GenericRecord> {
 
     private static class AvroNode implements Node<AvroNode> {
 
@@ -184,10 +186,10 @@ Object object() {
     private static class GenericRecordKeySelectorSupplier
             implements KeySelectorSupplier<GenericRecord> {
 
-        private final GenericRecordDeserializer deserializer;
+        private final Deserializer<GenericRecord> deserializer;
 
         GenericRecordKeySelectorSupplier(ConnectorConfig config) {
-            this.deserializer = new GenericRecordDeserializer(config, true);
+            this.deserializer = GenericRecordDeserializers.KeyDeserializer(config);
         }
 
         @Override
@@ -220,10 +222,10 @@ public Data extractKey(KafkaRecord<GenericRecord, ?> record) throws ValueExcepti
     private static class GenericRecordValueSelectorSupplier
             implements ValueSelectorSupplier<GenericRecord> {
 
-        private final GenericRecordDeserializer deseralizer;
+        private final Deserializer<GenericRecord> deseralizer;
 
         GenericRecordValueSelectorSupplier(ConnectorConfig config) {
-            this.deseralizer = new GenericRecordDeserializer(config, false);
+            this.deseralizer = GenericRecordDeserializers.ValueDeserializer(config);
         }
 
         @Override
@@ -253,14 +255,19 @@ public Data extractValue(KafkaRecord<?, GenericRecord> record) throws ValueExcep
         }
     }
 
-    public static KeySelectorSupplier<GenericRecord> keySelectorSupplier(ConnectorConfig config) {
+    private final ConnectorConfig config;
+
+    public GenericRecordSelectorsSuppliers(ConnectorConfig config) {
+        this.config = config;
+    }
+
+    @Override
+    public KeySelectorSupplier<GenericRecord> makeKeySelectorSupplier() {
         return new GenericRecordKeySelectorSupplier(config);
     }
 
-    public static ValueSelectorSupplier<GenericRecord> valueSelectorSupplier(
-            ConnectorConfig config) {
+    @Override
+    public ValueSelectorSupplier<GenericRecord> makeValueSelectorSupplier() {
         return new GenericRecordValueSelectorSupplier(config);
     }
-
-    private GenericRecordSelectorsSuppliers() {}
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializer.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializer.java
deleted file mode 100644
index 6d4856ca..00000000
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializer.java
+++ /dev/null
@@ -1,118 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.adapters.mapping.selectors.json;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
-import com.lightstreamer.kafka.adapters.mapping.selectors.AbstractLocalSchemaDeserializer;
-
-import io.confluent.kafka.schemaregistry.json.JsonSchema;
-import io.confluent.kafka.serializers.KafkaJsonDeserializer;
-import io.confluent.kafka.serializers.json.KafkaJsonSchemaDeserializer;
-
-import org.apache.kafka.common.errors.SerializationException;
-import org.apache.kafka.common.serialization.Deserializer;
-import org.everit.json.schema.ValidationException;
-
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.Map;
-
-public class JsonNodeDeserializer implements Deserializer<JsonNode> {
-
-    private Deserializer<JsonNode> deserializer;
-
-    private final boolean isKey;
-
-    JsonNodeDeserializer(ConnectorConfig config, boolean isKey) {
-        Map<String, String> props = new HashMap<>();
-        this.isKey = isKey;
-        if ((isKey && config.hasKeySchemaFile()) || (!isKey && config.hasValueSchemaFile())) {
-            deserializer = new JsonLocalSchemaDeserializer(config, isKey);
-        } else {
-            if (isKey) {
-                if (config.isSchemaRegistryEnabledForKey()) {
-                    deserializer = new KafkaJsonSchemaDeserializer<JsonNode>();
-                }
-            } else {
-                if (config.isSchemaRegistryEnabledForValue()) {
-                    deserializer = new KafkaJsonSchemaDeserializer<JsonNode>();
-                }
-            }
-        }
-        if (deserializer == null) {
-            deserializer = new KafkaJsonDeserializer<>();
-        }
-
-        deserializer.configure(config.extendsConsumerProps(props), isKey);
-    }
-
-    public boolean isKey() {
-        return isKey;
-    }
-
-    public String deserializerClassName() {
-        return deserializer.getClass().getName();
-    }
-
-    @Override
-    public JsonNode deserialize(String topic, byte[] data) {
-        return deserializer.deserialize(topic, data);
-    }
-
-    @Override
-    public void close() {
-        deserializer.close();
-    }
-}
-
-class JsonLocalSchemaDeserializer extends AbstractLocalSchemaDeserializer<JsonNode> {
-
-    private final ObjectMapper objectMapper = new ObjectMapper();
-
-    private final KafkaJsonDeserializer<JsonNode> deserializer;
-
-    private JsonSchema schema;
-
-    public JsonLocalSchemaDeserializer(ConnectorConfig config, boolean isKey) {
-        super(config, isKey);
-        deserializer = new KafkaJsonDeserializer<>();
-    }
-
-    @Override
-    public void configure(Map<String, ?> configs, boolean isKey) {
-        deserializer.configure(configs, isKey);
-        try {
-            schema = new JsonSchema(objectMapper.readTree(schemaFile));
-        } catch (IOException e) {
-            throw new SerializationException(e.getMessage());
-        }
-    }
-
-    @Override
-    public JsonNode deserialize(String topic, byte[] data) {
-        try {
-            JsonNode node = deserializer.deserialize(topic, data);
-            schema.validate(node);
-            return node;
-        } catch (IOException | ValidationException e) {
-            throw new SerializationException(e.getMessage());
-        }
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializers.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializers.java
new file mode 100644
index 00000000..6fa67119
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializers.java
@@ -0,0 +1,140 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.mapping.selectors.json;
+
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.JSON;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
+import com.lightstreamer.kafka.adapters.mapping.selectors.AbstractLocalSchemaDeserializer;
+
+import io.confluent.kafka.schemaregistry.json.JsonSchema;
+import io.confluent.kafka.serializers.KafkaJsonDeserializer;
+import io.confluent.kafka.serializers.json.KafkaJsonSchemaDeserializer;
+
+import org.apache.kafka.common.errors.SerializationException;
+import org.apache.kafka.common.serialization.Deserializer;
+import org.apache.kafka.common.utils.Utils;
+import org.everit.json.schema.ValidationException;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+
+class JsonNodeDeserializers {
+
+    static class JsonNodeLocalDeserializer extends AbstractLocalSchemaDeserializer<JsonNode> {
+
+        private final ObjectMapper objectMapper = new ObjectMapper();
+        private final KafkaJsonDeserializer<JsonNode> deserializer;
+        private JsonSchema schema;
+
+        JsonNodeLocalDeserializer() {
+            deserializer = new KafkaJsonDeserializer<>();
+        }
+
+        @Override
+        public void configure(Map<String, ?> configs, boolean isKey) {
+            deserializer.configure(configs, isKey);
+            try {
+                schema = new JsonSchema(objectMapper.readTree(getSchemaFile(isKey)));
+            } catch (IOException e) {
+                throw new SerializationException(e.getMessage());
+            }
+        }
+
+        @Override
+        public JsonNode deserialize(String topic, byte[] data) {
+            try {
+                JsonNode node = deserializer.deserialize(topic, data);
+                schema.validate(node);
+                return node;
+            } catch (IOException | ValidationException e) {
+                throw new SerializationException(e.getMessage());
+            }
+        }
+    }
+
+    static Deserializer<JsonNode> ValueDeserializer() {
+        return makeDeserializerNoConfig(false);
+    }
+
+    static Deserializer<JsonNode> ValueDeserializer(ConnectorConfig config) {
+        return configuredDeserializer(config, false);
+    }
+
+    static Deserializer<JsonNode> KeyDeserializer(ConnectorConfig config) {
+        return configuredDeserializer(config, true);
+    }
+
+    static Deserializer<JsonNode> KeyDeserializer() {
+        return makeDeserializerNoConfig(true);
+    }
+
+    private static Deserializer<JsonNode> makeDeserializerNoConfig(boolean isKey) {
+        Deserializer<JsonNode> deserializer = new KafkaJsonDeserializer<>();
+        deserializer.configure(Collections.emptyMap(), isKey);
+        return deserializer;
+    }
+
+    private static Deserializer<JsonNode> configuredDeserializer(
+            ConnectorConfig config, boolean isKey) {
+        checkEvaluator(config, isKey);
+        Deserializer<JsonNode> deserializer = newDeserializer(config, isKey);
+        deserializer.configure(Utils.propsToMap(config.baseConsumerProps()), isKey);
+        return deserializer;
+    }
+
+    private static Deserializer<JsonNode> newDeserializer(ConnectorConfig config, boolean isKey) {
+        if ((isKey && config.hasKeySchemaFile()) || (!isKey && config.hasValueSchemaFile())) {
+            JsonNodeLocalDeserializer jsonNodeLocalDeserializer = new JsonNodeLocalDeserializer();
+            jsonNodeLocalDeserializer.preConfigure(config);
+            return jsonNodeLocalDeserializer;
+        }
+        if ((isKey && config.isSchemaRegistryEnabledForKey())
+                || (!isKey && config.isSchemaRegistryEnabledForValue())) {
+            return new KafkaJsonSchemaDeserializer<>();
+        }
+        return new KafkaJsonDeserializer<>();
+    }
+
+    private static void checkEvaluator(ConnectorConfig config, boolean isKey) {
+        if (isJsonKeyEvaluator(config, isKey)) {
+            return;
+        }
+        if (isJsonValueEvaluator(config, isKey)) {
+            return;
+        }
+        throw new IllegalArgumentException("Evaluator type is not JSON");
+    }
+
+    private static boolean isJsonKeyEvaluator(ConnectorConfig config, boolean isKey) {
+        if (!isKey) {
+            return false;
+        }
+        return config.getKeyEvaluator().is(JSON);
+    }
+
+    private static boolean isJsonValueEvaluator(ConnectorConfig config, boolean isKey) {
+        if (isKey) {
+            return false;
+        }
+        return config.getValueEvaluator().is(JSON);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorsSuppliers.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorsSuppliers.java
index 8dd8fead..f92e480b 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorsSuppliers.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorsSuppliers.java
@@ -19,6 +19,7 @@
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
+import com.lightstreamer.kafka.adapters.mapping.selectors.KeyValueSelectorSuppliersMaker;
 import com.lightstreamer.kafka.common.expressions.Constant;
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
 import com.lightstreamer.kafka.common.mapping.selectors.Data;
@@ -33,7 +34,9 @@
 
 import org.apache.kafka.common.serialization.Deserializer;
 
-public class JsonNodeSelectorsSuppliers {
+import java.util.Optional;
+
+public class JsonNodeSelectorsSuppliers implements KeyValueSelectorSuppliersMaker<JsonNode> {
 
     private static class JsonNodeNode implements Node<JsonNodeNode> {
 
@@ -86,10 +89,14 @@ public String asText(String defaultStr) {
 
     private static class JsonNodeKeySelectorSupplier implements KeySelectorSupplier<JsonNode> {
 
-        private final JsonNodeDeserializer deseralizer;
+        private final Deserializer<JsonNode> deseralizer;
 
         JsonNodeKeySelectorSupplier(ConnectorConfig config) {
-            this.deseralizer = new JsonNodeDeserializer(config, true);
+            this.deseralizer = JsonNodeDeserializers.KeyDeserializer(config);
+        }
+
+        JsonNodeKeySelectorSupplier() {
+            this.deseralizer = JsonNodeDeserializers.KeyDeserializer();
         }
 
         @Override
@@ -121,10 +128,14 @@ public Data extractKey(KafkaRecord<JsonNode, ?> record) {
 
     private static class JsonNodeValueSelectorSupplier implements ValueSelectorSupplier<JsonNode> {
 
-        private final JsonNodeDeserializer deseralizer;
+        private final Deserializer<JsonNode> deseralizer;
 
         JsonNodeValueSelectorSupplier(ConnectorConfig config) {
-            this.deseralizer = new JsonNodeDeserializer(config, false);
+            this.deseralizer = JsonNodeDeserializers.ValueDeserializer(config);
+        }
+
+        JsonNodeValueSelectorSupplier() {
+            this.deseralizer = JsonNodeDeserializers.ValueDeserializer();
         }
 
         @Override
@@ -154,13 +165,25 @@ public Data extractValue(KafkaRecord<?, JsonNode> record) {
         }
     }
 
-    public static KeySelectorSupplier<JsonNode> keySelectorSupplier(ConnectorConfig config) {
-        return new JsonNodeKeySelectorSupplier(config);
+    private final Optional<ConnectorConfig> config;
+
+    public JsonNodeSelectorsSuppliers(ConnectorConfig config) {
+        this.config = Optional.of(config);
+    }
+
+    public JsonNodeSelectorsSuppliers() {
+        this.config = Optional.empty();
     }
 
-    public static ValueSelectorSupplier<JsonNode> valueSelectorSupplier(ConnectorConfig config) {
-        return new JsonNodeValueSelectorSupplier(config);
+    @Override
+    public KeySelectorSupplier<JsonNode> makeKeySelectorSupplier() {
+        return config.map(JsonNodeKeySelectorSupplier::new)
+                .orElseGet(() -> new JsonNodeKeySelectorSupplier());
     }
 
-    private JsonNodeSelectorsSuppliers() {}
+    @Override
+    public ValueSelectorSupplier<JsonNode> makeValueSelectorSupplier() {
+        return config.map(JsonNodeValueSelectorSupplier::new)
+                .orElseGet(() -> new JsonNodeValueSelectorSupplier());
+    }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/others/OthersSelectorSuppliers.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/others/OthersSelectorSuppliers.java
index ef45148c..e108fa7d 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/others/OthersSelectorSuppliers.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/adapters/mapping/selectors/others/OthersSelectorSuppliers.java
@@ -17,13 +17,19 @@
 
 package com.lightstreamer.kafka.adapters.mapping.selectors.others;
 
+import static com.lightstreamer.kafka.common.expressions.Constant.KEY;
+
+import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType;
+import com.lightstreamer.kafka.adapters.mapping.selectors.KeyValueSelectorSuppliersMaker;
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers;
 import com.lightstreamer.kafka.common.expressions.Constant;
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
 import com.lightstreamer.kafka.common.mapping.selectors.ConstantSelectorSupplier;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
 import com.lightstreamer.kafka.common.mapping.selectors.KeySelector;
 import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueSelector;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
 
@@ -42,58 +48,54 @@
 
 import java.util.EnumMap;
 
-public class OthersSelectorSuppliers {
-
-    private static class BaseOthersSelectorSupplier {
-        private final Deserializer<?> deseralizer;
-        private final ConstantSelectorSupplier constantSelectorSupplier;
+public class OthersSelectorSuppliers implements KeyValueSelectorSuppliersMaker<Object> {
 
-        BaseOthersSelectorSupplier(EvaluatorType type, Constant constant) {
-            this.deseralizer = DESERIALIAZERS.get(type);
-            this.constantSelectorSupplier = new ConstantSelectorSupplier(constant);
-        }
+    private static class BaseOthersSelectorSupplier<T> {
+        protected final Deserializer<T> deseralizer;
 
-        public KeySelector<Object> newKeySelector(String name, ExtractionExpression expression)
-                throws ExtractionException {
-            return constantSelectorSupplier.newKeySelector(name, expression);
-        }
-
-        public ValueSelector<Object> newValueSelector(String name, ExtractionExpression expression)
-                throws ExtractionException {
-            return constantSelectorSupplier.newValueSelector(name, expression);
+        @SuppressWarnings("unchecked")
+        BaseOthersSelectorSupplier(EvaluatorType type, Class<T> klass, Constant constant) {
+            this.deseralizer = (Deserializer<T>) DESERIALIAZERS.get(type);
         }
 
-        @SuppressWarnings("unchecked")
-        public Deserializer<Object> deseralizer() {
-            return (Deserializer<Object>) deseralizer;
+        public Deserializer<T> deseralizer() {
+            return deseralizer;
         }
     }
 
-    private static class OthersKeySelectorSupplier extends BaseOthersSelectorSupplier
-            implements KeySelectorSupplier<Object> {
+    private static class OthersKeySelectorSupplier<T> extends BaseOthersSelectorSupplier<T>
+            implements KeySelectorSupplier<T> {
 
-        OthersKeySelectorSupplier(EvaluatorType type) {
-            super(type, Constant.KEY);
+        private final ConstantSelectorSupplier constantSelectorSupplier =
+                ConstantSelectorSupplier.KeySelector();
+
+        OthersKeySelectorSupplier(EvaluatorType type, Class<T> klass) {
+            super(type, klass, KEY);
         }
 
+        @SuppressWarnings("unchecked")
         @Override
-        public KeySelector<Object> newSelector(String name, ExtractionExpression expression)
+        public KeySelector<T> newSelector(String name, ExtractionExpression expression)
                 throws ExtractionException {
-            return newKeySelector(name, expression);
+            return (KeySelector<T>) constantSelectorSupplier.newSelector(name, expression);
         }
     }
 
-    private static class OthersValueSelectorSupplier extends BaseOthersSelectorSupplier
-            implements ValueSelectorSupplier<Object> {
+    private static class OthersValueSelectorSupplier<T> extends BaseOthersSelectorSupplier<T>
+            implements ValueSelectorSupplier<T> {
 
-        OthersValueSelectorSupplier(EvaluatorType type) {
-            super(type, Constant.VALUE);
+        private final ConstantSelectorSupplier selectorSupplier =
+                ConstantSelectorSupplier.ValueSelector();
+
+        OthersValueSelectorSupplier(EvaluatorType type, Class<T> klass) {
+            super(type, klass, Constant.VALUE);
         }
 
+        @SuppressWarnings("unchecked")
         @Override
-        public ValueSelector<Object> newSelector(String name, ExtractionExpression expression)
+        public ValueSelector<T> newSelector(String name, ExtractionExpression expression)
                 throws ExtractionException {
-            return newValueSelector(name, expression);
+            return (ValueSelector<T>) selectorSupplier.newSelector(name, expression);
         }
     }
 
@@ -103,7 +105,6 @@ public ValueSelector<Object> newSelector(String name, ExtractionExpression expre
     static {
         DESERIALIAZERS.put(EvaluatorType.STRING, new StringDeserializer());
         DESERIALIAZERS.put(EvaluatorType.INTEGER, new IntegerDeserializer());
-        DESERIALIAZERS.put(EvaluatorType.INTEGER, new IntegerDeserializer());
         DESERIALIAZERS.put(EvaluatorType.BOOLEAN, new BooleanDeserializer());
         DESERIALIAZERS.put(EvaluatorType.BYTE_ARRAY, new ByteArrayDeserializer());
         DESERIALIAZERS.put(EvaluatorType.BYTE_BUFFER, new ByteBufferDeserializer());
@@ -115,13 +116,57 @@ public ValueSelector<Object> newSelector(String name, ExtractionExpression expre
         DESERIALIAZERS.put(EvaluatorType.UUID, new UUIDDeserializer());
     }
 
-    public static ValueSelectorSupplier<?> valueSelectorSupplier(EvaluatorType type) {
-        return new OthersValueSelectorSupplier(type);
+    private final EvaluatorType keyEvaluatorType;
+    private final EvaluatorType valueEvaluatorType;
+
+    public OthersSelectorSuppliers(ConnectorConfig config) {
+        this(config.getKeyEvaluator(), config.getValueEvaluator());
+    }
+
+    public OthersSelectorSuppliers(EvaluatorType keyValueType) {
+        this(keyValueType, keyValueType);
     }
 
-    public static KeySelectorSupplier<?> keySelectorSupplier(EvaluatorType type) {
-        return new OthersKeySelectorSupplier(type);
+    public OthersSelectorSuppliers(EvaluatorType keyType, EvaluatorType valueType) {
+        this.keyEvaluatorType = keyType;
+        this.valueEvaluatorType = valueType;
     }
 
-    private OthersSelectorSuppliers() {}
+    public EvaluatorType keyEvaluatorType() {
+        return keyEvaluatorType;
+    }
+
+    public EvaluatorType valueEvaluatorType() {
+        return valueEvaluatorType;
+    }
+
+    @Override
+    public KeySelectorSupplier<Object> makeKeySelectorSupplier() {
+        return new OthersKeySelectorSupplier<>(keyEvaluatorType, Object.class);
+    }
+
+    @Override
+    public ValueSelectorSupplier<Object> makeValueSelectorSupplier() {
+        return new OthersValueSelectorSupplier<>(valueEvaluatorType, Object.class);
+    }
+
+    public static <K> KeySelectorSupplier<K> KeySelectorSupplier(Class<K> klass) {
+        return new OthersKeySelectorSupplier<>(EvaluatorType.fromClass(klass), klass);
+    }
+
+    public static <V> ValueSelectorSupplier<V> ValueSelectorSupplier(Class<V> klass) {
+        return new OthersValueSelectorSupplier<>(EvaluatorType.fromClass(klass), klass);
+    }
+
+    public static KeySelectorSupplier<String> StringKey() {
+        return KeySelectorSupplier(String.class);
+    }
+
+    public static ValueSelectorSupplier<String> StringValue() {
+        return ValueSelectorSupplier(String.class);
+    }
+
+    public static KeyValueSelectorSuppliers<String, String> String() {
+        return new WrapperKeyValueSelectorSuppliers<>(StringKey(), StringValue());
+    }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/config/FieldConfigs.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/config/FieldConfigs.java
index 2dafd745..348cae6c 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/config/FieldConfigs.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/config/FieldConfigs.java
@@ -22,7 +22,7 @@
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
 import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.SelectorSuppliers;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -42,7 +42,7 @@ private FieldConfigs(Map<String, String> fieldsMapping) {
             String fieldName = entry.getKey();
             String wrappedExpression = entry.getValue();
             try {
-                expressions.put(fieldName, Expressions.wrapped(wrappedExpression));
+                expressions.put(fieldName, Expressions.Wrapped(wrappedExpression));
             } catch (ExpressionException e) {
                 throw new ConfigException(
                         "Found the invalid expression [%s] while evaluating [%s]: <%s>"
@@ -63,13 +63,8 @@ public ExtractionExpression getExression(String fieldName) {
         return expressions.get(fieldName);
     }
 
-    public <K, V> DataExtractor<K, V> extractor(SelectorSuppliers<K, V> selectorSuppliers)
+    public <K, V> DataExtractor<K, V> extractor(KeyValueSelectorSuppliers<K, V> selectorSuppliers)
             throws ExtractionException {
-
-        return DataExtractor.<K, V>builder()
-                .withSuppliers(selectorSuppliers)
-                .withSchemaName(SCHEMA_NAME)
-                .withExpressions(expressions)
-                .build();
+        return DataExtractor.extractor(selectorSuppliers, SCHEMA_NAME, expressions);
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/config/TopicConfigurations.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/config/TopicConfigurations.java
index 39c8e351..187e0fb3 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/config/TopicConfigurations.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/config/TopicConfigurations.java
@@ -108,7 +108,7 @@ private ItemTemplateConfigs(Map<String, String> configs) {
                 String templateName = entry.getKey();
                 String templateExpression = entry.getValue();
                 try {
-                    TemplateExpression te = Expressions.template(templateExpression);
+                    TemplateExpression te = Expressions.Template(templateExpression);
                     expressions.put(templateName, te);
                 } catch (ExpressionException e) {
                     String msg =
@@ -218,8 +218,7 @@ private TopicConfigurations(
                             .toList();
             configs.add(new TopicConfiguration(topicMapping.topic(), refs));
         }
-        // this.topicConfigurations = Collections.unmodifiableSet(configs);
-        this.topicConfigurations = configs;
+        this.topicConfigurations = Collections.unmodifiableSet(configs);
     }
 
     public Set<TopicConfiguration> configurations() {
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/expressions/Expressions.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/expressions/Expressions.java
index 4489945f..84975fb1 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/expressions/Expressions.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/expressions/Expressions.java
@@ -101,19 +101,19 @@ public boolean equals(Object obj) {
 
     private static final Expressions EXPRESSIONS = new Expressions();
 
-    public static TemplateExpression template(String templateExpression) {
+    public static TemplateExpression Template(String templateExpression) {
         return EXPRESSIONS.newTemplateExpression(templateExpression);
     }
 
-    public static ExtractionExpression wrapped(String wrappedExpression) {
+    public static ExtractionExpression Wrapped(String wrappedExpression) {
         return EXPRESSIONS.fromWrapped(wrappedExpression);
     }
 
-    public static SubscriptionExpression subscription(String subscriptionExpression) {
+    public static SubscriptionExpression Subscription(String subscriptionExpression) {
         return EXPRESSIONS.newSubscriptionExpression(subscriptionExpression);
     }
 
-    public static ExtractionExpression expression(String expression) {
+    public static ExtractionExpression Expression(String expression) {
         return EXPRESSIONS.newExpression(expression);
     }
 
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/Items.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/Items.java
index 8f5e6394..331d2e9a 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/Items.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/Items.java
@@ -17,42 +17,35 @@
 
 package com.lightstreamer.kafka.common.mapping;
 
+import static com.lightstreamer.kafka.common.mapping.selectors.DataExtractor.extractor;
+
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.mapping;
+import static java.util.stream.Collectors.toSet;
+
 import com.lightstreamer.kafka.common.config.TopicConfigurations;
 import com.lightstreamer.kafka.common.config.TopicConfigurations.ItemReference;
 import com.lightstreamer.kafka.common.config.TopicConfigurations.TopicConfiguration;
 import com.lightstreamer.kafka.common.expressions.ExpressionException;
 import com.lightstreamer.kafka.common.expressions.Expressions;
 import com.lightstreamer.kafka.common.expressions.Expressions.SubscriptionExpression;
-import com.lightstreamer.kafka.common.expressions.Expressions.TemplateExpression;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
 import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
 import com.lightstreamer.kafka.common.mapping.selectors.Schema;
-import com.lightstreamer.kafka.common.mapping.selectors.SelectorSuppliers;
+import com.lightstreamer.kafka.common.mapping.selectors.SchemaAndValues;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 public class Items {
 
-    public interface Item {
-
-        Schema schema();
-
-        Map<String, String> values();
-
-        String valueAt(String key);
-
-        boolean matches(Item other);
-    }
+    public interface Item extends SchemaAndValues {}
 
     public interface SubscribedItem extends Item {
 
@@ -61,16 +54,13 @@ public interface SubscribedItem extends Item {
 
     public interface ItemTemplates<K, V> {
 
-        Stream<Item> expand(MappedRecord record);
-
         boolean matches(Item item);
 
-        Stream<DataExtractor<K, V>> extractors();
+        Map<String, Set<DataExtractor<K, V>>> extractorsByTopicName();
 
-        Set<String> topics();
+        Set<Schema> getExtractorSchemasByTopicName(String topic);
 
-        public Set<SubscribedItem> routes(
-                MappedRecord record, Collection<? extends SubscribedItem> subscribed);
+        Set<String> topics();
     }
 
     private static class DefaultItem implements Item {
@@ -107,21 +97,7 @@ public Schema schema() {
 
         @Override
         public Map<String, String> values() {
-            return Map.copyOf(valuesMap);
-        }
-
-        @Override
-        public String valueAt(String key) {
-            return valuesMap.get(key);
-        }
-
-        @Override
-        public boolean matches(Item other) {
-            if (!schema.matches(other.schema())) {
-                return false;
-            }
-
-            return schema.keys().stream().allMatch(key -> valueAt(key).equals(other.valueAt(key)));
+            return valuesMap;
         }
 
         @Override
@@ -136,7 +112,7 @@ private static class DefaultSubscribedItem implements SubscribedItem {
         private final DefaultItem wrappedItem;
 
         DefaultSubscribedItem(Object itemHandle, String prefix, Map<String, String> values) {
-            wrappedItem = new DefaultItem(prefix, values);
+            this.wrappedItem = new DefaultItem(prefix, values);
             this.itemHandle = itemHandle;
         }
 
@@ -164,18 +140,13 @@ public Map<String, String> values() {
         }
 
         @Override
-        public String valueAt(String key) {
-            return wrappedItem.valueAt(key);
-        }
-
-        @Override
-        public boolean matches(Item other) {
-            return wrappedItem.matches(other);
+        public Object itemHandle() {
+            return itemHandle;
         }
 
         @Override
-        public Object itemHandle() {
-            return itemHandle;
+        public String toString() {
+            return wrappedItem.toString();
         }
     }
 
@@ -195,15 +166,6 @@ public boolean matches(Item item) {
             return schema.matches(item.schema());
         }
 
-        Optional<Item> expand(MappedRecord record) {
-            if (record.topic().equals(this.topic)) {
-                Map<String, String> values = record.filter(extractor);
-                return Optional.of(new DefaultItem(schema.name(), values));
-            }
-
-            return Optional.empty();
-        }
-
         DataExtractor<K, V> selectors() {
             return extractor;
         }
@@ -222,43 +184,44 @@ private static class DefaultItemTemplates<K, V> implements ItemTemplates<K, V> {
         }
 
         @Override
-        public Stream<Item> expand(MappedRecord record) {
-            return templates.stream()
-                    .flatMap(template -> template.expand(record).stream())
-                    .distinct();
+        public boolean matches(Item item) {
+            return templates.stream().anyMatch(i -> i.matches(item));
         }
 
         @Override
-        public Set<SubscribedItem> routes(
-                MappedRecord record, Collection<? extends SubscribedItem> subscribed) {
-            return subscribed.stream()
-                    .filter(sItem -> expand(record).anyMatch(eItem -> eItem.matches(sItem)))
-                    .collect(Collectors.toSet());
+        public Map<String, Set<DataExtractor<K, V>>> extractorsByTopicName() {
+            return templates.stream()
+                    .collect(
+                            groupingBy(
+                                    ItemTemplate::topic,
+                                    mapping(ItemTemplate::selectors, toSet())));
         }
 
         @Override
-        public boolean matches(Item item) {
-            return templates.stream().anyMatch(i -> i.matches(item));
+        public Set<String> topics() {
+            return templates.stream().map(ItemTemplate::topic).collect(toSet());
         }
 
         @Override
-        public Stream<DataExtractor<K, V>> extractors() {
-            return templates.stream().map(ItemTemplate::selectors).distinct();
+        public Set<Schema> getExtractorSchemasByTopicName(String topic) {
+            return extractorsByTopicName().getOrDefault(topic, Collections.emptySet()).stream()
+                    .map(DataExtractor::schema)
+                    .collect(toSet());
         }
 
         @Override
-        public Set<String> topics() {
-            return templates.stream().map(ItemTemplate::topic).collect(Collectors.toSet());
+        public String toString() {
+            return templates.stream().map(Object::toString).collect(Collectors.joining(","));
         }
     }
 
     public static SubscribedItem subscribedFrom(String input) throws ExpressionException {
-        return susbcribedFrom(input, input);
+        return subscribedFrom(input, input);
     }
 
-    public static SubscribedItem susbcribedFrom(String input, Object itemHandle)
+    public static SubscribedItem subscribedFrom(String input, Object itemHandle)
             throws ExpressionException {
-        SubscriptionExpression result = Expressions.subscription(input);
+        SubscriptionExpression result = Expressions.Subscription(input);
         return subscribedFrom(itemHandle, result.prefix(), result.params());
     }
 
@@ -267,26 +230,21 @@ public static SubscribedItem subscribedFrom(
         return new DefaultSubscribedItem(itemHandle, prefix, values);
     }
 
-    public static Item from(String prefix, Map<String, String> values) {
+    public static Item itemFrom(String prefix, Map<String, String> values) {
         return new DefaultItem(prefix, values);
     }
 
-    public static <K, V> ItemTemplates<K, V> from(
-            TopicConfigurations topicsConfig, SelectorSuppliers<K, V> sSuppliers)
+    public static <K, V> ItemTemplates<K, V> templatesFrom(
+            TopicConfigurations topicsConfig, KeyValueSelectorSuppliers<K, V> sSuppliers)
             throws ExtractionException {
         List<ItemTemplate<K, V>> templates = new ArrayList<>();
         for (TopicConfiguration topicConfig : topicsConfig.configurations()) {
             for (ItemReference reference : topicConfig.itemReferences()) {
-                DataExtractor.Builder<K, V> builder =
-                        DataExtractor.<K, V>builder().withSuppliers(sSuppliers);
-
-                if (reference.isTemplate()) {
-                    TemplateExpression evaluated = reference.template();
-                    builder.withSchemaName(evaluated.prefix()).withExpressions(evaluated.params());
-                } else {
-                    builder.withSchemaName(reference.itemName());
-                }
-                templates.add(new ItemTemplate<>(topicConfig.topic(), builder.build()));
+                DataExtractor<K, V> dataExtractor =
+                        reference.isTemplate()
+                                ? extractor(sSuppliers, reference.template())
+                                : extractor(sSuppliers, reference.itemName());
+                templates.add(new ItemTemplate<>(topicConfig.topic(), dataExtractor));
             }
         }
         return new DefaultItemTemplates<>(templates);
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/RecordMapper.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/RecordMapper.java
index 746b79e7..2045d807 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/RecordMapper.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/RecordMapper.java
@@ -17,56 +17,97 @@
 
 package com.lightstreamer.kafka.common.mapping;
 
+import static java.util.Collections.emptySet;
+
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
 import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.Data;
-import com.lightstreamer.kafka.common.mapping.selectors.DataContainer;
 import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.Schema;
+import com.lightstreamer.kafka.common.mapping.selectors.SchemaAndValues;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 public interface RecordMapper<K, V> {
 
     interface MappedRecord {
 
-        String topic();
+        Set<SchemaAndValues> expanded();
 
-        int mappedValuesSize();
+        Map<String, String> fieldsMap();
 
-        Map<String, String> filter(DataExtractor<?, ?> extractor);
+        Set<SubscribedItem> route(Collection<? extends SubscribedItem> subscribed);
     }
 
-    int selectorsSize();
+    Set<DataExtractor<K, V>> getExtractorsByTopicName(String topicName);
+
+    MappedRecord map(KafkaRecord<K, V> record) throws ValueException;
 
-    MappedRecord map(KafkaRecord<K, V> record);
+    boolean hasExtractors();
+
+    boolean hasFieldExtractor();
 
     static <K, V> Builder<K, V> builder() {
         return new Builder<>();
     }
 
+    static class NOPDataExtractor<K, V> implements DataExtractor<K, V> {
+
+        @Override
+        public SchemaAndValues extractData(KafkaRecord<K, V> record) {
+            return SchemaAndValues.nop();
+        }
+
+        @Override
+        public Schema schema() {
+            return SchemaAndValues.nop().schema();
+        }
+    }
+
     static class Builder<K, V> {
 
-        final Set<DataExtractor<K, V>> allExtractors = new HashSet<>();
+        static final DataExtractor<?, ?> NOP = new NOPDataExtractor<>();
+
+        final Map<String, Set<DataExtractor<K, V>>> extractorsByTopicName = new HashMap<>();
+
+        @SuppressWarnings("unchecked")
+        DataExtractor<K, V> fieldExtractor = (DataExtractor<K, V>) NOP;
 
         private Builder() {}
 
-        public Builder<K, V> withExtractor(Stream<DataExtractor<K, V>> extractor) {
-            allExtractors.addAll(extractor.toList());
+        public Builder<K, V> withTemplateExtractors(
+                Map<String, Set<DataExtractor<K, V>>> templateExtractors) {
+            this.extractorsByTopicName.putAll(templateExtractors);
+            return this;
+        }
+
+        public final Builder<K, V> withTemplateExtractor(
+                String topic, DataExtractor<K, V> templateExtractor) {
+            this.extractorsByTopicName.compute(
+                    topic,
+                    (t, extractors) -> {
+                        if (extractors == null) {
+                            extractors = new HashSet<>();
+                        }
+                        extractors.add(templateExtractor);
+                        return extractors;
+                    });
             return this;
         }
 
-        public final Builder<K, V> withExtractor(DataExtractor<K, V> extractor) {
-            allExtractors.add(extractor);
+        public final Builder<K, V> withFieldExtractor(DataExtractor<K, V> extractor) {
+            this.fieldExtractor = extractor;
             return this;
         }
 
@@ -80,63 +121,94 @@ class DefaultRecordMapper<K, V> implements RecordMapper<K, V> {
 
     protected static Logger log = LoggerFactory.getLogger(DefaultRecordMapper.class);
 
-    private final Set<DataExtractor<K, V>> extractors;
+    private final Map<String, Set<DataExtractor<K, V>>> templateExtractors;
+    private final DataExtractor<K, V> fieldExtractor;
 
     DefaultRecordMapper(Builder<K, V> builder) {
-        this.extractors = Collections.unmodifiableSet(builder.allExtractors);
+        this.templateExtractors = Collections.unmodifiableMap(builder.extractorsByTopicName);
+        this.fieldExtractor = builder.fieldExtractor;
     }
 
     @Override
-    public MappedRecord map(KafkaRecord<K, V> record) throws ValueException {
-        return new DefaultMappedRecord(
-                record.topic(),
-                extractors.stream().map(ve -> ve.extractData(record)).collect(Collectors.toSet()));
+    public Set<DataExtractor<K, V>> getExtractorsByTopicName(String topicName) {
+        return templateExtractors.get(topicName);
+    }
+
+    public boolean hasExtractors() {
+        return !templateExtractors.isEmpty();
+    }
+
+    public boolean hasFieldExtractor() {
+        return fieldExtractor != Builder.NOP;
     }
 
     @Override
-    public int selectorsSize() {
-        return this.extractors.size();
+    public MappedRecord map(KafkaRecord<K, V> record) throws ValueException {
+        var extractors = templateExtractors.getOrDefault(record.topic(), emptySet());
+        if (extractors.isEmpty()) {
+            return DefaultMappedRecord.NOPRecord;
+        }
+
+        Set<SchemaAndValues> set = new HashSet<>();
+        for (DataExtractor<K, V> dataExtractor : extractors) {
+            set.add(dataExtractor.extractData(record));
+        }
+
+        SchemaAndValues mappedFields = fieldExtractor.extractData(record);
+        return new DefaultMappedRecord(set, mappedFields);
     }
 }
 
-class DefaultMappedRecord implements MappedRecord {
+final class DefaultMappedRecord implements MappedRecord {
 
-    private final String topic;
+    static final DefaultMappedRecord NOPRecord = new DefaultMappedRecord();
 
-    private final Set<DataContainer> dataContainers;
+    private final SchemaAndValues fieldsMap;
+    private final SchemaAndValues[] indexedTemplates;
 
-    DefaultMappedRecord(String topic, Set<DataContainer> dataContainers) {
-        this.topic = topic;
-        this.dataContainers = dataContainers;
+    DefaultMappedRecord() {
+        this(emptySet(), SchemaAndValues.nop());
+    }
+
+    DefaultMappedRecord(Set<SchemaAndValues> expandedTemplates, SchemaAndValues fieldsMap) {
+        this.indexedTemplates = expandedTemplates.toArray(new SchemaAndValues[] {});
+        this.fieldsMap = fieldsMap;
     }
 
     @Override
-    public String topic() {
-        return topic;
+    public Set<SchemaAndValues> expanded() {
+        return Set.of(indexedTemplates);
     }
 
     @Override
-    public int mappedValuesSize() {
-        return dataContainers.stream().mapToInt(v -> v.data().size()).sum();
+    public Set<SubscribedItem> route(Collection<? extends SubscribedItem> subscribedItems) {
+        Set<SubscribedItem> result = new HashSet<>();
+
+        // The following seems the most performant loop way
+        // to popoulate the set of routable subscriptions.
+        for (SubscribedItem item : subscribedItems) {
+            for (SchemaAndValues e : indexedTemplates) {
+                if (e.matches(item)) {
+                    result.add(item);
+                    break;
+                }
+            }
+        }
+        return result;
     }
 
     @Override
-    public Map<String, String> filter(DataExtractor<?, ?> extractor) {
-        Map<String, String> eventsMap = new HashMap<>();
-        dataContainers.stream()
-                .filter(container -> container.extractor().equals(extractor))
-                .flatMap(container -> container.data().stream())
-                .forEach(value -> eventsMap.put(value.name(), value.text()));
-        return eventsMap;
+    public Map<String, String> fieldsMap() {
+        return fieldsMap.values();
     }
 
     @Override
     public String toString() {
         String data =
-                dataContainers.stream()
-                        .flatMap(v -> v.data().stream())
-                        .map(Data::toString)
-                        .collect(Collectors.joining(","));
-        return String.format("MappedRecord [topic=[%s],values=[%s]]", topic, data);
+                Arrays.stream(indexedTemplates)
+                        .map(v -> v.values().toString())
+                        .collect(Collectors.joining(", "));
+        return String.format(
+                "MappedRecord [expandedTemplates=[%s], fieldsMap=%s]", data, fieldsMap);
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelector.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelector.java
index 01a091d2..83e69d1a 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelector.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelector.java
@@ -17,7 +17,7 @@
 
 package com.lightstreamer.kafka.common.mapping.selectors;
 
-public interface ConstantSelector extends Selector {
+public interface ConstantSelector extends KeySelector<Object>, ValueSelector<Object> {
 
     Data extract(KafkaRecord<?, ?> record) throws ValueException;
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelectorSupplier.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelectorSupplier.java
index a3181c8b..8026b2c0 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelectorSupplier.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelectorSupplier.java
@@ -30,13 +30,15 @@ public class ConstantSelectorSupplier implements SelectorSupplier<ConstantSelect
 
     private static class ConstantSelectorImpl extends BaseSelector implements ConstantSelector {
 
-        ConstantSelectorImpl(String name, Constant constant) {
-            super(name, constant);
+        private final Constant constant;
+
+        ConstantSelectorImpl(String name, Constant expression) {
+            super(name, expression);
+            this.constant = expression;
         }
 
         @Override
         public Data extract(KafkaRecord<?, ?> record) {
-            Constant constant = expression().constant();
             Object data =
                     switch (constant) {
                         case TIMESTAMP -> String.valueOf(record.timestamp());
@@ -48,45 +50,25 @@ public Data extract(KafkaRecord<?, ?> record) {
                     };
             return new SimpleData(name(), Objects.toString(data, null));
         }
-    }
-
-    private static class ConstantKeyValueSelector
-            implements KeySelector<Object>, ValueSelector<Object> {
-
-        private ConstantSelectorImpl name;
-
-        protected ConstantKeyValueSelector(ConstantSelectorImpl name) {
-            this.name = name;
-        }
 
         @Override
         public Data extractKey(KafkaRecord<Object, ?> record) throws ValueException {
-            return name.extract(record);
+            return new SimpleData(name(), Objects.toString(record.key(), null));
         }
 
         @Override
         public Data extractValue(KafkaRecord<?, Object> record) throws ValueException {
-            return name.extract(record);
-        }
-
-        @Override
-        public String name() {
-            return name.name();
-        }
-
-        @Override
-        public ExtractionExpression expression() {
-            return name.expression();
+            return new SimpleData(name(), Objects.toString(record.value(), null));
         }
     }
 
     private final Set<Constant> allowedConstants;
 
-    public ConstantSelectorSupplier(Constant... constant) {
+    ConstantSelectorSupplier(Constant... constant) {
         this.allowedConstants = new LinkedHashSet<>(Arrays.asList(constant));
     }
 
-    public ConstantSelectorSupplier() {
+    ConstantSelectorSupplier() {
         this(Constant.values());
     }
 
@@ -96,16 +78,6 @@ public ConstantSelector newSelector(String name, ExtractionExpression expression
         return mkSelector(name, expression);
     }
 
-    public KeySelector<Object> newKeySelector(String name, ExtractionExpression expression)
-            throws ExtractionException {
-        return new ConstantKeyValueSelector(mkSelector(name, expression));
-    }
-
-    public ValueSelector<Object> newValueSelector(String name, ExtractionExpression expression)
-            throws ExtractionException {
-        return new ConstantKeyValueSelector(mkSelector(name, expression));
-    }
-
     String expectedConstantStr() {
         return allowedConstants.stream().map(Constant::toString).collect(Collectors.joining("|"));
     }
@@ -120,4 +92,12 @@ private ConstantSelectorImpl mkSelector(String name, ExtractionExpression expres
         }
         return new ConstantSelectorImpl(name, expression.constant());
     }
+
+    public static ConstantSelectorSupplier KeySelector() {
+        return new ConstantSelectorSupplier(Constant.KEY);
+    }
+
+    public static ConstantSelectorSupplier ValueSelector() {
+        return new ConstantSelectorSupplier(Constant.VALUE);
+    }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractor.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractor.java
index ba741088..ccdbfeb7 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractor.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractor.java
@@ -17,28 +17,47 @@
 
 package com.lightstreamer.kafka.common.mapping.selectors;
 
+import static com.lightstreamer.kafka.common.expressions.Expressions.Expression;
+
+import com.lightstreamer.kafka.common.expressions.ExpressionException;
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
+import com.lightstreamer.kafka.common.expressions.Expressions.TemplateExpression;
 
+import java.util.Collections;
 import java.util.Map;
 
 public interface DataExtractor<K, V> {
 
-    DataContainer extractData(KafkaRecord<K, V> record);
+    SchemaAndValues extractData(KafkaRecord<K, V> record);
 
     Schema schema();
 
-    public static <K, V> Builder<K, V> builder() {
-        return new DataExtractorSupport.DataExtractorBuilder<>();
+    public static <K, V> DataExtractor<K, V> extractor(
+            KeyValueSelectorSuppliers<K, V> sSuppliers,
+            String schemaName,
+            Map<String, ExtractionExpression> expressions)
+            throws ExtractionException {
+        return DataExtractorSupport.extractor(sSuppliers, schemaName, expressions);
     }
 
-    public interface Builder<K, V> {
-
-        Builder<K, V> withSuppliers(SelectorSuppliers<K, V> sSuppliers);
-
-        Builder<K, V> withExpressions(Map<String, ExtractionExpression> expressions);
+    public static <K, V> DataExtractor<K, V> extractor(
+            KeyValueSelectorSuppliers<K, V> sSuppliers, TemplateExpression expression)
+            throws ExtractionException {
+        return extractor(sSuppliers, expression.prefix(), expression.params());
+    }
 
-        Builder<K, V> withSchemaName(String schema);
+    public static <K, V> DataExtractor<K, V> extractor(
+            KeyValueSelectorSuppliers<K, V> sSuppliers, String schemaName)
+            throws ExtractionException {
+        return extractor(sSuppliers, schemaName, Collections.emptyMap());
+    }
 
-        DataExtractor<K, V> build() throws ExtractionException;
+    public static <K, V> DataExtractor<K, V> extractor(
+            KeyValueSelectorSuppliers<K, V> sSuppliers,
+            String schema,
+            String parameter,
+            String expression)
+            throws ExpressionException, ExtractionException {
+        return extractor(sSuppliers, schema, Map.of(parameter, Expression(expression)));
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractorSupport.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractorSupport.java
index 2d3e0574..35894218 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractorSupport.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractorSupport.java
@@ -17,133 +17,41 @@
 
 package com.lightstreamer.kafka.common.mapping.selectors;
 
-import static java.util.function.Function.identity;
-import static java.util.stream.Collectors.toSet;
-
 import com.lightstreamer.kafka.common.expressions.Constant;
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 class DataExtractorSupport {
 
-    static class DataExtractorBuilder<K, V> implements DataExtractor.Builder<K, V> {
-
-        private SelectorSuppliers<K, V> sSuppliers;
-
-        private final Set<KeySelector<K>> keySelectors = new HashSet<>();
-        private final Set<ValueSelector<V>> valueSelectors = new HashSet<>();
-        private final Set<ConstantSelector> metaSelectors = new HashSet<>();
-
-        private Map<String, ExtractionExpression> expressions = new HashMap<>();
-        private String schemaName;
-
-        DataExtractorBuilder(SelectorSuppliers<K, V> sSuppliers) {
-            this.sSuppliers = sSuppliers;
-        }
-
-        DataExtractorBuilder() {}
-
-        @Override
-        public DataExtractorBuilder<K, V> withSuppliers(SelectorSuppliers<K, V> sSuppliers) {
-            this.sSuppliers = sSuppliers;
-            return this;
-        }
-
-        public DataExtractorBuilder<K, V> withExpressions(Map<String, ExtractionExpression> exprs) {
-            expressions = Collections.unmodifiableMap(exprs);
-            return this;
-        }
-
-        public DataExtractorBuilder<K, V> withSchemaName(String schemaName) {
-            this.schemaName = schemaName;
-            return this;
-        }
-
-        public DataExtractor<K, V> build() throws ExtractionException {
-            SelectorsAppender<K, V> dispatcher = new SelectorsAppender<>(this);
-            for (Map.Entry<String, ExtractionExpression> entry : expressions.entrySet()) {
-                dispatcher.dispatch(entry);
-            }
-            return new DataExtractorImpl<>(this);
-        }
-    }
-
-    private static class SelectorsAppender<K, V> {
-
-        private static class Appender<T extends Selector> {
-
-            private final Set<T> selectors;
-            private final SelectorSupplier<T> selectorSupplier;
-
-            Appender(Set<T> set, SelectorSupplier<T> selectorSupplier) {
-                this.selectors = set;
-                this.selectorSupplier = selectorSupplier;
-            }
-
-            void append(String param, ExtractionExpression expression) throws ExtractionException {
-                T newSelector = selectorSupplier.newSelector(param, expression);
-                if (!selectors.add(newSelector)) {
-                    throw ExtractionException.invalidExpression(param, expression.expression());
-                }
-            }
-        }
-
-        private Appender<KeySelector<K>> kFiller;
-        private Appender<ValueSelector<V>> vFiller;
-        private Appender<ConstantSelector> mFiller;
-
-        SelectorsAppender(DataExtractorBuilder<K, V> builder) {
-            kFiller =
-                    new Appender<>(
-                            builder.keySelectors,
-                            Objects.requireNonNull(builder.sSuppliers.keySelectorSupplier()));
-            vFiller =
-                    new Appender<>(
-                            builder.valueSelectors,
-                            Objects.requireNonNull(builder.sSuppliers.valueSelectorSupplier()));
-            mFiller =
-                    new Appender<>(
-                            builder.metaSelectors,
-                            new ConstantSelectorSupplier(
-                                    Constant.OFFSET,
-                                    Constant.PARTITION,
-                                    Constant.TIMESTAMP,
-                                    Constant.TOPIC));
-        }
-
-        void dispatch(Map.Entry<String, ExtractionExpression> boundExpression)
-                throws ExtractionException {
-            Constant root = boundExpression.getValue().constant();
-            Appender<?> filler =
-                    switch (root) {
-                        case KEY -> kFiller;
-                        case VALUE -> vFiller;
-                        default -> mFiller;
-                    };
-            filler.append(boundExpression.getKey(), boundExpression.getValue());
-        }
+    public static <K, V> DataExtractor<K, V> extractor(
+            KeyValueSelectorSuppliers<K, V> suppliers,
+            String schema,
+            Map<String, ExtractionExpression> expressions)
+            throws ExtractionException {
+        return new DataExtractorImpl<>(suppliers, schema, expressions);
     }
 
     private static final class DataExtractorImpl<K, V> implements DataExtractor<K, V> {
 
-        private final Set<KeySelector<K>> keySelectors;
-        private final Set<ValueSelector<V>> valueSelectors;
-        private final Set<ConstantSelector> metaSelectors;
-
         private final Schema schema;
+        private final WrapperSelectors<K, V> wrapperSelectors;
 
-        DataExtractorImpl(DataExtractorBuilder<K, V> builder) {
-            this.keySelectors = Collections.unmodifiableSet(builder.keySelectors);
-            this.valueSelectors = Collections.unmodifiableSet(builder.valueSelectors);
-            this.metaSelectors = Collections.unmodifiableSet(builder.metaSelectors);
-            this.schema = mkSchema(builder.schemaName);
+        DataExtractorImpl(
+                KeyValueSelectorSuppliers<K, V> sSuppliers,
+                String schemaName,
+                Map<String, ExtractionExpression> expressions)
+                throws ExtractionException {
+
+            this.wrapperSelectors = mkWrapperSelectors(sSuppliers, expressions);
+            this.schema = mkSchema(schemaName);
         }
 
         @Override
@@ -151,21 +59,27 @@ public Schema schema() {
             return schema;
         }
 
-        @Override
-        public DataContainer extractData(KafkaRecord<K, V> record) throws ValueException {
-            return new DefaultValuesContainer(
-                    this,
-                    Stream.of(
-                                    keySelectors.stream().map(k -> k.extractKey(record)),
-                                    valueSelectors.stream().map(v -> v.extractValue(record)),
-                                    metaSelectors.stream().map(m -> m.extract(record)))
-                            .flatMap(identity())
-                            .collect(toSet()));
+        public SchemaAndValues extractData(KafkaRecord<K, V> record) throws ValueException {
+            Map<String, String> values = new HashMap<>();
+            for (KeySelector<K> selector : wrapperSelectors.keySelectors()) {
+                Data data = selector.extractKey(record);
+                values.put(data.name(), data.text());
+            }
+            for (ValueSelector<V> selector : wrapperSelectors.valueSelectors()) {
+                Data data = selector.extractValue(record);
+                values.put(data.name(), data.text());
+            }
+            for (ConstantSelector selector : wrapperSelectors.metaSelectors()) {
+                Data data = selector.extract(record);
+                values.put(data.name(), data.text());
+            }
+
+            return new DefaultSchemaAndValues(schema, values);
         }
 
         @Override
         public int hashCode() {
-            return Objects.hash(keySelectors, valueSelectors, metaSelectors, schema);
+            return Objects.hash(wrapperSelectors, schema);
         }
 
         @Override
@@ -173,23 +87,83 @@ public boolean equals(Object obj) {
             if (this == obj) return true;
 
             return obj instanceof DataExtractorImpl<?, ?> other
-                    && Objects.equals(keySelectors, other.keySelectors)
-                    && Objects.equals(valueSelectors, other.valueSelectors)
-                    && Objects.equals(metaSelectors, other.metaSelectors)
+                    && Objects.equals(wrapperSelectors, other.wrapperSelectors)
                     && Objects.equals(schema, other.schema);
         }
 
         private Schema mkSchema(String schemaName) {
-            Stream<String> keyNames = keySelectors.stream().map(Selector::name);
-            Stream<String> valueNames = valueSelectors.stream().map(Selector::name);
-            Stream<String> metaNames = metaSelectors.stream().map(Selector::name);
+            Stream<String> keyNames = wrapperSelectors.keySelectors().stream().map(Selector::name);
+            Stream<String> valueNames =
+                    wrapperSelectors.valueSelectors().stream().map(Selector::name);
+            Stream<String> metaNames =
+                    wrapperSelectors.metaSelectors().stream().map(Selector::name);
 
             return Schema.from(
                     schemaName,
                     Stream.of(metaNames, keyNames, valueNames)
-                            .flatMap(identity())
-                            .collect(toSet()));
+                            .flatMap(Function.identity())
+                            .collect(Collectors.toSet()));
+        }
+    }
+
+    private static class Appender<T extends Selector> {
+
+        private final Set<T> selectors;
+        private final SelectorSupplier<T> selectorSupplier;
+
+        Appender(Set<T> set, SelectorSupplier<T> selectorSupplier) {
+            this.selectors = set;
+            this.selectorSupplier = selectorSupplier;
+        }
+
+        void append(String param, ExtractionExpression expression) throws ExtractionException {
+            T newSelector = selectorSupplier.newSelector(param, expression);
+            if (!selectors.add(newSelector)) {
+                throw ExtractionException.invalidExpression(param, expression.expression());
+            }
+        }
+    }
+
+    private static record WrapperSelectors<K, V>(
+            Set<KeySelector<K>> keySelectors,
+            Set<ValueSelector<V>> valueSelectors,
+            Set<ConstantSelector> metaSelectors) {
+
+        WrapperSelectors() {
+            this(new HashSet<>(), new HashSet<>(), new HashSet<>());
+        }
+    }
+
+    private static <K, V> WrapperSelectors<K, V> mkWrapperSelectors(
+            KeyValueSelectorSuppliers<K, V> sSuppliers,
+            Map<String, ExtractionExpression> expressions)
+            throws ExtractionException {
+
+        WrapperSelectors<K, V> ws = new WrapperSelectors<>();
+        Appender<KeySelector<K>> kFiller =
+                new Appender<>(ws.keySelectors(), sSuppliers.keySelectorSupplier());
+        Appender<ValueSelector<V>> vFiller =
+                new Appender<>(ws.valueSelectors(), sSuppliers.valueSelectorSupplier());
+        Appender<ConstantSelector> mFiller =
+                new Appender<>(
+                        ws.metaSelectors(),
+                        new ConstantSelectorSupplier(
+                                Constant.OFFSET,
+                                Constant.PARTITION,
+                                Constant.TIMESTAMP,
+                                Constant.TOPIC));
+
+        for (Map.Entry<String, ExtractionExpression> boundExpression : expressions.entrySet()) {
+            Constant root = boundExpression.getValue().constant();
+            Appender<?> filler =
+                    switch (root) {
+                        case KEY -> kFiller;
+                        case VALUE -> vFiller;
+                        default -> mFiller;
+                    };
+            filler.append(boundExpression.getKey(), boundExpression.getValue());
         }
+        return ws;
     }
 
     private DataExtractorSupport() {}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectKeySelector.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/KeyValueSelectorSuppliers.java
similarity index 63%
rename from kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectKeySelector.java
rename to kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/KeyValueSelectorSuppliers.java
index ab2717e4..1d9e4e87 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectKeySelector.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/KeyValueSelectorSuppliers.java
@@ -15,8 +15,15 @@
  * limitations under the License.
 */
 
-package com.lightstreamer.kafka.connect.mapping.selectors;
+package com.lightstreamer.kafka.common.mapping.selectors;
 
-import com.lightstreamer.kafka.common.mapping.selectors.KeySelector;
+/**
+ * The interface for wrapping a key selector supplier and a value selector supplier for the given
+ * data types.
+ */
+public interface KeyValueSelectorSuppliers<K, V> {
 
-public interface ConnectKeySelector extends KeySelector<Object> {}
+    SelectorSupplier<KeySelector<K>> keySelectorSupplier();
+
+    SelectorSupplier<ValueSelector<V>> valueSelectorSupplier();
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/Schema.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/Schema.java
index 25dd5336..228113f2 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/Schema.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/Schema.java
@@ -17,8 +17,12 @@
 
 package com.lightstreamer.kafka.common.mapping.selectors;
 
-import java.util.Collections;
+import static java.util.Collections.emptySet;
+
+import java.util.Arrays;
+import java.util.Objects;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 public interface Schema {
 
@@ -26,26 +30,67 @@ public interface Schema {
 
     String name();
 
-    public boolean matches(Schema other);
+    boolean matches(Schema other);
 
     static Schema from(String name, Set<String> keys) {
         return new DefaultSchema(name, keys);
     }
 
     static Schema empty(String name) {
-        return from(name, Collections.emptySet());
+        return from(name, emptySet());
+    }
+
+    static Schema nop() {
+        return DefaultSchema.NOP;
     }
 }
 
-final record DefaultSchema(String name, Set<String> keys) implements Schema {
-    DefaultSchema {
+final class DefaultSchema implements Schema {
+
+    static Schema NOP = Schema.empty("NOSCHEMA");
+
+    private final String name;
+    private final String[] keys;
+
+    DefaultSchema(String name, Set<String> keys) {
         if (name == null || name.isBlank()) {
             throw new IllegalArgumentException("Schema name must be a non empty string");
         }
+        this.name = name;
+        this.keys = keys.stream().sorted().toArray(String[]::new);
+    }
+
+    @Override
+    public Set<String> keys() {
+        return Arrays.stream(keys).collect(Collectors.toSet());
+    }
+
+    @Override
+    public String name() {
+        return name;
     }
 
     @Override
     public boolean matches(Schema other) {
         return this.equals(other);
     }
+
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+
+        return obj instanceof DefaultSchema other
+                && Objects.equals(name, other.name)
+                && Arrays.equals(keys, other.keys);
+    }
+
+    public int hashCode() {
+        int result = 17;
+        result = 31 * result + (name != null ? name.hashCode() : 0);
+        result = 31 * result + (keys != null ? Arrays.hashCode(keys) : 0);
+        return result;
+    }
+
+    public String toString() {
+        return String.format("(%s-%s)", name(), keys());
+    }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaAndValues.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaAndValues.java
new file mode 100644
index 00000000..4ec68f45
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaAndValues.java
@@ -0,0 +1,84 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.common.mapping.selectors;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+
+public interface SchemaAndValues {
+
+    Schema schema();
+
+    Map<String, String> values();
+
+    default boolean matches(SchemaAndValues other) {
+        return schema().matches(other.schema()) && values().equals(other.values());
+    }
+
+    static SchemaAndValues from(Schema schema, Map<String, String> values) {
+        return new DefaultSchemaAndValues(schema, values);
+    }
+
+    static SchemaAndValues from(String schemNane, Map<String, String> values) {
+        Schema schema = Schema.from(schemNane, values.keySet());
+        return new DefaultSchemaAndValues(schema, values);
+    }
+
+    static SchemaAndValues nop() {
+        return DefaultSchemaAndValues.NOP;
+    }
+}
+
+class DefaultSchemaAndValues implements SchemaAndValues {
+
+    static SchemaAndValues NOP = new DefaultSchemaAndValues(Schema.nop(), Collections.emptyMap());
+
+    private final Schema schema;
+    private final Map<String, String> values;
+
+    DefaultSchemaAndValues(Schema schema, Map<String, String> values) {
+        this.schema = schema;
+        this.values = Collections.unmodifiableMap(values);
+    }
+
+    @Override
+    public Schema schema() {
+        return schema;
+    }
+
+    @Override
+    public Map<String, String> values() {
+        return values;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+
+        return obj instanceof SchemaAndValues other && this.matches(other);
+    }
+
+    public int hashCode() {
+        return Objects.hash(schema, values);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("(%s-<%s>)", schema.name(), values);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/SelectorSuppliers.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/SelectorSuppliers.java
deleted file mode 100644
index 3be65294..00000000
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/SelectorSuppliers.java
+++ /dev/null
@@ -1,41 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.common.mapping.selectors;
-
-public interface SelectorSuppliers<K, V> {
-
-    KeySelectorSupplier<K> keySelectorSupplier();
-
-    ValueSelectorSupplier<V> valueSelectorSupplier();
-
-    static <K, V> SelectorSuppliers<K, V> of(
-            final KeySelectorSupplier<K> k, final ValueSelectorSupplier<V> v) {
-        return new SelectorSuppliers<K, V>() {
-
-            @Override
-            public KeySelectorSupplier<K> keySelectorSupplier() {
-                return k;
-            }
-
-            @Override
-            public ValueSelectorSupplier<V> valueSelectorSupplier() {
-                return v;
-            }
-        };
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/DataAdapterConfigurator.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/DataAdapterConfigurator.java
index 7d37333e..3858093e 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/DataAdapterConfigurator.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/DataAdapterConfigurator.java
@@ -24,7 +24,7 @@
 import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
 import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.SelectorSuppliers;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
 import com.lightstreamer.kafka.connect.config.LightstreamerConnectorConfig;
 import com.lightstreamer.kafka.connect.config.LightstreamerConnectorConfig.RecordErrorHandlingStrategy;
 import com.lightstreamer.kafka.connect.mapping.selectors.ConnectSelectorsSuppliers;
@@ -56,12 +56,9 @@ private DataAdapterConfigurator() {}
     static DataAdapterConfig configure(LightstreamerConnectorConfig config) throws ConfigException {
         TopicConfigurations topicsConfig =
                 TopicConfigurations.of(config.getItemTemplateConfigs(), config.getTopicMappings());
-        SelectorSuppliers<Object, Object> sSuppliers =
-                SelectorSuppliers.of(
-                        ConnectSelectorsSuppliers.keySelectorSupplier(),
-                        ConnectSelectorsSuppliers.valueSelectorSupplier());
+        KeyValueSelectorSuppliers<Object, Object> sSuppliers = new ConnectSelectorsSuppliers();
         try {
-            ItemTemplates<Object, Object> templates = Items.from(topicsConfig, sSuppliers);
+            ItemTemplates<Object, Object> templates = Items.templatesFrom(topicsConfig, sSuppliers);
             logger.info("Constructed item templates: {}", templates);
 
             FieldConfigs fieldConfigs = config.getFieldConfigs();
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/StreamingDataAdapter.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/StreamingDataAdapter.java
index 32afe4b9..34d1aaf4 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/StreamingDataAdapter.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/StreamingDataAdapter.java
@@ -28,7 +28,6 @@
 import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
 import com.lightstreamer.kafka.common.mapping.RecordMapper;
 import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
 import com.lightstreamer.kafka.connect.DataAdapterConfigurator.DataAdapterConfig;
@@ -75,10 +74,6 @@ interface DownstreamUpdater {
                 logger.debug("Skipping record");
             };
 
-    // The DataExtractor instance for extracting data from a SinkRecord to be mapped to Lighstreamer
-    // fields.
-    private final DataExtractor<Object, Object> fieldsExtractor;
-
     // The ItemTemplate instance for enabling the Filtered Routing.
     private final ItemTemplates<Object, Object> itemTemplates;
 
@@ -117,11 +112,10 @@ interface DownstreamUpdater {
     StreamingDataAdapter(
             DataAdapterConfig config, SinkTaskContext context, DownstreamUpdater nopUpdater) {
         this.itemTemplates = config.itemTemplates();
-        this.fieldsExtractor = config.fieldsExtractor();
         this.recordMapper =
                 RecordMapper.builder()
-                        .withExtractor(itemTemplates.extractors())
-                        .withExtractor(fieldsExtractor)
+                        .withTemplateExtractors(itemTemplates.extractorsByTopicName())
+                        .withFieldExtractor(config.fieldsExtractor())
                         .build();
 
         this.errorHandlingStrategy = config.recordErrorHandlingStrategy();
@@ -212,36 +206,37 @@ ErrantRecordReporter errantRecordReporter(SinkTaskContext context) {
         }
     }
 
-    // Only for testing purposes.
+    // Only for testing purposes
     ErrantRecordReporter getErrantRercordReporter() {
         return reporter;
     }
 
-    // Only for testing purposes.
+    // Only for testing purposes
     Item getSubscribedItem(String item) {
         return subscribedItems.get(item);
     }
 
-    // Only for testing purposes.
+    // Only for testing purposes
     int getCurrentItemsCount() {
         return itemsCounter.get();
     }
 
-    // Only for testing purposes.
+    // Only for testing purposes
     DownstreamUpdater getUpdater() {
         return updater;
     }
 
-    // Only for testing purposes.
+    // Only for testing purposes
     ItemEventListener getItemEventListener() {
         return listener;
     }
 
-    // Only for testing purposes.
+    // Only for testing purposes
     Map<TopicPartition, OffsetAndMetadata> getCurrentOffsets() {
         return currentOffsets;
     }
 
+    // Only for testing purposes
     Map<String, String> getInitParameters() {
         return initParameters;
     }
@@ -302,10 +297,10 @@ private void updateRecord(SinkRecord record) throws ValueException {
         MappedRecord mappedRecord = recordMapper.map(KafkaRecord.from(record));
         logger.debug("Mapped Kafka record");
 
-        Set<SubscribedItem> routable = itemTemplates.routes(mappedRecord, subscribedItems.values());
+        Set<SubscribedItem> routable = mappedRecord.route(subscribedItems.values());
 
         logger.debug("Filtering updates");
-        Map<String, String> updates = mappedRecord.filter(fieldsExtractor);
+        Map<String, String> updates = mappedRecord.fieldsMap();
 
         logger.info("Routing record to {} items", routable.size());
         for (SubscribedItem sub : routable) {
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/config/ItemTemplateValidator.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/config/ItemTemplateValidator.java
index 95ad61e4..477e759a 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/config/ItemTemplateValidator.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/config/ItemTemplateValidator.java
@@ -84,7 +84,7 @@ private String validateTemplate(String name, String template) {
 
         try {
             // Validates <template-expression>
-            Expressions.template(pair.value()).toString();
+            Expressions.Template(pair.value()).toString();
 
             // Returns <template-name>
             return pair.key();
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/config/RecordMappingValidator.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/config/RecordMappingValidator.java
index e948cc0a..fc55706c 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/config/RecordMappingValidator.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/config/RecordMappingValidator.java
@@ -40,7 +40,7 @@ public String validateStringElement(String name, String element) {
                                                         "[fieldName]:[extractionExpression]")));
         try {
             // Validates <field-expression>
-            Expressions.wrapped(pair.value());
+            Expressions.Wrapped(pair.value());
             return pair.key();
         } catch (ExpressionException ee) {
             throw new ConfigException(
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectKeySelectorSupplier.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectKeySelectorSupplier.java
deleted file mode 100644
index 56a2e7d7..00000000
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectKeySelectorSupplier.java
+++ /dev/null
@@ -1,36 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.connect.mapping.selectors;
-
-import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
-import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
-
-import org.apache.kafka.common.serialization.Deserializer;
-
-public interface ConnectKeySelectorSupplier extends KeySelectorSupplier<Object> {
-
-    @Override
-    ConnectKeySelector newSelector(String name, ExtractionExpression expression)
-            throws ExtractionException;
-
-    @Override
-    public default Deserializer<Object> deseralizer() {
-        throw new UnsupportedOperationException();
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectSelectorsSuppliers.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectSelectorsSuppliers.java
index f1cd8fa3..5478d6e4 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectSelectorsSuppliers.java
+++ b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectSelectorsSuppliers.java
@@ -23,9 +23,13 @@
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
 import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
 import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord.KafkaSinkRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.KeySelector;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
 import com.lightstreamer.kafka.common.mapping.selectors.Parsers.Node;
+import com.lightstreamer.kafka.common.mapping.selectors.SelectorSupplier;
 import com.lightstreamer.kafka.common.mapping.selectors.StructuredBaseSelector;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueSelector;
 
 import org.apache.kafka.connect.data.Field;
 import org.apache.kafka.connect.data.Schema;
@@ -37,7 +41,7 @@
 import java.util.List;
 import java.util.Map;
 
-public class ConnectSelectorsSuppliers {
+public class ConnectSelectorsSuppliers implements KeyValueSelectorSuppliers<Object, Object> {
 
     private static class SchemaAndValueNode implements Node<SchemaAndValueNode> {
 
@@ -141,21 +145,22 @@ public String asText(String defaultStr) {
         }
     }
 
-    private static class ConnectKeySelectorSupplierImpl implements ConnectKeySelectorSupplier {
+    private static class ConnectKeySelectorSupplier
+            implements SelectorSupplier<KeySelector<Object>> {
 
-        ConnectKeySelectorSupplierImpl() {}
+        ConnectKeySelectorSupplier() {}
 
         @Override
-        public ConnectKeySelector newSelector(String name, ExtractionExpression expression)
+        public KeySelector<Object> newSelector(String name, ExtractionExpression expression)
                 throws ExtractionException {
-            return new ConnectKeySelectorImpl(name, expression);
+            return new ConnectKeySelector(name, expression);
         }
     }
 
-    private static class ConnectKeySelectorImpl extends StructuredBaseSelector<SchemaAndValueNode>
-            implements ConnectKeySelector {
+    private static class ConnectKeySelector extends StructuredBaseSelector<SchemaAndValueNode>
+            implements KeySelector<Object> {
 
-        ConnectKeySelectorImpl(String name, ExtractionExpression expression)
+        ConnectKeySelector(String name, ExtractionExpression expression)
                 throws ExtractionException {
             super(name, expression, Constant.KEY, false);
         }
@@ -171,19 +176,20 @@ private SchemaAndValueNode asNode(KafkaRecord.KafkaSinkRecord sinkRecord) {
         }
     }
 
-    private static class ConnectValueSelectorSupplierImpl implements ConnectValueSelectorSupplier {
+    private static class ConnectValueSelectorSupplier
+            implements SelectorSupplier<ValueSelector<Object>> {
 
         @Override
-        public ConnectValueSelector newSelector(String name, ExtractionExpression expression)
+        public ValueSelector<Object> newSelector(String name, ExtractionExpression expression)
                 throws ExtractionException {
-            return new ConnectValueSelectorImpl(name, expression);
+            return new ConnectValueSelector(name, expression);
         }
     }
 
-    private static class ConnectValueSelectorImpl extends StructuredBaseSelector<SchemaAndValueNode>
-            implements ConnectValueSelector {
+    private static class ConnectValueSelector extends StructuredBaseSelector<SchemaAndValueNode>
+            implements ValueSelector<Object> {
 
-        ConnectValueSelectorImpl(String name, ExtractionExpression expression)
+        ConnectValueSelector(String name, ExtractionExpression expression)
                 throws ExtractionException {
             super(name, expression, Constant.VALUE, false);
         }
@@ -199,11 +205,17 @@ private SchemaAndValueNode asNode(KafkaRecord.KafkaSinkRecord sinkRecord) {
         }
     }
 
-    public static ConnectKeySelectorSupplier keySelectorSupplier() {
-        return new ConnectKeySelectorSupplierImpl();
+    private final ConnectKeySelectorSupplier keySelectorSupplier = new ConnectKeySelectorSupplier();
+    private final ConnectValueSelectorSupplier valueSelectorSupplier =
+            new ConnectValueSelectorSupplier();
+
+    @Override
+    public SelectorSupplier<KeySelector<Object>> keySelectorSupplier() {
+        return keySelectorSupplier;
     }
 
-    public static ConnectValueSelectorSupplier valueSelectorSupplier() {
-        return new ConnectValueSelectorSupplierImpl();
+    @Override
+    public SelectorSupplier<ValueSelector<Object>> valueSelectorSupplier() {
+        return valueSelectorSupplier;
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectValueSelectorSupplier.java b/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectValueSelectorSupplier.java
deleted file mode 100644
index a1daac55..00000000
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectValueSelectorSupplier.java
+++ /dev/null
@@ -1,35 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.connect.mapping.selectors;
-
-import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
-import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
-
-import org.apache.kafka.common.serialization.Deserializer;
-
-public interface ConnectValueSelectorSupplier extends ValueSelectorSupplier<Object> {
-
-    @Override
-    ConnectValueSelector newSelector(String name, ExtractionExpression expression)
-            throws ExtractionException;
-
-    public default Deserializer<Object> deseralizer() {
-        throw new UnsupportedOperationException();
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/ConnectorConfiguratorTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/ConnectorConfiguratorTest.java
index d00868b4..46f978ee 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/ConnectorConfiguratorTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/ConnectorConfiguratorTest.java
@@ -18,25 +18,32 @@
 package com.lightstreamer.kafka.adapters;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.BOOTSTRAP_SERVERS;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.DATA_ADAPTER_NAME;
 import static com.lightstreamer.kafka.test_utils.ConnectorConfigProvider.minimalConfig;
 import static com.lightstreamer.kafka.test_utils.ConnectorConfigProvider.minimalConfigWith;
 
 import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
 
-import com.lightstreamer.kafka.adapters.ConnectorConfigurator.ConsumerLoopConfig;
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
 import com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs;
-import com.lightstreamer.kafka.adapters.mapping.selectors.avro.GenericRecordDeserializer;
-import com.lightstreamer.kafka.adapters.mapping.selectors.json.JsonNodeDeserializer;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig.Concurrency;
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers;
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers.KeyValueDeserializers;
 import com.lightstreamer.kafka.common.config.ConfigException;
 import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
 import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.Schema;
 
+import io.confluent.kafka.serializers.KafkaJsonDeserializer;
+
 import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.common.serialization.BooleanDeserializer;
+import org.apache.kafka.common.serialization.Serdes;
 import org.apache.kafka.common.serialization.StringDeserializer;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
@@ -46,42 +53,90 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.nio.file.Files;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
+import java.util.Set;
 import java.util.stream.Stream;
 
 public class ConnectorConfiguratorTest {
 
-    static File adapterDir;
+    static File ADAPTER_DIR = new File("src/test/resources");
 
     static ConnectorConfigurator newConfigurator(Map<String, String> params) {
-        return new ConnectorConfigurator(params, adapterDir);
+        return new ConnectorConfigurator(params, ADAPTER_DIR);
     }
 
     static Map<String, String> basicParameters() {
         Map<String, String> adapterParams = new HashMap<>();
-        adapterParams.put(ConnectorConfig.BOOTSTRAP_SERVERS, "server:8080,server:8081");
+        adapterParams.put(BOOTSTRAP_SERVERS, "server:8080,server:8081");
         adapterParams.put(ConnectorConfig.ADAPTERS_CONF_ID, "KAFKA");
-        adapterParams.put(ConnectorConfig.DATA_ADAPTER_NAME, "CONNECTOR");
+        adapterParams.put(DATA_ADAPTER_NAME, "CONNECTOR");
         adapterParams.put("item-template.template1", "item1-#{partition=PARTITION}");
         adapterParams.put("map.topic1.to", "item-template.template1");
         adapterParams.put("field.fieldName1", "#{VALUE}");
         return adapterParams;
     }
 
-    @BeforeEach
-    public void before() throws IOException {
-        adapterDir = Files.createTempDirectory("adapter_dir").toFile();
+    static Stream<Arguments> getMakersArguments() {
+        return Stream.of(
+                Arguments.of(
+                        "LONG",
+                        Serdes.Long().deserializer().getClass(),
+                        "STRING",
+                        Serdes.String().deserializer().getClass()),
+                Arguments.of(
+                        "INTEGER",
+                        Serdes.Integer().deserializer().getClass(),
+                        "JSON",
+                        KafkaJsonDeserializer.class),
+                Arguments.of(
+                        "FLOAT",
+                        Serdes.Float().deserializer().getClass(),
+                        "BOOLEAN",
+                        BooleanDeserializer.class),
+                Arguments.of(
+                        "SHORT",
+                        Serdes.Short().deserializer().getClass(),
+                        "UUID",
+                        Serdes.UUID().deserializer().getClass()),
+                Arguments.of(
+                        "DOUBLE",
+                        Serdes.Double().deserializer().getClass(),
+                        "BYTE_ARRAY",
+                        Serdes.ByteArray().deserializer().getClass()),
+                Arguments.of(
+                        "BYTES",
+                        Serdes.Bytes().deserializer().getClass(),
+                        "BYTE_BUFFER",
+                        Serdes.ByteBuffer().deserializer().getClass()));
+    }
+
+    @ParameterizedTest
+    @MethodSource("getMakersArguments")
+    public void shouldGetMakers(
+            String keyType,
+            Class<?> expectedKeyDeserializer,
+            String valueType,
+            Class<?> expectedValueDeserializer) {
+        Map<String, String> updatedConfigs = new HashMap<>(basicParameters());
+        updatedConfigs.put(ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE, keyType);
+        updatedConfigs.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE, valueType);
+        ConnectorConfig config = ConnectorConfig.newConfig(ADAPTER_DIR, updatedConfigs);
+        WrapperKeyValueSelectorSuppliers<?, ?> wrapper =
+                ConnectorConfigurator.mkKeyValueSelectorSuppliers(config);
+        KeyValueDeserializers<?, ?> deserializers = wrapper.deserializers();
+        assertThat(deserializers.keyDeserializer().getClass()).isEqualTo(expectedKeyDeserializer);
+        assertThat(deserializers.valueDeserializer().getClass())
+                .isEqualTo(expectedValueDeserializer);
     }
 
     @Test
     public void shouldConfigureWithBasicParameters() throws IOException {
         ConnectorConfigurator configurator = newConfigurator(basicParameters());
-        ConsumerLoopConfig<?, ?> loopConfig = configurator.configure();
+        ConsumerTriggerConfig<?, ?> consumerTriggerConfig = configurator.configure();
 
-        Properties consumerProperties = loopConfig.consumerProperties();
+        Properties consumerProperties = consumerTriggerConfig.consumerProperties();
         assertThat(consumerProperties)
                 .containsAtLeast(
                         ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
@@ -93,47 +148,71 @@ public void shouldConfigureWithBasicParameters() throws IOException {
         assertThat(consumerProperties.getProperty(ConsumerConfig.GROUP_ID_CONFIG))
                 .startsWith("KAFKA-CONNECTOR-");
 
-        DataExtractor<?, ?> fieldExtractor = loopConfig.fieldsExtractor();
+        DataExtractor<?, ?> fieldExtractor = consumerTriggerConfig.fieldsExtractor();
         Schema schema = fieldExtractor.schema();
         assertThat(schema.name()).isEqualTo("fields");
         assertThat(schema.keys()).containsExactly("fieldName1");
 
-        ItemTemplates<?, ?> itemTemplates = loopConfig.itemTemplates();
+        ItemTemplates<?, ?> itemTemplates = consumerTriggerConfig.itemTemplates();
         assertThat(itemTemplates.topics()).containsExactly("topic1");
-        assertThat(itemTemplates.extractors().map(s -> s.schema().name())).containsExactly("item1");
 
-        assertThat(loopConfig.keyDeserializer().getClass()).isEqualTo(StringDeserializer.class);
-        assertThat(loopConfig.valueDeserializer().getClass()).isEqualTo(StringDeserializer.class);
-        loopConfig.valueDeserializer();
+        Set<Schema> schemas = itemTemplates.getExtractorSchemasByTopicName("topic1");
+        assertThat(schemas.stream().map(Schema::name)).containsExactly("item1");
+
+        KeyValueDeserializers<?, ?> deserializers = consumerTriggerConfig.deserializers();
+        assertThat(deserializers.keyDeserializer().getClass()).isEqualTo(StringDeserializer.class);
+        assertThat(consumerTriggerConfig.deserializers().valueDeserializer().getClass())
+                .isEqualTo(StringDeserializer.class);
+
+        Concurrency concurrency = consumerTriggerConfig.concurrency();
+        assertThat(concurrency.threads()).isEqualTo(1);
+        assertThat(concurrency.orderStrategy())
+                .isEqualTo(RecordConsumeWithOrderStrategy.ORDER_BY_PARTITION);
     }
 
     @Test
     public void shouldConfigureWithComplexParameters() throws IOException {
         Map<String, String> updatedConfigs = new HashMap<>(basicParameters());
-        updatedConfigs.put("item-template.template2", "item2-#{key=KEY.attrib}");
+        updatedConfigs.put("item-template.template2", "item2-#{key=KEY}");
         updatedConfigs.put("map.topic1.to", "item-template.template1,item-template.template2");
         updatedConfigs.put("map.topic2.to", "item-template.template1");
         updatedConfigs.put("map.topic3.to", "simple-item1,simple-item2");
-        updatedConfigs.put(ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE, "JSON");
+        updatedConfigs.put(ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE, "STRING");
         updatedConfigs.put("field.fieldName1", "#{VALUE.name}");
         updatedConfigs.put("field.fieldName2", "#{VALUE.otherAttrib}");
         updatedConfigs.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE, "JSON");
+        updatedConfigs.put(ConnectorConfig.RECORD_CONSUME_WITH_NUM_THREADS, "4");
+        updatedConfigs.put(ConnectorConfig.RECORD_CONSUME_WITH_ORDER_STRATEGY, "UNORDERED");
 
         ConnectorConfigurator configurator = newConfigurator(updatedConfigs);
-        ConsumerLoopConfig<?, ?> loopConfig = configurator.configure();
+        ConsumerTriggerConfig<?, ?> config = configurator.configure();
 
-        DataExtractor<?, ?> fieldsExtractor = loopConfig.fieldsExtractor();
+        DataExtractor<?, ?> fieldsExtractor = config.fieldsExtractor();
         Schema schema = fieldsExtractor.schema();
         assertThat(schema.name()).isEqualTo("fields");
         assertThat(schema.keys()).containsExactly("fieldName1", "fieldName2");
 
-        ItemTemplates<?, ?> itemTemplates = loopConfig.itemTemplates();
+        ItemTemplates<?, ?> itemTemplates = config.itemTemplates();
         assertThat(itemTemplates.topics()).containsExactly("topic1", "topic2", "topic3");
-        assertThat(itemTemplates.extractors().map(s -> s.schema().name()))
-                .containsExactly("item1", "item2", "simple-item1", "simple-item2");
 
-        assertThat(loopConfig.keyDeserializer().getClass()).isEqualTo(JsonNodeDeserializer.class);
-        assertThat(loopConfig.valueDeserializer().getClass()).isEqualTo(JsonNodeDeserializer.class);
+        Set<Schema> schemasForTopic1 = itemTemplates.getExtractorSchemasByTopicName("topic1");
+        assertThat(schemasForTopic1.stream().map(Schema::name)).containsExactly("item1", "item2");
+
+        Set<Schema> schemasForTopic2 = itemTemplates.getExtractorSchemasByTopicName("topic2");
+        assertThat(schemasForTopic2.stream().map(Schema::name)).containsExactly("item1");
+
+        Set<Schema> schemasForTopic3 = itemTemplates.getExtractorSchemasByTopicName("topic3");
+        assertThat(schemasForTopic3.stream().map(Schema::name))
+                .containsExactly("simple-item1", "simple-item2");
+
+        KeyValueDeserializers<?, ?> deserializers = config.deserializers();
+        assertThat(deserializers.keyDeserializer().getClass()).isEqualTo(StringDeserializer.class);
+        assertThat(config.deserializers().valueDeserializer().getClass())
+                .isEqualTo(KafkaJsonDeserializer.class);
+
+        Concurrency concurrency = config.concurrency();
+        assertThat(concurrency.threads()).isEqualTo(4);
+        assertThat(concurrency.orderStrategy()).isEqualTo(RecordConsumeWithOrderStrategy.UNORDERED);
     }
 
     @Test
@@ -148,26 +227,35 @@ public void shouldConfigureWithComplexParametersAvro() throws IOException {
         updatedConfigs.put("field.fieldName1", "#{VALUE.name}");
         updatedConfigs.put("field.fieldName2", "#{VALUE.otherAttrib}");
         updatedConfigs.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE, "AVRO");
-        updatedConfigs.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
+        updatedConfigs.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH, "test_schema.avsc");
         updatedConfigs.put(SchemaRegistryConfigs.URL, "http://localhost:8081");
 
         ConnectorConfigurator configurator = newConfigurator(updatedConfigs);
-        ConsumerLoopConfig<?, ?> loopConfig = configurator.configure();
+        ConsumerTriggerConfig<?, ?> config = configurator.configure();
 
-        DataExtractor<?, ?> fieldsExtractor = loopConfig.fieldsExtractor();
+        DataExtractor<?, ?> fieldsExtractor = config.fieldsExtractor();
         Schema schema = fieldsExtractor.schema();
         assertThat(schema.name()).isEqualTo("fields");
         assertThat(schema.keys()).containsExactly("fieldName1", "fieldName2");
 
-        ItemTemplates<?, ?> itemTemplates = loopConfig.itemTemplates();
+        ItemTemplates<?, ?> itemTemplates = config.itemTemplates();
         assertThat(itemTemplates.topics()).containsExactly("topic1", "topic2", "topic3");
-        assertThat(itemTemplates.extractors().map(s -> s.schema().name()))
-                .containsExactly("item1", "item2", "simple-item1", "simple-item2");
 
-        assertThat(loopConfig.keyDeserializer().getClass())
-                .isEqualTo(GenericRecordDeserializer.class);
-        assertThat(loopConfig.valueDeserializer().getClass())
-                .isEqualTo(GenericRecordDeserializer.class);
+        Set<Schema> schemasForTopic1 = itemTemplates.getExtractorSchemasByTopicName("topic1");
+        assertThat(schemasForTopic1.stream().map(Schema::name)).containsExactly("item1", "item2");
+
+        Set<Schema> schemasForTopic2 = itemTemplates.getExtractorSchemasByTopicName("topic2");
+        assertThat(schemasForTopic2.stream().map(Schema::name)).containsExactly("item1");
+
+        Set<Schema> schemasForTopic3 = itemTemplates.getExtractorSchemasByTopicName("topic3");
+        assertThat(schemasForTopic3.stream().map(Schema::name))
+                .containsExactly("simple-item1", "simple-item2");
+
+        KeyValueDeserializers<?, ?> deserializers = config.deserializers();
+        assertThat(deserializers.keyDeserializer().getClass().getSimpleName())
+                .isEqualTo("WrapperKafkaAvroDeserializer");
+        assertThat(config.deserializers().valueDeserializer().getClass().getSimpleName())
+                .isEqualTo("GenericRecordLocalSchemaDeserializer");
     }
 
     @ParameterizedTest
@@ -177,7 +265,8 @@ public void shouldNotCreateConfiguratorDueToInvalidTopicMappingParameters(
         Map<String, String> config = minimalConfigWith(Map.of(topicMappingParam, "item"));
         ConfigException e =
                 assertThrows(
-                        ConfigException.class, () -> new ConnectorConfigurator(config, adapterDir));
+                        ConfigException.class,
+                        () -> new ConnectorConfigurator(config, ADAPTER_DIR));
         assertThat(e.getMessage()).isEqualTo("Specify a valid parameter [map.<...>.to]");
     }
 
@@ -210,6 +299,17 @@ public void shouldNotCreateConfiguratorDueToInvalidItemTemplateParameter(String
                         "Found the invalid expression [value] while evaluating [template]: <Invalid template expression>");
     }
 
+    @Test
+    public void shouldNotCreateConfiguratorDueToOrderStrategy() {
+        Map<String, String> config =
+                minimalConfigWith(
+                        Map.of("record.consume.with.order.strategy", "invalidOrderStrategy"));
+        ConfigException ce = assertThrows(ConfigException.class, () -> newConfigurator(config));
+        assertThat(ce.getMessage())
+                .isEqualTo(
+                        "Specify a valid value for parameter [record.consume.with.order.strategy]");
+    }
+
     @ParameterizedTest
     @NullAndEmptySource
     @ValueSource(strings = {","})
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/config/ConnectorConfigTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/config/ConnectorConfigTest.java
index ac9c52a7..63e5f88b 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/config/ConnectorConfigTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/config/ConnectorConfigTest.java
@@ -18,15 +18,75 @@
 package com.lightstreamer.kafka.adapters.config;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.adapters.config.AbstractConfig.ADAPTERS_CONF_ID;
+import static com.lightstreamer.kafka.adapters.config.AbstractConfig.ADAPTER_DIR;
+import static com.lightstreamer.kafka.adapters.config.BrokerAuthenticationConfigs.PASSWORD;
+import static com.lightstreamer.kafka.adapters.config.BrokerAuthenticationConfigs.USERNAME;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.AUTHENTICATION_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.BOOTSTRAP_SERVERS;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_CLIENT_ID;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_ENABLE_AUTO_COMMIT_CONFIG;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_FETCH_MAX_BYTES_CONFIG;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_FETCH_MAX_WAIT_MS_CONFIG;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_FETCH_MIN_BYTES_CONFIG;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_HEARTBEAT_INTERVAL_MS;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_MAX_POLL_INTERVAL_MS;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_MAX_POLL_RECORDS;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_METADATA_MAX_AGE_CONFIG;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_RECONNECT_BACKOFF_MAX_MS_CONFIG;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_RECONNECT_BACKOFF_MS_CONFIG;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_REQUEST_TIMEOUT_MS_CONFIG;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.CONSUMER_SESSION_TIMEOUT_MS;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.DATA_ADAPTER_NAME;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.ENCYRPTION_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.GROUP_ID;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.ITEM_INFO_FIELD;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.ITEM_INFO_NAME;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.ITEM_TEMPLATE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.LIGHSTREAMER_CLIENT_ID;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_CONSUME_FROM;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_CONSUME_WITH_NUM_THREADS;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_CONSUME_WITH_ORDER_STRATEGY;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.TOPIC_MAPPING;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.BASIC_AUTHENTICATION_USER_NAME;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.BASIC_AUTHENTICATION_USER_PASSWORD;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.ENABLE_BASIC_AUTHENTICATION;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.HOSTNAME_VERIFICATION_ENANLE;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.KEYSTORE_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.KEYSTORE_PASSWORD;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.KEYSTORE_PATH;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.KEYSTORE_TYPE;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.KEY_PASSWORD;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.SSL_CIPHER_SUITES;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.SSL_ENABLED_PROTOCOLS;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.SSL_PROTOCOL;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.TRUSTSTORE_PASSWORD;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.TRUSTSTORE_PATH;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.TRUSTSTORE_TYPE;
+import static com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs.URL;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.STRING;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeFrom.EARLIEST;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy.IGNORE_AND_CONTINUE;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.SslProtocol.TLSv12;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.SslProtocol.TLSv13;
 
+import static io.confluent.kafka.schemaregistry.client.SchemaRegistryClientConfig.BASIC_AUTH_CREDENTIALS_SOURCE;
+import static io.confluent.kafka.schemaregistry.client.SchemaRegistryClientConfig.USER_INFO_CONFIG;
+
 import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType;
-import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordComsumeFrom;
-import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.SaslMechanism;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigsSpec.ConfParameter;
@@ -38,8 +98,6 @@
 import com.lightstreamer.kafka.common.expressions.Expressions.TemplateExpression;
 import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
 
-import io.confluent.kafka.schemaregistry.client.SchemaRegistryClientConfig;
-
 import org.apache.kafka.clients.CommonClientConfigs;
 import org.apache.kafka.clients.consumer.ConsumerConfig;
 import org.apache.kafka.common.config.SaslConfigs;
@@ -88,67 +146,92 @@ public void before() throws IOException {
     public void shouldReturnConfigSpec() {
         ConfigsSpec configSpec = ConnectorConfig.configSpec();
 
-        ConfParameter adapterDir = configSpec.getParameter(ConnectorConfig.ADAPTER_DIR);
-        assertThat(adapterDir.name()).isEqualTo(ConnectorConfig.ADAPTER_DIR);
-        assertThat(adapterDir.required()).isTrue();
-        assertThat(adapterDir.multiple()).isFalse();
-        assertThat(adapterDir.mutable()).isTrue();
-        assertThat(adapterDir.defaultValue()).isNull();
-        assertThat(adapterDir.type()).isEqualTo(ConfType.DIRECTORY);
-
-        ConfParameter enabled = configSpec.getParameter(ConnectorConfig.ENABLE);
-        assertThat(enabled.name()).isEqualTo(ConnectorConfig.ENABLE);
-        assertThat(enabled.required()).isFalse();
-        assertThat(enabled.multiple()).isFalse();
-        assertThat(enabled.mutable()).isTrue();
-        assertThat(enabled.defaultValue()).isEqualTo("true");
-        assertThat(enabled.type()).isEqualTo(ConfType.BOOL);
-
-        ConfParameter adapterConfId = configSpec.getParameter(ConnectorConfig.ADAPTERS_CONF_ID);
-        assertThat(adapterConfId.name()).isEqualTo(ConnectorConfig.ADAPTERS_CONF_ID);
+        ConfParameter adapterConfId = configSpec.getParameter(ADAPTERS_CONF_ID);
+        assertThat(adapterConfId.name()).isEqualTo(ADAPTERS_CONF_ID);
         assertThat(adapterConfId.required()).isTrue();
         assertThat(adapterConfId.multiple()).isFalse();
         assertThat(adapterConfId.mutable()).isTrue();
         assertThat(adapterConfId.defaultValue()).isNull();
         assertThat(adapterConfId.type()).isEqualTo(ConfType.TEXT);
 
-        ConfParameter dataAdapterName = configSpec.getParameter(ConnectorConfig.DATA_ADAPTER_NAME);
-        assertThat(dataAdapterName.name()).isEqualTo(ConnectorConfig.DATA_ADAPTER_NAME);
+        ConfParameter adapterDir = configSpec.getParameter(ADAPTER_DIR);
+        assertThat(adapterDir.name()).isEqualTo(ADAPTER_DIR);
+        assertThat(adapterDir.required()).isTrue();
+        assertThat(adapterDir.multiple()).isFalse();
+        assertThat(adapterDir.mutable()).isTrue();
+        assertThat(adapterDir.defaultValue()).isNull();
+        assertThat(adapterDir.type()).isEqualTo(ConfType.DIRECTORY);
+
+        ConfParameter dataAdapterName = configSpec.getParameter(DATA_ADAPTER_NAME);
+        assertThat(dataAdapterName.name()).isEqualTo(DATA_ADAPTER_NAME);
         assertThat(dataAdapterName.required()).isTrue();
         assertThat(dataAdapterName.multiple()).isFalse();
         assertThat(dataAdapterName.mutable()).isTrue();
         assertThat(dataAdapterName.defaultValue()).isNull();
         assertThat(dataAdapterName.type()).isEqualTo(ConfType.TEXT);
 
-        ConfParameter bootStrapServers = configSpec.getParameter(ConnectorConfig.BOOTSTRAP_SERVERS);
-        assertThat(bootStrapServers.name()).isEqualTo(ConnectorConfig.BOOTSTRAP_SERVERS);
+        ConfParameter enabled = configSpec.getParameter(ENABLE);
+        assertThat(enabled.name()).isEqualTo(ENABLE);
+        assertThat(enabled.required()).isFalse();
+        assertThat(enabled.multiple()).isFalse();
+        assertThat(enabled.mutable()).isTrue();
+        assertThat(enabled.defaultValue()).isEqualTo("true");
+        assertThat(enabled.type()).isEqualTo(ConfType.BOOL);
+
+        ConfParameter bootStrapServers = configSpec.getParameter(BOOTSTRAP_SERVERS);
+        assertThat(bootStrapServers.name()).isEqualTo(BOOTSTRAP_SERVERS);
         assertThat(bootStrapServers.required()).isTrue();
         assertThat(bootStrapServers.multiple()).isFalse();
         assertThat(bootStrapServers.mutable()).isTrue();
         assertThat(bootStrapServers.defaultValue()).isNull();
         assertThat(bootStrapServers.type()).isEqualTo(ConfType.HOST_LIST);
 
-        ConfParameter groupId = configSpec.getParameter(ConnectorConfig.GROUP_ID);
-        assertThat(groupId.name()).isEqualTo(ConnectorConfig.GROUP_ID);
+        ConfParameter groupId = configSpec.getParameter(GROUP_ID);
+        assertThat(groupId.name()).isEqualTo(GROUP_ID);
         assertThat(groupId.required()).isFalse();
         assertThat(groupId.multiple()).isFalse();
         assertThat(groupId.mutable()).isTrue();
         assertThat(groupId.defaultValue()).isNotNull();
         assertThat(groupId.type()).isEqualTo(ConfType.TEXT);
 
-        ConfParameter keyEvaluatorType =
-                configSpec.getParameter(ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE);
-        assertThat(keyEvaluatorType.name()).isEqualTo(ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE);
+        ConfParameter itemTemplate = configSpec.getParameter(ITEM_TEMPLATE);
+        assertThat(itemTemplate.name()).isEqualTo(ITEM_TEMPLATE);
+        assertThat(itemTemplate.required()).isFalse();
+        assertThat(itemTemplate.multiple()).isTrue();
+        assertThat(itemTemplate.suffix()).isNull();
+        assertThat(itemTemplate.mutable()).isTrue();
+        ;
+        assertThat(itemTemplate.defaultValue()).isNull();
+        assertThat(itemTemplate.type()).isEqualTo(ConfType.TEXT);
+
+        ConfParameter topicMapping = configSpec.getParameter(TOPIC_MAPPING);
+        assertThat(topicMapping.name()).isEqualTo(TOPIC_MAPPING);
+        assertThat(topicMapping.required()).isTrue();
+        assertThat(topicMapping.multiple()).isTrue();
+        assertThat(topicMapping.suffix()).isEqualTo("to");
+        assertThat(topicMapping.mutable()).isTrue();
+        assertThat(topicMapping.defaultValue()).isNull();
+        assertThat(topicMapping.type()).isEqualTo(ConfType.TEXT_LIST);
+
+        ConfParameter fieldMapping = configSpec.getParameter(ConnectorConfig.FIELD_MAPPING);
+        assertThat(fieldMapping.name()).isEqualTo(ConnectorConfig.FIELD_MAPPING);
+        assertThat(fieldMapping.required()).isTrue();
+        assertThat(fieldMapping.multiple()).isTrue();
+        assertThat(fieldMapping.suffix()).isNull();
+        assertThat(fieldMapping.mutable()).isTrue();
+        assertThat(fieldMapping.defaultValue()).isNull();
+        assertThat(fieldMapping.type()).isEqualTo(ConfType.TEXT);
+
+        ConfParameter keyEvaluatorType = configSpec.getParameter(RECORD_KEY_EVALUATOR_TYPE);
+        assertThat(keyEvaluatorType.name()).isEqualTo(RECORD_KEY_EVALUATOR_TYPE);
         assertThat(keyEvaluatorType.required()).isFalse();
         assertThat(keyEvaluatorType.multiple()).isFalse();
         assertThat(keyEvaluatorType.mutable()).isTrue();
         assertThat(keyEvaluatorType.defaultValue()).isEqualTo("STRING");
         assertThat(keyEvaluatorType.type()).isEqualTo(ConfType.EVALUATOR);
 
-        ConfParameter keySchemaFile =
-                configSpec.getParameter(ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH);
-        assertThat(keySchemaFile.name())
-                .isEqualTo(ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH);
+        ConfParameter keySchemaFile = configSpec.getParameter(RECORD_KEY_EVALUATOR_SCHEMA_PATH);
+        assertThat(keySchemaFile.name()).isEqualTo(RECORD_KEY_EVALUATOR_SCHEMA_PATH);
         assertThat(keySchemaFile.required()).isFalse();
         assertThat(keySchemaFile.multiple()).isFalse();
         assertThat(keySchemaFile.mutable()).isTrue();
@@ -156,30 +239,25 @@ public void shouldReturnConfigSpec() {
         assertThat(keySchemaFile.type()).isEqualTo(ConfType.FILE);
 
         ConfParameter schemaRegistryEnabledForKey =
-                configSpec.getParameter(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
+                configSpec.getParameter(RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
         assertThat(schemaRegistryEnabledForKey.name())
-                .isEqualTo(ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
+                .isEqualTo(RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
         assertThat(schemaRegistryEnabledForKey.required()).isFalse();
         assertThat(schemaRegistryEnabledForKey.multiple()).isFalse();
         assertThat(schemaRegistryEnabledForKey.mutable()).isTrue();
         assertThat(schemaRegistryEnabledForKey.defaultValue()).isEqualTo("false");
         assertThat(schemaRegistryEnabledForKey.type()).isEqualTo(ConfType.BOOL);
 
-        ConfParameter valueEvaluatorType =
-                configSpec.getParameter(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE);
-        assertThat(valueEvaluatorType.name())
-                .isEqualTo(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE);
+        ConfParameter valueEvaluatorType = configSpec.getParameter(RECORD_VALUE_EVALUATOR_TYPE);
+        assertThat(valueEvaluatorType.name()).isEqualTo(RECORD_VALUE_EVALUATOR_TYPE);
         assertThat(valueEvaluatorType.required()).isFalse();
         assertThat(valueEvaluatorType.multiple()).isFalse();
         assertThat(valueEvaluatorType.mutable()).isTrue();
         assertThat(valueEvaluatorType.defaultValue()).isEqualTo("STRING");
         assertThat(valueEvaluatorType.type()).isEqualTo(ConfType.EVALUATOR);
 
-        ConfParameter valueSchemaFile =
-                configSpec.getParameter(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH);
-        assertThat(valueSchemaFile.name())
-                .isEqualTo(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH);
+        ConfParameter valueSchemaFile = configSpec.getParameter(RECORD_VALUE_EVALUATOR_SCHEMA_PATH);
+        assertThat(valueSchemaFile.name()).isEqualTo(RECORD_VALUE_EVALUATOR_SCHEMA_PATH);
         assertThat(valueSchemaFile.required()).isFalse();
         assertThat(valueSchemaFile.multiple()).isFalse();
         assertThat(valueSchemaFile.mutable()).isTrue();
@@ -187,113 +265,211 @@ public void shouldReturnConfigSpec() {
         assertThat(valueSchemaFile.type()).isEqualTo(ConfType.FILE);
 
         ConfParameter schemaRegistryEnabledForValue =
-                configSpec.getParameter(
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
+                configSpec.getParameter(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
         assertThat(schemaRegistryEnabledForValue.name())
-                .isEqualTo(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
+                .isEqualTo(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE);
         assertThat(schemaRegistryEnabledForValue.required()).isFalse();
         assertThat(schemaRegistryEnabledForValue.multiple()).isFalse();
         assertThat(schemaRegistryEnabledForValue.mutable()).isTrue();
         assertThat(schemaRegistryEnabledForValue.defaultValue()).isEqualTo("false");
         assertThat(schemaRegistryEnabledForValue.type()).isEqualTo(ConfType.BOOL);
 
-        ConfParameter itemTemplate = configSpec.getParameter(ConnectorConfig.ITEM_TEMPLATE);
-        assertThat(itemTemplate.name()).isEqualTo(ConnectorConfig.ITEM_TEMPLATE);
-        assertThat(itemTemplate.required()).isFalse();
-        assertThat(itemTemplate.multiple()).isTrue();
-        assertThat(itemTemplate.suffix()).isNull();
-        assertThat(itemTemplate.mutable()).isTrue();
-        ;
-        assertThat(itemTemplate.defaultValue()).isNull();
-        assertThat(itemTemplate.type()).isEqualTo(ConfType.TEXT);
-
-        ConfParameter topicMapping = configSpec.getParameter(ConnectorConfig.TOPIC_MAPPING);
-        assertThat(topicMapping.name()).isEqualTo(ConnectorConfig.TOPIC_MAPPING);
-        assertThat(topicMapping.required()).isTrue();
-        assertThat(topicMapping.multiple()).isTrue();
-        assertThat(topicMapping.suffix()).isEqualTo("to");
-        assertThat(topicMapping.mutable()).isTrue();
-        assertThat(topicMapping.defaultValue()).isNull();
-        assertThat(topicMapping.type()).isEqualTo(ConfType.TEXT_LIST);
-
-        ConfParameter fieldMapping = configSpec.getParameter(ConnectorConfig.FIELD_MAPPING);
-        assertThat(fieldMapping.name()).isEqualTo(ConnectorConfig.FIELD_MAPPING);
-        assertThat(fieldMapping.required()).isTrue();
-        assertThat(fieldMapping.multiple()).isTrue();
-        assertThat(fieldMapping.suffix()).isNull();
-        assertThat(fieldMapping.mutable()).isTrue();
-        assertThat(fieldMapping.defaultValue()).isNull();
-        assertThat(fieldMapping.type()).isEqualTo(ConfType.TEXT);
-
-        ConfParameter itemInfoName = configSpec.getParameter(ConnectorConfig.ITEM_INFO_NAME);
-        assertThat(itemInfoName.name()).isEqualTo(ConnectorConfig.ITEM_INFO_NAME);
+        ConfParameter itemInfoName = configSpec.getParameter(ITEM_INFO_NAME);
+        assertThat(itemInfoName.name()).isEqualTo(ITEM_INFO_NAME);
         assertThat(itemInfoName.required()).isFalse();
         assertThat(itemInfoName.multiple()).isFalse();
         assertThat(itemInfoName.mutable()).isTrue();
         assertThat(itemInfoName.defaultValue()).isEqualTo("INFO");
         assertThat(itemInfoName.type()).isEqualTo(ConfType.TEXT);
 
-        ConfParameter itemInfoField = configSpec.getParameter(ConnectorConfig.ITEM_INFO_FIELD);
-        assertThat(itemInfoField.name()).isEqualTo(ConnectorConfig.ITEM_INFO_FIELD);
+        ConfParameter itemInfoField = configSpec.getParameter(ITEM_INFO_FIELD);
+        assertThat(itemInfoField.name()).isEqualTo(ITEM_INFO_FIELD);
         assertThat(itemInfoField.required()).isFalse();
         assertThat(itemInfoField.multiple()).isFalse();
         assertThat(itemInfoField.mutable()).isTrue();
         assertThat(itemInfoField.defaultValue()).isEqualTo("MSG");
         assertThat(itemInfoField.type()).isEqualTo(ConfType.TEXT);
 
+        ConfParameter recordExtrationErrorHandling =
+                configSpec.getParameter(RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY);
+        assertThat(recordExtrationErrorHandling.name())
+                .isEqualTo(RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY);
+        assertThat(recordExtrationErrorHandling.required()).isFalse();
+        assertThat(recordExtrationErrorHandling.multiple()).isFalse();
+        assertThat(recordExtrationErrorHandling.mutable()).isTrue();
+        assertThat(recordExtrationErrorHandling.defaultValue()).isEqualTo("IGNORE_AND_CONTINUE");
+        assertThat(recordExtrationErrorHandling.type()).isEqualTo(ConfType.ERROR_STRATEGY);
+
+        ConfParameter recordConsumeWithOrderStrategy =
+                configSpec.getParameter(RECORD_CONSUME_WITH_ORDER_STRATEGY);
+        assertThat(recordConsumeWithOrderStrategy.name())
+                .isEqualTo(RECORD_CONSUME_WITH_ORDER_STRATEGY);
+        assertThat(recordConsumeWithOrderStrategy.required()).isFalse();
+        assertThat(recordConsumeWithOrderStrategy.multiple()).isFalse();
+        assertThat(recordConsumeWithOrderStrategy.mutable()).isTrue();
+        assertThat(recordConsumeWithOrderStrategy.defaultValue()).isEqualTo("ORDER_BY_PARTITION");
+        assertThat(recordConsumeWithOrderStrategy.type()).isEqualTo(ConfType.ORDER_STRATEGY);
+
+        ConfParameter recordConsumeWithThreadsNumber =
+                configSpec.getParameter(RECORD_CONSUME_WITH_NUM_THREADS);
+        assertThat(recordConsumeWithThreadsNumber.name())
+                .isEqualTo(RECORD_CONSUME_WITH_NUM_THREADS);
+        assertThat(recordConsumeWithThreadsNumber.required()).isFalse();
+        assertThat(recordConsumeWithThreadsNumber.multiple()).isFalse();
+        assertThat(recordConsumeWithThreadsNumber.mutable()).isTrue();
+        assertThat(recordConsumeWithThreadsNumber.defaultValue()).isEqualTo("1");
+        assertThat(recordConsumeWithThreadsNumber.type()).isEqualTo(ConfType.THREADS);
+
         ConfParameter enableAutoCommit =
-                configSpec.getParameter(ConnectorConfig.CONSUMER_ENABLE_AUTO_COMMIT_CONFIG);
-        assertThat(enableAutoCommit.name())
-                .isEqualTo(ConnectorConfig.CONSUMER_ENABLE_AUTO_COMMIT_CONFIG);
+                configSpec.getParameter(CONSUMER_ENABLE_AUTO_COMMIT_CONFIG);
+        assertThat(enableAutoCommit.name()).isEqualTo(CONSUMER_ENABLE_AUTO_COMMIT_CONFIG);
         assertThat(enableAutoCommit.required()).isFalse();
         assertThat(enableAutoCommit.multiple()).isFalse();
         assertThat(enableAutoCommit.mutable()).isFalse();
         assertThat(enableAutoCommit.defaultValue()).isEqualTo("false");
         assertThat(enableAutoCommit.type()).isEqualTo(ConfType.BOOL);
 
-        ConfParameter clientId = configSpec.getParameter(ConnectorConfig.CONSUMER_CLIENT_ID);
-        assertThat(clientId.name()).isEqualTo(ConnectorConfig.CONSUMER_CLIENT_ID);
-        assertThat(clientId.required()).isFalse();
-        assertThat(clientId.multiple()).isFalse();
-        assertThat(clientId.mutable()).isFalse();
-        assertThat(clientId.defaultValue()).isEqualTo("");
-        assertThat(clientId.type()).isEqualTo(ConfType.TEXT);
-
-        ConfParameter consumeEventsFrom =
-                configSpec.getParameter(ConnectorConfig.RECORD_CONSUME_FROM);
-        assertThat(consumeEventsFrom.name()).isEqualTo(ConnectorConfig.RECORD_CONSUME_FROM);
-        assertThat(consumeEventsFrom.required()).isFalse();
-        assertThat(consumeEventsFrom.multiple()).isFalse();
-        assertThat(consumeEventsFrom.mutable()).isTrue();
-        assertThat(consumeEventsFrom.defaultValue()).isEqualTo("LATEST");
-        assertThat(consumeEventsFrom.type()).isEqualTo(ConfType.CONSUME_FROM);
-
-        ConfParameter encryptionEnabed = configSpec.getParameter(ConnectorConfig.ENCYRPTION_ENABLE);
-        assertThat(encryptionEnabed.name()).isEqualTo(ConnectorConfig.ENCYRPTION_ENABLE);
+        ConfParameter encryptionEnabed = configSpec.getParameter(ENCYRPTION_ENABLE);
+        assertThat(encryptionEnabed.name()).isEqualTo(ENCYRPTION_ENABLE);
         assertThat(encryptionEnabed.required()).isFalse();
         assertThat(encryptionEnabed.multiple()).isFalse();
         assertThat(encryptionEnabed.mutable()).isTrue();
         assertThat(encryptionEnabed.defaultValue()).isEqualTo("false");
         assertThat(encryptionEnabed.type()).isEqualTo(ConfType.BOOL);
 
-        ConfParameter authenticationEnabled =
-                configSpec.getParameter(ConnectorConfig.AUTHENTICATION_ENABLE);
-        assertThat(authenticationEnabled.name()).isEqualTo(ConnectorConfig.AUTHENTICATION_ENABLE);
+        ConfParameter authenticationEnabled = configSpec.getParameter(AUTHENTICATION_ENABLE);
+        assertThat(authenticationEnabled.name()).isEqualTo(AUTHENTICATION_ENABLE);
         assertThat(authenticationEnabled.required()).isFalse();
         assertThat(authenticationEnabled.multiple()).isFalse();
         assertThat(authenticationEnabled.mutable()).isTrue();
         assertThat(authenticationEnabled.defaultValue()).isEqualTo("false");
         assertThat(authenticationEnabled.type()).isEqualTo(ConfType.BOOL);
+
+        ConfParameter consumeEventsFrom = configSpec.getParameter(RECORD_CONSUME_FROM);
+        assertThat(consumeEventsFrom.name()).isEqualTo(RECORD_CONSUME_FROM);
+        assertThat(consumeEventsFrom.required()).isFalse();
+        assertThat(consumeEventsFrom.multiple()).isFalse();
+        assertThat(consumeEventsFrom.mutable()).isTrue();
+        assertThat(consumeEventsFrom.defaultValue()).isEqualTo("LATEST");
+        assertThat(consumeEventsFrom.type()).isEqualTo(ConfType.CONSUME_FROM);
+
+        ConfParameter clientId = configSpec.getParameter(CONSUMER_CLIENT_ID);
+        assertThat(clientId.name()).isEqualTo(CONSUMER_CLIENT_ID);
+        assertThat(clientId.required()).isFalse();
+        assertThat(clientId.multiple()).isFalse();
+        assertThat(clientId.mutable()).isFalse();
+        assertThat(clientId.defaultValue()).isEqualTo("");
+        assertThat(clientId.type()).isEqualTo(ConfType.TEXT);
+
+        ConfParameter enableAutoCommitConfig =
+                configSpec.getParameter(CONSUMER_ENABLE_AUTO_COMMIT_CONFIG);
+        assertThat(enableAutoCommitConfig.name()).isEqualTo(CONSUMER_ENABLE_AUTO_COMMIT_CONFIG);
+        assertThat(enableAutoCommitConfig.required()).isFalse();
+        assertThat(enableAutoCommitConfig.multiple()).isFalse();
+        assertThat(enableAutoCommitConfig.mutable()).isFalse();
+        assertThat(enableAutoCommitConfig.defaultValue()).isEqualTo("false");
+        assertThat(enableAutoCommitConfig.type()).isEqualTo(ConfType.BOOL);
+
+        ConfParameter reconnectBackoffMaxMs =
+                configSpec.getParameter(CONSUMER_RECONNECT_BACKOFF_MAX_MS_CONFIG);
+        assertThat(reconnectBackoffMaxMs.name())
+                .isEqualTo(CONSUMER_RECONNECT_BACKOFF_MAX_MS_CONFIG);
+        assertThat(reconnectBackoffMaxMs.required()).isFalse();
+        assertThat(reconnectBackoffMaxMs.multiple()).isFalse();
+        assertThat(reconnectBackoffMaxMs.mutable()).isTrue();
+        assertThat(reconnectBackoffMaxMs.defaultValue()).isNull();
+        assertThat(reconnectBackoffMaxMs.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter reconnectBackoffMs =
+                configSpec.getParameter(CONSUMER_RECONNECT_BACKOFF_MS_CONFIG);
+        assertThat(reconnectBackoffMs.name()).isEqualTo(CONSUMER_RECONNECT_BACKOFF_MS_CONFIG);
+        assertThat(reconnectBackoffMs.required()).isFalse();
+        assertThat(reconnectBackoffMs.multiple()).isFalse();
+        assertThat(reconnectBackoffMs.mutable()).isTrue();
+        assertThat(reconnectBackoffMs.defaultValue()).isNull();
+        assertThat(reconnectBackoffMs.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter fetchMinBytes = configSpec.getParameter(CONSUMER_FETCH_MIN_BYTES_CONFIG);
+        assertThat(fetchMinBytes.name()).isEqualTo(CONSUMER_FETCH_MIN_BYTES_CONFIG);
+        assertThat(fetchMinBytes.required()).isFalse();
+        assertThat(fetchMinBytes.multiple()).isFalse();
+        assertThat(fetchMinBytes.mutable()).isTrue();
+        assertThat(fetchMinBytes.defaultValue()).isNull();
+        assertThat(fetchMinBytes.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter fetchMaxBytes = configSpec.getParameter(CONSUMER_FETCH_MAX_BYTES_CONFIG);
+        assertThat(fetchMaxBytes.name()).isEqualTo(CONSUMER_FETCH_MAX_BYTES_CONFIG);
+        assertThat(fetchMaxBytes.required()).isFalse();
+        assertThat(fetchMaxBytes.multiple()).isFalse();
+        assertThat(fetchMaxBytes.mutable()).isTrue();
+        assertThat(fetchMaxBytes.defaultValue()).isNull();
+        assertThat(fetchMaxBytes.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter fetchMaxWaitMs = configSpec.getParameter(CONSUMER_FETCH_MAX_WAIT_MS_CONFIG);
+        assertThat(fetchMaxWaitMs.name()).isEqualTo(CONSUMER_FETCH_MAX_WAIT_MS_CONFIG);
+        assertThat(fetchMaxWaitMs.required()).isFalse();
+        assertThat(fetchMaxWaitMs.multiple()).isFalse();
+        assertThat(fetchMaxWaitMs.mutable()).isTrue();
+        assertThat(fetchMaxWaitMs.defaultValue()).isNull();
+        assertThat(fetchMaxWaitMs.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter maxPollRecords = configSpec.getParameter(CONSUMER_MAX_POLL_RECORDS);
+        assertThat(maxPollRecords.name()).isEqualTo(CONSUMER_MAX_POLL_RECORDS);
+        assertThat(maxPollRecords.required()).isFalse();
+        assertThat(maxPollRecords.multiple()).isFalse();
+        assertThat(maxPollRecords.mutable()).isTrue();
+        assertThat(maxPollRecords.defaultValue()).isNull();
+        assertThat(maxPollRecords.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter heartBeatIntervalMs = configSpec.getParameter(CONSUMER_HEARTBEAT_INTERVAL_MS);
+        assertThat(heartBeatIntervalMs.name()).isEqualTo(CONSUMER_HEARTBEAT_INTERVAL_MS);
+        assertThat(heartBeatIntervalMs.required()).isFalse();
+        assertThat(heartBeatIntervalMs.multiple()).isFalse();
+        assertThat(heartBeatIntervalMs.mutable()).isTrue();
+        assertThat(heartBeatIntervalMs.defaultValue()).isNull();
+        assertThat(heartBeatIntervalMs.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter sessionTimeoutMs = configSpec.getParameter(CONSUMER_SESSION_TIMEOUT_MS);
+        assertThat(sessionTimeoutMs.name()).isEqualTo(CONSUMER_SESSION_TIMEOUT_MS);
+        assertThat(sessionTimeoutMs.required()).isFalse();
+        assertThat(sessionTimeoutMs.multiple()).isFalse();
+        assertThat(sessionTimeoutMs.mutable()).isTrue();
+        assertThat(sessionTimeoutMs.defaultValue()).isNull();
+        assertThat(sessionTimeoutMs.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter maxPollIntervalMs = configSpec.getParameter(CONSUMER_MAX_POLL_INTERVAL_MS);
+        assertThat(maxPollIntervalMs.name()).isEqualTo(CONSUMER_MAX_POLL_INTERVAL_MS);
+        assertThat(maxPollIntervalMs.required()).isFalse();
+        assertThat(maxPollIntervalMs.multiple()).isFalse();
+        assertThat(maxPollIntervalMs.mutable()).isFalse();
+        assertThat(maxPollIntervalMs.defaultValue()).isEqualTo("5000");
+        assertThat(maxPollIntervalMs.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter metadatMaxAge = configSpec.getParameter(CONSUMER_METADATA_MAX_AGE_CONFIG);
+        assertThat(metadatMaxAge.name()).isEqualTo(CONSUMER_METADATA_MAX_AGE_CONFIG);
+        assertThat(metadatMaxAge.required()).isFalse();
+        assertThat(metadatMaxAge.multiple()).isFalse();
+        assertThat(metadatMaxAge.mutable()).isFalse();
+        assertThat(metadatMaxAge.defaultValue()).isEqualTo("250");
+        assertThat(metadatMaxAge.type()).isEqualTo(ConfType.INT);
+
+        ConfParameter requestTimeoutMs =
+                configSpec.getParameter(CONSUMER_REQUEST_TIMEOUT_MS_CONFIG);
+        assertThat(requestTimeoutMs.name()).isEqualTo(CONSUMER_REQUEST_TIMEOUT_MS_CONFIG);
+        assertThat(requestTimeoutMs.required()).isFalse();
+        assertThat(requestTimeoutMs.multiple()).isFalse();
+        assertThat(requestTimeoutMs.mutable()).isFalse();
+        assertThat(requestTimeoutMs.defaultValue()).isEqualTo("30000");
+        assertThat(requestTimeoutMs.type()).isEqualTo(ConfType.INT);
     }
 
     private Map<String, String> standardParameters() {
         Map<String, String> standardParams = new HashMap<>();
-        standardParams.put(ConnectorConfig.BOOTSTRAP_SERVERS, "server:8080,server:8081");
-        standardParams.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE, "STRING");
+        standardParams.put(BOOTSTRAP_SERVERS, "server:8080,server:8081");
+        standardParams.put(RECORD_VALUE_EVALUATOR_TYPE, "STRING");
         standardParams.put(
-                ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                valueSchemaFile.getFileName().toString());
-        standardParams.put(ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE, "JSON");
+                RECORD_VALUE_EVALUATOR_SCHEMA_PATH, valueSchemaFile.getFileName().toString());
+        standardParams.put(RECORD_KEY_EVALUATOR_TYPE, "JSON");
         standardParams.put(
                 ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
                 keySchemaFile.getFileName().toString());
@@ -307,15 +483,14 @@ private Map<String, String> standardParameters() {
         standardParams.put(ConnectorConfig.CONSUMER_FETCH_MIN_BYTES_CONFIG, "300");
         standardParams.put(ConnectorConfig.CONSUMER_RECONNECT_BACKOFF_MAX_MS_CONFIG, "400");
         standardParams.put(ConnectorConfig.CONSUMER_RECONNECT_BACKOFF_MS_CONFIG, "500");
-        standardParams.put(ConnectorConfig.CONSUMER_HEARTBEAT_INTERVAL_MS, "600");
+        standardParams.put(CONSUMER_HEARTBEAT_INTERVAL_MS, "600");
         standardParams.put(ConnectorConfig.CONSUMER_MAX_POLL_RECORDS, "700");
-        standardParams.put(ConnectorConfig.CONSUMER_SESSION_TIMEOUT_MS, "800");
-        standardParams.put(ConnectorConfig.CONSUMER_MAX_POLL_INTERVAL_MS, "2000"); // Unmodifiable
-        standardParams.put(ConnectorConfig.CONSUMER_METADATA_MAX_AGE_CONFIG, "250"); // Unmodifiable
+        standardParams.put(CONSUMER_SESSION_TIMEOUT_MS, "800");
+        standardParams.put(CONSUMER_MAX_POLL_INTERVAL_MS, "2000"); // Unmodifiable
+        standardParams.put(CONSUMER_METADATA_MAX_AGE_CONFIG, "250"); // Unmodifiable
         standardParams.put(
                 ConnectorConfig.CONSUMER_DEFAULT_API_TIMEOUT_MS_CONFIG, "1000"); // Unmodifiable
-        standardParams.put(
-                ConnectorConfig.CONSUMER_REQUEST_TIMEOUT_MS_CONFIG, "15000"); // Unmodifiable
+        standardParams.put(CONSUMER_REQUEST_TIMEOUT_MS_CONFIG, "15000"); // Unmodifiable
         standardParams.put("item-template.template1", "template1-#{v=VALUE}");
         standardParams.put("item-template.template2", "template2-#{v=OFFSET}");
         standardParams.put("map.topic1.to", "template1");
@@ -326,7 +501,7 @@ private Map<String, String> standardParameters() {
 
     private Map<String, String> encryptionParameters() {
         Map<String, String> encryptionParams = new HashMap<>();
-        encryptionParams.put(ConnectorConfig.ENCYRPTION_ENABLE, "true");
+        encryptionParams.put(ENCYRPTION_ENABLE, "true");
         return encryptionParams;
     }
 
@@ -339,9 +514,9 @@ private Map<String, String> kesytoreParameters() {
 
     private Map<String, String> authenticationParameters() {
         Map<String, String> authParams = new HashMap<>();
-        authParams.put(ConnectorConfig.AUTHENTICATION_ENABLE, "true");
-        authParams.put(BrokerAuthenticationConfigs.USERNAME, "sasl-username");
-        authParams.put(BrokerAuthenticationConfigs.PASSWORD, "sasl-password");
+        authParams.put(AUTHENTICATION_ENABLE, "true");
+        authParams.put(USERNAME, "sasl-username");
+        authParams.put(PASSWORD, "sasl-password");
         return authParams;
     }
 
@@ -351,76 +526,59 @@ public void shouldSpecifyRequiredParams() {
                 assertThrows(
                         ConfigException.class, () -> new ConnectorConfig(Collections.emptyMap()));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Missing required parameter [%s]"
-                                .formatted(ConnectorConfig.ADAPTERS_CONF_ID));
+                .isEqualTo("Missing required parameter [%s]".formatted(ADAPTERS_CONF_ID));
 
         Map<String, String> params = new HashMap<>();
 
-        params.put(ConnectorConfig.ADAPTERS_CONF_ID, "");
+        params.put(ADAPTERS_CONF_ID, "");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Specify a valid value for parameter [%s]"
-                                .formatted(ConnectorConfig.ADAPTERS_CONF_ID));
+                .isEqualTo("Specify a valid value for parameter [%s]".formatted(ADAPTERS_CONF_ID));
 
-        params.put(ConnectorConfig.ADAPTERS_CONF_ID, "adapters_conf_id");
+        params.put(ADAPTERS_CONF_ID, "adapters_conf_id");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Missing required parameter [%s]".formatted(ConnectorConfig.ADAPTER_DIR));
+                .isEqualTo("Missing required parameter [%s]".formatted(ADAPTER_DIR));
 
-        params.put(ConnectorConfig.ADAPTER_DIR, "");
+        params.put(ADAPTER_DIR, "");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Specify a valid value for parameter [%s]"
-                                .formatted(ConnectorConfig.ADAPTER_DIR));
+                .isEqualTo("Specify a valid value for parameter [%s]".formatted(ADAPTER_DIR));
 
-        params.put(ConnectorConfig.ADAPTER_DIR, "non-existing-directory");
+        params.put(ADAPTER_DIR, "non-existing-directory");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
                 .isEqualTo(
                         "Not found directory [non-existing-directory] specified in [%s]"
-                                .formatted(ConnectorConfig.ADAPTER_DIR));
+                                .formatted(ADAPTER_DIR));
 
-        params.put(ConnectorConfig.ADAPTER_DIR, adapterDir.toString());
+        params.put(ADAPTER_DIR, adapterDir.toString());
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Missing required parameter [%s]"
-                                .formatted(ConnectorConfig.DATA_ADAPTER_NAME));
+                .isEqualTo("Missing required parameter [%s]".formatted(DATA_ADAPTER_NAME));
 
-        params.put(ConnectorConfig.DATA_ADAPTER_NAME, "");
+        params.put(DATA_ADAPTER_NAME, "");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Specify a valid value for parameter [%s]"
-                                .formatted(ConnectorConfig.DATA_ADAPTER_NAME));
+                .isEqualTo("Specify a valid value for parameter [%s]".formatted(DATA_ADAPTER_NAME));
 
-        params.put(ConnectorConfig.DATA_ADAPTER_NAME, "data_provider_name");
+        params.put(DATA_ADAPTER_NAME, "data_provider_name");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Missing required parameter [%s]"
-                                .formatted(ConnectorConfig.BOOTSTRAP_SERVERS));
+                .isEqualTo("Missing required parameter [%s]".formatted(BOOTSTRAP_SERVERS));
 
-        params.put(ConnectorConfig.BOOTSTRAP_SERVERS, "");
+        params.put(BOOTSTRAP_SERVERS, "");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Specify a valid value for parameter [%s]"
-                                .formatted(ConnectorConfig.BOOTSTRAP_SERVERS));
+                .isEqualTo("Specify a valid value for parameter [%s]".formatted(BOOTSTRAP_SERVERS));
 
         // Trailing "," not allowed
-        params.put(ConnectorConfig.BOOTSTRAP_SERVERS, "server:8080,");
+        params.put(BOOTSTRAP_SERVERS, "server:8080,");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage())
-                .isEqualTo(
-                        "Specify a valid value for parameter [%s]"
-                                .formatted(ConnectorConfig.BOOTSTRAP_SERVERS));
+                .isEqualTo("Specify a valid value for parameter [%s]".formatted(BOOTSTRAP_SERVERS));
 
-        params.put(ConnectorConfig.BOOTSTRAP_SERVERS, "server:8080");
+        params.put(BOOTSTRAP_SERVERS, "server:8080");
         ce = assertThrows(ConfigException.class, () -> new ConnectorConfig(params));
         assertThat(ce.getMessage()).isEqualTo("Specify at least one parameter [map.<...>.to]");
 
@@ -520,7 +678,7 @@ static Stream<String> confluentCloudHostList() {
 
     @ParameterizedTest
     @MethodSource("confluentCloudHostList")
-    public void shouldRetrieveLightstreamreClientIdWhenConnectedToConfluentClod(String hostList) {
+    public void shouldRetrieveLightstreamerClientIdWhenConnectedToConfluentClod(String hostList) {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
         updatedConfig.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, hostList);
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
@@ -530,7 +688,7 @@ public void shouldRetrieveLightstreamreClientIdWhenConnectedToConfluentClod(Stri
                         ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
                         hostList,
                         ConsumerConfig.CLIENT_ID_CONFIG,
-                        ConnectorConfig.LIGHSTREAMER_CLIENT_ID);
+                        LIGHSTREAMER_CLIENT_ID);
     }
 
     static Stream<String> partialConfluentCloudHostList() {
@@ -579,7 +737,7 @@ public void shouldNotModifyEnableAutoCommitConfig() {
         updatedConfig.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
         ConnectorConfig config =
                 ConnectorConfig.newConfig(adapterDir.toFile(), standardParameters());
-        assertThat(config.getBoolean(ConnectorConfig.CONSUMER_ENABLE_AUTO_COMMIT_CONFIG)).isFalse();
+        assertThat(config.getBoolean(CONSUMER_ENABLE_AUTO_COMMIT_CONFIG)).isFalse();
     }
 
     @Test
@@ -591,7 +749,7 @@ public void shouldGetText() {
         assertThat(config.getItemInfoName()).isEqualTo("INFO_ITEM");
         assertThat(config.getItemInfoField()).isEqualTo("INFO_FIELD");
 
-        String groupId = config.getText(ConnectorConfig.GROUP_ID);
+        String groupId = config.getText(GROUP_ID);
         assertThat(groupId).startsWith("KAFKA-CONNECTOR-");
         assertThat(groupId.length()).isGreaterThan("KAFKA-CONNECTOR-".length());
     }
@@ -613,10 +771,10 @@ public void shouldGetText() {
                 "BYTE_ARRAY",
                 "BYTE_BUFFER"
             })
-    public void shouldGetEvaluator(String type) {
+    public void shouldGetRecordEvaluatorTypes(String type) {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE, type);
-        updatedConfig.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE, type);
+        updatedConfig.put(RECORD_KEY_EVALUATOR_TYPE, type);
+        updatedConfig.put(RECORD_VALUE_EVALUATOR_TYPE, type);
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
 
         assertThat(config.getValueEvaluator()).isEqualTo(EvaluatorType.valueOf(type));
@@ -627,9 +785,9 @@ public void shouldGetEvaluator(String type) {
     public void shouldFailDueToInvalidEvaluatorType() {
         Map<String, String> keys =
                 Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE,
+                        RECORD_KEY_EVALUATOR_TYPE,
                         "[record.key.evaluator.type]",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE,
+                        RECORD_VALUE_EVALUATOR_TYPE,
                         "[record.value.evaluator.type]");
         for (Map.Entry<String, String> entry : keys.entrySet()) {
             Map<String, String> updatedConfig = new HashMap<>(standardParameters());
@@ -647,9 +805,9 @@ public void shouldFailDueToInvalidEvaluatorType() {
     public void shouldFailDueToInvalidSchemaPath() {
         Map<String, String> keys =
                 Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                        RECORD_KEY_EVALUATOR_SCHEMA_PATH,
                         "[key.evaluator.schema.path]",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                        RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
                         "[value.evaluator.schema.path]");
         for (Map.Entry<String, String> entry : keys.entrySet()) {
             Map<String, String> updatedConfig = new HashMap<>(standardParameters());
@@ -668,7 +826,7 @@ public void shouldFailDueToInvalidSchemaPath() {
     @Test
     public void shouldFailDueToMissingSchemaPathForAvro() {
         Map<String, String> configs = new HashMap<>();
-        configs.put(ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE, "AVRO");
+        configs.put(RECORD_KEY_EVALUATOR_TYPE, "AVRO");
 
         ConfigException ce =
                 assertThrows(
@@ -678,7 +836,7 @@ public void shouldFailDueToMissingSchemaPathForAvro() {
                         "Specify a valid value either for [record.key.evaluator.schema.path] or [record.key.evaluator.schema.registry.enable]");
 
         Map<String, String> configs2 = new HashMap<>();
-        configs2.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE, "AVRO");
+        configs2.put(RECORD_VALUE_EVALUATOR_TYPE, "AVRO");
 
         ce =
                 assertThrows(
@@ -691,10 +849,10 @@ public void shouldFailDueToMissingSchemaPathForAvro() {
     @Test
     public void shouldGetOverridenGroupId() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.GROUP_ID, "group-id");
+        updatedConfig.put(GROUP_ID, "group-id");
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
 
-        assertThat(config.getText(ConnectorConfig.GROUP_ID)).isEqualTo("group-id");
+        assertThat(config.getText(GROUP_ID)).isEqualTo("group-id");
     }
 
     @Test
@@ -745,11 +903,11 @@ void shouldGetItemTemplateConfigs() {
 
         TemplateExpression te1 = templateConfigs.getExpression("template1");
         assertThat(te1.prefix()).isEqualTo("item1");
-        assertThat(te1.params()).containsExactly("param1", Expressions.expression("VALUE.value1"));
+        assertThat(te1.params()).containsExactly("param1", Expressions.Expression("VALUE.value1"));
 
         TemplateExpression te2 = templateConfigs.getExpression("template2");
         assertThat(te2.prefix()).isEqualTo("item2");
-        assertThat(te2.params()).containsExactly("param2", Expressions.expression("VALUE.value2"));
+        assertThat(te2.params()).containsExactly("param2", Expressions.Expression("VALUE.value2"));
     }
 
     @Test
@@ -763,17 +921,16 @@ void shouldGetFieldConfigs() {
     @Test
     public void shouldGetHostList() {
         ConnectorConfig config = ConnectorConfigProvider.minimal();
-        assertThat(config.getHostsList(ConnectorConfig.BOOTSTRAP_SERVERS))
-                .isEqualTo("server:8080,server:8081");
+        assertThat(config.getHostsList(BOOTSTRAP_SERVERS)).isEqualTo("server:8080,server:8081");
     }
 
     @Test
     public void shouldGetDefaultText() {
         ConnectorConfig config = ConnectorConfigProvider.minimal();
-        assertThat(config.getText(ConnectorConfig.ADAPTERS_CONF_ID)).isEqualTo("KAFKA");
-        assertThat(config.getText(ConnectorConfig.DATA_ADAPTER_NAME)).isEqualTo("CONNECTOR");
-        assertThat(config.getText(ConnectorConfig.ITEM_INFO_NAME)).isEqualTo("INFO");
-        assertThat(config.getText(ConnectorConfig.ITEM_INFO_FIELD)).isEqualTo("MSG");
+        assertThat(config.getText(ADAPTERS_CONF_ID)).isEqualTo("KAFKA");
+        assertThat(config.getText(DATA_ADAPTER_NAME)).isEqualTo("CONNECTOR");
+        assertThat(config.getText(ITEM_INFO_NAME)).isEqualTo("INFO");
+        assertThat(config.getText(ITEM_INFO_FIELD)).isEqualTo("MSG");
     }
 
     @Test
@@ -783,7 +940,7 @@ public void shouldGetEnabled() {
         assertThat(config.isEnabled()).isTrue();
 
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.ENABLE, "false");
+        updatedConfig.put(ENABLE, "false");
         config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
         assertThat(config.isEnabled()).isFalse();
     }
@@ -794,9 +951,9 @@ public void shouldOverrideConsumeEventsFrom() {
                 ConnectorConfig.newConfig(adapterDir.toFile(), standardParameters());
 
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_CONSUME_FROM, "EARLIEST");
+        updatedConfig.put(RECORD_CONSUME_FROM, "EARLIEST");
         config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
-        assertThat(config.getRecordConsumeFrom()).isEqualTo(RecordComsumeFrom.EARLIEST);
+        assertThat(config.getRecordConsumeFrom()).isEqualTo(EARLIEST);
         assertThat(config.baseConsumerProps())
                 .containsAtLeast(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
     }
@@ -818,33 +975,92 @@ public void shouldGetAuthenticationEnabled() {
     @Test
     public void shouldGetDefaultEvaluator() {
         ConnectorConfig config = ConnectorConfigProvider.minimal();
-        assertThat(config.getKeyEvaluator()).isEqualTo(EvaluatorType.STRING);
-        assertThat(config.getValueEvaluator()).isEqualTo(EvaluatorType.STRING);
+        assertThat(config.getKeyEvaluator()).isEqualTo(STRING);
+        assertThat(config.getValueEvaluator()).isEqualTo(STRING);
 
         assertThat(config.isSchemaRegistryEnabledForKey()).isFalse();
-        assertThat(config.isSchemaRegistryEnabledForKey()).isFalse();
+        assertThat(config.isSchemaRegistryEnabledForValue()).isFalse();
         assertThat(config.isSchemaRegistryEnabled()).isFalse();
+        assertThat(config.hasKeySchemaFile()).isFalse();
+        assertThat(config.hasValueSchemaFile()).isFalse();
+        assertThat(config.hasSchemaFile()).isFalse();
     }
 
     @Test
     public void shouldGetErrorStrategy() {
         ConnectorConfig config = ConnectorConfigProvider.minimal();
         assertThat(config.getRecordExtractionErrorHandlingStrategy())
-                .isEqualTo(RecordErrorHandlingStrategy.IGNORE_AND_CONTINUE);
+                .isEqualTo(IGNORE_AND_CONTINUE);
 
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
         updatedConfig.put(
-                ConnectorConfig.RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY,
-                RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION.toString());
+                RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY, FORCE_UNSUBSCRIPTION.toString());
         config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
         assertThat(config.getRecordExtractionErrorHandlingStrategy())
-                .isEqualTo(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION);
+                .isEqualTo(FORCE_UNSUBSCRIPTION);
+    }
+
+    @Test
+    public void shouldFailDueToInvalidErrorStrategyType() {
+        Map<String, String> updatedConfig = new HashMap<>(standardParameters());
+        updatedConfig.put(RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY, "invalidType");
+        ConfigException e =
+                assertThrows(
+                        ConfigException.class,
+                        () -> ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig));
+        assertThat(e.getMessage())
+                .isEqualTo(
+                        "Specify a valid value for parameter ["
+                                + RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY
+                                + "]");
+    }
+
+    @Test
+    public void shouldGetRecordConsumeWithOrderStrategy() {
+        ConnectorConfig config = ConnectorConfigProvider.minimal();
+        assertThat(config.getRecordConsumeWithOrderStrategy())
+                .isEqualTo(RecordConsumeWithOrderStrategy.ORDER_BY_PARTITION);
+
+        Map<String, String> updatedConfig = new HashMap<>(standardParameters());
+        updatedConfig.put(
+                RECORD_CONSUME_WITH_ORDER_STRATEGY,
+                RecordConsumeWithOrderStrategy.ORDER_BY_KEY.toString());
+        config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
+        assertThat(config.getRecordConsumeWithOrderStrategy())
+                .isEqualTo(RecordConsumeWithOrderStrategy.ORDER_BY_KEY);
+    }
+
+    @Test
+    public void shouldFaileDueToInvalidOrderStrategyType() {
+        Map<String, String> updatedConfig = new HashMap<>(standardParameters());
+        updatedConfig.put(RECORD_CONSUME_WITH_ORDER_STRATEGY, "invalidType");
+        ConfigException e =
+                assertThrows(
+                        ConfigException.class,
+                        () -> ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig));
+        assertThat(e.getMessage())
+                .isEqualTo(
+                        "Specify a valid value for parameter ["
+                                + RECORD_CONSUME_WITH_ORDER_STRATEGY
+                                + "]");
     }
 
     @Test
-    public void shouldFailDueToInvalidErrorStragetyType() {
+    public void shouldGetRecordConsumeWithThreadsNumber() {
+        ConnectorConfig config = ConnectorConfigProvider.minimal();
+        assertThat(config.getRecordConsumeWithNumThreads()).isEqualTo(1);
+
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY, "invalidType");
+        updatedConfig.put(RECORD_CONSUME_WITH_NUM_THREADS, "10");
+        config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
+        assertThat(config.getRecordConsumeWithNumThreads()).isEqualTo(10);
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -2})
+    public void shouldFailDueToInvalidRecordConsumeWithThreadsNumber(int invalidThreadsNumber) {
+        Map<String, String> updatedConfig = new HashMap<>(standardParameters());
+        updatedConfig.put(RECORD_CONSUME_WITH_NUM_THREADS, String.valueOf(invalidThreadsNumber));
         ConfigException e =
                 assertThrows(
                         ConfigException.class,
@@ -852,46 +1068,50 @@ public void shouldFailDueToInvalidErrorStragetyType() {
         assertThat(e.getMessage())
                 .isEqualTo(
                         "Specify a valid value for parameter ["
-                                + ConnectorConfig.RECORD_EXTRACTION_ERROR_HANDLING_STRATEGY
+                                + RECORD_CONSUME_WITH_NUM_THREADS
                                 + "]");
     }
 
     @Test
     public void shouldGetDirectory() {
         ConnectorConfig config = ConnectorConfigProvider.minimal(adapterDir.toString());
-        assertThat(config.getDirectory(ConnectorConfig.ADAPTER_DIR))
-                .isEqualTo(adapterDir.toString());
+        assertThat(config.getDirectory(ADAPTER_DIR)).isEqualTo(adapterDir.toString());
     }
 
     @Test
     public void shouldGetFiles() {
         ConnectorConfig config =
                 ConnectorConfig.newConfig(adapterDir.toFile(), standardParameters());
-        assertThat(config.getFile(ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH))
+        assertThat(config.getFile(RECORD_KEY_EVALUATOR_SCHEMA_PATH))
                 .isEqualTo(keySchemaFile.toString());
-        assertThat(config.getFile(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH))
+        assertThat(config.getFile(RECORD_VALUE_EVALUATOR_SCHEMA_PATH))
                 .isEqualTo(valueSchemaFile.toString());
+        assertThat(config.hasKeySchemaFile()).isTrue();
+        assertThat(config.hasValueSchemaFile()).isTrue();
+        assertThat(config.hasSchemaFile()).isTrue();
     }
 
     @Test
     public void shouldGetNotExistingNonRequiredFiles() {
         ConnectorConfig config = ConnectorConfigProvider.minimal(adapterDir.toString());
-        assertThat(config.getFile(ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH)).isNull();
-        assertThat(config.getFile(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH)).isNull();
+        assertThat(config.getFile(RECORD_KEY_EVALUATOR_SCHEMA_PATH)).isNull();
+        assertThat(config.getFile(RECORD_VALUE_EVALUATOR_SCHEMA_PATH)).isNull();
+        assertThat(config.hasKeySchemaFile()).isFalse();
+        assertThat(config.hasValueSchemaFile()).isFalse();
+        assertThat(config.hasSchemaFile()).isFalse();
     }
 
     @Test
     public void shouldNoGetNonExistingNonRequiredInt() {
         ConnectorConfig config = ConnectorConfigProvider.minimal();
-        assertThat(config.getInt(ConnectorConfig.CONSUMER_FETCH_MAX_BYTES_CONFIG)).isNull();
-        assertThat(config.getInt(ConnectorConfig.CONSUMER_FETCH_MAX_WAIT_MS_CONFIG)).isNull();
-        assertThat(config.getInt(ConnectorConfig.CONSUMER_FETCH_MIN_BYTES_CONFIG)).isNull();
-        assertThat(config.getInt(ConnectorConfig.CONSUMER_RECONNECT_BACKOFF_MAX_MS_CONFIG))
-                .isNull();
-        assertThat(config.getInt(ConnectorConfig.CONSUMER_RECONNECT_BACKOFF_MS_CONFIG)).isNull();
-        assertThat(config.getInt(ConnectorConfig.CONSUMER_HEARTBEAT_INTERVAL_MS)).isNull();
-        assertThat(config.getInt(ConnectorConfig.CONSUMER_MAX_POLL_RECORDS)).isNull();
-        assertThat(config.getInt(ConnectorConfig.CONSUMER_SESSION_TIMEOUT_MS)).isNull();
+        assertThat(config.getInt(CONSUMER_FETCH_MAX_BYTES_CONFIG)).isNull();
+        assertThat(config.getInt(CONSUMER_FETCH_MAX_WAIT_MS_CONFIG)).isNull();
+        assertThat(config.getInt(CONSUMER_FETCH_MIN_BYTES_CONFIG)).isNull();
+        assertThat(config.getInt(CONSUMER_RECONNECT_BACKOFF_MAX_MS_CONFIG)).isNull();
+        assertThat(config.getInt(CONSUMER_RECONNECT_BACKOFF_MS_CONFIG)).isNull();
+        assertThat(config.getInt(CONSUMER_HEARTBEAT_INTERVAL_MS)).isNull();
+        assertThat(config.getInt(CONSUMER_MAX_POLL_RECORDS)).isNull();
+        assertThat(config.getInt(CONSUMER_SESSION_TIMEOUT_MS)).isNull();
     }
 
     @Test
@@ -924,7 +1144,7 @@ public void shouldNotAccessToEncryptionSettings() {
     @Test
     public void shouldSpecifyEncryptionParametersWhenRequired() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.ENCYRPTION_ENABLE, "true");
+        updatedConfig.put(ENCYRPTION_ENABLE, "true");
 
         updatedConfig.put(EncryptionConfigs.TRUSTSTORE_PATH, "");
         ConfigException ce =
@@ -1170,7 +1390,7 @@ public void shouldOverrideKeystoreSettings() {
     @Test
     public void shouldSpecifyAuthenticationRequiredParameters() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.AUTHENTICATION_ENABLE, "true");
+        updatedConfig.put(AUTHENTICATION_ENABLE, "true");
 
         updatedConfig.put(BrokerAuthenticationConfigs.SASL_MECHANISM, "invalid");
         ConfigException ce =
@@ -1189,7 +1409,7 @@ public void shouldSpecifyAuthenticationRequiredParameters() {
         assertThat(ce.getMessage())
                 .isEqualTo("Missing required parameter [authentication.username]");
 
-        updatedConfig.put(BrokerAuthenticationConfigs.USERNAME, "");
+        updatedConfig.put(USERNAME, "");
         ce =
                 assertThrows(
                         ConfigException.class,
@@ -1197,7 +1417,7 @@ public void shouldSpecifyAuthenticationRequiredParameters() {
         assertThat(ce.getMessage())
                 .isEqualTo("Specify a valid value for parameter [authentication.username]");
 
-        updatedConfig.put(BrokerAuthenticationConfigs.USERNAME, "username");
+        updatedConfig.put(USERNAME, "username");
         ce =
                 assertThrows(
                         ConfigException.class,
@@ -1205,7 +1425,7 @@ public void shouldSpecifyAuthenticationRequiredParameters() {
         assertThat(ce.getMessage())
                 .isEqualTo("Missing required parameter [authentication.password]");
 
-        updatedConfig.put(BrokerAuthenticationConfigs.PASSWORD, "");
+        updatedConfig.put(PASSWORD, "");
         ce =
                 assertThrows(
                         ConfigException.class,
@@ -1213,7 +1433,7 @@ public void shouldSpecifyAuthenticationRequiredParameters() {
         assertThat(ce.getMessage())
                 .isEqualTo("Specify a valid value for parameter [authentication.password]");
 
-        updatedConfig.put(BrokerAuthenticationConfigs.PASSWORD, "password");
+        updatedConfig.put(PASSWORD, "password");
         assertDoesNotThrow(() -> ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig));
     }
 
@@ -1306,7 +1526,7 @@ public void shouldOverrideAuthenticationSettings() {
     @Test
     public void shouldSpecifyGssapiAuthenticationRequiredParameters() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.AUTHENTICATION_ENABLE, "true");
+        updatedConfig.put(AUTHENTICATION_ENABLE, "true");
         updatedConfig.put(BrokerAuthenticationConfigs.SASL_MECHANISM, "GSSAPI");
 
         ConfigException ce =
@@ -1349,7 +1569,7 @@ public void shouldSpecifyGssapiAuthenticationRequiredParameters() {
     @Test
     public void shouldGetDefaultGssapiAuthenticationSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.AUTHENTICATION_ENABLE, "true");
+        updatedConfig.put(AUTHENTICATION_ENABLE, "true");
         updatedConfig.put(BrokerAuthenticationConfigs.SASL_MECHANISM, "GSSAPI");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_PRINCIPAL, "kafka-user");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_KERBEROS_SERVICE_NAME, "kafka");
@@ -1378,7 +1598,7 @@ public void shouldGetDefaultGssapiAuthenticationSettings() {
     @Test
     public void shouldOverrideGssapiAuthenticationSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.AUTHENTICATION_ENABLE, "true");
+        updatedConfig.put(AUTHENTICATION_ENABLE, "true");
         updatedConfig.put(BrokerAuthenticationConfigs.SASL_MECHANISM, "GSSAPI");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_KERBEROS_SERVICE_NAME, "kafka");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_PRINCIPAL, "kafka-user");
@@ -1413,7 +1633,7 @@ public void shouldOverrideGssapiAuthenticationSettings() {
     @Test
     public void shouldOverrideGssapiAuthenticationSettingsWithTicketCache() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.AUTHENTICATION_ENABLE, "true");
+        updatedConfig.put(AUTHENTICATION_ENABLE, "true");
         updatedConfig.put(BrokerAuthenticationConfigs.SASL_MECHANISM, "GSSAPI");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_KERBEROS_SERVICE_NAME, "kafka");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_TICKET_CACHE_ENABLE, "true");
@@ -1445,7 +1665,7 @@ public void shouldOverrideGssapiAuthenticationSettingsWithTicketCache() {
     @Test
     public void shouldNotValidateWhenKeyTabIsNotSpecified() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.AUTHENTICATION_ENABLE, "true");
+        updatedConfig.put(AUTHENTICATION_ENABLE, "true");
         updatedConfig.put(BrokerAuthenticationConfigs.SASL_MECHANISM, "GSSAPI");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_PRINCIPAL, "kafka-user");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_KERBEROS_SERVICE_NAME, "kafka");
@@ -1478,7 +1698,7 @@ public void shouldNotValidateWhenKeyTabIsNotSpecified() {
     @Test
     public void shouldNotValidateWhenPrincipalIsNotSpecifiedAndNotUseTicketCache() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.AUTHENTICATION_ENABLE, "true");
+        updatedConfig.put(AUTHENTICATION_ENABLE, "true");
         updatedConfig.put(BrokerAuthenticationConfigs.SASL_MECHANISM, "GSSAPI");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_PRINCIPAL, "kafka-user");
         updatedConfig.put(BrokerAuthenticationConfigs.GSSAPI_KERBEROS_SERVICE_NAME, "kafka");
@@ -1539,8 +1759,8 @@ public void shouldNotAccessToSchemaRegistrySettings() {
     @ParameterizedTest
     @ValueSource(
             strings = {
-                ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE
+                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE
             })
     public void shouldSpecifyRequiredSchemaRegistryParameters(String evaluatorKey) {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
@@ -1552,15 +1772,15 @@ public void shouldSpecifyRequiredSchemaRegistryParameters(String evaluatorKey) {
                         () -> ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig));
         assertThat(ce.getMessage()).isEqualTo("Missing required parameter [schema.registry.url]");
 
-        updatedConfig.put(SchemaRegistryConfigs.URL, "http://localhost:8080");
+        updatedConfig.put(URL, "http://localhost:8080");
         assertDoesNotThrow(() -> ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig));
     }
 
     @Test
     public void shouldNotAccessToSchemaRegistryEncryptionSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
-        updatedConfig.put(SchemaRegistryConfigs.URL, "http://localhost:8080");
+        updatedConfig.put(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
+        updatedConfig.put(URL, "http://localhost:8080");
 
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
         assertThat(config.schemaRegistryUrl()).isEqualTo("http://localhost:8080");
@@ -1588,8 +1808,8 @@ public void shouldNotAccessToSchemaRegistryEncryptionSettings() {
     @Test
     public void shouldGetDefaultSchemaRegistryEncryptionSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
-        updatedConfig.put(SchemaRegistryConfigs.URL, "https://localhost:8080");
+        updatedConfig.put(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
+        updatedConfig.put(URL, "https://localhost:8080");
 
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
         assertThat(config.schemaRegistryUrl()).isEqualTo("https://localhost:8080");
@@ -1639,18 +1859,17 @@ public void shouldGetDefaultSchemaRegistryEncryptionSettings() {
     @Test
     public void shouldOverrideSchemaRegistryEncryptionSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
-        updatedConfig.put(SchemaRegistryConfigs.URL, "https://localhost:8080");
-        updatedConfig.put(
-                SchemaRegistryConfigs.TRUSTSTORE_PATH, trustStoreFile.getFileName().toString());
-        updatedConfig.put(SchemaRegistryConfigs.TRUSTSTORE_PASSWORD, "truststore-password");
-        updatedConfig.put(SchemaRegistryConfigs.SSL_ENABLED_PROTOCOLS, "TLSv1.2");
-        updatedConfig.put(SchemaRegistryConfigs.SSL_PROTOCOL, "TLSv1.2");
-        updatedConfig.put(SchemaRegistryConfigs.TRUSTSTORE_TYPE, "PKCS12");
+        updatedConfig.put(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
+        updatedConfig.put(URL, "https://localhost:8080");
+        updatedConfig.put(TRUSTSTORE_PATH, trustStoreFile.getFileName().toString());
+        updatedConfig.put(TRUSTSTORE_PASSWORD, "truststore-password");
+        updatedConfig.put(SSL_ENABLED_PROTOCOLS, "TLSv1.2");
+        updatedConfig.put(SSL_PROTOCOL, "TLSv1.2");
+        updatedConfig.put(TRUSTSTORE_TYPE, "PKCS12");
         updatedConfig.put(
-                SchemaRegistryConfigs.SSL_CIPHER_SUITES,
+                SSL_CIPHER_SUITES,
                 "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,TLS_RSA_WITH_AES_256_CBC_SHA");
-        updatedConfig.put(SchemaRegistryConfigs.HOSTNAME_VERIFICATION_ENANLE, "true");
+        updatedConfig.put(HOSTNAME_VERIFICATION_ENANLE, "true");
 
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
 
@@ -1693,12 +1912,11 @@ public void shouldOverrideSchemaRegistryEncryptionSettings() {
     @Test
     public void shouldGetDefaultSchemaRegistryKeystoreSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
-        updatedConfig.put(SchemaRegistryConfigs.URL, "https://localhost:8080");
-        updatedConfig.put(SchemaRegistryConfigs.KEYSTORE_ENABLE, "true");
-        updatedConfig.put(
-                SchemaRegistryConfigs.KEYSTORE_PATH, keyStoreFile.getFileName().toString());
-        updatedConfig.put(SchemaRegistryConfigs.KEYSTORE_PASSWORD, "keystore-password");
+        updatedConfig.put(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
+        updatedConfig.put(URL, "https://localhost:8080");
+        updatedConfig.put(KEYSTORE_ENABLE, "true");
+        updatedConfig.put(KEYSTORE_PATH, keyStoreFile.getFileName().toString());
+        updatedConfig.put(KEYSTORE_PASSWORD, "keystore-password");
 
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
 
@@ -1724,20 +1942,19 @@ public void shouldGetDefaultSchemaRegistryKeystoreSettings() {
     @Test
     public void shouldOverrideSchemaRegistryKeystoreSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
-        updatedConfig.put(SchemaRegistryConfigs.URL, "https://localhost:8080");
-        updatedConfig.put(SchemaRegistryConfigs.KEYSTORE_ENABLE, "true");
-        updatedConfig.put(SchemaRegistryConfigs.KEYSTORE_TYPE, "PKCS12");
-        updatedConfig.put(
-                SchemaRegistryConfigs.KEYSTORE_PATH, keyStoreFile.getFileName().toString());
-        updatedConfig.put(SchemaRegistryConfigs.KEYSTORE_PASSWORD, "keystore-password");
+        updatedConfig.put(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
+        updatedConfig.put(URL, "https://localhost:8080");
+        updatedConfig.put(KEYSTORE_ENABLE, "true");
+        updatedConfig.put(KEYSTORE_TYPE, "PKCS12");
+        updatedConfig.put(KEYSTORE_PATH, keyStoreFile.getFileName().toString());
+        updatedConfig.put(KEYSTORE_PASSWORD, "keystore-password");
 
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
 
         assertThat(config.isSchemaRegistryKeystoreEnabled()).isTrue();
         assertThat(config.schemaRegistryKeystoreType().toString()).isEqualTo("PKCS12");
 
-        updatedConfig.put(SchemaRegistryConfigs.KEY_PASSWORD, "");
+        updatedConfig.put(KEY_PASSWORD, "");
         ConfigException ce =
                 assertThrows(
                         ConfigException.class,
@@ -1746,7 +1963,7 @@ public void shouldOverrideSchemaRegistryKeystoreSettings() {
                 .isEqualTo(
                         "Specify a valid value for parameter [schema.registry.encryption.keystore.key.password]");
 
-        updatedConfig.put(SchemaRegistryConfigs.KEY_PASSWORD, "key-password");
+        updatedConfig.put(KEY_PASSWORD, "key-password");
         config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
         assertThat(config.schemaRegistryKeyPassword()).isEqualTo("key-password");
 
@@ -1766,8 +1983,8 @@ public void shouldOverrideSchemaRegistryKeystoreSettings() {
     @Test
     public void shouldNotAccessToSchemaRegistryBasicAuthenticationSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
-        updatedConfig.put(SchemaRegistryConfigs.URL, "http://localhost:8080");
+        updatedConfig.put(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
+        updatedConfig.put(URL, "http://localhost:8080");
 
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
         assertThat(config.isSchemaRegistryBasicAuthenticationEnabled()).isFalse();
@@ -1787,9 +2004,9 @@ public void shouldNotAccessToSchemaRegistryBasicAuthenticationSettings() {
     @Test
     public void shouldGetSchemaRegistryBasicAuthenticationSettings() {
         Map<String, String> updatedConfig = new HashMap<>(standardParameters());
-        updatedConfig.put(ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
-        updatedConfig.put(SchemaRegistryConfigs.URL, "http://localhost:8080");
-        updatedConfig.put(SchemaRegistryConfigs.ENABLE_BASIC_AUTHENTICATION, "true");
+        updatedConfig.put(RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE, "true");
+        updatedConfig.put(URL, "http://localhost:8080");
+        updatedConfig.put(ENABLE_BASIC_AUTHENTICATION, "true");
 
         ConfigException ce =
                 assertThrows(
@@ -1799,7 +2016,7 @@ public void shouldGetSchemaRegistryBasicAuthenticationSettings() {
                 .isEqualTo(
                         "Missing required parameter [schema.registry.basic.authentication.username]");
 
-        updatedConfig.put(SchemaRegistryConfigs.BASIC_AUTHENTICATION_USER_NAME, "");
+        updatedConfig.put(BASIC_AUTHENTICATION_USER_NAME, "");
         ce =
                 assertThrows(
                         ConfigException.class,
@@ -1808,7 +2025,7 @@ public void shouldGetSchemaRegistryBasicAuthenticationSettings() {
                 .isEqualTo(
                         "Specify a valid value for parameter [schema.registry.basic.authentication.username]");
 
-        updatedConfig.put(SchemaRegistryConfigs.BASIC_AUTHENTICATION_USER_NAME, "username");
+        updatedConfig.put(BASIC_AUTHENTICATION_USER_NAME, "username");
         ce =
                 assertThrows(
                         ConfigException.class,
@@ -1817,7 +2034,7 @@ public void shouldGetSchemaRegistryBasicAuthenticationSettings() {
                 .isEqualTo(
                         "Missing required parameter [schema.registry.basic.authentication.password]");
 
-        updatedConfig.put(SchemaRegistryConfigs.BASIC_AUTHENTICATION_USER_PASSWORD, "");
+        updatedConfig.put(BASIC_AUTHENTICATION_USER_PASSWORD, "");
         ce =
                 assertThrows(
                         ConfigException.class,
@@ -1826,7 +2043,7 @@ public void shouldGetSchemaRegistryBasicAuthenticationSettings() {
                 .isEqualTo(
                         "Specify a valid value for parameter [schema.registry.basic.authentication.password]");
 
-        updatedConfig.put(SchemaRegistryConfigs.BASIC_AUTHENTICATION_USER_PASSWORD, "password");
+        updatedConfig.put(BASIC_AUTHENTICATION_USER_PASSWORD, "password");
 
         ConnectorConfig config = ConnectorConfig.newConfig(adapterDir.toFile(), updatedConfig);
         assertThat(config.isSchemaRegistryBasicAuthenticationEnabled()).isTrue();
@@ -1836,9 +2053,9 @@ public void shouldGetSchemaRegistryBasicAuthenticationSettings() {
         Properties props = config.baseConsumerProps();
         assertThat(props)
                 .containsAtLeast(
-                        SchemaRegistryClientConfig.BASIC_AUTH_CREDENTIALS_SOURCE,
+                        BASIC_AUTH_CREDENTIALS_SOURCE,
                         "USER_INFO",
-                        SchemaRegistryClientConfig.USER_INFO_CONFIG,
+                        USER_INFO_CONFIG,
                         "username:password");
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/ConsumerLoopTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/ConsumerLoopTest.java
deleted file mode 100644
index 1760c9f2..00000000
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/ConsumerLoopTest.java
+++ /dev/null
@@ -1,167 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.adapters.consumers;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-import com.lightstreamer.interfaces.data.SubscriptionException;
-import com.lightstreamer.kafka.adapters.ConnectorConfigurator.ConsumerLoopConfig;
-import com.lightstreamer.kafka.adapters.commons.MetadataListener;
-import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
-import com.lightstreamer.kafka.common.config.TopicConfigurations;
-import com.lightstreamer.kafka.common.config.TopicConfigurations.ItemTemplateConfigs;
-import com.lightstreamer.kafka.common.config.TopicConfigurations.TopicMappingConfig;
-import com.lightstreamer.kafka.common.mapping.Items;
-import com.lightstreamer.kafka.common.mapping.Items.Item;
-import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
-import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
-import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
-
-import org.apache.kafka.common.serialization.Deserializer;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-import java.util.Properties;
-
-class TestMetadataListener implements MetadataListener {
-
-    @Override
-    public void forceUnsubscription(String item) {}
-
-    @Override
-    public void forceUnsubscriptionAll() {}
-}
-
-class TestConsumerLoopTest extends AbstractConsumerLoop<String, String> {
-
-    TestConsumerLoopTest(ConsumerLoopConfig<String, String> config) {
-        super(config);
-    }
-
-    @Override
-    void stopConsuming() {}
-
-    @Override
-    public void unsubscribeInfoItem() {}
-
-    @Override
-    void startConsuming() throws SubscriptionException {}
-}
-
-class TestLoopConfig implements ConsumerLoopConfig<String, String> {
-
-    private final TopicConfigurations topicsConfig;
-
-    TestLoopConfig(TopicConfigurations topicsConfig) {
-        this.topicsConfig = topicsConfig;
-    }
-
-    @Override
-    public Properties consumerProperties() {
-        return new Properties();
-    }
-
-    @Override
-    public DataExtractor<String, String> fieldsExtractor() {
-        throw new UnsupportedOperationException("Unimplemented method 'fieldMappings'");
-    }
-
-    @Override
-    public ItemTemplates<String, String> itemTemplates() {
-        try {
-            return Items.from(topicsConfig, TestSelectorSuppliers.string());
-        } catch (ExtractionException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    @Override
-    public Deserializer<String> keyDeserializer() {
-        throw new UnsupportedOperationException("Unimplemented method 'keyDeserializer'");
-    }
-
-    @Override
-    public Deserializer<String> valueDeserializer() {
-        throw new UnsupportedOperationException("Unimplemented method 'valueDeserializer'");
-    }
-
-    @Override
-    public RecordErrorHandlingStrategy recordErrorHandlingStrategy() {
-        return RecordErrorHandlingStrategy.IGNORE_AND_CONTINUE;
-    }
-
-    @Override
-    public String connectionName() {
-        return "TestConnection";
-    }
-}
-
-public class ConsumerLoopTest {
-
-    private static TestConsumerLoopTest consumerLoopTest() {
-        TopicConfigurations topicsConfig =
-                TopicConfigurations.of(
-                        ItemTemplateConfigs.empty(),
-                        List.of(
-                                TopicMappingConfig.fromDelimitedMappings(
-                                        "aTopic", "anItemTemplate")));
-        ConsumerLoopConfig<String, String> c = new TestLoopConfig(topicsConfig);
-
-        TestConsumerLoopTest consumerLoopTest = new TestConsumerLoopTest(c);
-        return consumerLoopTest;
-    }
-
-    @Test
-    public void shouldSubscribe() throws SubscriptionException {
-        TestConsumerLoopTest consumerLoopTest = consumerLoopTest();
-        assertThat(consumerLoopTest.getItemsCounter()).isEqualTo(0);
-        Object itemHandle = new Object();
-        Item item = consumerLoopTest.subscribe("anItemTemplate", itemHandle);
-        assertThat(item).isEqualTo(Items.susbcribedFrom("anItemTemplate", itemHandle));
-        assertThat(consumerLoopTest.getItemsCounter()).isEqualTo(1);
-    }
-
-    @Test
-    public void shouldNotSubscribe() {
-        TestConsumerLoopTest consumerLoopTest = consumerLoopTest();
-        Object itemHandle = new Object();
-        assertThrows(
-                SubscriptionException.class,
-                () -> consumerLoopTest.subscribe("unregisteredTemplate", itemHandle));
-    }
-
-    @Test
-    public void shouldUnsubscribe() throws SubscriptionException {
-        TestConsumerLoopTest consumerLoopTest = consumerLoopTest();
-        Object itemHandle = new Object();
-        Item item = consumerLoopTest.subscribe("anItemTemplate", itemHandle);
-        Item removed = consumerLoopTest.unsubscribe("anItemTemplate");
-        assertThat(removed).isSameInstanceAs(item);
-        assertThat(consumerLoopTest.getItemsCounter()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldNotUnsubscribe() {
-        TestConsumerLoopTest consumerLoopTest = consumerLoopTest();
-        assertThrows(
-                SubscriptionException.class, () -> consumerLoopTest.unsubscribe("anItemTemplate"));
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTriggerTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTriggerTest.java
new file mode 100644
index 00000000..a1dd0166
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/ConsumerTriggerTest.java
@@ -0,0 +1,184 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.common.config.TopicConfigurations.TopicMappingConfig.fromDelimitedMappings;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import com.lightstreamer.interfaces.data.SubscriptionException;
+import com.lightstreamer.kafka.adapters.commons.MetadataListener;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig;
+import com.lightstreamer.kafka.adapters.consumers.wrapper.ConsumerWrapper;
+import com.lightstreamer.kafka.common.config.TopicConfigurations;
+import com.lightstreamer.kafka.common.config.TopicConfigurations.ItemTemplateConfigs;
+import com.lightstreamer.kafka.common.mapping.Items;
+import com.lightstreamer.kafka.common.mapping.Items.Item;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+import com.lightstreamer.kafka.test_utils.Mocks;
+import com.lightstreamer.kafka.test_utils.Mocks.MockConsumerWrapper;
+import com.lightstreamer.kafka.test_utils.Mocks.MockMetadataListener;
+
+import org.apache.kafka.common.KafkaException;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+
+public class ConsumerTriggerTest {
+
+    private static ConsumerTriggerImpl<?, ?> mkConsumerTrigger(
+            MetadataListener metadataListener,
+            ConsumerWrapper<String, String> consumer,
+            boolean throwExceptionWhileConnectingToKafka) {
+        TopicConfigurations topicsConfig =
+                TopicConfigurations.of(
+                        ItemTemplateConfigs.empty(),
+                        List.of(
+                                fromDelimitedMappings(
+                                        "aTopic", "anItemTemplate,anotherItemTemplate")));
+        ConsumerTriggerConfig<String, String> config = new Mocks.MockTriggerConfig(topicsConfig);
+
+        Function<Collection<SubscribedItem>, ConsumerWrapper<String, String>> consumerWrapper =
+                items -> {
+                    if (throwExceptionWhileConnectingToKafka) {
+                        throw new KafkaException("Simulated Exception");
+                    }
+                    return consumer;
+                };
+        return new ConsumerTriggerImpl<>(config, metadataListener, consumerWrapper);
+    }
+
+    private ConsumerTriggerImpl<?, ?> consumerTrigger;
+    private MockMetadataListener metadataListener;
+    private MockConsumerWrapper<String, String> kafkaConsumer;
+
+    void init() {
+        init(false);
+    }
+
+    void init(boolean throwExceptionWhileConnectingToKafka) {
+        kafkaConsumer = new Mocks.MockConsumerWrapper<>();
+        metadataListener = new Mocks.MockMetadataListener();
+        consumerTrigger =
+                mkConsumerTrigger(
+                        metadataListener, kafkaConsumer, throwExceptionWhileConnectingToKafka);
+        assertThat(consumerTrigger.getItemsCounter()).isEqualTo(0);
+    }
+
+    @Test
+    public void shouldSubscribe() throws SubscriptionException {
+        init();
+        Object itemHandle1 = new Object();
+        Object itemHandle2 = new Object();
+
+        CompletableFuture<Void> consuming1 =
+                consumerTrigger.subscribe("anItemTemplate", itemHandle1);
+        assertThat(consumerTrigger.getItemsCounter()).isEqualTo(1);
+
+        CompletableFuture<Void> consuming2 =
+                consumerTrigger.subscribe("anotherItemTemplate", itemHandle2);
+        assertThat(consumerTrigger.getItemsCounter()).isEqualTo(2);
+
+        Item item1 = consumerTrigger.getSubscribeditem("anItemTemplate");
+        assertThat(item1).isEqualTo(Items.subscribedFrom("anItemTemplate", itemHandle1));
+
+        Item item2 = consumerTrigger.getSubscribeditem("anotherItemTemplate");
+        assertThat(item2).isEqualTo(Items.subscribedFrom("anotherItemTemplate", itemHandle2));
+
+        assertThat(consuming1).isSameInstanceAs(consuming2);
+
+        consuming1.join();
+        assertThat(kafkaConsumer.hasRan()).isTrue();
+        assertThat(kafkaConsumer.isClosed()).isFalse();
+    }
+
+    @Test
+    public void shouldFailSubscriptionDueToNotRegisteredTemplate() {
+        init();
+        Object itemHandle = new Object();
+        SubscriptionException se =
+                assertThrows(
+                        SubscriptionException.class,
+                        () -> consumerTrigger.subscribe("@invalidItem@", itemHandle));
+        assertThat(se.getMessage()).isEqualTo("Invalid Item");
+    }
+
+    @Test
+    public void shouldFailSubscriptionDueInvalidExpression() {
+        init();
+        Object itemHandle = new Object();
+        assertThrows(
+                SubscriptionException.class,
+                () -> consumerTrigger.subscribe("unregisteredTemplate", itemHandle));
+    }
+
+    @Test
+    public void shouldFailSubscriptionDueToKafkaException() throws SubscriptionException {
+        init(true);
+        Object itemHandle = new Object();
+
+        CompletableFuture<Void> consuming = consumerTrigger.subscribe("anItemTemplate", itemHandle);
+        Item item = consumerTrigger.getSubscribeditem("anItemTemplate");
+
+        assertThat(item).isEqualTo(Items.subscribedFrom("anItemTemplate", itemHandle));
+        assertThat(consuming.isCompletedExceptionally());
+        assertThat(consumerTrigger.getItemsCounter()).isEqualTo(0);
+        assertThat(kafkaConsumer.hasRan()).isFalse();
+        assertThat(metadataListener.forcedUnsubscription()).isTrue();
+
+        // Since the exception might be temporary, tt is still possbile to try a new subscription.
+        consuming = consumerTrigger.subscribe("anItemTemplate", itemHandle);
+        assertThat(consuming.isCompletedExceptionally());
+    }
+
+    @Test
+    public void shouldUnsubscribe() throws SubscriptionException {
+        init();
+        Object itemHandle1 = new Object();
+        Object itemHandle2 = new Object();
+        consumerTrigger.subscribe("anItemTemplate", itemHandle1);
+        Item item1 = consumerTrigger.getSubscribeditem("anItemTemplate");
+
+        consumerTrigger.subscribe("anotherItemTemplate", itemHandle2);
+        Item item2 = consumerTrigger.getSubscribeditem("anotherItemTemplate");
+
+        Item removed1 = consumerTrigger.unsubscribe("anItemTemplate");
+        assertThat(consumerTrigger.getItemsCounter()).isEqualTo(1);
+
+        // The consumer is still alive
+        assertThat(kafkaConsumer.isClosed()).isFalse();
+
+        Item removed2 = consumerTrigger.unsubscribe("anotherItemTemplate");
+        assertThat(consumerTrigger.getItemsCounter()).isEqualTo(0);
+        assertThat(removed1).isSameInstanceAs(item1);
+        assertThat(removed2).isSameInstanceAs(item2);
+        // The consumer stops only when no more subscriptions exist.
+        assertThat(kafkaConsumer.isClosed()).isTrue();
+    }
+
+    @Test
+    public void shouldNotUnsubscribe() {
+        init();
+        assertThrows(
+                SubscriptionException.class, () -> consumerTrigger.unsubscribe("anItemTemplate"));
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/offsets/OffsetServiceTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/offsets/OffsetServiceTest.java
new file mode 100644
index 00000000..ff265439
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/offsets/OffsetServiceTest.java
@@ -0,0 +1,364 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.offsets;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.test_utils.Records.Record;
+
+import static org.apache.kafka.clients.consumer.OffsetResetStrategy.EARLIEST;
+import static org.apache.kafka.clients.consumer.OffsetResetStrategy.LATEST;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import com.lightstreamer.kafka.adapters.consumers.offsets.Offsets.OffsetService;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
+import com.lightstreamer.kafka.test_utils.Mocks;
+import com.lightstreamer.kafka.test_utils.Mocks.MockOffsetStore;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.MockConsumer;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.TopicPartition;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.time.Duration;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+
+public class OffsetServiceTest {
+
+    private static final String TOPIC = "topic";
+
+    private MockConsumer<String, String> mockConsumer;
+    private OffsetService offsetService;
+    private static final TopicPartition partition0 = new TopicPartition(TOPIC, 0);
+    private static final TopicPartition partition1 = new TopicPartition(TOPIC, 1);
+
+    @BeforeEach
+    void beforeEach() {
+        setUpFromEarliast();
+        // setUpFromLatest();
+    }
+
+    void setUpFromEarliast() {
+        setUp(true);
+    }
+
+    void setUpFromLatest() {
+        setUp(false);
+    }
+
+    private void setUp(boolean earliest) {
+        this.mockConsumer = new MockConsumer<>(earliest ? EARLIEST : LATEST);
+
+        // A rebalance must be scheduled to later use the subscribe method
+        mockConsumer.schedulePollTask(() -> mockConsumer.rebalance(Set.of(partition0, partition1)));
+
+        // Set the start offset for each partition
+        HashMap<TopicPartition, Long> offsets = new HashMap<>();
+        offsets.put(partition0, 10L);
+        offsets.put(partition1, 12L);
+        if (earliest) {
+            mockConsumer.updateBeginningOffsets(offsets);
+        } else {
+            mockConsumer.updateEndOffsets(offsets);
+        }
+
+        // Initialize the OffsetService
+        this.offsetService = Offsets.OffsetService(mockConsumer);
+
+        // Subscribe to topic specifying the OffsetService as ConsumerRebalancerListener
+        mockConsumer.subscribe(Collections.singleton(TOPIC), offsetService);
+
+        // A first poll is required to trigger partitions assignment.
+        mockConsumer.poll(Duration.ofMillis(Long.MAX_VALUE));
+    }
+
+    static Stream<Arguments> initStoreArguments() {
+        return Stream.of(
+                arguments(
+                        Collections.emptyMap(),
+                        Map.of(partition0, 10L, partition1, 12L),
+                        Map.of(
+                                partition0,
+                                new OffsetAndMetadata(10L),
+                                partition1,
+                                new OffsetAndMetadata(12L))),
+                arguments(
+                        Map.of(partition0, new OffsetAndMetadata(10L)),
+                        Map.of(partition0, 5L, partition1, 12L),
+                        Map.of(
+                                partition0,
+                                new OffsetAndMetadata(10L),
+                                partition1,
+                                new OffsetAndMetadata(12L))),
+                arguments(
+                        Map.of(partition0, new OffsetAndMetadata(2L)),
+                        Map.of(partition0, 5L, partition1, 12L),
+                        Map.of(
+                                partition0,
+                                new OffsetAndMetadata(2L),
+                                partition1,
+                                new OffsetAndMetadata(12L))),
+                arguments(
+                        Map.of(
+                                partition0,
+                                new OffsetAndMetadata(1L),
+                                partition1,
+                                new OffsetAndMetadata(7L)),
+                        Map.of(partition0, 5L, partition1, 12L),
+                        Map.of(
+                                partition0,
+                                new OffsetAndMetadata(1L),
+                                partition1,
+                                new OffsetAndMetadata(7L))));
+    }
+
+    @ParameterizedTest
+    @MethodSource("initStoreArguments")
+    void shouldInitStoreWithArguments(
+            Map<TopicPartition, OffsetAndMetadata> committed,
+            Map<TopicPartition, Long> startOffsets,
+            Map<TopicPartition, OffsetAndMetadata> expected) {
+        // Initialize the store
+        offsetService.initStore(startOffsets, committed);
+
+        // The store should have the expected initial committed repo
+        Map<TopicPartition, OffsetAndMetadata> map = offsetService.offsetStore().get().current();
+        assertThat(map).isEqualTo(expected);
+    }
+
+    @Test
+    void shouldInitStore() {
+        // Normally, the store is initialized only after the very firt poll invocation
+        offsetService.initStore(false);
+
+        Map<TopicPartition, OffsetAndMetadata> map = offsetService.offsetStore().get().current();
+        assertThat(map)
+                .containsExactly(
+                        partition0,
+                        new OffsetAndMetadata(10l),
+                        partition1,
+                        new OffsetAndMetadata(12L));
+    }
+
+    @Test
+    void shouldUpdateOffsets() {
+        // Initialize with a mocked store because we want to verify
+        // just whether records are actually saved onto it upon invoking updateOffsets.
+        offsetService.initStore(
+                Mocks.MockOffsetStore::new,
+                Map.of(partition0, 0L, partition1, 0L),
+                Collections.emptyMap());
+        MockOffsetStore store = (MockOffsetStore) offsetService.offsetStore().get();
+        assertThat(store.getRecords()).isEmpty();
+
+        ConsumerRecord<?, ?> record1 = Record(TOPIC, 0, "A-0");
+        offsetService.updateOffsets(record1);
+        ConsumerRecord<?, ?> record2 = Record(TOPIC, 0, "B-10");
+        offsetService.updateOffsets(record2);
+        assertThat(store.getRecords()).containsExactly(record1, record2);
+    }
+
+    @Test
+    void shouldStoreFirstFailure() {
+        // Notify two different exceptions
+        ValueException firstFailure = ValueException.indexOfOutBoundex(1);
+        offsetService.onAsyncFailure(firstFailure);
+        offsetService.onAsyncFailure(ValueException.noKeyFound("key"));
+        // Verify that only the first one is stored
+        assertThat(offsetService.getFirstFailure()).isSameInstanceAs(firstFailure);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    void shouldCommitySync() {
+        prepareCommittedRecords();
+
+        // Normally, the store is initialized only after the very firt poll invocation
+        offsetService.initStore(false);
+
+        // No commit happens before invocation of commitSync
+        Map<TopicPartition, OffsetAndMetadata> committed =
+                mockConsumer.committed(Set.of(partition0, partition1));
+        assertThat(committed)
+                .containsExactly(
+                        partition0,
+                        new OffsetAndMetadata(15L),
+                        partition1,
+                        new OffsetAndMetadata(16L));
+
+        // Poll two new records
+        mockConsumer.schedulePollTask(
+                () -> {
+                    mockConsumer.addRecord(
+                            (ConsumerRecord<String, String>) Record(TOPIC, 0, "A-15"));
+                    mockConsumer.addRecord(
+                            (ConsumerRecord<String, String>) Record(TOPIC, 1, "B-16"));
+                });
+        org.apache.kafka.clients.consumer.ConsumerRecords<String, String> records =
+                mockConsumer.poll(Duration.ofMillis(Long.MAX_VALUE));
+        assertThat(records.count()).isEqualTo(2);
+
+        // Update the offsets and then commit
+        records.forEach(record -> offsetService.updateOffsets(record));
+        offsetService.commitSync();
+
+        // Check the committed map
+        committed = mockConsumer.committed(Set.of(partition0, partition1));
+        assertThat(committed)
+                .containsExactly(
+                        partition0,
+                        new OffsetAndMetadata(16L),
+                        partition1,
+                        new OffsetAndMetadata(17L));
+    }
+
+    private void prepareCommittedRecords() {
+        mockConsumer.commitSync(
+                Map.of(
+                        partition0,
+                        new OffsetAndMetadata(15L),
+                        partition1,
+                        new OffsetAndMetadata(16l)));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    void shouldCommityAsync() {
+        prepareCommittedRecords();
+
+        // Normally, the store is initialized only after the very firt poll invocation
+        offsetService.initStore(false);
+
+        // No commit happens before invocation of commitSync
+        Map<TopicPartition, OffsetAndMetadata> committed =
+                mockConsumer.committed(Set.of(partition0, partition1));
+        assertThat(committed)
+                .containsExactly(
+                        partition0,
+                        new OffsetAndMetadata(15L),
+                        partition1,
+                        new OffsetAndMetadata(16L));
+
+        // Poll two new records
+        mockConsumer.schedulePollTask(
+                () -> {
+                    mockConsumer.addRecord(
+                            (ConsumerRecord<String, String>) Record(TOPIC, 0, "A-15"));
+                    mockConsumer.addRecord(
+                            (ConsumerRecord<String, String>) Record(TOPIC, 1, "B-16"));
+                });
+        org.apache.kafka.clients.consumer.ConsumerRecords<String, String> records =
+                mockConsumer.poll(Duration.ofMillis(Long.MAX_VALUE));
+        assertThat(records.count()).isEqualTo(2);
+
+        // Update the offsetns and then commit
+        records.forEach(record -> offsetService.updateOffsets(record));
+        offsetService.commitAsync();
+
+        // Check the committed map
+        committed = mockConsumer.committed(Set.of(partition0, partition1));
+        assertThat(committed)
+                .containsExactly(
+                        partition0,
+                        new OffsetAndMetadata(16L),
+                        partition1,
+                        new OffsetAndMetadata(17L));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    void shouldCommitOnPartitionRevoked() {
+        prepareCommittedRecords();
+
+        // Normally, the store is initialized only after the very firt poll invocation
+        offsetService.initStore(false);
+
+        // Poll two new records
+        mockConsumer.schedulePollTask(
+                () -> {
+                    mockConsumer.addRecord(
+                            (ConsumerRecord<String, String>) Record(TOPIC, 0, "A-15"));
+                    mockConsumer.addRecord(
+                            (ConsumerRecord<String, String>) Record(TOPIC, 1, "B-16"));
+                });
+        org.apache.kafka.clients.consumer.ConsumerRecords<String, String> records =
+                mockConsumer.poll(Duration.ofMillis(Long.MAX_VALUE));
+        assertThat(records.count()).isEqualTo(2);
+
+        // Update the offsets BUT NOT commit
+        records.forEach(record -> offsetService.updateOffsets(record));
+
+        // Trigger a rebalance, which in turn make the OffsetService invoke onPartitionsRevoked
+        mockConsumer.schedulePollTask(() -> mockConsumer.rebalance(Set.of(partition1)));
+        records = mockConsumer.poll(Duration.ofMillis(Long.MAX_VALUE));
+        assertThat(records.count()).isEqualTo(0);
+
+        // Now the committed offsets should be populated
+        Map<TopicPartition, OffsetAndMetadata> committed =
+                mockConsumer.committed(Set.of(partition0, partition1));
+
+        OffsetAndMetadata actualOnPartition0 = committed.get(partition0);
+        assertThat(actualOnPartition0.offset()).isEqualTo(0l);
+        OffsetAndMetadata actualOnPartition1 = committed.get(partition1);
+        assertThat(actualOnPartition1.offset()).isEqualTo(17l);
+    }
+
+    @Test
+    void shouldIdentifyPendingOffsets() {
+        Map<TopicPartition, OffsetAndMetadata> committed =
+                Map.of(partition0, new OffsetAndMetadata(10l, "11,14,20"));
+        offsetService.initStore(Map.of(partition0, 0L, partition1, 0L), committed);
+
+        // The following three records have their offset stored in the metadata
+        List<ConsumerRecord<?, ?>> havePendingOffsets =
+                List.of(
+                        Record(TOPIC, 0, "A-11"),
+                        Record(TOPIC, 0, "A-14"),
+                        Record(TOPIC, 0, "A-20"));
+
+        for (ConsumerRecord<?, ?> record : havePendingOffsets) {
+            assertThat(offsetService.notHasPendingOffset(record)).isFalse();
+        }
+
+        // The following records do not have their offsets stored as pending in the metadata
+        List<ConsumerRecord<?, ?>> dontHavePendingOffsets =
+                List.of(
+                        Record(TOPIC, 0, "A-10"),
+                        Record(TOPIC, 0, "A-12"),
+                        Record(TOPIC, 0, "A-13"),
+                        Record(TOPIC, 0, "A-15"),
+                        Record(TOPIC, 0, "A-16"),
+                        Record(TOPIC, 0, "A-17"),
+                        Record(TOPIC, 0, "A-18"),
+                        Record(TOPIC, 0, "A-19"),
+                        Record(TOPIC, 0, "A-21"),
+                        Record(TOPIC, 1, "B-21"));
+        for (ConsumerRecord<?, ?> record : dontHavePendingOffsets) {
+            assertThat(offsetService.notHasPendingOffset(record)).isTrue();
+        }
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/offsets/OffsetStoreTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/offsets/OffsetStoreTest.java
new file mode 100644
index 00000000..f3a1aea9
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/offsets/OffsetStoreTest.java
@@ -0,0 +1,268 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.offsets;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.lightstreamer.kafka.adapters.consumers.offsets.Offsets.OffsetStore;
+import com.lightstreamer.kafka.test_utils.Records;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.TopicPartition;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class OffsetStoreTest {
+
+    private static String TEST_TOPIC = "topic";
+
+    static ConsumerRecord<?, ?> Record(int partition, String id) {
+        return Records.Record(TEST_TOPIC, partition, id);
+    }
+
+    private OffsetStore repo;
+
+    OffsetAndMetadata getOffsetAndMetadata(String topic, int partition) {
+        return repo.current().get(new TopicPartition(topic, 0));
+    }
+
+    @Test
+    void shoulddDecode() {
+        assertThat(Offsets.decode("")).isEmpty();
+        assertThat(Offsets.decode(",")).isEmpty();
+        assertThat(Offsets.decode("200")).containsExactly(200l);
+        assertThat(Offsets.decode("200,100,400")).containsExactly(200l, 100l, 400l);
+        assertThat(Offsets.decode("200,100,400")).isInOrder();
+    }
+
+    @Test
+    void shouldAppend() {
+        assertThat(Offsets.append("", 100)).isEqualTo("100");
+        assertThat(Offsets.append("100,300,150,301", 271)).isEqualTo("100,300,150,301,271");
+    }
+
+    @Test
+    void shouldReturnSameOffsetMap() {
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        offsets.put(new TopicPartition(TEST_TOPIC, 0), new OffsetAndMetadata(0));
+
+        repo = Offsets.OffsetStore(offsets);
+        Map<TopicPartition, OffsetAndMetadata> offsetsMap = repo.current();
+        assertThat(offsetsMap).isEqualTo(offsets);
+    }
+
+    @Test
+    void shouldUpdateOffsetSequentially() {
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        offsets.put(new TopicPartition(TEST_TOPIC, 0), new OffsetAndMetadata(0, null));
+
+        repo = Offsets.OffsetStore(offsets);
+
+        repo.save(Record(0, "A-0"));
+        OffsetAndMetadata o1 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        assertThat(o1.offset()).isEqualTo(1);
+        assertThat(o1.metadata()).isEqualTo("");
+
+        repo.save(Record(0, "B-1"));
+        OffsetAndMetadata o2 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        assertThat(o2.offset()).isEqualTo(2);
+        assertThat(o2.metadata()).isEqualTo("");
+    }
+
+    @Test
+    void shouldUpdateOffsetBeyondLastCommited() {
+        long LAST_COMMITED_OFFSET = 0;
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        offsets.put(new TopicPartition(TEST_TOPIC, 0), new OffsetAndMetadata(LAST_COMMITED_OFFSET));
+
+        repo = Offsets.OffsetStore(offsets);
+
+        repo.save(Record(0, "A-2"));
+        OffsetAndMetadata o1 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        // Last offset is still the one provided by the initializing map (0)
+        assertThat(o1.offset()).isEqualTo(LAST_COMMITED_OFFSET);
+        assertThat(o1.metadata()).isEqualTo("2");
+
+        repo.save(Record(0, "B-4"));
+        OffsetAndMetadata o2 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        assertThat(o2.offset()).isEqualTo(LAST_COMMITED_OFFSET);
+        assertThat(o2.metadata()).isEqualTo("2,4");
+
+        repo.save(Record(0, "B-6"));
+        OffsetAndMetadata o3 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        assertThat(o3.offset()).isEqualTo(LAST_COMMITED_OFFSET);
+        assertThat(o3.metadata()).isEqualTo("2,4,6");
+    }
+
+    @Test
+    void shouldSanitizeBeyondOffsetsSimple() {
+        long LAST_COMMITED_OFFSET = 0;
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        offsets.put(new TopicPartition(TEST_TOPIC, 0), new OffsetAndMetadata(LAST_COMMITED_OFFSET));
+
+        repo = Offsets.OffsetStore(offsets);
+
+        repo.save(Record(0, "A-1"));
+        OffsetAndMetadata o1 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        // Last offset is still the one provided by the initializing map (0)
+        assertThat(o1.offset()).isEqualTo(LAST_COMMITED_OFFSET);
+        assertThat(o1.metadata()).isEqualTo("1");
+
+        // Save the record whose offset matched the LAST_COMMITED_OFFSET
+        repo.save(Record(0, "A-0"));
+        OffsetAndMetadata o2 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        // Sanitization happened
+        assertThat(o2.offset()).isEqualTo(2);
+        assertThat(o2.metadata()).isEqualTo("");
+    }
+
+    @Test
+    void shouldSanitizeBeyondOffsetsComplex() {
+        long LAST_COMMITED_OFFSET = 0;
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        offsets.put(new TopicPartition(TEST_TOPIC, 0), new OffsetAndMetadata(LAST_COMMITED_OFFSET));
+
+        repo = Offsets.OffsetStore(offsets);
+
+        repo.save(Record(0, "A-1"));
+        repo.save(Record(0, "A-2"));
+        repo.save(Record(0, "A-3"));
+        OffsetAndMetadata o1 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        // Last offset is still the one provided by the initializing map (0)
+        assertThat(o1.offset()).isEqualTo(LAST_COMMITED_OFFSET);
+        assertThat(o1.metadata()).isEqualTo("1,2,3");
+
+        repo.save(Record(0, "A-0"));
+        OffsetAndMetadata o2 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        // After commiting the record whose offset matched the LAST_COMMITED_OFFSET,
+        assertThat(o2.offset()).isEqualTo(4);
+        assertThat(o2.metadata()).isEqualTo("");
+    }
+
+    @Test
+    void shouldSanitizeBeyondOffsetsComplexUnordered() {
+        long LAST_COMMITED_OFFSET = 0;
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        offsets.put(new TopicPartition(TEST_TOPIC, 0), new OffsetAndMetadata(LAST_COMMITED_OFFSET));
+
+        repo = Offsets.OffsetStore(offsets);
+
+        repo.save(Record(0, "A-300"));
+        repo.save(Record(0, "A-100"));
+        repo.save(Record(0, "A-200"));
+        OffsetAndMetadata o1 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        // Last offset is still the one provided by the initializing map (0)
+        assertThat(o1.offset()).isEqualTo(LAST_COMMITED_OFFSET);
+        assertThat(o1.metadata()).isEqualTo("300,100,200");
+
+        repo.save(Record(0, "A-0"));
+        OffsetAndMetadata o2 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        // After commiting the record whose offset matched the LAST_COMMITED_OFFSET,
+        // the consumed list
+        assertThat(o2.offset()).isEqualTo(1);
+        assertThat(o2.metadata()).isEqualTo("300,100,200");
+    }
+
+    @Test
+    void shouldSanitizeBeyondOffsetsVeryComplex() {
+        long LAST_COMMITED_OFFSET = 0;
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        offsets.put(new TopicPartition(TEST_TOPIC, 0), new OffsetAndMetadata(LAST_COMMITED_OFFSET));
+
+        repo = Offsets.OffsetStore(offsets);
+
+        repo.save(Record(0, "A-5"));
+        repo.save(Record(0, "A-1"));
+        repo.save(Record(0, "A-2"));
+        repo.save(Record(0, "A-3"));
+        repo.save(Record(0, "A-6"));
+        OffsetAndMetadata o1 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        // Last offset is still the one provided by the initializing map (0)
+        assertThat(o1.offset()).isEqualTo(LAST_COMMITED_OFFSET);
+        assertThat(o1.metadata()).isEqualTo("5,1,2,3,6");
+
+        repo.save(Record(0, "A-0"));
+        // Now the consumed list has been sanitized from 0 to 3, the next offet is 4
+        OffsetAndMetadata o2 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        assertThat(o2.offset()).isEqualTo(4);
+        assertThat(o2.metadata()).isEqualTo("5,6");
+
+        repo.save(Record(0, "A-4"));
+        // Sanitization complete
+        OffsetAndMetadata o3 = getOffsetAndMetadata(TEST_TOPIC, 0);
+        assertThat(o3.offset()).isEqualTo(7);
+        assertThat(o3.metadata()).isEqualTo("");
+    }
+
+    @Test
+    void shouldReturnOffsetMap() {
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        offsets.put(new TopicPartition(TEST_TOPIC, 0), new OffsetAndMetadata(0));
+
+        repo = Offsets.OffsetStore(offsets);
+        Map<TopicPartition, OffsetAndMetadata> offsetsMap = repo.current();
+        assertThat(offsetsMap).isEqualTo(offsets);
+
+        repo.save(Record(0, "A-1"));
+        OffsetAndMetadata o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(0);
+        assertThat(o1.metadata()).isEqualTo("1");
+
+        repo.save(Record(0, "A-0"));
+        o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(2);
+        assertThat(o1.metadata()).isEqualTo("");
+
+        repo.save(Record(0, "A-2"));
+        o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(3);
+        assertThat(o1.metadata()).isEqualTo("");
+
+        repo.save(Record(0, "A-4"));
+        o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(3);
+        assertThat(o1.metadata()).isEqualTo("4");
+        repo.save(Record(0, "A-5"));
+        o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(3);
+        assertThat(o1.metadata()).isEqualTo("4,5");
+
+        repo.save(Record(0, "A-3"));
+        o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(6);
+        assertThat(o1.metadata()).isEqualTo("");
+
+        repo.save(Record(0, "A-8"));
+        o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(6);
+        assertThat(o1.metadata()).isEqualTo("8");
+
+        repo.save(Record(0, "A-9"));
+        o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(6);
+        assertThat(o1.metadata()).isEqualTo("8,9");
+
+        repo.save(Record(0, "A-6"));
+        o1 = offsetsMap.get(new TopicPartition(TEST_TOPIC, 0));
+        assertThat(o1.offset()).isEqualTo(7);
+        assertThat(o1.metadata()).isEqualTo("8,9");
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumerTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumerTest.java
new file mode 100644
index 00000000..44d12b53
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordConsumerTest.java
@@ -0,0 +1,782 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.processor;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.test_utils.Records.generateRecords;
+
+import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.mapping;
+import static java.util.stream.Collectors.toList;
+
+import com.lightstreamer.interfaces.data.ItemEventListener;
+import com.lightstreamer.kafka.adapters.ConnectorConfigurator;
+import com.lightstreamer.kafka.adapters.commons.LogFactory;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.OrderStrategy;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumerSupport.DefaultRecordProcessor;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumerSupport.ParallelRecordConsumer;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumerSupport.SingleThreadedRecordConsumer;
+import com.lightstreamer.kafka.common.mapping.Items;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+import com.lightstreamer.kafka.common.mapping.RecordMapper;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
+import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
+import com.lightstreamer.kafka.test_utils.Mocks.MockItemEventListener;
+import com.lightstreamer.kafka.test_utils.Mocks.MockOffsetService;
+import com.lightstreamer.kafka.test_utils.Mocks.MockOffsetService.ConsumedRecordInfo;
+import com.lightstreamer.kafka.test_utils.Mocks.MockRecordProcessor;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.common.KafkaException;
+import org.apache.kafka.common.TopicPartition;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.slf4j.Logger;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class RecordConsumerTest {
+
+    static record Event(String key, int position, int partition, long offset, String threadName) {}
+
+    private static RecordMapper<String, String> newRecordMapper(
+            ConsumerTriggerConfig<String, String> config) {
+        return RecordMapper.<String, String>builder()
+                .withTemplateExtractors(config.itemTemplates().extractorsByTopicName())
+                .withFieldExtractor(config.fieldsExtractor())
+                .build();
+    }
+
+    private static Logger logger = LogFactory.getLogger("connection");
+
+    private RecordConsumer<String, String> recordConsumer;
+    private ConsumerTriggerConfig<String, String> config;
+    private RecordMapper<String, String> recordMapper;
+    private Set<SubscribedItem> subscriptions;
+
+    @SuppressWarnings("unchecked")
+    @BeforeEach
+    public void setUp() throws IOException {
+        File adapterDir = Files.createTempDirectory("adapter_dir").toFile();
+        Map<String, String> overrideSettings = new HashMap<>();
+        overrideSettings.put("field.key", "#{KEY}");
+        overrideSettings.put("field.value", "#{VALUE}");
+        overrideSettings.put("field.partition", "#{PARTITION}");
+        overrideSettings.put("field.offset", "#{OFFSET}");
+
+        ConnectorConfigurator connectorConfigurator =
+                new ConnectorConfigurator(
+                        ConnectorConfigProvider.minimalConfigWith(overrideSettings), adapterDir);
+
+        this.config = (ConsumerTriggerConfig<String, String>) connectorConfigurator.configure();
+
+        String item = "item";
+        this.subscriptions = Collections.singleton(Items.subscribedFrom(item, new Object()));
+
+        // Configure the RecordMapper.
+        this.recordMapper = newRecordMapper(config);
+    }
+
+    private RecordConsumer<String, String> mkRecordConsumer(
+            ItemEventListener listener, int threads, OrderStrategy orderStrategy) {
+        return RecordConsumer.<String, String>recordMapper(recordMapper)
+                .subscribedItems(subscriptions)
+                .eventListener(listener)
+                .offsetService(new MockOffsetService())
+                .errorStrategy(config.errorHandlingStrategy())
+                .logger(logger)
+                .threads(threads)
+                .ordering(orderStrategy)
+                .build();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        if (this.recordConsumer != null) {
+            this.recordConsumer.close();
+        }
+    }
+
+    static int extractNumberedSuffix(String value) {
+        int i = value.indexOf("-");
+        if (i != -1) {
+            return Integer.parseInt(value.substring(i + 1));
+        }
+        throw new RuntimeException("Cannot extract number from " + value);
+    }
+
+    @Test
+    public void testExtractNumberSuffix() {
+        assertThat(extractNumberedSuffix("abc-21")).isEqualTo(21);
+        assertThat(extractNumberedSuffix("EVENTT-1")).isEqualTo(1);
+    }
+
+    @Test
+    public void testRecordGeneration() {
+        ConsumerRecords<String, String> records =
+                generateRecords("topic", 40, List.of("a", "b", "c"));
+        assertThat(records).hasSize(40);
+
+        List<ConsumerRecord<String, String>> recordByPartition =
+                records.records(new TopicPartition("topic", 0));
+        Map<String, List<Integer>> byKey =
+                recordByPartition.stream()
+                        .collect(
+                                groupingBy(
+                                        ConsumerRecord::key,
+                                        mapping(r -> extractNumberedSuffix(r.value()), toList())));
+        Collection<List<Integer>> keyOrdered = byKey.values();
+        for (List<Integer> list : keyOrdered) {
+            assertThat(list).isInOrder();
+        }
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    public void shouldGetOrderStrategyFromConfig(RecordConsumeWithOrderStrategy orderStrategy) {
+        assertThat(OrderStrategy.from(orderStrategy).toString())
+                .isEqualTo(orderStrategy.toString());
+    }
+
+    @ParameterizedTest
+    @EnumSource(RecordErrorHandlingStrategy.class)
+    public void shouldBuildParalleRecordConsumerFromRecordMapperWithDefaultValues(
+            RecordErrorHandlingStrategy error) {
+        MockOffsetService offsetService = new MockOffsetService();
+        MockItemEventListener listener = new MockItemEventListener();
+
+        RecordConsumer<String, String> recordConsumer =
+                RecordConsumer.<String, String>recordMapper(recordMapper)
+                        .subscribedItems(subscriptions)
+                        .eventListener(listener)
+                        .offsetService(offsetService)
+                        .errorStrategy(error)
+                        .logger(logger)
+                        .build();
+
+        assertThat(recordConsumer).isNotNull();
+        assertThat(recordConsumer).isInstanceOf(ParallelRecordConsumer.class);
+
+        ParallelRecordConsumer<String, String> parallelRecordConsumer =
+                (ParallelRecordConsumer<String, String>) recordConsumer;
+        assertThat(parallelRecordConsumer.offsetService).isSameInstanceAs(offsetService);
+        assertThat(parallelRecordConsumer.logger).isSameInstanceAs(logger);
+        assertThat(parallelRecordConsumer.errorStrategy).isEqualTo(error);
+        assertThat(parallelRecordConsumer.recordProcessor)
+                .isInstanceOf(DefaultRecordProcessor.class);
+        // Default values
+        assertThat(parallelRecordConsumer.orderStrategy)
+                .isEqualTo(OrderStrategy.ORDER_BY_PARTITION);
+        assertThat(parallelRecordConsumer.configuredThreads).isEqualTo(1);
+        assertThat(parallelRecordConsumer.actualThreads)
+                .isEqualTo(parallelRecordConsumer.configuredThreads);
+
+        DefaultRecordProcessor<String, String> recordProcessor =
+                (DefaultRecordProcessor<String, String>) parallelRecordConsumer.recordProcessor;
+        assertThat(recordProcessor.recordMapper).isSameInstanceAs(recordMapper);
+        assertThat(recordProcessor.subscribedItems).isSameInstanceAs(subscriptions);
+        assertThat(recordProcessor.listener).isSameInstanceAs(listener);
+        assertThat(recordProcessor.log).isSameInstanceAs(logger);
+    }
+
+    @ParameterizedTest
+    @EnumSource(RecordErrorHandlingStrategy.class)
+    public void shouldBuildParalleRecordConsumerFromRecorProcessorDefaultValues(
+            RecordErrorHandlingStrategy error) {
+        MockOffsetService offsetService = new MockOffsetService();
+
+        RecordConsumer<String, String> recordConsumer =
+                RecordConsumer.<String, String>recordProcessor(
+                                new MockRecordProcessor<String, String>())
+                        .offsetService(offsetService)
+                        .errorStrategy(error)
+                        .logger(logger)
+                        .build();
+
+        assertThat(recordConsumer).isNotNull();
+        assertThat(recordConsumer).isInstanceOf(ParallelRecordConsumer.class);
+
+        ParallelRecordConsumer<String, String> parallelRecordConsumer =
+                (ParallelRecordConsumer<String, String>) recordConsumer;
+        assertThat(parallelRecordConsumer.offsetService).isSameInstanceAs(offsetService);
+        assertThat(parallelRecordConsumer.logger).isSameInstanceAs(logger);
+        assertThat(parallelRecordConsumer.errorStrategy).isEqualTo(error);
+        assertThat(parallelRecordConsumer.recordProcessor).isInstanceOf(MockRecordProcessor.class);
+        // Default values
+        assertThat(parallelRecordConsumer.orderStrategy)
+                .isEqualTo(OrderStrategy.ORDER_BY_PARTITION);
+        assertThat(parallelRecordConsumer.configuredThreads).isEqualTo(1);
+        assertThat(parallelRecordConsumer.actualThreads)
+                .isEqualTo(parallelRecordConsumer.configuredThreads);
+    }
+
+    static Stream<Arguments> parallelConsumerArgs() {
+        return Stream.of(
+                arguments(-1, OrderStrategy.ORDER_BY_KEY, true),
+                arguments(2, OrderStrategy.ORDER_BY_PARTITION, true),
+                arguments(4, OrderStrategy.UNORDERED, true));
+    }
+
+    @ParameterizedTest
+    @MethodSource("parallelConsumerArgs")
+    public void shouldBuildParalleRecordConsumerFromRecordMapperWithNonDefaultValues(
+            int threads, OrderStrategy order, boolean preferSingleThread) {
+        MockOffsetService offsetService = new MockOffsetService();
+        MockItemEventListener listener = new MockItemEventListener();
+
+        RecordConsumer<String, String> recordConsumer =
+                RecordConsumer.<String, String>recordMapper(recordMapper)
+                        .subscribedItems(subscriptions)
+                        .eventListener(listener)
+                        .offsetService(offsetService)
+                        .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                        .logger(logger)
+                        .threads(threads)
+                        .ordering(order)
+                        .preferSingleThread(preferSingleThread) // Pointless due to threads > 1
+                        .build();
+
+        assertThat(recordConsumer).isNotNull();
+        assertThat(recordConsumer).isInstanceOf(ParallelRecordConsumer.class);
+
+        ParallelRecordConsumer<String, String> parallelRecordConsumer =
+                (ParallelRecordConsumer<String, String>) recordConsumer;
+        assertThat(parallelRecordConsumer.offsetService).isSameInstanceAs(offsetService);
+        assertThat(parallelRecordConsumer.logger).isSameInstanceAs(logger);
+        assertThat(parallelRecordConsumer.errorStrategy)
+                .isEqualTo(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION);
+        assertThat(parallelRecordConsumer.recordProcessor)
+                .isInstanceOf(DefaultRecordProcessor.class);
+        // Nond-default values
+        assertThat(parallelRecordConsumer.orderStrategy).isEqualTo(order);
+        assertThat(parallelRecordConsumer.configuredThreads).isEqualTo(threads);
+        if (threads == -1) {
+            assertThat(parallelRecordConsumer.actualThreads).isGreaterThan(1);
+        } else {
+            assertThat(parallelRecordConsumer.actualThreads)
+                    .isEqualTo(parallelRecordConsumer.configuredThreads);
+        }
+
+        DefaultRecordProcessor<String, String> recordProcessor =
+                (DefaultRecordProcessor<String, String>) parallelRecordConsumer.recordProcessor;
+        assertThat(recordProcessor.recordMapper).isSameInstanceAs(recordMapper);
+        assertThat(recordProcessor.subscribedItems).isSameInstanceAs(subscriptions);
+        assertThat(recordProcessor.listener).isSameInstanceAs(listener);
+        assertThat(recordProcessor.log).isSameInstanceAs(logger);
+    }
+
+    @ParameterizedTest
+    @MethodSource("parallelConsumerArgs")
+    public void shouldBuildParalleRecordConsumerFromRecordProcessorWithNonDefaultValues(
+            int threads, OrderStrategy order, boolean preferSingleThread) {
+        MockOffsetService offsetService = new MockOffsetService();
+
+        RecordConsumer<String, String> recordConsumer =
+                RecordConsumer.<String, String>recordProcessor(
+                                new MockRecordProcessor<String, String>())
+                        .offsetService(offsetService)
+                        .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                        .logger(logger)
+                        .threads(threads)
+                        .ordering(order)
+                        .preferSingleThread(preferSingleThread) // Pointless due to threads > 1
+                        .build();
+
+        assertThat(recordConsumer).isNotNull();
+        assertThat(recordConsumer).isInstanceOf(ParallelRecordConsumer.class);
+
+        ParallelRecordConsumer<String, String> parallelRecordConsumer =
+                (ParallelRecordConsumer<String, String>) recordConsumer;
+        assertThat(parallelRecordConsumer.offsetService).isSameInstanceAs(offsetService);
+        assertThat(parallelRecordConsumer.logger).isSameInstanceAs(logger);
+        assertThat(parallelRecordConsumer.errorStrategy)
+                .isEqualTo(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION);
+        assertThat(parallelRecordConsumer.recordProcessor).isInstanceOf(MockRecordProcessor.class);
+        // Non-default values
+        assertThat(parallelRecordConsumer.orderStrategy).isEqualTo(order);
+        assertThat(parallelRecordConsumer.configuredThreads).isEqualTo(threads);
+        if (threads == -1) {
+            assertThat(parallelRecordConsumer.actualThreads).isGreaterThan(1);
+        } else {
+            assertThat(parallelRecordConsumer.actualThreads)
+                    .isEqualTo(parallelRecordConsumer.configuredThreads);
+        }
+    }
+
+    @Test
+    public void shouldBuildSingleThreadedRecordConsumerFromRecordMapper() {
+        MockOffsetService offsetService = new MockOffsetService();
+        MockItemEventListener listener = new MockItemEventListener();
+
+        RecordConsumer<String, String> recordConsumer =
+                RecordConsumer.<String, String>recordMapper(recordMapper)
+                        .subscribedItems(subscriptions)
+                        .eventListener(listener)
+                        .offsetService(offsetService)
+                        .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                        .logger(logger)
+                        .threads(1)
+                        // The following should trigger a SingleThreadedRecordConsumer instance
+                        .preferSingleThread(true)
+                        .build();
+
+        assertThat(recordConsumer).isNotNull();
+        assertThat(recordConsumer).isInstanceOf(SingleThreadedRecordConsumer.class);
+
+        SingleThreadedRecordConsumer<String, String> monoThreadedConsumer =
+                (SingleThreadedRecordConsumer<String, String>) recordConsumer;
+        assertThat(monoThreadedConsumer.offsetService).isSameInstanceAs(offsetService);
+        assertThat(monoThreadedConsumer.logger).isSameInstanceAs(logger);
+        assertThat(monoThreadedConsumer.errorStrategy)
+                .isEqualTo(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION);
+        assertThat(monoThreadedConsumer.recordProcessor).isInstanceOf(DefaultRecordProcessor.class);
+
+        DefaultRecordProcessor<String, String> recordProcessor =
+                (DefaultRecordProcessor<String, String>) monoThreadedConsumer.recordProcessor;
+        assertThat(recordProcessor.recordMapper).isSameInstanceAs(recordMapper);
+        assertThat(recordProcessor.subscribedItems).isSameInstanceAs(subscriptions);
+        assertThat(recordProcessor.listener).isSameInstanceAs(listener);
+        assertThat(recordProcessor.log).isSameInstanceAs(logger);
+    }
+
+    @Test
+    public void shouldBuildSingleThreadedRecordConsumerFromRecorProcessor() {
+        MockOffsetService offsetService = new MockOffsetService();
+
+        RecordConsumer<String, String> recordConsumer =
+                RecordConsumer.<String, String>recordProcessor(
+                                new MockRecordProcessor<String, String>())
+                        .offsetService(offsetService)
+                        .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                        .logger(logger)
+                        .threads(1)
+                        .preferSingleThread(
+                                true) // This should trigger a SingleThreadedRecordConsumer instance
+                        .build();
+
+        assertThat(recordConsumer).isNotNull();
+        assertThat(recordConsumer).isInstanceOf(SingleThreadedRecordConsumer.class);
+
+        SingleThreadedRecordConsumer<String, String> monoThreadedConsumer =
+                (SingleThreadedRecordConsumer<String, String>) recordConsumer;
+        assertThat(monoThreadedConsumer.offsetService).isSameInstanceAs(offsetService);
+        assertThat(monoThreadedConsumer.logger).isSameInstanceAs(logger);
+        assertThat(monoThreadedConsumer.errorStrategy)
+                .isEqualTo(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION);
+        assertThat(monoThreadedConsumer.recordProcessor).isInstanceOf(MockRecordProcessor.class);
+    }
+
+    @Test
+    public void shouldFailBuildingDueToNullValues() {
+        assertThrows(
+                NullPointerException.class,
+                () -> {
+                    RecordConsumer.<String, String>recordMapper(recordMapper)
+                            .subscribedItems(subscriptions)
+                            .eventListener(null)
+                            .offsetService(new MockOffsetService())
+                            .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                            .logger(logger)
+                            .build();
+                });
+        assertThrows(
+                NullPointerException.class,
+                () -> {
+                    RecordConsumer.<String, String>recordMapper(null)
+                            .subscribedItems(subscriptions)
+                            .eventListener(new MockItemEventListener())
+                            .offsetService(new MockOffsetService())
+                            .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                            .logger(logger)
+                            .build();
+                });
+        assertThrows(
+                NullPointerException.class,
+                () -> {
+                    RecordConsumer.<String, String>recordMapper(recordMapper)
+                            .subscribedItems(subscriptions)
+                            .eventListener(new MockItemEventListener())
+                            .offsetService(new MockOffsetService())
+                            .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                            .logger(null)
+                            .build();
+                });
+        assertThrows(
+                NullPointerException.class,
+                () -> {
+                    RecordConsumer.<String, String>recordProcessor(
+                                    new MockRecordProcessor<String, String>())
+                            .offsetService(new MockOffsetService())
+                            .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                            .logger(null)
+                            .build();
+                });
+        assertThrows(
+                NullPointerException.class,
+                () -> {
+                    RecordConsumer.<String, String>recordProcessor(null)
+                            .offsetService(new MockOffsetService())
+                            .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                            .logger(logger)
+                            .build();
+                });
+    }
+
+    @Test
+    public void shouldFailBuildingDueToIllegalValues() {
+        IllegalArgumentException ie =
+                assertThrows(
+                        IllegalArgumentException.class,
+                        () -> {
+                            RecordConsumer.<String, String>recordMapper(recordMapper)
+                                    .subscribedItems(subscriptions)
+                                    .eventListener(new MockItemEventListener())
+                                    .offsetService(new MockOffsetService())
+                                    .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                                    .logger(logger)
+                                    .threads(0)
+                                    .build();
+                        });
+        assertThat(ie.getMessage()).isEqualTo("Threads number must be greater than zero");
+    }
+
+    /**
+     * Method source for the test methods.
+     *
+     * @return the number of records to generate, the number of iteration for each record
+     *     collections, the number of threads to spin up
+     */
+    static Stream<Arguments> iterations() {
+        return Stream.of(
+                arguments(50, 1, 2),
+                arguments(100, 1, 2),
+                arguments(50, 1, 4),
+                arguments(100, 1, 4),
+                arguments(50, 10, 2),
+                arguments(100, 10, 2),
+                arguments(50, 10, 4),
+                arguments(50, 10, 4),
+                arguments(50, 100, 2),
+                arguments(100, 100, 2),
+                arguments(50, 100, 4),
+                arguments(50, 100, 4),
+                arguments(50, 1000, 2),
+                arguments(100, 1000, 2),
+                arguments(50, 1000, 4),
+                arguments(100, 1000, 4));
+    }
+
+    @ParameterizedTest
+    @MethodSource("iterations")
+    public void shoudDeliverKeyBasedOrder(int numOfRecords, int iterations, int threads) {
+        ConsumerRecords<String, String> records =
+                generateRecords(
+                        "topic", numOfRecords, List.of("a", "b", "c", "d"), new int[] {0, 1});
+
+        // Make the RecordConsumer.
+        List<Event> deliveredEvents = Collections.synchronizedList(new ArrayList<>());
+        recordConsumer =
+                mkRecordConsumer(
+                        new MockItemEventListener(buildEvent(deliveredEvents)),
+                        threads,
+                        OrderStrategy.ORDER_BY_KEY);
+
+        for (int i = 0; i < iterations; i++) {
+            recordConsumer.consumeRecords(records);
+            assertThat(deliveredEvents.size()).isEqualTo(numOfRecords);
+            // Group all the delievered events by record key
+            Map<String, List<Number>> byKey = getByKey(deliveredEvents);
+            // Ensure that events relative to the same key are in order
+            Collection<List<Number>> orderedLists = byKey.values();
+            for (List<Number> orderedList : orderedLists) {
+                assertThat(orderedList).isInOrder();
+            }
+
+            // Reset the event list for next iteration
+            deliveredEvents.clear();
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("iterations")
+    public void shoudDeliverPartitionBasedOrder(int numOfRecords, int iterations, int threads) {
+        List<String> keys = List.of("a", "b", "c");
+        // Provide less partitions than keys to enforce multiple key ending up to same partition.
+        int[] partitions = IntStream.range(0, keys.size() - 1).toArray();
+
+        ConsumerRecords<String, String> records =
+                generateRecords("topic", numOfRecords, keys, partitions);
+
+        // Make the RecordConsumer.
+        List<Event> deliveredEvents = Collections.synchronizedList(new ArrayList<>());
+        recordConsumer =
+                mkRecordConsumer(
+                        new MockItemEventListener(buildEvent(deliveredEvents)),
+                        threads,
+                        OrderStrategy.ORDER_BY_PARTITION);
+
+        for (int i = 0; i < iterations; i++) {
+            recordConsumer.consumeRecords(records);
+            assertThat(deliveredEvents.size()).isEqualTo(numOfRecords);
+            // Group the list of offsets by partition stored in all the delivered events
+            Map<String, List<Number>> byPartition = getByPartition(deliveredEvents);
+
+            // Ensure that the offsets relative to the same partition are in order
+            Collection<List<Number>> orderedLists = byPartition.values();
+            for (List<Number> orderedList : orderedLists) {
+                assertThat(orderedList).isInOrder();
+            }
+            // Reset the event list for next iteration
+            deliveredEvents.clear();
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("iterations")
+    public void shoudDeliverPartitionBasedOrderWithNoKey(
+            int numOfRecords, int iterations, int threads) {
+        List<String> keys = Collections.emptyList();
+        int[] partitions = IntStream.range(0, 3).toArray();
+
+        ConsumerRecords<String, String> records =
+                generateRecords("topic", numOfRecords, keys, partitions);
+
+        // Make the RecordConsumer.
+        List<Event> events = Collections.synchronizedList(new ArrayList<>());
+        recordConsumer =
+                mkRecordConsumer(
+                        new MockItemEventListener(buildEvent(events)),
+                        threads,
+                        OrderStrategy.ORDER_BY_PARTITION);
+
+        for (int i = 0; i < iterations; i++) {
+            recordConsumer.consumeRecords(records);
+            assertThat(events.size()).isEqualTo(numOfRecords);
+            // Get the list of offsets per partition stored in all received events
+            Map<String, List<Number>> byPartition = getByPartition(events);
+
+            // Ensure that the offsets relative to the same partition are in order
+            Collection<List<Number>> orderedLists = byPartition.values();
+            for (List<Number> orderedList : orderedLists) {
+                assertThat(orderedList).isInOrder();
+            }
+            // Reset the event list for next iteration
+            events.clear();
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("iterations")
+    public void shoudDeliverUnordered(int numOfRecords, int iterations, int threads) {
+        List<String> keys = Collections.emptyList();
+        int[] partitions = IntStream.range(0, 3).toArray();
+
+        ConsumerRecords<String, String> records =
+                generateRecords("topic", numOfRecords, keys, partitions);
+
+        // Make the RecordConsumer.
+        List<Event> deliveredEvents = Collections.synchronizedList(new ArrayList<>());
+        recordConsumer =
+                mkRecordConsumer(
+                        new MockItemEventListener(buildEvent(deliveredEvents)),
+                        2,
+                        OrderStrategy.UNORDERED);
+
+        for (int i = 0; i < iterations; i++) {
+            recordConsumer.consumeRecords(records);
+            assertThat(deliveredEvents.size()).isEqualTo(numOfRecords);
+            // Reset the delivered events list for next iteration
+            deliveredEvents.clear();
+        }
+    }
+
+    @Test
+    public void shouldConsumeFiltered() {
+        // Generate records distribuited into three partitions
+        List<String> keys = Collections.emptyList();
+        int[] partitions = IntStream.range(0, 3).toArray();
+        ConsumerRecords<String, String> records = generateRecords("topic", 99, keys, partitions);
+
+        // Make the RecordConsumer.
+        List<Event> deliveredEvents = Collections.synchronizedList(new ArrayList<>());
+        recordConsumer =
+                mkRecordConsumer(
+                        new MockItemEventListener(buildEvent(deliveredEvents)),
+                        2,
+                        OrderStrategy.UNORDERED);
+
+        // Consume only the records published to partion 0
+        recordConsumer.consumeFilteredRecords(records, c -> c.partition() == 0);
+        // Verify that only 1/3 of total published record have been consumed
+        assertThat(deliveredEvents.size()).isEqualTo(records.count() / 3);
+    }
+
+    static Stream<Arguments> handleErrors() {
+        return Stream.of(
+                Arguments.of(1, ValueException.fieldNotFound("field")),
+                Arguments.of(2, ValueException.fieldNotFound("field")),
+                Arguments.of(2, new RuntimeException("Serious issue")));
+    }
+
+    @ParameterizedTest
+    @MethodSource("handleErrors")
+    public void shouldHandleErrors(int numOfThreads, RuntimeException exception) {
+        List<String> keys = List.of("a", "b");
+        int[] partitions = IntStream.range(0, 2).toArray();
+
+        ConsumerRecords<String, String> records = generateRecords("topic", 30, keys, partitions);
+
+        // Prepare the list of offsets that will trigger a ValueException upon processing
+        List<ConsumedRecordInfo> offsetsTriggeringException =
+                List.of(
+                        new ConsumedRecordInfo("topic", 0, 2l),
+                        new ConsumedRecordInfo("topic", 0, 4l),
+                        new ConsumedRecordInfo("topic", 1, 3l));
+
+        MockOffsetService offsetService = new MockOffsetService();
+        RecordConsumer<String, String> recordConsumer =
+                RecordConsumer.<String, String>recordProcessor(
+                                new MockRecordProcessor<String, String>(
+                                        exception, offsetsTriggeringException))
+                        .offsetService(offsetService)
+                        .errorStrategy(RecordErrorHandlingStrategy.FORCE_UNSUBSCRIPTION)
+                        .logger(logger)
+                        .threads(numOfThreads)
+                        // This enforse usage of the SingleThreadedConsume if numOfThreads is 1
+                        // .preferSingleThread(true)
+                        .build();
+
+        assertThrows(KafkaException.class, () -> recordConsumer.consumeRecords(records));
+
+        // Ensure that the commited offsets do not include the broken ones.
+        List<ConsumedRecordInfo> consumedRecords = offsetService.getConsumedRecords();
+        assertThat(consumedRecords).hasSize(records.count() - offsetsTriggeringException.size());
+        assertThat(consumedRecords).containsNoneIn(offsetsTriggeringException);
+    }
+
+    @ParameterizedTest
+    @MethodSource("handleErrors")
+    public void shouldIgnoreErrorsOnlyIfValueException(
+            int numOfThreads, RuntimeException exception) {
+        List<String> keys = List.of("a", "b");
+        int[] partitions = IntStream.range(0, 2).toArray();
+
+        ConsumerRecords<String, String> records = generateRecords("topic", 30, keys, partitions);
+
+        // Prepare the list of offsets that will trigger a ValueException upon processing
+        List<ConsumedRecordInfo> offsetsTriggeringException =
+                List.of(
+                        new ConsumedRecordInfo("topic", 0, 2l),
+                        new ConsumedRecordInfo("topic", 0, 4l),
+                        new ConsumedRecordInfo("topic", 1, 3l));
+
+        MockOffsetService offsetService = new MockOffsetService();
+        RecordConsumer<String, String> recordConsumer =
+                RecordConsumer.<String, String>recordProcessor(
+                                new MockRecordProcessor<String, String>(
+                                        exception, offsetsTriggeringException))
+                        .offsetService(offsetService)
+                        // The following prevents the exception to be propagated
+                        .errorStrategy(RecordErrorHandlingStrategy.IGNORE_AND_CONTINUE)
+                        .logger(logger)
+                        .threads(numOfThreads)
+                        // This enforse usage of the SingleThreadedConsume if numOfThreads is 1
+                        .preferSingleThread(true)
+                        .build();
+
+        if (exception instanceof ValueException) {
+            recordConsumer.consumeRecords(records);
+            // Ensure that all offsets are commited
+            List<ConsumedRecordInfo> consumedRecords = offsetService.getConsumedRecords();
+            assertThat(consumedRecords).hasSize(records.count());
+        } else {
+            assertThrows(KafkaException.class, () -> recordConsumer.consumeRecords(records));
+            List<ConsumedRecordInfo> consumedRecords = offsetService.getConsumedRecords();
+            assertThat(consumedRecords)
+                    .hasSize(records.count() - offsetsTriggeringException.size());
+            assertThat(consumedRecords).containsNoneIn(offsetsTriggeringException);
+        }
+    }
+
+    /**
+     * Groups all the event offsets by key.
+     *
+     * @return a map of offsets list by key
+     */
+    private static Map<String, List<Number>> getByKey(List<Event> events) {
+        return events.stream().collect(groupingBy(Event::key, mapping(Event::offset, toList())));
+    }
+
+    /**
+     * Groups all the event offsets by partition.
+     *
+     * @return a map of offsets list by partition
+     */
+    private static Map<String, List<Number>> getByPartition(List<Event> events) {
+        return events.stream()
+                .collect(
+                        groupingBy(
+                                e -> String.valueOf(e.partition()),
+                                mapping(Event::offset, toList())));
+    }
+
+    private static Consumer<Map<String, String>> buildEvent(List<Event> events) {
+        return event -> {
+            // Get the key
+            String key = event.get("key");
+            // Extract the position from the value: "a-3" -> "3"
+            int position = extractNumberedSuffix(event.get("value"));
+            // Get the partition
+            String partition = event.get("partition");
+            // Get the offset
+            String offset = event.get("offset");
+            // Create and add the event
+            events.add(
+                    new Event(
+                            key,
+                            position,
+                            Integer.parseInt(partition),
+                            Long.parseLong(offset),
+                            Thread.currentThread().getName()));
+        };
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordProcessorTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordProcessorTest.java
new file mode 100644
index 00000000..26f84314
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/consumers/processor/RecordProcessorTest.java
@@ -0,0 +1,109 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.consumers.processor;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.adapters.mapping.selectors.others.OthersSelectorSuppliers.String;
+import static com.lightstreamer.kafka.common.mapping.selectors.DataExtractor.extractor;
+
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.RecordProcessor;
+import com.lightstreamer.kafka.common.mapping.Items;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+import com.lightstreamer.kafka.common.mapping.RecordMapper;
+import com.lightstreamer.kafka.common.mapping.RecordMapper.Builder;
+import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
+import com.lightstreamer.kafka.test_utils.Mocks.MockItemEventListener;
+import com.lightstreamer.kafka.test_utils.Records;
+
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class RecordProcessorTest {
+
+    private static final String TEST_TOPIC = "topic";
+
+    private static Builder<String, String> builder() {
+        return RecordMapper.<String, String>builder();
+    }
+
+    private RecordMapper<String, String> mapper;
+    private AtomicInteger counter;
+    private MockItemEventListener listener;
+    private ConsumerRecord<String, String> record;
+    private Set<SubscribedItem> subscribedItems;
+    private RecordProcessor<String, String> processor;
+
+    @BeforeEach
+    public void setUp() throws ExtractionException {
+        this.mapper =
+                builder()
+                        .withTemplateExtractor(
+                                TEST_TOPIC, extractor(String(), "item1", Collections.emptyMap()))
+                        .withTemplateExtractor(
+                                TEST_TOPIC, extractor(String(), "item2", Collections.emptyMap()))
+                        .build();
+        // Counts the listener invocations to deliver the real-time updates
+        this.counter = new AtomicInteger();
+
+        // The mocked ItemEventListener instance, wich updates the counter upon invocation.
+        this.listener = new MockItemEventListener(update -> counter.incrementAndGet());
+
+        // A record routable to "item1" and "item2"
+        this.record = Records.Record(TEST_TOPIC, 0, "a-1");
+
+        // The collection of subscribable items
+        this.subscribedItems = new HashSet<>();
+
+        // The RecordProcessor instance
+        this.processor =
+                new RecordConsumerSupport.DefaultRecordProcessor<>(
+                        mapper, subscribedItems, listener);
+    }
+
+    @Test
+    public void shouldProcess() {
+        // Subscribe to "item1" and process the record
+        subscribedItems.add(Items.subscribedFrom("item1", new Object()));
+        processor.process(record);
+        // Verify that the real-time update has been routed
+        assertThat(counter.get()).isEqualTo(1);
+        // Reset the counter
+        counter.set(0);
+
+        // Add subscription "item2"
+        subscribedItems.add(Items.subscribedFrom("item2", new Object()));
+        processor.process(record);
+        // Verify that the update has been routed two times, one for "item1" and one for "item2"
+        assertThat(counter.get()).isEqualTo(2);
+    }
+
+    @Test
+    public void shouldNotProcess() {
+        // Subscribe to the unexpected "item3" and process the record
+        subscribedItems.add(Items.subscribedFrom("item3", new Object()));
+        processor.process(record);
+        // Verify that the update has NOT been routed
+        assertThat(counter.get()).isEqualTo(0);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/WrapperKeyValueSelectorSupplierTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/WrapperKeyValueSelectorSupplierTest.java
new file mode 100644
index 00000000..82b00188
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/WrapperKeyValueSelectorSupplierTest.java
@@ -0,0 +1,95 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.adapters.mapping.selectors;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers.KeyValueDeserializers;
+import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
+import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
+import com.lightstreamer.kafka.common.mapping.selectors.KeySelector;
+import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueSelector;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
+
+import org.apache.kafka.common.serialization.Deserializer;
+import org.apache.kafka.common.serialization.Serdes;
+import org.junit.jupiter.api.Test;
+
+class KeySelectorSupplierImpl<T> implements KeySelectorSupplier<T> {
+
+    private Deserializer<T> deseralizer;
+
+    KeySelectorSupplierImpl(Deserializer<T> deserializer) {
+        this.deseralizer = deserializer;
+    }
+
+    @Override
+    public KeySelector<T> newSelector(String name, ExtractionExpression expression)
+            throws ExtractionException {
+        throw new UnsupportedOperationException("Unimplemented method 'newSelector'");
+    }
+
+    @Override
+    public Deserializer<T> deseralizer() {
+        return deseralizer;
+    }
+}
+
+class ValueSelectorSupplierImpl<T> implements ValueSelectorSupplier<T> {
+
+    private Deserializer<T> deseralizer;
+
+    ValueSelectorSupplierImpl(Deserializer<T> deserializer) {
+        this.deseralizer = deserializer;
+    }
+
+    @Override
+    public ValueSelector<T> newSelector(String name, ExtractionExpression expression)
+            throws ExtractionException {
+        throw new UnsupportedOperationException("Unimplemented method 'newSelector'");
+    }
+
+    @Override
+    public Deserializer<T> deseralizer() {
+        return deseralizer;
+    }
+}
+
+public class WrapperKeyValueSelectorSupplierTest {
+    @Test
+    void shouldCreate() {
+        Deserializer<String> stringDeserializer = Serdes.String().deserializer();
+        KeySelectorSupplierImpl<String> keySelectorSupplier =
+                new KeySelectorSupplierImpl<String>(stringDeserializer);
+        Deserializer<Long> longDeserializer = Serdes.Long().deserializer();
+        ValueSelectorSupplierImpl<Long> valueSelectorSupplier =
+                new ValueSelectorSupplierImpl<Long>(longDeserializer);
+        WrapperKeyValueSelectorSuppliers<String, Long> adapterKeyValueSelectorSupplier =
+                new WrapperKeyValueSelectorSuppliers<>(keySelectorSupplier, valueSelectorSupplier);
+
+        assertThat(adapterKeyValueSelectorSupplier.keySelectorSupplier())
+                .isSameInstanceAs(keySelectorSupplier);
+        assertThat(adapterKeyValueSelectorSupplier.valueSelectorSupplier())
+                .isSameInstanceAs(valueSelectorSupplier);
+        KeyValueDeserializers<String, Long> deserializers =
+                adapterKeyValueSelectorSupplier.deserializers();
+        assertThat(deserializers.keyDeserializer()).isSameInstanceAs(stringDeserializer);
+        assertThat(deserializers.valueDeserializer()).isSameInstanceAs(longDeserializer);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializerTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializerTest.java
index 644f38cd..c92e7cf9 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializerTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordDeserializerTest.java
@@ -18,139 +18,292 @@
 package com.lightstreamer.kafka.adapters.mapping.selectors.avro;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.AVRO;
 
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
 import com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs;
+import com.lightstreamer.kafka.adapters.mapping.selectors.avro.GenericRecordDeserializers.GenericRecordLocalSchemaDeserializer;
+import com.lightstreamer.kafka.adapters.mapping.selectors.avro.GenericRecordDeserializers.WrapperKafkaAvroDeserializer;
 import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
 
-import io.confluent.kafka.serializers.KafkaAvroDeserializer;
-
+import org.apache.avro.Schema;
+import org.apache.avro.generic.GenericData;
+import org.apache.avro.generic.GenericRecord;
+import org.apache.avro.io.DatumWriter;
+import org.apache.avro.io.Encoder;
+import org.apache.avro.io.EncoderFactory;
+import org.apache.avro.specific.SpecificDatumWriter;
+import org.apache.avro.util.Utf8;
+import org.apache.kafka.common.serialization.Deserializer;
 import org.junit.jupiter.api.Test;
 
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.util.Map;
 
 public class GenericRecordDeserializerTest {
 
+    private static final String SCHEMA_FOLDER = "src/test/resources";
+    private static final String TEST_SCHEMA_FILE = "test_schema.avsc";
+
+    private static byte[] serializeRecord(GenericRecord record) throws IOException {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        Encoder encoder = EncoderFactory.get().binaryEncoder(outputStream, null);
+        DatumWriter<GenericRecord> writer = new SpecificDatumWriter<>(record.getSchema());
+        writer.write(record, encoder);
+        encoder.flush();
+        byte[] bytes = outputStream.toByteArray();
+        return bytes;
+    }
+
     @Test
-    public void shouldDeserializeWithSchemaRegistry() {
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        SchemaRegistryConfigs.URL,
-                        "http://localhost:8080");
-        ConnectorConfig config = ConnectorConfigProvider.minimalWith(otherConfigs);
-
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaAvroDeserializer.class.getName());
+    public void shouldDeserializeWithLocalSchema() throws IOException {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
+
+        Schema.Parser parser = new Schema.Parser();
+        Schema schema =
+                parser.parse(
+                        GenericRecordDeserializerTest.class
+                                .getClassLoader()
+                                .getResourceAsStream(TEST_SCHEMA_FILE));
+        GenericRecord record = new GenericData.Record(schema);
+        record.put("firstName", "John");
+        record.put("lastName", "Doe");
+
+        byte[] bytes = serializeRecord(record);
+
+        try (Deserializer<GenericRecord> deserializer =
+                GenericRecordDeserializers.ValueDeserializer(config)) {
+            GenericRecord deserializedRecord = deserializer.deserialize("topic", bytes);
+            assertThat(deserializedRecord.get("firstName")).isEqualTo(new Utf8("John"));
+            assertThat(deserializedRecord.get("lastName")).isEqualTo(new Utf8("Doe"));
         }
+    }
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaAvroDeserializer.class.getName());
+    @Test
+    public void shouldGetKeyDeserializerWithSchemaRegsitry() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
+
+        try (Deserializer<GenericRecord> deserializer =
+                GenericRecordDeserializers.KeyDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(WrapperKafkaAvroDeserializer.class);
         }
     }
 
     @Test
-    public void shouldGetKeyDeserializeWithSchemaRegistryValueDeserializerWithLocalSchema() {
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc",
-                        SchemaRegistryConfigs.URL,
-                        "http://localhost:8080");
+    public void shouldGetValueDeserializerWithSchemaRegsitry() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
+
+        try (Deserializer<GenericRecord> deserializer =
+                GenericRecordDeserializers.ValueDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(WrapperKafkaAvroDeserializer.class);
+        }
+    }
+
+    @Test
+    public void shouldGetKeyAndVaueDeserializeWithSchemaRegisstry() {
         ConnectorConfig config =
-                ConnectorConfigProvider.minimalWith("src/test/resources", otherConfigs);
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaAvroDeserializer.class.getName());
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.KeyDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(WrapperKafkaAvroDeserializer.class);
         }
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(GenericRecordLocalSchemaDeserializer.class.getName());
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.ValueDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(WrapperKafkaAvroDeserializer.class);
         }
     }
 
     @Test
-    public void shouldDeserializeKeyWithLocalSchemaValueWithSchemaRegistry() {
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        SchemaRegistryConfigs.URL,
-                        "http://localhost:8080");
+    public void shouldGetKeyDeserializerWithLocalSchema() throws IOException {
         ConnectorConfig config =
-                ConnectorConfigProvider.minimalWith("src/test/resources", otherConfigs);
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(GenericRecordLocalSchemaDeserializer.class.getName());
+        try (Deserializer<GenericRecord> deserializer =
+                GenericRecordDeserializers.KeyDeserializer(config)) {
+            assertThat(deserializer.getClass())
+                    .isEqualTo(GenericRecordLocalSchemaDeserializer.class);
         }
+    }
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaAvroDeserializer.class.getName());
+    @Test
+    public void shouldGetValueDeserializerWithLocalSchema() throws IOException {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
+
+        try (Deserializer<GenericRecord> deserializer =
+                GenericRecordDeserializers.ValueDeserializer(config)) {
+            assertThat(deserializer.getClass())
+                    .isEqualTo(GenericRecordLocalSchemaDeserializer.class);
         }
     }
 
     @Test
     public void shouldGetKeyAndValueDeserializerWithLocalSchema() throws IOException {
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc");
         ConnectorConfig config =
-                ConnectorConfigProvider.minimalWith("src/test/resources", otherConfigs);
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE,
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
+
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.KeyDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(GenericRecordLocalSchemaDeserializer.class);
+        }
+
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.ValueDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(GenericRecordLocalSchemaDeserializer.class);
+        }
+    }
+
+    @Test
+    public void shouldGetKeyDeserializeWithSchemaRegistryValueDeserializerWithLocalSchema() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE,
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
+
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.KeyDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(WrapperKafkaAvroDeserializer.class);
+        }
+
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.ValueDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(GenericRecordLocalSchemaDeserializer.class);
+        }
+    }
+
+    @Test
+    public void shouldDeserializeKeyWithLocalSchemaValueWithSchemaRegistry() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE,
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(GenericRecordLocalSchemaDeserializer.class.getName());
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.KeyDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(GenericRecordLocalSchemaDeserializer.class);
         }
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(GenericRecordLocalSchemaDeserializer.class.getName());
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.ValueDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(WrapperKafkaAvroDeserializer.class);
         }
     }
 
     @Test
-    public void shouldDeserializazionWithLocalSchemaTakePrecedenceOverSchemaRegistry()
+    public void shouldDeserializazionWithLocalSchemaTakesPrecedenceOverSchemaRegistry()
             throws IOException {
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        SchemaRegistryConfigs.URL,
-                        "http://localhost:8080",
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc");
         ConnectorConfig config =
-                ConnectorConfigProvider.minimalWith("src/test/resources", otherConfigs);
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE,
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080",
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(GenericRecordLocalSchemaDeserializer.class.getName());
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.KeyDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(GenericRecordLocalSchemaDeserializer.class);
         }
 
-        try (GenericRecordDeserializer deser = new GenericRecordDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(GenericRecordLocalSchemaDeserializer.class.getName());
+        try (Deserializer<GenericRecord> deser =
+                GenericRecordDeserializers.ValueDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(GenericRecordLocalSchemaDeserializer.class);
         }
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorsSuppliersTest.java
similarity index 72%
rename from kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorTest.java
rename to kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorsSuppliersTest.java
index 9fcacde5..abcfd96d 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/avro/GenericRecordSelectorsSuppliersTest.java
@@ -18,14 +18,21 @@
 package com.lightstreamer.kafka.adapters.mapping.selectors.avro;
 
 import static com.google.common.truth.Truth.assertThat;
-import static com.lightstreamer.kafka.test_utils.ConsumerRecords.fromKey;
-import static com.lightstreamer.kafka.test_utils.ConsumerRecords.fromValue;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.AVRO;
 import static com.lightstreamer.kafka.test_utils.GenericRecordProvider.RECORD;
+import static com.lightstreamer.kafka.test_utils.Records.fromKey;
+import static com.lightstreamer.kafka.test_utils.Records.fromValue;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import com.google.common.truth.StringSubject;
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
+import com.lightstreamer.kafka.adapters.mapping.selectors.avro.GenericRecordDeserializers.GenericRecordLocalSchemaDeserializer;
 import com.lightstreamer.kafka.common.expressions.Expressions;
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
@@ -33,7 +40,6 @@
 import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueSelector;
 import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
 
 import org.apache.avro.generic.GenericRecord;
 import org.apache.kafka.common.serialization.Deserializer;
@@ -43,42 +49,94 @@
 
 import java.util.Map;
 
-public class GenericRecordSelectorTest {
+public class GenericRecordSelectorsSuppliersTest {
 
-    static ConnectorConfig config() {
-        return ConnectorConfigProvider.minimalWith(
-                "src/test/resources",
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc"));
-    }
+    static ConnectorConfig CONFIG =
+            ConnectorConfigProvider.minimalWith(
+                    "src/test/resources",
+                    Map.of(
+                            RECORD_KEY_EVALUATOR_TYPE,
+                            AVRO.toString(),
+                            RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                            "value.avsc",
+                            RECORD_VALUE_EVALUATOR_TYPE,
+                            AVRO.toString(),
+                            RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                            "value.avsc"));
 
     static ValueSelector<GenericRecord> valueSelector(ExtractionExpression expression)
             throws ExtractionException {
-        return TestSelectorSuppliers.avro(config())
-                .valueSelectorSupplier()
+        return new GenericRecordSelectorsSuppliers(CONFIG)
+                .makeValueSelectorSupplier()
                 .newSelector("name", expression);
     }
 
     static KeySelector<GenericRecord> keySelector(ExtractionExpression expression)
             throws ExtractionException {
-        return GenericRecordSelectorsSuppliers.keySelectorSupplier(config())
+        return new GenericRecordSelectorsSuppliers(CONFIG)
+                .makeKeySelectorSupplier()
                 .newSelector("name", expression);
     }
 
+    @Test
+    public void shouldMakeKeySelectorSupplier() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        "src/test/resources",
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                "value.avsc"));
+        GenericRecordSelectorsSuppliers s = new GenericRecordSelectorsSuppliers(config);
+        assertDoesNotThrow(() -> s.makeKeySelectorSupplier());
+    }
+
+    @Test
+    public void shouldNotMakeKeySelectorSupplierDueToMissingEvaluatorType() {
+        ConnectorConfig config = ConnectorConfigProvider.minimal();
+        GenericRecordSelectorsSuppliers s = new GenericRecordSelectorsSuppliers(config);
+        IllegalArgumentException ie =
+                assertThrows(IllegalArgumentException.class, () -> s.makeKeySelectorSupplier());
+        assertThat(ie.getMessage()).isEqualTo("Evaluator type is not AVRO");
+    }
+
+    @Test
+    public void shouldMakeValueSelectorSupplier() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        "src/test/resources",
+                        Map.of(
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                AVRO.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                "value.avsc"));
+        GenericRecordSelectorsSuppliers s = new GenericRecordSelectorsSuppliers(config);
+        assertDoesNotThrow(() -> s.makeValueSelectorSupplier());
+    }
+
+    @Test
+    public void shouldNotMakeValueSelectorSupplierDueToMissingEvaluatorType() {
+        ConnectorConfig config = ConnectorConfigProvider.minimal();
+        GenericRecordSelectorsSuppliers s = new GenericRecordSelectorsSuppliers(config);
+        IllegalArgumentException ie =
+                assertThrows(IllegalArgumentException.class, () -> s.makeValueSelectorSupplier());
+        assertThat(ie.getMessage()).isEqualTo("Evaluator type is not AVRO");
+    }
+
     @Test
     public void shouldGetDeserializer() {
         Deserializer<GenericRecord> keyDeserializer =
-                GenericRecordSelectorsSuppliers.keySelectorSupplier(config()).deseralizer();
-        assertThat(keyDeserializer).isInstanceOf(GenericRecordDeserializer.class);
-        assertThat(GenericRecordDeserializer.class.cast(keyDeserializer).isKey()).isTrue();
+                new GenericRecordSelectorsSuppliers(CONFIG).makeKeySelectorSupplier().deseralizer();
+        assertThat(keyDeserializer).isInstanceOf(GenericRecordLocalSchemaDeserializer.class);
+        // assertThat(GenericRecordDeserializer.class.cast(keyDeserializer).isKey()).isTrue();
 
         Deserializer<GenericRecord> valueDeserializer =
-                GenericRecordSelectorsSuppliers.valueSelectorSupplier(config()).deseralizer();
-        assertThat(valueDeserializer).isInstanceOf(GenericRecordDeserializer.class);
-        assertThat(GenericRecordDeserializer.class.cast(valueDeserializer).isKey()).isFalse();
+                new GenericRecordSelectorsSuppliers(CONFIG)
+                        .makeValueSelectorSupplier()
+                        .deseralizer();
+        assertThat(valueDeserializer).isInstanceOf(GenericRecordLocalSchemaDeserializer.class);
+        // assertThat(GenericRecordDeserializer.class.cast(valueDeserializer).isKey()).isFalse();
     }
 
     @ParameterizedTest(name = "[{index}] {arguments}")
@@ -107,7 +165,7 @@ public void shouldGetDeserializer() {
                         """)
     public void shouldExtractValue(String expressionStr, String expected)
             throws ExtractionException {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         StringSubject subject =
                 assertThat(valueSelector(expression).extractValue(fromValue(RECORD)).text());
         if (expected.equals("NULL")) {
@@ -139,7 +197,7 @@ public void shouldExtractValue(String expressionStr, String expected)
                         VALUE.type.attrib,            Field [attrib] not found
                         """)
     public void shouldNotExtractValue(String expressionStr, String errorMessage) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ValueException ve =
                 assertThrows(
                         ValueException.class,
@@ -172,7 +230,7 @@ public void shouldNotExtractValue(String expressionStr, String errorMessage) {
                         KEY.children[1].children[1]['name']  |  terence
                         """)
     public void shouldExtractKey(String expressionStr, String expected) throws ExtractionException {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         StringSubject subject =
                 assertThat(keySelector(expression).extractKey(fromKey(RECORD)).text());
         if (expected.equals("NULL")) {
@@ -203,7 +261,7 @@ public void shouldExtractKey(String expressionStr, String expected) throws Extra
                         KEY.type.attrib,            Field [attrib] not found
                         """)
     public void shouldNotExtractKey(String expressionStr, String errorMessage) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ValueException ve =
                 assertThrows(
                         ValueException.class,
@@ -225,7 +283,7 @@ public void shouldNotExtractKey(String expressionStr, String errorMessage) {
                         VALUE.attrib[a],     Found the invalid indexed expression [VALUE.attrib[a]] while evaluating [name]
                     """)
     public void shouldNotCreateValueSelector(String expressionStr, String expectedErrorMessage) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ExtractionException ee =
                 assertThrows(ExtractionException.class, () -> valueSelector(expression));
         assertThat(ee.getMessage()).isEqualTo(expectedErrorMessage);
@@ -245,7 +303,7 @@ public void shouldNotCreateValueSelector(String expressionStr, String expectedEr
                         KEY.attrib[a],     Found the invalid indexed expression [KEY.attrib[a]] while evaluating [name]
                     """)
     public void shouldNotCreateKeySelector(String expressionStr, String expectedErrorMessage) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ExtractionException ee =
                 assertThrows(ExtractionException.class, () -> keySelector(expression));
         assertThat(ee.getMessage()).isEqualTo(expectedErrorMessage);
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializerTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializerTest.java
index 6c14b4cb..47fd046b 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializerTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeDeserializerTest.java
@@ -18,210 +18,329 @@
 package com.lightstreamer.kafka.adapters.mapping.selectors.json;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.JSON;
 
+import static org.junit.Assert.assertThrows;
+
+import com.fasterxml.jackson.databind.JsonNode;
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
 import com.lightstreamer.kafka.adapters.config.SchemaRegistryConfigs;
+import com.lightstreamer.kafka.adapters.mapping.selectors.json.JsonNodeDeserializers.JsonNodeLocalDeserializer;
 import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
 
 import io.confluent.kafka.serializers.KafkaJsonDeserializer;
 import io.confluent.kafka.serializers.json.KafkaJsonSchemaDeserializer;
 
+import org.apache.kafka.common.errors.SerializationException;
+import org.apache.kafka.common.serialization.Deserializer;
 import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.util.Map;
 
 public class JsonNodeDeserializerTest {
 
+    private static final String SCHEMA_FOLDER = "src/test/resources";
+    private static final String TEST_SCHEMA_FILE = "flights.json";
+
     @Test
     public void shouldDeserializeWithNoSchema() {
         String s = "{\"stock_name\":\"Ations Europe\"}";
         ConnectorConfig config =
                 ConnectorConfigProvider.minimalWith(
-                        Map.of(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE, "JSON"));
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, false)) {
+                        Map.of(RECORD_VALUE_EVALUATOR_TYPE, JSON.toString()));
+        try (Deserializer<JsonNode> deser = JsonNodeDeserializers.ValueDeserializer(config)) {
             deser.deserialize("topic", s.getBytes());
         }
     }
 
+    @Test
+    public void shouldDeserializeWithLocalSchema() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
+
+        String flight =
+                """
+          {
+            "airline": "Lightstreamer Airlines",
+            "code": "LA1704",
+            "departureTime": "19:25",
+            "status": "SCHEDULED_ON_TIME",
+            "terminal": 1
+          }
+                """;
+        try (Deserializer<JsonNode> deserializer =
+                JsonNodeDeserializers.ValueDeserializer(config)) {
+            JsonNode node = deserializer.deserialize("topic", flight.getBytes());
+            assertThat(node.get("airline").asText()).isEqualTo("Lightstreamer Airlines");
+            assertThat(node.get("code").asText()).isEqualTo("LA1704");
+            assertThat(node.get("departureTime").asText()).isEqualTo("19:25");
+            assertThat(node.get("status").asText()).isEqualTo("SCHEDULED_ON_TIME");
+            assertThat(node.get("terminal").asInt()).isEqualTo(1);
+        }
+    }
+
+    @Test
+    public void shouldNotDeserializeWithLocalSchemaDueToInvalidRecord() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
+
+        // Missing required 'terminal' key
+        String flight =
+                """
+          {
+            "airline": "Lightstreamer Airlies",
+            "code": "LA1704",
+            "departureTime": "2025-01-01:12.05.00",
+            "status": "SCHEDULED_ON_TIME"
+          }
+                """;
+        try (Deserializer<JsonNode> deser = JsonNodeDeserializers.ValueDeserializer(config)) {
+            SerializationException se =
+                    assertThrows(
+                            SerializationException.class,
+                            () -> deser.deserialize("topic", flight.getBytes()));
+            assertThat(se.getMessage()).contains("required key [terminal] not found");
+        }
+    }
+
     @Test
     public void shouldGetKeyAndValueDeserializerWithNoSchema() {
         ConnectorConfig config =
                 ConnectorConfigProvider.minimalWith(
                         Map.of(
-                                ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE,
-                                "JSON",
-                                ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE,
-                                "JSON"));
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonDeserializer.class.getName());
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString()));
+        try (Deserializer<JsonNode> deserializer = JsonNodeDeserializers.KeyDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(KafkaJsonDeserializer.class);
         }
 
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonDeserializer.class.getName());
+        try (Deserializer<JsonNode> deserializer =
+                JsonNodeDeserializers.ValueDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(KafkaJsonDeserializer.class);
         }
     }
 
     @Test
     public void shouldGeKeyDeserializerWithSchemaRegistry() {
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE,
-                        "JSON",
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        SchemaRegistryConfigs.URL,
-                        "http://localhost:8080");
-        ConnectorConfig config = ConnectorConfigProvider.minimalWith(otherConfigs);
-
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonSchemaDeserializer.class.getName());
-        }
-
-        // No specific settings for the value deserializer, therefore the
-        // KafkaJsonDeserializer is expected here
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonDeserializer.class.getName());
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
+
+        try (Deserializer<JsonNode> deserializer = JsonNodeDeserializers.KeyDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(KafkaJsonSchemaDeserializer.class);
         }
     }
 
     @Test
     public void shouldGetValueDeserializerWithSchemaRegsitry() {
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE,
-                        "JSON",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        SchemaRegistryConfigs.URL,
-                        "http://localhost:8080");
-        ConnectorConfig config = ConnectorConfigProvider.minimalWith(otherConfigs);
-
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonSchemaDeserializer.class.getName());
-        }
-
-        // No specific settings for the key deserializer, therefore the
-        // KafkaJsonDeserializer is expected here
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonDeserializer.class.getName());
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
+
+        try (Deserializer<JsonNode> deserializer =
+                JsonNodeDeserializers.ValueDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(KafkaJsonSchemaDeserializer.class);
         }
     }
 
     @Test
     public void shouldGetKeyAndVaueDeserializeWithSchemaRegisstry() {
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE,
-                        "JSON",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE,
-                        "JSON",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
-                        "true",
-                        SchemaRegistryConfigs.URL,
-                        "http://localhost:8080");
-
-        ConnectorConfig config = ConnectorConfigProvider.minimalWith(otherConfigs);
-
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonSchemaDeserializer.class.getName());
-        }
-
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonSchemaDeserializer.class.getName());
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
+
+        try (Deserializer<JsonNode> deserializer = JsonNodeDeserializers.KeyDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(KafkaJsonSchemaDeserializer.class);
+        }
+
+        try (Deserializer<JsonNode> deserializer =
+                JsonNodeDeserializers.ValueDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(KafkaJsonSchemaDeserializer.class);
         }
     }
 
     @Test
     public void shouldGetKeyDeserializerWithLocalSchema() throws IOException {
-        Path adapterDir = Files.createTempDirectory("adapter_dir");
-        Path keySchemaFile = Files.createTempFile(adapterDir, "key_schema_", "json");
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE,
-                        "JSON",
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
-                        keySchemaFile.toFile().getName());
         ConnectorConfig config =
-                ConnectorConfigProvider.minimalWith(adapterDir.toString(), otherConfigs);
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
+
+        try (Deserializer<JsonNode> deserializer = JsonNodeDeserializers.KeyDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(JsonNodeLocalDeserializer.class);
+        }
+    }
+
+    @Test
+    public void shouldGetValueDeserializerWithLocalSchema() throws IOException {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
+
+        try (Deserializer<JsonNode> deserializer =
+                JsonNodeDeserializers.ValueDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(JsonNodeLocalDeserializer.class);
+        }
+    }
+
+    @Test
+    public void shouldGetKeyAndValueDeserializerWithLocalSchema() throws IOException {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE,
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
+
+        try (Deserializer<JsonNode> deserializer = JsonNodeDeserializers.KeyDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(JsonNodeLocalDeserializer.class);
+        }
+
+        try (Deserializer<JsonNode> deserializer =
+                JsonNodeDeserializers.ValueDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(JsonNodeLocalDeserializer.class);
+        }
+    }
+
+    @Test
+    public void shouldGetKeyDeserializeWithSchemaRegistryValueDeserializerWithLocalSchema() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE,
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
 
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(JsonLocalSchemaDeserializer.class.getName());
+        try (Deserializer<JsonNode> deser = JsonNodeDeserializers.KeyDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(KafkaJsonSchemaDeserializer.class);
         }
 
-        // No specific settings for the value deserializer, therefore the
-        // KafkaJsonDeserializer is expected here
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonDeserializer.class.getName());
+        try (Deserializer<JsonNode> deser = JsonNodeDeserializers.ValueDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(JsonNodeLocalDeserializer.class);
         }
     }
 
     @Test
-    public void shouldGetValueDeserializerWithLocalSchema() throws IOException {
-        Path adapterDir = Files.createTempDirectory("adapter_dir");
-        Path valueSchemaFile = Files.createTempFile(adapterDir, "value_schema_", "json");
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE,
-                        "JSON",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                        valueSchemaFile.toFile().getName());
+    public void shouldDeserializeKeyWithLocalSchemaValueWithSchemaRegistry() {
         ConnectorConfig config =
-                ConnectorConfigProvider.minimalWith(adapterDir.toString(), otherConfigs);
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE,
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080"));
 
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, false)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(JsonLocalSchemaDeserializer.class.getName());
+        try (Deserializer<JsonNode> deser = JsonNodeDeserializers.KeyDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(JsonNodeLocalDeserializer.class);
         }
 
-        // No specific settings for the key deserializer, therefore the
-        // KafkaJsonDeserializer is expected here
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(KafkaJsonDeserializer.class.getName());
+        try (Deserializer<JsonNode> deser = JsonNodeDeserializers.ValueDeserializer(config)) {
+            assertThat(deser.getClass()).isEqualTo(KafkaJsonSchemaDeserializer.class);
         }
     }
 
     @Test
-    public void shouldGetKeyAndValueDeserializerWithLocalSchema() throws IOException {
-        Path adapterDir = Files.createTempDirectory("adapter_dir");
-        Path keySchemaFile = Files.createTempFile(adapterDir, "key_schema_", "json");
-        Path valueSchemaFile = Files.createTempFile(adapterDir, "value_schema_", "json");
-        Map<String, String> otherConfigs =
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE,
-                        "JSON",
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
-                        keySchemaFile.toFile().getName(),
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE,
-                        "JSON",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                        valueSchemaFile.toFile().getName());
+    public void shouldDeserializazionWithLocalSchemaTakePrecedenceOverSchemaRegistry()
+            throws IOException {
         ConnectorConfig config =
-                ConnectorConfigProvider.minimalWith(adapterDir.toString(), otherConfigs);
+                ConnectorConfigProvider.minimalWith(
+                        SCHEMA_FOLDER,
+                        Map.of(
+                                RECORD_KEY_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_KEY_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE,
+                                RECORD_VALUE_EVALUATOR_TYPE,
+                                JSON.toString(),
+                                RECORD_VALUE_EVALUATOR_SCHEMA_REGISTRY_ENABLE,
+                                "true",
+                                SchemaRegistryConfigs.URL,
+                                "http://localhost:8080",
+                                RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                                TEST_SCHEMA_FILE));
 
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(JsonLocalSchemaDeserializer.class.getName());
+        try (Deserializer<JsonNode> deserializer = JsonNodeDeserializers.KeyDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(JsonNodeLocalDeserializer.class);
         }
 
-        try (JsonNodeDeserializer deser = new JsonNodeDeserializer(config, true)) {
-            assertThat(deser.deserializerClassName())
-                    .isEqualTo(JsonLocalSchemaDeserializer.class.getName());
+        try (Deserializer<JsonNode> deserializer =
+                JsonNodeDeserializers.ValueDeserializer(config)) {
+            assertThat(deserializer.getClass()).isEqualTo(JsonNodeLocalDeserializer.class);
         }
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorsSuppliersTest.java
similarity index 65%
rename from kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorTest.java
rename to kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorsSuppliersTest.java
index 305b8d42..3a85f3de 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/json/JsonNodeSelectorsSuppliersTest.java
@@ -18,10 +18,14 @@
 package com.lightstreamer.kafka.adapters.mapping.selectors.json;
 
 import static com.google.common.truth.Truth.assertThat;
-import static com.lightstreamer.kafka.test_utils.ConsumerRecords.fromKey;
-import static com.lightstreamer.kafka.test_utils.ConsumerRecords.fromValue;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.JSON;
 import static com.lightstreamer.kafka.test_utils.JsonNodeProvider.RECORD;
+import static com.lightstreamer.kafka.test_utils.Records.fromKey;
+import static com.lightstreamer.kafka.test_utils.Records.fromValue;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import com.fasterxml.jackson.databind.JsonNode;
@@ -31,42 +35,121 @@
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
 import com.lightstreamer.kafka.common.mapping.selectors.KeySelector;
+import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueSelector;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
 import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
 
+import io.confluent.kafka.serializers.KafkaJsonDeserializer;
+
 import org.apache.kafka.common.serialization.Deserializer;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
 
-public class JsonNodeSelectorTest {
+import java.util.Map;
+
+public class JsonNodeSelectorsSuppliersTest {
 
-    static ConnectorConfig config = ConnectorConfigProvider.minimal();
+    // A configuration with proper evaluator type settings for key and value
+    static ConnectorConfig CONFIG =
+            ConnectorConfigProvider.minimalWith(
+                    Map.of(
+                            RECORD_KEY_EVALUATOR_TYPE,
+                            JSON.toString(),
+                            RECORD_VALUE_EVALUATOR_TYPE,
+                            JSON.toString()));
 
     static ValueSelector<JsonNode> valueSelector(ExtractionExpression expression)
             throws ExtractionException {
-        return JsonNodeSelectorsSuppliers.valueSelectorSupplier(config)
+        return new JsonNodeSelectorsSuppliers(CONFIG)
+                .makeValueSelectorSupplier()
                 .newSelector("name", expression);
     }
 
     static KeySelector<JsonNode> keySelector(ExtractionExpression expression)
             throws ExtractionException {
-        return JsonNodeSelectorsSuppliers.keySelectorSupplier(config)
+        return new JsonNodeSelectorsSuppliers(CONFIG)
+                .makeKeySelectorSupplier()
                 .newSelector("name", expression);
     }
 
+    @Test
+    public void shouldMakeKeySelectorSupplier() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_KEY_EVALUATOR_TYPE, JSON.toString()));
+        JsonNodeSelectorsSuppliers s = new JsonNodeSelectorsSuppliers(config);
+        assertDoesNotThrow(() -> s.makeKeySelectorSupplier());
+    }
+
+    @Test
+    public void shouldNotMakeKeySelectorSupplierDueToMissingEvaluatorType() {
+        // Configure the key evaluator type, but leave default settings for
+        // RECORD_KEY_EVALUATOR_TYPE (String)
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_VALUE_EVALUATOR_TYPE, JSON.toString()));
+        JsonNodeSelectorsSuppliers s = new JsonNodeSelectorsSuppliers(config);
+        IllegalArgumentException ie =
+                assertThrows(IllegalArgumentException.class, () -> s.makeKeySelectorSupplier());
+        assertThat(ie.getMessage()).isEqualTo("Evaluator type is not JSON");
+    }
+
+    @Test
+    public void shouldMakeKeySelectorSupplierWithNoConfig() {
+        JsonNodeSelectorsSuppliers s = new JsonNodeSelectorsSuppliers();
+        KeySelectorSupplier<JsonNode> keySelectorSupplier = s.makeKeySelectorSupplier();
+        assertThat(keySelectorSupplier.deseralizer().getClass())
+                .isEqualTo(KafkaJsonDeserializer.class);
+    }
+
+    @Test
+    public void shouldMakeValueSelectorSupplierWithNoConfig() {
+        JsonNodeSelectorsSuppliers s = new JsonNodeSelectorsSuppliers();
+        ValueSelectorSupplier<JsonNode> valueSelectorSupplier = s.makeValueSelectorSupplier();
+        assertThat(valueSelectorSupplier.deseralizer().getClass())
+                .isEqualTo(KafkaJsonDeserializer.class);
+    }
+
+    @Test
+    public void shouldMakeValueSelectorSupplier() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_VALUE_EVALUATOR_TYPE, JSON.toString()));
+        JsonNodeSelectorsSuppliers s = new JsonNodeSelectorsSuppliers(config);
+        assertDoesNotThrow(() -> s.makeValueSelectorSupplier());
+    }
+
+    @Test
+    public void shouldNotMakeValueSelectorSupplierDueToMissingEvaluatorType() {
+        // Configure the key evaluator type, but leave default settings for
+        // RECORD_VALUE_EVALUATOR_TYPE (String)
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_KEY_EVALUATOR_TYPE, JSON.toString()));
+        JsonNodeSelectorsSuppliers s = new JsonNodeSelectorsSuppliers(config);
+        IllegalArgumentException ie =
+                assertThrows(IllegalArgumentException.class, () -> s.makeValueSelectorSupplier());
+        assertThat(ie.getMessage()).isEqualTo("Evaluator type is not JSON");
+    }
+
     @Test
     public void shouldGetDeserializer() {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_KEY_EVALUATOR_TYPE, JSON.toString()));
+
         Deserializer<JsonNode> keyDeserializer =
-                JsonNodeSelectorsSuppliers.keySelectorSupplier(config).deseralizer();
-        assertThat(keyDeserializer).isInstanceOf(JsonNodeDeserializer.class);
-        assertThat(JsonNodeDeserializer.class.cast(keyDeserializer).isKey()).isTrue();
-
-        Deserializer<JsonNode> valueDeserializer =
-                JsonNodeSelectorsSuppliers.valueSelectorSupplier(config).deseralizer();
-        assertThat(valueDeserializer).isInstanceOf(JsonNodeDeserializer.class);
-        assertThat(JsonNodeDeserializer.class.cast(valueDeserializer).isKey()).isFalse();
+                new JsonNodeSelectorsSuppliers(config).makeKeySelectorSupplier().deseralizer();
+        assertThat(keyDeserializer).isInstanceOf(KafkaJsonDeserializer.class);
+        // assertThat(JsonNodeDeserializer.class.cast(keyDeserializer).isKey()).isTrue();
+
+        // Deserializer<JsonNode> valueDeserializer =
+        //         new JsonNodeSelectorsSuppliers(CONFIG).makeValueSelectorSupplier().deseralizer();
+        // assertThat(valueDeserializer).isInstanceOf(KafkaJsonDeserializer.class);
+        // assertThat(JsonNodeDeserializer.class.cast(valueDeserializer).isKey()).isFalse();
     }
 
     @ParameterizedTest(name = "[{index}] {arguments}")
@@ -86,10 +169,14 @@ public void shouldGetDeserializer() {
                         VALUE.children[1].children[0].name,     gloria
                         VALUE.children[1].children[1].name,     terence
                         VALUE.children[1].children[1]['name'],  terence
+                        VALUE.family[0][0].name,                bro00
+                        VALUE.family[0][1].name,                bro01
+                        VALUE.family[1][0].name,                bro10
+                        VALUE.family[1][1].name,                bro11
                         """)
     public void shouldExtractValue(String expressionStr, String expected)
             throws ExtractionException {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         StringSubject subject =
                 assertThat(valueSelector(expression).extractValue(fromValue(RECORD)).text());
         if (expected.equals("NULL")) {
@@ -118,7 +205,7 @@ public void shouldExtractValue(String expressionStr, String expected)
                         VALUE.children[4].name,       Field not found at index [4]
                         """)
     public void shouldNotExtractValue(String expressionStr, String errorMessage) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ValueException ve =
                 assertThrows(
                         ValueException.class,
@@ -145,7 +232,7 @@ public void shouldNotExtractValue(String expressionStr, String errorMessage) {
                         KEY.children[1].children[1]['name'],  terence
                         """)
     public void shouldExtractKey(String expressionStr, String expected) throws ExtractionException {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         StringSubject subject =
                 assertThat(keySelector(expression).extractKey(fromKey(RECORD)).text());
         if (expected.equals("NULL")) {
@@ -173,7 +260,7 @@ public void shouldExtractKey(String expressionStr, String expected) throws Extra
                         KEY.children[4].name,       Field not found at index [4]
                         """)
     public void shouldNotExtractKey(String expressionStr, String errorMessage) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ValueException ve =
                 assertThrows(
                         ValueException.class,
@@ -195,7 +282,7 @@ public void shouldNotExtractKey(String expressionStr, String errorMessage) {
                         VALUE.attrib[a],     Found the invalid indexed expression [VALUE.attrib[a]] while evaluating [name]
                     """)
     public void shouldNotCreateValueSelector(String expressionStr, String expectedErrorMessage) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ExtractionException ee =
                 assertThrows(ExtractionException.class, () -> valueSelector(expression));
         assertThat(ee.getMessage()).isEqualTo(expectedErrorMessage);
@@ -215,7 +302,7 @@ public void shouldNotCreateValueSelector(String expressionStr, String expectedEr
                         KEY.attrib[a],     Found the invalid indexed expression [KEY.attrib[a]] while evaluating [name]
                     """)
     public void shouldNotCreateKeySelector(String expressionStr, String expectedErrorMessage) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ExtractionException ee =
                 assertThrows(ExtractionException.class, () -> keySelector(expression));
         assertThat(ee.getMessage()).isEqualTo(expectedErrorMessage);
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/others/OthersSelectorsTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/others/OthersSelectorsTest.java
index 76ba883f..b621b90c 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/others/OthersSelectorsTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/adapters/mapping/selectors/others/OthersSelectorsTest.java
@@ -18,8 +18,12 @@
 package com.lightstreamer.kafka.adapters.mapping.selectors.others;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.BOOLEAN;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.BYTES;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.BYTE_ARRAY;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.BYTE_BUFFER;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.DOUBLE;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.FLOAT;
 import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.INTEGER;
@@ -31,16 +35,16 @@
 import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
 
+import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
 import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType;
 import com.lightstreamer.kafka.common.expressions.Expressions;
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
 import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.KeySelector;
 import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
-import com.lightstreamer.kafka.common.mapping.selectors.ValueSelector;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
-import com.lightstreamer.kafka.test_utils.ConsumerRecords;
+import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
+import com.lightstreamer.kafka.test_utils.Records;
 
 import org.apache.kafka.common.serialization.Serde;
 import org.apache.kafka.common.serialization.Serdes;
@@ -51,27 +55,63 @@
 import org.junit.jupiter.params.provider.MethodSource;
 
 import java.nio.ByteBuffer;
+import java.util.Map;
 import java.util.UUID;
 import java.util.stream.Stream;
 
 public class OthersSelectorsTest {
 
-    static ValueSelector<?> valueSelector(EvaluatorType type, ExtractionExpression expression)
-            throws ExtractionException {
-        return OthersSelectorSuppliers.valueSelectorSupplier(type).newSelector("name", expression);
+    static Stream<Arguments> evaluatorTypes() {
+        return Stream.of(
+                arguments(STRING, Serdes.String().deserializer().getClass()),
+                arguments(INTEGER, Serdes.Integer().deserializer().getClass()),
+                arguments(BOOLEAN, Serdes.Boolean().deserializer().getClass()),
+                arguments(BYTE_ARRAY, Serdes.ByteArray().deserializer().getClass()),
+                arguments(BYTE_BUFFER, Serdes.ByteBuffer().deserializer().getClass()),
+                arguments(BYTES, Serdes.Bytes().deserializer().getClass()),
+                arguments(DOUBLE, Serdes.Double().deserializer().getClass()),
+                arguments(FLOAT, Serdes.Float().deserializer().getClass()),
+                arguments(LONG, Serdes.Long().deserializer().getClass()),
+                arguments(SHORT, Serdes.Short().deserializer().getClass()),
+                arguments(UUID, Serdes.UUID().deserializer().getClass()));
     }
 
-    static KeySelector<?> keySelector(EvaluatorType type, ExtractionExpression expression)
-            throws ExtractionException {
-        return OthersSelectorSuppliers.keySelectorSupplier(type).newSelector("name", expression);
+    @Test
+    public void shouldConfigWithDefaults() {
+        ConnectorConfig config = ConnectorConfigProvider.minimal();
+        OthersSelectorSuppliers s = new OthersSelectorSuppliers(config);
+        assertThat(s.keyEvaluatorType().is(STRING)).isTrue();
+        assertThat(s.valueEvaluatorType().is(STRING)).isTrue();
     }
 
-    static ValueSelectorSupplier<?> valueSelectorSupplier(EvaluatorType type) {
-        return OthersSelectorSuppliers.valueSelectorSupplier(type);
+    @ParameterizedTest
+    @MethodSource("evaluatorTypes")
+    public void shouldConfigKeyEvaluator(EvaluatorType type, Class<?> expectedDeserializer) {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_KEY_EVALUATOR_TYPE, type.toString()));
+        OthersSelectorSuppliers s = new OthersSelectorSuppliers(config);
+        assertThat(s.keyEvaluatorType().is(type)).isTrue();
+
+        KeySelectorSupplier<Object> keySelectorSupplier = s.makeKeySelectorSupplier();
+        assertThat(keySelectorSupplier.deseralizer()).isInstanceOf(expectedDeserializer);
+
+        assertThat(s.valueEvaluatorType().is(STRING)).isTrue();
     }
 
-    static KeySelectorSupplier<?> keySelectorSupplier(EvaluatorType type) {
-        return OthersSelectorSuppliers.keySelectorSupplier(type);
+    @ParameterizedTest
+    @MethodSource("evaluatorTypes")
+    public void shouldConfigValueEvaluator(EvaluatorType type, Class<?> expectedDeserializer) {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_VALUE_EVALUATOR_TYPE, type.toString()));
+        OthersSelectorSuppliers s = new OthersSelectorSuppliers(config);
+        assertThat(s.valueEvaluatorType().is(type)).isTrue();
+
+        ValueSelectorSupplier<Object> valueSelectorSupplier = s.makeValueSelectorSupplier();
+        assertThat(valueSelectorSupplier.deseralizer()).isInstanceOf(expectedDeserializer);
+
+        assertThat(s.keyEvaluatorType().is(STRING)).isTrue();
     }
 
     static Stream<Arguments> recordArgs() {
@@ -101,14 +141,20 @@ static Stream<Arguments> recordArgs() {
     @MethodSource("recordArgs")
     public void shouldDeserializeAndExtractValue(EvaluatorType type, Serde serde, Object data)
             throws ExtractionException {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_VALUE_EVALUATOR_TYPE, type.toString()));
+
         byte[] bytes = serde.serializer().serialize("topic", data);
-        ValueSelectorSupplier<?> valueSupplier = valueSelectorSupplier(type);
+        OthersSelectorSuppliers othersSelectorSuppliers = new OthersSelectorSuppliers(config);
+        ValueSelectorSupplier<?> valueSupplier =
+                othersSelectorSuppliers.makeValueSelectorSupplier();
         Object deserializedData = valueSupplier.deseralizer().deserialize("topic", bytes);
 
-        KafkaRecord kafkaRecord = ConsumerRecords.fromValue(deserializedData);
+        KafkaRecord kafkaRecord = Records.fromValue(deserializedData);
         String text =
                 valueSupplier
-                        .newSelector("name", Expressions.expression("VALUE"))
+                        .newSelector("name", Expressions.Expression("VALUE"))
                         .extractValue(kafkaRecord)
                         .text();
         assertThat(text).isEqualTo(String.valueOf(data));
@@ -117,52 +163,68 @@ public void shouldDeserializeAndExtractValue(EvaluatorType type, Serde serde, Ob
     @SuppressWarnings({"rawtypes", "unchecked"})
     @Test
     public void shouldExtractNullValue() throws ExtractionException {
-        ValueSelectorSupplier<?> valueSupplier = valueSelectorSupplier(EvaluatorType.INTEGER);
-        KafkaRecord kafkaRecord = ConsumerRecords.fromValue((Object) null);
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_VALUE_EVALUATOR_TYPE, INTEGER.toString()));
+        ValueSelectorSupplier<?> valueSupplier =
+                new OthersSelectorSuppliers(config).makeValueSelectorSupplier();
+        KafkaRecord kafkaRecord = Records.fromValue((Object) null);
         String text =
                 valueSupplier
-                        .newSelector("name", Expressions.expression("VALUE"))
+                        .newSelector("name", Expressions.Expression("VALUE"))
                         .extractValue(kafkaRecord)
                         .text();
         assertThat(text).isNull();
     }
 
-    @SuppressWarnings({"unchecked", "rawtypes"})
-    @Test
-    public void shouldExtractNullKey() throws ExtractionException {
-        KeySelectorSupplier<?> valueSupplier = keySelectorSupplier(EvaluatorType.INTEGER);
-        KafkaRecord kafkaRecord = ConsumerRecords.fromKey((Object) null);
-        String text =
-                valueSupplier
-                        .newSelector("name", Expressions.expression("KEY"))
-                        .extractKey(kafkaRecord)
-                        .text();
-        assertThat(text).isNull();
-    }
-
     @SuppressWarnings({"unchecked", "rawtypes"})
     @ParameterizedTest()
     @MethodSource("recordArgs")
     public void shouldDeserializeAndExtractKey(EvaluatorType type, Serde serde, Object data)
             throws ExtractionException {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_KEY_EVALUATOR_TYPE, type.toString()));
+        KeySelectorSupplier<?> keySupplier =
+                new OthersSelectorSuppliers(config).makeKeySelectorSupplier();
         byte[] bytes = serde.serializer().serialize("topic", data);
-        KeySelectorSupplier<?> valueSupplier = keySelectorSupplier(type);
-        Object deserializedData = valueSupplier.deseralizer().deserialize("topic", bytes);
+        Object deserializedData = keySupplier.deseralizer().deserialize("topic", bytes);
 
-        KafkaRecord kafkaRecord = ConsumerRecords.fromKey(deserializedData);
+        KafkaRecord kafkaRecord = Records.fromKey(deserializedData);
         String text =
-                valueSupplier
-                        .newSelector("name", Expressions.expression("KEY"))
+                keySupplier
+                        .newSelector("name", Expressions.Expression("KEY"))
                         .extractKey(kafkaRecord)
                         .text();
         assertThat(text).isEqualTo(String.valueOf(data));
     }
 
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    @Test
+    public void shouldExtractNullKey() throws ExtractionException {
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_KEY_EVALUATOR_TYPE, INTEGER.toString()));
+        KeySelectorSupplier<?> keySupplier =
+                new OthersSelectorSuppliers(config).makeKeySelectorSupplier();
+        KafkaRecord kafkaRecord = Records.fromKey((Object) null);
+        String text =
+                keySupplier
+                        .newSelector("name", Expressions.Expression("KEY"))
+                        .extractKey(kafkaRecord)
+                        .text();
+        assertThat(text).isNull();
+    }
+
     @ParameterizedTest()
     @MethodSource("recordArgs")
     public void shouldNotCreateSelector(EvaluatorType type) throws ExtractionException {
-        ValueSelectorSupplier<?> valueSupplier = valueSelectorSupplier(type);
-        ExtractionExpression expression = Expressions.expression("VALUE.a");
+        ConnectorConfig config =
+                ConnectorConfigProvider.minimalWith(
+                        Map.of(RECORD_VALUE_EVALUATOR_TYPE, INTEGER.toString()));
+        ValueSelectorSupplier<?> valueSupplier =
+                new OthersSelectorSuppliers(config).makeValueSelectorSupplier();
+        ExtractionExpression expression = Expressions.Expression("VALUE.a");
         ExtractionException ee =
                 assertThrows(
                         ExtractionException.class,
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/FieldConfigsTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/FieldConfigsTest.java
index 24d373c8..2fb5f04c 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/FieldConfigsTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/FieldConfigsTest.java
@@ -21,6 +21,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import com.lightstreamer.kafka.adapters.mapping.selectors.others.OthersSelectorSuppliers;
 import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
 import com.lightstreamer.kafka.common.mapping.selectors.Schema;
@@ -42,7 +43,8 @@ public class FieldConfigsTest {
     void shoudCreateAndMakeExtractor(String expression) throws ExtractionException {
         Map<String, String> fieldMappings = Map.of("field1", expression);
         FieldConfigs configs = FieldConfigs.from(fieldMappings);
-        DataExtractor<String, String> extractor = configs.extractor(TestSelectorSuppliers.string());
+        DataExtractor<String, String> extractor =
+                configs.extractor(OthersSelectorSuppliers.String());
         Schema schema = extractor.schema();
         assertThat(schema.name()).isEqualTo("fields");
         assertThat(schema.keys()).isEqualTo(fieldMappings.keySet());
@@ -55,7 +57,7 @@ void shoudFailCreateExtractor() {
         ExtractionException ee =
                 assertThrows(
                         ExtractionException.class,
-                        () -> configs.extractor(TestSelectorSuppliers.string()));
+                        () -> configs.extractor(OthersSelectorSuppliers.String()));
         assertThat(ee.getMessage())
                 .isEqualTo(
                         "Found the invalid expression [VALUE.notAllowedAttrib] for scalar values while evaluating [field1]");
@@ -75,7 +77,7 @@ void shoudCreateAndMakeExtractorForComplexSupplier(String expression)
             throws ExtractionException {
         Map<String, String> fieldMappings = Map.of("field1", expression);
         FieldConfigs configs = FieldConfigs.from(fieldMappings);
-        DataExtractor<Object, Object> extractor = configs.extractor(TestSelectorSuppliers.object());
+        DataExtractor<Object, Object> extractor = configs.extractor(TestSelectorSuppliers.Object());
         Schema schema = extractor.schema();
         assertThat(schema.name()).isEqualTo("fields");
         assertThat(schema.keys()).isEqualTo(fieldMappings.keySet());
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/ItemReferenceTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/ItemReferenceTest.java
index f8f06de8..3b986c14 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/ItemReferenceTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/ItemReferenceTest.java
@@ -59,16 +59,16 @@ void shouldCreateTemplates() {
         ItemReference i1 =
                 ItemReference.template(
                         new TemplateExpression(
-                                "template-prefix", Map.of("a", Expressions.expression("VALUE"))));
+                                "template-prefix", Map.of("a", Expressions.Expression("VALUE"))));
         assertThat(i1.isTemplate()).isTrue();
         assertThat(i1.template().prefix()).isEqualTo("template-prefix");
-        assertThat(i1.template().params()).containsExactly("a", Expressions.expression("VALUE"));
+        assertThat(i1.template().params()).containsExactly("a", Expressions.Expression("VALUE"));
         assertThrows(RuntimeException.class, () -> i1.itemName());
 
         ItemReference i2 =
                 ItemReference.template(
                         new TemplateExpression(
-                                "template-prefix", Map.of("a", Expressions.expression("VALUE"))));
+                                "template-prefix", Map.of("a", Expressions.Expression("VALUE"))));
         assertThat(i1.equals(i2)).isTrue();
         assertThat(i1.hashCode() == i2.hashCode()).isTrue();
     }
@@ -89,7 +89,7 @@ void shouldCreateTemplateFromFactoryMethod() {
         assertThat(i1.isTemplate()).isTrue();
         TemplateExpression te = i1.template();
         assertThat(te.prefix()).isEqualTo("template");
-        assertThat(te.params()).containsAtLeast("a", Expressions.expression("VALUE"));
+        assertThat(te.params()).containsAtLeast("a", Expressions.Expression("VALUE"));
     }
 
     @Test
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/ItemTemplateConfigsTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/ItemTemplateConfigsTest.java
index 2b6e62fc..252eae29 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/ItemTemplateConfigsTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/ItemTemplateConfigsTest.java
@@ -56,7 +56,7 @@ void shouldCreateItemTemplateConfigFromMapWithOneEntryOneParam() {
         assertThat(it.contains("template-name")).isTrue();
         TemplateExpression expression = it.getExpression("template-name");
         assertThat(expression.prefix()).isEqualTo("template-prefix");
-        assertThat(expression.params()).containsExactly("param", Expressions.expression("OFFSET"));
+        assertThat(expression.params()).containsExactly("param", Expressions.Expression("OFFSET"));
     }
 
     @Test
@@ -73,11 +73,11 @@ void shouldCreateItemTemplateConfigFromMapWithOneEntryMultipleParams() {
         assertThat(expression.params())
                 .containsExactly(
                         "param1",
-                        Expressions.expression("OFFSET"),
+                        Expressions.Expression("OFFSET"),
                         "param2",
-                        Expressions.expression("PARTITION"),
+                        Expressions.Expression("PARTITION"),
                         "param3",
-                        Expressions.expression("TIMESTAMP"));
+                        Expressions.Expression("TIMESTAMP"));
     }
 
     @Test
@@ -97,22 +97,22 @@ void shouldCreateItemTemplateConfigFromMapWithMultipleEntriesMultipleParams() {
         assertThat(expression_a.params())
                 .containsExactly(
                         "param1a",
-                        Expressions.expression("VALUE"),
+                        Expressions.Expression("VALUE"),
                         "param2a",
-                        Expressions.expression("KEY"),
+                        Expressions.Expression("KEY"),
                         "param3a",
-                        Expressions.expression("PARTITION"));
+                        Expressions.Expression("PARTITION"));
 
         TemplateExpression expression_b = it.getExpression("template-name-b");
         assertThat(expression_b.prefix()).isEqualTo("template-prefix-b");
         assertThat(expression_b.params())
                 .containsExactly(
                         "param1b",
-                        Expressions.expression("VALUE.b"),
+                        Expressions.Expression("VALUE.b"),
                         "param2b",
-                        Expressions.expression("KEY.b"),
+                        Expressions.Expression("KEY.b"),
                         "param3b",
-                        Expressions.expression("KEY.c"));
+                        Expressions.Expression("KEY.c"));
     }
 
     @ParameterizedTest
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/TopicConfigurationsTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/TopicConfigurationsTest.java
index c37a9d85..873bed17 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/TopicConfigurationsTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/config/TopicConfigurationsTest.java
@@ -61,7 +61,7 @@ void shouldConfigOneToOneTemplate() {
 
         TemplateExpression te = itemReference.template();
         assertThat(te.prefix()).isEqualTo("template1");
-        assertThat(te.params()).containsExactly("a", Expressions.expression("PARTITION"));
+        assertThat(te.params()).containsExactly("a", Expressions.Expression("PARTITION"));
     }
 
     @Test
@@ -117,12 +117,12 @@ void shouldConfigOneToManyTemplates() {
 
         TemplateExpression te1 = itemReference1.template();
         assertThat(te1.prefix()).isEqualTo("template1");
-        assertThat(te1.params()).containsExactly("a", Expressions.expression("VALUE"));
+        assertThat(te1.params()).containsExactly("a", Expressions.Expression("VALUE"));
 
         ItemReference itemReference2 = itemReferences.get(1);
         TemplateExpression te2 = itemReference2.template();
         assertThat(te2.prefix()).isEqualTo("template2");
-        assertThat(te2.params()).containsExactly("c", Expressions.expression("OFFSET"));
+        assertThat(te2.params()).containsExactly("c", Expressions.Expression("OFFSET"));
     }
 
     @Test
@@ -176,7 +176,7 @@ void shouldConfigOneToManyIndenticalTemplates() {
 
         TemplateExpression te1 = itemReference.template();
         assertThat(te1.prefix()).isEqualTo("template1");
-        assertThat(te1.params()).containsExactly("a", Expressions.expression("KEY"));
+        assertThat(te1.params()).containsExactly("a", Expressions.Expression("KEY"));
     }
 
     @Test
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/expressions/ExpressionsTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/expressions/ExpressionsTest.java
index 1e3dfa37..d065db47 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/expressions/ExpressionsTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/expressions/ExpressionsTest.java
@@ -18,6 +18,10 @@
 package com.lightstreamer.kafka.common.expressions;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.common.expressions.Expressions.Expression;
+import static com.lightstreamer.kafka.common.expressions.Expressions.Subscription;
+import static com.lightstreamer.kafka.common.expressions.Expressions.Template;
+import static com.lightstreamer.kafka.common.expressions.Expressions.Wrapped;
 
 import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
@@ -45,8 +49,8 @@ public class ExpressionsTest {
 
     @Test
     void shouldCreateEqualExpressions() {
-        ExtractionExpression ee1 = Expressions.expression("VALUE");
-        ExtractionExpression ee2 = Expressions.expression("VALUE");
+        ExtractionExpression ee1 = Expression("VALUE");
+        ExtractionExpression ee2 = Expression("VALUE");
 
         assertThat(ee1.equals(ee1)).isTrue(); // Enforces code coverage
         assertThat(ee1).isEqualTo(ee2);
@@ -54,7 +58,7 @@ void shouldCreateEqualExpressions() {
         assertThat(ee1).isNotEqualTo(new Object());
         assertThat(ee1.hashCode()).isEqualTo(ee2.hashCode());
 
-        ExtractionExpression ee3 = Expressions.expression("KEY");
+        ExtractionExpression ee3 = Expression("KEY");
         assertThat(ee1).isNotEqualTo(ee3);
         assertThat(ee1.hashCode()).isNotEqualTo(ee3.hashCode());
     }
@@ -73,7 +77,7 @@ static Stream<Arguments> expressionArgs() {
     @MethodSource("expressionArgs")
     void shouldCreateExpression(
             String expressionStr, Constant expectedRoot, List<String> expectedTokens) {
-        ExtractionExpression ee = Expressions.expression(expressionStr);
+        ExtractionExpression ee = Expression(expressionStr);
         assertThat(ee.expression()).isEqualTo(expressionStr);
         assertThat(ee.constant()).isEqualTo(expectedRoot);
         assertThat(ee.tokens()).asList().isEqualTo(expectedTokens);
@@ -85,8 +89,7 @@ void shouldCreateExpression(
     @ValueSource(strings = {"NOT-EXISTING-CONSTANT", "..", "@", "\\"})
     void shouldNotCreateExpression(String expressionStr) {
         ExpressionException ee =
-                assertThrows(
-                        ExpressionException.class, () -> Expressions.expression(expressionStr));
+                assertThrows(ExpressionException.class, () -> Expression(expressionStr));
         assertThat(ee.getMessage())
                 .isEqualTo("Missing root tokens [KEY|VALUE|TIMESTAMP|PARTITION|OFFSET|TOPIC]");
     }
@@ -95,8 +98,7 @@ void shouldNotCreateExpression(String expressionStr) {
     @ValueSource(strings = {"VALUE.", "VALUE..", "VALUE.attrib.", "VALUE.attrib[]]."})
     void shouldNotCreateExpressionDueToTrailingDots(String expressionStr) {
         ExpressionException ee =
-                assertThrows(
-                        ExpressionException.class, () -> Expressions.expression(expressionStr));
+                assertThrows(ExpressionException.class, () -> Expression(expressionStr));
         assertThat(ee.getMessage())
                 .isEqualTo(
                         "Found unexpected trailing dot(s) in the expression ["
@@ -120,7 +122,7 @@ static Stream<Arguments> templateArgs() {
     @MethodSource("templateArgs")
     void shouldCreateTemplateExpression(
             String expressionStr, String expectedPrefix, Map<String, String> expectedParams) {
-        TemplateExpression template = Expressions.template(expressionStr);
+        TemplateExpression template = Template(expressionStr);
         assertThat(template.prefix()).isEqualTo(expectedPrefix);
 
         Map<String, ExtractionExpression> templateParams = template.params();
@@ -159,7 +161,7 @@ void shouldCreateTemplateExpression(
                     """)
     void shouldNotCreateTemplateExpression(String expressionStr, String expectedErrorMessage) {
         ExpressionException ee =
-                assertThrows(ExpressionException.class, () -> Expressions.template(expressionStr));
+                assertThrows(ExpressionException.class, () -> Template(expressionStr));
         assertThat(ee.getMessage()).isEqualTo(expectedErrorMessage);
     }
 
@@ -180,7 +182,7 @@ static Stream<Arguments> subscriptionArgs() {
     @MethodSource("subscriptionArgs")
     void shouldCreateSubscriptionEpression(
             String expressionStr, String expectedPrefix, Map<String, String> expectedParams) {
-        SubscriptionExpression subscription = Expressions.subscription(expressionStr);
+        SubscriptionExpression subscription = Subscription(expressionStr);
         assertThat(subscription.prefix()).isEqualTo(expectedPrefix);
 
         Map<String, String> subscriptionParams = subscription.params();
@@ -205,8 +207,7 @@ void shouldCreateSubscriptionEpression(
                     """)
     void shouldNotCreateSubscriptionExpression(String expressionStr, String expectedErrorMessage) {
         ExpressionException ee =
-                assertThrows(
-                        ExpressionException.class, () -> Expressions.subscription(expressionStr));
+                assertThrows(ExpressionException.class, () -> Subscription(expressionStr));
         assertThat(ee.getMessage()).isEqualTo(expectedErrorMessage);
     }
 
@@ -225,7 +226,7 @@ static Stream<Arguments> fieldArgs() {
     @MethodSource("fieldArgs")
     void shouldCreateFieldExpression(
             String expressionStr, Constant expectedRoot, List<String> expectedTokens) {
-        ExtractionExpression ee = Expressions.wrapped(expressionStr);
+        ExtractionExpression ee = Wrapped(expressionStr);
         // Remove '#{' and '}'
         String expectedExpression =
                 expressionStr.substring(
@@ -239,7 +240,7 @@ void shouldCreateFieldExpression(
     @ValueSource(strings = {"#{NOT-EXISTING-CONSTANT}", "#{..}", "#{@}", "#{\\}"})
     void shouldNotCreateFieldExpression(String expressionStr) {
         ExpressionException ee =
-                assertThrows(ExpressionException.class, () -> Expressions.wrapped(expressionStr));
+                assertThrows(ExpressionException.class, () -> Wrapped(expressionStr));
         assertThat(ee.getMessage())
                 .isEqualTo("Missing root tokens [KEY|VALUE|TIMESTAMP|PARTITION|OFFSET|TOPIC]");
     }
@@ -261,7 +262,7 @@ void shouldNotCreateFieldExpression(String expressionStr) {
     void shouldNotCreateFieldExpressionDueToInvalidExpression(
             String expressionStr, String expectedErrorMessage) {
         ExpressionException ee =
-                assertThrows(ExpressionException.class, () -> Expressions.wrapped(expressionStr));
+                assertThrows(ExpressionException.class, () -> Wrapped(expressionStr));
         assertThat(ee.getMessage()).isEqualTo(expectedErrorMessage);
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/ItemTemplatesTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/ItemTemplatesTest.java
index c5183295..522f8bee 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/ItemTemplatesTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/ItemTemplatesTest.java
@@ -18,178 +18,211 @@
 package com.lightstreamer.kafka.common.mapping;
 
 import static com.google.common.truth.Truth.assertThat;
-import static com.lightstreamer.kafka.test_utils.ConsumerRecords.record;
-import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.avro;
-import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.avroKeyJsonValue;
-import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.jsonValue;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static com.lightstreamer.kafka.common.mapping.selectors.DataExtractor.extractor;
+import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.JsonValue;
+import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.Object;
 
-import static org.junit.jupiter.params.provider.Arguments.arguments;
+import static java.util.Collections.emptySet;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
-import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType;
 import com.lightstreamer.kafka.common.config.TopicConfigurations;
 import com.lightstreamer.kafka.common.config.TopicConfigurations.ItemTemplateConfigs;
 import com.lightstreamer.kafka.common.config.TopicConfigurations.TopicMappingConfig;
-import com.lightstreamer.kafka.common.mapping.Items.Item;
 import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
 import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.SelectorSuppliers;
-import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
-import com.lightstreamer.kafka.test_utils.ConsumerRecords;
-import com.lightstreamer.kafka.test_utils.GenericRecordProvider;
-import com.lightstreamer.kafka.test_utils.JsonNodeProvider;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
-
-import org.apache.avro.generic.GenericRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
+import com.lightstreamer.kafka.common.mapping.selectors.Schema;
+
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.CsvFileSource;
-import org.junit.jupiter.params.provider.MethodSource;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
+
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class ItemTemplatesTest {
 
-    private static final String TEST_TOPIC = "topic";
-
-    private static <K, V> ItemTemplates<K, V> mkItemTemplates(
-            SelectorSuppliers<K, V> sSuppliers, String... template) throws ExtractionException {
-
-        List<TopicMappingConfig> topicMappings = new ArrayList<>();
-        Map<String, String> templates = new HashMap<>();
-        for (int i = 0; i < template.length; i++) {
-            // Add a new item template with name "template-<i>"
-            templates.put("template-" + i, template[i]);
-            // Add a new TopicMapping referencing the template
-            topicMappings.add(
-                    TopicMappingConfig.fromDelimitedMappings(
-                            TEST_TOPIC, "item-template.template-" + i));
-        }
-        TopicConfigurations topicsConfig =
-                TopicConfigurations.of(ItemTemplateConfigs.from(templates), topicMappings);
-        return Items.from(topicsConfig, sSuppliers);
+    private static final String TEST_TOPIC_1 = "topic";
+
+    private static final String TEST_TOPIC_2 = "anotherTopic";
+
+    /*
+     * Prefix each input element with "item-template." and concatenate all of them, separated by a comma character
+     */
+    static String getFullTemplateNames(String... template) {
+        return Stream.of(template).map(t -> "item-template." + t).collect(Collectors.joining(","));
     }
 
-    private static <K, V> ItemTemplates<K, V> mkSimpleItems(
-            SelectorSuppliers<K, V> sSuppliers, String... items) throws ExtractionException {
-        List<TopicMappingConfig> topicMappings = new ArrayList<>();
-        for (int i = 0; i < items.length; i++) {
-            // Add a new TopicMapping referencing the item name
-            topicMappings.add(TopicMappingConfig.fromDelimitedMappings(TEST_TOPIC, items[i]));
-        }
+    @Test
+    public void shouldCreateWihtCommonTemplateDefinition() throws ExtractionException {
+        // Define three template names
+        String template1 = "template1";
+        String template2 = "template2";
+        String template3 = "template3";
+
+        // TEST_TOPIC_1 mapped to template "template1" and "template2"
+        TopicMappingConfig testTopic1Mapping =
+                TopicMappingConfig.fromDelimitedMappings(
+                        TEST_TOPIC_1, getFullTemplateNames(template1, template2));
 
-        // No templates required in this case
-        ItemTemplateConfigs noTemplatesMap = ItemTemplateConfigs.empty();
+        // TEST_TOPIC_2 mapped to template "template1","template2", and "template3"
+        TopicMappingConfig testTopic2Mapping =
+                TopicMappingConfig.fromDelimitedMappings(
+                        TEST_TOPIC_2, getFullTemplateNames(template1, template2, template3));
 
-        TopicConfigurations topicsConfig = TopicConfigurations.of(noTemplatesMap, topicMappings);
-        return Items.from(topicsConfig, sSuppliers);
+        // Create the three templates, sharing the same template definition
+        String templateDefinition = "stock-#{index=KEY.attrib}";
+        ItemTemplateConfigs templateConfigs =
+                ItemTemplateConfigs.from(
+                        Map.of(
+                                template1,
+                                templateDefinition,
+                                template2,
+                                templateDefinition,
+                                template3,
+                                templateDefinition));
+        ItemTemplates<Object, Object> templates =
+                Items.templatesFrom(
+                        TopicConfigurations.of(
+                                templateConfigs, List.of(testTopic1Mapping, testTopic2Mapping)),
+                        Object());
+        assertWithMessage("Templates object contains the expected topics")
+                .that(templates.topics())
+                .containsExactly(TEST_TOPIC_1, TEST_TOPIC_2);
+
+        Map<String, Set<DataExtractor<Object, Object>>> extractors =
+                templates.extractorsByTopicName();
+        assertThat(extractors).hasSize(2);
+        assertWithMessage("Only one extractor associated with TEST_TOPIC_1")
+                .that(extractors.get(TEST_TOPIC_1))
+                .hasSize(1);
+        assertWithMessage("The extractor associated with TEST_TOPIC_1 is as expected")
+                .that(extractors.get(TEST_TOPIC_1))
+                .containsExactly(extractor(Object(), "stock", "index", "KEY.attrib"));
+
+        assertWithMessage("Only one extractor associated with TEST_TOPIC_2")
+                .that(extractors.get(TEST_TOPIC_2))
+                .hasSize(1);
+        assertWithMessage("The extractor associated with TEST_TOPIC_2 is as expected")
+                .that(extractors.get(TEST_TOPIC_2))
+                .containsExactly(extractor(Object(), "stock", "index", "KEY.attrib"));
+        assertThat(templates.getExtractorSchemasByTopicName(TEST_TOPIC_2))
+                .containsExactly(Schema.from("stock", Set.of("index")));
+
+        assertWithMessage("The item matche at least a template")
+                .that(templates.matches(Items.subscribedFrom("stock-[index=1]")))
+                .isTrue();
+        assertWithMessage("The item matches at least a template")
+                .that(templates.matches(Items.subscribedFrom("stock-[index=2]")))
+                .isTrue();
+        assertWithMessage("The item does not match any defined template")
+                .that(templates.matches(Items.subscribedFrom("anItem")))
+                .isFalse();
     }
 
-    private static ItemTemplates<GenericRecord, GenericRecord> getAvroAvroTemplates(String template)
-            throws ExtractionException {
-        return mkItemTemplates(avro(avroAvroConfig()), template);
-    }
+    @Test
+    public void shouldCreateFromMixedTemplatesAndSimpleItems() throws ExtractionException {
+        TopicMappingConfig tm =
+                TopicMappingConfig.fromDelimitedMappings(
+                        TEST_TOPIC_1, "item-template.template1,simple-item-1");
 
-    private static ItemTemplates<GenericRecord, JsonNode> getAvroJsonTemplates(String template)
-            throws ExtractionException {
-        return mkItemTemplates(avroKeyJsonValue(avroJsonConfig()), template);
-    }
+        ItemTemplateConfigs templateConfigs =
+                ItemTemplateConfigs.from(Map.of("template1", "stock-#{index=KEY.attrib}"));
+        TopicConfigurations topicsConfig = TopicConfigurations.of(templateConfigs, List.of(tm));
 
-    private static ConnectorConfig avroJsonConfig() {
-        return ConnectorConfigProvider.minimalWith(
-                "src/test/resources",
-                Map.of(ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH, "value.avsc"));
+        ItemTemplates<Object, Object> templates = Items.templatesFrom(topicsConfig, Object());
+        assertThat(templates.topics()).containsExactly(TEST_TOPIC_1);
+        assertThat(templates.extractorsByTopicName()).hasSize(1);
+        assertThat(templates.extractorsByTopicName().get(TEST_TOPIC_1)).hasSize(2);
+        assertThat(templates.getExtractorSchemasByTopicName(TEST_TOPIC_1))
+                .containsExactly(
+                        Schema.from("stock", Set.of("index")),
+                        Schema.from("simple-item-1", emptySet()));
+
+        assertThat(templates.matches(Items.subscribedFrom("simple-item-1"))).isTrue();
+        assertThat(templates.matches(Items.subscribedFrom("stock-[index=1]"))).isTrue();
+        assertThat(templates.matches(Items.subscribedFrom("stock-[index=2]"))).isTrue();
+        assertThat(templates.matches(Items.subscribedFrom("simple-item-2"))).isFalse();
+        assertThat(templates.matches(Items.subscribedFrom("stock-[key=1]"))).isFalse();
     }
 
-    private static ConnectorConfig avroAvroConfig() {
-        return ConnectorConfigProvider.minimalWith(
-                "src/test/resources",
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc"));
+    @Test
+    public void shouldCreateOneToOneItemTemplateFromSimpleItem() throws ExtractionException {
+        // One topic mapping one item
+        TopicMappingConfig tm =
+                TopicMappingConfig.fromDelimitedMappings(TEST_TOPIC_1, "simple-item-1");
+        TopicConfigurations topicsConfig =
+                TopicConfigurations.of(ItemTemplateConfigs.empty(), List.of(tm));
+
+        ItemTemplates<Object, Object> templates = Items.templatesFrom(topicsConfig, Object());
+        assertThat(templates.topics()).containsExactly(TEST_TOPIC_1);
+        assertThat(templates.extractorsByTopicName()).hasSize(1);
+        assertThat(templates.extractorsByTopicName().get(TEST_TOPIC_1)).hasSize(1);
+        assertThat(templates.extractorsByTopicName().get(TEST_TOPIC_1))
+                .containsExactly(extractor(Object(), "simple-item-1"));
+        assertThat(templates.getExtractorSchemasByTopicName(TEST_TOPIC_1))
+                .containsExactly(Schema.from("simple-item-1", emptySet()));
     }
 
     @Test
-    public void shouldOneToManyTemplates() throws ExtractionException {
-        SelectorSuppliers<Object, Object> sSuppliers = TestSelectorSuppliers.object();
+    public void shouldCreateOneToOneItemTemplate() throws ExtractionException {
+        // One topic mapping one item template
+        TopicMappingConfig topicMapping =
+                TopicMappingConfig.fromDelimitedMappings("stocks", "item-template.template");
         ItemTemplateConfigs templateConfigs =
                 ItemTemplateConfigs.from(Map.of("template", "stock-#{index=KEY.attrib}"));
-
-        TopicMappingConfig topicMapping =
-                TopicMappingConfig.fromDelimitedMappings("stock", "item-template.template");
         TopicConfigurations topicsConfig =
                 TopicConfigurations.of(templateConfigs, List.of(topicMapping));
-        ItemTemplates<Object, Object> templates = Items.from(topicsConfig, sSuppliers);
-        assertThat(templates.topics()).containsExactly("stock");
 
-        Item subcribingItem1 = Items.subscribedFrom("stock-[index=1]");
-        assertThat(templates.matches(subcribingItem1)).isTrue();
+        ItemTemplates<Object, Object> templates = Items.templatesFrom(topicsConfig, Object());
+        assertThat(templates.topics()).containsExactly("stocks");
+        assertThat(templates.extractorsByTopicName()).hasSize(1);
+        assertThat(templates.extractorsByTopicName().get("stocks")).hasSize(1);
+        assertThat(templates.getExtractorSchemasByTopicName("stocks"))
+                .containsExactly(Schema.from("stock", Set.of("index")));
+
+        assertThat(templates.matches(Items.subscribedFrom("stock-[index=1]"))).isTrue();
+        assertThat(templates.matches(Items.subscribedFrom("stock-[key=1]"))).isFalse();
     }
 
     @Test
-    public void shouldOneToManySimple() throws ExtractionException {
-        SelectorSuppliers<String, JsonNode> sSuppliers =
-                jsonValue(ConnectorConfigProvider.minimal());
-
+    public void shouldCreateOneToManyItemTemplateFromSimpleItem() throws ExtractionException {
         // One topic mapping two items.
         TopicMappingConfig tm =
-                TopicMappingConfig.fromDelimitedMappings(TEST_TOPIC, "simple-item-1,simple-item-2");
+                TopicMappingConfig.fromDelimitedMappings(
+                        TEST_TOPIC_1, "simple-item-1,simple-item-2");
         TopicConfigurations topicsConfig =
                 TopicConfigurations.of(ItemTemplateConfigs.empty(), List.of(tm));
 
-        ItemTemplates<String, JsonNode> templates = Items.from(topicsConfig, sSuppliers);
-        assertThat(templates.topics()).containsExactly(TEST_TOPIC);
+        ItemTemplates<String, JsonNode> templates = Items.templatesFrom(topicsConfig, JsonValue());
+        assertThat(templates.topics()).containsExactly(TEST_TOPIC_1);
+        assertThat(templates.extractorsByTopicName()).hasSize(1);
+        assertThat(templates.extractorsByTopicName().get(TEST_TOPIC_1)).hasSize(2);
+        assertThat(templates.getExtractorSchemasByTopicName(TEST_TOPIC_1))
+                .containsExactly(
+                        Schema.from("simple-item-1", emptySet()),
+                        Schema.from("simple-item-2", emptySet()));
 
-        SubscribedItem item1 = Items.susbcribedFrom("simple-item-1", "itemHandle1");
+        SubscribedItem item1 = Items.subscribedFrom("simple-item-1", "itemHandle1");
         assertThat(templates.matches(item1)).isTrue();
 
-        SubscribedItem item2 = Items.susbcribedFrom("simple-item-2", "itemHandle2");
+        SubscribedItem item2 = Items.subscribedFrom("simple-item-2", "itemHandle2");
         assertThat(templates.matches(item2)).isTrue();
 
-        RecordMapper<String, JsonNode> mapper =
-                RecordMapper.<String, JsonNode>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        KafkaRecord<String, JsonNode> kafkaRecord =
-                record(TEST_TOPIC, "key", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        // Kafka records coming from same topic "topic" matches two different items
-        Set<Item> expandedItems = templates.expand(mappedRecord).collect(Collectors.toSet());
-        assertThat(expandedItems)
-                .containsExactly(
-                        Items.from("simple-item-1", Collections.emptyMap()),
-                        Items.from("simple-item-2", Collections.emptyMap()));
+        SubscribedItem item3 = Items.subscribedFrom("simple-item-3", "itemHandle2");
+        assertThat(templates.matches(item3)).isFalse();
     }
 
     @Test
-    public void shouldOneToMany() throws ExtractionException {
-        SelectorSuppliers<String, JsonNode> sSuppliers =
-                jsonValue(ConnectorConfigProvider.minimal());
-
+    public void shouldCreateOneToManyItemTemplate() throws ExtractionException {
         // One topic mapping two item templates.
         TopicMappingConfig tm =
                 TopicMappingConfig.fromDelimitedMappings(
-                        TEST_TOPIC, "item-template.family,item-template.relatives");
+                        TEST_TOPIC_1, "item-template.family,item-template.relatives");
         ItemTemplateConfigs templateConfigs =
                 ItemTemplateConfigs.from(
                         Map.of(
@@ -200,338 +233,87 @@ public void shouldOneToMany() throws ExtractionException {
 
         TopicConfigurations topicsConfig = TopicConfigurations.of(templateConfigs, List.of(tm));
 
-        ItemTemplates<String, JsonNode> templates = Items.from(topicsConfig, sSuppliers);
-        assertThat(templates.topics()).containsExactly(TEST_TOPIC);
+        ItemTemplates<String, JsonNode> templates = Items.templatesFrom(topicsConfig, JsonValue());
+        assertThat(templates.topics()).containsExactly(TEST_TOPIC_1);
+        assertThat(templates.extractorsByTopicName()).hasSize(1);
+        assertThat(templates.extractorsByTopicName().get(TEST_TOPIC_1)).hasSize(2);
+        assertThat(templates.getExtractorSchemasByTopicName(TEST_TOPIC_1))
+                .containsExactly(
+                        Schema.from("template-family", Set.of("topic", "info")),
+                        Schema.from("template-relatives", Set.of("topic", "info1")));
 
         SubscribedItem item1 =
-                Items.susbcribedFrom(
-                        "template-family-[topic=aSpecificTopic,info=aSpecificPartition]",
-                        "itemHandle1");
+                Items.subscribedFrom(
+                        "template-family-[topic=" + TEST_TOPIC_1 + ",info=150]", "itemHandle1");
         assertThat(templates.matches(item1)).isTrue();
 
         SubscribedItem item2 =
-                Items.susbcribedFrom(
-                        "template-relatives-[topic=anotherSpecificTopic,info1=aSpecificTimestamp]",
-                        "itemHandle2");
+                Items.subscribedFrom(
+                        "template-relatives-[topic=" + TEST_TOPIC_1 + ",info1=-1]", "itemHandle2");
         assertThat(templates.matches(item2)).isTrue();
-
-        RecordMapper<String, JsonNode> mapper =
-                RecordMapper.<String, JsonNode>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        KafkaRecord<String, JsonNode> kafkaRecord =
-                record(TEST_TOPIC, "key", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        // Kafka records coming from same topic "topic" matches two different item
-        // templates.
-        Set<Item> expandedItems = templates.expand(mappedRecord).collect(Collectors.toSet());
-        assertThat(expandedItems)
-                .containsExactly(
-                        Items.from("template-family", Map.of(TEST_TOPIC, "topic", "info", "150")),
-                        Items.from(
-                                "template-relatives", Map.of(TEST_TOPIC, "topic", "info1", "-1")));
     }
 
     @Test
-    public void shouldManyToOneSimple() throws ExtractionException {
-        SelectorSuppliers<String, JsonNode> sSuppliers =
-                jsonValue(ConnectorConfigProvider.minimal());
+    public void shouldCreateManyToOneItemTemplateFromSimpleItem() throws ExtractionException {
+        KeyValueSelectorSuppliers<String, JsonNode> sSuppliers = JsonValue();
 
         // One item.
         String item = "orders";
 
         // Two topics mapping the item.
+        String newOrdersTopic = "new_orders";
+        String pastOrderTopic = "past_orders";
         TopicMappingConfig orderMapping =
-                TopicMappingConfig.fromDelimitedMappings("new_orders", item);
+                TopicMappingConfig.fromDelimitedMappings(newOrdersTopic, item);
         TopicMappingConfig pastOrderMapping =
-                TopicMappingConfig.fromDelimitedMappings("past_orders", item);
+                TopicMappingConfig.fromDelimitedMappings(pastOrderTopic, item);
         TopicConfigurations topicsConfig =
                 TopicConfigurations.of(
                         ItemTemplateConfigs.empty(), List.of(orderMapping, pastOrderMapping));
 
-        ItemTemplates<String, JsonNode> templates = Items.from(topicsConfig, sSuppliers);
-        assertThat(templates.topics()).containsExactly("new_orders", "past_orders");
+        ItemTemplates<String, JsonNode> templates = Items.templatesFrom(topicsConfig, sSuppliers);
+        assertThat(templates.topics()).containsExactly(newOrdersTopic, pastOrderTopic);
+        assertThat(templates.extractorsByTopicName()).hasSize(2);
+        assertThat(templates.extractorsByTopicName().get(newOrdersTopic)).hasSize(1);
+        assertThat(templates.extractorsByTopicName().get(pastOrderTopic)).hasSize(1);
 
-        SubscribedItem subcribingItem = Items.susbcribedFrom("orders", "");
+        SubscribedItem subcribingItem = Items.subscribedFrom("orders", "");
         assertThat(templates.matches(subcribingItem)).isTrue();
-
-        RecordMapper<String, JsonNode> mapper =
-                RecordMapper.<String, JsonNode>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        // Kafka Record coming from topic "new_orders"
-        KafkaRecord<String, JsonNode> kafkaRecord1 =
-                record("new_orders", "key", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord1 = mapper.map(kafkaRecord1);
-
-        // Kafka Record coming from topic "past_orders"
-        KafkaRecord<String, JsonNode> kafkaRecord2 =
-                record("past_orders", "key", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord2 = mapper.map(kafkaRecord2);
-
-        // Kafka records coming from different topics ("new_orders" and "past_orders")
-        // match the same item.
-        Stream<Item> expandedItems1 = templates.expand(mappedRecord1);
-        assertThat(expandedItems1).containsExactly(Items.from("orders", Collections.emptyMap()));
-
-        Stream<Item> expandedItems2 = templates.expand(mappedRecord2);
-        assertThat(expandedItems2).containsExactly(Items.from("orders", Collections.emptyMap()));
     }
 
     @Test
     public void shouldManyToOne() throws ExtractionException {
-        SelectorSuppliers<String, JsonNode> sSuppliers =
-                jsonValue(ConnectorConfigProvider.minimal());
+        KeyValueSelectorSuppliers<String, JsonNode> sSuppliers = JsonValue();
 
         // One template.
         ItemTemplateConfigs templateConfigs =
                 ItemTemplateConfigs.from(
                         Map.of("template-order", "template-orders-#{topic=TOPIC}"));
-        // ItemReference orders = ItemReference.forTemplate("", "template-orders-#{topic=TOPIC}");
 
         // Two topics mapping the template.
+        String newOrdersTopic = "new_orders";
+        String pastOrderTopic = "past_orders";
         TopicMappingConfig orderMapping =
                 TopicMappingConfig.fromDelimitedMappings(
-                        "new_orders", "item-template.template-order");
+                        newOrdersTopic, "item-template.template-order");
         TopicMappingConfig pastOrderMapping =
                 TopicMappingConfig.fromDelimitedMappings(
-                        "past_orders", "item-template.template-order");
+                        pastOrderTopic, "item-template.template-order");
         TopicConfigurations topicsConfig =
                 TopicConfigurations.of(templateConfigs, List.of(orderMapping, pastOrderMapping));
 
-        ItemTemplates<String, JsonNode> templates = Items.from(topicsConfig, sSuppliers);
-        assertThat(templates.topics()).containsExactly("new_orders", "past_orders");
-
-        SubscribedItem subcribingItem =
-                Items.susbcribedFrom("template-orders-[topic=aSpecifgicTopic]", "");
-        assertThat(templates.matches(subcribingItem)).isTrue();
+        ItemTemplates<String, JsonNode> templates = Items.templatesFrom(topicsConfig, sSuppliers);
+        assertThat(templates.topics()).containsExactly(newOrdersTopic, pastOrderTopic);
+        assertThat(templates.extractorsByTopicName()).hasSize(2);
+        assertThat(templates.extractorsByTopicName().get(newOrdersTopic)).hasSize(1);
+        assertThat(templates.extractorsByTopicName().get(pastOrderTopic)).hasSize(1);
 
-        RecordMapper<String, JsonNode> mapper =
-                RecordMapper.<String, JsonNode>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        // Kafka Record coming from topic "new_orders"
-        KafkaRecord<String, JsonNode> kafkaRecord1 =
-                record("new_orders", "key", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord1 = mapper.map(kafkaRecord1);
-
-        // Kafka Record coming from topic "past_orders"
-        KafkaRecord<String, JsonNode> kafkaRecord2 =
-                record("past_orders", "key", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord2 = mapper.map(kafkaRecord2);
-
-        // Kafka records coming from different topics ("new_orders" and "past_orders")
-        // match the same item template.
-        Stream<Item> expandedItems1 = templates.expand(mappedRecord1);
-        assertThat(expandedItems1)
-                .containsExactly(Items.from("template-orders", Map.of(TEST_TOPIC, "new_orders")));
-
-        Stream<Item> expandedItems2 = templates.expand(mappedRecord2);
-        assertThat(expandedItems2)
-                .containsExactly(Items.from("template-orders", Map.of(TEST_TOPIC, "past_orders")));
-    }
-
-    @ParameterizedTest
-    @CsvFileSource(
-            files = "src/test/resources/should-expand-items.csv",
-            useHeadersInDisplayName = true,
-            delimiter = '|')
-    public void shouldExpand(
-            String template, String subscribingItem, boolean canSubscribe, boolean exandable)
-            throws ExtractionException {
-        ItemTemplates<GenericRecord, GenericRecord> templates = getAvroAvroTemplates(template);
-        RecordMapper<GenericRecord, GenericRecord> mapper =
-                RecordMapper.<GenericRecord, GenericRecord>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        KafkaRecord<GenericRecord, GenericRecord> incomingRecord =
-                record(TEST_TOPIC, GenericRecordProvider.RECORD, GenericRecordProvider.RECORD);
-        MappedRecord mapped = mapper.map(incomingRecord);
-        Item subscribedItem = Items.susbcribedFrom(subscribingItem, new Object());
-
-        assertThat(templates.matches(subscribedItem)).isEqualTo(canSubscribe);
-
-        Stream<Item> expandedItem = templates.expand(mapped);
-        List<Item> list = expandedItem.toList();
-        assertThat(list.size()).isEqualTo(1);
-        Item first = list.get(0);
-
-        assertThat(first.matches(subscribedItem)).isEqualTo(exandable);
-    }
-
-    @ParameterizedTest(name = "[{index}] {arguments}")
-    @CsvFileSource(
-            files = "src/test/resources/should-expand-items.csv",
-            useHeadersInDisplayName = true,
-            delimiter = '|')
-    public void shouldExpandMixedKeyAndValueTypes(
-            String template, String subscribingItem, boolean canSubscribe, boolean exandable)
-            throws ExtractionException {
-        ItemTemplates<GenericRecord, JsonNode> templates = getAvroJsonTemplates(template);
-        RecordMapper<GenericRecord, JsonNode> mapper =
-                RecordMapper.<GenericRecord, JsonNode>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        KafkaRecord<GenericRecord, JsonNode> incomingRecord =
-                record(TEST_TOPIC, GenericRecordProvider.RECORD, JsonNodeProvider.RECORD);
-        MappedRecord mapped = mapper.map(incomingRecord);
-        Item subscribedItem = Items.susbcribedFrom(subscribingItem, new Object());
-
-        assertThat(templates.matches(subscribedItem)).isEqualTo(canSubscribe);
-
-        Stream<Item> expandedItem = templates.expand(mapped);
-        Optional<Item> first = expandedItem.findFirst();
-
-        assertThat(first.isPresent()).isTrue();
-        assertThat(first.get().matches(subscribedItem)).isEqualTo(exandable);
-    }
-
-    static Stream<Arguments> templateArgs() {
-        return Stream.of(
-                arguments(
-                        List.of("item-#{key=KEY,value=VALUE}"),
-                        List.of(
-                                Items.susbcribedFrom("item-[key=key,value=value]", "handle1"),
-                                Items.susbcribedFrom("item-[value=value,key=key]", "handle2")),
-                        List.of(
-                                Items.susbcribedFrom("item", "handle3"),
-                                Items.susbcribedFrom("item-[key=key]", "handle4"),
-                                Items.susbcribedFrom("item-[key=anotherKey]", "handle5"),
-                                Items.susbcribedFrom("item-[value=anotherValue]", "handle6"),
-                                Items.susbcribedFrom("nonRoutable", new Object()))),
-                arguments(
-                        List.of(
-                                "item-#{key=KEY,value=VALUE}",
-                                "item-#{topic=TOPIC}",
-                                "myItem-#{topic=TOPIC}"),
-                        List.of(
-                                Items.susbcribedFrom("item-[key=key,value=value]", "handle1"),
-                                Items.susbcribedFrom("item-[value=value,key=key]", "handle2"),
-                                Items.susbcribedFrom("item-[topic=topic]", "handle3"),
-                                Items.susbcribedFrom("myItem-[topic=topic]", "handle4")),
-                        List.of(
-                                Items.susbcribedFrom("nonRoutable", "handle5"),
-                                Items.susbcribedFrom("item-[key=anotherKey]", "handle6"),
-                                Items.susbcribedFrom("item-[value=anotherValue]", "handle7"),
-                                Items.susbcribedFrom("item-[topic=anotherTopic]", "handle8"),
-                                Items.susbcribedFrom("item", "handle9"),
-                                Items.susbcribedFrom("item-[key=key]", "handle10"),
-                                Items.susbcribedFrom("item-[value=value]", "handle11"),
-                                Items.susbcribedFrom("myItem-[topic=anotherTopic]", "handle12"))));
-    }
-
-    @ParameterizedTest
-    @MethodSource("templateArgs")
-    public void shouldRoutesFromTemplates(
-            List<String> templateStr,
-            List<SubscribedItem> routables,
-            List<SubscribedItem> nonRoutables)
-            throws ExtractionException {
-        ItemTemplates<String, String> templates =
-                mkItemTemplates(
-                        TestSelectorSuppliers.string(),
-                        templateStr.toArray(size -> new String[size]));
-        RecordMapper<String, String> mapper =
-                RecordMapper.<String, String>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        MappedRecord mapped = mapper.map(ConsumerRecords.record(TEST_TOPIC, "key", "value"));
-        List<SubscribedItem> all =
-                Stream.concat(routables.stream(), nonRoutables.stream()).toList();
-
-        Set<SubscribedItem> routed = templates.routes(mapped, all);
-        assertThat(routed).containsExactlyElementsIn(routables);
-    }
-
-    static Stream<Arguments> itemArgs() {
-        return Stream.of(
-                arguments(
-                        List.of("item"),
-                        List.of(Items.susbcribedFrom("item", "handle1")),
-                        List.of(Items.susbcribedFrom("otherItem", "handle2"))));
-    }
-
-    @ParameterizedTest
-    @MethodSource("itemArgs")
-    public void shouldRoutesFromSimpleItems(
-            List<String> templateStr,
-            List<SubscribedItem> routables,
-            List<SubscribedItem> nonRoutables)
-            throws ExtractionException {
-        ItemTemplates<String, String> templates =
-                mkSimpleItems(
-                        TestSelectorSuppliers.string(),
-                        templateStr.toArray(size -> new String[size]));
-        RecordMapper<String, String> mapper =
-                RecordMapper.<String, String>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        MappedRecord mapped = mapper.map(ConsumerRecords.record(TEST_TOPIC, "key", "value"));
-        List<SubscribedItem> all =
-                Stream.concat(routables.stream(), nonRoutables.stream()).toList();
-
-        Set<SubscribedItem> routed = templates.routes(mapped, all);
-        assertThat(routed).containsExactlyElementsIn(routables);
-    }
-
-    static Stream<Arguments> templateArgsJson() {
-        return Stream.of(
-                arguments(
-                        """
-                            {
-                            "name": "James",
-                            "surname": "Kirk",
-                            "age": 37
-                            }
-                            """,
-                        List.of("user-#{firstName=VALUE.name,lastName=VALUE.surname}"),
-                        List.of(
-                                Items.susbcribedFrom(
-                                        "user-[firstName=James,lastName=Kirk]", new Object())),
-                        List.of(
-                                Items.susbcribedFrom("item", new Object()),
-                                Items.susbcribedFrom("item-[key=key]", new Object()),
-                                Items.susbcribedFrom("item-[key=anotherKey]", new Object()),
-                                Items.susbcribedFrom("item-[value=anotherValue]", new Object())),
-                        Items.susbcribedFrom("nonRoutable", new Object())));
-    }
+        SubscribedItem itemFilteringTopic1 =
+                Items.subscribedFrom("template-orders-[topic=new_orders]", "");
+        assertThat(templates.matches(itemFilteringTopic1)).isTrue();
 
-    @ParameterizedTest
-    @MethodSource("templateArgsJson")
-    public void shouldRoutesFromMoreTemplatesJson(
-            String jsonString,
-            List<String> templateStr,
-            List<SubscribedItem> routables,
-            List<SubscribedItem> nonRoutables)
-            throws JsonMappingException, JsonProcessingException, ExtractionException {
-
-        Map<String, String> updatedConfigs =
-                Map.of(ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE, EvaluatorType.JSON.toString());
-        ItemTemplates<String, JsonNode> templates =
-                mkItemTemplates(
-                        TestSelectorSuppliers.jsonValue(
-                                ConnectorConfigProvider.minimalWith(updatedConfigs)),
-                        templateStr.toArray(size -> new String[size]));
-        RecordMapper<String, JsonNode> mapper =
-                RecordMapper.<String, JsonNode>builder()
-                        .withExtractor(templates.extractors())
-                        .build();
-
-        ObjectMapper om = new ObjectMapper();
-        JsonNode jsonNode = om.readTree(jsonString);
-        MappedRecord mapped = mapper.map(ConsumerRecords.record(TEST_TOPIC, "key", jsonNode));
-        List<SubscribedItem> all =
-                Stream.concat(routables.stream(), nonRoutables.stream()).toList();
-
-        Set<SubscribedItem> routed = templates.routes(mapped, all);
-        assertThat(routed).containsExactlyElementsIn(routables);
+        SubscribedItem itemFilteringTopic2 =
+                Items.subscribedFrom("template-orders-[topic=past_orders]", "");
+        assertThat(templates.matches(itemFilteringTopic2)).isTrue();
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/ItemTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/ItemTest.java
index d176ff82..7bdd5827 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/ItemTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/ItemTest.java
@@ -115,7 +115,7 @@ public void shouldNotMathcDueToDifferentPrefix() {
 						""")
     public void shouldMakeWithEmptySchemaKeys(String input, String expectedPrefix) {
         Object handle = new Object();
-        SubscribedItem item = Items.susbcribedFrom(input, handle);
+        SubscribedItem item = Items.subscribedFrom(input, handle);
         assertThat(item).isNotNull();
         assertThat(item.itemHandle()).isSameInstanceAs(handle);
         assertThat(item.schema().name()).isEqualTo(expectedPrefix);
@@ -142,7 +142,7 @@ public void shouldMakeWithEmptySchemaKeys(String input, String expectedPrefix) {
     public void shouldMakeWithValue(
             String input, String expectedPrefix, String expectedName, String expectedValue) {
         Object handle = new Object();
-        SubscribedItem item = Items.susbcribedFrom(input, handle);
+        SubscribedItem item = Items.subscribedFrom(input, handle);
         assertThat(item).isNotNull();
         assertThat(item.schema().name()).isEqualTo(expectedPrefix);
         assertThat(item.itemHandle()).isSameInstanceAs(handle);
@@ -166,7 +166,7 @@ public void shouldMakeWithValue(
     public void shouldMakeWithMoreValues(
             String input, String name1, String val1, String name2, String value2) {
         Object handle = new Object();
-        SubscribedItem item = Items.susbcribedFrom(input, handle);
+        SubscribedItem item = Items.subscribedFrom(input, handle);
 
         assertThat(item).isNotNull();
         assertThat(item.itemHandle()).isSameInstanceAs(handle);
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/MappedRecordTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/MappedRecordTest.java
index a8acbdec..d0d94242 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/MappedRecordTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/MappedRecordTest.java
@@ -18,105 +18,121 @@
 package com.lightstreamer.kafka.common.mapping;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.common.mapping.Items.subscribedFrom;
 
-import com.lightstreamer.kafka.common.expressions.Expressions;
-import com.lightstreamer.kafka.common.mapping.selectors.Data;
-import com.lightstreamer.kafka.common.mapping.selectors.DataContainer;
-import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
-import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
+import static java.util.Collections.emptyMap;
+
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+import com.lightstreamer.kafka.common.mapping.selectors.SchemaAndValues;
 
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 
 public class MappedRecordTest {
 
-    DataExtractor<String, String> extractor1;
-    DataExtractor<String, String> extractor2;
-    Set<DataContainer> dataContainers;
-
-    @BeforeEach
-    void creaValuesContainer() throws ExtractionException {
-        extractor1 =
-                DataExtractor.<String, String>builder()
-                        .withSuppliers(TestSelectorSuppliers.string())
-                        .withSchemaName("schema1")
-                        .withExpressions(
-                                Map.of(
-                                        "partition",
-                                        Expressions.expression("PARTITION"),
-                                        "topic",
-                                        Expressions.expression("TOPIC")))
-                        .build();
-
-        DataContainer container1 =
-                DataContainer.from(
-                        extractor1,
-                        Set.of(
-                                Data.from("partition", "partitionValue"),
-                                Data.from("topic", "topicValue")));
-
-        extractor2 =
-                DataExtractor.<String, String>builder()
-                        .withSchemaName("schema1")
-                        .withSuppliers(TestSelectorSuppliers.string())
-                        .withExpressions(
-                                Map.of(
-                                        "partition2",
-                                        Expressions.expression("PARTITION"),
-                                        "topic2",
-                                        Expressions.expression("TOPIC")))
-                        .build();
-
-        DataContainer container2 =
-                DataContainer.from(
-                        extractor2,
-                        Set.of(
-                                Data.from("partition2", "partitionValue2"),
-                                Data.from("topic2", "topicValue2")));
-        dataContainers = Set.of(container1, container2);
-    }
-
     @Test
-    void shouldHaveExpectedTopic() {
-        DefaultMappedRecord mp = new DefaultMappedRecord("topic", Collections.emptySet());
-        assertThat(mp.topic()).isEqualTo("topic");
+    public void shouldCreateSimpleMappedRecord() {
+        SchemaAndValues expandedTemplate = SchemaAndValues.from("schema", Map.of("key", "aKey"));
+        SchemaAndValues fieldsMap = SchemaAndValues.from("fields", Map.of("field1", "value1"));
+        DefaultMappedRecord record = new DefaultMappedRecord(Set.of(expandedTemplate), fieldsMap);
+        assertThat(record.expanded()).containsExactly(expandedTemplate);
+        assertThat(record.fieldsMap()).containsExactly("field1", "value1");
+        assertThat(record.toString())
+                .isEqualTo(
+                        "MappedRecord [expandedTemplates=[{key=aKey}], fieldsMap=(fields-<{field1=value1}>)]");
     }
 
     @Test
-    void shouldFilter() {
-        DefaultMappedRecord mp = new DefaultMappedRecord("topic", dataContainers);
-        Map<String, String> map1 = mp.filter(extractor1);
-        assertThat(map1).containsExactly("partition", "partitionValue", "topic", "topicValue");
-
-        Map<String, String> map2 = mp.filter(extractor2);
-        assertThat(map2).containsExactly("partition2", "partitionValue2", "topic2", "topicValue2");
+    public void shouldCreateMappedRecord() {
+        Map<String, String> map1 = new LinkedHashMap<>();
+        map1.put("key", "aKey");
+        SchemaAndValues expandedTemplate1 = SchemaAndValues.from("schema1", map1);
+        SchemaAndValues expandedTemplate2 = SchemaAndValues.from("schema2", emptyMap());
+
+        Map<String, String> map2 = new LinkedHashMap<>();
+        map2.put("value", "aValue");
+        map2.put("partition", "aPartition");
+        SchemaAndValues expandedTemplate3 = SchemaAndValues.from("schema3", map2);
+
+        Set<SchemaAndValues> expandedTemplates = new LinkedHashSet<>();
+        expandedTemplates.add(expandedTemplate1);
+        expandedTemplates.add(expandedTemplate2);
+        expandedTemplates.add(expandedTemplate3);
+
+        Map<String, String> fields = new LinkedHashMap<>();
+        fields.put("field1", "value1");
+        fields.put("field2", "value2");
+        fields.put("field3", null);
+        SchemaAndValues fieldsMap = SchemaAndValues.from("fields", fields);
+
+        DefaultMappedRecord record = new DefaultMappedRecord(expandedTemplates, fieldsMap);
+        assertThat(record.expanded())
+                .containsExactly(expandedTemplate1, expandedTemplate2, expandedTemplate3);
+        assertThat(record.fieldsMap())
+                .containsExactly("field1", "value1", "field2", "value2", "field3", null);
+        assertThat(record.toString())
+                .isEqualTo(
+                        "MappedRecord [expandedTemplates=[{key=aKey}, {}, {value=aValue, partition=aPartition}], fieldsMap=(fields-<{field1=value1, field2=value2, field3=null}>)]");
     }
 
     @Test
-    void shouldFilterWithNullValue() {
-        Set<DataContainer> dc =
-                Set.of(DataContainer.from(extractor1, Set.of(Data.from("partition", null))));
-        DefaultMappedRecord mp = new DefaultMappedRecord("topic", dc);
-        Map<String, String> map1 = mp.filter(extractor1);
-        assertThat(map1).containsExactly("partition", null);
+    public void shouldNotHaveExpandedTemplatesAndFieldsMapIfNOP() {
+        assertThat(DefaultMappedRecord.NOPRecord.expanded()).isEmpty();
+        assertThat(DefaultMappedRecord.NOPRecord.fieldsMap()).isEmpty();
+        assertThat(DefaultMappedRecord.NOPRecord.toString())
+                .isEqualTo("MappedRecord [expandedTemplates=[], fieldsMap=(NOSCHEMA-<{}>)]");
     }
 
     @Test
-    void shouldHaveExpectedMappedValueSize() {
-        DefaultMappedRecord mp = new DefaultMappedRecord("topic", dataContainers);
-        assertThat(mp.mappedValuesSize()).isEqualTo(4);
+    public void shouldRouteMatchingParameterizedItems() {
+        SchemaAndValues expandedTemplate1 =
+                SchemaAndValues.from(
+                        "schema1", Map.of("topic", "aTopic", "partition", "aPartition"));
+        SchemaAndValues expandedTemplate2 =
+                SchemaAndValues.from("schema2", Map.of("key", "aKey", "value", "aValue"));
+        Set<SchemaAndValues> expandedTemplates = Set.of(expandedTemplate1, expandedTemplate2);
+        DefaultMappedRecord record =
+                new DefaultMappedRecord(expandedTemplates, SchemaAndValues.nop());
+
+        // This item should match the expandedTemplate 1: routable
+        SubscribedItem matchingItem1 =
+                subscribedFrom("schema1-[topic=aTopic,partition=aPartition]");
+        // This item should match the expandedTemplate 2: routable
+        SubscribedItem matchingItem2 = subscribedFrom("schema2-[key=aKey,value=aValue]");
+        // The following items shuld match no templates: non-routable
+        SubscribedItem notMatchingBindParameters =
+                subscribedFrom("schema1-[topic=anotherTopic,partition=anotherPartition]");
+        SubscribedItem notMatchingSchema = subscribedFrom("schemaX-[key=aKey,value=aValue]");
+
+        assertThat(
+                        record.route(
+                                Set.of(
+                                        matchingItem1,
+                                        matchingItem2,
+                                        notMatchingBindParameters,
+                                        notMatchingSchema)))
+                .containsExactly(matchingItem1, matchingItem2);
+        assertThat(record.route(Set.of(notMatchingBindParameters, notMatchingSchema))).isEmpty();
     }
 
     @Test
-    void shouldHaveExpectedMappedValueSizeWithNullValue() {
-        Set<DataContainer> dc =
-                Set.of(DataContainer.from(extractor1, Set.of(Data.from("partition", null))));
-        DefaultMappedRecord mp = new DefaultMappedRecord("topic", dc);
-        assertThat(mp.mappedValuesSize()).isEqualTo(1);
+    public void shouldRouteMatchingSimpleItems() {
+        SchemaAndValues expandedTemplate1 = SchemaAndValues.from("simple-item-1", emptyMap());
+        SchemaAndValues expandedTemplate2 = SchemaAndValues.from("simple-item-2", emptyMap());
+        DefaultMappedRecord record =
+                new DefaultMappedRecord(
+                        Set.of(expandedTemplate1, expandedTemplate2), SchemaAndValues.nop());
+        assertThat(record.expanded()).containsExactly(expandedTemplate1, expandedTemplate2);
+        assertThat(record.fieldsMap()).isEmpty();
+
+        SubscribedItem matchingItem1 = subscribedFrom("simple-item-1");
+        SubscribedItem matchingItem2 = subscribedFrom("simple-item-2");
+        SubscribedItem notMatchingItem = subscribedFrom("simple-item-3");
+        assertThat((record.route(Set.of(matchingItem1, matchingItem2, notMatchingItem))))
+                .containsExactly(matchingItem1, matchingItem2);
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperAvroTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperAvroTest.java
deleted file mode 100644
index 817c2541..00000000
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperAvroTest.java
+++ /dev/null
@@ -1,224 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.common.mapping;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
-import com.lightstreamer.kafka.common.expressions.Expressions;
-import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.Builder;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
-import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.SelectorSuppliers;
-import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
-import com.lightstreamer.kafka.test_utils.ConsumerRecords;
-import com.lightstreamer.kafka.test_utils.GenericRecordProvider;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
-
-import org.apache.avro.generic.GenericRecord;
-import org.junit.jupiter.api.Test;
-
-import java.util.Map;
-
-public class RecordMapperAvroTest {
-
-    private static DataExtractor<String, GenericRecord> extractor(
-            String schemaName, Map<String, ExtractionExpression> expressions)
-            throws ExtractionException {
-        SelectorSuppliers<String, GenericRecord> avroValue =
-                TestSelectorSuppliers.avroValue(
-                        ConnectorConfigProvider.minimalWith(
-                                "src/test/resources",
-                                Map.of(
-                                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                                        "value.avsc")));
-        return DataExtractor.<String, GenericRecord>builder()
-                .withSuppliers(avroValue)
-                .withSchemaName(schemaName)
-                .withExpressions(expressions)
-                .build();
-    }
-
-    private static Builder<String, GenericRecord> builder() {
-        return RecordMapper.<String, GenericRecord>builder();
-    }
-
-    @Test
-    public void shouldBuildEmptyMapper() {
-        RecordMapper<String, GenericRecord> mapper = builder().build();
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldBuildMapperWithDuplicateSelectors() throws ExtractionException {
-        RecordMapper<String, GenericRecord> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .build();
-
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(1);
-    }
-
-    @Test
-    public void shouldBuildMapperWithDifferentSelectors() throws ExtractionException {
-        RecordMapper<String, GenericRecord> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test1",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor(
-                                        "test2",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .build();
-
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(2);
-    }
-
-    @Test
-    public void shouldMapEmpty() {
-        RecordMapper<String, GenericRecord> mapper = builder().build();
-
-        KafkaRecord<String, GenericRecord> kafkaRecord =
-                ConsumerRecords.record("", GenericRecordProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        // No expected values because no selectors have been bound to the RecordMapper.
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldMapWithValues() throws ExtractionException {
-        RecordMapper<String, GenericRecord> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test1",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor("test2", Map.of("aKey", Expressions.expression("TOPIC"))))
-                        .withExtractor(
-                                extractor(
-                                        "test3",
-                                        Map.of("aKey", Expressions.expression("TIMESTAMP"))))
-                        .build();
-
-        KafkaRecord<String, GenericRecord> kafkaRecord =
-                ConsumerRecords.record("", GenericRecordProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(3);
-    }
-
-    @Test
-    public void shoulNotFilterDueToUnboundSelectors() throws ExtractionException {
-        RecordMapper<String, GenericRecord> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("name", Expressions.expression("PARTITION"))))
-                        .build();
-
-        KafkaRecord<String, GenericRecord> kafkaRecord =
-                ConsumerRecords.record("", GenericRecordProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(1);
-        DataExtractor<String, GenericRecord> unboundExtractor =
-                extractor("test", Map.of("name", Expressions.expression("VALUE.any")));
-        assertThat(mappedRecord.filter(unboundExtractor)).isEmpty();
-    }
-
-    @Test
-    public void shouldFilter() throws ExtractionException {
-        DataExtractor<String, GenericRecord> nameExtractor =
-                extractor("test", Map.of("name", Expressions.expression("VALUE.name")));
-
-        DataExtractor<String, GenericRecord> childExtractor1 =
-                extractor(
-                        "test",
-                        Map.of("firstChildName", Expressions.expression("VALUE.children[0].name")));
-
-        DataExtractor<String, GenericRecord> childExtractor2 =
-                extractor(
-                        "test",
-                        Map.of(
-                                "secondChildName",
-                                Expressions.expression("VALUE.children[1].name"),
-                                "grandChildName",
-                                Expressions.expression("VALUE.children[1].children[1].name")));
-
-        RecordMapper<String, GenericRecord> mapper =
-                builder()
-                        .withExtractor(nameExtractor)
-                        .withExtractor(childExtractor1)
-                        .withExtractor(childExtractor2)
-                        .build();
-
-        KafkaRecord<String, GenericRecord> kafkaRecord =
-                ConsumerRecords.record("", GenericRecordProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(4);
-
-        Map<String, String> parentName = mappedRecord.filter(nameExtractor);
-        assertThat(parentName).containsExactly("name", "joe");
-
-        Map<String, String> firstChildName = mappedRecord.filter(childExtractor1);
-        assertThat(firstChildName).containsExactly("firstChildName", "alex");
-
-        Map<String, String> otherPeopleNames = mappedRecord.filter(childExtractor2);
-        assertThat(otherPeopleNames)
-                .containsExactly("secondChildName", "anna", "grandChildName", "terence");
-    }
-
-    @Test
-    public void shouldFilterWithNullValues() throws ExtractionException {
-        DataExtractor<String, GenericRecord> extractor =
-                extractor(
-                        "test",
-                        Map.of(
-                                "name",
-                                Expressions.expression("VALUE.children[0].name"),
-                                "signature",
-                                Expressions.expression("VALUE.children[0].signature")));
-
-        RecordMapper<String, GenericRecord> mapper = builder().withExtractor(extractor).build();
-
-        KafkaRecord<String, GenericRecord> kafkaRecord =
-                ConsumerRecords.record("", GenericRecordProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(2);
-
-        Map<String, String> parentName = mappedRecord.filter(extractor);
-        assertThat(parentName).containsExactly("name", "alex", "signature", null);
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperJsonTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperJsonTest.java
deleted file mode 100644
index f7166ef4..00000000
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperJsonTest.java
+++ /dev/null
@@ -1,216 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.common.mapping;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.lightstreamer.kafka.common.expressions.Expressions;
-import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.Builder;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
-import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
-import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
-import com.lightstreamer.kafka.test_utils.ConsumerRecords;
-import com.lightstreamer.kafka.test_utils.JsonNodeProvider;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.Map;
-
-public class RecordMapperJsonTest {
-
-    private static DataExtractor<String, JsonNode> extractor(
-            String schemaName, Map<String, ExtractionExpression> expressions)
-            throws ExtractionException {
-
-        return DataExtractor.<String, JsonNode>builder()
-                .withSuppliers(TestSelectorSuppliers.jsonValue(ConnectorConfigProvider.minimal()))
-                .withSchemaName(schemaName)
-                .withExpressions(expressions)
-                .build();
-    }
-
-    private static Builder<String, JsonNode> builder() {
-        return RecordMapper.<String, JsonNode>builder();
-    }
-
-    @Test
-    public void shouldBuildEmptyMapper() {
-        RecordMapper<String, JsonNode> mapper = RecordMapper.<String, JsonNode>builder().build();
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldBuildMapperWithDuplicateSelectors() throws ExtractionException {
-        RecordMapper<String, JsonNode> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .build();
-
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(1);
-    }
-
-    @Test
-    public void shouldBuildMapperWithDifferentSelectors() throws ExtractionException {
-        RecordMapper<String, JsonNode> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test1",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor(
-                                        "test2",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .build();
-
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(2);
-    }
-
-    @Test
-    public void shouldMapEmpty() {
-        RecordMapper<String, JsonNode> mapper = builder().build();
-
-        KafkaRecord<String, JsonNode> kafkaRecord =
-                ConsumerRecords.record("", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        // No expected values because no selectors have been bound to the RecordMapper.
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldMapWithValues() throws ExtractionException {
-        RecordMapper<String, JsonNode> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test1",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor("test2", Map.of("aKey", Expressions.expression("TOPIC"))))
-                        .withExtractor(
-                                extractor(
-                                        "test3",
-                                        Map.of("aKey", Expressions.expression("TIMESTAMP"))))
-                        .build();
-
-        KafkaRecord<String, JsonNode> kafkaRecord =
-                ConsumerRecords.record("", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(3);
-    }
-
-    @Test
-    public void shoulNotFilterDueToUnboundSelectors() throws ExtractionException {
-        RecordMapper<String, JsonNode> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("name", Expressions.expression("PARTITION"))))
-                        .build();
-
-        KafkaRecord<String, JsonNode> kafkaRecord =
-                ConsumerRecords.record("", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(1);
-        DataExtractor<String, JsonNode> unboundSelectors =
-                extractor("test", Map.of("name", Expressions.expression("VALUE.any")));
-        assertThat(mappedRecord.filter(unboundSelectors)).isEmpty();
-    }
-
-    @Test
-    public void shouldFilter() throws ExtractionException {
-        DataExtractor<String, JsonNode> nameExtractor =
-                extractor("test", Map.of("name", Expressions.expression("VALUE.name")));
-
-        DataExtractor<String, JsonNode> childExtractor1 =
-                extractor(
-                        "test",
-                        Map.of("firstChildName", Expressions.expression("VALUE.children[0].name")));
-
-        DataExtractor<String, JsonNode> childExtractor2 =
-                extractor(
-                        "test",
-                        Map.of(
-                                "secondChildName",
-                                Expressions.expression("VALUE.children[1].name"),
-                                "grandChildName",
-                                Expressions.expression("VALUE.children[1].children[1].name")));
-
-        RecordMapper<String, JsonNode> mapper =
-                builder()
-                        .withExtractor(nameExtractor)
-                        .withExtractor(childExtractor1)
-                        .withExtractor(childExtractor2)
-                        .build();
-
-        KafkaRecord<String, JsonNode> kafkaRecord =
-                ConsumerRecords.record("", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(4);
-
-        Map<String, String> parentName = mappedRecord.filter(nameExtractor);
-        assertThat(parentName).containsExactly("name", "joe");
-
-        Map<String, String> firstChildName = mappedRecord.filter(childExtractor1);
-        assertThat(firstChildName).containsExactly("firstChildName", "alex");
-
-        Map<String, String> otherPeopleNames = mappedRecord.filter(childExtractor2);
-        assertThat(otherPeopleNames)
-                .containsExactly("secondChildName", "anna", "grandChildName", "terence");
-    }
-
-    @Test
-    public void shouldFilterWithNullValues() throws ExtractionException {
-        DataExtractor<String, JsonNode> extractor =
-                extractor(
-                        "test",
-                        Map.of(
-                                "name",
-                                Expressions.expression("VALUE.children[0].name"),
-                                "signature",
-                                Expressions.expression("VALUE.children[0].signature")));
-
-        RecordMapper<String, JsonNode> mapper = builder().withExtractor(extractor).build();
-
-        KafkaRecord<String, JsonNode> kafkaRecord =
-                ConsumerRecords.record("", JsonNodeProvider.RECORD);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(2);
-
-        Map<String, String> parentName = mappedRecord.filter(extractor);
-        assertThat(parentName).containsExactly("name", "alex", "signature", null);
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperSinkRecordTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperSinkRecordTest.java
deleted file mode 100644
index 3d5e8bd6..00000000
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperSinkRecordTest.java
+++ /dev/null
@@ -1,221 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.common.mapping;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.lightstreamer.kafka.common.expressions.Expressions;
-import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.Builder;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
-import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
-import com.lightstreamer.kafka.test_utils.ConsumerRecords;
-import com.lightstreamer.kafka.test_utils.SchemaAndValueProvider;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
-
-import org.apache.kafka.connect.data.Struct;
-import org.apache.kafka.connect.sink.SinkRecord;
-import org.junit.jupiter.api.Test;
-
-import java.util.Map;
-
-public class RecordMapperSinkRecordTest {
-
-    private static DataExtractor<Object, Object> extractor(
-            String schemaName, Map<String, ExtractionExpression> expressions)
-            throws ExtractionException {
-
-        return DataExtractor.builder()
-                .withSuppliers(TestSelectorSuppliers.object())
-                .withSchemaName(schemaName)
-                .withExpressions(expressions)
-                .build();
-    }
-
-    private static Builder<Object, Object> builder() {
-        return RecordMapper.<Object, Object>builder();
-    }
-
-    @Test
-    public void shouldBuildEmptyMapper() {
-        RecordMapper<Object, Object> mapper = builder().build();
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldBuildMapperWithDuplicateSelectors() throws ExtractionException {
-        RecordMapper<Object, Object> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .build();
-
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(1);
-    }
-
-    @Test
-    public void shouldBuildMapperWithDifferentSelectors() throws ExtractionException {
-        RecordMapper<Object, Object> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test1",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor(
-                                        "test2",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .build();
-
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(2);
-    }
-
-    @Test
-    public void shouldMapEmpty() {
-        RecordMapper<Object, Object> mapper = builder().build();
-
-        KafkaRecord<Object, Object> kafkaRecord =
-                ConsumerRecords.sinkRecord("topic", null, SchemaAndValueProvider.STRUCT);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        // No expected values because no selectors have been bound to the RecordMapper.
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldMapWithValues() throws ExtractionException {
-        RecordMapper<Object, Object> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test1",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor("test2", Map.of("aKey", Expressions.expression("TOPIC"))))
-                        .withExtractor(
-                                extractor(
-                                        "test3",
-                                        Map.of("aKey", Expressions.expression("TIMESTAMP"))))
-                        .build();
-
-        KafkaRecord<Object, Object> kafkaRecord =
-                ConsumerRecords.sinkRecord("topic", null, SchemaAndValueProvider.STRUCT);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(3);
-    }
-
-    @Test
-    public void shoulNotFilterDueToUnboundSelectors() throws ExtractionException {
-        RecordMapper<Object, Object> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("name", Expressions.expression("PARTITION"))))
-                        .build();
-
-        KafkaRecord<Object, Object> kafkaRecord =
-                ConsumerRecords.sinkRecord("topic", null, SchemaAndValueProvider.STRUCT);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(1);
-        DataExtractor<Object, Object> unboundExtractor =
-                extractor("test", Map.of("name", Expressions.expression("VALUE.any")));
-        assertThat(mappedRecord.filter(unboundExtractor)).isEmpty();
-    }
-
-    @Test
-    public void shouldFilter() throws ExtractionException {
-        DataExtractor<Object, Object> nameExtractor =
-                extractor("test", Map.of("name", Expressions.expression("VALUE.name")));
-
-        DataExtractor<Object, Object> childExtractor1 =
-                extractor(
-                        "test",
-                        Map.of("firstChildName", Expressions.expression("VALUE.children[0].name")));
-
-        DataExtractor<Object, Object> childExtractor2 =
-                extractor(
-                        "test",
-                        Map.of(
-                                "secondChildName",
-                                Expressions.expression("VALUE.children[1].name"),
-                                "grandChildName",
-                                Expressions.expression("VALUE.children[1].children[1].name")));
-
-        RecordMapper<Object, Object> mapper =
-                builder()
-                        .withExtractor(nameExtractor)
-                        .withExtractor(childExtractor1)
-                        .withExtractor(childExtractor2)
-                        .build();
-
-        KafkaRecord<Object, Object> kafkaRecord =
-                ConsumerRecords.sinkFromValue(
-                        "topic",
-                        SchemaAndValueProvider.STRUCT.schema(),
-                        SchemaAndValueProvider.STRUCT);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(4);
-
-        Map<String, String> parentName = mappedRecord.filter(nameExtractor);
-        assertThat(parentName).containsExactly("name", "joe");
-
-        Map<String, String> firstChildName = mappedRecord.filter(childExtractor1);
-        assertThat(firstChildName).containsExactly("firstChildName", "alex");
-
-        Map<String, String> otherPeopleNames = mappedRecord.filter(childExtractor2);
-        assertThat(otherPeopleNames)
-                .containsExactly("secondChildName", "anna", "grandChildName", "terence");
-    }
-
-    @Test
-    public void shouldFilterWithNullValues() throws ExtractionException {
-        DataExtractor<Object, Object> extractor =
-                extractor(
-                        "test",
-                        Map.of(
-                                "name",
-                                Expressions.expression("VALUE.children[0].name"),
-                                "signature",
-                                Expressions.expression("VALUE.children[0].signature")));
-
-        RecordMapper<Object, Object> mapper = builder().withExtractor(extractor).build();
-
-        Struct STRUCT = SchemaAndValueProvider.STRUCT;
-        KafkaRecord<Object, Object> kafkaRecord =
-                KafkaRecord.from(
-                        new SinkRecord("topic", 1, null, null, STRUCT.schema(), STRUCT, 0));
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(2);
-
-        Map<String, String> parentName = mappedRecord.filter(extractor);
-        assertThat(parentName).containsExactly("name", "alex", "signature", null);
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperStringTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperStringTest.java
deleted file mode 100644
index 5301d679..00000000
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperStringTest.java
+++ /dev/null
@@ -1,188 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.common.mapping;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.lightstreamer.kafka.common.expressions.Expressions;
-import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.Builder;
-import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
-import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
-import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
-import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
-import com.lightstreamer.kafka.test_utils.ConsumerRecords;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.Map;
-
-public class RecordMapperStringTest {
-
-    private static DataExtractor<String, String> extractor(
-            String schemaName, Map<String, ExtractionExpression> expressions)
-            throws ExtractionException {
-
-        return DataExtractor.<String, String>builder()
-                .withSuppliers(TestSelectorSuppliers.string())
-                .withSchemaName(schemaName)
-                .withExpressions(expressions)
-                .build();
-    }
-
-    private static Builder<String, String> builder() {
-        return RecordMapper.<String, String>builder();
-    }
-
-    @Test
-    public void shouldBuildEmptyMapper() {
-        RecordMapper<String, String> mapper = builder().build();
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldBuildMapperWithDuplicateSelectors() throws ExtractionException {
-        RecordMapper<String, String> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .build();
-
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(1);
-    }
-
-    @Test
-    public void shouldBuildMapperWithDifferentSelectors() throws ExtractionException {
-        RecordMapper<String, String> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test1",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor(
-                                        "test2",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .build();
-
-        assertThat(mapper).isNotNull();
-        assertThat(mapper.selectorsSize()).isEqualTo(2);
-    }
-
-    @Test
-    public void shouldMapEmpty() {
-        RecordMapper<String, String> mapper = builder().build();
-
-        KafkaRecord<String, String> kafkaRecord = ConsumerRecords.record("", "aValue");
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        // No expected values because no selectors have been bound to the RecordMapper.
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(0);
-    }
-
-    @Test
-    public void shouldMapWithValues() throws ExtractionException {
-        RecordMapper<String, String> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test1",
-                                        Map.of("aKey", Expressions.expression("PARTITION"))))
-                        .withExtractor(
-                                extractor("test2", Map.of("aKey", Expressions.expression("TOPIC"))))
-                        .withExtractor(
-                                extractor(
-                                        "test3",
-                                        Map.of("aKey", Expressions.expression("TIMESTAMP"))))
-                        .build();
-
-        KafkaRecord<String, String> kafkaRecord = ConsumerRecords.record(null, "aValue");
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(3);
-    }
-
-    @Test
-    public void shoulNotFilterDueToUnboundSelectors() throws ExtractionException {
-        RecordMapper<String, String> mapper =
-                builder()
-                        .withExtractor(
-                                extractor(
-                                        "test",
-                                        Map.of("name", Expressions.expression("PARTITION"))))
-                        .build();
-
-        KafkaRecord<String, String> kafkaRecord = ConsumerRecords.record("", "aValue");
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(1);
-        DataExtractor<String, String> unboundExtractor =
-                extractor("test", Map.of("name", Expressions.expression("VALUE")));
-        assertThat(mappedRecord.filter(unboundExtractor)).isEmpty();
-    }
-
-    @Test
-    public void shouldFilter() throws ExtractionException {
-        DataExtractor<String, String> valueExtractor =
-                extractor("test", Map.of("name", Expressions.expression("VALUE")));
-        DataExtractor<String, String> keyExtractor =
-                extractor("test", Map.of("name", Expressions.expression("KEY")));
-
-        RecordMapper<String, String> mapper =
-                builder().withExtractor(valueExtractor).withExtractor(keyExtractor).build();
-
-        KafkaRecord<String, String> kafkaRecord = ConsumerRecords.record("", "aValue");
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(2);
-
-        Map<String, String> parentName = mappedRecord.filter(valueExtractor);
-        assertThat(parentName).containsExactly("name", "aValue");
-
-        Map<String, String> firstChildName = mappedRecord.filter(keyExtractor);
-        assertThat(firstChildName).containsExactly("name", "");
-    }
-
-    @Test
-    public void shouldFilterNulls() throws ExtractionException {
-        DataExtractor<String, String> valueExtractor =
-                extractor("test", Map.of("name", Expressions.expression("VALUE")));
-        DataExtractor<String, String> keyExtractor =
-                extractor("test", Map.of("name", Expressions.expression("KEY")));
-
-        RecordMapper<String, String> mapper =
-                builder().withExtractor(valueExtractor).withExtractor(keyExtractor).build();
-
-        KafkaRecord<String, String> kafkaRecord = ConsumerRecords.record("", null);
-        MappedRecord mappedRecord = mapper.map(kafkaRecord);
-        assertThat(mappedRecord.mappedValuesSize()).isEqualTo(2);
-
-        Map<String, String> parentName = mappedRecord.filter(valueExtractor);
-        assertThat(parentName).containsExactly("name", null);
-
-        Map<String, String> firstChildName = mappedRecord.filter(keyExtractor);
-        assertThat(firstChildName).containsExactly("name", "");
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperTest.java
new file mode 100644
index 00000000..139a9dda
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordMapperTest.java
@@ -0,0 +1,476 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.common.mapping;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.adapters.mapping.selectors.others.OthersSelectorSuppliers.String;
+import static com.lightstreamer.kafka.common.expressions.Expressions.Expression;
+import static com.lightstreamer.kafka.common.mapping.selectors.DataExtractor.extractor;
+import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.AvroValue;
+import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.JsonValue;
+import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.Object;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.lightstreamer.kafka.common.mapping.RecordMapper.Builder;
+import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
+import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.SchemaAndValues;
+import com.lightstreamer.kafka.test_utils.GenericRecordProvider;
+import com.lightstreamer.kafka.test_utils.JsonNodeProvider;
+import com.lightstreamer.kafka.test_utils.Records;
+import com.lightstreamer.kafka.test_utils.SchemaAndValueProvider;
+
+import org.apache.avro.generic.GenericRecord;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+import java.util.Set;
+
+public class RecordMapperTest {
+
+    private static final String TEST_TOPIC_1 = "topic";
+    private static final String TEST_TOPIC_2 = "anotherTopic";
+
+    private static Builder<String, String> builder() {
+        return RecordMapper.<String, String>builder();
+    }
+
+    @Test
+    public void shouldBuildEmptyMapper() {
+        RecordMapper<String, String> mapper = builder().build();
+        assertThat(mapper).isNotNull();
+        assertThat(mapper.hasExtractors()).isFalse();
+        assertThat(mapper.hasFieldExtractor()).isFalse();
+    }
+
+    @Test
+    public void shouldBuildMapperWithDuplicateTemplateExtractors() throws ExtractionException {
+        RecordMapper<String, String> mapper =
+                builder()
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        String(), "test", Map.of("aKey", Expression("PARTITION"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        String(), "test", Map.of("aKey", Expression("PARTITION"))))
+                        .build();
+
+        assertThat(mapper).isNotNull();
+        assertThat(mapper.hasExtractors()).isTrue();
+        assertThat(mapper.hasFieldExtractor()).isFalse();
+        assertThat(mapper.getExtractorsByTopicName(TEST_TOPIC_1)).hasSize(1);
+        assertThat(mapper.getExtractorsByTopicName(TEST_TOPIC_1))
+                .containsExactly(
+                        extractor(String(), "test", Map.of("aKey", Expression("PARTITION"))));
+    }
+
+    @Test
+    public void shouldBuildMapperWithDifferentTemplateExtractors() throws ExtractionException {
+        RecordMapper<String, String> mapper =
+                builder()
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(String(), "prefix1", Map.of("aKey", Expression("KEY"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        String(),
+                                        "prefix2",
+                                        Map.of("aValue", Expression("PARTITION"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_2,
+                                extractor(
+                                        String(),
+                                        "anotherPrefix",
+                                        Map.of("aKey", Expression("PARTITION"))))
+                        .build();
+
+        assertThat(mapper).isNotNull();
+        assertThat(mapper.hasExtractors()).isTrue();
+        assertThat(mapper.hasFieldExtractor()).isFalse();
+
+        assertThat(mapper.getExtractorsByTopicName(TEST_TOPIC_1)).hasSize(2);
+        assertThat(mapper.getExtractorsByTopicName(TEST_TOPIC_1))
+                .containsExactly(
+                        extractor(String(), "prefix1", Map.of("aKey", Expression("KEY"))),
+                        extractor(String(), "prefix2", Map.of("aValue", Expression("PARTITION"))));
+        assertThat(mapper.getExtractorsByTopicName(TEST_TOPIC_2)).hasSize(1);
+        assertThat(mapper.getExtractorsByTopicName(TEST_TOPIC_2))
+                .containsExactly(
+                        extractor(
+                                String(),
+                                "anotherPrefix",
+                                Map.of("aKey", Expression("PARTITION"))));
+    }
+
+    @Test
+    public void shouldBuildWithFieldsExtractor() throws ExtractionException {
+        RecordMapper<String, String> mapper =
+                builder()
+                        .withFieldExtractor(
+                                extractor(
+                                        String(),
+                                        "fields",
+                                        Map.of("aKey", Expression("PARTITION"))))
+                        .build();
+
+        assertThat(mapper).isNotNull();
+        assertThat(mapper.hasExtractors()).isFalse();
+        assertThat(mapper.hasFieldExtractor()).isTrue();
+    }
+
+    @Test
+    public void shouldMapRecordWithMatchingTopic() throws ExtractionException {
+        RecordMapper<String, String> mapper =
+                builder()
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        String(),
+                                        "prefix1",
+                                        Map.of(
+                                                "partition",
+                                                Expression("PARTITION"),
+                                                "value",
+                                                Expression("VALUE"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        String(), "prefix2", Map.of("topic", Expression("TOPIC"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(String(), "prefix3", Map.of("key", Expression("KEY"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_2,
+                                extractor(
+                                        String(), "prefix3", Map.of("value", Expression("VALUE"))))
+                        .withFieldExtractor(
+                                extractor(
+                                        String(),
+                                        "fields",
+                                        Map.of(
+                                                "keyField",
+                                                Expression("KEY"),
+                                                "valueField",
+                                                Expression("VALUE"))))
+                        .build();
+        assertThat(mapper.hasExtractors()).isTrue();
+        assertThat(mapper.hasFieldExtractor()).isTrue();
+
+        // Record published to topic "topic": mapping
+        KafkaRecord<String, String> kafkaRecord1 = Records.record(TEST_TOPIC_1, "aKey", "aValue");
+        MappedRecord mappedRecord1 = mapper.map(kafkaRecord1);
+        Set<SchemaAndValues> expandedFromTestsTopic = mappedRecord1.expanded();
+        assertThat(expandedFromTestsTopic)
+                .containsExactly(
+                        SchemaAndValues.from(
+                                "prefix1", Map.of("partition", "150", "value", "aValue")),
+                        SchemaAndValues.from("prefix2", Map.of("topic", TEST_TOPIC_1)),
+                        SchemaAndValues.from("prefix3", Map.of("key", "aKey")));
+        assertThat(mappedRecord1.fieldsMap())
+                .containsExactly("keyField", "aKey", "valueField", "aValue");
+
+        // Record published to topic "anotherTopic": mapping
+        KafkaRecord<String, String> kafkaRecord2 =
+                Records.record(TEST_TOPIC_2, "anotherKey", "anotherValue");
+        MappedRecord mappedRecord2 = mapper.map(kafkaRecord2);
+        Set<SchemaAndValues> expandedFromAnotherTopic = mappedRecord2.expanded();
+        assertThat(expandedFromAnotherTopic)
+                .containsExactly(SchemaAndValues.from("prefix3", Map.of("value", "anotherValue")));
+        assertThat(mappedRecord2.fieldsMap())
+                .containsExactly("keyField", "anotherKey", "valueField", "anotherValue");
+
+        // Record published to topic "undefinedTopic": no mapping
+        KafkaRecord<String, String> kafkaRecord3 =
+                Records.record("undefinedTopic", "anotherKey", "anotherValue");
+        MappedRecord mappedRecord3 = mapper.map(kafkaRecord3);
+        assertThat(mappedRecord3.expanded()).isEmpty();
+        assertThat(mappedRecord3.fieldsMap()).isEmpty();
+    }
+
+    @Test
+    public void shouldMapJsonRecordWithMatchingTopic() throws ExtractionException {
+        RecordMapper<String, JsonNode> mapper =
+                RecordMapper.<String, JsonNode>builder()
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        JsonValue(),
+                                        "test",
+                                        Map.of("name", Expression("VALUE.name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        JsonValue(),
+                                        "test",
+                                        Map.of(
+                                                "firstChildName",
+                                                Expression("VALUE.children[0].name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        JsonValue(),
+                                        "test",
+                                        Map.of(
+                                                "secondChildName",
+                                                Expression("VALUE.children[1].name"),
+                                                "grandChildName",
+                                                Expression("VALUE.children[1].children[1].name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_2,
+                                extractor(
+                                        JsonValue(),
+                                        "test",
+                                        Map.of(
+                                                "thirdChildName",
+                                                Expression("VALUE.children[2].name"),
+                                                "grandChildName",
+                                                Expression("VALUE.children[1].children[0].name"))))
+                        .withFieldExtractor(
+                                extractor(
+                                        JsonValue(),
+                                        "fields",
+                                        Map.of(
+                                                "firstName",
+                                                Expression("VALUE.name"),
+                                                "childSignature",
+                                                Expression("VALUE.children[0].signature"))))
+                        .build();
+        assertThat(mapper.hasExtractors()).isTrue();
+        assertThat(mapper.hasFieldExtractor()).isTrue();
+
+        // Record published to topic "topic": mapping
+        KafkaRecord<String, JsonNode> kafkaRecord =
+                Records.record(TEST_TOPIC_1, "", JsonNodeProvider.RECORD);
+        MappedRecord mappedRecord = mapper.map(kafkaRecord);
+        Set<SchemaAndValues> expandedFromTestsTopic = mappedRecord.expanded();
+        assertThat(expandedFromTestsTopic)
+                .containsExactly(
+                        SchemaAndValues.from("test", Map.of("name", "joe")),
+                        SchemaAndValues.from("test", Map.of("firstChildName", "alex")),
+                        SchemaAndValues.from(
+                                "test",
+                                Map.of("secondChildName", "anna", "grandChildName", "terence")));
+        assertThat(mappedRecord.fieldsMap())
+                .containsExactly("firstName", "joe", "childSignature", null);
+
+        // Record published to topic "anotherTopic": mapping
+        KafkaRecord<String, JsonNode> kafkaRecord2 =
+                Records.record(TEST_TOPIC_2, "", JsonNodeProvider.RECORD);
+        MappedRecord mappedRecord2 = mapper.map(kafkaRecord2);
+        Set<SchemaAndValues> expandedFromAnotherTopic = mappedRecord2.expanded();
+        assertThat(expandedFromAnotherTopic)
+                .containsExactly(
+                        SchemaAndValues.from(
+                                "test",
+                                Map.of("thirdChildName", "serena", "grandChildName", "gloria")));
+        assertThat(mappedRecord2.fieldsMap())
+                .containsExactly("firstName", "joe", "childSignature", null);
+
+        // Record published to topic "undefinedTopic": no mapping
+        KafkaRecord<String, JsonNode> kafkaRecord3 =
+                Records.record("undefinedTopic", "", JsonNodeProvider.RECORD);
+        MappedRecord mappedRecord3 = mapper.map(kafkaRecord3);
+        assertThat(mappedRecord3.expanded()).isEmpty();
+        assertThat(mappedRecord3.fieldsMap()).isEmpty();
+    }
+
+    @Test
+    public void shouldMapAvroRecordWithMatchingTopic() throws ExtractionException {
+        RecordMapper<String, GenericRecord> mapper =
+                RecordMapper.<String, GenericRecord>builder()
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        AvroValue(),
+                                        "test",
+                                        Map.of("name", Expression("VALUE.name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        AvroValue(),
+                                        "test",
+                                        Map.of(
+                                                "firstChildName",
+                                                Expression("VALUE.children[0].name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        AvroValue(),
+                                        "test",
+                                        Map.of(
+                                                "secondChildName",
+                                                Expression("VALUE.children[1].name"),
+                                                "grandChildName",
+                                                Expression("VALUE.children[1].children[1].name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_2,
+                                extractor(
+                                        AvroValue(),
+                                        "test",
+                                        Map.of(
+                                                "thirdChildName",
+                                                Expression("VALUE.children[2].name"),
+                                                "grandChildName",
+                                                Expression("VALUE.children[1].children[0].name"))))
+                        .withFieldExtractor(
+                                extractor(
+                                        AvroValue(),
+                                        "fields",
+                                        Map.of(
+                                                "firstName",
+                                                Expression("VALUE.name"),
+                                                "childSignature",
+                                                Expression("VALUE.children[0].signature"))))
+                        .build();
+        assertThat(mapper.hasExtractors()).isTrue();
+        assertThat(mapper.hasFieldExtractor()).isTrue();
+
+        // Record published to topic "topic": mapping
+        KafkaRecord<String, GenericRecord> kafkaRecord =
+                Records.record(TEST_TOPIC_1, "", GenericRecordProvider.RECORD);
+        MappedRecord mappedRecord = mapper.map(kafkaRecord);
+        Set<SchemaAndValues> expandedFromTestsTopic = mappedRecord.expanded();
+        assertThat(expandedFromTestsTopic)
+                .containsExactly(
+                        SchemaAndValues.from("test", Map.of("name", "joe")),
+                        SchemaAndValues.from("test", Map.of("firstChildName", "alex")),
+                        SchemaAndValues.from(
+                                "test",
+                                Map.of("secondChildName", "anna", "grandChildName", "terence")));
+        assertThat(mappedRecord.fieldsMap())
+                .containsExactly("firstName", "joe", "childSignature", null);
+
+        // Record published to topic "anotherTopic": mapping
+        KafkaRecord<String, GenericRecord> kafkaRecord2 =
+                Records.record(TEST_TOPIC_2, "", GenericRecordProvider.RECORD);
+        MappedRecord mappedRecord2 = mapper.map(kafkaRecord2);
+        Set<SchemaAndValues> expandedFromAnotherTopic = mappedRecord2.expanded();
+        assertThat(expandedFromAnotherTopic)
+                .containsExactly(
+                        SchemaAndValues.from(
+                                "test",
+                                Map.of("thirdChildName", "serena", "grandChildName", "gloria")));
+        assertThat(mappedRecord2.fieldsMap())
+                .containsExactly("firstName", "joe", "childSignature", null);
+
+        // Record published to topic "undefinedTopic": no mapping
+        KafkaRecord<String, GenericRecord> kafkaRecord3 =
+                Records.record("undefinedTopic", "", GenericRecordProvider.RECORD);
+        MappedRecord mappedRecord3 = mapper.map(kafkaRecord3);
+        assertThat(mappedRecord3.expanded()).isEmpty();
+        assertThat(mappedRecord3.fieldsMap()).isEmpty();
+    }
+
+    @Test
+    public void shouldMapSinkRecordMatchingTopic() throws ExtractionException {
+        RecordMapper<Object, Object> mapper =
+                RecordMapper.<Object, Object>builder()
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        Object(), "test", Map.of("name", Expression("VALUE.name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        Object(),
+                                        "test",
+                                        Map.of(
+                                                "firstChildName",
+                                                Expression("VALUE.children[0].name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_1,
+                                extractor(
+                                        Object(),
+                                        "test",
+                                        Map.of(
+                                                "secondChildName",
+                                                Expression("VALUE.children[1].name"),
+                                                "grandChildName",
+                                                Expression("VALUE.children[1].children[1].name"))))
+                        .withTemplateExtractor(
+                                TEST_TOPIC_2,
+                                extractor(
+                                        Object(),
+                                        "test",
+                                        Map.of(
+                                                "thirdChildName",
+                                                Expression("VALUE.children[2].name"),
+                                                "grandChildName",
+                                                Expression("VALUE.children[1].children[0].name"))))
+                        .withFieldExtractor(
+                                extractor(
+                                        Object(),
+                                        "fields",
+                                        Map.of(
+                                                "firstName",
+                                                Expression("VALUE.name"),
+                                                "childSignature",
+                                                Expression("VALUE.children[0].signature"))))
+                        .build();
+        assertThat(mapper.hasExtractors()).isTrue();
+        assertThat(mapper.hasFieldExtractor()).isTrue();
+
+        // Record published to topic "topic": mapping
+        KafkaRecord<Object, Object> kafkaRecord =
+                Records.sinkFromValue(
+                        TEST_TOPIC_1,
+                        SchemaAndValueProvider.STRUCT.schema(),
+                        SchemaAndValueProvider.STRUCT);
+        MappedRecord mappedRecord = mapper.map(kafkaRecord);
+        Set<SchemaAndValues> expandedFromTestsTopic = mappedRecord.expanded();
+        assertThat(expandedFromTestsTopic)
+                .containsExactly(
+                        SchemaAndValues.from("test", Map.of("name", "joe")),
+                        SchemaAndValues.from("test", Map.of("firstChildName", "alex")),
+                        SchemaAndValues.from(
+                                "test",
+                                Map.of("secondChildName", "anna", "grandChildName", "terence")));
+        assertThat(mappedRecord.fieldsMap())
+                .containsExactly("firstName", "joe", "childSignature", null);
+
+        // Record published to topic "anotherTopic": mapping
+        KafkaRecord<Object, Object> kafkaRecord2 =
+                Records.sinkFromValue(
+                        TEST_TOPIC_2,
+                        SchemaAndValueProvider.STRUCT.schema(),
+                        SchemaAndValueProvider.STRUCT);
+        MappedRecord mappedRecord2 = mapper.map(kafkaRecord2);
+        Set<SchemaAndValues> expandedFromAnotherTopic = mappedRecord2.expanded();
+        assertThat(expandedFromAnotherTopic)
+                .containsExactly(
+                        SchemaAndValues.from(
+                                "test",
+                                Map.of("thirdChildName", "serena", "grandChildName", "gloria")));
+        assertThat(mappedRecord2.fieldsMap())
+                .containsExactly("firstName", "joe", "childSignature", null);
+
+        // Record published to topic "undefinedTopic": no mapping
+        KafkaRecord<Object, Object> kafkaRecord3 =
+                Records.record(
+                        "undefinedTopic",
+                        SchemaAndValueProvider.STRUCT.schema(),
+                        SchemaAndValueProvider.STRUCT);
+        MappedRecord mappedRecord3 = mapper.map(kafkaRecord3);
+        assertThat(mappedRecord3.expanded()).isEmpty();
+        assertThat(mappedRecord3.fieldsMap()).isEmpty();
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordRoutingTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordRoutingTest.java
new file mode 100644
index 00000000..5f49f797
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/RecordRoutingTest.java
@@ -0,0 +1,286 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.common.mapping;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.common.mapping.Items.subscribedFrom;
+import static com.lightstreamer.kafka.test_utils.Records.record;
+import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.JsonValue;
+
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.lightstreamer.kafka.adapters.mapping.selectors.others.OthersSelectorSuppliers;
+import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
+import com.lightstreamer.kafka.common.mapping.Items.SubscribedItem;
+import com.lightstreamer.kafka.common.mapping.RecordMapper.MappedRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
+import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
+import com.lightstreamer.kafka.test_utils.GenericRecordProvider;
+import com.lightstreamer.kafka.test_utils.ItemTemplatesUtils;
+import com.lightstreamer.kafka.test_utils.JsonNodeProvider;
+import com.lightstreamer.kafka.test_utils.Records;
+
+import org.apache.avro.generic.GenericRecord;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+
+public class RecordRoutingTest {
+
+    private static final String TEST_TOPIC_1 = "topic";
+    private static final String TEST_TOPIC_2 = "anotherTopic";
+
+    static Stream<Arguments> itemArgs() {
+        return Stream.of(
+                // One-to-One
+                arguments(
+                        List.of(TEST_TOPIC_1),
+                        "item",
+                        // Routeable item
+                        List.of(subscribedFrom("item", "handle1")),
+                        // Non-routeable item
+                        List.of(subscribedFrom("otherItem", "handle2"))),
+                // Many-to-One
+                arguments(
+                        List.of(TEST_TOPIC_1, TEST_TOPIC_2),
+                        "item",
+                        // Routeable item
+                        List.of(subscribedFrom("item", "handle1")),
+                        // Non-routeable item
+                        List.of(subscribedFrom("otherItem", "handle2"))));
+    }
+
+    @ParameterizedTest
+    @MethodSource("itemArgs")
+    public void shouldRoutesFromSimpleItems(
+            List<String> topics,
+            String item,
+            List<SubscribedItem> routables,
+            List<SubscribedItem> nonRoutables)
+            throws ExtractionException {
+        ItemTemplates<String, String> templates =
+                ItemTemplatesUtils.mkSimpleItems(
+                        OthersSelectorSuppliers.String(), topics, List.of(item));
+        RecordMapper<String, String> mapper =
+                RecordMapper.<String, String>builder()
+                        .withTemplateExtractors(templates.extractorsByTopicName())
+                        .build();
+
+        for (String topic : topics) {
+            MappedRecord mapped = mapper.map(Records.record(topic, "key", "value"));
+            List<SubscribedItem> all =
+                    Stream.concat(routables.stream(), nonRoutables.stream()).toList();
+
+            Set<SubscribedItem> routed = mapped.route(all);
+            assertThat(routed).containsExactlyElementsIn(routables);
+        }
+    }
+
+    static Stream<Arguments> templateArgs() {
+        return Stream.of(
+                arguments(
+                        List.of(TEST_TOPIC_1, TEST_TOPIC_2),
+                        List.of("item-#{key=KEY,value=VALUE,topic=TOPIC}"),
+                        Map.of(
+                                // Routable items for TEST_TOPIC_1
+                                TEST_TOPIC_1,
+                                List.of(
+                                        subscribedFrom(
+                                                "item-[key=key,value=value,topic=topic]",
+                                                "handle1"),
+                                        subscribedFrom(
+                                                "item-[value=value,topic=topic,key=key]",
+                                                "handle2")),
+                                // Routable items for TEST_TOPIC_2
+                                TEST_TOPIC_2,
+                                List.of(
+                                        subscribedFrom(
+                                                "item-[key=key,value=value,topic=anotherTopic]",
+                                                "handle1"),
+                                        subscribedFrom(
+                                                "item-[topic=anotherTopic,value=value,key=key]",
+                                                "handle2"))),
+                        Map.of(
+                                // Non-routable items for TEST_TOPIC_1
+                                TEST_TOPIC_1,
+                                List.of(
+                                        subscribedFrom(
+                                                "item-[key=key,value=value,topic=anotherTopic]",
+                                                "handle1"),
+                                        subscribedFrom("item", "handle3"),
+                                        subscribedFrom("item-[key=key]", "handle4"),
+                                        subscribedFrom("item-[key=anotherKey]", "handle5"),
+                                        subscribedFrom("item-[value=anotherValue]", "handle6"),
+                                        subscribedFrom("nonRoutable", new Object())),
+                                // Non-routable items for TEST_TOPIC_2
+                                TEST_TOPIC_2,
+                                List.of(
+                                        subscribedFrom(
+                                                "item-[key=key,value=value,topic=topic]",
+                                                "handle1"),
+                                        subscribedFrom("item", "handle3"),
+                                        subscribedFrom("item-[key=key]", "handle4"),
+                                        subscribedFrom("item-[key=anotherKey]", "handle5"),
+                                        subscribedFrom("item-[value=anotherValue]", "handle6"),
+                                        subscribedFrom("nonRoutable", new Object())))));
+    }
+
+    @ParameterizedTest
+    @MethodSource("templateArgs")
+    public void shouldRoutesFromTemplates(
+            List<String> topics,
+            List<String> templateStr,
+            Map<String, List<SubscribedItem>> routables,
+            Map<String, List<SubscribedItem>> nonRoutables)
+            throws ExtractionException {
+        ItemTemplates<String, String> templates =
+                ItemTemplatesUtils.ItemTemplates(
+                        OthersSelectorSuppliers.String(), topics, templateStr);
+        RecordMapper<String, String> mapper =
+                RecordMapper.<String, String>builder()
+                        .withTemplateExtractors(templates.extractorsByTopicName())
+                        .build();
+
+        for (String topic : topics) {
+            MappedRecord mapped = mapper.map(Records.record(topic, "key", "value"));
+            List<SubscribedItem> routablesForTopic = routables.get(topic);
+            List<SubscribedItem> nonRoutableForTopic = nonRoutables.get(topic);
+
+            List<SubscribedItem> all = new ArrayList<>(routablesForTopic);
+            all.addAll(nonRoutableForTopic);
+
+            Set<SubscribedItem> routed = mapped.route(all);
+            assertThat(routed).containsExactlyElementsIn(routablesForTopic);
+        }
+    }
+
+    static Stream<Arguments> templateArgsJson() {
+        return Stream.of(
+                arguments(
+                        """
+                            {
+                            "name": "James",
+                            "surname": "Kirk",
+                            "age": 37
+                            }
+                            """,
+                        List.of("user-#{firstName=VALUE.name,lastName=VALUE.surname}"),
+                        List.of(
+                                subscribedFrom(
+                                        "user-[firstName=James,lastName=Kirk]", new Object())),
+                        List.of(
+                                subscribedFrom("item", new Object()),
+                                subscribedFrom("item-[key=key]", new Object()),
+                                subscribedFrom("item-[key=anotherKey]", new Object()),
+                                subscribedFrom("item-[value=anotherValue]", new Object()),
+                                subscribedFrom("nonRoutable", new Object()))));
+    }
+
+    @ParameterizedTest
+    @MethodSource("templateArgsJson")
+    public void shouldRoutesFromTemplateWithJsonValueRecord(
+            String jsonString,
+            List<String> templateStr,
+            List<SubscribedItem> routables,
+            List<SubscribedItem> nonRoutables)
+            throws JsonMappingException, JsonProcessingException, ExtractionException {
+        ItemTemplates<String, JsonNode> templates =
+                ItemTemplatesUtils.ItemTemplates(JsonValue(), List.of(TEST_TOPIC_1), templateStr);
+        RecordMapper<String, JsonNode> mapper =
+                RecordMapper.<String, JsonNode>builder()
+                        .withTemplateExtractors(templates.extractorsByTopicName())
+                        .build();
+
+        ObjectMapper om = new ObjectMapper();
+        JsonNode jsonNode = om.readTree(jsonString);
+        MappedRecord mapped = mapper.map(Records.record(TEST_TOPIC_1, "key", jsonNode));
+        List<SubscribedItem> all =
+                Stream.concat(routables.stream(), nonRoutables.stream()).toList();
+        Set<SubscribedItem> routed = mapped.route(all);
+        assertThat(routed).containsExactlyElementsIn(routables);
+    }
+
+    @ParameterizedTest
+    @CsvFileSource(
+            files = "src/test/resources/should-route-items.csv",
+            useHeadersInDisplayName = true,
+            delimiter = '|')
+    public void shouldRoute(
+            String template, String subscribingItem, boolean canSubscribe, boolean routeable)
+            throws ExtractionException {
+        ItemTemplates<GenericRecord, GenericRecord> templates =
+                ItemTemplatesUtils.AvroAvroTemplates(TEST_TOPIC_1, template);
+        RecordMapper<GenericRecord, GenericRecord> mapper =
+                RecordMapper.<GenericRecord, GenericRecord>builder()
+                        .withTemplateExtractors(templates.extractorsByTopicName())
+                        .build();
+
+        KafkaRecord<GenericRecord, GenericRecord> incomingRecord =
+                record(TEST_TOPIC_1, GenericRecordProvider.RECORD, GenericRecordProvider.RECORD);
+        MappedRecord mapped = mapper.map(incomingRecord);
+        SubscribedItem subscribedItem = subscribedFrom(subscribingItem, new Object());
+
+        assertThat(templates.matches(subscribedItem)).isEqualTo(canSubscribe);
+        Set<SubscribedItem> routed = mapped.route(Set.of(subscribedItem));
+        if (routeable) {
+            assertThat(routed).containsExactly(subscribedItem);
+        } else {
+            assertThat(routed).isEmpty();
+        }
+    }
+
+    @ParameterizedTest(name = "[{index}] {arguments}")
+    @CsvFileSource(
+            files = "src/test/resources/should-route-items.csv",
+            useHeadersInDisplayName = true,
+            delimiter = '|')
+    public void shouldRouteWithMixedKeyAndValueTypes(
+            String template, String subscribingItem, boolean canSubscribe, boolean routable)
+            throws ExtractionException {
+        ItemTemplates<GenericRecord, JsonNode> templates =
+                ItemTemplatesUtils.AvroJsonTemplates(TEST_TOPIC_1, template);
+        RecordMapper<GenericRecord, JsonNode> mapper =
+                RecordMapper.<GenericRecord, JsonNode>builder()
+                        .withTemplateExtractors(templates.extractorsByTopicName())
+                        .build();
+
+        KafkaRecord<GenericRecord, JsonNode> incomingRecord =
+                record(TEST_TOPIC_1, GenericRecordProvider.RECORD, JsonNodeProvider.RECORD);
+        MappedRecord mapped = mapper.map(incomingRecord);
+        SubscribedItem subscribedItem = subscribedFrom(subscribingItem, new Object());
+
+        assertThat(templates.matches(subscribedItem)).isEqualTo(canSubscribe);
+        Set<SubscribedItem> routed = mapped.route(Set.of(subscribedItem));
+        if (routable) {
+            assertThat(routed).containsExactly(subscribedItem);
+        } else {
+            assertThat(routed).isEmpty();
+        }
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/SchemaTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/SchemaTest.java
deleted file mode 100644
index 65d3eed1..00000000
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/SchemaTest.java
+++ /dev/null
@@ -1,101 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.common.mapping;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.params.provider.Arguments.arguments;
-
-import com.lightstreamer.kafka.common.mapping.selectors.Schema;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.EmptySource;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.junit.jupiter.params.provider.NullSource;
-import org.junit.jupiter.params.provider.ValueSource;
-
-import java.util.Collections;
-import java.util.Set;
-import java.util.stream.Stream;
-
-public class SchemaTest {
-
-    static Stream<Set<String>> keySets() {
-        return Stream.of(Set.of("key1"), Set.of("key1", "key2"));
-    }
-
-    @ParameterizedTest
-    @MethodSource("keySets")
-    void shouldCreate(Set<String> keys) {
-        Schema schema = Schema.from("schemaName", keys);
-        assertThat(schema).isNotNull();
-        assertThat(schema.name()).isEqualTo("schemaName");
-        assertThat(schema.keys()).isEqualTo(keys);
-    }
-
-    @ParameterizedTest
-    @NullSource
-    @EmptySource
-    @ValueSource(strings = {"  ", "\t", "\n"})
-    void shouldNotCreate(String schemaName) {
-        assertThrows(IllegalArgumentException.class, () -> Schema.from(schemaName, Set.of("key")));
-        assertThrows(IllegalArgumentException.class, () -> Schema.empty(schemaName));
-    }
-
-    @Test
-    void shouldCreateEmptySchema() {
-        Schema schema = Schema.empty("schemaName");
-        assertThat(schema).isNotNull();
-        assertThat(schema.name()).isEqualTo("schemaName");
-        assertThat(schema.keys()).isEmpty();
-    }
-
-    @ParameterizedTest
-    @MethodSource("keySets")
-    void shouldMatchWithSingleKey(Set<String> keys) {
-        Schema schema1 = Schema.from("schemaName", Collections.unmodifiableSet(keys));
-        Schema schema2 = Schema.from("schemaName", Collections.unmodifiableSet(keys));
-        assertThat(schema1.matches(schema2)).isTrue();
-    }
-
-    @ParameterizedTest
-    @MethodSource("keySets")
-    void shouldNotMatchDueToDifferentNames(Set<String> keys) {
-        Schema schema1 = Schema.from("schemaName1", Collections.unmodifiableSet(keys));
-        Schema schema2 = Schema.from("schemaName2", Collections.unmodifiableSet(keys));
-        assertThat(schema1.matches(schema2)).isFalse();
-    }
-
-    static Stream<Arguments> notMatchingKeySets() {
-        return Stream.of(
-                arguments(Set.of("key1"), Set.of("key2")),
-                arguments(Set.of("key1", "key2"), Set.of("key1", "key3")),
-                arguments(Set.of("key1"), Collections.emptySet()));
-    }
-
-    @ParameterizedTest
-    @MethodSource("notMatchingKeySets")
-    void shouldNotMatchDueToDifferentKeys(Set<String> keySet1, Set<String> keySet2) {
-        Schema schema1 = Schema.from("schemaName", keySet1);
-        Schema schema2 = Schema.from("schemaName", keySet2);
-        assertThat(schema1.matches(schema2)).isFalse();
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelectorTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelectorTest.java
index b46f815c..d1a533d0 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelectorTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/ConstantSelectorTest.java
@@ -18,7 +18,7 @@
 package com.lightstreamer.kafka.common.mapping.selectors;
 
 import static com.google.common.truth.Truth.assertThat;
-import static com.lightstreamer.kafka.test_utils.ConsumerRecords.record;
+import static com.lightstreamer.kafka.test_utils.Records.record;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
@@ -45,7 +45,7 @@ static ConstantSelector selector(ExtractionExpression expression) throws Extract
     @ParameterizedTest
     @ValueSource(strings = {"VALUE.a", "KEY.b", "OFFSET.a"})
     void shouldNotCreateSelectorDueToNotAllowedAttributes(String expressionStr) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ExtractionException ee =
                 assertThrows(ExtractionException.class, () -> selector(expression));
         assertThat(ee.getMessage())
@@ -70,7 +70,7 @@ void shouldNotCreateSelectorDueToNotAllowedAttributes(String expressionStr) {
                     """)
     public void shouldExtractValue(String expression, String expectedValue)
             throws ExtractionException {
-        ExtractionExpression ee = Expressions.expression(expression);
+        ExtractionExpression ee = Expressions.Expression(expression);
         Data data = selector(ee).extract(record("record-key", "record-value"));
         assertThat(data.name()).isEqualTo("field_name");
         assertThat(data.text()).isEqualTo(expectedValue);
@@ -94,7 +94,7 @@ public void shouldDumpExpectedConstantString(String expectedString, Constant...
     @ParameterizedTest
     @ValueSource(strings = {"TOPIC", "PARTITION", "OFFSET", "TIMESTAMP"})
     public void shouldNotCreateDueToNotAllowedConstant(String expressionStr) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ExtractionException ee =
                 assertThrows(
                         ExtractionException.class,
@@ -108,22 +108,22 @@ public void shouldNotCreateDueToNotAllowedConstant(String expressionStr) {
 
     @Test
     public void shouldCreateKeySelectorAndExtractData() throws ExtractionException {
-        ExtractionExpression expression = Expressions.expression("KEY");
+        ExtractionExpression expression = Expressions.Expression("KEY");
         ConstantSelectorSupplier cs = new ConstantSelectorSupplier(Constant.KEY);
 
-        KeySelector<Object> newKeySelector = cs.newKeySelector("field_name", expression);
-        Data data = newKeySelector.extractKey(record("record-key", "record-value"));
+        ConstantSelector selector = cs.newSelector("field_name", expression);
+        Data data = selector.extractKey(record("record-key", "record-value"));
         assertThat(data.name()).isEqualTo("field_name");
         assertThat(data.text()).isEqualTo("record-key");
     }
 
     @Test
     public void shouldCreateValueSelectorAndExtractData() throws ExtractionException {
-        ExtractionExpression expression = Expressions.expression("VALUE");
+        ExtractionExpression expression = Expressions.Expression("VALUE");
         ConstantSelectorSupplier cs = new ConstantSelectorSupplier(Constant.VALUE);
 
-        KeySelector<Object> newKeySelector = cs.newKeySelector("field_name", expression);
-        Data data = newKeySelector.extractKey(record("record-key", "record-value"));
+        ConstantSelector selector = cs.newSelector("field_name", expression);
+        Data data = selector.extractValue(record("record-key", "record-value"));
         assertThat(data.name()).isEqualTo("field_name");
         assertThat(data.text()).isEqualTo("record-value");
     }
@@ -131,14 +131,14 @@ public void shouldCreateValueSelectorAndExtractData() throws ExtractionException
     @ParameterizedTest
     @ValueSource(strings = {"TOPIC", "PARTITION", "OFFSET", "TIMESTAMP"})
     public void shouldNotCreateKeySelector(String expressionStr) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ConstantSelectorSupplier cs = new ConstantSelectorSupplier(Constant.KEY);
 
         ExtractionException ee1 =
                 assertThrows(
                         ExtractionException.class,
                         () -> {
-                            cs.newKeySelector("field_name", expression);
+                            cs.newSelector("field_name", expression);
                         });
         assertThat(ee1.getMessage())
                 .isEqualTo("Expected the root token [KEY] while evaluating [field_name]");
@@ -147,16 +147,55 @@ public void shouldNotCreateKeySelector(String expressionStr) {
     @ParameterizedTest
     @ValueSource(strings = {"TOPIC", "PARTITION", "OFFSET", "TIMESTAMP"})
     public void shouldNotCreatValueSelector(String expressionStr) {
-        ExtractionExpression expression = Expressions.expression(expressionStr);
+        ExtractionExpression expression = Expressions.Expression(expressionStr);
         ConstantSelectorSupplier cs = new ConstantSelectorSupplier(Constant.VALUE);
 
         ExtractionException ee =
                 assertThrows(
                         ExtractionException.class,
                         () -> {
-                            cs.newValueSelector("field_name", expression);
+                            cs.newSelector("field_name", expression);
                         });
         assertThat(ee.getMessage())
                 .isEqualTo("Expected the root token [VALUE] while evaluating [field_name]");
     }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"TOPIC", "PARTITION", "OFFSET", "TIMESTAMP"})
+    public void shouldCreateEqualSelectors(String expressionStr) throws ExtractionException {
+        ConstantSelector selector1 = selector(Expressions.Expression(expressionStr));
+        assertThat(selector1.equals(selector1)).isTrue();
+
+        ConstantSelector selector2 = selector(Expressions.Expression(expressionStr));
+        assertThat(selector1.hashCode()).isEqualTo(selector2.hashCode());
+        assertThat(selector1.equals(selector2)).isTrue();
+    }
+
+    @Test
+    public void shouldCreateEqualKeySelectors() throws ExtractionException {
+        KeySelector<Object> keySelector1 =
+                ConstantSelectorSupplier.KeySelector()
+                        .newSelector("field_name", Expressions.Expression("KEY"));
+        assertThat(keySelector1.equals(keySelector1)).isTrue();
+
+        KeySelector<Object> keySelector2 =
+                ConstantSelectorSupplier.KeySelector()
+                        .newSelector("field_name", Expressions.Expression("KEY"));
+        assertThat(keySelector1.hashCode()).isEqualTo(keySelector2.hashCode());
+        assertThat(keySelector1.equals(keySelector2)).isTrue();
+    }
+
+    @Test
+    public void shouldCreateEqualValueSelectors() throws ExtractionException {
+        KeySelector<Object> valueSelector1 =
+                ConstantSelectorSupplier.ValueSelector()
+                        .newSelector("field_name", Expressions.Expression("VALUE"));
+        assertThat(valueSelector1.equals(valueSelector1)).isTrue();
+
+        KeySelector<Object> valueSelector2 =
+                ConstantSelectorSupplier.ValueSelector()
+                        .newSelector("field_name", Expressions.Expression("VALUE"));
+        assertThat(valueSelector1.hashCode()).isEqualTo(valueSelector2.hashCode());
+        assertThat(valueSelector1.equals(valueSelector2)).isTrue();
+    }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataContainerTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataContainerTest.java
deleted file mode 100644
index 8e73b332..00000000
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataContainerTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-
-/*
- * Copyright (C) 2024 Lightstreamer Srl
- *
- * 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 com.lightstreamer.kafka.common.mapping.selectors;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import com.lightstreamer.kafka.common.expressions.Expressions;
-import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.Map;
-import java.util.Set;
-
-public class DataContainerTest {
-
-    @Test
-    public void shouldCreateValue() {
-        Data data = Data.from("name", "value");
-
-        assertThat(data.text()).isEqualTo("value");
-        assertThat(data.name()).isEqualTo("name");
-    }
-
-    @Test
-    public void shouldCreateValuesContainer() throws ExtractionException {
-        DataExtractor<String, String> extractor =
-                DataExtractor.<String, String>builder()
-                        .withSuppliers(TestSelectorSuppliers.string())
-                        .withSchemaName("schema")
-                        .withExpressions(Map.of("name", Expressions.expression("VALUE")))
-                        .build();
-        DataContainer container =
-                DataContainer.from(extractor, Set.of(Data.from("name", "aValue")));
-
-        assertThat(container.extractor()).isSameInstanceAs(extractor);
-        assertThat(container.data()).containsExactly(Data.from("name", "aValue"));
-    }
-}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractorTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractorTest.java
index 34df41ac..4ce30ded 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractorTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataExtractorTest.java
@@ -18,22 +18,26 @@
 package com.lightstreamer.kafka.common.mapping.selectors;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.adapters.mapping.selectors.others.OthersSelectorSuppliers.String;
+import static com.lightstreamer.kafka.common.expressions.Expressions.Expression;
+import static com.lightstreamer.kafka.common.expressions.Expressions.Template;
+import static com.lightstreamer.kafka.common.mapping.selectors.DataExtractor.extractor;
 
+import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
 
-import static java.util.Collections.emptyMap;
-import static java.util.Collections.emptySet;
+import static java.util.Collections.EMPTY_MAP;
 
-import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
-import com.lightstreamer.kafka.common.expressions.Expressions;
 import com.lightstreamer.kafka.common.expressions.Expressions.ExtractionExpression;
-import com.lightstreamer.kafka.test_utils.ConnectorConfigProvider;
-import com.lightstreamer.kafka.test_utils.ConsumerRecords;
+import com.lightstreamer.kafka.common.expressions.Expressions.TemplateExpression;
+import com.lightstreamer.kafka.test_utils.Records;
 import com.lightstreamer.kafka.test_utils.TestSelectorSuppliers;
 
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import java.util.Map;
 import java.util.Set;
@@ -43,81 +47,171 @@ public class DataExtractorTest {
 
     static final String TEST_SCHEMA = "schema";
 
-    static ConnectorConfig avroConfig() {
-        return ConnectorConfigProvider.minimalWith(
-                "src/test/resources",
-                Map.of(
-                        ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc",
-                        ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
-                        "value.avsc"));
-    }
+    @Test
+    public void shouldBuildEqualExtractors() throws ExtractionException {
+        DataExtractor<String, String> extractor1 =
+                extractor(String(), "prefix1", Map.of("aKey", Expression("KEY")));
+        assertThat(extractor1.equals(extractor1)).isTrue();
 
-    static <K, V> DataExtractor<K, V> extractor(
-            Map<String, ExtractionExpression> expressions, SelectorSuppliers<K, V> suppliers)
-            throws ExtractionException {
-        return DataExtractor.<K, V>builder()
-                .withSuppliers(suppliers)
-                .withSchemaName(TEST_SCHEMA)
-                .withExpressions(expressions)
-                .build();
+        DataExtractor<String, String> extractor2 =
+                extractor(String(), "prefix1", Map.of("aKey", Expression("KEY")));
+        assertThat(extractor1.hashCode()).isEqualTo(extractor2.hashCode());
+        assertThat(extractor1.equals(extractor2)).isTrue();
     }
 
-    static Stream<Arguments> stringExtractorArguments() {
+    static Stream<Arguments> extractorFromExtractionExpressions() {
         return Stream.of(
-                arguments(emptyMap(), Schema.empty(TEST_SCHEMA), emptySet()),
+                arguments(TEST_SCHEMA, EMPTY_MAP, Schema.empty(TEST_SCHEMA), EMPTY_MAP),
                 arguments(
-                        Map.of("name", Expressions.expression("VALUE")),
+                        TEST_SCHEMA,
+                        Map.of("name", Expression("VALUE")),
                         Schema.from(TEST_SCHEMA, Set.of("name")),
-                        Set.of(Data.from("name", "aValue"))),
+                        Map.of("name", "aValue")),
                 arguments(
-                        Map.of(
-                                "value",
-                                Expressions.expression("VALUE"),
-                                "key",
-                                Expressions.expression("KEY")),
-                        Schema.from(TEST_SCHEMA, Set.of("value", "key")),
-                        Set.of(Data.from("key", "aKey"), Data.from("value", "aValue"))),
+                        "aSchemNAme",
+                        Map.of("value", Expression("VALUE"), "key", Expression("KEY")),
+                        Schema.from("aSchemNAme", Set.of("value", "key")),
+                        Map.of("key", "aKey", "value", "aValue")),
                 arguments(
-                        Map.of(
-                                "value1",
-                                Expressions.expression("VALUE"),
-                                "key1",
-                                Expressions.expression("KEY")),
-                        Schema.from(TEST_SCHEMA, Set.of("value1", "key1")),
-                        Set.of(Data.from("key1", "aKey"), Data.from("value1", "aValue"))),
+                        "anotherSchemaName",
+                        Map.of("value1", Expression("VALUE"), "key1", Expression("KEY")),
+                        Schema.from("anotherSchemaName", Set.of("value1", "key1")),
+                        Map.of("key1", "aKey", "value1", "aValue")),
                 arguments(
+                        "mySchemaName",
                         Map.of(
                                 "timestamp",
-                                Expressions.expression("TIMESTAMP"),
+                                Expression("TIMESTAMP"),
                                 "partition",
-                                Expressions.expression("PARTITION"),
+                                Expression("PARTITION"),
                                 "topic",
-                                Expressions.expression("TOPIC")),
-                        Schema.from(TEST_SCHEMA, Set.of("timestamp", "partition", "topic")),
-                        Set.of(
-                                Data.from("partition", "150"),
-                                Data.from("topic", "record-topic"),
-                                Data.from("timestamp", "-1"))));
+                                Expression("TOPIC")),
+                        Schema.from("mySchemaName", Set.of("timestamp", "partition", "topic")),
+                        Map.of("partition", "150", "topic", "record-topic", "timestamp", "-1")));
     }
 
     @ParameterizedTest
-    @MethodSource("stringExtractorArguments")
-    public void shouldCreateAndExtractValues(
+    @MethodSource("extractorFromExtractionExpressions")
+    public void shouldCreateAndExtractValuesExtractionExpressions(
+            String schemaName,
             Map<String, ExtractionExpression> expressions,
             Schema expectedSchema,
-            Set<Data> expectedValues)
+            Map<String, String> expectedValues)
+            throws ExtractionException {
+        DataExtractor<String, String> extractor = extractor(String(), schemaName, expressions);
+        Schema schema = extractor.schema();
+        assertThat(schema).isEqualTo(expectedSchema);
+
+        KafkaRecord<String, String> kafkaRecord = Records.record("aKey", "aValue");
+        SchemaAndValues schemaAndValues = extractor.extractData(kafkaRecord);
+        Map<String, String> values = schemaAndValues.values();
+        assertThat(values).isEqualTo(expectedValues);
+    }
+
+    static Stream<Arguments> extractorFromSimpleExpression() {
+        return Stream.of(
+                arguments(
+                        TEST_SCHEMA,
+                        "name",
+                        "VALUE",
+                        Schema.from(TEST_SCHEMA, Set.of("name")),
+                        Map.of("name", "aValue")),
+                arguments(
+                        "aSchemNAme",
+                        "value",
+                        "VALUE",
+                        Schema.from("aSchemNAme", Set.of("value")),
+                        Map.of("value", "aValue")),
+                arguments(
+                        "anotherSchemaName",
+                        "value1",
+                        "VALUE",
+                        Schema.from("anotherSchemaName", Set.of("value1")),
+                        Map.of("value1", "aValue")),
+                arguments(
+                        "mySchemaName",
+                        "partition",
+                        "PARTITION",
+                        Schema.from("mySchemaName", Set.of("partition")),
+                        Map.of("partition", "150")));
+    }
+
+    @ParameterizedTest
+    @MethodSource("extractorFromSimpleExpression")
+    public void shouldCreateAndExtractValuesSimpleExpression(
+            String schemaName,
+            String param,
+            String expression,
+            Schema expectedSchema,
+            Map<String, String> expectedValues)
             throws ExtractionException {
         DataExtractor<String, String> extractor =
-                extractor(expressions, TestSelectorSuppliers.string());
+                extractor(String(), schemaName, param, expression);
+        assertThat(extractor.schema()).isEqualTo(expectedSchema);
 
+        KafkaRecord<String, String> kafkaRecord = Records.record("aKey", "aValue");
+        SchemaAndValues schemaAndValues = extractor.extractData(kafkaRecord);
+        Map<String, String> values = schemaAndValues.values();
+        assertThat(values).isEqualTo(expectedValues);
+    }
+
+    static Stream<Arguments> extractorArgumentsFromTemplateExpressions() {
+        return Stream.of(
+                arguments(
+                        Template("prefix-#{name=VALUE}"),
+                        Schema.from("prefix", Set.of("name")),
+                        Map.of("name", "aValue")),
+                arguments(
+                        Template("aTemplate-#{value=VALUE,key=KEY}"),
+                        Schema.from("aTemplate", Set.of("value", "key")),
+                        Map.of("key", "aKey", "value", "aValue")),
+                arguments(
+                        Template("anotherTemplate-#{value1=VALUE,key1=KEY}"),
+                        Schema.from("anotherTemplate", Set.of("value1", "key1")),
+                        Map.of("key1", "aKey", "value1", "aValue")),
+                arguments(
+                        Template(
+                                "mySchemaName-#{timestamp=TIMESTAMP,partition=PARTITION,topic=TOPIC}"),
+                        Schema.from("mySchemaName", Set.of("timestamp", "partition", "topic")),
+                        Map.of("partition", "150", "topic", "record-topic", "timestamp", "-1")));
+    }
+
+    @ParameterizedTest
+    @MethodSource("extractorArgumentsFromTemplateExpressions")
+    public void shouldCreateAndExtractValuesFromTemplateExpressions(
+            TemplateExpression expression,
+            Schema expectedSchema,
+            Map<String, String> expectedValues)
+            throws ExtractionException {
+        DataExtractor<String, String> extractor = extractor(String(), expression);
         assertThat(extractor.schema()).isEqualTo(expectedSchema);
 
-        KafkaRecord<String, String> kafkaRecord = ConsumerRecords.record("aKey", "aValue");
-        DataContainer values = extractor.extractData(kafkaRecord);
+        KafkaRecord<String, String> kafkaRecord = Records.record("aKey", "aValue");
+        SchemaAndValues schemaAndValues = extractor.extractData(kafkaRecord);
+        Map<String, String> values = schemaAndValues.values();
+        assertThat(values).isEqualTo(expectedValues);
+    }
+
+    @Test
+    public void shouldCreateAndExtractValuesFromNoExpressions() throws ExtractionException {
+        DataExtractor<String, String> extractor = extractor(String(), TEST_SCHEMA);
+        assertThat(extractor.schema()).isEqualTo(Schema.empty(TEST_SCHEMA));
+
+        KafkaRecord<String, String> kafkaRecord = Records.record("aKey", "aValue");
+        SchemaAndValues schemaAndValues = extractor.extractData(kafkaRecord);
+        Map<String, String> values = schemaAndValues.values();
+        assertThat(values).isEmpty();
+    }
 
-        assertThat(values.extractor()).isSameInstanceAs(extractor);
-        Set<Data> values2 = values.data();
-        assertThat(values2).isEqualTo(expectedValues);
+    @ParameterizedTest
+    @ValueSource(strings = {"VALUE"})
+    public void shouldNotCreate(String expression) throws ExtractionException {
+        assertThrows(
+                ExtractionException.class,
+                () ->
+                        extractor(
+                                TestSelectorSuppliers.JsonValue(),
+                                TEST_SCHEMA,
+                                Map.of("value", Expression(expression))));
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataContainer.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataTest.java
similarity index 64%
rename from kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataContainer.java
rename to kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataTest.java
index eb4e97af..c3bc33e0 100644
--- a/kafka-connector-project/kafka-connector/src/main/java/com/lightstreamer/kafka/common/mapping/selectors/DataContainer.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/DataTest.java
@@ -17,18 +17,16 @@
 
 package com.lightstreamer.kafka.common.mapping.selectors;
 
-import java.util.Set;
+import static com.google.common.truth.Truth.assertThat;
 
-public interface DataContainer {
+import org.junit.jupiter.api.Test;
 
-    DataExtractor<?, ?> extractor();
+public class DataTest {
 
-    Set<Data> data();
-
-    static DataContainer from(DataExtractor<?, ?> extractor, Set<Data> data) {
-        return new DefaultValuesContainer(extractor, data);
+    @Test
+    public void shouldCreateValue() {
+        Data data = Data.from("name", "value");
+        assertThat(data.text()).isEqualTo("value");
+        assertThat(data.name()).isEqualTo("name");
     }
 }
-
-record DefaultValuesContainer(DataExtractor<?, ?> extractor, Set<Data> data)
-        implements DataContainer {}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/ParsersTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/ParsersTest.java
index 470b1b02..026d0266 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/ParsersTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/ParsersTest.java
@@ -38,8 +38,8 @@ public class ParsersTest {
 
     static Stream<Arguments> args() {
         return Stream.of(
-                arguments("name", Expressions.expression("VALUE"), Constant.VALUE),
-                arguments("name", Expressions.expression("KEY.attrib"), Constant.KEY));
+                arguments("name", Expressions.Expression("VALUE"), Constant.VALUE),
+                arguments("name", Expressions.Expression("KEY.attrib"), Constant.KEY));
     }
 
     @ParameterizedTest
@@ -62,7 +62,7 @@ void shouldCreateParsingContext(
     @Test
     void shouldMatchRoot() throws ExtractionException {
         Parsers.ParsingContext p =
-                new Parsers.ParsingContext("name", Expressions.expression("VALUE"), Constant.VALUE);
+                new Parsers.ParsingContext("name", Expressions.Expression("VALUE"), Constant.VALUE);
         assertDoesNotThrow(() -> p.matchRoot());
     }
 
@@ -70,7 +70,7 @@ void shouldMatchRoot() throws ExtractionException {
     void shouldNotMatchRoot() {
         Parsers.ParsingContext p =
                 new Parsers.ParsingContext(
-                        "name", Expressions.expression("KEY.attrib"), Constant.VALUE);
+                        "name", Expressions.Expression("KEY.attrib"), Constant.VALUE);
         ExtractionException ee = assertThrows(ExtractionException.class, () -> p.matchRoot());
         assertThat(ee.getMessage())
                 .isEqualTo("Expected the root token [VALUE] while evaluating [name]");
@@ -80,7 +80,7 @@ void shouldNotMatchRoot() {
     void shouldOneTokenFollowingRoot() throws ExtractionException {
         Parsers.ParsingContext p =
                 new Parsers.ParsingContext(
-                        "name", Expressions.expression("VALUE.a"), Constant.VALUE);
+                        "name", Expressions.Expression("VALUE.a"), Constant.VALUE);
         p.matchRoot();
         assertThat(p.hasNext()).isTrue();
         assertThat(p.next()).isEqualTo("a");
@@ -91,7 +91,7 @@ void shouldOneTokenFollowingRoot() throws ExtractionException {
     void shouldMoreTokensFollowingRoot() throws ExtractionException {
         Parsers.ParsingContext p =
                 new Parsers.ParsingContext(
-                        "name", Expressions.expression("VALUE.a.b"), Constant.VALUE);
+                        "name", Expressions.Expression("VALUE.a.b"), Constant.VALUE);
         p.matchRoot();
         assertThat(p.hasNext()).isTrue();
         assertThat(p.next()).isEqualTo("a");
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaAndValuesTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaAndValuesTest.java
new file mode 100644
index 00000000..33a4f55c
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaAndValuesTest.java
@@ -0,0 +1,123 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.common.mapping.selectors;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class SchemaAndValuesTest {
+
+    @Test
+    public void shouldCreateSchemaAndValues() {
+        Schema schema = Schema.from("schema", Set.of("key", "value"));
+        SchemaAndValues schemaAndValues =
+                SchemaAndValues.from(schema, Map.of("key", "aKey", "value", "aValue"));
+        assertThat(schemaAndValues.schema()).isSameInstanceAs(schema);
+        assertThat(schemaAndValues.values()).containsExactly("key", "aKey", "value", "aValue");
+    }
+
+    @Test
+    public void shouldCreateSchemaAndValuesFromNameAndValues() {
+        SchemaAndValues schemaAndValues =
+                SchemaAndValues.from("schema", Map.of("key", "aKey", "value", "aValue"));
+        assertThat(schemaAndValues.schema().name()).isEqualTo("schema");
+        assertThat(schemaAndValues.schema().keys()).containsExactly("key", "value");
+        assertThat(schemaAndValues.values()).containsExactly("key", "aKey", "value", "aValue");
+    }
+
+    @Test
+    public void shouldMatchWhenSameSchemaAndValues() {
+        Schema schema1 = Schema.from("schema1", Set.of("field1", "field2"));
+        Schema schema2 = Schema.from("schema2", Set.of("field1", "field2"));
+        Map<String, String> values = new HashMap<>(Map.of("field1", "value1", "field2", "value2"));
+
+        SchemaAndValues sAndValues1 = SchemaAndValues.from(schema1, values);
+        SchemaAndValues sAndValues2 = SchemaAndValues.from(schema2, values);
+        SchemaAndValues sAndValues3 = SchemaAndValues.from(schema1, Collections.emptyMap());
+
+        assertThat(sAndValues1.matches(sAndValues2)).isFalse();
+        assertThat(sAndValues1.matches(sAndValues3)).isFalse();
+    }
+
+    @Test
+    public void shouldNotMatchDueToDifferentNames() {
+        Schema schema = Schema.from("schema", Set.of("key", "value"));
+        SchemaAndValues schemaAndValues =
+                SchemaAndValues.from(schema, Map.of("key", "aKey", "value", "aValue"));
+        Schema otherSchema = Schema.from("anotherSchema", Set.of("key", "value"));
+        SchemaAndValues otherSchemaAndValues =
+                SchemaAndValues.from(otherSchema, Map.of("key", "aKey", "value", "aValue"));
+        assertThat(schemaAndValues.matches(otherSchemaAndValues)).isFalse();
+        assertThat(schemaAndValues.equals(otherSchemaAndValues)).isFalse();
+    }
+
+    @Test
+    void shouldNotMatchDueToDifferentValues() {
+        Schema schema = Schema.from("schema", Set.of("key", "value"));
+        SchemaAndValues schemaAndValues =
+                SchemaAndValues.from(schema, Map.of("key", "aKey", "value", "aValue"));
+        Schema otherSchema = schema;
+        SchemaAndValues anotherSchemaAndValues =
+                SchemaAndValues.from(
+                        otherSchema, Map.of("key", "anoterKey", "value", "aNotherValue"));
+        assertThat(schemaAndValues.matches(anotherSchemaAndValues)).isFalse();
+        assertThat(schemaAndValues.equals(anotherSchemaAndValues)).isFalse();
+    }
+
+    @Test
+    void shouldCreateNopSchemaAndValues() {
+        SchemaAndValues nop = SchemaAndValues.nop();
+
+        assertThat(nop.values()).isEmpty();
+        assertThat(nop.schema().keys()).isEmpty();
+    }
+
+    @Test
+    void shouldMatchItselfAsNop() {
+        SchemaAndValues nop = SchemaAndValues.nop();
+        assertThat(nop.matches(nop)).isTrue();
+    }
+
+    @Test
+    void shouldGenerateCorrectToString() {
+        Schema schema = Schema.from("schema", Set.of("field1", "field2"));
+        Map<String, String> values = new LinkedHashMap<>(); // Use LinkedHashMap for order
+        values.put("field1", "value1");
+        values.put("field2", "value2");
+        SchemaAndValues schemaAndValues = SchemaAndValues.from(schema, values);
+
+        assertThat(schemaAndValues.toString())
+                .isEqualTo("(schema-<{field1=value1, field2=value2}>)");
+    }
+
+    @Test
+    void shouldGenerateCorrectToStringWithEmptyValues() {
+        Schema schema = Schema.from("schema", Set.of("field1", "field2"));
+        Map<String, String> values = Collections.emptyMap();
+        SchemaAndValues schemaAndValues = SchemaAndValues.from(schema, values);
+
+        assertThat(schemaAndValues.toString()).isEqualTo("(schema-<{}>)");
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaTest.java
new file mode 100644
index 00000000..6c27dd1e
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/common/mapping/selectors/SchemaTest.java
@@ -0,0 +1,100 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.common.mapping.selectors;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.junit.Assert.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+
+public class SchemaTest {
+
+    @Test
+    public void shouldCreateSchema() {
+        Schema schema = Schema.from("test", Set.of("a", "b"));
+
+        assertThat(schema.name()).isEqualTo("test");
+        assertThat(schema.keys()).containsExactly("a", "b");
+    }
+
+    @Test
+    public void shouldCreateEmptySchema() {
+        Schema schema = Schema.empty("test");
+
+        assertThat(schema.name()).isEqualTo("test");
+        assertThat(schema.keys()).isEmpty();
+    }
+
+    @Test
+    public void shouldCreateNopSchema() {
+        Schema schema = Schema.nop();
+
+        assertThat(schema.name()).isEqualTo("NOSCHEMA");
+        assertThat(schema.keys()).isEmpty();
+    }
+
+    @Test
+    public void shouldMatch() {
+        Schema schema1 = Schema.from("test", Set.of("a", "b"));
+        Schema schema2 = Schema.from("test", Set.of("a", "b"));
+
+        assertThat(schema1.matches(schema2)).isTrue();
+        assertThat(schema1.hashCode()).isEqualTo(schema2.hashCode());
+    }
+
+    @Test
+    public void shouldNotMatchDifferentName() {
+        Schema schema1 = Schema.from("test1", Set.of("a", "b"));
+        Schema schema2 = Schema.from("test2", Set.of("a", "b"));
+
+        assertThat(schema1.matches(schema2)).isFalse();
+    }
+
+    @Test
+    public void shouldNotMatchDifferentKeys() {
+        Schema schema1 = Schema.from("test", Set.of("a", "b"));
+        Schema schema2 = Schema.from("test", Set.of("a", "c"));
+
+        assertThat(schema1.matches(schema2)).isFalse();
+    }
+
+    @Test
+    public void shouldThrowOnNullName() {
+        IllegalArgumentException exception =
+                assertThrows(
+                        IllegalArgumentException.class,
+                        () -> {
+                            Schema.from(null, Set.of("a", "b"));
+                        });
+        assertThat(exception.getMessage()).isEqualTo("Schema name must be a non empty string");
+    }
+
+    @Test
+    public void shouldThrowOnBlankName() {
+        IllegalArgumentException exception =
+                assertThrows(
+                        IllegalArgumentException.class,
+                        () -> {
+                            Schema.from("  ", Set.of("a", "b"));
+                        });
+        assertThat(exception.getMessage()).isEqualTo("Schema name must be a non empty string");
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/StreamingDataAdapterTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/StreamingDataAdapterTest.java
index 25801803..4d50ea43 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/StreamingDataAdapterTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/StreamingDataAdapterTest.java
@@ -18,6 +18,7 @@
 package com.lightstreamer.kafka.connect;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.lightstreamer.kafka.connect.config.LightstreamerConnectorConfig.RECORD_EXTRACTION_ERROR_STRATEGY;
 
 import static org.junit.Assert.assertThrows;
 
@@ -255,9 +256,7 @@ public void shouldIgnoreAndContinue() throws SubscriptionException, FailureExcep
         Map<String, String> otherSettings = new HashMap<>();
 
         // Configure the IGNORE_AND_CONTINUE error strategy.
-        otherSettings.put(
-                LightstreamerConnectorConfig.RECORD_EXTRACTION_ERROR_STRATEGY,
-                "IGNORE_AND_CONTINUE");
+        otherSettings.put(RECORD_EXTRACTION_ERROR_STRATEGY, "IGNORE_AND_CONTINUE");
         // This entry will trigger a ValueException for records that are missing the 'attrib' field.
         otherSettings.put(LightstreamerConnectorConfig.RECORD_MAPPING, "field1:#{VALUE.attrib}");
 
@@ -295,8 +294,7 @@ public void shouldForwardToDLQ() throws SubscriptionException, FailureException
         Map<String, String> otherSettings = new HashMap<>();
 
         // Configure the FORWARD_TO_DLQ error strategy.
-        otherSettings.put(
-                LightstreamerConnectorConfig.RECORD_EXTRACTION_ERROR_STRATEGY, "FORWARD_TO_DLQ");
+        otherSettings.put(RECORD_EXTRACTION_ERROR_STRATEGY, "FORWARD_TO_DLQ");
         // This entry will trigger a ValueException for records that are missing the 'attrib' field.
         otherSettings.put(LightstreamerConnectorConfig.RECORD_MAPPING, "field1:#{VALUE.attrib}");
 
@@ -336,8 +334,7 @@ public void shouldTerminateTaskDueToMissingReporter()
         Map<String, String> otherSettings = new HashMap<>();
 
         // Configure the FORWARD_TO_DLQ error strategy.
-        otherSettings.put(
-                LightstreamerConnectorConfig.RECORD_EXTRACTION_ERROR_STRATEGY, "FORWARD_TO_DLQ");
+        otherSettings.put(RECORD_EXTRACTION_ERROR_STRATEGY, "FORWARD_TO_DLQ");
         // This entry will trigger a ValueException for records that are missing the 'attrib' field.
         otherSettings.put(LightstreamerConnectorConfig.RECORD_MAPPING, "field1:#{VALUE.attrib}");
 
@@ -370,8 +367,7 @@ public void shouldTerminateTask() throws SubscriptionException, FailureException
         Map<String, String> otherSettings = new HashMap<>();
 
         // Configure the TERMINATE_TASK error strategy.
-        otherSettings.put(
-                LightstreamerConnectorConfig.RECORD_EXTRACTION_ERROR_STRATEGY, "TERMINATE_TASK");
+        otherSettings.put(RECORD_EXTRACTION_ERROR_STRATEGY, "TERMINATE_TASK");
         // This entry will trigger a ValueException for records that are missing the 'attrib' field.
         otherSettings.put(LightstreamerConnectorConfig.RECORD_MAPPING, "field1:#{VALUE.attrib}");
 
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/config/LightstreamerConnectorConfigTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/config/LightstreamerConnectorConfigTest.java
index 65caa354..96e98529 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/config/LightstreamerConnectorConfigTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/config/LightstreamerConnectorConfigTest.java
@@ -236,16 +236,16 @@ void shouldGetMoreItemTemplates() {
         TemplateExpression stockExpression = itemTemplate.getExpression("stock-template");
         assertThat(stockExpression.prefix()).isEqualTo("stock");
         assertThat(stockExpression.params())
-                .containsExactly("index", Expressions.expression("KEY"));
+                .containsExactly("index", Expressions.Expression("KEY"));
 
         TemplateExpression productExpression = itemTemplate.getExpression("product-template");
         assertThat(productExpression.prefix()).isEqualTo("product");
         assertThat(productExpression.params())
                 .containsExactly(
                         "id",
-                        Expressions.expression("KEY"),
+                        Expressions.Expression("KEY"),
                         "price",
-                        Expressions.expression("VALUE.price"));
+                        Expressions.Expression("VALUE.price"));
     }
 
     @Test
@@ -307,41 +307,41 @@ void shouldGetFieldMappings() {
         assertThat(fieldMappings.expressions())
                 .containsExactly(
                         "timestamp",
-                        Expressions.expression("VALUE.timestamp"),
+                        Expressions.Expression("VALUE.timestamp"),
                         "time",
-                        Expressions.expression("VALUE.time"),
+                        Expressions.Expression("VALUE.time"),
                         "stock_name",
-                        Expressions.expression("VALUE.name"),
+                        Expressions.Expression("VALUE.name"),
                         "last_price",
-                        Expressions.expression("VALUE.last_price"),
+                        Expressions.Expression("VALUE.last_price"),
                         "ask",
-                        Expressions.expression("VALUE.ask"),
+                        Expressions.Expression("VALUE.ask"),
                         "ask_quantity",
-                        Expressions.expression("VALUE.ask_quantity"),
+                        Expressions.Expression("VALUE.ask_quantity"),
                         "bid",
-                        Expressions.expression("VALUE.bid"),
+                        Expressions.Expression("VALUE.bid"),
                         "bid_quantity",
-                        Expressions.expression("VALUE.bid_quantity"),
+                        Expressions.Expression("VALUE.bid_quantity"),
                         "pct_change",
-                        Expressions.expression("VALUE.pct_change"),
+                        Expressions.Expression("VALUE.pct_change"),
                         "min",
-                        Expressions.expression("VALUE.min"),
+                        Expressions.Expression("VALUE.min"),
                         "max",
-                        Expressions.expression("VALUE.max"),
+                        Expressions.Expression("VALUE.max"),
                         "ref_price",
-                        Expressions.expression("VALUE.ref_price"),
+                        Expressions.Expression("VALUE.ref_price"),
                         "open_price",
-                        Expressions.expression("VALUE.open_price"),
+                        Expressions.Expression("VALUE.open_price"),
                         "item_status",
-                        Expressions.expression("VALUE.item_status"),
+                        Expressions.Expression("VALUE.item_status"),
                         "ts",
-                        Expressions.expression("TIMESTAMP"),
+                        Expressions.Expression("TIMESTAMP"),
                         "topic",
-                        Expressions.expression("TOPIC"),
+                        Expressions.Expression("TOPIC"),
                         "offset",
-                        Expressions.expression("OFFSET"),
+                        Expressions.Expression("OFFSET"),
                         "partition",
-                        Expressions.expression("PARTITION"));
+                        Expressions.Expression("PARTITION"));
     }
 
     @ParameterizedTest
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectSelectorsSuppliersTest.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectSelectorsSuppliersTest.java
index fd3f2639..33df8194 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectSelectorsSuppliersTest.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/connect/mapping/selectors/ConnectSelectorsSuppliersTest.java
@@ -18,8 +18,8 @@
 package com.lightstreamer.kafka.connect.mapping.selectors;
 
 import static com.google.common.truth.Truth.assertThat;
-import static com.lightstreamer.kafka.test_utils.ConsumerRecords.sinkFromKey;
-import static com.lightstreamer.kafka.test_utils.ConsumerRecords.sinkFromValue;
+import static com.lightstreamer.kafka.test_utils.Records.sinkFromKey;
+import static com.lightstreamer.kafka.test_utils.Records.sinkFromValue;
 import static com.lightstreamer.kafka.test_utils.SchemaAndValueProvider.STRUCT;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -29,12 +29,15 @@
 import com.lightstreamer.kafka.common.expressions.Expressions;
 import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
 import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
+import com.lightstreamer.kafka.common.mapping.selectors.KeySelector;
 import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueSelector;
 
 import org.apache.kafka.connect.data.Schema;
 import org.apache.kafka.connect.data.SchemaBuilder;
 import org.apache.kafka.connect.data.Struct;
 import org.apache.kafka.connect.sink.SinkRecord;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
@@ -80,14 +83,23 @@ public class ConnectSelectorsSuppliersTest {
                     .field("mapOfMap", OPTIONAL_MAP_OF_MAP_SCHEMA)
                     .build();
 
-    static ConnectValueSelector valueSelector(String expression) throws ExtractionException {
-        return ConnectSelectorsSuppliers.valueSelectorSupplier()
-                .newSelector("name", Expressions.expression(expression));
+    private ConnectSelectorsSuppliers connectSelectorsSuppliers;
+
+    ValueSelector<Object> valueSelector(String expression) throws ExtractionException {
+        return connectSelectorsSuppliers
+                .valueSelectorSupplier()
+                .newSelector("name", Expressions.Expression(expression));
+    }
+
+    KeySelector<Object> keySelector(String expression) throws ExtractionException {
+        return connectSelectorsSuppliers
+                .keySelectorSupplier()
+                .newSelector("name", Expressions.Expression(expression));
     }
 
-    static ConnectKeySelector keySelector(String expression) throws ExtractionException {
-        return ConnectSelectorsSuppliers.keySelectorSupplier()
-                .newSelector("name", Expressions.expression(expression));
+    @BeforeEach
+    public void beforeEach() {
+        connectSelectorsSuppliers = new ConnectSelectorsSuppliers();
     }
 
     @ParameterizedTest(name = "[{index}] {arguments}")
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/GenericRecordProvider.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/GenericRecordProvider.java
index 4c9e4874..f6564769 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/GenericRecordProvider.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/GenericRecordProvider.java
@@ -17,8 +17,6 @@
 
 package com.lightstreamer.kafka.test_utils;
 
-import com.lightstreamer.kafka.adapters.mapping.selectors.avro.GenericRecordSelectorTest;
-
 import org.apache.avro.Schema;
 import org.apache.avro.generic.GenericData;
 import org.apache.avro.generic.GenericRecord;
@@ -32,24 +30,21 @@
 public class GenericRecordProvider {
 
     private final Schema valueSchema;
-
     private final Schema childrenSchema;
 
     private GenericRecordProvider() {
-        ClassLoader classLoader = GenericRecordSelectorTest.class.getClassLoader();
+        ClassLoader classLoader = GenericRecordProvider.class.getClassLoader();
         Schema.Parser parser = new Schema.Parser();
 
         try {
             valueSchema = parser.parse(classLoader.getResourceAsStream("value.avsc"));
             childrenSchema = valueSchema.getField("children").schema();
-
         } catch (IOException io) {
             throw new RuntimeException(io);
         }
     }
 
     private static GenericRecordProvider PROVIDER = new GenericRecordProvider();
-
     public static GenericRecord RECORD = PROVIDER.newGenericRecord();
 
     private GenericRecord newGenericRecord() {
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/ItemTemplatesUtils.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/ItemTemplatesUtils.java
new file mode 100644
index 00000000..a12368ce
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/ItemTemplatesUtils.java
@@ -0,0 +1,105 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.test_utils;
+
+import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.Avro;
+import static com.lightstreamer.kafka.test_utils.TestSelectorSuppliers.AvroKeyJsonValue;
+
+import static java.util.stream.Collectors.joining;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.lightstreamer.kafka.common.config.TopicConfigurations;
+import com.lightstreamer.kafka.common.config.TopicConfigurations.ItemTemplateConfigs;
+import com.lightstreamer.kafka.common.config.TopicConfigurations.TopicMappingConfig;
+import com.lightstreamer.kafka.common.mapping.Items;
+import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
+import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
+
+import org.apache.avro.generic.GenericRecord;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ItemTemplatesUtils {
+
+    public static <K, V> ItemTemplates<K, V> ItemTemplates(
+            KeyValueSelectorSuppliers<K, V> sSuppliers, List<String> topics, List<String> templates)
+            throws ExtractionException {
+
+        List<TopicMappingConfig> topicMappings = new ArrayList<>();
+        Map<String, String> templatesMap = new HashMap<>();
+        for (int i = 0; i < templates.size(); i++) {
+            // Add a new item template with name "template-<i>"
+            templatesMap.put("template-" + i, templates.get(i));
+        }
+
+        for (String topic : topics) {
+            // Add a new TopicMapping referencing the template
+            topicMappings.add(
+                    TopicMappingConfig.fromDelimitedMappings(
+                            topic, getFullTemplateNames(templatesMap.keySet())));
+        }
+
+        return mkItemTemplates(sSuppliers, topicMappings, ItemTemplateConfigs.from(templatesMap));
+    }
+
+    /** Map the specified topic to the specified item names */
+    public static <K, V> ItemTemplates<K, V> mkSimpleItems(
+            KeyValueSelectorSuppliers<K, V> sSuppliers, List<String> topics, List<String> items)
+            throws ExtractionException {
+        List<TopicMappingConfig> topicMappings = new ArrayList<>();
+        String delimitedItems = String.join(",", items);
+        for (String topic : topics) {
+            // Add a new TopicMapping referencing the item name
+            topicMappings.add(TopicMappingConfig.fromDelimitedMappings(topic, delimitedItems));
+        }
+
+        // No template configuration required in this case
+        return mkItemTemplates(sSuppliers, topicMappings, ItemTemplateConfigs.empty());
+    }
+
+    public static ItemTemplates<GenericRecord, GenericRecord> AvroAvroTemplates(
+            String topic, String template) throws ExtractionException {
+        return ItemTemplates(Avro(), List.of(topic), List.of(template));
+    }
+
+    public static ItemTemplates<GenericRecord, JsonNode> AvroJsonTemplates(
+            String topic, String template) throws ExtractionException {
+        return ItemTemplates(AvroKeyJsonValue(), List.of(topic), List.of(template));
+    }
+
+    /*
+     * Prefix each input element with "item-template." and concatenate all of them, separated by a comma character
+     */
+    static String getFullTemplateNames(Collection<String> template) {
+        return template.stream().map(t -> "item-template." + t).collect(joining(","));
+    }
+
+    private static <K, V> ItemTemplates<K, V> mkItemTemplates(
+            KeyValueSelectorSuppliers<K, V> sSuppliers,
+            List<TopicMappingConfig> topicMappings,
+            ItemTemplateConfigs templateConfigs)
+            throws ExtractionException {
+        TopicConfigurations topicsConfig = TopicConfigurations.of(templateConfigs, topicMappings);
+        return Items.templatesFrom(topicsConfig, sSuppliers);
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/JsonNodeProvider.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/JsonNodeProvider.java
index 2dfb0b56..c1df10c8 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/JsonNodeProvider.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/JsonNodeProvider.java
@@ -42,10 +42,20 @@ private ObjectNode newNode() {
 
         Value value = new Value("joe", joeChildren);
         value.signature = new byte[] {97, 98, 99, 100};
+        value.family =
+                new Value[][] {
+                    {new Value("bro00"), new Value("bro01")},
+                    {new Value("bro10"), new Value("bro11")}
+                };
 
         ObjectNode node = new ObjectMapper().valueToTree(value);
         return node;
     }
+
+    public static void main(String[] args) {
+        // System.out.println(new JsonNodeProvider().newNode());
+
+    }
 }
 
 class Value {
@@ -73,4 +83,41 @@ public Value(String name, Value[][] family) {
         this(name);
         this.family = family;
     }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("{");
+        sb.append("\"name\":\"").append(this.name).append("\",");
+        if (this.children != null) {
+            sb.append("\"children\":");
+            sb.append("[");
+            for (int i = 0; i < this.children.size(); i++) {
+                sb.append(this.children.get(i));
+                if (i < this.children.size() - 1) {
+                    sb.append(",");
+                }
+            }
+            sb.append("]");
+        }
+        if (this.family != null) {
+            sb.append("\"family\":");
+            sb.append("[");
+            for (int i = 0; i < this.family.length; i++) {
+                sb.append("[");
+                for (int j = 0; j < this.family[i].length; j++) {
+                    sb.append(this.family[i][j]);
+                    if (j < this.family[i].length - 1) {
+                        sb.append(",");
+                    }
+                }
+                sb.append("]");
+                if (i < this.family.length - 1) {
+                    sb.append(",");
+                }
+            }
+            sb.append("]");
+        }
+        sb.append("}");
+        return sb.toString();
+    }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/Mocks.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/Mocks.java
new file mode 100644
index 00000000..547eac71
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/Mocks.java
@@ -0,0 +1,426 @@
+
+/*
+ * Copyright (C) 2024 Lightstreamer Srl
+ *
+ * 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 com.lightstreamer.kafka.test_utils;
+
+import static com.lightstreamer.kafka.adapters.mapping.selectors.others.OthersSelectorSuppliers.String;
+
+import com.lightstreamer.interfaces.data.DiffAlgorithm;
+import com.lightstreamer.interfaces.data.IndexedItemEvent;
+import com.lightstreamer.interfaces.data.ItemEvent;
+import com.lightstreamer.interfaces.data.ItemEventListener;
+import com.lightstreamer.interfaces.data.OldItemEvent;
+import com.lightstreamer.kafka.adapters.commons.MetadataListener;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordConsumeWithOrderStrategy;
+import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.RecordErrorHandlingStrategy;
+import com.lightstreamer.kafka.adapters.consumers.ConsumerTrigger.ConsumerTriggerConfig;
+import com.lightstreamer.kafka.adapters.consumers.offsets.Offsets.OffsetService;
+import com.lightstreamer.kafka.adapters.consumers.offsets.Offsets.OffsetStore;
+import com.lightstreamer.kafka.adapters.consumers.processor.RecordConsumer.RecordProcessor;
+import com.lightstreamer.kafka.adapters.consumers.wrapper.ConsumerWrapper;
+import com.lightstreamer.kafka.adapters.consumers.wrapper.ConsumerWrapper.AdminInterface;
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers.KeyValueDeserializers;
+import com.lightstreamer.kafka.common.config.FieldConfigs;
+import com.lightstreamer.kafka.common.config.TopicConfigurations;
+import com.lightstreamer.kafka.common.mapping.Items;
+import com.lightstreamer.kafka.common.mapping.Items.ItemTemplates;
+import com.lightstreamer.kafka.common.mapping.selectors.DataExtractor;
+import com.lightstreamer.kafka.common.mapping.selectors.ExtractionException;
+import com.lightstreamer.kafka.common.mapping.selectors.ValueException;
+import com.lightstreamer.kafka.test_utils.Mocks.MockOffsetService.ConsumedRecordInfo;
+
+import org.apache.kafka.clients.admin.ListTopicsOptions;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.TopicPartition;
+import org.slf4j.Logger;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Properties;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public class Mocks {
+
+    public static class MockTriggerConfig implements ConsumerTriggerConfig<String, String> {
+
+        private final TopicConfigurations topicsConfig;
+        private Properties consumerProperties;
+
+        public MockTriggerConfig(TopicConfigurations topicsConfig) {
+            this(topicsConfig, new Properties());
+        }
+
+        public MockTriggerConfig(TopicConfigurations topicsConfig, Properties properties) {
+            this.topicsConfig = topicsConfig;
+            this.consumerProperties = properties;
+        }
+
+        @Override
+        public Properties consumerProperties() {
+            return this.consumerProperties;
+        }
+
+        @Override
+        public DataExtractor<String, String> fieldsExtractor() {
+            try {
+                return FieldConfigs.from(Map.of("field", "#{VALUE}")).extractor(String());
+            } catch (ExtractionException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        @Override
+        public ItemTemplates<String, String> itemTemplates() {
+            try {
+                return Items.templatesFrom(topicsConfig, String());
+            } catch (ExtractionException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        @Override
+        public String connectionName() {
+            return "TestConnection";
+        }
+
+        @Override
+        public KeyValueDeserializers<String, String> deserializers() {
+            return null;
+        }
+
+        @Override
+        public Concurrency concurrency() {
+            return new Concurrency() {
+
+                @Override
+                public RecordConsumeWithOrderStrategy orderStrategy() {
+                    return RecordConsumeWithOrderStrategy.ORDER_BY_PARTITION;
+                }
+
+                @Override
+                public int threads() {
+                    return 2;
+                }
+            };
+        }
+
+        @Override
+        public RecordErrorHandlingStrategy errorHandlingStrategy() {
+            return RecordErrorHandlingStrategy.IGNORE_AND_CONTINUE;
+        }
+    }
+
+    public static class MockConsumerWrapper<K, V> implements ConsumerWrapper<K, V> {
+
+        private volatile boolean ran = false;
+        private volatile boolean closed = false;
+
+        public MockConsumerWrapper() {}
+
+        @Override
+        public void run() {
+            ran = true;
+        }
+
+        @Override
+        public void close() {
+            closed = true;
+        }
+
+        public boolean hasRan() {
+            return ran;
+        }
+
+        public boolean isClosed() {
+            return closed;
+        }
+
+        @Override
+        public void consumeRecords(ConsumerRecords<K, V> records) {
+            throw new UnsupportedOperationException("Unimplemented method 'consumeRecords'");
+        }
+    }
+
+    public static class MockAdminInterface implements AdminInterface {
+
+        private final String topic;
+        private final boolean throwException;
+
+        public MockAdminInterface(String topic, boolean throwException) {
+            this.topic = topic;
+            this.throwException = throwException;
+        }
+
+        public MockAdminInterface(String topic) {
+            this(topic, false);
+        }
+
+        @Override
+        public void close() throws Exception {}
+
+        @Override
+        public Set<String> listTopics(ListTopicsOptions options) throws Exception {
+            if (throwException) {
+                throw new RuntimeException("Fake Exception");
+            }
+            return Collections.singleton(topic);
+        }
+    }
+
+    public static class MockMetadataListener implements MetadataListener {
+
+        private volatile boolean forcedUnsubscription = false;
+
+        @Override
+        public void forceUnsubscription(String item) {}
+
+        @Override
+        public void forceUnsubscriptionAll() {
+            forcedUnsubscription = true;
+        }
+
+        public boolean forcedUnsubscription() {
+            return forcedUnsubscription;
+        }
+    }
+
+    public static class MockOffsetService implements OffsetService {
+
+        public static record ConsumedRecordInfo(String topic, int partition, Long offset) {
+            static ConsumedRecordInfo from(ConsumerRecord<?, ?> record) {
+                return new ConsumedRecordInfo(record.topic(), record.partition(), record.offset());
+            }
+        }
+
+        private List<ConsumedRecordInfo> records = Collections.synchronizedList(new ArrayList<>());
+        private volatile Throwable firstFailure;
+
+        @Override
+        public void onPartitionsRevoked(Collection<TopicPartition> partitions) {}
+
+        @Override
+        public void onPartitionsAssigned(Collection<TopicPartition> partitions) {}
+
+        @Override
+        public void commitSync() {}
+
+        @Override
+        public void commitSyncAndIgnoreErrors() {}
+
+        @Override
+        public void commitAsync() {}
+
+        @Override
+        public void updateOffsets(ConsumerRecord<?, ?> record) {
+            records.add(
+                    new ConsumedRecordInfo(record.topic(), record.partition(), record.offset()));
+        }
+
+        @Override
+        public void onAsyncFailure(Throwable th) {
+            if (firstFailure == null) {
+                firstFailure = th; // any of the first exceptions got should be enough
+            }
+        }
+
+        @Override
+        public Throwable getFirstFailure() {
+            return firstFailure;
+        }
+
+        @Override
+        public void initStore(boolean flag, OffsetStoreSupplier storeSupplier) {
+            throw new UnsupportedOperationException("Unimplemented method 'initStore'");
+        }
+
+        @Override
+        public boolean notHasPendingOffset(ConsumerRecord<?, ?> record) {
+            throw new UnsupportedOperationException("Unimplemented method 'isAlreadyConsumed'");
+        }
+
+        @Override
+        public Optional<OffsetStore> offsetStore() {
+            throw new UnsupportedOperationException("Unimplemented method 'offsetStore'");
+        }
+
+        @Override
+        public void initStore(
+                OffsetStoreSupplier storeSupplier,
+                Map<TopicPartition, Long> startOffsets,
+                Map<TopicPartition, OffsetAndMetadata> committed) {
+            throw new UnsupportedOperationException("Unimplemented method 'initStore'");
+        }
+
+        public List<ConsumedRecordInfo> getConsumedRecords() {
+            return records;
+        }
+    }
+
+    public static class MockOffsetStore implements OffsetStore {
+
+        private final List<ConsumerRecord<?, ?>> records = new ArrayList<>();
+        private final Map<TopicPartition, OffsetAndMetadata> topicMap;
+
+        public MockOffsetStore(Map<TopicPartition, OffsetAndMetadata> topicMap) {
+            this.topicMap = Collections.unmodifiableMap(topicMap);
+        }
+
+        @Override
+        public void save(ConsumerRecord<?, ?> record) {
+            records.add(record);
+        }
+
+        @Override
+        public Map<TopicPartition, OffsetAndMetadata> current() {
+            return topicMap;
+        }
+
+        public List<ConsumerRecord<?, ?>> getRecords() {
+            return Collections.unmodifiableList(records);
+        }
+    }
+
+    public static class MockRecordProcessor<K, V> implements RecordProcessor<K, V> {
+
+        private List<ConsumedRecordInfo> offsetTrriggeringExceptions;
+        private RuntimeException e;
+
+        public MockRecordProcessor(
+                RuntimeException e, List<ConsumedRecordInfo> offsetTrriggeringExceptions) {
+            this.e = e;
+            this.offsetTrriggeringExceptions = offsetTrriggeringExceptions;
+        }
+
+        public MockRecordProcessor() {
+            this(null, Collections.emptyList());
+        }
+
+        @Override
+        public void process(ConsumerRecord<K, V> record) throws ValueException {
+            if (e == null) {
+                return;
+            }
+
+            if (offsetTrriggeringExceptions.contains(ConsumedRecordInfo.from(record))) {
+                throw e;
+            }
+        }
+
+        @Override
+        public void useLogger(Logger logger) {}
+    }
+
+    public static class MockItemEventListener implements ItemEventListener {
+
+        private static Consumer<Map<String, String>> NOPConsumer = m -> {};
+
+        private Consumer<Map<String, String>> consumer;
+
+        public MockItemEventListener(Consumer<Map<String, String>> consumer) {
+            this.consumer = consumer;
+        }
+
+        public MockItemEventListener() {
+            this(NOPConsumer);
+        }
+
+        @Override
+        public void update(String itemName, ItemEvent event, boolean isSnapshot) {
+            throw new UnsupportedOperationException("Unimplemented method 'update'");
+        }
+
+        @Override
+        public void update(String itemName, OldItemEvent event, boolean isSnapshot) {
+            throw new UnsupportedOperationException("Unimplemented method 'update'");
+        }
+
+        @Override
+        public void update(String itemName, Map event, boolean isSnapshot) {
+            throw new UnsupportedOperationException("Unimplemented method 'update'");
+        }
+
+        @Override
+        public void update(String itemName, IndexedItemEvent event, boolean isSnapshot) {
+            throw new UnsupportedOperationException("Unimplemented method 'update'");
+        }
+
+        @Override
+        public void smartUpdate(Object itemHandle, ItemEvent event, boolean isSnapshot) {
+            throw new UnsupportedOperationException("Unimplemented method 'smartUpdate'");
+        }
+
+        @Override
+        public void smartUpdate(Object itemHandle, OldItemEvent event, boolean isSnapshot) {
+            throw new UnsupportedOperationException("Unimplemented method 'smartUpdate'");
+        }
+
+        @Override
+        public void smartUpdate(Object itemHandle, Map event, boolean isSnapshot) {
+            consumer.accept(event);
+        }
+
+        @Override
+        public void smartUpdate(Object itemHandle, IndexedItemEvent event, boolean isSnapshot) {
+            throw new UnsupportedOperationException("Unimplemented method 'smartUpdate'");
+        }
+
+        @Override
+        public void endOfSnapshot(String itemName) {
+            throw new UnsupportedOperationException("Unimplemented method 'endOfSnapshot'");
+        }
+
+        @Override
+        public void smartEndOfSnapshot(Object itemHandle) {
+            throw new UnsupportedOperationException("Unimplemented method 'smartEndOfSnapshot'");
+        }
+
+        @Override
+        public void clearSnapshot(String itemName) {
+            throw new UnsupportedOperationException("Unimplemented method 'clearSnapshot'");
+        }
+
+        @Override
+        public void smartClearSnapshot(Object itemHandle) {
+            throw new UnsupportedOperationException("Unimplemented method 'smartClearSnapshot'");
+        }
+
+        @Override
+        public void declareFieldDiffOrder(
+                String itemName, Map<String, DiffAlgorithm[]> algorithmsMap) {
+            throw new UnsupportedOperationException("Unimplemented method 'declareFieldDiffOrder'");
+        }
+
+        @Override
+        public void smartDeclareFieldDiffOrder(
+                Object itemHandle, Map<String, DiffAlgorithm[]> algorithmsMap) {
+            throw new UnsupportedOperationException(
+                    "Unimplemented method 'smartDeclareFieldDiffOrder'");
+        }
+
+        @Override
+        public void failure(Throwable e) {
+            throw new UnsupportedOperationException("Unimplemented method 'failure'");
+        }
+    }
+}
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/ConsumerRecords.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/Records.java
similarity index 56%
rename from kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/ConsumerRecords.java
rename to kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/Records.java
index 051bdc42..ba946b3f 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/ConsumerRecords.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/Records.java
@@ -17,19 +17,31 @@
 
 package com.lightstreamer.kafka.test_utils;
 
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.mapping;
+import static java.util.stream.Collectors.toList;
+
 import com.fasterxml.jackson.databind.JsonNode;
 import com.lightstreamer.kafka.common.mapping.selectors.KafkaRecord;
 
 import org.apache.avro.generic.GenericRecord;
 import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.common.TopicPartition;
 import org.apache.kafka.common.header.internals.RecordHeaders;
 import org.apache.kafka.common.record.TimestampType;
 import org.apache.kafka.connect.data.Schema;
 import org.apache.kafka.connect.sink.SinkRecord;
 
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
-public class ConsumerRecords {
+public class Records {
 
     public static KafkaRecord<GenericRecord, ?> fromKey(GenericRecord key) {
         return record(key, null);
@@ -99,6 +111,14 @@ public static <K, V> KafkaRecord<K, V> record(String topic, K key, V value) {
                         Optional.empty()));
     }
 
+    public static ConsumerRecord<String, String> Record(String topic, int partition, String id) {
+        String[] tokens = id.split("-");
+        String key = tokens[0];
+        long offset = Long.parseLong(tokens[1]);
+        String value = offset + key;
+        return new ConsumerRecord<String, String>(topic, partition, offset, key, value);
+    }
+
     public static KafkaRecord<Object, Object> sinkFromValue(
             String topic, Schema valueSchema, Object value) {
         return sink(topic, null, null, valueSchema, value);
@@ -123,7 +143,7 @@ public static KafkaRecord<Object, Object> sinkRecord(String topic, Object key, O
                         TimestampType.NO_TIMESTAMP_TYPE));
     }
 
-    private static KafkaRecord<Object, Object> sink(
+    public static KafkaRecord<Object, Object> sink(
             String topic, Schema keySchema, Object key, Schema valueSchema, Object value) {
         return KafkaRecord.from(
                 new SinkRecord(
@@ -137,4 +157,59 @@ private static KafkaRecord<Object, Object> sink(
                         (long) -1,
                         TimestampType.NO_TIMESTAMP_TYPE));
     }
+
+    public static ConsumerRecords<String, String> generateRecords(
+            String topic, int size, List<String> keys) {
+        return generateRecords(topic, size, keys, new int[] {0});
+    }
+
+    public static ConsumerRecords<String, String> generateRecords(
+            String topic, int size, List<String> keys, int[] partitions) {
+
+        List<ConsumerRecord<String, String>> records = new ArrayList<>();
+        Map<String, Integer> eventCounter = new HashMap<>();
+        Map<Integer, Integer> offsetCounter = new HashMap<>();
+        SecureRandom secureRandom = new SecureRandom();
+
+        // Generate the records list
+        for (int i = 0; i < size; i++) {
+            String recordKey = null;
+            String recordValue = null;
+            String eventCounterKey = "noKey";
+            int partition = 0;
+
+            if (keys.size() > 0) {
+                // Select randomly one of the passed keys
+                int index = secureRandom.nextInt(keys.size());
+                recordKey = keys.get(index);
+                eventCounterKey = recordKey;
+                // Generate a value by adding a counter suffix to the key: key "a" -> value
+                // "a-4"
+                int counter = eventCounter.compute(eventCounterKey, (k, v) -> v == null ? 1 : ++v);
+                recordValue = "%s-%d".formatted(recordKey, counter);
+                // Select a partition based on the key hascode
+                partition = recordKey.hashCode() % partitions.length;
+            } else {
+                // Generate a value simply by adding a counter suffix
+                // Note that in this case the counter is global
+                int counter = eventCounter.compute(eventCounterKey, (k, v) -> v == null ? 1 : ++v);
+                recordValue = "%s-%d".formatted("EVENT", counter);
+                // Round robin selection of the partion
+                partition = i % partitions.length;
+            }
+
+            // Increment the offset relative to the selected partition
+            int offset = offsetCounter.compute(partition, (p, o) -> o == null ? 0 : ++o);
+            records.add(new ConsumerRecord<>(topic, partition, offset, recordKey, recordValue));
+        }
+
+        // Group records by partition to be passed to the ConsumerRecords instance
+        Map<TopicPartition, List<ConsumerRecord<String, String>>> partionsToRecords =
+                records.stream()
+                        .collect(
+                                groupingBy(
+                                        record -> new TopicPartition("topic", record.partition()),
+                                        mapping(Function.identity(), toList())));
+        return new ConsumerRecords<>(partionsToRecords);
+    }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/TestSelectorSuppliers.java b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/TestSelectorSuppliers.java
index 1d4bedf7..345b6cdb 100644
--- a/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/TestSelectorSuppliers.java
+++ b/kafka-connector-project/kafka-connector/src/test/java/com/lightstreamer/kafka/test_utils/TestSelectorSuppliers.java
@@ -17,70 +17,93 @@
 
 package com.lightstreamer.kafka.test_utils;
 
-import static com.lightstreamer.kafka.common.mapping.selectors.SelectorSuppliers.of;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_KEY_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_SCHEMA_PATH;
+import static com.lightstreamer.kafka.adapters.config.ConnectorConfig.RECORD_VALUE_EVALUATOR_TYPE;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.AVRO;
+import static com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType.JSON;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.lightstreamer.kafka.adapters.config.ConnectorConfig;
-import com.lightstreamer.kafka.adapters.config.specs.ConfigTypes.EvaluatorType;
+import com.lightstreamer.kafka.adapters.mapping.selectors.WrapperKeyValueSelectorSuppliers;
 import com.lightstreamer.kafka.adapters.mapping.selectors.avro.GenericRecordSelectorsSuppliers;
 import com.lightstreamer.kafka.adapters.mapping.selectors.json.JsonNodeSelectorsSuppliers;
 import com.lightstreamer.kafka.adapters.mapping.selectors.others.OthersSelectorSuppliers;
-import com.lightstreamer.kafka.common.mapping.selectors.KeySelectorSupplier;
-import com.lightstreamer.kafka.common.mapping.selectors.SelectorSuppliers;
-import com.lightstreamer.kafka.common.mapping.selectors.ValueSelectorSupplier;
+import com.lightstreamer.kafka.common.mapping.selectors.KeyValueSelectorSuppliers;
 import com.lightstreamer.kafka.connect.mapping.selectors.ConnectSelectorsSuppliers;
 
 import org.apache.avro.generic.GenericRecord;
 
+import java.util.Map;
+
 public interface TestSelectorSuppliers {
 
-    @SuppressWarnings("unchecked")
-    public static SelectorSuppliers<String, String> string() {
-        return of(
-                (KeySelectorSupplier<String>)
-                        OthersSelectorSuppliers.keySelectorSupplier(EvaluatorType.STRING),
-                (ValueSelectorSupplier<String>)
-                        OthersSelectorSuppliers.valueSelectorSupplier(EvaluatorType.STRING));
+    public static KeyValueSelectorSuppliers<GenericRecord, GenericRecord> Avro() {
+        GenericRecordSelectorsSuppliers g = new GenericRecordSelectorsSuppliers(avroAvroConfig());
+        return new WrapperKeyValueSelectorSuppliers<>(
+                g.makeKeySelectorSupplier(), g.makeValueSelectorSupplier());
+    }
+
+    public static KeyValueSelectorSuppliers<String, GenericRecord> AvroValue() {
+        GenericRecordSelectorsSuppliers g = new GenericRecordSelectorsSuppliers(avroAvroConfig());
+        return new WrapperKeyValueSelectorSuppliers<>(
+                OthersSelectorSuppliers.StringKey(), g.makeValueSelectorSupplier());
+    }
+
+    public static KeyValueSelectorSuppliers<GenericRecord, JsonNode> AvroKeyJsonValue() {
+        ConnectorConfig config = avroJsonConfig();
+        JsonNodeSelectorsSuppliers j = new JsonNodeSelectorsSuppliers(config);
+        GenericRecordSelectorsSuppliers g = new GenericRecordSelectorsSuppliers(config);
+        return new WrapperKeyValueSelectorSuppliers<>(
+                g.makeKeySelectorSupplier(), j.makeValueSelectorSupplier());
     }
 
-    public static SelectorSuppliers<GenericRecord, GenericRecord> avro(ConnectorConfig config) {
-        return of(
-                GenericRecordSelectorsSuppliers.keySelectorSupplier(config),
-                GenericRecordSelectorsSuppliers.valueSelectorSupplier(config));
+    public static KeyValueSelectorSuppliers<JsonNode, JsonNode> Json(ConnectorConfig config) {
+        JsonNodeSelectorsSuppliers j = new JsonNodeSelectorsSuppliers(config);
+        return new WrapperKeyValueSelectorSuppliers<>(
+                j.makeKeySelectorSupplier(), j.makeValueSelectorSupplier());
     }
 
-    @SuppressWarnings("unchecked")
-    public static SelectorSuppliers<String, GenericRecord> avroValue(ConnectorConfig config) {
-        return of(
-                (KeySelectorSupplier<String>)
-                        OthersSelectorSuppliers.keySelectorSupplier(EvaluatorType.STRING),
-                GenericRecordSelectorsSuppliers.valueSelectorSupplier(config));
+    public static KeyValueSelectorSuppliers<String, JsonNode> JsonValue(ConnectorConfig config) {
+        JsonNodeSelectorsSuppliers j = new JsonNodeSelectorsSuppliers(config);
+        return new WrapperKeyValueSelectorSuppliers<>(
+                OthersSelectorSuppliers.StringKey(), j.makeValueSelectorSupplier());
     }
 
-    public static SelectorSuppliers<GenericRecord, JsonNode> avroKeyJsonValue(
-            ConnectorConfig config) {
-        return of(
-                GenericRecordSelectorsSuppliers.keySelectorSupplier(config),
-                JsonNodeSelectorsSuppliers.valueSelectorSupplier(config));
+    public static KeyValueSelectorSuppliers<String, JsonNode> JsonValue() {
+        JsonNodeSelectorsSuppliers j = new JsonNodeSelectorsSuppliers();
+        return new WrapperKeyValueSelectorSuppliers<>(
+                OthersSelectorSuppliers.StringKey(), j.makeValueSelectorSupplier());
     }
 
-    public static SelectorSuppliers<JsonNode, JsonNode> json(ConnectorConfig config) {
-        return of(
-                JsonNodeSelectorsSuppliers.keySelectorSupplier(config),
-                JsonNodeSelectorsSuppliers.valueSelectorSupplier(config));
+    public static KeyValueSelectorSuppliers<Object, Object> Object() {
+        return new ConnectSelectorsSuppliers();
     }
 
-    @SuppressWarnings("unchecked")
-    public static SelectorSuppliers<String, JsonNode> jsonValue(ConnectorConfig config) {
-        return of(
-                (KeySelectorSupplier<String>)
-                        OthersSelectorSuppliers.keySelectorSupplier(EvaluatorType.STRING),
-                JsonNodeSelectorsSuppliers.valueSelectorSupplier(config));
+    private static ConnectorConfig avroJsonConfig() {
+        return ConnectorConfigProvider.minimalWith(
+                "src/test/resources",
+                Map.of(
+                        RECORD_KEY_EVALUATOR_TYPE,
+                        AVRO.toString(),
+                        RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                        "value.avsc",
+                        RECORD_VALUE_EVALUATOR_TYPE,
+                        JSON.toString()));
     }
 
-    public static SelectorSuppliers<Object, Object> object() {
-        return of(
-                ConnectSelectorsSuppliers.keySelectorSupplier(),
-                ConnectSelectorsSuppliers.valueSelectorSupplier());
+    private static ConnectorConfig avroAvroConfig() {
+        return ConnectorConfigProvider.minimalWith(
+                "src/test/resources",
+                Map.of(
+                        RECORD_KEY_EVALUATOR_TYPE,
+                        AVRO.toString(),
+                        RECORD_KEY_EVALUATOR_SCHEMA_PATH,
+                        "value.avsc",
+                        RECORD_VALUE_EVALUATOR_TYPE,
+                        AVRO.toString(),
+                        RECORD_VALUE_EVALUATOR_SCHEMA_PATH,
+                        "value.avsc"));
     }
 }
diff --git a/kafka-connector-project/kafka-connector/src/test/resources/should-matches-items.csv b/kafka-connector-project/kafka-connector/src/test/resources/should-matches-items.csv
deleted file mode 100644
index aa96252b..00000000
--- a/kafka-connector-project/kafka-connector/src/test/resources/should-matches-items.csv
+++ /dev/null
@@ -1,25 +0,0 @@
-TEMPLATE                                                                       | SUBCRIBING_ITEM                          | SHOULD_EXPAND
-complex-item-${keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-<name=joe>                       | false
-complex-item-${keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item-<name=joe>                  | true
-complex-item-${keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item-<name=joe,child=alex>       | true
-complex-item-${keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item-<child=alex>                | true
-complex-item-${keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item                             | true
-complex-item-${keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item-                            | false
-complex-item-${keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item-<keyName=joe>               | true
-complex-item-${keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item-<keyName=joe,child=alex>    | true
-complex-item-${keyName=KEY.name,child=VALUE.children[1].children[0].name}      | complex-item-<keyName=joe,child=gloria>  | true
-complex-item-${keyName=KEY.name,child=VALUE.children[1].children[1].name}      | complex-item-<keyName=joe,child=terence> | true
-complex-item-${keyName=KEY.name,child=VALUE.children[1].children[1].name}      | complex-item-<keyName=joe,child=carol>   | false
-complex-item-${child=VALUE.children[1].children[1].name}                       | complex-item-<keyName=joe,child=terence> | false
-complex-item-${child=VALUE.children[1].children[1].name}                       | complex-item-<child=terence>             | true
-item-${ts=TIMESTAMP,partition=PARTITION}                                       | item-<ts=-1>                             | true
-item-${ts=TIMESTAMP,partition=PARTITION}                                       | item-<partition=150>                     | true
-item-${ts=TIMESTAMP,partition=PARTITION}                                       | item-<partition=150,ts=-1>               | true
-item-${ts=TIMESTAMP,partition=PARTITION}                                       | item-<partition=150,ts=1>                | false
-item-${ts=TIMESTAMP,partition=PARTITION}                                       | item-<partition=50>                      | false
-item                                                                           | item                                     | true
-item-first                                                                     | item-first                               | true
-item_123_                                                                      | item_123_                                | true
-item-                                                                          | item-                                    | true
-prefix-${}                                                                     | prefix                                   | true
-prefix-${}                                                                     | prefix-                                  | false
\ No newline at end of file
diff --git a/kafka-connector-project/kafka-connector/src/test/resources/should-expand-items.csv b/kafka-connector-project/kafka-connector/src/test/resources/should-route-items.csv
similarity index 98%
rename from kafka-connector-project/kafka-connector/src/test/resources/should-expand-items.csv
rename to kafka-connector-project/kafka-connector/src/test/resources/should-route-items.csv
index 5856a715..54239386 100644
--- a/kafka-connector-project/kafka-connector/src/test/resources/should-expand-items.csv
+++ b/kafka-connector-project/kafka-connector/src/test/resources/should-route-items.csv
@@ -1,4 +1,4 @@
-TEMPLATE                                                                       | SUBCRIBING_ITEM                                | SHOULD_SUBSCRIBE  | SHOULD_EXPAND   
+TEMPLATE                                                                       | SUBCRIBING_ITEM                                | SHOULD_SUBSCRIBE  | SHOULD_ROUTE
 complex-item-#{keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-[name=joe]                             | false             | false
 complex-item-#{keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item-[name=joe]                        | false             | false 
 complex-item-#{keyName=KEY.name,name=VALUE.name,child=VALUE.children[0].name}  | complex-item-[name=joe,child=alex]             | false             | false
diff --git a/kafka-connector-project/kafka-connector/src/test/resources/test_schema.avsc b/kafka-connector-project/kafka-connector/src/test/resources/test_schema.avsc
new file mode 100644
index 00000000..ec9c172c
--- /dev/null
+++ b/kafka-connector-project/kafka-connector/src/test/resources/test_schema.avsc
@@ -0,0 +1,17 @@
+{
+    "namespace": "kafkaconnector.avro",
+    "type": "record",
+    "name": "User",
+    "fields": [
+        {
+            "name": "firstName",
+            "type": "string"
+        },
+        {
+            "name": "lastName",
+            "type": [
+                "string"
+            ]
+        }
+    ]
+}
\ No newline at end of file