@sap/cds-dk 7.0.2 → 7.1.0

package/lib/import/odata/v4parser.js

@@ -82,7 +82,7 @@ const known_vocabularies = {
     'com.sap.vocabularies.UI.v1': 'UI',
 };
 
-function _initialize(parserContext) {
+function _initialize(parserContext, mockServerUc) {
     parserContext.unboundedActions = {};
     parserContext.unboundedFunctions = {};
     parserContext.entityTypes = [];
@@ -103,8 +103,8 @@ function _initialize(parserContext) {
     parserContext.entityToBoundedActions = {};
     parserContext.entityToBoundedFunctions = {};
     parserContext.entityContainerAnnotations = {};
+    parserContext.mockServerUc = mockServerUc;
 }
-
 function _isJson(edmx) {
     let isJson = false;
     try {
@@ -124,8 +124,8 @@ function _extractSchemaNameAndElementName(name) {
 }
 
 /**
- * @param {String} fqName 
- * @param {String} schemaName 
+ * @param {String} fqName
+ * @param {String} schemaName
  * @param {Object} parserContext
  * @returns index of schemaName in the schemaDataList
  */
@@ -155,31 +155,16 @@ function _resolveAliasedElementName(fqName, parserContext) {
     return schemaName + '.' + elementName;
 }
 
-function _isValidJSON(jsonObj, parserContext, context) {
-    if (jsonObj.$Version && _hasEntityContainer(jsonObj, parserContext, context) && jsonObj[parserContext.primarySchema]) {
-        return true;
+function _collectPrimarySchemaContext(jsonObj, parserContext, importerContext) {
+    let jsonObjEntityContainer = jsonObj.$EntityContainer;
+    if (jsonObjEntityContainer) {
+        // scenario: Schema Namespace="A.B.C.D" & jsonObjEntityContainer is "A.B.C.D.EntityContainerName"
+        [parserContext.primarySchema, parserContext.entityContainerName] = _extractSchemaNameAndElementName(jsonObjEntityContainer);
+        // required for `--keep-namespace` scenario
+        importerContext.schemaNamespace = parserContext.primarySchema;
     }
     else {
-        throw new Error(messages.INVALID_EDMX_METADATA);
-    }
-}
-
-function _hasEntityContainer(jsonObj, parserContext, context) {
-    let jsonObjEntityContainer = jsonObj.$EntityContainer;
-    try {
-        if (jsonObjEntityContainer) {
-            // scenario: Schema Namespace="A.B.C.D" & jsonObjEntityContainer is "A.B.C.D.EntityContainerName"
-            [parserContext.primarySchema, parserContext.entityContainerName] = _extractSchemaNameAndElementName(jsonObjEntityContainer);
-            // required for `--keep-namespace` scenario
-            context.schemaNamespace = parserContext.primarySchema;
-        }
-        if (jsonObj[parserContext.primarySchema][parserContext.entityContainerName] &&
-            jsonObj[parserContext.primarySchema][parserContext.entityContainerName] instanceof Object
-        ) {
-            return true;
-        }
-    } catch (err) {
-        throw new Error(messages.MISSING_ENTITY_CONTAINER);
+        parserContext.mockServerUc = false;
     }
 }
 
@@ -213,7 +198,7 @@ function _updateElementObjectForDefaultValue(dataTypeObj, defaultvalue) {
 }
 
 function _updateDataTypeObjectForMaxLength(dataTypeObj, propertyDataType, maxLength) {
-    const mappedValue = edmToCdsTypeMappingWithMaxLength[propertyDataType]; 
+    const mappedValue = edmToCdsTypeMappingWithMaxLength[propertyDataType];
 
     if (mappedValue) {
         dataTypeObj.type = mappedValue
@@ -301,7 +286,7 @@ function _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObj
     if (annotationTerm === "@Core.Description" || annotationTerm === "@Core.LongDescription") {
         // we don't capture `null` value for doc
         if (annotationTermObject === null)  return;
-        
+
         annotationTermObject = _replaceSpecialCharacters(annotationTermObject);
 
         if (csnDefsTargetObject.doc) {
@@ -372,7 +357,7 @@ function _parseCapabilitiesTerm(annotationTerm, annotationTermObject, csnDefsTar
      * 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 (annotationTermObject instanceof Array || !(annotationTermObject instanceof Object)) {
@@ -433,8 +418,8 @@ function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTarg
 function _resolveAnotationTerm(schemaDataAnnotation, parserContext) {
     // Case 1: We have the Namespace and Alias for the vocabulary
     for (const [alias, namespace] of Object.entries(parserContext.vocabAliasToNamespace)) {
-        if (schemaDataAnnotation.includes(alias)) {
-            schemaDataAnnotation = schemaDataAnnotation.split(alias).join(known_vocabularies[namespace]);
+        if (schemaDataAnnotation.includes('@' + alias)) {
+            schemaDataAnnotation = schemaDataAnnotation.split('@' + alias).join('@' + known_vocabularies[namespace]);
         }
     }
     /**
@@ -452,10 +437,10 @@ function _resolveAnotationTerm(schemaDataAnnotation, parserContext) {
 
 /**
  * Capture all the annotation cases withtin an Element
- * 
+ *
  * UnKnown term: <Annotation Term="Org.OData.ASDF.V1.qwe"/>
  * Known term: <Annotation Term="Org.OData.Measures.V1.Unit" String="Centimeters"/>
- * 
+ *
  * if "--include-namespaces *" then we also capture for ABS and QWE
  * <TypeDefinition Name="TD_2" UnderlyingType="Edm.Int32" ABS:asdf="testing" QWE:qwe="testing"/>
  */
@@ -536,7 +521,7 @@ function _getEntityTypeMappedName(entityType, parserContext) {
     }
 }
 
-function _generateStructuredDataTypeCsn(dataType, propertyObject, isPrimaryKey, dataTypeKind, elementKind, mockServerUc, parserContext) {
+function _generateStructuredDataTypeCsn(dataType, propertyObject, isPrimaryKey, dataTypeKind, elementKind, parserContext) {
     const dataTypeObj = {};
     const isCollection = propertyObject.$Collection;
     const nullable = propertyObject.$Nullable;
@@ -558,7 +543,7 @@ function _generateStructuredDataTypeCsn(dataType, propertyObject, isPrimaryKey,
     }
 
     // if dataTypeKind is EntityType, also check for mapped entity name
-    if (mockServerUc && dataTypeKind === 'EntityType') {
+    if (parserContext.mockServerUc && dataTypeKind === 'EntityType') {
         // propertyDataType is resolved fully qualified name
         if (parserContext.entityToEntitySetMap?.get(propertyDataType)) {
             propertyDataType = _getEntityTypeMappedName(propertyDataType, parserContext);
@@ -578,9 +563,9 @@ function _generateStructuredDataTypeCsn(dataType, propertyObject, isPrimaryKey,
     }
     /**
      * only Primitive type and EnumType can have DefaultValue facet as per documentation
-     * but compiler accepts it for TypeDefintion and ComplexType as well, 
+     * but compiler accepts it for TypeDefintion and ComplexType as well,
      * do we also need to handle it for TypeDefintion and ComplexType?
-     * 
+     *
      * For parameters, default value is added via OptionalParamter Annotation
      */
     if (defaultvalue && dataTypeKind === 'EnumType' && elementKind === 'property') {
@@ -594,7 +579,7 @@ function _generateStructuredDataTypeCsn(dataType, propertyObject, isPrimaryKey,
     return dataTypeObj;
 }
 
-function _parseAssociationProperty(foreignReference, associationNode, mockServerUc, parserContext) {
+function _parseAssociationProperty(foreignReference, associationNode, parserContext) {
     const associationProperty = {};
     let foreignKeys;
     // var foreignReference = associationNode.$Type;
@@ -626,7 +611,7 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
         );
     }
 
-    if (mockServerUc && entityTypeMapping) {
+    if (parserContext.mockServerUc && entityTypeMapping) {
         if (entityTypeMapping.length > 1) {
             for (let j = 0; j < entityTypeMapping.length; j++) {
                 if (entityTypeMapping[j] === foreignReference) {
@@ -712,7 +697,7 @@ function _checkIsStructureTypeAndReturnDataKind(dataType, contentObject, element
  * @param {Object} elementObj
  * @param {Object} parserContext
  */
-function _parsePropertyContent(csnObj, elementObj, mockServerUc, parserContext) {
+function _parsePropertyContent(csnObj, elementObj, parserContext) {
     let contentObj = {};
     const isPrimaryKey = true;
     let dataType, isPrimitiveType, keySet = [];
@@ -748,17 +733,17 @@ function _parsePropertyContent(csnObj, elementObj, mockServerUc, parserContext)
                     if (['EnumType', 'TypeDefinition'].includes(dataKind)) {
                         csnObj.elements[objKey] = _generateStructuredDataTypeCsn(dataType, contentObj,
                             (keySet.includes(dataType) ? isPrimaryKey : !isPrimaryKey),
-                            dataKind, 'property', mockServerUc, parserContext
+                            dataKind, 'property', parserContext
                         );
                     }
                     else {
                         csnObj.elements[objKey] = _generateStructuredDataTypeCsn(dataType, contentObj,
-                            !isPrimaryKey, dataKind, 'property', mockServerUc, parserContext
+                            !isPrimaryKey, dataKind, 'property', parserContext
                         );
                     }
                 }
                 else if (contentKind === 'NavigationProperty') {
-                    csnObj.elements[objKey] = _parseAssociationProperty(objKey, elementObj[objKey], mockServerUc, parserContext);
+                    csnObj.elements[objKey] = _parseAssociationProperty(objKey, elementObj[objKey], parserContext);
                 }
             }
         }
@@ -837,7 +822,7 @@ function _captureOpenTypes(fqName, csnObj, elementObj, isEntity, mockServerUc, p
     }
 }
 
-function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, entityList, parserContext) {
+function _generateCSNForEntityType(ignorePersistenceSkip, entityList, parserContext) {
     const csnEntity = {};
     let isEntity = true;
     entityList.forEach(entityElement => {
@@ -851,12 +836,12 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, entityLi
             csnEntity[entityName]['@cds.persistence.skip'] = true;
         }
 
-        _captureOpenTypes(entityName, csnEntity[entityName], entityElement[entityName], isEntity, mockServerUc, parserContext);
+        _captureOpenTypes(entityName, csnEntity[entityName], entityElement[entityName], isEntity, parserContext.mockServerUc, parserContext);
         _captureAnnotationWithinElement(entityElement[entityName], csnEntity[entityName], parserContext);
 
         csnEntity[entityName].elements = {};
 
-        _parsePropertyContent(csnEntity[entityName], entityElement[entityName], mockServerUc, parserContext);
+        _parsePropertyContent(csnEntity[entityName], entityElement[entityName], parserContext);
 
         // needs to be checked if this is necessary
         if (entityElement[entityName].$HasStream) {
@@ -871,7 +856,7 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, entityLi
     return csnEntity;
 }
 
-function _parseCSNForEntityType(schemaData, ignorePersistenceSkip, mockServerUc, parserContext) {
+function _parseCSNForEntityType(schemaData, ignorePersistenceSkip, parserContext) {
     let entitiesList = [];
     for (let fqName of parserContext.entityTypes) {
         let entity = {};
@@ -884,10 +869,10 @@ function _parseCSNForEntityType(schemaData, ignorePersistenceSkip, mockServerUc,
         }
     }
 
-    return _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, entitiesList, parserContext);
+    return _generateCSNForEntityType(ignorePersistenceSkip, entitiesList, parserContext);
 }
 
-function _parseParameterAndReturnTypeContent(elementObject, mockServerUc, parserContext) {
+function _parseParameterAndReturnTypeContent(elementObject, parserContext) {
     let dataType = elementObject.$Type;
     const isPrimitiveType = dataType.startsWith('Edm') ? true : false;
     const isPrimaryKey = true;
@@ -904,11 +889,11 @@ function _parseParameterAndReturnTypeContent(elementObject, mockServerUc, parser
     // structured type
     else {
         const dataKind = _checkIsStructureTypeAndReturnDataKind(dataType, elementObject, 'parameter', parserContext);
-        return _generateStructuredDataTypeCsn(dataType, elementObject, !isPrimaryKey, dataKind, 'parameter', mockServerUc, parserContext);
+        return _generateStructuredDataTypeCsn(dataType, elementObject, !isPrimaryKey, dataKind, 'parameter', parserContext);
     }
 }
 
-function _generateCSNForBoundedActionFunction(actionFunctionObject, kind, mockServerUc, parserContext) {
+function _generateCSNForBoundedActionFunction(actionFunctionObject, kind, parserContext) {
     const csnObj = {};
     const isBounded = actionFunctionObject.$IsBound;
     const parameters = actionFunctionObject.$Parameter;
@@ -922,7 +907,7 @@ function _generateCSNForBoundedActionFunction(actionFunctionObject, kind, mockSe
 
         for (let index = 0; index < parameters.length; index++) {
             let isCollection = parameters[index].$Collection;
-            csnObj.params[parameters[index].$Name] = _parseParameterAndReturnTypeContent(parameters[index], mockServerUc, parserContext);
+            csnObj.params[parameters[index].$Name] = _parseParameterAndReturnTypeContent(parameters[index], parserContext);
             /**
              * binding parameter handling - only first parameter will contain the binding
              * parameter information, so only make change to the first parameter information.
@@ -940,13 +925,13 @@ function _generateCSNForBoundedActionFunction(actionFunctionObject, kind, mockSe
         }
     }
     if (returnType) {
-        csnObj.returns = _parseParameterAndReturnTypeContent(returnType, mockServerUc, parserContext);
+        csnObj.returns = _parseParameterAndReturnTypeContent(returnType, parserContext);
     }
 
     return csnObj;
 }
 
-function _parseBoundedActionFunction(schemaData, csnObj, kind, mockServerUc, parserContext) {
+function _parseBoundedActionFunction(schemaData, csnObj, kind, parserContext) {
     const boundedObject = (kind === 'action') ? parserContext.entityToBoundedActions : parserContext.entityToBoundedFunctions;
 
     Object.keys(boundedObject).forEach(fqEntityName => {
@@ -960,14 +945,14 @@ function _parseBoundedActionFunction(schemaData, csnObj, kind, mockServerUc, par
             }
             Object.keys(actionFunctionObjectList).forEach(actionFunctionName => {
                 csnObj[fqEntityName].actions[actionFunctionName] = _generateCSNForBoundedActionFunction(
-                    actionFunctionObjectList[actionFunctionName], kind, mockServerUc, parserContext
+                    actionFunctionObjectList[actionFunctionName], kind, parserContext
                 );
             });
         }
     });
 }
 
-function _parseUnBoundedActionFunction(schemaData, kind, mockServerUc, parserContext) {
+function _parseUnBoundedActionFunction(schemaData, kind, parserContext) {
     const unBoundedObject = (kind === 'action') ? parserContext.unboundedActions : parserContext.unboundedFunctions;
     const csnObj = {};
 
@@ -988,11 +973,11 @@ function _parseUnBoundedActionFunction(schemaData, kind, mockServerUc, parserCon
                 csnObj[fqName].params = {};
 
                 for (let paramObj of parameters) {
-                    csnObj[fqName].params[paramObj.$Name] = _parseParameterAndReturnTypeContent(paramObj, mockServerUc, parserContext);
+                    csnObj[fqName].params[paramObj.$Name] = _parseParameterAndReturnTypeContent(paramObj, parserContext);
                 }
             }
             if (returnType) {
-                csnObj[fqName].returns = _parseParameterAndReturnTypeContent(returnType, mockServerUc, parserContext);
+                csnObj[fqName].returns = _parseParameterAndReturnTypeContent(returnType, parserContext);
             }
         }
     });
@@ -1000,7 +985,7 @@ function _parseUnBoundedActionFunction(schemaData, kind, mockServerUc, parserCon
     return csnObj;
 }
 
-function _parserCSNForComplexType(schemaData, mockServerUc, parserContext) {
+function _parserCSNForComplexType(schemaData, parserContext) {
     const complexCsn = {};
     const isEntity = true;
 
@@ -1014,9 +999,9 @@ function _parserCSNForComplexType(schemaData, mockServerUc, parserContext) {
             complexCsn[fqName]['@cds.external'] = true;
             complexCsn[fqName].elements = {};
             // inheritance handling
-            _captureOpenTypes(fqName, complexCsn[fqName], complexObj, !isEntity, !mockServerUc, parserContext);
+            _captureOpenTypes(fqName, complexCsn[fqName], complexObj, !isEntity, !parserContext.mockServerUc, parserContext);
             _captureAnnotationWithinElement(complexObj, complexCsn[fqName], parserContext);
-            _parsePropertyContent(complexCsn[fqName], complexObj, mockServerUc, parserContext);
+            _parsePropertyContent(complexCsn[fqName], complexObj, parserContext);
         }
     }
     // add @open annotations
@@ -1102,7 +1087,7 @@ function _resolveEntityContainerAnnotationTarget(targetPath, csnDefs, hasPropert
     /**
      * format: <schemaName_or_Alias><EntityContainerName>/<ContainerElement>
      * <schemaName_or_Alias><EntityContainerName>/<ContainerElement>/...
-     * 
+     *
      * needs to be handled without 'EntityContainerName'
      */
     if (hasProperty) {
@@ -1167,7 +1152,7 @@ function _resolveAnnotationTarget(targetPath, csnDefs, parserContext) {
     const indexOfOpenBrace = targetPath.indexOf('(');
     const hasPropOrParam = (indexOfSlash > 0);
     let elemNameList, fqName;
- 
+
     // Case 1: Direct path
     if (indexOfOpenBrace === -1 && indexOfSlash === -1) {
         fqName = _resolveAliasedElementName(targetPath, parserContext);
@@ -1224,7 +1209,7 @@ function _parseEntityContainer(csnDefs, entityContainerElements, parserContext)
     entityContainerElementNames.forEach(ecElement => {
         if (entityContainerElements[ecElement] instanceof Object) {
             let definitionRefName, kind;
-            
+
             if (entityContainerElements[ecElement].$Action) {
                 definitionRefName = entityContainerElements[ecElement].$Action;
                 kind = 'action';
@@ -1245,7 +1230,7 @@ function _parseEntityContainer(csnDefs, entityContainerElements, parserContext)
             /**
              * For now we don't support the collision between entitycontainer element name
              * and any of the schema elemetents like entitytype, complextype, etc.
-             * TODO: In future we might have to support it. 
+             * TODO: In future we might have to support it.
              */
             if (csnDefs[fqElementName] && csnDefs[fqElementName].kind !== kind) {
                 throw new Error(messages.ELEMENT_NAME_COLLISION + ecElement);
@@ -1315,7 +1300,7 @@ function _collectAllParameters(dataObjList) {
  * @param {String} fqName, fully qualified name
  * @param {List<Object>} schemaDataList
  * @param {Object} parserContext
- * 
+ *
  * Scenarios:
  * 1. UnBounded Actions can't have collision. Action name must be unique.
  * 2. UnBounded Functions can have collision; capture the max number of parameters.
@@ -1366,7 +1351,7 @@ function _collectUnboundedActionFunction(schemaDataList, parserContext) {
  * @param {String} elementName
  * @param {List<Object>} elementDataList, bounded action/function details
  * @param {Object} parserContext
- * 
+ *
  * Scenarios for bounded actions, functions:
  * 1. Actions with same name and binding parameter type can't have collision.
  * 2. Functions can have collision and we will capture the max number of parameters.
@@ -1472,7 +1457,7 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
                      * we only have a single entity container
                      */
                     if (currNamespace === parserContext.primarySchema) {
-                        Object.keys(schemaData.$Annotations).forEach(annotationTarget => { 
+                        Object.keys(schemaData.$Annotations).forEach(annotationTarget => {
                             if (annotationTarget.includes(parserContext.entityContainerName)) {
                                 parserContext.entityContainerAnnotations[annotationTarget] = schemaData.$Annotations[annotationTarget];
                                 /**
@@ -1489,7 +1474,8 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
     }
 }
 
-function _preProcess(edmxAsJson, mockServerUc, parserContext) {
+function _preProcess(edmxAsJson, parserContext, importerContext) {
+    _collectPrimarySchemaContext(edmxAsJson, parserContext, importerContext);
     let schemaDataList = [], indexOfSchema = 0;
 
     Object.keys(edmxAsJson).forEach(schemaName => {
@@ -1505,7 +1491,7 @@ function _preProcess(edmxAsJson, mockServerUc, parserContext) {
             indexOfSchema++;
         }
         // if mock server use case & traversing primary schema, collect relevant mappings
-        if (mockServerUc && schemaName === parserContext.primarySchema) {
+        if (parserContext.mockServerUc && schemaName === parserContext.primarySchema) {
             let entityContainerData = schemaData[parserContext.entityContainerName];
             Object.keys(entityContainerData).forEach(elementName => {
                 let elementObj = entityContainerData[elementName];
@@ -1531,18 +1517,27 @@ function _preProcess(edmxAsJson, mockServerUc, parserContext) {
         }
     });
 
+    // if mockServerUc='true' and EntityContainer has no content, we set the value to false
+    if (parserContext.mockServerUc &&
+        parserContext.entityToEntitySetMap._.size === 0 &&
+        parserContext.entityToSingletonMap._.size === 0 &&
+        parserContext.actionToActionImportMap._.size === 0 &&
+        parserContext.functionToFunctionImportMap._.size === 0) {
+        parserContext.mockServerUc = false;
+    }
+
     _collectSchemaElements(edmxAsJson, schemaDataList, parserContext);
 
     return schemaDataList;
 }
 
-function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserContext) {
+function _generateCSN(edmxAsJson, ignorePersistenceSkip, parserContext, importerContext) {
     let csn = {};
     csn.meta = {};
     csn.meta.creator = 'cds-dk ' + versionInfo;
     csn.$version = '2.0';
     csn.definitions = {};
-    let schemaDataList = _preProcess(edmxAsJson, mockServerUc, parserContext);
+    let schemaDataList = _preProcess(edmxAsJson, parserContext, importerContext);
 
     for (let schemaData of schemaDataList) {
         // Step 1: parse all type definition
@@ -1550,15 +1545,15 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserCon
         // Step 2: parse all enum types
         csn.definitions = Object.assign(_parseCSNForEnumType(schemaData, parserContext), csn.definitions);
         // Step 3: parse all complex types
-        csn.definitions = Object.assign(_parserCSNForComplexType(schemaData, mockServerUc, parserContext), csn.definitions);
+        csn.definitions = Object.assign(_parserCSNForComplexType(schemaData, parserContext), csn.definitions);
         // Step 4: parse all entity type
-        csn.definitions = Object.assign(_parseCSNForEntityType(schemaData, ignorePersistenceSkip, mockServerUc, parserContext), csn.definitions);
+        csn.definitions = Object.assign(_parseCSNForEntityType(schemaData, ignorePersistenceSkip, parserContext), csn.definitions);
         // Step 5: parse all bounded action & function
-        _parseBoundedActionFunction(schemaData, csn.definitions, 'action', mockServerUc, parserContext);
-        _parseBoundedActionFunction(schemaData, csn.definitions, 'function', mockServerUc, parserContext);
+        _parseBoundedActionFunction(schemaData, csn.definitions, 'action', parserContext);
+        _parseBoundedActionFunction(schemaData, csn.definitions, 'function', parserContext);
         // Step 6: parse all unbounded action & function
-        csn.definitions = Object.assign(_parseUnBoundedActionFunction(schemaData, 'action', mockServerUc, parserContext), csn.definitions);
-        csn.definitions = Object.assign(_parseUnBoundedActionFunction(schemaData, 'function', mockServerUc, parserContext), csn.definitions);
+        csn.definitions = Object.assign(_parseUnBoundedActionFunction(schemaData, 'action', parserContext), csn.definitions);
+        csn.definitions = Object.assign(_parseUnBoundedActionFunction(schemaData, 'function', parserContext), csn.definitions);
         // Step 7: parse all annotations
         if (schemaData.$Annotations) {
             _parseAnnotations(schemaData.$Annotations, csn.definitions, parserContext);
@@ -1566,7 +1561,7 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserCon
     }
 
     // add Service object and EntityContainer items only if it is mock server use case
-    if (mockServerUc) {
+    if (parserContext.mockServerUc) {
         csn.definitions[parserContext.primarySchema] = {};
         csn.definitions[parserContext.primarySchema].kind = 'service';
         csn.definitions[parserContext.primarySchema]['@cds.external'] = true;
@@ -1580,7 +1575,7 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserCon
     return JSON.stringify(csn, null, 4);
 }
 
-function _generateEDMX2JSON(edmx, name_space, parserContext, context) {
+function _generateEDMX2JSON(edmx, name_space) {
     return new Promise(function getJson(resolve, reject) {
         try {
             const inputBuffer = edmx;
@@ -1590,9 +1585,7 @@ function _generateEDMX2JSON(edmx, name_space, parserContext, context) {
                 if (missingReferencedDocuments?.length > 0) {
                     console.log(missingReferencedDocuments); // eslint-disable-line no-console
                 }
-                if (_isValidJSON(json, parserContext, context)) {
-                    resolve(json);
-                }
+                resolve(json);
             });
         } catch (err) {
             reject(err);
@@ -1600,37 +1593,34 @@ function _generateEDMX2JSON(edmx, name_space, parserContext, context) {
     });
 }
 
-async function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
+async function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, importerContext) {
     let csn;
     let edmjConverted;
     let name_space = [];
 
     const parserContext = {};
-    _initialize(parserContext);
+    _initialize(parserContext, mockServerUc);
 
-    if (context.include_all_namespaces) {
+    if (importerContext.include_all_namespaces) {
         name_space.push(true);
     }
     else {
-        name_space = context.namespaces;
+        name_space = importerContext.namespaces;
     }
 
     if (_isJson(edmx)) {
         return new Promise(function getCsn(resolve, reject) {
             try {
                 edmjConverted = JSON.parse(edmx);
-                if (_isValidJSON(edmjConverted, parserContext, context)) {
-                    csn = _generateCSN(edmjConverted, ignorePersistenceSkip, mockServerUc, parserContext);
-                    if (csn) resolve(csn);
-                }
+                csn = _generateCSN(edmjConverted, ignorePersistenceSkip, parserContext, importerContext);
+                if (csn) resolve(csn);
             } catch (err) {
                 reject(err);
             }
         });
     }
-    const edmj = await _generateEDMX2JSON(edmx, name_space, parserContext, context);
-
-    return _generateCSN(edmj, ignorePersistenceSkip, mockServerUc, parserContext);
+    const edmj = await _generateEDMX2JSON(edmx, name_space);
+    return _generateCSN(edmj, ignorePersistenceSkip, parserContext, importerContext);
 }
 
 module.exports = {

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '2.0.1';
+const MAVEN_ARCHETYPE_VERSION = '2.0.2';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),