@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/transform/transformUtilsNew.js

@@ -9,12 +9,14 @@ const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
 
 const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
-const { cloneCsn, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { cloneCsnNonDict, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { ModelError } = require("../base/error");
+const { forEach } = require('../utils/objectUtils');
 
 // 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).
 // 'model' is compacted new style CSN
-// TODO: Error and warnings handling with compacted CSN? - currently just throw new Error for everything
+// TODO: Error and warnings handling with compacted CSN? - currently just throw new ModelError for everything
 // TODO: check the situation with assocs with values. In compacted CSN such elements have only "@Core.Computed": true
 function getTransformers(model, options, pathDelimiter = '_') {
   const { error, warning, info } = makeMessageFunction(model, options);
@@ -246,6 +248,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
     const struct = elemType ? elemType.elements : elem.elements;
 
     // Collect all child elements (recursively) into 'result'
+    // TODO: Do not report collisions in the generated elements here, but instead
+    // leave that work to the receiver of this result
     let result = Object.create(null);
     const addGeneratedFlattenedElement = (e, eName) => {
       if(result[eName]){
@@ -255,7 +259,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
         result[eName] = e;
       }
     }
-    Object.entries(struct).forEach(([childName, childElem]) => {
+    forEach(struct, (childName, childElem) => {
       if (isStructured(childElem)) {
         // Descend recursively into structured children
         let grandChildElems = flattenStructuredElement(childElem, childName, elementPath, pathInCsn.concat('elements',childName));
@@ -273,7 +277,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       } else {
         // Primitive child - clone it and restore its cross references
         let flatElemName = elemName + pathDelimiter + childName;
-        let flatElem = cloneCsn(childElem, options);
+        let flatElem = cloneCsnNonDict(childElem, options);
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));
@@ -282,11 +286,15 @@ function getTransformers(model, options, pathDelimiter = '_') {
     });
 
     // Fix all collected flat elements (names, annotations, properties, origin ..)
-    Object.values(result).forEach(flatElem => {
+    forEach(result, (name, flatElem) => {
       // Copy annotations from struct (not overwriting, because deep annotations should have precedence)
       copyAnnotations(elem, flatElem, false);
       // Copy selected type properties
-      for (let p of ['key', 'virtual', 'masked', 'viaAll']) {
+      const props = ['key', 'virtual', 'masked', 'viaAll'];
+      // 'localized' is needed for OData
+      if(options.toOdata)
+        props.push('localized');
+      for (let p of props) {
         if (elem[p]) {
           flatElem[p] = elem[p];
         }
@@ -313,12 +321,14 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2) {
       return ref;
+    } else if(scope === '$self' && ref.length === 2) {
+      return ref;
     }
 
     return flatten(ref, path);
 
     function flatten(ref, path) {
-      let result = [];
+      let result = scope === '$self' ? [ref[0]] : [];
       //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
       if(!links && !scope) { // calculate JIT if not supplied
         const res = inspectRef(path);
@@ -327,23 +337,25 @@ function getTransformers(model, options, pathDelimiter = '_') {
       }
       if (scope === '$magic')
         return ref;
+      // Don't process a leading $self - it will a .art with .elements!
+      const startIndex = scope === '$self' ? 1 : 0;
       let flattenStep = false;
-      links.forEach((value, idx) => {
+      for(let i = startIndex; i < links.length; i++) {
+        const value = links[i];
         if (flattenStep) {
-          result[result.length - 1] += pathDelimiter + (ref[idx].id ? ref[idx].id : ref[idx]);
+          result[result.length - 1] += pathDelimiter + (ref[i].id ? ref[i].id : ref[i]);
           // if we had a filter or args, we had an assoc so this step is done
           // we then keep along the filter/args by updating the id of the current ref
-          if(ref[idx].id) {
-            ref[idx].id = result[result.length-1];
-            result[result.length-1] = ref[idx];
+          if(ref[i].id) {
+            ref[i].id = result[result.length-1];
+            result[result.length-1] = ref[i];
           }
         }
         else {
-          result.push(ref[idx]);
+          result.push(ref[i]);
         }
-
         flattenStep = value.art && !value.art.kind && !value.art.SELECT && !value.art.from && (value.art.elements || effectiveType(value.art).elements || (resolvedLinkTypes.get(value)||{}).elements);
-      });
+      }
 
       return result;
     }
@@ -389,7 +401,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    *
    * @param {CSN.Artifact} node
    * @param {WeakMap} [resolved] WeakMap containing already resolved refs
-   * @param {boolean} [keepLocalized=false] Wether to clone .localized from a type def
+   * @param {boolean} [keepLocalized=false] Whether to clone .localized from a type def
    * @returns {void}
    */
   function toFinalBaseType(node, resolved, keepLocalized=false) {
@@ -402,11 +414,11 @@ function getTransformers(model, options, pathDelimiter = '_') {
         throw Error('Failed to obtain final base type for reference : ' + node.type.ref.join('/'));
       if(finalBaseType.elements) {
           // This changes the order - to be discussed!
-        node.elements = cloneCsn(finalBaseType, options).elements; // copy elements
+        node.elements = cloneCsnNonDict(finalBaseType, options).elements; // copy elements
         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.items, options); // copy items
+        node.items = cloneCsnNonDict(finalBaseType.items, options); // copy items
         delete node.type;
       } else {
         node.type=finalBaseType;
@@ -420,20 +432,19 @@ function getTransformers(model, options, pathDelimiter = '_') {
     let typeDef = typeof node.type === 'string' ? getCsnDef(node.type) : node.type;
     // Nothing to do if type is an array or a struct type
     if (typeDef.items || typeDef.elements) {
-      if(!(options.transformation === 'hdbcds' || options.toSql))
-        return;
-
       // cloneCsn only works correctly if we start "from the top"
-      const cloneTypeDef = cloneCsn(typeDef, options);
-      // With hdbcds-hdbcds, don't resolve structured types - but propagrate ".items", to turn into LargeString later on.
+      const cloneTypeDef = cloneCsnNonDict(typeDef, options);
+      // With hdbcds-hdbcds, don't resolve structured types - but propagate ".items", to turn into LargeString later on.
       if(typeDef.items) {
         delete node.type;
-        Object.assign(node, {items: cloneTypeDef.items});
+        if(!node.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: cloneTypeDef.elements});
+        if(!node.elements)
+          Object.assign(node, {elements: cloneTypeDef.elements});
       }
 
 
@@ -593,7 +604,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   //                 elemName         typeName        isKey               defaultVal       notNull
   function createScalarElement(elemName, typeName, isKey = false, defaultVal = undefined, notNull=false) {
     if (!isBuiltinType(typeName) && !model.definitions[typeName]) {
-      throw new Error('Expecting valid type name: ' + typeName);
+      throw new ModelError('Expecting valid type name: ' + typeName);
     }
     let result = {
       [elemName]: {
@@ -684,7 +695,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function addForeignKey(foreignKey, elem) {
     // Sanity checks
     if (!elem.target || !elem.keys) {
-      throw new Error('Expecting managed association element with foreign keys');
+      throw new ModelError('Expecting managed association element with foreign keys');
     }
 
     // Add the foreign key
@@ -703,7 +714,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function addElement(elem, artifact, artifactName) {
     // Sanity check
     if (!artifact.elements) {
-      throw new Error('Expecting artifact with elements: ' + JSON.stringify(artifact));
+      throw new ModelError('Expecting artifact with elements: ' + JSON.stringify(artifact));
     }
     let elemName = Object.keys(elem)[0];
     // Element must not exist
@@ -734,7 +745,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    */
   function copyAndAddElement(elem, artifact, artifactName, elementName) {
     if (!artifact.elements) {
-      throw new Error('Expected structured artifact');
+      throw new ModelError('Expected structured artifact');
     }
     // Must not already have such an element
     if (artifact.elements[elementName]) {
@@ -765,14 +776,14 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
     if (returnTypeName) {
       if (!isBuiltinType(returnTypeName) && !model.definitions[returnTypeName])
-        throw new Error('Expecting valid return type name: ' + returnTypeName);
+        throw new ModelError('Expecting valid return type name: ' + returnTypeName);
       action.returns = { type: returnTypeName };
     }
 
     // Add parameter if provided
     if (paramName && paramTypeName) {
       if (!isBuiltinType(paramTypeName) && !model.definitions[paramTypeName])
-        throw new Error('Expecting valid parameter type name: ' + paramTypeName);
+        throw new ModelError('Expecting valid parameter type name: ' + paramTypeName);
 
       action.params = Object.create(null);
       action.params[paramName] = {
@@ -885,7 +896,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     let elements = artifact.elements;
     if (elements) {
       path.push('elements', null);
-      Object.entries(elements).forEach(([name, obj]) => {
+      forEach(elements, (name, obj) => {
         path[path.length - 1] = name;
         recurseElements(obj, path, callback);
       });
@@ -1105,7 +1116,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       'xpr': (parent, name, xpr, path) => {
         parent.xpr = expand(parent.xpr, path.concat(name));
       }
-    }, undefined, undefined, options);
+    }, [], options);
 
     /*
       flatten structured leaf types and return array of paths

package/lib/transform/translateAssocsToJoins.js

@@ -44,7 +44,7 @@ function translateAssocsToJoinsCSN(csn, options){
   }
 
   // If A2J reports error - end! Continuing with a broken CSN makes no sense
-  makeMessageFunction(model, options).throwWithError();
+  makeMessageFunction(model, options).throwWithAnyError();
   // FIXME: Move this somewhere more appropriate
   const compact = compactModel(model, compileOptions);
   return compact;
@@ -120,7 +120,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     /*
       Setup QAs for mixins
       Mark all mixin assoc definitions with a pseudo QA that points to the assoc target.
-      This QA is required to detect mixin assoc usages to decide wether a minimum or full
+      This QA is required to detect mixin assoc usages to decide whether a minimum or full
       join needs to be done
     */
     forEachQuery(createQAForMixinAssoc, env);
@@ -793,25 +793,8 @@ function translateAssocsToJoins(model, inputOptions = {})
                 If the value is an expression in the select block, return the unmodified
                 expression. rewriteGenericPaths will check and rewrite these paths later
                 to the correct ON condition expression.
-
-                Hack alert:
-                But if this mixin ON condition path starts with $self no foreign key can
-                be generated, raise the error here and set $check to false
-                as it is too hard for checkPathDictionary() to find out that this is a
-                mixin speciality. Use same mesage as in checkPathDictionary().
               */
 
-              path.forEach(ps => { // eslint-disable-line consistent-return
-                if(ps._artifact.target) {
-                  error(null, pathNode.location,
-                    { name: env.lead.name.absolute,  id: ps.id, alias: pathAsStr(pathNode.path) },
-                    '$(NAME): $(ID) in path $(ALIAS) must not be an association'
-                  );
-                  //pathNode.$check = false;
-                  return pathNode;
-                }
-              });
-
               if(!value.path)
                 return value;
               else {
@@ -1090,7 +1073,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
   /*
     Replace the table alias node in $tableAliases inplace with the newly created JOIN node
-    See definer.js initTableExpression for details where _joinParent and $joinArgsIndex is set.
+    See define.js initTableExpression for details where _joinParent and $joinArgsIndex is set.
   */
   function replaceTableAliasInPlace( tableAlias, replacementNode ) {
     if (tableAlias._joinParent)

package/lib/transform/universalCsn/.eslintrc.json

@@ -0,0 +1,36 @@
+{
+  "root": true,
+  "plugins": ["sonarjs", "jsdoc"],
+  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended", "plugin:jsdoc/recommended"],
+  "rules": {
+    "prefer-const": "error",
+    "quotes": ["error", "single", "avoid-escape"],
+    "prefer-template": "error",
+    "no-trailing-spaces": "error",
+    "template-curly-spacing":["error", "never"],
+    "complexity": ["warn", 30],
+    "max-len": "off",
+    // Don't enforce stupid descriptions
+    "jsdoc/require-param-description": "off",
+    "jsdoc/require-returns-description": "off",
+    // Very whiny and nitpicky
+    "sonarjs/cognitive-complexity": "off",
+    // Does not recognize TS types
+    "jsdoc/no-undefined-types": "off",
+    // Just annoying as hell
+    "sonarjs/no-duplicate-string": "off"
+  },
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "script"
+  },
+  "env": {
+    "es6": true,
+    "node": true
+  },
+  "settings": {
+    "jsdoc": {
+      "mode": "typescript"
+    }
+  }
+}

package/lib/transform/universalCsn/coreComputed.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const {
+  getUtils, forEachDefinition, forAllQueries, getNormalizedQuery,
+} = require('../../model/csnUtils');
+const { setAnnotationIfNotDefined } = require('./utils');
+
+/**
+ * Set @Core.Computed on the elements of views (and projections).
+ *
+ * @param {CSN.Model} csn
+ */
+function setCoreComputedOnViews(csn) {
+  const {
+    artifactRef, getColumn, getElement,
+  } = getUtils(csn, 'init-all');
+
+  forEachDefinition(csn, (artifact) => {
+    if (artifact.query || artifact.projection) {
+      forAllQueries(getNormalizedQuery(artifact).query, (query) => {
+        if (query.SELECT)
+          traverseQueryAndAttachCoreComputed(query, query.SELECT.elements || artifact.elements);
+      });
+    }
+  });
+  /**
+   * Attach @Core.Computed to elements resulting from calculated fields
+   *
+   * To do that, for a given element, we search for its matching column/subquery-element (its ancestor).
+   * At the ancestor, we can see if it needs a @CoreComputed - check out {@link needsCoreComputed} for details.
+   *
+   *
+   * @param {CSN.Query} query
+   * @param {CSN.Elements} elements
+   */
+  function traverseQueryAndAttachCoreComputed(query, elements) {
+    for (const [ name, element ] of Object.entries(elements)) {
+      const ancestor = getAncestor(element, name, query.SELECT);
+
+      if (needsCoreComputed(ancestor)) // calculated field, function or virtual
+        setAnnotationIfNotDefined(element, '@Core.Computed', true);
+      if (ancestor && (ancestor.expand || ancestor.inline))
+        traverseExpandInline(ancestor, attachCoreComputed);
+    }
+
+    /**
+     * Get the ancestor of a given element - either a direct column that "caused" it, or an element
+     * from some other artifact (table or view/subquery). The later happens via SELECT * and can be found by drilling down into the
+     * FROM-clause.
+     *
+     * @param {CSN.Element} element
+     * @param {string} name
+     * @param {CSN.QuerySelect} base
+     * @returns {CSN.Column|CSN.Element}
+     */
+    function getAncestor(element, name, base) {
+      const column = getColumn(element);
+      if (column)
+        return column;
+      return getElementFromFrom(name, base.from);
+    }
+
+    /**
+     * Get the element <name> from the given query-base (from of a select).
+     *
+     * For a simple ref to a table, resolve the ref and check the elements
+     * For a UNION, drill down into the leading query
+     * For a JOIN, check each join-argument
+     * For a query with subelements, check the subelements
+     *
+     * @param {string} name
+     * @param {object} base
+     * @returns {CSN.Element}
+     * @todo cleanup throw(s) - but leave in during dev
+     */
+    function getElementFromFrom(name, base) {
+      if (base.SELECT && base.SELECT.elements) {
+        return getAncestor(base.SELECT.elements[name], name, base.SELECT);
+      }
+      else if (base.ref) {
+        let artifact = artifactRef(base);
+        if (artifact.target)
+          artifact = artifactRef(artifact.target);
+        return artifact.elements[name];
+      }
+      else if (base.SET) {
+        return getElementFromFrom(name, base.SET.args[0]);
+      }
+      else if (base.args && base.join) {
+        const result = checkJoinSources(base.args, name);
+        if (!result)
+          throw new Error(`Could not find ${name} in ${JSON.stringify(base.args)}`);
+        return result;
+      }
+
+      throw new Error(JSON.stringify(base));
+    }
+
+    /**
+     * For the given JOIN-args, check if one of the join sources provides an element <name>
+     *
+     * @param {Array} args
+     * @param {string} name
+     * @returns {CSN.Element|null} Null if no element was found
+     */
+    function checkJoinSources(args, name) {
+      for (const arg of args) {
+        if (arg.args) { // Join after join - A join B on <..> join C on <..>
+          const result = checkJoinSources(arg.args, name);
+          if (result)
+            return result;
+        }
+        else { // All other cases - normal ref, a subselect, etc. pp
+          const result = getElementFromFrom(name, arg);
+          if (result)
+            return result;
+        }
+      }
+
+      return null;
+    }
+
+    /**
+     * On a given column, attach @Core.Computed if needed
+     *
+     * @param {CSN.Column} column
+     */
+    function attachCoreComputed(column) {
+      if (needsCoreComputed(column))
+        setAnnotationIfNotDefined(getElement(column), '@Core.Computed', true);
+    }
+
+    /**
+     * Return whether the given columns element needs to be marked with @Core.Computed.
+     *
+     * @param {CSN.Column} column
+     * @returns {boolean}
+     */
+    function needsCoreComputed(column) {
+      return column &&
+        (
+          column.xpr || column.func || column.val !== undefined || column.param || column.SELECT || column.SET ||
+          column.ref && [ '$at', '$now', '$user', '$session' ].includes(column.ref[0])
+        );
+    }
+
+    /**
+     * Call the given callback for all sub-things of a .expand/.inline and drill further down into other .expand/.inline
+     *
+     * @param {CSN.Column} column
+     * @param {Function} callback
+     */
+    function traverseExpandInline(column, callback) {
+      if (column.expand) {
+        column.expand.forEach((col) => {
+          callback(col);
+          traverseExpandInline(col, callback);
+        });
+      }
+      else if (column.inline) {
+        column.inline.forEach((col) => {
+          callback(col);
+          traverseExpandInline(col, callback);
+        });
+      }
+    }
+  }
+}
+
+module.exports = {
+  setCoreComputedOnViews,
+};