@sap/cds-dk 6.0.4 → 6.1.3

package/lib/compile/openapi/csdl2openapi.js

@@ -7,10 +7,9 @@ var pluralize = require('pluralize')
 //TODO
 // - Core.Example for complex types
 // - reduce number of loops over schemas
-// - inject $Name or $$Name into each model element to make parameter passing easier?
+// - inject $$name into each model element to make parameter passing easier?
 // - allow passing additional files for referenced documents
 // - delta: headers Prefer and Preference-Applied
-// - response codes and descriptions - https://issues.oasis-open.org/browse/ODATA-884
 // - inline definitions for Edm.* to make OpenAPI documents self-contained
 // - both "clickable" and freestyle $expand, $select, $orderby - does not work yet, open issue for OpenAPI UI
 // - system query options for actions/functions/imports depending on $Collection
@@ -21,6 +20,18 @@ var pluralize = require('pluralize')
 // - InsertRestrictions/NonInsertableNavigationProperties
 // - see //TODO comments below
 
+const SUFFIX = {
+    read: "",
+    create: "-create",
+    update: "-update",
+  };
+  
+  const TITLE_SUFFIX = {
+    "": "",
+    "-create": " (for create)",
+    "-update": " (for update)",
+  };
+  
 /**
  * Construct an OpenAPI description from a CSDL document
  * @param {object} csdl CSDL document
@@ -31,6 +42,7 @@ module.exports.csdl2openapi = function (
     csdl,
     {
         url: serviceRoot,
+        servers: serversObject,
         scheme: scheme = 'https',
         host: host = 'localhost',
         basePath: basePath = '/service-root',
@@ -47,6 +59,8 @@ module.exports.csdl2openapi = function (
     const namespace = { 'Edm': 'Edm' };
     const namespaceUrl = {};
     const voc = {};
+    const requiredSchemas = { list: [], used: {} };
+
     preProcess(csdl, boundOverloads, derivedTypes, alias, namespace, namespaceUrl, voc);
 
     const entityContainer = csdl.$EntityContainer ? modelElement(csdl.$EntityContainer) : {};
@@ -59,7 +73,7 @@ module.exports.csdl2openapi = function (
         'x-sap-api-type': 'ODATAV4',
         'x-odata-version': '4.0',
         'x-sap-shortText': getShortText(csdl, entityContainer),
-        servers: getServers(serviceRoot),
+        servers: getServers(serviceRoot, serversObject),
         tags: entityContainer ? getTags(entityContainer) : {},
         paths: entityContainer ? getPaths(entityContainer) : {},
         components: getComponents(csdl, entityContainer)
@@ -152,7 +166,7 @@ module.exports.csdl2openapi = function (
                     );
                 }
                 if (!element) {
-                    // console.warn(`Invalid annotation target '${target}'`)
+                    console.warn(`Invalid annotation target '${target}'`);
                 } else if (Array.isArray(element)) {
                     //TODO: action or function:
                     //- loop over all overloads
@@ -165,7 +179,8 @@ module.exports.csdl2openapi = function (
                         case 2:
                             if (['Action', 'Function'].includes(element.$Kind)) {
                                 if (segments[1] == '$ReturnType') {
-                                    Object.assign(element.$ReturnType, annotations);
+                                    if (element.$ReturnType)
+                                        Object.assign(element.$ReturnType, annotations);
                                 } else {
                                     const parameter = element.$Parameter.find(p => p.$Name == segments[1]);
                                     Object.assign(parameter, annotations);
@@ -407,12 +422,27 @@ module.exports.csdl2openapi = function (
 
     /**
      * Construct an array of Server Objects
-     * @param {object} csdl The CSDL document
-     * @param {object} options Optional parameters
+     * @param {object} serviceRoot The service root
+     * @param {object} serversObject Input servers object
      * @return {Array} The list of servers
      */
-    function getServers(serviceRoot) {
-        return [{ url: serviceRoot }];
+    function getServers(serviceRoot, serversObject) {
+        let servers;
+
+        if (serversObject) {
+            try {
+                servers = JSON.parse(serversObject);
+            } catch (err) {
+                throw new Error(`The input server object is invalid.`);
+            }
+
+            if(!servers.length){
+                throw new Error(`The input server object should be an array.`);
+            }
+        } else {
+            servers = [{ url: serviceRoot }];
+        }
+        return servers;
     }
 
     /**
@@ -484,7 +514,7 @@ module.exports.csdl2openapi = function (
         const nonExpandable = nonExpandableProperties(root, navigationPath);
 
         paths[prefix] = pathItem;
-        if (prefixParameters.length > 0) paths[prefix].parameters = prefixParameters;
+        if (prefixParameters.length > 0) pathItem.parameters = prefixParameters;
 
         operationRead(pathItem, element, name, sourceName, targetName, target, level, restrictions, false, nonExpandable);
         if (element.$Collection && (element.$ContainsTarget || level < 2 && target)) {
@@ -505,6 +535,9 @@ module.exports.csdl2openapi = function (
                 pathItemsWithNavigation(paths, prefix, prefixParameters, type, root, sourceName, level, navigationPath);
             }
         }
+
+        if (Object.keys(pathItem).filter((i) => i !== "parameters").length === 0)
+            delete paths[prefix];
     }
 
     /**
@@ -568,6 +601,8 @@ module.exports.csdl2openapi = function (
                 operationRead(pathItem, element, name, sourceName, targetName, target, level, restrictions, true, nonExpandable);
                 operationUpdate(pathItem, element, name, sourceName, target, level, restrictions, true);
                 operationDelete(pathItem, element, name, sourceName, target, level, restrictions, true);
+                if (Object.keys(pathItem).filter((i) => i !== "parameters").length === 0)
+                    delete paths[path];
 
                 pathItemsForBoundOperations(paths, path, parameters, element, sourceName, true);
                 pathItemsWithNavigation(paths, path, parameters, type, root, sourceName, level, navigationPath);
@@ -600,11 +635,11 @@ module.exports.csdl2openapi = function (
                     required: true,
                     content: {
                         'application/json': {
-                            schema: ref(element.$Type, '-create')
+                            schema: ref(element.$Type, SUFFIX.create),
                         }
                     }
                 },
-                responses: response(201, 'Created ' + lname, { $Type: element.$Type })
+                responses: response(201, 'Created ' + lname, { $Type: element.$Type }, insertRestrictions.ErrorResponses),
             };
             if (insertRestrictions.LongDescription) pathItem.post.description = insertRestrictions.LongDescription;
             if (targetName && sourceName != targetName) pathItem.post.tags.push(targetName);
@@ -657,7 +692,7 @@ module.exports.csdl2openapi = function (
      * @param {array} nonExpandable Non-expandable navigation properties
      */
     function operationRead(pathItem, element, name, sourceName, targetName, target, level, restrictions, byKey, nonExpandable) {
-        const targetRestrictions = target && target[voc.Capabilities.ReadRestrictions];
+        const targetRestrictions = target?.[voc.Capabilities.ReadRestrictions];
         const readRestrictions = restrictions.ReadRestrictions || targetRestrictions || {};
         const readByKeyRestrictions = readRestrictions.ReadByKeyRestrictions;
         let readable = true;
@@ -675,7 +710,8 @@ module.exports.csdl2openapi = function (
                 summary: descriptions.Description || operationSummary('Retrieve', name, sourceName, level, element.$Collection, byKey),
                 tags: [sourceName],
                 parameters: [],
-                responses: response(200, 'Retrieved ' + (byKey ? pluralize.singular(lname) : lname), { $Type: element.$Type, $Collection: collection })
+                responses: response(200, 'Retrieved ' + (byKey ? pluralize.singular(lname) : lname), { $Type: element.$Type, $Collection: collection },
+                byKey ? readByKeyRestrictions?.ErrorResponses : readRestrictions?.ErrorResponses)
             };
             const deltaSupported = element[voc.Capabilities.ChangeTracking] && element[voc.Capabilities.ChangeTracking].Supported;
             if (!byKey && deltaSupported) {
@@ -1125,11 +1161,11 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
                     required: true,
                     content: {
                         'application/json': {
-                            schema: ref(element.$Type, '-update')
+                            schema: ref(element.$Type, SUFFIX.update),
                         }
                     }
                 },
-                responses: response(204, 'Success')
+                responses: response(204, "Success", undefined, updateRestrictions.ErrorResponses),
             };
             if (updateRestrictions.LongDescription) operation.description = updateRestrictions.LongDescription;
             customParameters(operation, updateRestrictions);
@@ -1156,7 +1192,7 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
             pathItem.delete = {
                 summary: deleteRestrictions.Description || operationSummary('Delete', name, sourceName, level, element.$Collection, byKey),
                 tags: [sourceName],
-                responses: response(204, 'Success')
+                responses: response(204, "Success", undefined, deleteRestrictions.ErrorResponses),
             };
             if (deleteRestrictions.LongDescription) pathItem.delete.description = deleteRestrictions.LongDescription;
             customParameters(pathItem.delete, deleteRestrictions);
@@ -1374,9 +1410,8 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
             post: {
                 summary: actionImport[voc.Core.Description] || overload[voc.Core.Description] || 'Invoke action ' + name,
                 tags: [overload[voc.Common.Label] || sourceName || 'Service Operations'],
-                responses: overload.$ReturnType
-                    ? response(200, 'Success', overload.$ReturnType)
-                    : response(204, 'Success')
+                responses: overload.$ReturnType ? response(200, "Success", overload.$ReturnType, overload[voc.Capabilities.OperationRestrictions]?.ErrorResponses)
+                : response(204, "Success", undefined, overload[voc.Capabilities.OperationRestrictions]?.ErrorResponses),
             }
         };
         const description = actionImport[voc.Core.LongDescription] || overload[voc.Core.LongDescription];
@@ -1487,7 +1522,7 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
                 summary: functionImport[voc.Core.Description] || overload[voc.Core.Description] || 'Invoke function ' + name,
                 tags: [overload[voc.Common.Label] || sourceName || 'Service Operations'],
                 parameters: prefixParameters.concat(params),
-                responses: response(200, 'Success', overload.$ReturnType)
+                responses: response(200, "Success", overload.$ReturnType, overload[voc.Capabilities.OperationRestrictions]?.ErrorResponses),
             }
         };
         const iDescription = functionImport[voc.Core.LongDescription] || overload[voc.Core.LongDescription];
@@ -1561,8 +1596,9 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
      * @param {string} code HTTP response code
      * @param {string} description Description
      * @param {object} type Response type object
+     * @param {array} errors Array of operation-specific status codes with descriptions
      */
-    function response(code, description, type = {}) {
+     function response(code, description, type, errors) {
         const r = {};
         r[code] = {
             description: description
@@ -1584,8 +1620,21 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
                 }
             };
         }
-        r['4XX'] = {
-            $ref: '#/components/responses/error'
+        if (errors) {
+            for (const e of errors) {
+                r[e.StatusCode] = {
+                    description: e.Description,
+                    content: {
+                        "application/json": {
+                            schema: { $ref: "#/components/schemas/error" },
+                        },
+                    },
+                };
+            }
+        } else {
+            r["4XX"] = {
+                $ref: "#/components/responses/error",
+            };
         }
         return r;
     }
@@ -1626,34 +1675,37 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
      * @return {object} Map of Schema Objects
      */
     function getSchemas(csdl) {
-        const s = {};
-
-        Object.keys(csdl).filter(key => isIdentifier(key)).forEach(namespace => {
-            Object.keys(csdl[namespace]).filter(key => isIdentifier(key)).forEach(name => {
-                const type = csdl[namespace][name];
-                switch (type.$Kind) {
-                    case 'ComplexType':
-                    case 'EntityType':
-                        schemasForStructuredType(s, namespace, name, type);
-                        break;
-                    case 'EnumType':
-                        schemaForEnumerationType(s, namespace, name, type);
-                        break;
-                    case 'TypeDefinition':
-                        schemaForTypeDefinition(s, namespace, name, type);
-                        break;
-                }
-            });
-        });
+        const unordered = {};
+
+        for (const r of requiredSchemas.list) {
+            const type = modelElement(`${r.namespace}.${r.name}`);
+            if (!type) continue;
+            switch (type.$Kind) {
+                case "ComplexType":
+                case "EntityType":
+                    schemasForStructuredType(unordered, r.namespace, r.name, type, r.suffix);
+                    break;
+                case "EnumType":
+                    schemaForEnumerationType(unordered, r.namespace, r.name, type);
+                    break;
+                case "TypeDefinition":
+                    schemaForTypeDefinition(unordered, r.namespace, r.name, type);
+                    break;
+            }
+        }
+        const ordered = {};
+        for (const name of Object.keys(unordered).sort()) {
+            ordered[name] = unordered[name];
+        }
 
-        inlineTypes(s);
+        inlineTypes(ordered);
 
         if (csdl.$EntityContainer) {
-            s.count = count();
-            s.error = error();
+            ordered.count = count();
+            ordered.error = error();
         }
 
-        return s;
+        return ordered;
     }
 
     /**
@@ -1729,87 +1781,66 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
      * @param {object} schemas Map of Schema Objects to augment
      * @param {string} qualifier Qualifier for structured type
      * @param {string} name Simple name of structured type
+     * @param {string} suffix Suffix for read/create/update
      * @param {object} type Structured type
      * @return {object} Map of Schemas Objects
      */
-    function schemasForStructuredType(schemas, qualifier, name, type) {
-        const allName = qualifier + '.' + name;
-        const creName = allName + '-create';
-        const updName = allName + '-update';
+     function schemasForStructuredType(schemas, qualifier, name, type, suffix) {
+        const schemaName = qualifier + "." + name + suffix;
+        const baseName = qualifier + "." + name;
         const isKey = keyMap(type);
         const required = Object.keys(isKey);
-        const allProperties = {};
-        const creProperties = {};
-        const updProperties = {};
+        const schemaProperties = {};
 
         const properties = propertiesOfStructuredType(type);
         Object.keys(properties).forEach(iName => {
             const property = properties[iName];
-            allProperties[iName] = getSchema(property);
-            if ((Object.prototype.hasOwnProperty.call(property, '@Common.FieldControl')) && property['@Common.FieldControl'] === 'Mandatory') {
-                required.push(iName)
-            }
+            if (suffix === SUFFIX.read) schemaProperties[iName] = getSchema(property);
+            if((Object.prototype.hasOwnProperty.call(property, '@Common.FieldControl')) && property['@Common.FieldControl'] === 'Mandatory')
+                { required.push(iName) }
             if (property.$Kind == 'NavigationProperty') {
-                if (property.$Collection) {
-                    allProperties[`${iName}@${csdl.$Version === '4.0' ? 'odata.' : ''}count`] = ref('count');
+                if (property.$Collection && suffix === "") {
+                    schemaProperties[`${iName}@${csdl.$Version === '4.0' ? 'odata.' : ''}count`] = ref('count');
                 }
-                creProperties[iName] = getSchema(property, '-create');
-                if (deepUpdate)
-                    updProperties[iName] = getSchema(property, '-create');
+                if (suffix === SUFFIX.create)
+                    schemaProperties[iName] = getSchema(property, SUFFIX.create);
+                if (suffix === SUFFIX.update && deepUpdate)
+                    schemaProperties[iName] = getSchema(property, SUFFIX.create);
             } else {
-                if (property[voc.Core.Permissions] == 'Read' || property[voc.Core.Computed]) {
+                if (property[voc.Core.Permissions] != "Read" && !property[voc.Core.Computed] && property.$ContainsTarget) {
                     let index = required.indexOf(iName);
                     if (index != -1) required.splice(index, 1);
                 } else {
-                    creProperties[iName] = getSchema(property, '-create');
-                    if (!isKey[iName] && !property[voc.Core.Immutable])
-                        updProperties[iName] = getSchema(property, '-update');
+                    if (suffix === SUFFIX.create)
+                        schemaProperties[iName] = getSchema(property, SUFFIX.create);
+                    if (suffix === SUFFIX.update && !isKey[iName] && !property[voc.Core.Immutable])
+                        schemaProperties[iName] = getSchema(property, SUFFIX.update);
                 }
             }
         });
 
-        const title = name;
 
-        schemas[allName] = {
-            title: title,
+        schemas[schemaName] = {
+            title: (type[voc.Core.Description] || name) + TITLE_SUFFIX[suffix],
             type: 'object'
         };
-        if (Object.keys(allProperties).length > 0) schemas[allName].properties = allProperties;
+        if (Object.keys(schemaProperties).length > 0)
+            schemas[schemaName].properties = schemaProperties;
 
-        schemas[creName] = {
-            title: title + ' (for create)',
-            type: 'object',
-        };
-        if (Object.keys(creProperties).length > 0) schemas[creName].properties = creProperties;
-        if (required.length > 0) schemas[creName].required = required;
-
-        schemas[updName] = {
-            title: title + ' (for update)',
-            type: 'object'
-        };
-        if (Object.keys(updProperties).length > 0) schemas[updName].properties = updProperties;
+        if (suffix === SUFFIX.create && required.length > 0)
+            schemas[schemaName].required = required;
 
         const description = type[voc.Core.Description];
         if (description) {
-            schemas[allName].description = description;
-            schemas[creName].description = description;
-            schemas[updName].description = description;
+            schemas[schemaName].description = description;
         }
 
-        if (derivedTypes[allName]) {
-            schemas[allName].anyOf = [];
-            schemas[creName].anyOf = [];
-            schemas[updName].anyOf = [];
-            derivedTypes[allName].forEach(derivedType => {
-                schemas[allName].anyOf.push(ref(derivedType));
-                schemas[creName].anyOf.push(ref(derivedType, '-create'));
-                schemas[updName].anyOf.push(ref(derivedType, '-update'));
+        if (derivedTypes[baseName]) {
+            schemas[schemaName].anyOf = [];
+            derivedTypes[baseName].forEach((derivedType) => {
+              schemas[schemaName].anyOf.push(ref(derivedType, suffix));
             });
-            if (!type.$Abstract) {
-                schemas[allName].anyOf.push({});
-                schemas[creName].anyOf.push({});
-                schemas[updName].anyOf.push({});
-            }
+            if (!type.$Abstract) schemas[schemaName].anyOf.push({});
         }
     }
 
@@ -2215,6 +2246,10 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
             nsp = namespace[parts.qualifier];
             name = nsp + '.' + parts.name;
             url = namespaceUrl[nsp] || '';
+            if (url === "" && !requiredSchemas.used[name + suffix]) {
+                requiredSchemas.used[name + suffix] = true;
+                requiredSchemas.list.push({ namespace: nsp, name: parts.name, suffix });
+            }
             //TODO: introduce better way than guessing
             if (url.endsWith('.xml')) url = url.substring(0, url.length - 3) + "openapi3.json";
         }
@@ -2347,67 +2382,4 @@ see [Expand](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part1-prot
         return !name.startsWith('$') && !name.includes('@');
     }
 
-}
-
-
-/**
- * Delete referenced Schema and Parameter Objects from an OpenAPI description
- * @param {object} openapi OpenAPI description
- */
-module.exports.deleteUnreferencedSchemas = function (openapi) {
-    var gReferenced;
-    var gDeleted;
-
-    do {
-        gReferenced = {};
-        getReferencedSchemas(openapi, gReferenced);
-        gDeleted = deleteUnreferenced(openapi.components.schemas, gReferenced, '#/components/schemas/');
-    } while (gDeleted)
-
-    deleteUnreferenced(openapi.components.parameters, gReferenced, '#/components/parameters/');
-    if (Object.keys(openapi.components.parameters || {}).length == 0) {
-        delete openapi.components.parameters;
-    }
-
-    return;
-
-
-    /**
-     * Get unreferenced Schema and Parameter Objects recursively
-     * @param {object} openapi OpenAPI description
-     * @param {object} referenced Map of referenced objects
-     */
-    function getReferencedSchemas(document, referenced) {
-        Object.keys(document).forEach(key => {
-            let value = document[key];
-            if (key == '$ref') {
-                referenced[value] = true;
-            } else {
-                if (Array.isArray(value)) {
-                    value.forEach(item => getReferencedSchemas(item, referenced))
-                } else if (typeof value == 'object' && value != null) {
-                    getReferencedSchemas(value, referenced);
-                }
-            }
-        });
-    }
-
-    /**
-     * Delete unreferenced Schema and Parameter Objects recursively
-     * @param {object} schemas Map of Schema and Parameter Objects
-     * @param {object} referenced Map of referenced objects
-     * @param {string} prefix Prefix used within referenced
-     */
-    function deleteUnreferenced(schemas, referenced, prefix) {
-        var deleted = false;
-
-        Object.keys(schemas || {}).forEach(key => {
-            if (!referenced[prefix + key]) {
-                delete schemas[key];
-                deleted = true;
-            }
-        });
-
-        return deleted;
-    }
-}
+};

package/lib/compile/openapi/index.js

@@ -31,7 +31,6 @@ function* _iterate(csdl, csn, options) {
 
 function _getOpenApi(csdl, options) {
     const openapi = csdl2openapi.csdl2openapi(csdl, options);
-    csdl2openapi.deleteUnreferencedSchemas(openapi);
     return openapi;
 }
 

package/lib/import/common.js

@@ -373,7 +373,8 @@ async function _updatePackageJson(dest, service, version, cwd) {
         version = (version === "V2") ? 'odata-v2' : 'odata';
     }
     if (!requires[service]) {
-        const model = path.relative(cwd, dest);
+        const initial_model = path.relative(cwd, dest);
+        const model = isLinux() ? initial_model.replace(/\\/g, '/') : initial_model;
         cds.env.requires[service] = requires[service] = { kind: version, model };
         await write(package_json, JSON.stringify(conf, null, '  '));
         console.log(`[cds] - updated ./package.json`);
@@ -409,6 +410,13 @@ async function identifyFile(filepath) {
         return extension;
 }
 
+function isLinux(){
+    let platform = process.platform
+    if (platform === 'linux' || platform === 'win32'){
+        return true;
+    }
+}
+
 function readEnvVariables(options, cliCheck) {
     if (cds.env.import) {
         if (cliCheck) {

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

@@ -579,18 +579,28 @@ class Expression {
         const nonStdAttributes = this.getNonStdAttributes(element.attributes);
         for (let i = 0; i < nonStdAttributes.length; i++) {
             let attr = nonStdAttributes[i];
+            let check = 0;
             let [prefix, attrName] = attr.split(':');
-            if(attrName)
+            if (attrName)
                 attrName = attrName.replace(/-/g,'.');
             let attribute;
             if ((MetadataConverter.custom_namespace.includes(prefix) || MetadataConverter.custom_namespace.includes(true)) && attrName !== undefined)
                 attribute = "@" + prefix + "." + attrName;
             else if (attrName === undefined)
                 attribute = "$" + prefix;
-            if (attribute !== undefined)
-                target[attribute] = element.attributes[attr];
+            if (attribute !== undefined && attribute.startsWith('$') === false) {
+                Object.entries(target).forEach(a => {
+                    if (Object.keys(a[1]).length === 0 && typeof(a[1]) != 'boolean' ) {
+                        a[1][attribute] = element.attributes[attr];
+                        check = 1;
+                    }
+                });
+                if (check == 0 )
+                    target[attribute] = element.attributes[attr];
+            }
         }
     }
+
     getNonStdAttributes(attributes) {
         const attributeList = [];
         const standardArrtibutes = ['MaxLength', 'Precision', 'Scale', 'Nullable', 'DefaultValue', 
@@ -1667,7 +1677,10 @@ class PropertyValueExpression extends Expression {
         this.setTarget(target);
         this.buildTypeCollectionAndFacets('$Type');
 
-        if (element.attributes.Path) target[name].$Path = element.attributes.Path;
+        if (element.attributes.Path) target[name] = {"=": element.attributes.Path};
+        if (element.attributes.PropertyPath) target[name] = {"=": element.attributes.PropertyPath};
+        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;
         if (element.attributes.Bool) target[name] = element.attributes.Bool === 'true';