@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/compiler/utils.js

@@ -6,6 +6,8 @@
 // Please do not add functions “for completeness”, this is not an API file for
 // others but only by the core compiler.
 
+// TODO: probably split this file into utils/….js
+
 'use strict';
 
 const { dictAdd, pushToDict } = require('../base/dictionaries');
@@ -30,6 +32,15 @@ function annotationIsFalse( anno ) {                   // falsy, but not null (u
   return anno && (anno.val === false || anno.val === 0 || anno.val === '');
 }
 
+/**
+ * Set compiler-calculated annotation value.
+ *
+ * @param {XSN.Artifact} art
+ * @param {string} anno
+ * @param {XSN.Location} [location]
+ * @param {*} [val]
+ * @param {string} [literal]
+ */
 function annotateWith( art, anno, location = art.location, val = true, literal = 'boolean' ) {
   if (art[anno])  // do not overwrite user-defined including null
     return;
@@ -37,11 +48,11 @@ function annotateWith( art, anno, location = art.location, val = true, literal =
     name: { path: [ { id: anno.slice(1), location } ], location },
     val,
     literal,
+    $inferred: '$generated',
     location,
   };
 }
 
-// TODO: define setLink() like the current setProp(), we might have setArtifactLink()
 // Do not share this function with CSN processors!
 
 // The link (_artifact,_effectiveType,...) usually has the artifact as value.
@@ -50,28 +61,13 @@ function annotateWith( art, anno, location = art.location, val = true, literal =
 // - null: no valid reference, param:true if that is not allowed
 // - false (only complete ref): multiple definitions, rejected
 // - 0 (for _effectiveType only): circular reference
-function setLink( obj, value = null, prop = '_artifact' ) {
+function setLink( obj, prop, value ) {
   Object.defineProperty( obj, prop, { value, configurable: true, writable: true } );
   return value;
 }
-
-/**
- * Like `obj.prop = value`, but not contained in JSON / CSN
- * It's important to set enumerable explicitly to false (although 'false' is the default),
- * as else, if the property already exists, it keeps the old setting for enumerable.
- *
- * @param {object} obj
- * @param {string} prop
- * @param {any} value
- */
-function setProp(obj, prop, value) {
-  const descriptor = {
-    value,
-    configurable: true,
-    writable: true,
-    enumerable: false,
-  };
-  Object.defineProperty( obj, prop, descriptor );
+// And a variant with the most common `prop`:
+function setArtifactLink( obj, value ) {
+  Object.defineProperty( obj, '_artifact', { value, configurable: true, writable: true } );
   return value;
 }
 
@@ -85,7 +81,7 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
     elem.name.$inferred = origin.name.$inferred;
   if (parent)
     setMemberParent( elem, name, parent, prop ); // TODO: redef in template
-  setProp( elem, '_origin', origin );
+  setLink( elem, '_origin', origin );
   // TODO: should we use silent dependencies also for other things, like
   // included elements?  (Currently for $inferred: 'expand-element' only)
   if (silentDep)
@@ -103,20 +99,21 @@ function setMemberParent( elem, name, parent, prop ) {
       p[prop] = Object.create(null);
     dictAdd( p[prop], name, elem );
   }
-  if (parent._outer)
+  if (parent._outer && parent._outer.items) // TODO: remove for items, too
     parent = parent._outer;
-  setProp( elem, '_parent', parent );
-  setProp( elem, '_main', parent._main || parent );
-  elem.name.absolute = elem._main.name.absolute;
+  setLink( elem, '_parent', parent );
+  setLink( elem, '_main', parent._main || parent );
+  const parentName = parent.name || parent._outer.name;
+  elem.name.absolute = parentName.absolute;
   if (name == null)
     return;
   const normalized = kindProperties[elem.kind].normalized || elem.kind;
   [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
     if (normalized === kind)
-      elem.name[kind] = (parent.name[kind] != null && kind !== 'select' && kind !== 'alias') ? `${ parent.name[kind] }.${ name }` : name;
+      elem.name[kind] = (parentName[kind] != null && kind !== 'select' && kind !== 'alias') ? `${ parentName[kind] }.${ name }` : name;
 
-    else if (parent.name[kind] != null)
-      elem.name[kind] = parent.name[kind];
+    else if (parentName[kind] != null)
+      elem.name[kind] = parentName[kind];
 
     else
       delete elem.name[kind];
@@ -133,7 +130,7 @@ function setMemberParent( elem, name, parent, prop ) {
  */
 function dependsOn( user, art, location ) {
   if (!user._deps)
-    setProp( user, '_deps', [] );
+    setLink( user, '_deps', [] );
   user._deps.push( { art, location } );
 }
 
@@ -146,17 +143,17 @@ function dependsOn( user, art, location ) {
  */
 function dependsOnSilent( user, art ) {
   if (!user._deps)
-    setProp( user, '_deps', [] );
+    setLink( user, '_deps', [] );
   user._deps.push( { art } );
 }
 
 function storeExtension( elem, name, prop, parent, block ) {
   if (prop === 'enum')
     prop = 'elements';
-  setProp( elem, '_block', block );
+  setLink( elem, '_block', block );
   const kind = `_${ elem.kind }`; // _extend or _annotate
   if (!parent[kind])
-    setProp( parent, kind, {} );
+    setLink( parent, kind, {} );
   // if (name === '' && prop === 'params') {
   //   pushToDict( parent[kind], 'returns', elem ); // not really a dict
   //   return;
@@ -181,6 +178,16 @@ function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = fa
   return false;
 }
 
+/**
+ * Return string 'A.B.C' for parsed source `A.B.C` (is vector of ids with
+ * locations).
+ *
+ * @param {XSN.Path} path
+ */
+function pathName(path) {
+  return (path.broken) ? '' : path.map( id => id.id ).join('.');
+}
+
 /**
  * Generates an XSN path out of the given name. Path segments are delimited by a dot.
  * Each segment will have the given location assigned.
@@ -201,6 +208,174 @@ function augmentPath( location, ...args ) {
   return { path: args.map( id => ({ id, location }) ), location };
 }
 
+function copyExpr( expr, location, skipUnderscored, rewritePath ) {
+  if (!expr || typeof expr !== 'object')
+    return expr;
+  else if (Array.isArray(expr))
+    return expr.map( e => copyExpr( e, location, skipUnderscored, rewritePath ) );
+
+  const proto = Object.getPrototypeOf( expr );
+  if (proto && proto !== Object.prototype) // do not copy object from special classes
+    return expr;
+  const r = Object.create( proto );
+  for (const prop of Object.getOwnPropertyNames( expr )) {
+    const pd = Object.getOwnPropertyDescriptor( expr, prop );
+    if (!pd.enumerable) { // should include all properties starting with _
+      if (!skipUnderscored ||
+          prop === '_artifact' || prop === '_navigation' || prop === '_effectiveType')
+        Object.defineProperty( r, prop, pd );
+    }
+    else if (!proto) {
+      r[prop] = copyExpr( pd.value, location, skipUnderscored, rewritePath );
+    }
+    else if (prop === 'location') {
+      r[prop] = location || pd.value;
+    }
+    else if (prop.charAt(0) !== '$' || prop === '$inferred') {
+      r[prop] = copyExpr( pd.value, location, skipUnderscored, rewritePath );
+    }
+    else if (!skipUnderscored) {  // skip $ properties
+      Object.defineProperty( r, prop, pd );
+    }
+  }
+  return r;
+}
+
+function testExpr( expr, pathTest, queryTest ) {
+  // TODO: also check path arguments/filters
+  if (!expr || typeof expr === 'string') { // parse error or keywords in {xpr:...}
+    return false;
+  }
+  else if (Array.isArray(expr)) {
+    return expr.some( e => testExpr( e, pathTest, queryTest ) );
+  }
+  else if (expr.path) {
+    return pathTest( expr );
+  }
+  else if (expr.query) {
+    return queryTest( expr.query );
+  }
+  else if (expr.op && expr.args) {
+    // unnamed args => array
+    if (Array.isArray(expr.args))
+      return expr.args.some( e => testExpr( e, pathTest, queryTest ) );
+    // named args => dictionary
+    for (const namedArg of Object.keys(expr.args)) {
+      if (testExpr(expr.args[namedArg], pathTest, queryTest))
+        return true;
+    }
+  }
+  return false;
+}
+
+// Return true if the path `item` with a final type `assoc` has a max target
+// cardinality greater than one - either specified on the path item or assoc type.
+function targetMaxNotOne( assoc, item ) {
+  // Semantics of associations without provided cardinality: [*,0..1]
+  const cardinality = item.cardinality || assoc.cardinality;
+  return cardinality && cardinality.targetMax && cardinality.targetMax.val !== 1;
+}
+
+// Query tree post-order traversal - called for everything which contributes to the query
+// i.e. is necessary to calculate the elements of the query
+// except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
+// NOTE: does not run on non-referred sub queries!  Consider using ‹main›.$queries instead!
+function traverseQueryPost( query, simpleOnly, callback ) {
+  if (!query)                   // parser error
+    return;
+  if (!query.op) {              // in FROM (not JOIN)
+    if (query.query)            // subquery
+      traverseQueryPost( query.query, simpleOnly, callback );
+    return;
+  }
+  if (simpleOnly) {
+    const { from } = query;
+    if (!from || from.join)     // parse error or join
+      return;                   // ok are: path or simple sub query (!)
+  }
+  if (query.from) {             // SELECT
+    traverseQueryPost( query.from, simpleOnly, callback );
+    // console.log('FC:')
+    callback( query );
+    // console.log('FE:')
+  }
+  else if (query.args) {             // JOIN, UNION, INTERSECT
+    if (!query.join && simpleOnly == null) {
+      // enough for elements: traverse only first args for UNION/INTERSECT
+      // TODO: we might use this also when we do not rewrite associations
+      // in non-referred sub queries
+      traverseQueryPost( query.args[0], simpleOnly, callback );
+    }
+    else {
+      for (const q of query.args)
+        traverseQueryPost( q, simpleOnly, callback );
+      // The ON condition has to be traversed extra, because it must be evaluated
+      // after the complete FROM has been traversed.  It is also not necessary to
+      // evaluate it in populateQuery().
+    }
+  }
+  // else: with parse error (`select from <EOF>`, `select distinct from;`)
+}
+
+// Call callback on all queries in dependency order, i.e. starting with query Q
+// 1. sub queries in FROM sources of Q
+// 2. Q itself, except if non-referred query, but with right UNION parts
+// 3. sub queries in ON in FROM of Q
+// 4. sub queries in columns, WHERE, HAVING
+function traverseQueryExtra( main, callback ) {
+  if (!main.$queries)
+    return;
+  // with a top-level UNION, $queries[0] is just the left
+  traverseQueryPost( main.query, false, (q) => { // also with right of UNION (to be compatible)
+    setLink( q, '_status', 'extra' );
+    callback( q );
+  } );
+  for (const query of main.$queries.slice(1)) {
+    if (query._status === 'extra' || query._parent.kind === '$tableAlias')
+      continue; // if parent is alias, query is FROM source -> run by traverseQueryPost
+    // we are now in the top-level (parent is entity) or a non-referred query (parent is query)
+    setLink( query, '_status', 'extra' ); // do not call callback() in non-referred query
+    // console.log( 'A:', query.name,query._status)
+    traverseQueryPost( query, null, (q) => {
+      if (q._status !== 'extra') {
+        // console.log( 'T:', q.name)
+        setLink( q, '_status', 'extra' );
+        callback( q );
+      }
+      // else console.log( 'E:', q.name)
+    } );
+  }
+}
+
+// About Helper property $expand for faster the XSN-to-CSN transformation
+// - null/undefined: artifact, member, items does not contain expanded members
+// - 'origin': all expanded (sub) elements have no new target/on and no new annotations
+//             that value is only on elements, types, and params -> no other members
+//             when set, only on elem/art with expanded elements
+// - 'target': all expanded (sub) elements might only have new target/on, but
+//             no indivual annotations on any (sub) member
+//             when set, traverse all parents where the value has been 'origin' before
+// - 'annotate': at least one inferred (sub) member has an individual annotation,
+//               not counting propagated ones; set up to the definition (main artifact)
+//               (only set with anno on $inferred elem), annotate “beats” target
+// Usage according to CSN flavor:
+// - gensrc: do not render inferred elements (including expanded elements),
+//           collect annotate statements with value 'annotate'
+// - client: do not render expanded sub elements if artifact/member is no type, has a type,
+//           has $expand = 'origin', and all its _origin also have $expand = 'origin'
+//           (might sometimes render the elements unnecessarily, which is not wrong)
+// - universal: do not render expanded sub elements if $expand = 'origin'
+function setExpandStatus( elem, status ) {
+  // set on element
+  while (elem._main) {
+    elem = elem._parent;
+    if (status === 'annotate' ? elem.$expand === 'annotate' : elem.$expand !== 'origin')
+      return;
+    elem.$expand = status;    // meaning: expanded, containing assocs
+    for (let line = elem.items; line; line = line.items)
+      line.$expand = status; // to-csn just uses the innermost $expand
+  }
+}
 
 module.exports = {
   pushLink,
@@ -208,13 +383,20 @@ module.exports = {
   annotationIsFalse,
   annotateWith,
   setLink,
-  setProp,
+  setArtifactLink,
   linkToOrigin,
   dependsOn,
   dependsOnSilent,
   setMemberParent,
   storeExtension,
   withAssociation,
+  pathName,
   augmentPath,
   splitIntoPath,
+  copyExpr,
+  testExpr,
+  targetMaxNotOne,
+  traverseQueryPost,
+  traverseQueryExtra,
+  setExpandStatus,
 };

package/lib/edm/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "no-shadow": "off"
+  }
+}

package/lib/edm/annotations/genericTranslation.js

@@ -207,7 +207,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // Note: we assume that all objects ly flat in the service, i.e. objName always
   //       looks like <service name, can contain dots>.<id>
   forEachDefinition(csn, (object, objName) => {
-    if(objName == serviceName || objName.startsWith(serviceName + '.')) {
+    if (objName === serviceName || objName.startsWith(serviceName + '.')) {
       if (object.kind === 'action' || object.kind === 'function') {
         handleAction(objName, object, null);
       }
@@ -504,9 +504,18 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       let hasAlternativeCarrier = false; // is the alternative annotation target available in the EDM?
       let testToAlternativeEdmTarget = null; // if true, assign to alternative Edm Target
 
-      if (carrier.kind === 'entity' || carrier.kind === 'view') {
-      // If AppliesTo=[EntitySet/Singleton, EntityType], EntitySet/Singleton has precedence
-        testToAlternativeEdmTarget = (x => x.includes('EntitySet') || x.includes('Singleton'));
+      if (carrier.kind === 'entity') {
+      // If AppliesTo=[EntitySet/Singleton/Collection, EntityType], EntitySet/Singleton/Collection has precedence
+        testToAlternativeEdmTarget = (x => {
+          if(options.isV2()) {
+            return ['Singleton', 'EntitySet', 'Collection'].some(y => x.includes(y));
+          }
+          else {
+            return edmUtils.isSingleton(carrier)
+              ? x.includes('Singleton')
+              : ['EntitySet', 'Collection'].some(y => x.includes(y));
+          }
+        });
         testToStandardEdmTarget = (x => x ? x.includes('EntityType') : true);
       // if carrier has an alternate 'entitySetName' use this instead of EdmTargetName
       // (see edmPreprocessor.initializeParameterizedEntityOrView(), where parameterized artifacts
@@ -534,15 +543,21 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         alternativeEdmTargetName = edmTargetName;
         hasAlternativeCarrier = true; // EntityContainer is always available
       }
-    //element => decide if navprop or normal property
+      //element => decide if navprop or normal property
       else if(!carrier.kind) {
-      // if appliesTo is undefined, return true
+        // if appliesTo is undefined, return true
         if(carrier.target) {
-          testToStandardEdmTarget = (x=> x ? x.includes('NavigationProperty') : true);
+          testToStandardEdmTarget = (x => x
+            ? x.includes('NavigationProperty') ||
+              carrier.cardinality && carrier.cardinality.max === '*' && x.includes('Collection')
+            : true);
         }
         else {
         // this might be more precise if handleAnnotation would know more about the carrier
-          testToStandardEdmTarget = (x => x ? ['Parameter', 'Property'].some(y => x.includes(y)): true);
+          testToStandardEdmTarget = (x => x
+            ? ['Parameter', 'Property'].some(y => x.includes(y) ||
+              carrier._isCollection && x.includes('Collection'))
+            : true);
         }
       }
       return [
@@ -851,7 +866,6 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     else if (!expectedType['Members'].includes(enumValue)) {
       message(warning, context, `enumeration type ${ dTypeName } has no value ${ enumValue }`);
     }
-    return;
   }
 
   // cAnnoValue: array
@@ -865,8 +879,9 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     }
 
     let index = 0;
-    for (let e of cAnnoValue) {
-      context.stack.push('[' + index++ + ']');
+    for (const e of cAnnoValue) {
+      context.stack.push('[' + index + ']');
+      index++;
       if (e['#']) {
         checkEnumValue(e['#'], dTypeName, context);
       }
@@ -901,7 +916,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     }
     else {
       // replace all occurrences of '.' by '/' up to first '@'
-      val = expr.split('@').map((o,i) => (i==0 ? o.replace(/\./g, '/') : o)).join('@');
+      val = expr.split('@').map((o,i) => (i === 0 ? o.replace(/\./g, '/') : o)).join('@');
     }
 
     return {
@@ -922,9 +937,10 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     // caller already made sure that val is neither object nor array
     dTypeName = resolveType(dTypeName);
 
-    if(isEnumType(dTypeName)) {
+    if (isEnumType(dTypeName)) {
       const type = getDictType(dTypeName);
-      message(warning, context, `found non-enum value "${val}", expected ${type.Members.map(m=>`"#${m}"`).join(', ')} for ${dTypeName}`);
+      const expected = type.Members.map(m => `"#${m}"`).join(', ');
+      message(warning, context, `found non-enum value "${val}", expected ${expected} for ${dTypeName}`);
     }
 
     let typeName = 'String';
@@ -932,7 +948,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     if (typeof val === 'string') {
       if (dTypeName === 'Edm.Boolean') {
         typeName = 'Bool';
-        if (!['true','false'].includes(val)) {
+        if (val !== 'true' && val !== 'false') {
           message(warning, context, `found String, but expected type ${ dTypeName }`);
         }
       }
@@ -1154,8 +1170,9 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     }
 
     let index = 0;
-    for (let value of annoValue) {
-      context.stack.push('[' + index++ + ']');
+    for (const value of annoValue) {
+      context.stack.push('[' + index + ']');
+      index++
 
       // for dealing with the single array entries we unfortunately cannot call handleValue(),
       //   as the values inside an array are represented differently from the values
@@ -1214,8 +1231,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       return edmNode;
     }
 
-    if(dynExprs.length === 0) {
-      if (typeof obj === 'object' && obj !== null && !Array.isArray(obj) && Object.keys(obj).length==1) {
+    if (dynExprs.length === 0) {
+      if (typeof obj === 'object' && obj !== null && !Array.isArray(obj) && Object.keys(obj).length === 1) {
         const k = Object.keys(obj)[0];
         const val = obj[k];
         edmNode = new Edm.ValueThing(v, k[0] === '$' ? k.slice(1) : k, val );
@@ -1267,14 +1284,10 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           });
         }
         else { // literal
-          let escaped = obj;
-          if (typeof escaped === 'string') {
-            escaped = escaped.replace(/&/g, '&amp;')
-          }
           edmNode = new Edm.ValueThing(v,
-            exprDef && exprDef.valueThingName || getXmlTypeName(escaped), escaped);
+            exprDef && exprDef.valueThingName || getXmlTypeName(obj), obj);
           // typename for static expression rendering
-          edmNode.setJSON( { [getJsonTypeName(escaped)]: escaped } );
+          edmNode.setJSON( { [getJsonTypeName(obj)]: obj } );
         }
       }
     }

package/lib/edm/annotations/preprocessAnnotations.js

@@ -101,7 +101,7 @@ function preprocessAnnotations(csn, serviceName, options) {
 
       // inner functions
       function draftAnnotations(carrier, aName, aNameWithoutQualifier) {
-        if ((carrier.kind === 'entity' || carrier.kind === 'view') &&
+        if ((carrier.kind === 'entity') &&
             (aNameWithoutQualifier === '@Common.DraftRoot.PreparationAction' ||
               aNameWithoutQualifier === '@Common.DraftRoot.ActivationAction' ||
               aNameWithoutQualifier === '@Common.DraftRoot.EditAction' ||
@@ -136,7 +136,7 @@ function preprocessAnnotations(csn, serviceName, options) {
               return false;
             }
 
-            if (carrier.kind === 'entity' || carrier.kind === 'view') {
+            if (carrier.kind === 'entity') {
               warning(null, null, `annotation preprocessing/${aNameWithoutQualifier}: annotation must not be used for an entity, ${ctx}`);
               return false;
             }
@@ -236,7 +236,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             } else {
               let stringFields = Object.keys(vlEntity.elements).filter(
                 x => !vlEntity.elements[x].key && vlEntity.elements[x].type === 'cds.String')
-              if (stringFields.length == 1)
+              if (stringFields.length === 1)
                 textField = stringFields[0];
             }
 

package/lib/edm/csn2edm.js

@@ -45,6 +45,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
   let [ allServices,
     allSchemas,
     whatsMyServiceRootName,
+    autoexposeSchemaName,
     options ] = initializeModel(csn, _options, messageFunctions);
 
   const Edm = require('./edm.js')(options, error);
@@ -188,9 +189,9 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       fqSchemaXRef.sort((a,b) => b.length-a.length);
 
       // Bring the schemas in alphabetical order, service first, root last
-      const sortedSchemaNames = Object.keys(subSchemaDictionary).filter(n => n !== 'root' && n !== serviceCsn.name).sort();
-      if(subSchemaDictionary.root)
-        sortedSchemaNames.push('root');
+      const sortedSchemaNames = Object.keys(subSchemaDictionary).filter(n => n !== autoexposeSchemaName && n !== serviceCsn.name).sort();
+      if(subSchemaDictionary[autoexposeSchemaName])
+        sortedSchemaNames.push(autoexposeSchemaName);
 
       // Finally create the schemas and register them in the service.
       LeadSchema = createSchema(subSchemaDictionary[serviceCsn.name]);
@@ -234,7 +235,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       Object.entries(csn.definitions).forEach(([fqName, art]) => {
         // Identify service members by their definition name only, this allows
         // to let the internal object.name have the sub-schema name.
-        // With nested services we must do a longest path match and check wether
+        // With nested services we must do a longest path match and check whether
         // the current definition belongs to the current toplevel service definition.
 
         // Definition is to be considered if
@@ -246,7 +247,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // not marked to be ignored as schema member
         if(mySchemaName &&
            serviceCsn.name === whatsMyServiceRootName(fqName, false) &&
-           ![ 'context', 'service' ].includes(art.kind)) {
+           art.kind !== 'context' && art.kind !== 'service') {
 
           // Strip the toplevel serviceName from object.name
           // except if the schema name is the service name itself.
@@ -420,7 +421,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           /** @type {object} */
           let containerEntry;
 
-          if(edmUtils.isSingleton(entityCsn, options.isV4())) {
+          if(edmUtils.isSingleton(entityCsn) && options.isV4()) {
             containerEntry = new Edm.Singleton(v, { Name: EntitySetName, Type: fullQualified(EntityTypeName) }, entityCsn);
             if(entityCsn['@odata.singleton.nullable'])
               containerEntry.Nullable= true;
@@ -574,7 +575,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         edmUtils.forAll(actionCsn.params, (parameterCsn, parameterName) => {
           const paramLoc = [...actLoc, 'params', parameterName];
           const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
-          if(!param._type.startsWith('Edm.') && !edmUtils.isStructuredType(csn.definitions[param._type])) {
+          if(param._type && !param._type.startsWith('Edm.') && !edmUtils.isStructuredType(csn.definitions[param._type])) {
             warning('odata-spec-violation-param', paramLoc, { api: 'OData V2' });
           }
           if(param._isCollection) {
@@ -591,8 +592,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           // it is safe to assume that either type or items.type are set
           const returns = action.returns.items || action.returns;
           let type = returns.type;
-          if(type){
-            if(!isBuiltinType(type) && !['entity', 'view', 'type'].includes(csn.definitions[type].kind)){
+          if (type){
+            if (!isBuiltinType(type) && csn.definitions[type].kind !== 'entity' && csn.definitions[type].kind !== 'type') {
               const returnsLoc = [ ...actLoc, 'returns'];
               warning('odata-spec-violation-returns', returnsLoc, { kind: action.kind, api: 'OData V2' });
             }