@sap/cds-compiler 3.9.4 → 4.0.0

package/lib/transform/localized.js

@@ -610,8 +610,10 @@ function _addLocalizationViews(csn, options, useJoins, config) {
       override: true,
       filter: (name) => name.startsWith('localized.'),
       notFound(name, index) {
-        if (!ignoreUnknownExtensions)
-          messageFunctions.message('anno-undefined-art', [ 'extensions', index ], { name })
+        if (!ignoreUnknownExtensions) {
+          messageFunctions.message('anno-undefined-art', [ 'extensions', index ],
+                                   { art: name });
+        }
       },
     });
   }

package/lib/transform/odata/toFinalBaseType.js

@@ -103,14 +103,14 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
 
     if(node.type && !isBuiltinType(node.type)) {
       const finalBaseType = csnUtils.getFinalTypeInfo(node.type);
-      if(!finalBaseType) {
+      if(finalBaseType == null) {
         /*
-          type could not be resolved, set it to null
-          Today, all type refs must be resolvable,
-          input validations checkTypeDefinitionHasType, checkElementTypeDefinitionHasType
+          type could not be resolved, delete type property to be equal to a typeless element
+          definition. Today, all type refs must be resolvable, input validations
+          checkTypeDefinitionHasType, checkElementTypeDefinitionHasType
           guarantee this. In the future this may change.
         */
-        node.type = null;
+        delete node.type;
       }
       else {
         if (isExpandable(finalBaseType) || node.kind === 'type') {

package/lib/transform/odata/typesExposure.js

@@ -26,7 +26,7 @@ const { CompilerAssertion } = require('../../base/error');
  * and edges e(v_r, v_d) such that all v_r, v_d are elements of S (v_rs, v_ds) and with that
  * all edges are { e(v_rs, v_ds) }.
  *
- * The input CSN may contain edges e(v_rs, v_dns) with v_r element of S_i (v_rs) and v_d not element 
+ * The input CSN may contain edges e(v_rs, v_dns) with v_r element of S_i (v_rs) and v_d not element
  * of S_i (v_dns).
  *
  * The aim of this algorithm is to produce Tc's for all requested S_i by 'filling' up the missing
@@ -50,7 +50,7 @@ const { CompilerAssertion } = require('../../base/error');
  *
  * If name(v_dns) has no prefix segments, the fallback schema name is prepended instead:
  * name(v_ds) = name(v_s) + '.' + fallbackschema + name(v_dns);
- * 
+ *
  * @param {CSN.Model} csn
  * @param {function}  whatsMyServiceName
  * @param {string[]}     requestedServiceNames
@@ -160,7 +160,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         // we're no longer in a key def => don't set notNull:true on named types
         if(isKey)
           isKey = false;
-        // in case this was a named type and if the openess does not match the type definition
+        // in case this was a named type and if the openness does not match the type definition
         // expose the type as a new one not changing the original definition.
         if(elements && !!node['@open'] !== !!typeDef['@open'])
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';

package/lib/transform/parseExpr.js

@@ -282,6 +282,9 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
       // if(xpr?.func && funkyfuncs.includes(xpr?.func))
       //   return xpr;
       for(let n in xpr) {
+        // xpr could be an array with polluted prototype
+        if (!Object.hasOwnProperty.call(xpr, n))
+          continue;
         const x = xpr[n];
         const isAnno = n[0] === '@' && isSimpleAnnoValue(x);
         if(isAnno)

package/lib/transform/transformUtilsNew.js

@@ -66,28 +66,35 @@ function getTransformers(model, options, pathDelimiter = '_') {
     expandStructsInExpression,
   };
 
-  // Try to apply length, precision, scale from options if no type facet is set on the primitive types 'cds.String' or 'cds.Decimal'.
-  // If 'obj' has primitive type 'cds.String' and no length try to apply length from options if available or set to default 5000.
-  // if 'obj' has primitive type 'cds.Decimal' try to apply precision, scale from options if available.
-  function addDefaultTypeFacets(element, defStrLen5k=true) {
+  /**
+   * Try to apply length, precision, scale from options if no type facet is set on the primitive types 'cds.String' or 'cds.Decimal'.
+   * If 'obj' has primitive type 'cds.String' and no length try to apply length from options if available or set to default internalDefaultLengths[type].
+   * if 'obj' has primitive type 'cds.Decimal' try to apply precision, scale from options if available.
+   *
+   * @param {CSN.Element} element
+   * @param {null|object} [internalDefaultLengths] Either null (no implicit default) or an object `{ 'cds.String': N, 'cds.Binary': N }`.
+   * */
+  function addDefaultTypeFacets(element, internalDefaultLengths = null) {
     if (!element || !element.type)
       return;
 
     if (element.type === 'cds.String' && element.length === undefined) {
-      if(options.defaultStringLength) {
+      if (options.defaultStringLength) {
         element.length = options.defaultStringLength;
         setProp(element, '$default', true);
       }
-      else if(defStrLen5k)
-        element.length = 5000;
+      else if (internalDefaultLengths !== null) {
+        element.length = internalDefaultLengths[element.type];
+      }
     }
     if (element.type === 'cds.Binary' && element.length === undefined) {
-      if(options.defaultBinaryLength) {
+      if (options.defaultBinaryLength) {
         element.length = options.defaultBinaryLength;
         setProp(element, '$default', true);
       }
-      else if(defStrLen5k)
-        element.length = 5000;
+      else if(internalDefaultLengths !== null) {
+        element.length = internalDefaultLengths[element.type];
+      }
     }
   /*
     if (element.type === 'cds.Decimal' && element.precision === undefined && options.precision) {
@@ -273,7 +280,22 @@ function getTransformers(model, options, pathDelimiter = '_') {
       // This has historic reasons. We don't copy doc-comments because copying annotations
       // is questionable to begin with.  Only selected annotations should have been copied,
       // if at all.
-      copyAnnotations(elem, flatElem, false);
+      // When flattening structured elements for OData don't propagate the odata.Type annotations
+      // as these would falsify the flattened elements. Type facets must be aligned with
+      // EdmTypeFacetMap defined in edm.js
+      const excludes = options.toOdata ?
+      {
+        '@odata.Type': 1,
+        '@odata.Scale': 1,
+        '@odata.Precision': 1,
+        '@odata.MaxLength': 1,
+        '@odata.SRID': 1,
+        '@odata.FixedLength': 1,
+        '@odata.Collation': 1,
+        '@odata.Unicode': 1,
+      } : {};
+      copyAnnotations(elem, flatElem, false, excludes);
+
       // Copy selected type properties
       const props = ['key', 'virtual', 'masked', 'viaAll'];
       // 'localized' is needed for OData
@@ -413,14 +435,11 @@ function getTransformers(model, options, pathDelimiter = '_') {
       // Copy elements/items and we're finished. No need to look up actual base type,
       // since it must also be structured and must contain at least as many elements,
       // if not more (in client style CSN).
-      if (typeRef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
+      if (typeRef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds'))
         nodeWithType.elements = cloneCsnDictionary(typeRef.elements, options);
-        delete nodeWithType.type;
-      }
-      if (typeRef.items) {
+      else if (typeRef.items)
         nodeWithType.items = cloneCsnNonDict(typeRef.items, options);
-        delete nodeWithType.type;
-      }
+
       return;
     }
 
@@ -450,7 +469,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     art.elements && Object.entries(art.elements).forEach(([elemName, artElem]) => {
       let elem = Object.assign({}, artElem);
       // Transfer xrefs, that are redirected to the projection
-      // TODO: shall we remove the transfered elements from the original?
+      // TODO: shall we remove the transferred elements from the original?
       // if (artElem._xref) {
       //   setProp(elem, '_xref', artElem._xref.filter(xref => xref.user && xref.user._main && xref.user._main._service == service));
       // }
@@ -470,7 +489,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // Assemble the projection itself and add it into the model
     let projection = {
       'kind': 'entity',
-      projection: query.SELECT, // it is important that projetion and query refer to the same object!
+      projection: query.SELECT, // it is important that projection and query refer to the same object!
       elements
     };
     // copy annotations from art to projection
@@ -749,6 +768,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       if (!isBuiltinType(returnTypeName) && !model.definitions[returnTypeName])
         throw new ModelError('Expecting valid return type name: ' + returnTypeName);
       action.returns = { type: returnTypeName };
+      // TODO: What about annotation propagation from return type to `returns`?
     }
 
     // Add parameter if provided
@@ -918,7 +938,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
   /**
    * Assigns unconditionally annotation to a node, which means it overwrites already existing annotation assignment.
-   * Overwritting is when the assignment differs from undefined and null, also when differs from the already set value.
+   * Overwriting is when the assignment differs from undefined and null, also when differs from the already set value.
    * Setting new assignment results false as return value and overwriting - true.
    *
    * @param {object} node Assignee
@@ -1114,7 +1134,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
           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;
           const lhsIsVal = (lhs.val !== undefined);
-          // if ever rhs should be alowed to be a value uncomment this
+          // if ever rhs should be allowed to be a value uncomment this
           const rhsIsVal = (rhs === 'null' /*|| rhs.val !== undefined*/);
 
           // lhs & rhs must be expandable types (structures or managed associations)
@@ -1300,8 +1320,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
       }
 
       function getType(art) {
-        const effart = effectiveType(art);
-        return Object.keys(effart).length ? effart : art.type;
+        const effArt = effectiveType(art);
+        return Object.keys(effArt).length ? effArt : art.type;
       }
 
       function isExpandable(art) {

package/lib/transform/translateAssocsToJoins.js

@@ -230,7 +230,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
   /*
     Add an artificial QA for each mixin definition. This QA completes the QAT
-    datastructure that requires a QA at the rootQat before starting the join generation.
+    data-structure that requires a QA at the rootQat before starting the join generation.
     This QA is marked as 'mixin' which indicates that the paths of the ON condition must
     not receive the usual source and target table alias (which is used for generic associations)
     but instead just use the rootQA of the individual ON condition paths. These paths are
@@ -684,7 +684,7 @@ function translateAssocsToJoins(model, inputOptions = {})
               //env.assocStack.includes(fwdAssoc) => recursion
               if(env.assocStack.length === 2) {
                 // reuse (ugly) error message from forHana
-                error(null, env.assocStack[0].location,
+                error(null, [env.assocStack[0].location,env.assocStack[0]],
                   { name: '$self', id: '$self' },
                   'An association that uses $(NAME) in its ON-condition can\'t be compared to $(ID)');
                 // don't check these paths again
@@ -706,6 +706,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       }
 
       function cloneOnCondExprTree(expr) {
+        // TODO: This function is not covered by an tests, only cloneOnCondExprStream is.
         // keep parentheses intact
         if(Array.isArray(expr))
           return expr.map(cloneOnCondition);
@@ -1126,7 +1127,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       for(let fkn in element.foreignKeys)
       {
         let fk = element.foreignKeys[fkn];
-        // once a fk is to be followed, treat all sub patsh as srcSide, this will add fk.name.id only
+        // once a fk is to be followed, treat all sub-paths as srcSide, this will add fk.name.id only
         if(srcSide)
           paths = paths.concat(flattenElement(fk.targetElement._artifact, true,  fk.name.id, fk.targetElement.path.map(ps => ps.id).join(pathDelimiter)));
         else
@@ -1199,7 +1200,7 @@ function translateAssocsToJoins(model, inputOptions = {})
   /*
     Munch path steps and append them to a path string until an
     assoc step is found. The assoc path step is also appended
-    to the path string. If no assoc path step has occured, all
+    to the path string. If no assoc path step has occurred, all
     path steps are added to the path string and tail is empty.
 
     Return assocPathStep, the remaining tail path and the path string
@@ -1219,7 +1220,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
   /*
     Substitute the n first path steps of a given path against a FK alias name.
-    Resolve a foreign key of a managaged association by following the n first
+    Resolve a foreign key of a managed association by following the n first
     path steps. Longest path matches:
     Example: fk tuple { a.b, a.b.c, a.b.e },
     path: a.b.c.d.e.f: FK a.b.c is found, even if FK a.b is one level higher in the prefix tree.
@@ -1866,7 +1867,7 @@ function walkPath(node, env)
     /*
       NOTE: As long as association path steps are not allowed in filters,
       it is not required to walk over filter expressions.
-      Simple filter paths are rewritten inin createJoinTree (first filter)
+      Simple filter paths are rewritten in createJoinTree (first filter)
       and createJoinQA (subsequent one that belong to the ON condition).
 
       If the filter becomes JOIN relevant, default FILTERS (part of the

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

@@ -1,7 +1,7 @@
 {
   "root": true,
   "plugins": ["sonarjs", "jsdoc"],
-  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended", "plugin:jsdoc/recommended"],
+  "extends": ["plugin:jsdoc/recommended", "../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
   "rules": {
     "prefer-const": "error",
     "quotes": ["error", "single", "avoid-escape"],

package/lib/transform/universalCsn/coreComputed.js

@@ -27,7 +27,9 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
     }
     else if (artifact.kind === 'entity' || artifact.kind === 'aspect') {
       forEachMemberRecursively(artifact, (element) => {
-        if (element.value && !element.value?.ref) // calculated elements, but simple references are ignored
+        // Calculated elements, but simple references are ignored for on-read.
+        // casts() are also computed. In CSN, they appear next to a `.ref`.
+        if (element.value && (!element.value.ref || element.value.cast || element.value.stored))
           setAnnotationIfNotDefined(element, '@Core.Computed', true);
       }, path);
     }
@@ -95,7 +97,7 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
         return getAncestor(base.SELECT.elements[name], name, base.SELECT);
       }
       else if (base.ref) {
-        let artifact = artifactRef(base);
+        let artifact = artifactRef.from(base);
         if (artifact.target)
           artifact = artifactRef(artifact.target);
         return artifact.elements[name];
@@ -145,7 +147,7 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
     }
 
     /**
-     * Return whether the given columns element needs to be marked with @Core.Computed.
+     * Returns true, if the given columns element needs to be annotated with @Core.Computed.
      *
      * @param {CSN.Column} column
      * @returns {boolean}
@@ -153,9 +155,9 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
     function needsCoreComputed( column ) {
       return column &&
         (
-          column.xpr || column.list || column.func || column.val !== undefined || column.param ||
+          column.xpr || column.list || column.func || column.val !== undefined || column['#'] !== undefined || column.param ||
           column.SELECT || column.SET ||
-          column.ref && [ '$at', '$valid', '$now', '$user', '$session' ].includes(column.ref[0])
+          column.ref && [ '$at', '$valid', '$now', '$user', '$session', '$parameters' ].includes(column.ref[0])
         );
     }
 

package/lib/transform/universalCsn/universalCsnEnricher.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const shuffleGen = require('../../base/shuffle');
 const { setAnnotationIfNotDefined, makeClientCompatible } = require('./utils');
 const {
@@ -23,7 +23,6 @@ const { setCoreComputedOnViewsAndCalculatedElements } = require('./coreComputed'
  * @param {CSN.Options} options
  */
 module.exports = (csn, options) => {
-  const propagateToReturns = isBetaEnabled( options, 'v4preview' );
   const csnUtils = getUtils(csn, 'init-all');
   const {
     initDefinition, getOrigin, getQueryPrimarySource, artifactRef, getColumn,
@@ -116,7 +115,7 @@ module.exports = (csn, options) => {
   // The $origin properties need to be removed separately
   // as the values are used in csnRef::getOrigin that is used during
   // the propagation above.
-  // Currently testMode-only for comparison against client CSN.
+  // Currently, testMode-only for comparison against client CSN.
   if (options.testMode)
     makeClientCompatible(csn);
 
@@ -174,10 +173,7 @@ module.exports = (csn, options) => {
 
         setTargetAspectIfRequired(parent);
       },
-      type: ( parent, prop, type, path, grandParent, parentProp ) => {
-        // annos are not propagated to `returns` (<=v3) and `items`
-        if (parentProp === 'returns' && !propagateToReturns)
-          return;
+      type: ( parent, prop, type ) => {
         const annotationsForBuiltinType = extensions[type];
         Object.assign( parent, annotationsForBuiltinType );
       },
@@ -288,13 +284,17 @@ module.exports = (csn, options) => {
       },
       params: (parent, prop, params) => {
         forEachValue(params, (param) => {
+          const propagateToParams = typeof param.type === 'string' ? csn.definitions[param.type]?.kind !== 'entity' : true;
           propagateMemberPropsFromOrigin(param, {
-            items: true, elements: true, enum: true, virtual: true,
+            '@': !propagateToParams, items: true, elements: true, enum: true, virtual: true,
           });
         });
       },
       returns: (parent, prop, returns) => {
-        propagateMemberPropsFromOrigin(returns, { items: true, '@': !propagateToReturns, elements: true });
+        // Only propagate to `returns` (return parameter) if return type is not an entity.
+        // If returns.type is an array, it is an element ref. If it's not found, it's likely builtin.
+        const propagateToParams = typeof returns.type === 'string' ? csn.definitions[returns.type]?.kind !== 'entity' : true;
+        propagateMemberPropsFromOrigin(returns, { '@': !propagateToParams, items: true, elements: true });
         if (returns.target)
           calculateForeignKeys(returns);
       },
@@ -368,7 +368,7 @@ module.exports = (csn, options) => {
        * @todo check if still necessary
        */
       function skipMemberPropagation( origin ) {
-      // For empty members (`{}`), the origin was set in a previous call to `getOrigin(definition)`.
+        // For empty members (`{}`), the origin was set in a previous call to `getOrigin(definition)`.
         return !origin;
       }
     }
@@ -519,7 +519,7 @@ module.exports = (csn, options) => {
     forEachValue(elements, (element) => {
       if (element.target) {
         const column = getColumn(element);
-        if (column) {
+        if (column?.ref) {
           const mixin = query.SELECT.mixin[implicitAs(column.ref)] || {};
           copyProperties(mixin, element, getMemberPropagationRuleFor);
         }
@@ -552,7 +552,7 @@ module.exports = (csn, options) => {
     if (!target.kind)
       return;
     const primarySourceRef = getQueryPrimarySource(target.query || target.projection);
-    const artRef = primarySourceRef ? artifactRef(primarySourceRef) : source;
+    const artRef = primarySourceRef ? artifactRef.from(primarySourceRef) : source;
     if (!artRef.target)
       target[prop] = source[prop];
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "3.9.4",
+  "version": "4.0.0",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -59,6 +59,6 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   }
 }

package/share/messages/{duplicate-autoexposed.md → def-duplicate-autoexposed.md}

@@ -1,4 +1,4 @@
-# duplicate-autoexposed
+# def-duplicate-autoexposed
 
 Two or more entities with the same name can’t be auto-exposed in the same
 service.
@@ -76,3 +76,7 @@ auto-exposing entities.  The reason is that the resulting auto-exposed names
 could become _long_ names that don’t seem natural nor intuitive.  We chose to
 expose the entity name because that’s what most developers want to do when
 they manually expose entities.
+
+## Other Notes
+
+This message was called `duplicate-autoexposed` in cds-compiler v3 and earlier.

package/share/messages/message-explanations.json

@@ -4,7 +4,7 @@
     "anno-duplicate-unrelated-layer",
     "check-proper-type",
     "check-proper-type-of",
-    "duplicate-autoexposed",
+    "def-duplicate-autoexposed",
     "extend-repeated-intralayer",
     "extend-unrelated-layer",
     "redirected-to-ambiguous",