iotagent-node-lib 2.25.0 → 2.26.0

package/CHANGES_NEXT_RELEASE

@@ -1 +0,0 @@
-

package/config.js

@@ -29,7 +29,12 @@ var config = {
     },
     server: {
         port: 4041,
-        host: '0.0.0.0'
+        host: '0.0.0.0',
+        ldSupport : {
+           null: true,
+           datasetId: true,
+           merge: false
+       }
     },
     authentication: {
         enabled: true,

package/doc/deprecated.md

@@ -18,7 +18,9 @@ A list of deprecated features and the version in which they were deprecated foll
 -   Support to Node.js v8 in iotagent-node-lib 2.12.0 (finally removed in 2.13.0)
 -   Support to Node.js v10 in iotagent-node-lib 2.15.0 (finally removed in 2.16.0)
 -   Support to Node.js v12 in iotagent-node-lib 2.24.0 (finally removed in 2.25.0)
--   Support to NGSI-LD v1.3 in iotagent-node-lib 2.25.0
+-   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`)
 
 The use of Node.js v14 is highly recommended.
 
@@ -46,3 +48,4 @@ 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          |

package/doc/howto.md

@@ -430,6 +430,14 @@ iotAgentLib.setDataUpdateHandler(updateContextHandler);
 iotAgentLib.setDataQueryHandler(queryContextHandler);
 ```
 
+Where necessary, additional handlers to deal with command actuations and merge-patch operations may also be added when
+necessary.
+
+```javascript
+iotAgentLib.setCommandHandler(commandHandler);
+iotAgentLib.setMergePatchHandler(mergePatchHandler);
+```
+
 #### IOTA Testing
 
 In order to test it, we need to create an HTTP server simulating the device. The quickest way to do that may be using

package/doc/installationguide.md

@@ -72,6 +72,22 @@ 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.
+
+```javascript
+{
+    baseRoot: '/',
+    port: 4041,
+    ldSupport : {
+      null: true,
+      datasetId: true
+    }
+}
+```
+
 -   **stats**: configure the periodic collection of statistics. Use `interval` in milliseconds to set the time between
     stats writings.
 
@@ -301,6 +317,8 @@ overrides.
 | IOTA_CB_NGSI_VERSION                 | `contextBroker.ngsiVersion`     |
 | IOTA_NORTH_HOST                      | `server.host`                   |
 | IOTA_NORTH_PORT                      | `server.port`                   |
+| IOTA_LD_SUPPORT_NULL                 | `server.ldSupport.null`         |
+| IOTA_LD_SUPPORT_DATASET_ID           | `server.ldSupport.datasetId`    |
 | IOTA_PROVIDER_URL                    | `providerUrl`                   |
 | IOTA_AUTH_ENABLED                    | `authentication.enabled`        |
 | IOTA_AUTH_TYPE                       | `authentication.type`           |

package/doc/usermanual.md

@@ -354,6 +354,83 @@ values.
 The handler is expected to call its callback once with no parameters (failing to do so may cause unexpected behaviors in
 the IoT Agent).
 
+##### iotagentLib.setCommandHandler()
+
+###### Signature
+
+```javascript
+function setCommandHandler(newHandler)
+```
+
+###### Description
+
+Sets the new user handler for registered entity commands. This handler will be called whenever a command request arrives, with
+the following parameters: (`id`, `type`, `service`, `subservice`, `attributes`, `callback`). The handler must retrieve
+all the corresponding information from the devices and return a NGSI entity with the requested values.
+
+The callback must be invoked with the updated Context Element, using the information retrieved from the devices. E.g.:
+
+```javascript
+callback(null, {
+    type: "TheType",
+    isPattern: false,
+    id: "EntityID",
+    attributes: [
+        {
+            name: "lumniscence",
+            type: "Lumens",
+            value: "432"
+        }
+    ]
+});
+```
+
+In the case of NGSI requests affecting multiple entities, this handler will be called multiple times, one for each
+entity, and all the results will be combined into a single response.  Only IoT Agents which deal with actuator devices will include a handler for commands.
+
+###### Params
+
+-   newHandler: User handler for command requests.
+
+##### iotagentLib.setMergePatchHandler()
+
+###### Signature
+
+```javascript
+function setMergePatchHandler(newHandler)
+```
+
+###### Description
+
+Sets the new user handler for NGSI-LD Entity [merge-patch](https://datatracker.ietf.org/doc/html/rfc7386) requests. This handler will be called whenever a merge-patch request arrives, with
+the following parameters: (`id`, `type`, `service`, `subservice`, `attributes`, `callback`). The handler must retrieve
+all the corresponding information from the devices and return a NGSI entity with the requested values.
+
+The callback must be invoked with the updated Context Element, using the information retrieved from the devices. E.g.:
+
+```javascript
+callback(null, {
+    type: "TheType",
+    isPattern: false,
+    id: "EntityID",
+    attributes: [
+        {
+            name: "lumniscence",
+            type: "Lumens",
+            value: "432"
+        }
+    ]
+});
+```
+
+In the case of NGSI-LD requests affecting multiple entities, this handler will be
+called multiple times. Since merge-patch is an advanced function, not all IoT Agents
+will include a handler for merge-patch.
+
+###### Params
+
+-   newHandler: User handler for merge-patch requests.
+
 ##### iotagentLib.setProvisioningHandler()
 
 ###### Signature

package/lib/commonConfig.js

@@ -158,7 +158,9 @@ function processEnvironmentVariables() {
         'IOTA_DEFAULT_ENTITY_NAME_CONJUNCTION',
         'IOTA_JSON_LD_CONTEXT',
         'IOTA_FALLBACK_TENANT',
-        'IOTA_FALLBACK_PATH'
+        'IOTA_FALLBACK_PATH',
+        'IOTA_LD_SUPPORT_NULL',
+        'IOTA_LD_SUPPORT_DATASET_ID'
     ];
     const iotamVariables = [
         'IOTA_IOTAM_URL',
@@ -263,6 +265,18 @@ function processEnvironmentVariables() {
         config.server.port = process.env.IOTA_NORTH_PORT;
     }
 
+    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';
+    }
+    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) {
+        config.server.ldSupport.datasetId = process.env.IOTA_LD_SUPPORT_MERGE === 'true';
+    }
+
     if (process.env.IOTA_PROVIDER_URL) {
         config.providerUrl = process.env.IOTA_PROVIDER_URL;
     }

package/lib/constants.js

@@ -60,6 +60,7 @@ module.exports = {
     SUBSERVICE_HEADER: 'fiware-servicepath',
     NGSI_LD_TENANT_HEADER: 'NGSILD-Tenant',
     NGSI_LD_PATH_HEADER: 'NGSILD-Path',
+    NGSI_LD_NULL: 'urn:ngsi-ld:null',
     //FIXME: check Keystone support this in lowercase, then change
     AUTH_HEADER: 'X-Auth-Token',
     X_FORWARDED_FOR_HEADER: 'x-forwarded-for',

package/lib/fiware-iotagent-lib.js

@@ -323,6 +323,7 @@ exports.getConfigurationSilently = groupConfig.getSilently;
 exports.findConfiguration = groupConfig.find;
 exports.setDataUpdateHandler = contextServer.setUpdateHandler;
 exports.setCommandHandler = contextServer.setCommandHandler;
+exports.setMergePatchHandler = contextServer.setMergePatchHandler;
 exports.setDataQueryHandler = contextServer.setQueryHandler;
 exports.setConfigurationHandler = contextServer.setConfigurationHandler;
 exports.setRemoveConfigurationHandler = contextServer.setRemoveConfigurationHandler;

package/lib/services/devices/deviceService.js

@@ -363,6 +363,7 @@ function registerDevice(deviceObj, callback) {
                     deviceObj.type = deviceData.type;
                     deviceObj.staticAttributes = deviceData.staticAttributes;
                     deviceObj.commands = deviceData.commands;
+                    deviceObj.lazy = deviceData.lazy;
                     if ('timestamp' in deviceData && deviceData.timestamp !== undefined) {
                         deviceObj.timestamp = deviceData.timestamp;
                     }

package/lib/services/devices/registrationUtils.js

@@ -310,9 +310,11 @@ function sendRegistrationsNgsiLD(unregister, deviceData, callback) {
         return sendUnregistrationsNgsiLD(deviceData, callback);
     }
 
+    const operations = [];
     const properties = [];
     const lazy = deviceData.lazy || [];
     const commands = deviceData.commands || [];
+    const supportMerge = config.getConfig().server.ldSupport.merge;
 
     lazy.forEach((element) => {
         properties.push(element.name);
@@ -321,6 +323,16 @@ function sendRegistrationsNgsiLD(unregister, deviceData, callback) {
         properties.push(element.name);
     });
 
+    if (lazy.length > 0){
+        operations.push('retrieveOps');  
+    }
+    if (commands.length > 0){
+         operations.push('updateOps'); 
+    }
+    if (supportMerge){
+        operations.push('mergeEntity'); 
+    }
+
     if (properties.length === 0) {
         logger.debug(context, 'Registration with Context Provider is not needed. Device without lazy atts or commands');
         return callback(null, deviceData);
@@ -348,10 +360,18 @@ function sendRegistrationsNgsiLD(unregister, deviceData, callback) {
             information: [
                 {
                     entities: [{ type: deviceData.type, id }],
-                    properties
+                    propertyNames: properties
                 }
             ],
+            mode: 'exclusive',
+            operations,
             endpoint: config.getConfig().providerUrl,
+            contextSourceInfo: [
+                {
+                    'key': 'jsonldContext',
+                    'value': config.getConfig().contextBroker.jsonLdContext
+                }
+            ],
             '@context': config.getConfig().contextBroker.jsonLdContext
         },
         headers: {

package/lib/services/northBound/contextServer-NGSI-LD.js

@@ -31,6 +31,7 @@ const async = require('async');
 const apply = async.apply;
 const logger = require('logops');
 const errors = require('../../errors');
+const constants = require('../../constants');
 const deviceService = require('../devices/deviceService');
 const middlewares = require('../common/genericMiddleware');
 const _ = require('underscore');
@@ -41,11 +42,98 @@ const updateContextTemplateNgsiLD = require('../../templates/updateContextNgsiLD
 const notificationTemplateNgsiLD = require('../../templates/notificationTemplateNgsiLD.json');
 const contextServerUtils = require('./contextServerUtils');
 const ngsiLD = require('../ngsi/entities-NGSI-LD');
+const config = require('../../commonConfig');
 
 const overwritePaths = ['/ngsi-ld/v1/entities/:entity/attrs', '/ngsi-ld/v1/entities/:entity/attrs/:attr'];
 const updatePaths = ['/ngsi-ld/v1/entities/:entity/attrs', '/ngsi-ld/v1/entities/:entity/attrs/:attr'];
 const queryPaths = ['/ngsi-ld/v1/entities/:entity'];
 
+
+/**
+ * Replacement of NGSI-LD Null placeholders with real null values
+ *
+ */
+function replaceNGSILDNull(payload){
+    Object.keys(payload).forEach((key) =>{
+        const value = payload[key];
+        if ( value === constants.NGSI_LD_NULL){
+           payload[key] = null; 
+        } else if (typeof value === 'object' &&
+            !Array.isArray(value) &&
+            value !== null){
+            payload[key] = replaceNGSILDNull(payload[key]);
+        }
+    })
+    return  payload;
+}
+
+/**
+ * Check to see if the payload or its subattributes contain null values
+ *
+ */
+function containsNulls(payload, result){
+    Object.keys(payload).forEach((key) =>{
+        const value = payload[key];
+        if ( value === null){
+           result.nulls = true; 
+        } else if (typeof value === 'object' &&
+            !Array.isArray(value) &&
+            value !== null){
+            containsNulls(payload[key], result);
+        }
+    })
+    return  result;
+}
+
+/**
+ * An Express middleware for preprocessing NGSI-LD payloads. Converts NGSI-LD Nulls
+ * to real nulls and checks for the presence of null and datasetId
+ *
+ */
+function preprocessNGSILD(req, res, next){
+    res.locals.hasDatasetId =  false;
+    const payload = req.body
+    if (payload && typeof payload === 'object'){
+        Object.keys(payload).forEach((key) =>{
+            if (_.isArray(payload[key])){
+                payload[key].forEach((obj) => {
+                    if (obj.datasetId){
+                        res.locals.hasDatasetId = true;
+                    }
+                });
+            } else if (payload[key] && payload[key].datasetId && payload[key].datasetId !== '@none'){
+               res.locals.hasDatasetId = true;
+            } 
+        });
+        req.body = replaceNGSILDNull(payload);
+        const result = { nulls: false }
+        containsNulls(payload, result);
+        res.locals.hasNulls = result.nulls;
+    }
+    next();
+}
+
+/**
+ * A configurable Middleware that makes additional NGSI-LD checks within the payload.
+
+ *
+ * @param {Boolean} supportNull          Whether to support NGSI-LD nulls in the payload
+ * @param {Boolean} supportDatasetId     Whether to support multiattributes in the payload.
+ * @return {Object}            Express middleware used in request validation.
+ */
+function validateNGSILD(supportNull, supportDatasetId) {
+    return function validate(req, res, next) {
+        if (!supportNull && res.locals.hasNulls) {
+            next(new errors.BadRequest('NGSI-LD Null found within the payload. This IoT Agent does not support nulls for this endpoint.'));
+        } else if (!supportDatasetId && res.locals.hasDatasetId) {
+            next(new errors.BadRequest('datasetId found within the payload. This IoT Agent does not support multi-attribute requests.'));
+        } else {
+            next();
+        }
+    };
+}
+
+
 /**
  * Extract metadata attributes from input.
  *
@@ -318,6 +406,104 @@ function defaultQueryHandlerNgsiLD(id, type, service, subservice, attributes, ca
     });
 }
 
+/**
+ * Generate a merge-patch action corresponding to the request using NGSI-LD.
+ * Merge-patch is an NGSI-LD specific action.
+ *
+ * @param {Object} req                  Update request to generate Actions from
+ */
+function generateMergePatchActionNgsiLD(req, callback) {
+ 
+    const entityId = req.params.entity;
+
+       
+    function addAttributes(deviceData, body, attributes){
+        const keys = Object.keys(body);
+
+        for (const j in deviceData) {
+            if (keys.includes(deviceData[j].name)) {
+                const obj = body[deviceData[j].name]
+                if ( obj === null) {
+                    attributes.push({
+                        type: deviceData[j].type,
+                        value: null,
+                        name: deviceData[j].name
+                    });
+                } else {
+                     attributes.push({
+                        type: deviceData[j].type,
+                        value: obj.value,
+                        name: deviceData[j].name
+                    });
+                }
+            } 
+        }
+        return attributes;
+    }
+    
+
+    deviceService.getDeviceByName(
+        entityId,
+        contextServerUtils.getLDTenant(req),
+        contextServerUtils.getLDPath(req),
+        function (error, deviceObj) {
+            if (error) {
+                callback(error);
+            } else {
+                const attributes = [];
+                addAttributes(deviceObj.commands, req.body, attributes)
+                addAttributes(deviceObj.lazy, req.body, attributes)
+                const executeMergePatchHandler = apply(
+                    contextServerUtils.mergePatchHandler,
+                    entityId,
+                    deviceObj.type,
+                    contextServerUtils.getLDTenant(req),
+                    contextServerUtils.getLDPath(req),
+                    attributes
+                );
+                async.waterfall(
+                    [executeMergePatchHandler],
+                    callback()
+        );
+            }
+        }
+    );
+}
+
+/**
+ * Express middleware to manage incoming merge-patch requests using NGSI-LD.
+ *
+ * @param {Object} req              Request that was handled in first place.
+ * @param {Object} res              Response that will be sent.
+ */
+function handleMergePatchNgsiLD(req, res, next) {
+
+    function handleMergePatchRequest(error, result) {
+        if (error) {
+            logger.debug(context, 'There was an error handling the merge-patch: %s.', error);
+            next(error);
+        } else {
+            logger.debug(context, 'Merge-patch from [%s] handled successfully.', req.get('host'));
+            res.status(200).json(result);
+        }
+    }
+
+    logger.debug(context, 'Handling merge-patch from [%s]', req.get('host'));
+    if ((req.is('json') || req.is('application/ld+json')) === false) {
+        return handleMergePatchRequest(new errors.UnsupportedContentType(req.header('content-type')));
+    }
+    
+    if (req.body) {
+        logger.debug(context, JSON.stringify(req.body, null, 4));
+    }
+
+    if (contextServerUtils.mergePatchHandler){
+        generateMergePatchActionNgsiLD(req, handleMergePatchRequest);
+    } else {
+       return handleMergePatchRequest(new errors.MethodNotSupported(req.method, req.path)) 
+    }
+}
+
 /**
  * Express middleware to manage incoming query context requests using NGSI-LD.
  *
@@ -489,19 +675,21 @@ function handleQueryNgsiLD(req, res, next) {
  * @param {Object} req              Request that was handled in first place.
  * @param {Object} res              Response that will be sent.
  */
-function queryErrorHandlingNgsiLD(error, req, res, next) {
-    let code = 500;
+function ErrorHandlingNgsiLD(action) {
+    return function errorHandle(error, req, res, next) {
+        let code = 500;
 
-    logger.debug(context, 'Query NGSI-LD error [%s] handling request: %s', error.name, error.message);
+        logger.debug(context, action + ' NGSI-LD error [%s] handling request: %s', error.name, error.message);
 
-    if (error.code && String(error.code).match(/^[2345]\d\d$/)) {
-        code = error.code;
-    }
+        if (error.code && String(error.code).match(/^[2345]\d\d$/)) {
+            code = error.code;
+        }
 
-    res.status(code).json({
-        error: error.name,
-        description: error.message.replace(/[<>\"\'=;\(\)]/g, '')
-    });
+        res.status(code).json({
+            error: error.name,
+            description: error.message.replace(/[<>\"\'=;\(\)]/g, '')
+        });
+    }
 }
 
 /**
@@ -601,28 +789,6 @@ function handleNotificationNgsiLD(req, res, next) {
     }
 }
 
-/**
- * Error handler for NGSI-LD update requests.
- *
- * @param {Object} error            Incoming error
- * @param {Object} req              Request that was handled in first place.
- * @param {Object} res              Response that will be sent.
- */
-function updateErrorHandlingNgsiLD(error, req, res, next) {
-    let code = 500;
-
-    logger.debug(context, 'Update NGSI-LD error [%s] handing request: %s', error.name, error.message);
-
-    if (error.code && String(error.code).match(/^[2345]\d\d$/)) {
-        code = error.code;
-    }
-
-    res.status(code).json({
-        error: error.name,
-        description: error.message.replace(/[<>\"\'=;\(\)]/g, '')
-    });
-}
-
 /**
  * Load unsupported NGSI-LD entity routes and return proper NGSI-LD not supported responses
  *
@@ -645,36 +811,53 @@ function loadUnsupportedEndpointsNGSILD(router) {
  */
 function loadContextRoutesNGSILD(router) {
     // In a more evolved implementation, more endpoints could be added to queryPathsNgsi2
-    // according to http://fiware.github.io/specifications/ngsiv2/stable.
-
+    // according to https://www.etsi.org/standards-search#page=1&search=GS%20CIM%20009
+    
+    const support = config.getConfig().server.ldSupport;
     let i;
 
     logger.info(context, 'Loading NGSI-LD Context server routes');
+    // Update Patch endpoints - this endpoint may accept NGSI-LD Null
     for (i = 0; i < updatePaths.length; i++) {
         router.patch(updatePaths[i], [
             middlewares.ensureType,
             middlewares.validateJson(updateContextTemplateNgsiLD),
+            preprocessNGSILD,
+            validateNGSILD(support.null, support.datasetId),
             handleUpdateNgsiLD,
-            updateErrorHandlingNgsiLD
+            ErrorHandlingNgsiLD('Partial Update')
         ]);
     }
+    // Merge Patch endpoints - this endpoint may accept NGSI-LD Null
+    router.patch('/ngsi-ld/v1/entities/:entity', [
+        preprocessNGSILD,
+        validateNGSILD(support.null, support.datasetId),
+        handleMergePatchNgsiLD, 
+        ErrorHandlingNgsiLD('Merge-Patch')
+    ]);
 
+    // Overwrite/PUT endpoints - this endpoint does not accept NGSI-LD Null
     for (i = 0; i < overwritePaths.length; i++) {
         router.put(overwritePaths[i], [
             middlewares.ensureType,
             middlewares.validateJson(updateContextTemplateNgsiLD),
+            preprocessNGSILD,
+            validateNGSILD(false, support.datasetId),
             handleUpdateNgsiLD,
-            updateErrorHandlingNgsiLD
+            ErrorHandlingNgsiLD('Overwrite')
         ]);
     }
+    // Query/GET endpoints - no payload to check.
     for (i = 0; i < queryPaths.length; i++) {
-        router.get(queryPaths[i], [handleQueryNgsiLD, queryErrorHandlingNgsiLD]);
+        router.get(queryPaths[i], [handleQueryNgsiLD, ErrorHandlingNgsiLD('Query')]);
     }
     router.post('/notify', [
         middlewares.ensureType,
         middlewares.validateJson(notificationTemplateNgsiLD),
+        preprocessNGSILD,
+        validateNGSILD(false, support.datasetId),
         handleNotificationNgsiLD,
-        queryErrorHandlingNgsiLD
+        ErrorHandlingNgsiLD('Notify')
     ]);
     loadUnsupportedEndpointsNGSILD(router);
 }

package/lib/services/northBound/contextServer.js

@@ -64,7 +64,7 @@ function setUpdateHandler(newHandler) {
 }
 
 /**
- * Sets the new user handler for commadn execution requests. This handler will be called whenever an update request
+ * Sets the new user handler for command execution requests. This handler will be called whenever an update request
  * arrives to a with the following parameters: (id, type, attributes, callback). The callback is in charge of updating
  * the corresponding values in the devices with the appropriate protocol.
  *
@@ -77,6 +77,18 @@ function setCommandHandler(newHandler) {
     contextServerUtils.commandHandler = newHandler;
 }
 
+/**
+ * Sets the new user handler for NGSI-LD merge-patch requests. This handler will be called whenever an update request
+ * arrives to a with the following parameters: (id, type, attributes, callback). The callback is in charge of updating
+ * the corresponding values in the devices with the appropriate protocol.
+ *
+ *
+ * @param {Function} newHandler         User handler for update requests
+ */
+function setMergePatchHandler(newHandler) {
+    contextServerUtils.mergePatchHandler = newHandler;
+}
+
 /**
  * Sets the new user handler for Entity query requests. This handler will be called whenever an update request arrives
  * with the following parameters: (id, type, attributes, callback). The handler must retrieve all the corresponding
@@ -140,6 +152,7 @@ function clear(callback) {
 exports.clear = clear;
 exports.loadContextRoutes = intoTrans(context, loadContextRoutes);
 exports.setUpdateHandler = intoTrans(context, setUpdateHandler);
+exports.setMergePatchHandler = intoTrans(context, setMergePatchHandler);
 exports.setCommandHandler = intoTrans(context, setCommandHandler);
 exports.setNotificationHandler = intoTrans(context, setNotificationHandler);
 exports.addNotificationMiddleware = intoTrans(context, addNotificationMiddleware);

package/lib/services/northBound/northboundServer.js

@@ -110,6 +110,7 @@ function clear(callback) {
     async.series([deviceProvisioning.clear, groupProvisioning.clear, contextServer.clear], callback);
 }
 
+exports.setMergePatchHandler = intoTrans(context, contextServer.setMergePatchHandler);
 exports.setUpdateHandler = intoTrans(context, contextServer.setUpdateHandler);
 exports.setQueryHandler = intoTrans(context, contextServer.setQueryHandler);
 exports.setCommandHandler = intoTrans(context, contextServer.setCommandHandler);

package/package.json

@@ -2,7 +2,7 @@
   "name": "iotagent-node-lib",
   "license": "AGPL-3.0-only",
   "description": "IoT Agent library to interface with NGSI Context Broker",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "homepage": "https://github.com/telefonicaid/iotagent-node-lib",
   "keywords": [
     "fiware",

package/test/unit/memoryRegistry/deviceRegistryMemory_test.js

@@ -241,7 +241,7 @@ describe('NGSI-v2 - In memory device registry', function () {
                 should.exist(device.type);
                 device.name.should.equal('name5');
                 device.type.should.equal('Light5');
-                Object.keys(device).length.should.equal(11);
+                Object.keys(device).length.should.equal(12);
                 done();
             });
         });