@sap/xsodata 7.5.5 → 8.0.0

package/CHANGELOG.md

@@ -8,6 +8,12 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ## Unreleased
 
+## [8.0.0] - 2022-08-04
+
+* HANA Cloud database support added
+* Public synonym support added
+* Update module dependencies
+
 ## [7.5.5] - 2022-04-21
 
 * On calc view: Stable sort order with $skip and $top usage for subsequent requests via "order by" of key fields in SQL statement

package/lib/db/connect.js

@@ -1,4 +1,5 @@
 'use strict';
+
 /**
  * Add  <db> attribute to <context>
  * Uses <context>.<handlerConfiguration.dbConfiguration>
@@ -60,13 +61,48 @@ function loadDbVersion(context, asyncDone) {
             context.logger.info('xsodata', 'db version: ' + version);
             context.gModel.setDbVersion(version);
         } else {
-            context.gModel.setDbVersion(null); // don't try reload
+            context.gModel.setDbVersion(null);  // don't try reload
+        }
+
+        return asyncDone(null, context);
+    });
+}
+
+function setHanaCloudContext(context, asyncDone) {
+
+    return context.db.client.exec('select version from "SYS"."M_DATABASE"', function (err, rows) {
+        if (err) {
+            return asyncDone(new SqlError(context, err), context);
+        }
+
+        if (rows && rows[0] && rows[0].VERSION) {
+            const version = rows[0].VERSION;
+            context.logger.info('xsodata', 'db version: ' + version);
+            context.db.isHanaCloudDb = isHanaCloudDb(context, rows[0].VERSION);
+            context.logger.info('xsodata', `isHanaCloud: ${context.db.isHanaCloudDb} (DB version based)`);
+        } else {
+            // 06/2022:
+            // Currently all SQL from Hana Cloud work also on Hana Service, i.e. take that version as default;
+            // could be changed in the future, i.e. using the context setting of 'context.db.isHanaCloudDb'
+            context.db.isHanaCloudDb = true;
+            context.logger.info('xsodata', `isHanaCloud: ${context.db.isHanaCloudDb} (default)`);
         }
 
         return asyncDone(null, context);
     });
 }
 
+function isHanaCloudDb(context, version) {
+    const regex = /^([0-9])+\..*$/;
+    let result = version.match(regex);
+
+    if (result && result[1]) {
+        return (result[1] >= 4);
+    } else {
+        context.logger.error(`DB Version parsing failed: ${version}`);
+        return true;        // default: Hana Cloud
+    }
+}
 
 function getDbClientType(dbClient) {
     if (dbClient._settings) {
@@ -97,6 +133,8 @@ function prepareConnection(context, asyncDone) {
     // Set the isolation level
     executeList.push(utils.tryAndMeasure(execSQL, 'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ', 'execSQL (isolation level)'));
     executeList.push(loadDbVersion);
+    // Set Hana Cloud indicator in context
+    executeList.push(setHanaCloudContext);
 
     async.waterfall(
         executeList,
@@ -163,9 +201,6 @@ function _connectInternal(context, asyncDone) {
 
 
     try {
-        context.logger.silly('connect - db', 'use hdb.createClient');
-
-
         let db_module = null;
 
         if (context.handlerConfiguration.dbClient === 'hdb') {
@@ -173,11 +208,13 @@ function _connectInternal(context, asyncDone) {
                 hdb_module = require('hdb');
             }
             db_module = hdb_module;
+            context.logger.silly('connect - db', 'use hdb.createClient');
         } else {
             if (!hana_client_module) {
                 hana_client_module = require('@sap/hana-client');
             }
             db_module = hana_client_module;
+            context.logger.silly('connect - db', 'use hana-client');
         }
 
 
@@ -250,6 +287,7 @@ exports.connect = function (context, asyncDone) {
         }
         context.logger.debug('connect - db', 'connection is usable');
         context.db.connectionInitialized = true;
+        context.logger.debug('connect - context setting - Is Hana Cloud used?', `${context.db.isHanaCloudDb}`);
         return asyncDone(null, context);
 
     });

package/lib/model/entityType.js

@@ -43,6 +43,12 @@ function EntityType(entityType, settings) {
     this.path = this._entityType.path;
     this.keys = determineKeys(this._entityType);
 
+    // virtual table / virtual view data (includes synonyms + virtual tables)
+    this._isVirtual = false;
+    this._virtualObjectSchema = null;
+    this._virtualObjectName = null;
+    this._remoteSource = null;
+
     // in .xsodata as "entityname" --> null
     // in .xsodata as "entityname" concurrencytoken; --> {}
     // in .xsodata as "entityname" concurrencytoken ("KEY"); --> { key : true }
@@ -107,6 +113,12 @@ function EntityType(entityType, settings) {
     this._admindata = prepareAdmindata(this._settings.admindata, this._entityType.admindata);
 }
 
+EntityType.prototype.setVirtualInfo = function(objectSchema, objectName, remoteSource = null) {
+    this._isVirtual = true;
+    this._virtualObjectSchema = objectSchema;
+    this._virtualObjectName = objectName;
+    this._remoteSource = remoteSource;
+};
 
 function mergeAdmindataTuples(into, data) {
     for (const tuple of data) {

package/lib/model/metadataReader.js

@@ -44,11 +44,15 @@ function loadKeysForTable(context, entityType, cb) {
         return cb(null, entityType);
     };
 
-    var schema = entityType.schema || context.defaultSchema;
-
-    var sql =
-        "SELECT * from CONSTRAINTS " +
-        "WHERE SCHEMA_NAME = '" + schema + "' AND TABLE_NAME = '" + entityType.tableName + "' AND IS_PRIMARY_KEY = 'TRUE' ORDER BY position";
+    let sql = "";
+    if (entityType._isVirtual) {
+        sql =
+            "select * from " + (entityType._remoteSource ? "\"" + entityType._remoteSource + "\".\"SYS\".\"CONSTRAINTS\"" : "\"SYS\".\"CONSTRAINTS\" " ) +
+            "WHERE SCHEMA_NAME = '" + entityType._virtualObjectSchema + "' AND TABLE_NAME = '" + entityType._virtualObjectName + "' AND IS_PRIMARY_KEY = 'TRUE' ORDER BY position";
+    } else {
+        let schema = entityType.schema || context.defaultSchema;
+        sql = "SELECT * from CONSTRAINTS WHERE SCHEMA_NAME = '" + schema + "' AND TABLE_NAME = '" + entityType.tableName + "' AND IS_PRIMARY_KEY = 'TRUE' ORDER BY position";
+    }
     dataCollector2.executeSqlDirectly(context, sql, processRows);
 }
 
@@ -104,13 +108,13 @@ function loadTableInfo(context, entityType, tableStoreType, cb) {
         }
     };
 
-    context.logger.silly("model", "loadTableInfo 2");
-    var schema = entityType.schema || context.defaultSchema;
-    // entityType.table is either a real table or a SQL view
-    // So we need to lookup both: sys.table_columns and sys.view_columns
-    // sys.columns is not usable due to access restrictions
-    var sql =
+    let schema = "";
+    let parameters = [];
 
+    // entityType.table is either a real table or a SQL view;
+    // so we need to lookup both: sys.table_columns and sys.view_columns (if set: check via "remote source");
+    // sys.columns is not usable due to access restrictions
+    let sql =
         "SELECT " +
         "   TO_BIGINT(" + model.entityKind.table + ") kind, " +
         "   table_name, " +
@@ -121,7 +125,7 @@ function loadTableInfo(context, entityType, tableStoreType, cb) {
         "   length, " +
         "   scale, " +
         "   default_value " +
-        "FROM TABLE_COLUMNS " +
+        "FROM " + (entityType._remoteSource ? "\"" + entityType._remoteSource + "\"" + ".\"SYS\".\"TABLE_COLUMNS\"" : "TABLE_COLUMNS ") +
         "WHERE  schema_name = ? AND " +
         "       table_name = ? " +
         "UNION ALL " +
@@ -135,13 +139,17 @@ function loadTableInfo(context, entityType, tableStoreType, cb) {
         "   length, " +
         "   scale, " +
         "   default_value " +
-        "FROM VIEW_COLUMNS " +
+        "FROM " + (entityType._remoteSource ? "\"" + entityType._remoteSource + "\"" + ".\"SYS\".\"VIEW_COLUMNS\"" : "VIEW_COLUMNS ") +
         "WHERE  schema_name = ? AND " +
         "       view_name = ?  " +
         "ORDER BY position";
 
-    var parameters = [schema, entityType.tableName, schema, entityType.tableName];
-
+    if (entityType._isVirtual) {
+        parameters = [entityType._virtualObjectSchema, entityType._virtualObjectName, entityType._virtualObjectSchema, entityType._virtualObjectName];
+    } else {
+        schema = entityType.schema || context.defaultSchema;
+        parameters = [schema, entityType.tableName, schema, entityType.tableName];
+    }
     context.logger.silly("model", "sql loadTableInfo: " + sql);
     context.logger.silly("model", "sql parameters: " + parameters);
     dataCollector2.executeSqlAsPreparedStatement(context, sql, parameters, processRows);
@@ -151,26 +159,26 @@ function loadCalcViewInfo(context, entityType, cb) {
     /*
      Remark : it is not possible(or at least i was not able to) to execute a JOIN in a MDX SELECT
      */
-    var schema = entityType.schema || context.defaultSchema;
-    var sql = 'select ' +
-        'SCHEMA_NAME,' +
-        'QUALIFIED_NAME,' +
-        'CATALOG_NAME,' +
-        'CUBE_NAME,' +
-        'COLUMN_NAME,' +           // JOIN ON
-        'MEASURE_AGGREGATOR,' +    // 1, 2, 3, 4 in sync with entityType.CV_AGGREGATE_FUNCTIONS
-        'MEASURE_AGGREGATABLE, ' +
-        'SEMANTIC_TYPE, ' +
-        'COLUMN_CAPTION, ' +
-        'DIMENSION_TYPE, ' +
-        'UNIT_COLUMN_NAME, ' +
-        'DESC_NAME, ' +
-        '"ORDER" ' +
-        "from _SYS_BI.BIMC_DIMENSION_VIEW_HDI " +
+    let schema = entityType.schema || context.defaultSchema;
+    let sql =
+        'select ' +
+            'SCHEMA_NAME,' +
+            'QUALIFIED_NAME,' +
+            'CATALOG_NAME,' +
+            'CUBE_NAME,' +
+            'COLUMN_NAME,' +           // JOIN ON
+            'MEASURE_AGGREGATOR,' +    // 1, 2, 3, 4, 5 in sync with entityType.CV_AGGREGATE_FUNCTIONS
+            'MEASURE_AGGREGATABLE, ' +
+            'SEMANTIC_TYPE, ' +
+            'COLUMN_CAPTION, ' +
+            'DIMENSION_TYPE, ' +
+            'UNIT_COLUMN_NAME, ' +
+            'DESC_NAME, ' +
+            '"ORDER" ' +
+        "from " + (entityType._remoteSource ? "\"" + entityType._remoteSource + "\"" + ".\"_SYS_BI\".\"BIMC_DIMENSION_VIEW_HDI\"" : "_SYS_BI.BIMC_DIMENSION_VIEW_HDI ") +
         "where SCHEMA_NAME = ? AND QUALIFIED_NAME = ? " +
         'order by "ORDER"';
 
-
     function processRows(err, rows) {
         if (logMetadata) {
             context.logger.silly('metadataReader', 'rows\n' + JSON.stringify(rows, null, 4));
@@ -232,27 +240,37 @@ function loadCalcViewInfo(context, entityType, cb) {
      The current HANA version has a bug, and prepared statements are not working in mdx select.
      Hence i replaced prepared statement with direct sql statement.
     */
-    var parameters = [schema, entityType.tableName];
+
+    let parameters = [];
+    if (entityType._isVirtual) {
+        // CV information must be read from the remote database;
+        // no such concept of "virtual" CV data in local database as it is the case for tables
+        parameters = [entityType._virtualObjectSchema, entityType._virtualObjectName];
+    } else {
+        parameters = [schema, entityType.tableName];
+    }
     dataCollector2.executeSqlAsPreparedStatement(context, sql, parameters, processRows);
 }
 
 function loadInputParameters(parameters, entityType, context, cb) {
-    // At the time this sql was developed SCHEMA_NAME == NULL
-    var sql = 'select distinct ' +
-        'VARIABLE_NAME, ' +
-        'COLUMN_TYPE_D, ' +
-        'COLUMN_SQL_TYPE, ' +
-        'MANDATORY, ' +
-        'DESCRIPTION, ' +
-        'DEFAULT_VALUE, ' +
-        'SEMANTIC_TYPE, ' +
-        'SELECTION_TYPE, ' +
-        'MULTILINE, ' +
-        '"ORDER" ' +
-        'from _SYS_BI.BIMC_VARIABLE_VIEW_HDI where QUALIFIED_NAME = ? order by "ORDER"';
+
+    let sql =
+        'select distinct ' +
+            'VARIABLE_NAME, ' +
+            'COLUMN_TYPE_D, ' +
+            'COLUMN_SQL_TYPE, ' +
+            'MANDATORY, ' +
+            'DESCRIPTION, ' +
+            'DEFAULT_VALUE, ' +
+            'SEMANTIC_TYPE, ' +
+            'SELECTION_TYPE, ' +
+            'MULTILINE, ' +
+            '"ORDER" ' +
+        'from ' + (entityType._remoteSource ? '"' + entityType._remoteSource + '"' + '"_SYS_BI"."BIMC_VARIABLE_VIEW_HDI"' : '_SYS_BI.BIMC_VARIABLE_VIEW_HDI ') +
+        'where QUALIFIED_NAME = ? order by "ORDER"';
 
     context.logger.debug('metadataReader', 'loadInputParameters: ' + entityType.tableName);
-    context.logger.silly("metadataReader", "sql loadInputParameters: " + sql);
+    context.logger.debug("metadataReader", "sql loadInputParameters: " + sql);
 
     dataCollector2.executeSqlAsPreparedStatement(context, sql, [entityType.tableName], (err, rows) => {
 
@@ -459,17 +477,127 @@ function loadEntityType(context, entityType, cbErr) {
  * @param {Function} callback - callback function, which is called when the operation is completed.
  */
 function determineStoreType(context, entityType, callback) {
-    var schema = entityType.schema || context.defaultSchema,
+
+    let schema = entityType.schema || context.defaultSchema,
         sql = 'select IS_COLUMN_TABLE as "IS_COLUMN_TYPE" from TABLES where SCHEMA_NAME = ? AND TABLE_NAME = ? ' +
-            'union select IS_COLUMN_VIEW as "IS_COLUMN_TYPE" from VIEWS where SCHEMA_NAME = ? AND VIEW_NAME = ?',
+              'union select IS_COLUMN_VIEW as "IS_COLUMN_TYPE" from VIEWS where SCHEMA_NAME = ? AND VIEW_NAME = ?',
         tableName = entityType.tableName,
         parameters = [schema, tableName, schema, tableName];
 
-    context.logger.silly("model", "sql determineStoreType: " + sql);
-    context.logger.silly("model", "sql determineStoreType parameters: " + parameters);
+    context.logger.debug("model", "sql determineStoreType: " + sql);
+    context.logger.debug("model", "sql determineStoreType parameters: " + parameters);
 
     dataCollector2.executeSqlAsPreparedStatement(context, sql, parameters, (error, rows) => {
-        return processTableType(error, rows, context, tableName, callback);
+
+        if (error) {
+            return callback(new SqlError(context, error));
+        }
+
+        // if no error and no rows are returned: check for public synonym;
+        // if a virtual table is used (includes remote tables and remote views / CVs), we got a row back here!
+        if (rows.length === 0) {
+            context.logger.debug("model", `No table/view information found for ${tableName}. Try public synonym.`);
+            processSynonymTableType(context, entityType, tableName, (synonymErr, synonymFound, tableStoreType) => {
+                if (synonymErr) {
+                    return callback(synonymErr);
+                }
+                if (synonymFound) {
+                    return callback(null, tableStoreType);
+                }
+                return callback(new NotFound(`No table/view or synonym data found for table ${tableName}.`, context));
+            });
+        } else {
+            // check for virtual table; add VT data for entity type, if existing
+            let virtualTableSQL = "select * from SYS.VIRTUAL_TABLES where schema_name = ? and table_name = ?";
+            let virtualTableParameters = [schema, tableName];
+            context.logger.info("model", `Check for virtual table for ${tableName}`);
+            dataCollector2.executeSqlAsPreparedStatement(context, virtualTableSQL, virtualTableParameters, (sqlError, virtualTableRows) => {
+                if (sqlError) {
+                    context.logger.error("model", `Failed read data for virtual table: ${tableName}` + sqlError);
+                    return callback(new SqlError(context, sqlError));
+                }
+                if (virtualTableRows.length !== 0) {
+                    entityType.setVirtualInfo(
+                        virtualTableRows[0].REMOTE_OWNER_NAME,
+                        virtualTableRows[0].REMOTE_OBJECT_NAME,
+                        virtualTableRows[0].REMOTE_SOURCE_NAME );
+                    context.logger.info("model", `(Remote) Virtual table information for table ${tableName}`);
+                    context.logger.info("model", `Remote schema: ${virtualTableRows[0].REMOTE_OWNER_NAME}`);
+                    context.logger.info("model", `Remote object: ${virtualTableRows[0].REMOTE_OBJECT_NAME}`);
+                    context.logger.info("model", `Remote source: ${virtualTableRows[0].REMOTE_SOURCE_NAME}`);
+                } else {
+                    context.logger.info("model", `No virtual table information exists for ${tableName}`);
+                }
+                // use data already found from TABLES / VIEWS for setting store type
+                return processTableType(error, rows, context, tableName, callback);
+            });
+        }
+    });
+}
+
+function processSynonymTableType(context, entityType, tableName, callback) {
+
+    const synonymSql = `select * from SYNONYMS where SCHEMA_NAME = 'PUBLIC' AND SYNONYM_NAME = '${tableName}'`;
+
+    dataCollector2.executeSqlDirectly(context, synonymSql, (synonymErr, synonymRows) => {
+        if (synonymErr) {
+            context.logger.error("model", "Failed to read synonym: " + synonymErr);
+            return callback(new SqlError(context, synonymErr), false, null);
+        }
+        if (synonymRows.length === 0) {
+            return callback(null, false, null);     // not a synonym
+        }
+        if (synonymRows.length !== 1) {
+            context.logger.error("model", "No (unique) synonym data found for " + tableName + " table.");
+            return callback(new NotFound("No (unique) synonym data found for " + tableName + " table.", context), false, null);
+        }
+
+        // check for local or remote synonym
+        if (synonymRows[0].OBJECT_SCHEMA === '_SYS_LDB') {      // remote synonym
+
+            const virtualTableName = synonymRows[0].OBJECT_NAME;
+            const virtualTableSql = `select * from VIRTUAL_TABLES where SCHEMA_NAME = '_SYS_LDB' and TABLE_NAME = '${virtualTableName}'`;
+
+            context.logger.info("model", `Checking virtual tables for remote synonym information for table ${virtualTableName}`);
+
+            // get remote source
+            dataCollector2.executeSqlDirectly(context, virtualTableSql, (virtualTableErr, virtualTableRows) => {
+                if (virtualTableErr) {
+                    context.logger.error("model", `Failed to read virtual table ${virtualTableName} for synonym ${tableName}:  ${virtualTableErr}`);
+                    return callback(new SqlError(context, virtualTableErr), false, null);
+                }
+
+                context.logger.info("model", `(Remote) Virtual table information for synonym ${tableName} via table ${virtualTableName}`);
+                context.logger.info("model", `Remote schema: ${virtualTableRows[0].REMOTE_OWNER_NAME}`);
+                context.logger.info("model", `Remote object: ${virtualTableRows[0].REMOTE_OBJECT_NAME}`);
+                context.logger.info("model", `Remote source: ${virtualTableRows[0].REMOTE_SOURCE_NAME}`);
+
+                entityType.setVirtualInfo(
+                    virtualTableRows[0].REMOTE_OWNER_NAME,      // remote schema name
+                    virtualTableRows[0].REMOTE_OBJECT_NAME,     // remote object name
+                    virtualTableRows[0].REMOTE_SOURCE_NAME);    // remote source
+
+                // in SYNONYMS, each remote object has always the setting IS_COLUMN_OBJECT === FALSE (keep it as is)
+                let isColumnStoreType = synonymRows[0].IS_COLUMN_OBJECT;
+                let tableStoreType = isColumnStoreType === "TRUE" ? "column" : "row";
+                return callback(null, true, tableStoreType);
+            });
+
+        } else {    // local synonym
+
+            context.logger.info("model", `(Local) Synonym information for ${synonymRows[0].SYNONYM_NAME}`);
+            context.logger.info("model", `Local schema: ${synonymRows[0].OBJECT_SCHEMA}`);
+            context.logger.info("model", `Local object: ${synonymRows[0].OBJECT_NAME}`);
+
+            entityType.setVirtualInfo(
+                synonymRows[0].OBJECT_SCHEMA,       // local schema name
+                synonymRows[0].OBJECT_NAME);        // local object name
+
+            // in SYNONYMS, a local object has the "correct" store type setting
+            let isColumnObjectType = synonymRows[0].IS_COLUMN_OBJECT;
+            let tableStoreType = isColumnObjectType === "TRUE" ? "column" : "row";
+            return callback(null, true, tableStoreType);
+        }
     });
 }
 
@@ -487,7 +615,7 @@ function processTableType(error, dbRows, context, tableName, callback) {
         tableStoreType;
 
     if (error) {
-        return callback(new SqlError(context, error));
+        return (error instanceof SqlError) ? callback(error) : callback(new SqlError(context, error));
     }
 
     if (dbRows.length === 0) {
@@ -497,6 +625,8 @@ function processTableType(error, dbRows, context, tableName, callback) {
         context.logger.silly("processTableType", "rows:\n" + JSON.stringify(dbRows, null, 4));
     }
 
+    // if found table is a virtual (remote) table, the IS_COLUMN_TYPE is always set to FALSE,
+    // but this setting does not affect SQL processing (joins on temp. tables)
     isColumnStoreType = dbRows[0].IS_COLUMN_TYPE;
 
     // HANA returns "TRUE"/"FALSE" as a string and not as a boolean value
@@ -592,6 +722,9 @@ exports.loadModelMetadata = function (context, asyncDone) {
             }
         },
         function (err) {
+            if (err) {
+                context.logger.error('model', `Error on loadEntityTypes for ${context.uriTree.xsoFile}:` + err);
+            }
             context.logger.silly('model', 'loadEntityTypes finished for ' + context.uriTree.xsoFile);
             return asyncDone(err, context);
         }

package/lib/model/xsodataReader.js

@@ -182,7 +182,7 @@ function checkSchema(context, asyncDone) {
     entityTypes = parsedXsodata.service.entityTypes;
 
 
-    // Run through entityTypes and check if navigates peroperty id provided
+    // Run through entityTypes and check if navigates property id provided
     for (key in entityTypes) {
         if (entityTypes.hasOwnProperty(key) === true) {
 

package/lib/processor/batchProcessor.js

@@ -148,15 +148,15 @@ function processChangeSet(batchContext, part, asyncDone) {
 
             utils.try(collectContentIds),
 
-            utils.try(processChangeSetPartsCreateTable),
+            utils.try(processChangeSetPartsCreateTable),    // for *ALL* operations of current changeset: create all temp. tables once at beginning
 
-            utils.try(processChangeSetParts),
+            utils.try(processChangeSetParts),               // execute all operations
 
-            utils.try(processChangeSetPartsPreCommit),
+            utils.try(processChangeSetPartsPreCommit),      // mainly custom-exit processing (pre-commit exit)
 
-            utils.try(processChangeSetPartsCommit),
+            utils.try(processChangeSetPartsCommit),         // all changes of operations are committed
 
-            utils.try(processChangeSetPartsPostCommit)
+            utils.try(processChangeSetPartsPostCommit)      // mainly custom-exit processing (post-commit exit)
 
         ], function (err, batchContext) {
             if (!err) {
@@ -220,7 +220,7 @@ function processAppWithState(app, state, batchContext, asyncDone) {
 
 function processPart(batchContext, part, asyncDone) {
     batchContext.logger.silly('batchProcessor', 'processPart');
-    if (part.type === 'app') {
+    if (part.type === 'app') {                      // processing a batch single operation (not in changeset)
         async.waterfall(
             [
                 utils.injectContext(batchContext),
@@ -288,7 +288,7 @@ exports.process = function (context, asyncDone) {
     var batchContext = {
         parentContext: context,
         logger: context.logger,
-        callRegisteredStep : context.callRegisteredStep, // pass to inner context
+        callRegisteredStep : context.callRegisteredStep,    // pass to inner context
         inChangeSet: false,
         batchData: null,
         batchParsed: null,

package/lib/processor/processor.js

@@ -21,15 +21,15 @@ exports.processRequest = function (context, asyncDone) {
         } else if (oData.kind === odataUri.URI_KIND_MetaData) {
             Measurement.measureWithCB(metadataProcessor.process, context, asyncDone, 'metadataProcessor.process');
         } else if (oData.kind === odataUri.URI_KIND_Batch) {
-            Measurement.measureWithCB(batchProcessor.process, context, asyncDone, 'batchProcessor.process');
+            Measurement.measureWithCB(batchProcessor.process, context, asyncDone, 'batchProcessor.process');        // $batch-request itself
         } else if (oData.kind === odataUri.URI_KIND_Resource) {
 
             if (!context.batchContext) {
-                //normal no batch request processing
+                // regular request processing
                 Measurement.measureWithCB(resourceProcessor.process, context, asyncDone, 'resourceProcessor.process');
             } else {
-                var batchContext = context.batchContext;
-                if (batchContext.status === batchRunState.createTables) {
+                var batchContext = context.batchContext;                            // $batch-request: operation processing (based on status)
+                if (batchContext.status === batchRunState.createTables) {           // on batch changes: all temp. tables of all operations are generated at beginning batch
                     Measurement.measureWithCB(resourceProcessor.processInBatchCreateTables, context, asyncDone, 'processInBatchCreateTables');
                 }else if (batchContext.status === batchRunState.execution) {
                     Measurement.measureWithCB(resourceProcessor.processInBatch, context, asyncDone, 'processInBatch');

package/lib/sql/createDeleteLinksStatements.js

@@ -22,7 +22,14 @@ exports.createDeleteLinksMNStatementsCreateTmpTables = function (context, asyncD
     context.sql = sqlContext;
     dbSegLast.sql.stmContainer = new sql.PostContainer();
 
-    createMNDeleteStatementContainerCreateTmpTables (sqlContext);
+    // set Hana Cloud / Service context in SQL context; default == cloud
+    let isHanaCloudDb = true;
+    if (context.db !== undefined && context.db.isHanaCloudDb !== undefined) {
+        isHanaCloudDb = context.db.isHanaCloudDb;
+    }
+    context.sql.isHanaCloudDb = isHanaCloudDb;
+
+    createMNDeleteStatementContainerCreateTmpTables(sqlContext);
     return asyncDone(null, context);
 };
 

package/lib/sql/createDeleteStatements.js

@@ -8,7 +8,7 @@ exports.createDeleteStatementsForCreateTmpTables = function (context, asyncDone)
 
     context.logger.silly('createDeleteStatements', 'createDeleteStatementsForCreateTmpTables');
 
-    var sqlContext = {
+    const sqlContext = {
         context: context,
         netId: context.uniqueNetworkRequestID,
         reqId: context.uniqueRequestID,

package/lib/sql/createGetStatements.js

@@ -23,6 +23,7 @@ exports._masterTableInsert = masterTableInsert;
  * @returns {*}
  */
 exports.createGetSqlStatements = function (context, asyncDone) {
+
     var sqlContext = context.sql = {
         netId: context.uniqueNetworkRequestID,
         reqId: context.uniqueRequestID,
@@ -54,8 +55,6 @@ exports.createGetSqlStatements = function (context, asyncDone) {
 function masterTable(sqlContext) {
     let dbSeg = sqlContext.dbSegLast;
 
-
-
     sqlContext.context.logger.debug('createGetStatements', 'masterTable');
 
     //dbSeg.sql.stmContainer = new sql.GetContainer();

package/lib/sql/createLinksSQLStatements_1_n.js

@@ -36,7 +36,21 @@ function createSQLCreateStmt(dbSeg, rId, withForeignKeyProperties) {
     stmCreate.setModifiers(['local', 'temporary', dbSeg.entityType.tableStoreType]);
     stmCreate.setTableName(rId);
     stmCreate.setAs(createSelectTemplate(dbSeg, withForeignKeyProperties));
-    stmCreate.setPostModifiers(['with no data']);
+    // Note about the modifier 'WITHOUT CONSTRAINT' for create temporary table:
+    // Is only important in HANA Cloud databases, but is also valid in HANA Service databases.
+    // => Characteristics of creating temporary tables:
+    // (1) HANA Service: Temporary tables do not have constraints (e.g. NOT-NULL for key columns)
+    // (2) HANA Cloud: Temporary tables have constraints, if created via this SQL:
+    //                 "create local temporary <store-type> <tab-name> as (select ... from <source-table> ...)"
+    //                 => temp. table inherits the constraints from <source-table>
+    //                 => use the modifier 'WITHOUT CONSTRAINT' to switch off this inheritance
+    // Test cases affected for HANA Cloud:
+    // - test_apps/test_authorization/test_authorization_scopes_batch.js
+    // - test_apps/test_authorization/test_authorization_scopes.js
+    // - test_apps/test_db/test_clean_dbcon_after_xsodata_processing.js
+    // - test_apps/test_xsodata/test_links.js
+    // - test_apps/test_xsodata/test_linksBatch.js
+    stmCreate.setPostModifiers(['with no data', 'WITHOUT CONSTRAINT']);
     return stmCreate;
 }
 
@@ -71,14 +85,14 @@ exports.createLinksStatementsCreateTmpTables = function (context, isDeleteScenar
     var dbSegToBeUpdated = context.oData.links.toBeUpdated;
 
     var sqlContext = {
-        context: context,
+        context: context,                                               // sqlContext gets parent context (includes "isHanaCloudDb")
         netId: context.uniqueNetworkRequestID,
         reqId: context.uniqueRequestID,
         rId: 1,
         dbSegToBeUpdated: dbSegToBeUpdated,
         dbSegPrincipal: context.oData.links.principal,
         dbSegDependent: context.oData.links.dependent,
-        systemQueryParameters: context.oData.systemQueryParameters
+        systemQueryParameters: context.oData.systemQueryParameters,
     };
 
     if (isDeleteScenario) {

package/lib/sql/dataCollector2.js

@@ -9,12 +9,10 @@ const CreateSqlErrorLog = (context, err, sql, parameters) => {
         return;
     }
 
-    context.logger.error('SQL Exec', 'Error: \n' + err);
-    context.logger.error('SQL Exec', 'SQL: \n' + sql);
+    context.logger.error('SQL Exec', 'Error: ' + err);
+    context.logger.error('SQL Exec', 'SQL: ' + sql);
+    context.logger.logSqlParameters(parameters, true, true);  // force parameter logging as error
 
-    if (parameters) {
-        context.logger.logSqlParameters(parameters, true, true);  // force parameter logging as error
-    }
     return new SqlError(context, err);
 };
 
@@ -128,7 +126,7 @@ const executeSqlDirectly = (context, sql, cb) => {
     let startTime = context.logger.getStartTimeSql();
     client.exec(sql, (errExec, rows) => {
         context.logger.logSqlTime('exec', startTime, sql);
-        return cb(CreateSqlErrorLog(context, errExec), rows);
+        return cb(CreateSqlErrorLog(context, errExec, sql), rows);
     });
 };
 

package/lib/sql/dataCollectorGet.js

@@ -64,7 +64,8 @@ exports.select = function (context, asyncDone) {
     var container = context.sql.container;
     var stms = container.select.concat(container.selectTmp);
 
-    async.mapSeries(stms,
+    async.mapSeries(
+        stms,
         function (item, cb) {
             try {
                 execStatement(item, function (err, rows) {
@@ -85,7 +86,7 @@ exports.select = function (context, asyncDone) {
                             context.logger.info('SQL Exec', 'Check maxRecords :' + maxRecords);
                             if (rows.length > maxRecords) {
                                 // since there are possibly more
-                                return cb(new BadRequest("Too many records in result set. Use $top with to reduce the record count.", context));
+                                return cb(new BadRequest("Too many records in result set. Use $top to reduce the record count.", context));
                             }
                         }
 
@@ -158,7 +159,7 @@ exports.select = function (context, asyncDone) {
                     }
                 }
             }
-            context.logger.silly('dataCollector', JSON.stringify(rows.length));
+            context.logger.silly('GET dataCollector - row count', JSON.stringify(rows.length));
             // context.logger.silly('dataCollector', JSON.stringify(rows, null, 2));
             return cb(null, rows);
 

package/lib/sql/sqlStatement.js

@@ -19,15 +19,31 @@ exports.SqlBuildHanaContext = function (context) {
         this.isNav = function (string) {
             return dbSeg._SelectedNavigations.indexOf(string) > -1;
         };
+        this.isHanaCloudDb = getHanaCloudDbSetting(context);
     } else {
         this.oDataNullSupport = false;
         this.isNav = false;
+        this.isHanaCloudDb = true;      // use default Hana Cloud - Q: Is this needed? In a clone (without context, the original context should have this setting)
     }
     this.inOrderBy = false;
     this.table = null;
     this.noAlias = null; // only used in a cloned SqlBuildHanaContext to avoid using aliases in orderby clauses
 };
 
+function getHanaCloudDbSetting(context) {
+
+    // 06/2022: All used SQL from Hana Cloud DB work also on Hana Service DB,
+    // i.e. take that as default; but that may change in the future!
+    let isHanaCloudDb = true;
+
+    if (context.batchContext && context.batchContext.parentContext && context.batchContext.parentContext.db && context.batchContext.parentContext.db.isHanaCloudDb !== undefined) {
+        isHanaCloudDb = context.batchContext.parentContext.db.isHanaCloudDb;    // batch request context
+    } else if (context.db && context.db.isHanaCloudDb !== undefined) {
+        isHanaCloudDb = context.db.isHanaCloudDb;                               // regular request context
+    }
+    return isHanaCloudDb;
+}
+
 exports.SqlBuildHanaContext.prototype.clone = function () {
     var c = new exports.SqlBuildHanaContext();
     c.oDataNullSupport = this.oDataNullSupport;
@@ -35,6 +51,7 @@ exports.SqlBuildHanaContext.prototype.clone = function () {
     c.table = this.table; // used in Property.prototype.toSqlHana
     c.noAlias = this.noAlias;
     c.inOrderBy = this.inOrderBy;
+    c.isHanaCloudDb = this.isHanaCloudDb;   // keep this setting in any clone!!!
     return c;
 };
 
@@ -446,7 +463,7 @@ Create.prototype.toSqlHana = function (context, parameter) {
     for (i = 0; i < this.modifiers.length; i++) {
         sql += ' ' + this.modifiers[i];
     }
-    sql += '\ntable ';
+    sql += ' table ';
     sql += '"' + this.table + '" ';
     if (this.as) {
         sql += '\nas ( ';
@@ -1145,6 +1162,78 @@ Update.prototype.addWhereKeyValuePairs = function (keyValuePairs) {
 
 
 Update.prototype.toSqlHana = function (context, parameter) {
+
+    // 'context.isHanaCloudDb': is set in SQL context (hence 'context' here) to member 'isHanaCloudDb';
+    // check creation of 'new SqlBuildHanaContext' above
+    let isHanaCloudDb = (context.isHanaCloudDb) ? context.isHanaCloudDb : true;   // Hana Cloud as default
+    return (isHanaCloudDb) ? this.getHANACloudUpdateSql(context, parameter) : this.getHANAServiceUpdateSql(context, parameter);
+};
+
+
+Update.prototype.getHANACloudUpdateSql = function(context, parameter) {
+
+    var sql = '';
+
+    sql += 'MERGE INTO ';
+    if (this.update.table.substr(0, 1) === '#') {
+        sql += ' "' + this.update.table + '" ';
+        if (this.update.alias) {
+            sql += ' "' + this.update.alias + '"';
+        }
+    } else {
+
+        if (this.update.schema) {
+            sql += '"' + this.update.schema + '".';
+        }
+        sql += '"' + this.update.table + '"';
+        if (this.update.alias) {
+            sql += ' "' + this.update.alias + '"';
+        }
+    }
+
+    sql += ' USING ';
+    if (this.from.table.substr(0, 1) === '#') {
+        sql += ' "' + this.from.table + '" ';
+        if (this.from.alias) {
+            sql += ' "' + this.from.alias + '"';
+        }
+    } else {
+        if (this.from.schema) {
+            sql += '"' + this.from.schema + '".';
+        }
+        sql += '"' + this.from.table + '"';
+        if (this.from.alias) {
+            sql += ' "' + this.from.alias + '"';
+        }
+    }
+
+    if (this.whereAnded.length > 0) {
+        sql += ' ON ';
+        for (let i = 0; i < this.whereAnded.length; i++) {
+            sql += (i === 0 ? '' : ' and ');
+            sql += '(';
+            sql += this.whereAnded[i].toSqlHana(context, parameter);
+            sql += ')';
+        }
+    }
+
+    sql += ' WHEN MATCHED THEN UPDATE ';
+
+    sql += ' SET ';
+    for (let i = 0; i < this.copyFromTo.length; i++) {
+        var cft = this.copyFromTo[i];
+        sql += (i === 0 ? '' : ', ');
+
+        sql += cft.to.toSqlHana(context, parameter, { withoutTable: true });
+        sql += '=';
+        sql += cft.from.toSqlHana(context, parameter);
+    }
+
+    return sql;
+};
+
+
+Update.prototype.getHANAServiceUpdateSql = function(context, parameter) {
     var i;
 
     var sql = '';

package/lib/sql/statementProcessor.js

@@ -36,7 +36,8 @@ const execStmsDirectlyNoResult = function (context, stmsInput, asyncDone) {
 const execStmsAsPreparedNoResult = function (context, stmsInput, asyncDone) {
     const stms = Array.isArray(stmsInput) ? stmsInput :  [stmsInput];
     context.logger.silly('dataCollector', 'execParallelNoResult');
-    async.mapSeries(stms,
+    async.mapSeries(
+        stms,
         function (item, cb) {
             try {
                 var p = [];
@@ -58,7 +59,8 @@ const execStmsAsPreparedNoResult = function (context, stmsInput, asyncDone) {
 const execStmsAsPrepared = function (context,stmsInput,  asyncDone) {
     const stms = Array.isArray(stmsInput) ? stmsInput :  [stmsInput];
     context.logger.silly('dataCollector', 'execParallelNoResult');
-    async.mapSeries(stms,
+    async.mapSeries(
+        stms,
         function (item, cb) {
             try {
                 var p = [];

package/lib/uri/resourcePathParser.js

@@ -180,7 +180,7 @@ ResourcePathReader.prototype.consumeFollowerSegment = function consumeFollowerSe
 
     if (prevDbSegment.isCollection === true) {
         //E.g. /Teams/invalid
-        throw new Http400_BadRequest("The segment 'invalid' at position 6 in the request URI is not valid. Since the previous segment refers to a collection, the only supported value for the next segment is '$count'.");
+        throw new Http400_BadRequest(`The segment '${segment.identifier}' in the request URI is not valid. Since the previous segment refers to a collection, the only supported value for the next segment is '$count'.`);
     }
 
     //check for primitive property

package/lib/utils/errors/internalError.js

@@ -16,9 +16,6 @@ function InternalError(message, context, cause) {
     this.context = context;
     if (cause && cause.stack && context && context.logger) {
         context.logger.error('InternalError', cause.stack);
-        if (cause.cause && cause.cause.message) {
-            context.logger.error('InternalError', cause.cause.message);
-        }
     }
 }
 

package/lib/utils/errors/sqlError.js

@@ -12,10 +12,14 @@ module.exports = SqlError;
  * @param information
  * @constructor
  */
-function SqlError(context, cause,  information) {
+function SqlError(context, cause, information) {
     const errorText = "Error while executing a DB query";
     InternalError.call(this, errorText, context, cause);
-    this.message = errorText;
+    if (cause && cause.message) {
+        this.message = `${errorText}: ${cause.message}`;
+    } else {
+        this.message = errorText;
+    }
     this.information = information;
 }
 

package/lib/utils/errors/xsODataError.js

@@ -20,7 +20,10 @@ function XsODataError(message, cause) {
 }
 
 XsODataError.prototype.toString = function () {
-    return this.stack.toString();
+    let ret = "";
+    ret = this.stack.toString();
+    ret += (this.cause) ? ("\n" + this.cause + "\n") : "";
+    return ret;
 };
 
 util.inherits(XsODataError, Error);

package/lib/utils/logger.js

@@ -109,25 +109,27 @@ function printSqlData(array) {
 
 function printSqlParameters(array) {
     let ret = '';
-    for (const value of array) {
-        if (ret.length) {
-            ret += ',';
-        }
-
-        if (typeof value === 'string' && value.length > XSODATA_LOG_SQL_PARAM_VALUE_SIZE) {
-            ret += value.substr(0, XSODATA_LOG_SQL_PARAM_VALUE_SIZE) + '<' + value.length + '>';
-            continue;
-        }
-        if (Array.isArray(value) && value.length > XSODATA_LOG_SQL_PARAM_ARRAY_SIZE) {
-            ret += value.slice(0, XSODATA_LOG_SQL_PARAM_VALUE_SIZE);
-            continue;
-        }
-        if (Buffer.isBuffer(value) && value.length > XSODATA_LOG_SQL_PARAM_VALUE_SIZE) {
-            ret += value.slice(0, XSODATA_LOG_SQL_PARAM_VALUE_SIZE).toString('hex') + '.LEN:' + value.length;
-            continue;
+    if (array && Array.isArray(array)) {
+        for (const value of array) {
+            if (ret.length) {
+                ret += ',';
+            }
+
+            if (typeof value === 'string' && value.length > XSODATA_LOG_SQL_PARAM_VALUE_SIZE) {
+                ret += value.substr(0, XSODATA_LOG_SQL_PARAM_VALUE_SIZE) + '<' + value.length + '>';
+                continue;
+            }
+            if (Array.isArray(value) && value.length > XSODATA_LOG_SQL_PARAM_ARRAY_SIZE) {
+                ret += value.slice(0, XSODATA_LOG_SQL_PARAM_VALUE_SIZE);
+                continue;
+            }
+            if (Buffer.isBuffer(value) && value.length > XSODATA_LOG_SQL_PARAM_VALUE_SIZE) {
+                ret += value.slice(0, XSODATA_LOG_SQL_PARAM_VALUE_SIZE).toString('hex') + '.LEN:' + value.length;
+                continue;
+            }
+
+            ret += value;
         }
-
-        ret += value;
     }
 
     return ret;
@@ -236,6 +238,18 @@ Logger.prototype.logSqlCommand = function (sql) {
     }
 };
 
+Logger.prototype.logSqlParameters = function (parameters, force, asError) {
+
+    if (XSODATA_LOG_SQL_COMMAND >= 2 && (XSODATA_LOG_SQL_PARAMETERS >= 2 || force || asError)) {
+        let out = printSqlParameters(parameters);
+        if (asError) {
+            this.logger.error(this.getKey() + 'SQL param: ' + out);
+        } else {
+            this.logger.debug(this.getKey() + 'SQL param: ' + out);
+        }
+    }
+};
+
 Logger.prototype.getStartTimeSql = function () {
     if (XSODATA_LOG_SQL_TIME || XSODATA_FORCE_LOG_LONG_SQL) {
         return process.hrtime();
@@ -293,16 +307,4 @@ Logger.prototype.logRequestTime = function (text, startTime, url) {
     }
 };
 
-Logger.prototype.logSqlParameters = function (parameters, force, asError) {
-
-    if (XSODATA_LOG_SQL_COMMAND >= 2 && (XSODATA_LOG_SQL_PARAMETERS >= 2 || force || asError)) {
-        let out = printSqlParameters(parameters);
-        if (asError) {
-            this.logger.error(this.getKey() + 'SQL param: ' + out);
-        } else {
-            this.logger.debug(this.getKey() + 'SQL param: ' + out);
-        }
-    }
-};
-
 module.exports = Logger;

package/lib/xsodata.js

@@ -215,7 +215,7 @@ exports.ODataHandler.prototype.createRequestChain = function (context) {
  * @param { module:configuration.RequestOptions } requestOptions @see module:configuration.RequestOptions
  * @param applicationDone Callback call after request is processed. Signature ( err : Object, context : Object )
  */
-exports.ODataHandler.prototype.processRequest = function process(request, response, requestOptions, applicationDone) {
+exports.ODataHandler.prototype.processRequest = function(request, response, requestOptions, applicationDone) {
     var networkContext;
     var context;
     var baseMeasurement;
@@ -241,6 +241,7 @@ exports.ODataHandler.prototype.processRequest = function process(request, respon
         context.logger.info('xsodata', 'process url: ' + request.url);
         context.logger.info('xsodata', 'version: ' + packageJson.version);
         context.logger.info('xsodata', 'uriPrefix: ' + context.uriPrefix);
+        context.logger.info('xsodata', 'node version: ' + process.version);
 
         context.url = request.url;
         context.request = simpleRequest.createRequest(request, context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/xsodata",
-  "version": "7.5.5",
+  "version": "8.0.0",
   "description": "Expose data from a HANA database as OData V2 service with help of .xsodata files.",
   "main": "index.js",
   "license": "SEE LICENSE IN developer-license-3.1.txt",
@@ -9,13 +9,14 @@
     "serve-debug": "node --inspect-brk test_apps/server",
     "pretest": "npm -g ls --depth=0 && npm  ls --depth=0",
     "lint": "jshint .",
-    "all-tests-jenkins": "node ./node_modules/mocha/bin/_mocha --timeout 20000 'test/**/test*.js' 'test_apps/test_**/**/test*.js'",
-    "all-tests-cv": "node ./node_modules/mocha/bin/_mocha --timeout 20000 'test_apps/test_cv/**/test*.js'",
-    "scenario-tests": "node ./node_modules/mocha/bin/_mocha --timeout 20000 test_apps/test_**/**/test*.js",
+    "all-tests-jenkins": "node ./node_modules/mocha/bin/_mocha --no-color --timeout 20000 'test/**/test*.js' 'test_apps/test_**/**/test*.js'",
+    "all-tests-cv": "node ./node_modules/mocha/bin/_mocha --no-color --timeout 20000 'test_apps/test_cv/**/test*.js'",
+    "scenario-tests": "node ./node_modules/mocha/bin/_mocha --no-color --timeout 20000 test_apps/test_**/**/test*.js",
+    "all-tests-synonym": "node ./node_modules/mocha/bin/_mocha --no-color --timeout 20000 test_apps/test_synonyms/test_*.js",
     "unit-tests": "node ./node_modules/mocha/bin/_mocha test/**/test*.js",
     "cover-unit-tests": "nyc --reporter=text --reporter=html --all --include lib/ npm run unit-tests",
-    "cover-scenario-tests": "nyc --reporter=text --reporter=html --all --include lib/ --check-coverage true --lines 80 --branches 69 --functions 87 --statements 80 npm run scenario-tests",
-    "cover-jenkins": "nyc --reporter=text --reporter=html --all --include lib/ --check-coverage true --lines 80 --branches 69 --functions 87 --statements 80 npm run all-tests-jenkins",
+    "cover-scenario-tests": "nyc --reporter=text --reporter=html --all --include lib/ --check-coverage true --lines 80 --branches 68 --functions 86 --statements 80 npm run scenario-tests",
+    "cover-jenkins": "nyc --reporter=text --reporter=html --all --include lib/ --check-coverage true --lines 80 --branches 68 --functions 86 --statements 80 npm run all-tests-jenkins",
     "report": "node ./node_modules/mocha/bin/_mocha test/**/test*.js test_apps/test_**/**/test*.js --reporter mocha-simple-html-reporter --reporter-options output=report_all.html",
     "report-unit-tests": "node ./node_modules/mocha/bin/_mocha test/**/test*.js --reporter mocha-simple-html-reporter --reporter-options output=report_unit.html",
     "report-scenario-tests": "node ./node_modules/mocha/bin/_mocha test_apps/test_**/**/test*.js --reporter mocha-simple-html-reporter --reporter-options output=report_scenario.html",
@@ -45,12 +46,12 @@
     ".npmignore"
   ],
   "dependencies": {
-    "@sap/xsenv": "3.2.1",
+    "@sap/xsenv": "3.3.2",
     "@sap/xssec": "3.2.13",
-    "async": "3.2.3",
-    "big.js": "6.1.1",
-    "body-parser": "1.19.2",
-    "hdb": "0.19.1",
+    "async": "3.2.4",
+    "big.js": "6.2.1",
+    "body-parser": "1.20.0",
+    "hdb": "0.19.4",
     "lodash": "4.17.21",
     "negotiator": "0.6.3",
     "rwlock": "5.0.0",
@@ -63,7 +64,7 @@
     "@sap/hana-client": "2.10.20",
     "chai": "4.2.0",
     "expect": "1.20.2",
-    "filter-node-package": "=2.2.0",
+    "filter-node-package": "3.0.0",
     "jison": "0.4.18",
     "jshint": "2.13.4",
     "mocha": "9.2.2",
@@ -72,6 +73,6 @@
     "nyc": "^15.1.0",
     "pegjs": "0.10.0",
     "sinon": "6.1.4",
-    "xml2js": "0.4.19"
+    "xml2js": "0.4.23"
   }
 }