@sap/cds-compiler 2.12.0 → 2.15.2

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

@@ -4,15 +4,16 @@ const edmUtils = require('../edmUtils.js');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
 const { forEachDefinition } = require('../../model/csnUtils');
+const { forEach } = require("../../utils/objectUtils");
 
 
-/* Vocabulary overview as of January 2020:
-
+/*
    OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/master/vocabularies
    Aggregation (published)
    Authorization (published)
    Capabilities (published)
    Core (published)
+   JSON (published)
    Measures (published)
    Repeatability (published)
    Temporal (not published, not yet finalized)
@@ -23,8 +24,9 @@ const { forEachDefinition } = require('../../model/csnUtils');
    CodeList (published)
    Common (pubished)
    Communication (published)
+   DataIntegration (published)
    Graph (published, experimental)
-   Hierarchy (not published, still experimental)
+   Hierarchy (published, experimental)
    HTML5 (published, experimental)
    ODM (published, experimental)
    PersonalData (published)
@@ -73,16 +75,31 @@ const vocabularyDefinitions = {
     'inc': { Alias: 'Core', Namespace: 'Org.OData.Core.V1' },
     'int': { filename: 'Core.xml' }
   },
+  'DataIntegration': {
+    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/DataIntegration.xml' },
+    'inc': { Alias: 'DataIntegration', Namespace: 'com.sap.vocabularies.DataIntegration.v1' },
+    'int': { filename: 'DataIntegration.xml' }
+  },
   'Graph': {
     'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Graph.xml' },
     'inc': { Alias: 'Graph', Namespace: 'com.sap.vocabularies.Graph.v1' },
     'int': { filename: 'Graph.xml' }
   },
+  'Hierarchy': {
+    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Hierarchy.xml' },
+    'inc': { Alias: 'Hierarchy', Namespace: 'com.sap.vocabularies.Hierarchy.v1' },
+    'int': { filename: 'Hierarchy.xml' }
+  },
   'HTML5': {
     'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/HTML5.xml' },
     'inc': { Alias: 'HTML5', Namespace: 'com.sap.vocabularies.HTML5.v1' },
     'int': { filename: 'HTML5.xml' }
   },
+  'JSON': {
+    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.JSON.V1.xml' },
+    'inc': { Alias: 'JSON', Namespace: 'Org.OData.JSON.V1' },
+    'int': { filename: 'JSON.xml' }
+  },
   'Measures': {
     'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Measures.V1.xml' },
     'inc': { Alias: 'Measures', Namespace: 'Org.OData.Measures.V1' },
@@ -414,7 +431,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     // do nothing
 
     if(!isEdmPropertyRendered(carrier, options) ||
-      (isV2() && (edmUtils.isDerivedType(carrier) || carrier['@Core.MediaType']))) {
+      (isV2() && (edmUtils.isDerivedType(carrier)))) {
       return;
     }
 
@@ -504,7 +521,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 +571,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);
@@ -663,7 +680,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           }
           mergePathStepsIntoPrefixTree(tree[name], pathSteps, index+1, carrier);
         }
-        else {
+        else if(typeof tree === 'object' ){
           tree[name] = carrier['@' + pathSteps.join('.')];
         }
       }
@@ -714,9 +731,10 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
      * @type {object}
      * */
     let newAnno = undefined;
-    const nullWhitelist = [ 'Core.OperationAvailable' ];
+    const omissions = { 'Aggregation.default':1 };
+    const nullList = { 'Core.OperationAvailable':1 };
     const voc = termName.slice(0, termName.indexOf('.'));
-    if(vocabularyDefinitions[voc] && annoValue !== null || nullWhitelist.includes(termName)) {
+    if(vocabularyDefinitions[voc] && annoValue !== null && !omissions[termName]|| nullList[termName]) {
       newAnno = new Edm.Annotation(v, termName);
 
     // termName may contain a qualifier: @UI.FieldGroup#shippingStatus
@@ -729,8 +747,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           message(error, context,
                 `OData annotation qualifier "${ p[1] }" must start with a letter or underscore, followed by at most 127 letters, underscores or digits`);
         }
-        newAnno.Term = termNameWithoutQualifiers;
-        newAnno.Qualifier = p[1];
+        newAnno.setEdmAttribute('Term', termNameWithoutQualifiers);
+        newAnno.setEdmAttribute('Qualifier', p[1]);
       }
       if (p.length>2) {
         message(warning, context, `multiple qualifiers (${ p[1] },${ p[2] }${ p.length > 3 ? ',...' : '' })`);
@@ -948,7 +966,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 }`);
         }
       }
@@ -1072,7 +1090,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         // this type doesn't exist
         message(warning, context, `explicitly specified type '${ actualTypeName }' not found in vocabulary`);
         // explicitly mentioned type, render in XML and JSON
-        newRecord.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else if (dTypeName && !isDerivedFrom(actualTypeName, dTypeName)) {
         // this type doesn't fit the expected one
@@ -1080,7 +1098,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         }' is not derived from expected type '${ dTypeName }'`);
         actualTypeName = dTypeName;
         // explicitly mentioned type, render in XML and JSON
-        newRecord.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else if (isAbstractType(actualTypeName)) {
         // this type is abstract
@@ -1088,7 +1106,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         if(dTypeName)
           actualTypeName = dTypeName;
         // set to definition name and render in XML and JSON
-        newRecord.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else {
         // ok
@@ -1251,7 +1269,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           const props = Object.create(null);
           Object.entries(obj).forEach(([k, val]) => {
             if(k === '@type') {
-              edmNode.Type = val;
+              edmNode.setEdmAttribute('Type', val);
             }
             else {
               let child = undefined;
@@ -1284,14 +1302,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 } );
         }
       }
     }
@@ -1301,14 +1315,14 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       edmNode = exprDef.create(obj);
 
       // iterate over each obj.property and translate expression into EDM
-      Object.entries(obj).forEach(([name, val]) => {
+      forEach(obj, (name, val) => {
         if(exprDef) {
           if(exprDef.anno && name[0] === '@') {
             edmNode.append(handleTerm(name.slice(1), val, context));
           }
           else if (exprDef.attr && exprDef.attr.includes(name)) {
             if (name[0] === '$') {
-              edmNode[name.slice(1)] = val;
+              edmNode.setEdmAttribute(name.slice(1), val);
             }
           }
           else if (exprDef.jsonAttr && exprDef.jsonAttr.includes(name)) {

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;
             }