@sap/cds-compiler 2.12.0 → 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');
@@ -31,6 +33,8 @@ function annotationIsFalse( anno ) {                   // falsy, but not null (u
 }
 
 /**
+ * Set compiler-calculated annotation value.
+ *
  * @param {XSN.Artifact} art
  * @param {string} anno
  * @param {XSN.Location} [location]
@@ -44,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.
@@ -57,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;
 }
 
@@ -92,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)
@@ -110,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];
@@ -140,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 } );
 }
 
@@ -153,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;
@@ -218,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,
@@ -225,7 +383,7 @@ module.exports = {
   annotationIsFalse,
   annotateWith,
   setLink,
-  setProp,
+  setArtifactLink,
   linkToOrigin,
   dependsOn,
   dependsOnSilent,
@@ -235,4 +393,10 @@ module.exports = {
   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

@@ -504,7 +504,7 @@ 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 (carrier.kind === 'entity') {
       // If AppliesTo=[EntitySet/Singleton/Collection, EntityType], EntitySet/Singleton/Collection has precedence
         testToAlternativeEdmTarget = (x => {
           if(options.isV2()) {
@@ -554,7 +554,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         }
         else {
         // this might be more precise if handleAnnotation would know more about the carrier
-          testToStandardEdmTarget = (x => x 
+          testToStandardEdmTarget = (x => x
             ? ['Parameter', 'Property'].some(y => x.includes(y) ||
               carrier._isCollection && x.includes('Collection'))
             : true);
@@ -948,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 }`);
         }
       }
@@ -1284,14 +1284,10 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           });
         }
         else { // literal
-          let escaped = obj;
-          if (typeof escaped === 'string') {
-            escaped = escaped.replace(/&/g, '&')
-          }
           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;
             }

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.
@@ -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' });
             }

package/lib/edm/edm.js

@@ -137,11 +137,11 @@ module.exports = function (options, error) {
       let tmpStr = '';
       edmUtils.forAll(this, (v, p) => {
         if (typeof this[p] !== 'object')
-          tmpStr += ' ' + p + '="' + edmUtils.escapeString(v) + '"'
+          tmpStr += ' ' + p + '="' + edmUtils.escapeStringForAttributeValue(v) + '"'
       });
       edmUtils.forAll(this._xmlOnlyAttributes, (v,p) => {
         if (typeof v !== 'object')
-          tmpStr += ' ' + p + '="' + edmUtils.escapeString(v) + '"'
+          tmpStr += ' ' + p + '="' + edmUtils.escapeStringForAttributeValue(v) + '"'
       });
       return tmpStr;
     }
@@ -599,7 +599,7 @@ module.exports = function (options, error) {
         // Complex/EntityType are derived from TypeBase
         // but have no type attribute in their CSN
         if(typecsn.type) { // this thing has a type
-          // check wether this is a scalar type (or array of scalar type) or a named type
+          // check whether this is a scalar type (or array of scalar type) or a named type
           let scalarType = undefined;
           if(typecsn.items && typecsn.items.type &&
             isBuiltinType(typecsn.items.type)) {
@@ -879,11 +879,12 @@ module.exports = function (options, error) {
       // the V2 metadata.xml
       // @ts-ignore
       Property.SAP_Annotation_Attribute_WhiteList = [
-        '@sap.hierarchy.node.for',                  //-> 	sap:hierarchy-node-for
-        '@sap.hierarchy.parent.node.for',           // -> 	sap:hierarchy-parent-node-for
-        '@sap.hierarchy.level.for',               	// -> 	sap:hierarchy-level-for
-        '@sap.hierarchy.drill.state.for',           // -> 	sap:hierarchy-drill-state-for
-        '@sap.hierarchy.node.descendant.count.for'	// -> 	sap:hierarchy-node-descendant-count-for
+        '@sap.hierarchy.node.for',                  // ->   sap:hierarchy-node-for
+        '@sap.hierarchy.parent.node.for',           // ->   sap:hierarchy-parent-node-for
+        '@sap.hierarchy.level.for',                 // ->   sap:hierarchy-level-for
+        '@sap.hierarchy.drill.state.for',           // ->   sap:hierarchy-drill-state-for
+        '@sap.hierarchy.node.descendant.count.for', // ->   sap:hierarchy-node-descendant-count-for
+        '@sap.parameter'
       ];
 
       super(v, attributes, csn);
@@ -927,9 +928,7 @@ module.exports = function (options, error) {
             Additionally: The attribute is named 'Default' in V2 and 'DefaultValue' in V4
           */
           if(this.v4)
-            this[`Default${this.v4 ? 'Value' : ''}`] = ['cds.Boolean', 'cds.Binary', 'cds.LargeBinary', 'cds.Integer64', 'cds.Integer'].includes(csn.type)
-          ? defVal
-          : edmUtils.escapeString(defVal);
+            this[`Default${this.v4 ? 'Value' : ''}`] = defVal;
         }
       }
     }
@@ -1356,7 +1355,7 @@ module.exports = function (options, error) {
     {
       let kind = this.kind;
       let xml = indent + '<' + kind + this.toXMLattributes();
-      xml +=  (this._value !== undefined ? '>' + edmUtils.escapeString(this._value) + '</' + kind + '>' : '/>');
+      xml +=  (this._value !== undefined ? '>' + edmUtils.escapeStringForText(this._value) + '</' + kind + '>' : '/>');
       return xml;
     }