@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/transform/forOdataNew.js

@@ -22,7 +22,7 @@ const { flattenCSN } = require('./odata/structureFlattener');
 const generateForeignKeys = require('./odata/generateForeignKeyElements');
 const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssociations');
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { attachPath } = require('./odata/attachPath');
 const enrichUniversalCsn = require('./universalCsnEnricher');
 
@@ -192,6 +192,10 @@ function transform4odataWithCsn(inputModel, options) {
 
   // Apply default type facets as set by options
   // Flatten on-conditions in unmanaged associations
+  /* FIXME (HJB): Is this comment still correct? processOnCond only strips $self
+                  We should not remove $self prefixes in structured OData to not
+                  interfer with path resolution
+  */
   // This must be done before all the draft logic as all
   // composition targets are annotated with @odata.draft.enabled in this step
   forEachDefinition(csn, [ setDefaultTypeFacets, processOnCond ], { skipArtifact: isExternalServiceMember });
@@ -299,8 +303,9 @@ function transform4odataWithCsn(inputModel, options) {
     // If @Core.Computed is explicitly set, don't overwrite it!
     if (node['@Core.Computed'] !== undefined) return;
 
-    // For @odata.on.insert/update, also add @Core.Computed
-    if (node['@odata.on.insert'] || node['@odata.on.update'])
+    // For @odata.on.insert/update,  also add @Core.Computed
+    // @odata.on is deprecated, use @cds.on {update|insert} instead
+    if(['@odata.on.insert', '@odata.on.update', '@cds.on.insert', '@cds.on.update'].some(a => node[a]))
       node['@Core.Computed'] = true;
   }
 
@@ -569,6 +574,9 @@ function transform4odataWithCsn(inputModel, options) {
   // CDXCORE-481
   // (4.5) If the member is an association whose target has @cds.odata.valuelist annotate it
   // with @Common.ValueList.viaAssociation.
+  /*
+    FIXME (HJB): Comment outdated: Anno propagation to FKs is done in EdmPreprocessor
+  */
   // This must be done before foreign keys are calculated and the annotations are propagated
   // to them. This will make sure that association and all its foreign keys are annotated with
   // Common.ValueList in the final EDM.

package/lib/transform/localized.js

@@ -5,14 +5,12 @@ const { setProp } = require('../base/model');
 const { hasErrors } = require('../base/messages');
 const { cloneCsnDictionary } = require('../model/csnUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
-const { rejectManagedAssociationsAndStructuresForHdbcsNames } = require('../checks/selectItems');
 const {
   cloneCsn,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
   sortCsnDefinitionsForTests,
-  getUtils,
 } = require('../model/csnUtils');
 
 /**
@@ -79,7 +77,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   if (hasExistingLocalizationViews(csn, options))
     return csn;
 
-  const { info, error } = makeMessageFunction(csn, options);
+  const { info } = makeMessageFunction(csn, options);
 
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
@@ -87,16 +85,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
 
-  forEachDefinition(csn, (definition, artName, prop, path) => {
-    cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor)
-    if(definition.query) {
-      // reject managed association and structure publishing for to-hdbcds.hdbcds
-      const that = { csnUtils: getUtils(csn), options, error };
-      rejectManagedAssociationsAndStructuresForHdbcsNames.call(that, definition, path)
-    }
-  });
-
-
+  forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
 
   sortCsnDefinitionsForTests(csn, options);
   return csn;
@@ -144,7 +133,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
     art[_hasLocalizedView] = viewName;
 
-    if(acceptLocalizedView && !acceptLocalizedView(viewName, artName))
+    if (acceptLocalizedView && !acceptLocalizedView(viewName, artName))
       return;
 
     let view;
@@ -698,6 +687,8 @@ function copyPersistenceAnnotations(target, source) {
  * @param {CSN.Options} options
  */
 function hasExistingLocalizationViews(csn, options) {
+  if (!csn || !csn.definitions)
+    return false;
   const firstLocalizedView = Object.keys(csn.definitions).find(isInLocalizedNamespace);
   if (firstLocalizedView) {
     const { info } = makeMessageFunction(csn, options);

package/lib/transform/odata/generateForeignKeyElements.js

@@ -201,13 +201,13 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
       // Transfer selected type properties from target key element
       // FIXME: There is currently no other way but to treat the annotation '@odata.Type' as a type property.
       for (let prop of ['type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type']) {
-        if (fkArtifact[prop] != undefined) {
+        if (fkArtifact[prop] !== undefined) {
           foreignKeyElement[prop] = fkArtifact[prop];
         }
       }
       // If the association is non-fkArtifact resp. key, so should be the foreign key field
       for (let prop of ['notNull', 'key']) {
-        if (assoc[prop] != undefined) {
+        if (assoc[prop] !== undefined) {
           foreignKeyElement[prop] = assoc[prop];
         }
       }

package/lib/transform/transformUtilsNew.js

@@ -9,7 +9,7 @@ const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
 
 const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
-const { cloneCsn, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { cloneCsn, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
 
 // Return the public functions of this module, with 'model' captured in a closure (for definitions, options etc).
 // Use 'pathDelimiter' for flattened names (e.g. of struct elements or foreign key elements).
@@ -80,6 +80,14 @@ function getTransformers(model, options, pathDelimiter = '_') {
       else if(defStrLen5k)
         element.length = 5000;
     }
+    if (element.type === 'cds.Binary' && element.length === undefined) {
+      if(options.defaultBinaryLength) {
+        element.length = options.defaultBinaryLength;
+        setProp(element, '$default', true);
+      }
+      else if(defStrLen5k)
+        element.length = 5000;
+    }
   /*
     if (element.type === 'cds.Decimal' && element.precision === undefined && options.precision) {
       element.precision = options.precision;
@@ -100,7 +108,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // Transfer selected type properties from target key element
     // FIXME: There is currently no other way but to treat the annotation '@odata.Type' as a type property.
     for (const prop of ['type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type']) {
-      if (fkArtifact[prop] != undefined) {
+      if (fkArtifact[prop] !== undefined) {
         foreignKeyElement[prop] = fkArtifact[prop];
       }
     }
@@ -110,7 +118,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
     // If the association is non-fkArtifact resp. key, so should be the foreign key field
     for (const prop of ['notNull', 'key']) {
-      if (assoc[prop] != undefined) {
+      if (assoc[prop] !== undefined) {
         foreignKeyElement[prop] = assoc[prop];
       }
     }
@@ -294,7 +302,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    *  [ (Entity), (struct1), (struct2), (assoc), (elem) ] should result in
    *  [ (Entity), (struct1_struct2_assoc), (elem) ]
    *
-   * @param {string[]} ref 
+   * @param {string[]} ref
    * @param {CSN.Path} path CSN path to the ref
    * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
@@ -344,6 +352,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
   /**
    * Copy properties of the referenced type, but don't resolve to the final base type.
    *
+   * Do not copy the length if it was just set via the default-value.
+   *
    * @param {any} node Node to copy to
    * @returns {void}
    */
@@ -377,7 +387,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * also unravel derived enum types, i.e. take the final base type of the enum's base type.
    * Similar with associations and compositions (we probably need a _baseType link)
    *
-   * @param {CSN.Artifact} node 
+   * @param {CSN.Artifact} node
    * @param {WeakMap} [resolved] WeakMap containing already resolved refs
    * @param {boolean} [keepLocalized=false] Wether to clone .localized from a type def
    * @returns {void}
@@ -396,7 +406,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
         delete node.type; // delete the type reference as edm processing does not expect it
       } else if(finalBaseType.items) {
           // This changes the order - to be discussed!
-        node.items = cloneCsn(finalBaseType, options).items; // copy items
+        node.items = cloneCsn(finalBaseType.items, options); // copy items
         delete node.type;
       } else {
         node.type=finalBaseType;
@@ -414,16 +424,16 @@ function getTransformers(model, options, pathDelimiter = '_') {
         return;
 
       // cloneCsn only works correctly if we start "from the top"
-      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options);
+      const cloneTypeDef = cloneCsn(typeDef, options);
       // With hdbcds-hdbcds, don't resolve structured types - but propagrate ".items", to turn into LargeString later on.
       if(typeDef.items) {
         delete node.type;
-        Object.assign(node, {items: clone.definitions.TypeDef.items});
+        Object.assign(node, {items: cloneTypeDef.items});
       }
       if(typeDef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
         if(!typeDef.items)
           delete node.type;
-        Object.assign(node, {elements: clone.definitions.TypeDef.elements});
+        Object.assign(node, {elements: cloneTypeDef.elements});
       }
 
 
@@ -431,7 +441,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     }
     // if the declared element is an enum, these values are with priority
     if (!node.enum && typeDef.enum) {
-      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options).definitions.TypeDef.enum;
+      const clone = cloneCsnDictionary(typeDef.enum, options);
       Object.assign(node, { enum: clone });
     }
     if (node.length === undefined && typeDef.length !== undefined)
@@ -855,7 +865,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function checkMultipleAssignments(array, annoName, artifact, artifactName, err = true) {
     if (array.length > 1) {
       const loc = ['definitions', artifactName];
-      if (err == true) {
+      if (err === true) {
         error(null, loc, { anno: annoName }, `Annotation $(ANNO) must be assigned only once`);
       } else {
         warning(null, loc, { anno: annoName },`Annotation $(ANNO) must be assigned only once`);
@@ -1074,7 +1084,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * Expand structured expression arguments to flat reference paths.
    * Structured elements are real sub element lists and managed associations.
    * All unmanaged association definitions are rewritten if applicable (elements/mixins).
-   * Also, HAVING and WHERE clauses are rewritten. We also check for infix filters and 
+   * Also, HAVING and WHERE clauses are rewritten. We also check for infix filters and
    * .xpr in columns.
    *
    * @todo Check if can be skipped for abstract entity  and or cds.persistence.skip ?
@@ -1084,16 +1094,16 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function expandStructsInExpression(csn, options = {}) {
     applyTransformations(csn, {
       'on': (parent, name, on, path) => {
-        parent.on = expand(parent.on, path);
+        parent.on = expand(parent.on, path.concat(name));
       },
       'having': (parent, name, having, path) => {
-        parent.having = expand(parent.having, path);
+        parent.having = expand(parent.having, path.concat(name));
       },
       'where': (parent, name, where, path) => {
-        parent.where = expand(parent.where, path);
+        parent.where = expand(parent.where, path.concat(name));
       },
       'xpr': (parent, name, xpr, path) => {
-        parent.xpr = expand(parent.xpr, path);
+        parent.xpr = expand(parent.xpr, path.concat(name));
       }
     }, undefined, undefined, options);
 
@@ -1111,17 +1121,21 @@ function getTransformers(model, options, pathDelimiter = '_') {
         if(i < expr.length-2)
         {
           const [lhs, op, rhs] = expr.slice(i);
+
+          // we might have to ad-hoc resolve a ref, since handleExists is run before hand and generates new refs.
+          const lhsArt = lhs._art || lhs.ref && !lhs.$scope && inspectRef(location.concat(i)).art;
+          const rhsArt = rhs._art || rhs.ref && !rhs.$scope && inspectRef(location.concat(i+2)).art;
           // lhs & rhs must be expandable types (structures or managed associations)
-          if(lhs._art && rhs._art &&
+          if(lhsArt && rhsArt &&
              lhs.ref && rhs.ref &&
-             isExpandable(lhs._art) && isExpandable(rhs._art) &&
+             isExpandable(lhsArt) && isExpandable(rhsArt) &&
              ['=', '<', '>', '>=', '<=', '!=', '<>'].includes(op) &&
              !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs))) {
 
             // if path is scalar and no assoc or has no type (@Core.Computed) use original expression
             // only do the expansion on (managed) assocs and (items.)elements, array of check in ON cond is done elsewhere
-            const lhspaths = /*isScalarOrNoType(lhs._art) ? [ lhs ] : */ flattenPath({ _art: lhs._art, ref: lhs.ref }, false, true );
-            const rhspaths = /*isScalarOrNoType(rhs._art) ? [ rhs ] : */ flattenPath({ _art: rhs._art, ref: rhs.ref }, false, true );
+            const lhspaths = /*isScalarOrNoType(lhs._art) ? [ lhs ] : */ flattenPath({ _art: lhsArt, ref: lhs.ref }, false, true );
+            const rhspaths = /*isScalarOrNoType(rhs._art) ? [ rhs ] : */ flattenPath({ _art: rhsArt, ref: rhs.ref }, false, true );
 
             // mapping dict for lhs/rhs for mismatch check
             // strip lhs/rhs prefix from flattened paths to check remaining common trailing path

package/lib/transform/translateAssocsToJoins.js

@@ -1,12 +1,12 @@
 'use strict'
 
 const { setProp, forEachGeneric, forEachDefinition, isBetaEnabled } = require('../base/model');
-var { makeMessageFunction } = require('../base/messages');
+const { makeMessageFunction } = require('../base/messages');
 const { recompileX } = require('../compiler/index');
-var { linkToOrigin } = require('../compiler/shared');
+const { linkToOrigin, pathName } = require('../compiler/utils');
 const  {compactModel, compactExpr} = require('../json/to-csn');
 const { deduplicateMessages } = require('../base/messages');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 // Paths that start with an artifact of protected kind are special
 // either ignore them in QAT building or in path rewriting
 const internalArtifactKinds = ['builtin'/*, '$parameters'*/, 'param'];
@@ -179,7 +179,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       let joinTree = query.from;
       for(let tan in query.$tableAliases)
       {
-        if(!['$projection', '$self'].includes(tan)) // don't drive into $projection/$self tableAlias (yet)
+        if(query.$tableAliases[tan].kind !== '$self') // don't drive into $projection/$self tableAlias (yet)
         {
           let ta = query.$tableAliases[tan];
           joinTree = createJoinTree(env, joinTree, ta.$qat, 'left', '$qat', ta.$QA);
@@ -200,7 +200,7 @@ function translateAssocsToJoins(model, inputOptions = {})
   function createQAForFromClauseSubQuery(query, env)
   {
     for (let taName in query.$tableAliases) {
-      if (!['$self', '$projection'].includes(taName)) {
+      if (query.$tableAliases[taName].kind !== '$self') {
         let ta = query.$tableAliases[taName];
         if(!ta.$QA) {
           ta.$QA = createQA(env, ta._origin, taName, undefined);
@@ -241,14 +241,6 @@ function translateAssocsToJoins(model, inputOptions = {})
         {
           art.$QA = createQA(env, art.target._artifact, art.name.id );
           art.$QA.mixin = true;
-          /* Mark mixin definition to be _ignored:
-            - If the mixin is used, it is now resolved into a join => definition vaporizes
-            - If the mixin is published, forHana backend must create a __copy with rewritten
-              $projection ON conditon and publish it with alias.
-            - If the mixin is neither be used nor published it shall not be visible to the database
-              (internal mixin).
-          */
-          art.$a2j = { _ignore: true };
         }
       });
     }
@@ -317,13 +309,13 @@ function translateAssocsToJoins(model, inputOptions = {})
       let [QA, ps] = rightMostQA(tail, head._navigation._parent.$QA || head._navigation.$QA);
       if(!QA) {
         error(null, pathNode.$location,
-          { name: pathNode.path.map(ps=ps.id).join('.') },
+          { name: pathName(pathNode.path) },
           'Please debug me: No QA found for generic path rewriting in $(NAME)')
         return;
       }
       // if the found QA is the mixin QA and if the path length is one,
       // this indicates the publishing of a mixin assoc, don't rewrite the path
-      if(QA.mixin && tail.length == 1)
+      if(QA.mixin && tail.length === 1)
         return;
       let pos = tail.indexOf(ps);
       // cut off ps if it's a join relevant association with postfix
@@ -678,7 +670,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             if(fwdAssoc)
             {
               //env.assocStack.includes(fwdAssoc) => recursion
-              if(env.assocStack.length == 2) {
+              if(env.assocStack.length === 2) {
                 // reuse (ugly) error message from forHana
                 error(null, env.assocStack[0].location,
                   { name: '$self', id: '$self' },
@@ -710,7 +702,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         // ON cond of the forward assoc with swapped src/tgt aliases
         let fwdAssoc = getForwardAssociationExpr(expr);
         if(fwdAssoc) {
-          if(env.assocStack.length == 2) {
+          if(env.assocStack.length === 2) {
             // reuse (ugly) error message from forHana
             error(null, expr.location, 'An association that uses “$self” in its ON-condition can\'t be compared to “$self”');
             // don't check these paths again
@@ -744,7 +736,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         let newSrcAlias = tgtAlias;
         let newTgtAlias = {};
         // first try to identify table alias for complex views or redirected associations
-        if(fwdAssoc._redirected && fwdAssoc._redirected.length && 
+        if(fwdAssoc._redirected && fwdAssoc._redirected.length &&
            // redirected target must have a $QA
            fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA &&
            // $QA's artifact must either be same srcAlias artifact
@@ -920,7 +912,7 @@ function translateAssocsToJoins(model, inputOptions = {})
               combined list of elements made available by the from clause.
           */
           let _navigation = undefined; // don't modify original path
-          if(env.assocStack.length == 2) {
+          if(env.assocStack.length === 2) {
             // a mixin assoc cannot have a structure prefix, it's sufficient to check head
             if(head.id === env.assocStack.id()) {
               // source side from view point of view (target side from forward point of view)
@@ -982,7 +974,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
       // Return the original association if expr is a backlink term, undefined otherwise
       function getForwardAssociationExpr(expr) {
-        if(expr.op && expr.op.val === '=' && expr.args.length == 2) {
+        if(expr.op && expr.op.val === '=' && expr.args.length === 2) {
           return getForwardAssociation(expr.args[0].path, expr.args[1].path);
         }
         return undefined;
@@ -991,10 +983,10 @@ function translateAssocsToJoins(model, inputOptions = {})
       function getForwardAssociation(lhs, rhs) {
         // [alpha.]BACKLINK.[beta.]FORWARD
         if(lhs && rhs) {
-          if(rhs.length == 1 && rhs[0].id === '$self' &&
+          if(rhs.length === 1 && rhs[0].id === '$self' &&
               lhs.length > 1 && hasPrefix(lhs))
             return lhs[lhs.length-1]._artifact;
-          if(lhs.length == 1 && lhs[0].id === '$self' &&
+          if(lhs.length === 1 && lhs[0].id === '$self' &&
               rhs.length > 1 && hasPrefix(rhs))
             return rhs[rhs.length-1]._artifact;
         }
@@ -1403,7 +1395,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
     let [head, ...tail] = path;
 
-    if(['$projection', '$self'].includes(head.id) && tail.length) {
+    if(['$projection', '$self'].includes(head.id) && tail.length && head._navigation.kind === '$self') {
       // make sure not to truncate tail
       if(tail.length > 1)
         [head, ...tail] = tail;