iotagent-node-lib 3.0.0 → 3.2.0

package/doc/deprecated.md

@@ -21,6 +21,7 @@ A list of deprecated features and the version in which they were deprecated foll
 -   Support to NGSI-LD v1.3 in iotagent-node-lib 2.25.0 (finally removed in 2.26.0)
 -   Support groups (provision) statically defined by configuration
 -   Support to in-memory registry (i.e.`deviceRegistry.type=memory`)
+-   Support to legacy expressions (finally removed in 3.2.0)
 
 The use of Node.js v14 is highly recommended.
 
@@ -48,4 +49,5 @@ The following table provides information about the last iotagent-node-lib versio
 | Support to Node.js v8  | 2.12.0                                                | April 7th, 2020               |
 | Support to Node.js v10 | 2.15.0                                                | February 18th, 2021           |
 | Support to Node.js v12 | 2.24.0                                                | September 2nd, 2022           |
-| Support to NGSI-LD 1.3 | 2.25.0                                                | January 24th, 2023          |
+| Support to NGSI-LD 1.3 | 2.25.0                                                | January 24th, 2023            |
+| Support to Legacy Expressions | 3.1.0                                          | April 25th, 2023              |

package/doc/development.md

@@ -7,6 +7,9 @@
 -   [Continuous testing](#continuous-testing)
 -   [Code Coverage](#code-coverage)
 -   [Clean](#clean)
+-   [Data mapping plugins](#data-mapping-plugins)
+    -   [Development](#development)
+    -   [Provided plugins](#provided-plugins)
 
 ### Contributions
 
@@ -163,3 +166,120 @@ To ensure consistent Markdown formatting run the following:
 # Use git-bash on Windows
 npm run prettier:text
 ```
+
+# DB Models (from API document)
+
+## Service group model
+
+The table below shows the information held in the service group provisioning resource. The table also contains the
+correspondence between the API resource fields and the same fields in the database model.
+
+| Payload Field                  | DB Field                       | Definition                                                                                                                                                                                                                                                                |
+| ------------------------------ | ------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---- |
+| `service`                      | `service`                      | Service of the devices of this type                                                                                                                                                                                                                                       |
+| `subservice`                   | `subservice`                   | Subservice of the devices of this type.                                                                                                                                                                                                                                   |
+| `resource`                     | `resource`                     | string representing the Southbound resource that will be used to assign a type to a device (e.g.: pathname in the southbound port).                                                                                                                                       |
+| `apikey`                       | `apikey`                       | API Key string.                                                                                                                                                                                                                                                           |
+| `timestamp`                    | `timestamp`                    | Optional flag about whether or not to add the `TimeInstant` attribute to the device entity created, as well as a `TimeInstant` metadata to each attribute, with the current timestamp. With NGSI-LD, the Standard `observedAt` property-of-a-property is created instead. | true |
+| `entity_type`                  | `entity_type`                  | name of the Entity `type` to assign to the group.                                                                                                                                                                                                                         |
+| `trust`                        | `trust`                        | trust token to use for secured access to the Context Broker for this type of devices (optional; only needed for secured scenarios).                                                                                                                                       |
+| `cbHost`                       | `cbHost`                       | Context Broker connection information. This options can be used to override the global ones for specific types of devices.                                                                                                                                                |
+| `lazy`                         | `lazy`                         | list of common lazy attributes of the device. For each attribute, its `name` and `type` must be provided.                                                                                                                                                                 |
+| `commands`                     | `commands`                     | list of common commands attributes of the device. For each attribute, its `name` and `type` must be provided, additional `metadata` is optional.                                                                                                                          |
+| `attributes`                   | `attributes`                   | list of common active attributes of the device. For each attribute, its `name` and `type` must be provided, additional `metadata` is optional.                                                                                                                            |
+| `static_attributes`            | `staticAttributes`             | this attributes will be added to all the entities of this group 'as is', additional `metadata` is optional.                                                                                                                                                               |
+| `internal_attributes`          | `internalAttributes`           | optional section with free format, to allow specific IoT Agents to store information along with the devices in the Device Registry.                                                                                                                                       |
+| `expressionLanguage`           | `expresionLanguage`            | optional boolean value, to set expression language used to compute expressions, possible values are: legacy or jexl. When not set or wrongly set, `legacy` is used as default value.                                                                                      |
+| `explicitAttrs`                | `explicitAttrs`                | optional field to support selective ignore of measures so that IOTA doesn’t progress. See details in [specific section](advanced-topics.md#explicitly-defined-attributes-explicitattrs)                                                                                   |
+| `entityNameExp`                | `entityNameExp`                | optional field to allow use expressions to define entity name, instead default `id` and `type`                                                                                                                                                                            |
+| `ngsiVersion`                  | `ngsiVersion`                  | optional string value used in mixed mode to switch between **NGSI-v2** and **NGSI-LD** payloads. Possible values are: `v2` or `ld`. The default is `v2`. When not running in mixed mode, this field is ignored.                                                           |
+| `defaultEntityNameConjunction` | `defaultEntityNameConjunction` | optional string value to set default conjunction string used to compose a default `entity_name` when is not provided at device provisioning time.                                                                                                                         |
+| `autoprovision`                | `autoprovision`                | optional boolean: If `false`, autoprovisioned devices (i.e. devices that are not created with an explicit provision operation but when the first measure arrives) are not allowed in this group. Default (in the case of omitting the field) is `true`.                   |
+
+## Device model
+
+The table below shows the information held in the Device resource. The table also contains the correspondence between
+the API resource fields and the same fields in the database model.
+
+| Payload Field         | DB Field             | Definition                                                                                                                                                                                                                                                                | Example of value                              |
+| --------------------- | -------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :-------------------------------------------- |
+| `device_id`           | `id`                 | Device ID that will be used to identify the device.                                                                                                                                                                                                                       | UO834IO                                       |
+| `service`             | `service`            | Name of the service the device belongs to (will be used in the fiware-service header).                                                                                                                                                                                    | smartGondor                                   |
+| `service_path`        | `subservice`         | Name of the subservice the device belongs to (used in the fiware-servicepath header).                                                                                                                                                                                     | /gardens                                      |
+| `entity_name`         | `name`               | Name of the entity representing the device in the Context Broker                                                                                                                                                                                                          | ParkLamplight12                               |
+| `entity_type`         | `type`               | Type of the entity in the Context Broker                                                                                                                                                                                                                                  | Lamplights                                    |
+| `timezone`            | `timezone`           | Time zone of the sensor if it has any                                                                                                                                                                                                                                     | America/Santiago                              |
+| `timestamp`           | `timestamp`          | Optional flag about whether or not to add the `TimeInstant` attribute to the device entity created, as well as a `TimeInstant` metadata to each attribute, with the current timestamp. With NGSI-LD, the Standard `observedAt` property-of-a-property is created instead. | true                                          |
+| `apikey`              | `apikey`             | Optional Apikey key string to use instead of group apikey                                                                                                                                                                                                                 | 9n4hb1vpwbjozzmw9f0flf9c2                     |
+| `endpoint`            | `endpoint`           | Endpoint where the device is going to receive commands, if any.                                                                                                                                                                                                           | http://theDeviceUrl:1234/commands             |
+| `protocol`            | `protocol`           | Name of the device protocol, for its use with an IoT Manager.                                                                                                                                                                                                             | IoTA-UL                                       |
+| `transport`           | `transport`          | Name of the device transport protocol, for the IoT Agents with multiple transport protocols.                                                                                                                                                                              | MQTT                                          |
+| `attributes`          | `active`             | List of active attributes of the device                                                                                                                                                                                                                                   | `[ { "name": "attr_name", "type": "Text" } ]` |
+| `lazy`                | `lazy`               | List of lazy attributes of the device                                                                                                                                                                                                                                     | `[ { "name": "attr_name", "type": "Text" } ]` |
+| `commands`            | `commands`           | List of commands of the device                                                                                                                                                                                                                                            | `[ { "name": "attr_name", "type": "Text" } ]` |
+| `internal_attributes` | `internalAttributes` | List of internal attributes with free format for specific IoT Agent configuration                                                                                                                                                                                         | LWM2M mappings from object URIs to attributes |
+| `static_attributes`   | `staticAttributes`   | List of static attributes to append to the entity. All the updateContext requests to the CB will have this set of attributes appended.                                                                                                                                    | `[ { "name": "attr_name", "type": "Text" } ]` |
+| `expressionLanguage`  | `expresionLanguage`  | optional boolean value, to set expression language used to compute expressions, possible values are: legacy or jexl. When not set or wrongly set, legacy is used as default value.                                                                                        |
+| `explicitAttrs`       | `explicitAttrs`      | optional field to support selective ignore of measures so that IOTA doesn’t progress. See details in [specific section](advanced-topics.md#explicitly-defined-attributes-explicitattrs)                                                                                   | (see details in specific section)             |
+| `ngsiVersion`         | `ngsiVersion`        | optional string value used in mixed mode to switch between **NGSI-v2** and **NGSI-LD** payloads. The default is `v2`. When not running in mixed mode, this field is ignored.                                                                                              | `v2/ld`                                       |
+
+## Data mapping plugins
+
+The IoT Agent Library provides a plugin mechanism in order to facilitate reusing code that makes small transformations
+on incoming data (both from the device and from the context consumers). This mechanism is based in the use of
+middlewares, i.e.: small pieces of code that receive and return an `entity`, making as many changes as they need, but
+taking care of returning a valid entity, that can be used as the input for other middlewares; this way, all those pieces
+of code can be chained together in order to make all the needed transformations in the target entity.
+
+There are two kinds of middlewares: updateContext middlewares and queryContext middlewares. The updateContext
+middlewares are applied before the information is sent to the Context Broker, modifiying the entity before it is sent to
+Orion. The queryContext middlewares are applied on the received data, whenever the IoT Agent queries the Context Broker
+for information. I.e.: both middlewares will be automatically applied whenever the `update()` or `query()` functions are
+called in the library.
+
+All the middlewares have the opportunity to break the chain of middleware applications by calling the `callback()` with
+an error object (the usual convention). If any of the updateContext middlewares raise an error, no request will be sent
+to the Context Broker. On the other hand, the queryContext request is always performed, but the call to the `query()`
+function will end up in an error if any of the queryContext middlewares report an error.
+
+### Development
+
+All the middlewares have the same signature:
+
+```javascript
+function middlewareName(entity, typeInformation, callback) {}
+```
+
+The arguments for any middleware are the NGSI data over which it can operate:
+
+-   An updateContext payload in the case of an updateContext middleware and a queryContext payload otherwise;
+-   a typeInformation object containing all the information about the device stored during registration.
+-   and the customary `callback` parameter, with the usual meaning. It's really important for the library user to call
+    this callback, as failing to do so may hang the IoT Agent completely. The callback must be called with the an
+    optional error in the first argument and the same arguments received (potentially modified) as the following.
+
+In order to manage the middlewares to the system, the following functions can be used:
+
+-   `addUpdateMiddleware`: adds an updateContext middleware to the stack of middlewares. All the middlewares will be
+    applied to every call to the `update()` function. The final payload of the updateContext request will be the result
+    of applying all this middlewares in the order they have been defined.
+
+-   `addQueryMiddleware`: adds a queryContext middleware to the stack of middlewares. All the middlewares will be
+    applied to every call to the `query()` function.
+
+-   `resetMiddlewares`: remove all the middlewares from the system.
+
+Usually, the full list of middlewares an IoT Agent will use would be added in the IoTAgent start sequence, so they
+should not change a lot during the IoT lifetime.
+
+### Provided plugins
+
+The library provides some plugins out of the box, in the `dataPlugins` collection. In order to load any of them, just
+use the `addQueryMiddleware` and `addUpdateMiddleware` functions with the selected plugin, as in the example:
+
+```javascript
+var iotaLib = require('iotagent-node-lib');
+
+iotaLib.addUpdateMiddleware(iotaLib.dataPlugins.compressTimestamp.update);
+iotaLib.addQueryMiddleware(iotaLib.dataPlugins.compressTimestamp.query);
+```

package/doc/installationguide.md

@@ -73,9 +73,9 @@ overriding the group setting.
 ```
 
 When connected to an **NGSI-LD** context broker, an IoT Agent is able to indicate whether it is willing to accept `null`
-values and also whether it is able to process the **NGSI-LD** `datasetId` metadata element. Setting these
-values to `false` will cause the IoT Agent to return a 400 **Bad Request** HTTP status code explaining that the IoT
-Agent does not support nulls or multi-attribute requests if they are encountered.
+values and also whether it is able to process the **NGSI-LD** `datasetId` metadata element. Setting these values to
+`false` will cause the IoT Agent to return a 400 **Bad Request** HTTP status code explaining that the IoT Agent does not
+support nulls or multi-attribute requests if they are encountered.
 
 ```javascript
 {
@@ -277,8 +277,6 @@ used for the same purpose. For instance:
     the IoTAgent runs in a single thread. For more details about multi-core functionality, please refer to the
     [Cluster](https://nodejs.org/api/cluster.html) module in Node.js and
     [this section](howto.md#iot-agent-in-multi-thread-mode) of the library documentation.
--   **defaultExpressionLanguage**: the default expression language used to compute expressions, possible values are:
-    `legacy` or `jexl`. When not set or wrongly set, `legacy` is used as default value.
 -   **fallbackTenant** - For Linked Data Context Brokers which do not support multi-tenancy, this provides an
     alternative mechanism for supplying the `NGSILD-Tenant` header. Note that NGSILD-Tenant has not yet been included in
     the NGSI-LD standard (it has been proposed for the next update of the standard, but the final decision has yet been
@@ -362,7 +360,6 @@ overrides.
 | IOTA_JSON_LD_CONTEXT                 | `jsonLdContext`                 |
 | IOTA_FALLBACK_TENANT                 | `fallbackTenant`                |
 | IOTA_FALLBACK_PATH                   | `fallbackPath`                  |
-| IOTA_DEFAULT_EXPRESSION_LANGUAGE     | `defaultExpressionLanguage`     |
 | IOTA_EXPLICIT_ATTRS                  | `explicitAttrs`                 |
 | IOTA_DEFAULT_ENTITY_NAME_CONJUNCTION | `defaultEntityNameConjunction`  |
 | IOTA_RELAX_TEMPLATE_VALIDATION       | `relaxTemplateValidation`       |

package/docker-compose-dev.yml

@@ -3,6 +3,6 @@ version: '3'
 services:
 
   mongo:
-    image: mongo:4.2
+    image: mongo:4.4
     ports:
       - "27017:27017"

package/lib/commonConfig.js

@@ -153,7 +153,6 @@ function processEnvironmentVariables() {
         'IOTA_POLLING_EXPIRATION',
         'IOTA_POLLING_DAEMON_FREQ',
         'IOTA_MULTI_CORE',
-        'IOTA_DEFAULT_EXPRESSION_LANGUAGE',
         'IOTA_RELAX_TEMPLATE_VALIDATION',
         'IOTA_DEFAULT_ENTITY_NAME_CONJUNCTION',
         'IOTA_JSON_LD_CONTEXT',
@@ -245,9 +244,9 @@ function processEnvironmentVariables() {
         config.contextBroker.jsonLdContext = process.env.IOTA_JSON_LD_CONTEXT.split(',').map((ctx) => ctx.trim());
     }
 
-   if (Array.isArray(config.contextBroker.jsonLdContext) && config.contextBroker.jsonLdContext.length === 1){
+    if (Array.isArray(config.contextBroker.jsonLdContext) && config.contextBroker.jsonLdContext.length === 1) {
         config.contextBroker.jsonLdContext = config.contextBroker.jsonLdContext[0];
-   }
+    }
 
     config.contextBroker.fallbackTenant =
         process.env.IOTA_FALLBACK_TENANT || config.contextBroker.service || 'iotagent';
@@ -265,7 +264,7 @@ function processEnvironmentVariables() {
         config.server.port = process.env.IOTA_NORTH_PORT;
     }
 
-    config.server.ldSupport = config.server.ldSupport || {null: true, datasetId: true, merge: false};
+    config.server.ldSupport = config.server.ldSupport || { null: true, datasetId: true, merge: false };
 
     if (process.env.IOTA_LD_SUPPORT_NULL) {
         config.server.ldSupport.null = process.env.IOTA_LD_SUPPORT_NULL === 'true';
@@ -273,7 +272,7 @@ function processEnvironmentVariables() {
     if (process.env.IOTA_LD_SUPPORT_DATASET_ID) {
         config.server.ldSupport.datasetId = process.env.IOTA_LD_SUPPORT_DATASET_ID === 'true';
     }
-     if (process.env.IOTA_LD_SUPPORT_MERGE) {
+    if (process.env.IOTA_LD_SUPPORT_MERGE) {
         config.server.ldSupport.datasetId = process.env.IOTA_LD_SUPPORT_MERGE === 'true';
     }
 
@@ -473,9 +472,6 @@ function processEnvironmentVariables() {
         config.multiCore = config.multiCore === true;
     }
 
-    if (process.env.IOTA_DEFAULT_EXPRESSION_LANGUAGE) {
-        config.defaultExpressionLanguage = process.env.IOTA_DEFAULT_EXPRESSION_LANGUAGE;
-    }
     if (process.env.IOTA_RELAX_TEMPLATE_VALIDATION) {
         config.relaxTemplateValidation = process.env.IOTA_RELAX_TEMPLATE_VALIDATION === 'true';
     } else {
@@ -484,7 +480,9 @@ function processEnvironmentVariables() {
     if (process.env.IOTA_DEFAULT_ENTITY_NAME_CONJUNCTION) {
         config.defaultEntityNameConjunction = process.env.IOTA_DEFAULT_ENTITY_NAME_CONJUNCTION;
     } else {
-        config.defaultEntityNameConjunction = config.defaultEntityNameConjunction ? config.defaultEntityNameConjunction : ':';
+        config.defaultEntityNameConjunction = config.defaultEntityNameConjunction
+            ? config.defaultEntityNameConjunction
+            : ':';
     }
 }
 
@@ -539,7 +537,6 @@ function ngsiVersion() {
     return 'unknown';
 }
 
-
 /**
  * It checks if a combination of typeInformation or common Config is LD
  *

package/lib/fiware-iotagent-lib.js

@@ -125,16 +125,6 @@ function doActivate(newConfig, callback) {
         }
     }
 
-    if (
-        newConfig.defaultExpressionLanguage &&
-        (newConfig.defaultExpressionLanguage === 'legacy' || newConfig.defaultExpressionLanguage === 'jexl')
-    ) {
-        logger.info(context, 'Using ' + newConfig.defaultExpressionLanguage + ' as default expression language');
-    } else {
-        logger.info(context, 'Default expression language not set, or invalid, using legacy configuration');
-        newConfig.defaultExpressionLanguage = 'legacy';
-    }
-
     config.setConfig(newConfig); //after chaging some configuration, we re apply the configuration
 
     logger.info(context, 'Activating IOT Agent NGSI Library.');

package/lib/jexlTranformsMap.js

@@ -78,7 +78,8 @@ const map = {
     toisostring: (d) => new Date(d).toISOString(),
     // https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
     localestring: (d, timezone, options) => new Date(d).toLocaleString(timezone, options),
-    now: () => Date.now()
+    now: () => Date.now(),
+    hextostring: (val) => new TextDecoder().decode(new Uint8Array(val.match(/.{1,2}/g).map(byte => parseInt(byte, 16))))
 };
 
 exports.map = map;

package/lib/plugins/bidirectionalData.js

@@ -75,9 +75,7 @@ function extractVariables(item) {
 
     function extractFromExpression(value) {
         if (value.expression) {
-            return value.expression.match(/@[a-zA-Z]+/g).map(function (item) {
-                return item.substr(1);
-            });
+            return parser.extractVariables(value.expression);
         }
         return [];
     }
@@ -157,9 +155,7 @@ function getReverseTransformations(list, values, callback) {
     let transformations = [];
 
     function getVariable(expression) {
-        return expression.match(/@[a-zA-Z]+/g).map(function (item) {
-            return item.substr(1);
-        });
+        return parser.extractVariables(expression);
     }
 
     if (list && list.length > 0) {
@@ -191,7 +187,7 @@ function getReverseTransformations(list, values, callback) {
  */
 function processTransformationsNGSIv2(values, typeInformation, transformations, callback) {
     let cleanedExpression;
-    const ctx = parser.extractContext(values, typeInformation);
+    const ctx = parser.extractContext(values);
     let resultTransformations = [];
 
     for (let j = 0; j < 2; j++) {
@@ -201,10 +197,7 @@ function processTransformationsNGSIv2(values, typeInformation, transformations,
     }
 
     for (let i = 0; i < resultTransformations.length; i++) {
-        cleanedExpression = resultTransformations[i].expression.substr(
-            2,
-            resultTransformations[i].expression.length - 3
-        );
+        cleanedExpression = resultTransformations[i].expression;
 
         values.push({
             name: resultTransformations[i].object_id,
@@ -252,20 +245,12 @@ function processTransformationsNGSILD(values, typeInformation, transformations,
     // This is the direct equivalent of the NGSI-v2 function
     if (!_.isEmpty(defaultValues)) {
         for (let i = 0; i < resultTransformations.length; i++) {
-            cleanedExpression = resultTransformations[i].expression.substr(
-                2,
-                resultTransformations[i].expression.length - 3
-            );
+            cleanedExpression = resultTransformations[i].expression;
             values.push({
                 name: resultTransformations[i].object_id,
                 type: resultTransformations[i].type,
                 metadata: {},
-                value: parser.parse(
-                    cleanedExpression,
-                    parser.extractContext(defaultValues, typeInformation),
-                    'String',
-                    typeInformation
-                )
+                value: parser.parse(cleanedExpression, parser.extractContext(defaultValues), 'String', typeInformation)
             });
         }
     }
@@ -274,10 +259,7 @@ function processTransformationsNGSILD(values, typeInformation, transformations,
     // There is no equivalent with NGSI-v2
     _.keys(datasetIds).forEach((datasetId) => {
         for (let i = 0; i < resultTransformations.length; i++) {
-            cleanedExpression = resultTransformations[i].expression.substr(
-                2,
-                resultTransformations[i].expression.length - 3
-            );
+            cleanedExpression = resultTransformations[i].expression;
             values.push({
                 name: resultTransformations[i].object_id,
                 type: resultTransformations[i].type,
@@ -285,7 +267,7 @@ function processTransformationsNGSILD(values, typeInformation, transformations,
                 metadata: {},
                 value: parser.parse(
                     cleanedExpression,
-                    parser.extractContext(datasetIds[datasetId], typeInformation),
+                    parser.extractContext(datasetIds[datasetId]),
                     'String',
                     typeInformation
                 )

package/lib/plugins/expressionPlugin.js

@@ -24,9 +24,7 @@
  * Modified by: Federico M. Facca - Martel Innovate
  */
 
-const legacyParser = require('./expressionParser');
 const jexlParser = require('./jexlParser');
-const config = require('../commonConfig');
 /* eslint-disable no-unused-vars */
 const logger = require('logops');
 const errors = require('../errors');
@@ -44,53 +42,23 @@ function setJEXLTransforms(transformationMap) {
 }
 
 function applyExpression(expression, context, typeInformation) {
-    let parser = jexlParser;
-    if (!checkJexl(typeInformation)) {
-        parser = legacyParser;
-    }
-    return parser.applyExpression(expression, context, typeInformation);
+    return jexlParser.applyExpression(expression, context, typeInformation);
 }
 
-function extractContext(attributeList, typeInformation) {
-    let parser = jexlParser;
-    if (!checkJexl(typeInformation)) {
-        parser = legacyParser;
-    }
-    return parser.extractContext(attributeList);
+function extractContext(attributeList) {
+    return jexlParser.extractContext(attributeList);
 }
 
-function parse(expression, context, type, typeInformation) {
-    if (!checkJexl(typeInformation)) {
-        return legacyParser.parse(expression, context, type);
-    }
+function parse(expression, context) {
     return jexlParser.parse(expression, context);
 }
 
 function contextAvailable(expression, context, typeInformation) {
-    let parser = jexlParser;
-    if (!checkJexl(typeInformation)) {
-        parser = legacyParser;
-    }
-    return parser.contextAvailable(expression, context);
+    return jexlParser.contextAvailable(expression, context);
 }
 
-function checkJexl(typeInformation) {
-    if (
-        config.getConfig().defaultExpressionLanguage === 'jexl' &&
-        typeInformation.expressionLanguage &&
-        typeInformation.expressionLanguage !== 'legacy'
-    ) {
-        return true;
-    } else if (config.getConfig().defaultExpressionLanguage === 'jexl' && !typeInformation.expressionLanguage) {
-        return true;
-    } else if (
-        config.getConfig().defaultExpressionLanguage === 'legacy' &&
-        typeInformation.expressionLanguage &&
-        typeInformation.expressionLanguage === 'jexl'
-    ) {
-        return true;
-    }
-    return false;
+function extractVariables(expression) {
+    return jexlParser.extractVariables(expression);
 }
 
 exports.parse = parse;
@@ -98,4 +66,4 @@ exports.setJEXLTransforms = setJEXLTransforms;
 exports.applyExpression = applyExpression;
 exports.extractContext = extractContext;
 exports.contextAvailable = contextAvailable;
-exports.checkJexl = checkJexl;
+exports.extractVariables = extractVariables;

package/lib/plugins/jexlParser.js

@@ -28,6 +28,8 @@
 /* eslint-disable no-unused-vars */
 
 const jexl = require('jexl');
+const grammar = require('jexl/dist/grammar').getGrammar();
+const Lexer = require('jexl/dist/Lexer');
 const errors = require('../errors');
 const logger = require('logops');
 const fillService = require('../services/common/domain').fillService;
@@ -62,6 +64,31 @@ function parse(expression, context, callback) {
     }
 }
 
+function extractVariables(expression) {
+    const inst = new Lexer(grammar);
+    let variables = [];
+
+    try {
+        const tokens = inst.tokenize(expression);
+
+        // Keep only root attributes, removing the dot and sub-attributes. For example, if we have
+        // a.0.b, a.1.b and a.2.b, we will only keep a
+        // Additionaly, it will remove the function calls, since they are also detected as identifiers
+        variables = tokens.filter(function (token, index, array) {
+            return (
+                (token.type === ' ' && array[index - 1].type !== 'dot') ||
+                (token.type === 'identifier' && array[index + 1].type !== 'openParen')
+            );
+        });
+
+        // Return only array of values
+        return variables.map((a) => a.value);
+    } catch (e) {
+        logger.warn(logContext, 'Wrong expression found "[%j]" error: "[%s]", it will be ignored', expression, e);
+        return false;
+    }
+}
+
 function extractContext(attributeList) {
     const context = {};
     let value;
@@ -162,6 +189,7 @@ function setTransforms(configMap) {
     logger.info(logContext, message);
 }
 
+exports.extractVariables = extractVariables;
 exports.extractContext = extractContext;
 exports.contextAvailable = contextAvailable;
 exports.applyExpression = applyExpression;

package/lib/services/commands/commandService.js

@@ -58,7 +58,7 @@ function addCommandDevice(service, subservice, device, command, callback) {
         // The context for the JEXL expression should be the ID, TYPE, S, SS
         let attrList = pluginUtils.getIdTypeServSubServiceFromDevice(device);
         attrList = device.staticAttributes ? attrList.concat(device.staticAttributes) : attrList.concat([]);
-        let ctxt = parser.extractContext(attrList, device);
+        let ctxt = parser.extractContext(attrList);
         logger.debug(context, 'attrList [%j] for device %j', attrList, device);
         // expression result will be the full command payload
         let cmdValueRes = null;

package/lib/services/devices/deviceService.js

@@ -294,7 +294,8 @@ function registerDevice(deviceObj, callback) {
                 // Add device ID, TYPE, S, SS to the context for the JEXL expression
                 let attrList = pluginUtils.getIdTypeServSubServiceFromDevice(deviceData);
                 attrList = deviceData.staticAttributes ? attrList.concat(deviceData.staticAttributes) : attrList;
-                let ctxt = expressionPlugin.extractContext(attrList, deviceData);
+                attrList = configuration.staticAttributes ? attrList.concat(configuration.staticAttributes) : attrList;
+                let ctxt = expressionPlugin.extractContext(attrList);
                 try {
                     entityName = expressionPlugin.applyExpression(configuration.entityNameExp, ctxt, deviceData);
                 } catch (e) {