@sap/cds-dk 6.6.0 → 6.6.2

package/CHANGELOG.md

@@ -7,6 +7,30 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## Version 6.6.2 - 2023-03-22
+
+### Fixed
+
+- Bump `sqlite3` to 5.1.6
+- Bump `@sap/cds` to 6.2.2
+- `cds init` creates project sample files correctly.
+
+## Version 6.6.1 - 2023-03-09
+
+### Added
+
+- `cds compile --to openapi` now adds extension validation keywords `x-sap-precision` and `x-sap-scale` for decimal values.
+
+### Fixed
+
+- `cds add helm` fixed html5 cloud service is now read properly.
+- `cds import` now flattens the `@Capabilities` anotation in the CSN for OData V4 files.
+- `cds import` for OData V4 files now captures the `EnumTypes` information in the CSN according to `UnderlyingType`.
+- `cds import` now captures the `@Common.Text` annotation value properly in the CSN for OData V4 files.
+- `cds init --add java` now uses local Java version when creating new Java project.
+- `cds watch` terminates properly in case livereload websocket clients are connected
+- `cds watch`'s livereload feature works again on Node.js >= 17, where local IPv6 addresses are the default (`::1` instead of `127.0.0.1`)
+
 ## Version 6.6.0 - 2023-02-28
 
 ### Added

package/lib/client/helper/errors.js

@@ -4,8 +4,10 @@ class CliError extends Error {
     // noinspection JSAnnotator
     constructor(message, { error, command } = {}) {
         const help = command && getCommandHelp(command);
+        const stackLimit = Error.stackTraceLimit;
         Error.stackTraceLimit = 0
-        throw new Error(getMessage(message, { error, help }));
+        super(getMessage(message, { error, help }));
+        Error.stackTraceLimit = stackLimit;
     }
 }
 

package/lib/compile/openapi/csdl2openapi.js

@@ -2047,6 +2047,8 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
                     anyOf: [{ type: 'number', format: 'decimal' }, { type: 'string' }],
                     example: 0
                 };
+                if (!isNaN(element.$Precision)) s['x-sap-precision'] = element.$Precision;
+                if (!isNaN(element.$Scale)) s['x-sap-scale'] = element.$Scale;
                 // eslint-disable-next-line no-case-declarations
                 let scale = !isNaN(element.$Scale) ? element.$Scale : null;
                 if (scale !== null) {

package/lib/import/message.js

@@ -17,7 +17,8 @@ const messages = {
 	COLLECTION_IN_KEY: 'Key Property of an Entity cannot be of the type Collection.',
 	INVALID_OPENAPI_FILE: 'The OpenAPI file is not valid. Specify the correct OpenAPI file.',
 	UNRESOLVED_TYPE: 'Could not resolve the type: ',
-	NO_RETURN_TYPE: 'No ReturnType found in Function: '
+	NO_RETURN_TYPE: 'No ReturnType found in Function: ',
+	INVALID_ENUM_TYPE: 'The Underlying type provided is not supported for the EnumType: '
 };
 
 function getMessages() {

package/lib/import/odata/metadataconverter/MetadataConverter.js

@@ -1682,6 +1682,11 @@ class PropertyValueExpression extends Expression {
         if (element.attributes.EnumMember) target[name] = { "#": element.attributes.EnumMember.substring(element.attributes.EnumMember.lastIndexOf('/') + 1) };
         if (element.attributes.NavigationPropertyPath) target[name] = { "=": element.attributes.NavigationPropertyPath };
         if (element.attributes.String) target[name] = element.attributes.String;
+        /**
+         * EnumType is converted to TypeDefinition when generating edmx from compiler
+         * we then have to fetch this value correctly via this attribute of annotation
+         */
+        if (element.attributes.Int) target[name] = Number(element.attributes.Int);
         if (element.attributes.Bool) target[name] = element.attributes.Bool === 'true';
 
         this.getStack().forEach((expr) => {
@@ -1993,8 +1998,8 @@ class EnumTypeExpression extends Expression {
                 Object.assign(target, interpretation);
             }
         });
-
-        this.buildTypeCollectionAndFacets('$Type', '$UnderlyingType', '$IsFlags', '$BaseType');
+        // EnumType doesn't have Type, BaseType as attribute/facet so removed it
+        this.buildTypeCollectionAndFacets('$UnderlyingType', '$IsFlags');
         return result;
     }
 }

package/lib/import/odata/v4parser.js

@@ -12,7 +12,6 @@ const ignoreObjects = ["$Reference"]; // add all the objects that needs to be ig
 const validEdmDatatypes = ["Edm.DateTimeOffset"];
 const { warn } = require("../../util/term");
 const MetadataConverterFactory = require("./metadataconverter/MetadataConverterFactory");
-const cds = require('../../cds');
 
 const edmxncdsdatatype = {
     "Edm.String": "cds.LargeString",
@@ -142,7 +141,7 @@ function _hasEntityContainer(jsonObj, parserContext) {
             jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] instanceof Object
         ) {
             return true;
-        } 
+        }
     } catch (err) {
         throw new Error(messages.MISSING_ENTITY_CONTAINER);
     }
@@ -158,7 +157,7 @@ function _includeExternalNamespaceAnnotation(source, target) {
 
 function _addNotNull(property, isCollection) {
     if (isCollection) property.items["notNull"] = true;
-    else property["notNull"] = true; 
+    else property["notNull"] = true;
 }
 
 function _typeWithCollections(property, type, isCollection) {
@@ -567,6 +566,7 @@ function _collectEnumType(schemaDataList, parserContext) {
 }
 
 function _generateCSNForEnumType(schemaData, parserContext) {
+    const nonMemberList = ["$Kind", "$Type", "$UnderlyingType", "$IsFlags"];
     let enumCsn = {};
     let eTypes;
     eTypes = _collectEnumType(schemaData, parserContext);
@@ -575,15 +575,19 @@ function _generateCSNForEnumType(schemaData, parserContext) {
         enumCsn[element].kind = 'type';
         enumCsn[element]['@cds.external'] = true;
         enumCsn[element].enum = {};
-        enumCsn[element].type = eTypes[element].$Type != null ? edmxncdsdatatype[eTypes[element].$Type] : 'cds.LargeString';
-        Object.keys(eTypes[element]).forEach(property => {
-            if (property != "$Kind" && property != "$Type") {
-                if (enumCsn[element].type == 'cds.LargeString') {
-                    enumCsn[element].enum[property] = cds.parse.expr(`'${(eTypes[element][property])}'`);
-                }
-                else {
-                    enumCsn[element].enum[property] = cds.parse.expr(`${(eTypes[element][property])}`);
-                }
+        /**
+         * If UnderlyingType not specified, default is Edm.Int32 --> cds.Integer
+         */
+        let underlyingType = eTypes[element].$UnderlyingType;
+        enumCsn[element].type = underlyingType ? edmxncdsdatatype[underlyingType] : 'cds.Integer';
+
+        if (!enumCsn[element].type || enumCsn[element].type !== "cds.Integer" ) {
+            throw new Error(messages.INVALID_ENUM_TYPE + `'${underlyingType}'`);
+        }
+        Object.keys(eTypes[element]).forEach(member => {
+            if (!nonMemberList.includes(member)) {
+                enumCsn[element].enum[member] = {};
+                enumCsn[element].enum[member].val = eTypes[element][member];
             }
         });
     });
@@ -900,7 +904,7 @@ function _generateCSNForComplexType(schemaData, parserContext) {
         }
         if ((isAbstract || isOpenType) && !parserContext.complexTypeOpenEntries.includes(element)) {
             parserContext.complexTypeOpenEntries.push(element);
-        }        
+        }
         Object.keys(cTypes[element]).forEach(property => { // cTypes[element][property].$Type.startsWith('Edm.')
             if (cTypes[element][property] instanceof Object) {
                 if (!cTypes[element][property].$Type ||
@@ -944,11 +948,16 @@ function _parseTypeDefinition(parserContext) {
         typeDef[element] = {};
         typeDef[element].kind = 'type';
         typeDef[element]['@cds.external'] = true;
-        if (!parserContext.typeDefinitions[element].$Type ||
-            edmxncdsdatatype[parserContext.typeDefinitions[element].$Type]
-        ) {
+
+        let underlyingType = parserContext.typeDefinitions[element].$UnderlyingType;
+        parserContext.typeDefinitions[element].$Type = underlyingType;
+
+        if (edmxncdsdatatype[underlyingType] ) {
             propertyType = parserContext.typeDefinitions[element];
             typeDef[element] = Object.assign(typeDef[element], generatePropertyCsn(propertyType, false));
+            if (typeDef[element].type === "cds.LargeString") typeDef[element].type = "cds.String";
+        } else {
+            throw new Error(messages.UNRESOLVED_TYPE + `'${underlyingType}'`);
         }
     });
     return typeDef;
@@ -999,13 +1008,13 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                                 if (objData.$Parameter[i].$Collection && !paramType.items) {
                                     obj[objType].params[objData.$Parameter[i].$Name] = {};
                                     obj[objType].params[objData.$Parameter[i].$Name].items = paramType;
-                                    if(objData.$Parameter[i].$Nullable != true){
+                                    if (!objData.$Parameter[i].$Nullable) {
                                         obj[objType].params[objData.$Parameter[i].$Name].items["notNull"] = true;
                                     }
                                 } else {
                                     obj[objType].params[objData.$Parameter[i].$Name] = paramType;
                                     if (!paramType.items) {
-                                        if(objData.$Parameter[i].$Nullable != true){
+                                        if (!objData.$Parameter[i].$Nullable) {
                                             obj[objType].params[objData.$Parameter[i].$Name]["notNull"] = true;
                                         }
                                     }
@@ -1169,6 +1178,7 @@ function _replaceSpecialCharacters(text) {
 }
 
 function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString, vocab) {
+    let annoTerm = targetString.substring(targetString.indexOf('@') + 1).split('.')[0];
     if (path) {
         if (targetString === "@Core.Description" && annotation[1]["@Core.Description"]) {
             if (path.doc === undefined)
@@ -1182,11 +1192,17 @@ function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString, voc
         else if (targetString === "@Core.OptionalParameter" && annotation[1]["@Core.OptionalParameter"]) {
             _captureOptionalParameter(annotation, path);
         }
-        else if (vocab) { 
-            if (vocab.includes(targetString.substring(targetString.indexOf('@') + 1, targetString.lastIndexOf('.')))) {
-                if (annotation[1][targetString]?.$Cast) {
+        else if (vocab) {
+            if (vocab.includes(annoTerm)) {
+                if (annoTerm === "Capabilities") {
+                    path[targetString] = annotation[1][1];
+                }
+                else if (annotation[1][targetString]?.$Cast) {
                     path[targetString] = Number(annotation[1][targetString].$Cast);
                 }
+                else if (annotation[1][targetString]?.$Path) {
+                    path[targetString] = { "=": annotation[1][targetString].$Path };
+                }
                 else {
                     path[targetString] = annotation[1][targetString] === null ? true : annotation[1][targetString];
                 }
@@ -1202,37 +1218,38 @@ function checkEntitySetMap(pathName, parserContext, index = 0) {
     return pathName;
 }
 
-function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, parserContext) {
+function _checkAnnotationTarget(annotation, csnDefs, str, no_of_terms, vocab, parserContext) {
     if ((annotation[0].indexOf('/') === -1 && annotation[0].indexOf('(') === -1) || annotation[0].includes("Container")) {
-        if (cdsDefs[annotation[0]]) {
+        if (csnDefs[annotation[0]]) {
             let path = annotation[0].split('/');
             let pathFromEntityTypeMap = parserContext.entitySetToEntityTypeMap.get(path[0]);
             if (pathFromEntityTypeMap != null) {
                 if (pathFromEntityTypeMap.length > 1) {
                     for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
                         let path1 = checkEntitySetMap(path[0], parserContext, index);
-                        _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+                        _checkAnnotatationTerm(annotation, csnDefs[path1], no_of_terms, str, vocab);
                     }
                 } else {
-                    _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str, vocab);
+                    _checkAnnotatationTerm(annotation, csnDefs[annotation[0]], no_of_terms, str, vocab);
                 }
             }
             else {
-                _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str, vocab);
+                _checkAnnotatationTerm(annotation, csnDefs[annotation[0]], no_of_terms, str, vocab);
             }
         }
+
         if (annotation[0].indexOf('/') > 0) {
             let path = annotation[0].split('/');
             let temp = parserContext.namespace + '.' + path[1];
             let path1 = checkEntitySetMap(temp, parserContext);
-            if (cdsDefs[path1]) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+            if (csnDefs[path1]) {
+                _checkAnnotatationTerm(annotation, csnDefs[path1], no_of_terms, str, vocab);
             }
         }
         else if (annotation[0].includes("Container")) {
             let path = annotation[0].substring(0, annotation[0].lastIndexOf('.'));
             let actualPath = checkEntitySetMap(path, parserContext);
-            _checkAnnotatationTerm(annotation, cdsDefs[actualPath], no_of_terms, str, vocab);
+            _checkAnnotatationTerm(annotation, csnDefs[actualPath], no_of_terms, str, vocab);
         }
         else if (annotation[0].indexOf('(') === -1 && (annotation[0].indexOf('/') === -1)) {
             let path = annotation[0].split('/');
@@ -1241,7 +1258,7 @@ function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, pa
                 if (pathFromEntityTypeMap.length > 1) {
                     for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
                         let path1 = checkEntitySetMap(path[0], parserContext, index);
-                        _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+                        _checkAnnotatationTerm(annotation, csnDefs[path1], no_of_terms, str, vocab);
                     }
                 }
             }
@@ -1254,39 +1271,39 @@ function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, pa
             if (pathFromEntityTypeMap.length > 1) {
                 for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
                     let path1 = checkEntitySetMap(path[0], parserContext, index);
-                    _checkAnnotatationTerm(annotation, cdsDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
+                    _checkAnnotatationTerm(annotation, csnDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
                 }
             }
             else {
                 let path1 = checkEntitySetMap(path[0], parserContext);
-                if (cdsDefs[path1]) {
-                    _checkAnnotatationTerm(annotation, cdsDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
+                if (csnDefs[path1]) {
+                    _checkAnnotatationTerm(annotation, csnDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
                 }
             }
         }
         else {
-            if (cdsDefs[path[0]]) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["elements"][path[1]], no_of_terms, str, vocab);
+            if (csnDefs[path[0]]) {
+                _checkAnnotatationTerm(annotation, csnDefs[path[0]]["elements"][path[1]], no_of_terms, str, vocab);
             }
         }
     }
     else {
         let path = annotation[0].split('(');
         let actualPath = checkEntitySetMap(path[0], parserContext);
-        if (cdsDefs[actualPath] === undefined) {
+        if (csnDefs[actualPath] === undefined) {
             let temp = path[1].split(')');
             let path1 = temp[0].split(',');
             let path2 = path[0].split('.');
-            if (cdsDefs[path1[0]]) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path1[0]]["actions"][path2[1]], no_of_terms, str, vocab);
+            if (csnDefs[path1[0]]) {
+                _checkAnnotatationTerm(annotation, csnDefs[path1[0]]["actions"][path2[1]], no_of_terms, str, vocab);
             }
         } else {
             if (path[1].indexOf('/') === -1) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path[0]], no_of_terms, str, vocab);
+                _checkAnnotatationTerm(annotation, csnDefs[path[0]], no_of_terms, str, vocab);
             } else {
                 let path1 = path[1].split('/');
-                if (cdsDefs[path[0]] && cdsDefs[path[0]]["params"]) {
-                    _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["params"][path1[1]], no_of_terms, str, vocab);
+                if (csnDefs[path[0]] && csnDefs[path[0]]["params"]) {
+                    _checkAnnotatationTerm(annotation, csnDefs[path[0]]["params"][path1[1]], no_of_terms, str, vocab);
                 }
             }
         }
@@ -1305,7 +1322,7 @@ function _replaceSchemaDataAnnotation(vocabAlias, vocabNamespce, schemaDataAnnot
     return JSON.parse(schemaDataAnnotation);
 }
 
-function _generateDocumentation(edmxAsJson, schemaData, cdsDefs, parserContext) {
+function _generateDocumentation(edmxAsJson, schemaData, csnDefs, parserContext) {
     let vocabAlias = [];
     let vocab = [];
     let vocabNamespce = [];
@@ -1326,18 +1343,23 @@ function _generateDocumentation(edmxAsJson, schemaData, cdsDefs, parserContext)
         Object.entries(schemaData[0].$Annotations).map(annotation => {
             let no_of_terms;
             Object.entries(annotation[1]).forEach(anno => {
-                if (vocab.includes(anno[0].substring(anno[0].indexOf('@') + 1, anno[0].lastIndexOf('.')))) {
+                let annoTerm = anno[0].substring(anno[0].indexOf('@') + 1).split('.')[0];
+
+                if (vocab.includes(annoTerm) && annoTerm !== 'Capabilities') {
                     if (annotation[1].hasOwnProperty('@Core.Description')) {
                         no_of_terms = true;
                     }
                     if (annotation[1].hasOwnProperty('@Common.FieldControl') && controlFieldFlag === 0) {
-                        annotation[1]["@Common.FieldControl"] = { "#": annotation[1]["@Common.FieldControl"]}
+                        annotation[1]["@Common.FieldControl"] = { "#": annotation[1]["@Common.FieldControl"] };
                         controlFieldFlag = 1;
                     }
                     if (annotation[1].hasOwnProperty('@Common.IsUpperCase')) {
                         annotation[1]["@Common.IsUpperCase"] = true;
                     }
-                    _checkAnnotationTarget(annotation, cdsDefs, anno[0], no_of_terms, vocab, parserContext);
+                    _checkAnnotationTarget(annotation, csnDefs, anno[0], no_of_terms, vocab, parserContext);
+                }
+                if (vocab.includes(annoTerm) && annoTerm === 'Capabilities') {
+                    _parseCapabilitiesAnnotation(annotation[0], anno, csnDefs, vocab, parserContext);
                 }
             });
             controlFieldFlag = 0;
@@ -1345,6 +1367,72 @@ function _generateDocumentation(edmxAsJson, schemaData, cdsDefs, parserContext)
     }
 }
 
+function _flattenAnnotationObject(annotationPrefix, annotationObject) {
+    let flattenedResult = [];
+
+    Object.entries(annotationObject).forEach(annotation => {
+        let currentResult = [];
+        currentResult[0] = annotationPrefix + '.' + annotation[0];
+        currentResult[1] = annotation[1];
+        flattenedResult.push(currentResult);
+    });
+
+    return flattenedResult;
+}
+
+function _removeTypeInAnnotation(annotationObject) {
+    Object.keys(annotationObject).forEach(key => {
+        if (key === "$Type") delete annotationObject[key];
+        else if (annotationObject[key] instanceof Object) {
+            _removeTypeInAnnotation(annotationObject[key]);
+        }
+    });
+}
+
+function _parseCapabilitiesAnnotation(annotationTargetPath, currentAnnotation, csnDefs, vocab, parserContext) {
+    let annotationResult = [annotationTargetPath, ''], currentResult = [], targetString;
+
+    _removeTypeInAnnotation(currentAnnotation);
+
+    /**
+     * For entries like:
+     * <Annotation Term="Capabilities.FilterFunctions"> <Collection> <String>eq</String> <String>ne</String> </Collection> </Annotation>
+     * <Annotation Term="Capabilities.DeleteRestrictions.Deletable" Bool="true"/>
+     * 
+     * simply preserve the value as it is
+     */
+    if (currentAnnotation[1] instanceof Array || !(currentAnnotation[1] instanceof Object)) {
+        targetString = currentAnnotation[0];
+        currentResult = [targetString, currentAnnotation[1]];
+        annotationResult[1] = currentResult;
+        _checkAnnotationTarget(annotationResult, csnDefs, targetString, undefined, vocab, parserContext);
+    }
+    else {
+        Object.keys(currentAnnotation[1]).forEach(annoKey => {
+            let currentAnnoValue = currentAnnotation[1][annoKey];
+            // if the currentAnnoValue is an Object, we need to flatten it
+            if (currentAnnoValue instanceof Object && !(currentAnnoValue instanceof Array)) {
+                targetString = currentAnnotation[0] + '.' + annoKey;
+                let currentResultList = _flattenAnnotationObject(targetString, currentAnnoValue);
+
+                for (let idx = 0; idx < currentResultList.length; idx++) {
+                    targetString = currentResultList[idx][0];
+                    annotationResult[1] = currentResultList[idx];
+                    _checkAnnotationTarget(annotationResult, csnDefs, targetString, undefined, vocab, parserContext);    
+                }
+            } 
+            // if the currentAnnoValue is a list or direct value, we preserve as it is
+            else {
+                targetString = currentAnnotation[0] + '.' + annoKey;
+                currentResult[0] = targetString;
+                currentResult[1] = currentAnnoValue;
+                annotationResult[1] = currentResult;
+                _checkAnnotationTarget(annotationResult, csnDefs, targetString, undefined, vocab, parserContext);
+            }
+        });
+    }
+}
+
 function _generateLongDescription(annotation, path, no_of_terms) {
     if (path) {
         path.doc = no_of_terms ? (path.doc += "\n\n") : (path.doc ? (path.doc += "") : (path.doc = ""));

package/lib/init/index.js

@@ -24,6 +24,8 @@ module.exports = class CDSGenerator {
                 target: 'projectName',
                 validate: async (value) => {
                     try {
+                        cds.root = path.resolve(this.cwd, value || '.');
+
                         await this._validateProjectName(value);
                         await this._validateProjectFolder(path.join(this.cwd, value), this.cwd);
 

package/lib/init/template/html5-repo/files/html5-apps-deployer-configmap.yaml

@@ -1,7 +1,7 @@
 # Please do not modify this file. This file may be overwritten.
 
-{{- $cloudService := index .Values "html5-apps-deployer.env.SAP_CLOUD_SERVICE" -}}
-{{- $defaultParameters :=  dict "Type" "HTTP" "ProxyType" "Internet" "Authentication" "NoAuthentication" "sap.cloud.service" "sap.fe.cap.sflight" "HTML5.forwardAuthToken" "true" }}
+{{- $cloudService := index .Values "html5-apps-deployer" "env" "SAP_CLOUD_SERVICE" -}}
+{{- $defaultParameters :=  dict "Type" "HTTP" "ProxyType" "Internet" "Authentication" "NoAuthentication" "sap.cloud.service" $cloudService "HTML5.forwardAuthToken" "true" }}
 {{- $ := dict "root" . "defaultParameters" $defaultParameters "html5" true }}
 
 apiVersion: v1

package/lib/init/template/java/index.js

@@ -30,7 +30,7 @@ module.exports = class JavaTemplate extends require('../templateBase') {
     }
 
     async run() {
-        const mvnCmdArgs = mvnArchetypeUtil.getGenerateCmdArgs(this.projectName, this.options);
+        const mvnCmdArgs = await mvnArchetypeUtil.getGenerateCmdArgs(this.projectName, this.options);
         const { cmdLine, artifactId, archetypeVersion } = mvnCmdArgs
 
         LOG.info(`Using Maven archetype version ${archetypeVersion}`);

package/lib/init/util/mvnArchetypeUtil.js

@@ -2,10 +2,19 @@
 const { MAVEN_ARCHETYPE_VERSION, OPTION_JAVA_MVN,
     OPTION_JAVA_PACKAGE, OPTION_SAMPLES, REGEX_JAVA_PACKAGE, OPTION_HANA } = require('../constants');
 
+const { CliError } = require('../../client/helper/errors');
+
+
+const cp = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(cp.exec);
+
+
 const DEFAULT_GROUP_ID = 'customer';
 
 const LOG = console
-const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) && console.debug
+const cds = require('../../cds')
+const DEBUG = cds.debug('cli')
 
 class MvnArchetypeUtil {
 
@@ -88,7 +97,7 @@ class MvnArchetypeUtil {
         return packageName.toLowerCase().replace(/-/g, '_').replace(/\.([0-9])/g, '._$1').replace(/^([0-9])/, '_$1').replace(/\.+/g, '.');
     }
 
-    getGenerateCmdArgs(projectName, options) {
+    async getGenerateCmdArgs(projectName, options) {
         const params = new Map();
 
         // set header
@@ -115,6 +124,29 @@ class MvnArchetypeUtil {
             this._scanMvnParams(options[OPTION_JAVA_MVN], params);
         }
 
+        // -DjdkVersion=[11|17]
+        if (!params.get('-DjdkVersion')) {
+            try {
+                const javaVersion = await execAsync('java -version');
+                const match = javaVersion?.stderr?.match(/version\s*"?(\d+\.\d+\.\d+)"?/);
+                if (match?.[1]) {
+                    const segments = match[1]?.split('.');
+                    const version = new Number(segments?.[0]);
+                    switch (true) {
+                        case (version < 11): throw new CliError(`Java version ${match[1]} is not supported. Use Java 11 or higher.`);
+                        case (version <= 16): params.set(`-DjdkVersion`, 11); break;
+                        case (version > 16): params.set(`-DjdkVersion`, 17); break;
+                        default:
+                    }
+                }
+            } catch (err) {
+                if (err instanceof CliError) {
+                    throw err;
+                }
+                DEBUG?.(err);
+            }
+        }
+
         if (options[OPTION_JAVA_PACKAGE]) {
             params.set(`-Dpackage`, options[OPTION_JAVA_PACKAGE]);
         }

package/lib/init/util/projectReader.js

@@ -36,7 +36,7 @@ module.exports = new class ProjectReader {
     }
 
     async readProject(options) {
-        if (options?.cwd) cds.root = options.cwd
+        // if (options?.cwd) cds.root = options.cwd
 
         const env = this.getEnv()
         DEBUG && DEBUG({ env })

package/lib/watch/livereload-server.js

@@ -73,8 +73,9 @@ module.exports = class LiveReload {
       }
 
       process.once('shutdown', ()=>{
-        server.close()
+        this.wsServer.clients?.forEach(ws => ws.terminate())
         this.wsServer.close()
+        server.close()
       })
     })
   }
@@ -116,8 +117,12 @@ async function livereloadURL(address, port) {
       return
     }
   }
-  // Local case.  Add effective server address/host to URL so that e.g.
-  // 2 reload servers on same port but different network stacks (IPv4 and IPv6)
-  // can be uniquely addressed.
+  // Local case.  Add effective server address/host to URL.
+  // Make sure IPv6 addresses are properly escaped.
+  if (require('net').isIPv6(address)) {
+    // TODO remove as soon as IPv6 support in https://github.com/livereload/livereload-js/pull/103 is fixed
+    if (address === '::1')  address = 'localhost'
+    // address = `[${address}]`
+  }
   return `http://${address}:${port}/livereload.js?snipver=1`
 }