@sap/cds-compiler 6.9.3 → 7.0.1

package/lib/transform/localized.js

@@ -29,31 +29,22 @@ const annoPersistenceSkip = '@cds.persistence.skip';
 /**
  * Create transitive localized convenience views.
  *
- * A convenience view is created if (a) the entity/view has a localized element[^1]
- * or (b) if it exposes an association leading to a localized-tagged target.
- * The second part (b) is only performed if option `fewerLocalizedViews` is
- * disabled.
+ * A convenience view is created if the entity/view has a localized element[^1].
  *
  * INTERNALS:
- * We have three kinds of localized convenience views:
+ * We have two kinds of localized convenience views:
  *
  *  1. "direct ones" using coalesce() for the table entities with localized
- *     elements[^1]: as projection on the original and '.texts' entity (created in extend.js)
- *  2. for _table_ entities with associations to entities which have a localized
- *     convenience: as projection on the original
- *  3. for _view_ entities with either localized elements[^1] or associations
- *     to entities which have a localized convenience view:
+ *     elements[^1]: as projection on the original and '.texts' entity
+ *  2. for _view_ entities with localized elements[^1]:
  *     as view using a copy of the original query, but replacing all sources by
  *     their localized convenience view variant if present
  *
  * [^1]: That is, the element has `localized: true`.
  *
- * First, all "direct ones" are built (1).  Then we build all 2 and 3
- * transitively (i.e. as long as an entity has an association which directly or
- * indirectly leads to an entity with localized elements, we create a localized
- * variant for it), and finally make sure via redirection that associations in
- * localized convenience views have as target the localized convenience view
- * variant if present.
+ * First, all "direct ones" are built (1).  Then we build 2 transitively and
+ * finally make sure via redirection that associations in localized convenience
+ * views have as target the localized convenience view variant if present.
  *
  * @param {CSN.Model} csn
  *     Input CSN model.  Should not have existing convenience views.
@@ -82,8 +73,6 @@ function _addLocalizationViews(csn, options, config) {
   const { useJoins, acceptLocalizedView, ignoreUnknownExtensions } = config;
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
-  // default is true, hence only check for explicitly disabled option
-  const ignoreAssocToLocalized = options.fewerLocalizedViews !== false;
 
   /**
    * Indicator that a definition is localized and has a convenience view.
@@ -103,29 +92,22 @@ function _addLocalizationViews(csn, options, config) {
    * @type {Record<string, boolean>}
    */
   const createdForEntity = Object.create(null); // $inferred = 'LOCALIZED-HORIZONTAL'
-  /**
-   * List of artifacts for which the view/entity is a target.
-   * Used to transitively create convenience views.
-   * @type {Record<string, string[]>}
-   */
-  const targetFor = Object.create(null);
 
   createDirectConvenienceViews();     // 1
-  createTransitiveConvenienceViews(); // 2 + 3
+  createConvenienceViewsForViews(); // 2
   applyAnnotationsForLocalizedViews();
   sortLocalizedForTests(csn, options);
   messageFunctions.throwWithError();
   return csn;
 
   /**
-   * Create direct convenience localization views for entities that have localized elements.
-   * Only entities that have `localized` elements are used.  `localized` in types or sub-elements
-   * are not respected.
+   * Create direct convenience localization views for table entities (not views or projections)
+   * that have localized elements.  `localized` in types or sub-elements are not respected.
    */
   function createDirectConvenienceViews() {
     forEachDefinition(csn, (art, artName) => {
       if (art.kind !== 'entity' || art.query || art.projection)
-        // Ignore non-entities and views.  The latter are handled at a later point (step 2+3).
+        // Ignore non-entities and views.  The latter are handled at a later point (step 2).
         return;
 
       if (isInLocalizedNamespace(artName))
@@ -412,42 +394,30 @@ function _addLocalizationViews(csn, options, config) {
   }
 
   /**
-   * Transitively create convenience views for entities/views that have
-   * associations to localized entities, views that themselves have such
-   * a dependency or views that contain projections on localized elements.
+   * Create convenience views for views/projections that contain localized elements.
    *
    * The algorithm is as follows:
    *
    *  1. For each view with elements that have `localized: true` markers:
    *      => add view to array `entities`
-   *     For each view/entity with associations (if fewerLocalizedViews is false):
-   *      - If target is NOT localized => add view/entity to target's `_targetFor` property
-   *      - If target is     localized => add view/entity to array `entities`
-   *  2. As long as `entities` has entries:
-   *      a. For each entry in `entities`
-   *         - Create a convenience view
-   *         - If the entry has a `_targetFor` property, add its entries to `nextEntities`
-   *           because they now have a transitive dependency on a localized view.
-   *      b. Copy all entries from `nextEntities` to `entities`.
-   *      c. Clear `nextEntities`.
+   *  2. For each entry in `entities`: create a convenience view.
    *  3. Rewrite all references to the localized variants.
    */
-  function createTransitiveConvenienceViews() {
-    let entities = [];
+  function createConvenienceViewsForViews() {
+    const entities = [];
     forEachDefinition( csn, collectLocalizedEntities );
-
-    let nextEntities = [];
-    while (entities.length) {
-      entities.forEach( createViewAndCollectSources );
-      entities = [ ...nextEntities ];
-      nextEntities = [];
+    for (const artName of entities) {
+      if (!localizedViewFor[artName])
+        addLocalizedView(artName);
     }
     forEachDefinition( csn, rewriteToLocalized );
-    return;
 
     function collectLocalizedEntities( art, artName ) {
       if (art.kind !== 'entity')
-        // Ignore non-entities but also process entities because of associations.
+        // Ignore non-entities.
+        return;
+      if (!art.query && !art.projection)
+        // Table entities are already handled in step 1.
         return;
       if (isInLocalizedNamespace(artName))
         // Ignore existing `localized.` views.
@@ -458,63 +428,24 @@ function _addLocalizationViews(csn, options, config) {
 
       _collectFromElements(art.elements);
 
+      // helper function, return value only used internally to stop recursion if localized element is found
       function _collectFromElements(elements) {
-        if (!elements)
-          return;
-
-        // Element may be localized or has an association to localized entity.
+        // Element may be localized.
         for (const elemName in elements) {
           const elem = elements[elemName];
 
-          if ((art.query || art.projection) && elem.localized && !elem.key && !elem.$key) {
-            // e.g. projections ; ignore if key is present (warning already issued) or
-            // if the artifact is an entity (already processed in (1))
+          if (elem.localized && !elem.key && !elem.$key) {
+            // e.g. projections ; ignore if key is present (warning already issued)
             entities.push(artName);
+            return true; // one push per artifact is enough
           }
-          else if (!ignoreAssocToLocalized && elem.target) {
-            // If the target has a localized view then we are localized as well.
-            // Only necessary if "fewerLocalizedView" is disabled.
-            const def = csn.definitions[elem.target];
-            if (!def)
-              continue;
-
-            if (localizedViewFor[elem.target]) {
-              // The target may already be localized and if so, then add the artifact
-              // to the to-be-processed entities.
-              entities.push(artName);
-            }
-            else {
-              // Otherwise the target view may become localized at a later point so
-              // we should add it to a reverse-dependency list.
-              targetFor[elem.target] ??= [];
-              targetFor[elem.target].push(artName);
-            }
-          }
-          else {
-            // recursive check
-            _collectFromElements(elem.elements);
-          }
-        }
-      }
-    }
 
-    /**
-     * Create a localization view for `artName` and add views/entities that depend
-     * on `artName` to `nextEntities`
-     *
-     * @param {string} artName
-     */
-    function createViewAndCollectSources( artName ) {
-      if (localizedViewFor[artName]) {
-        // view/entity was already processed
-        return;
+          // recursive check
+          if (elem.elements && _collectFromElements(elem.elements))
+            return true;  // found localized element
+        }
+        return false;
       }
-
-      addLocalizedView(artName);
-
-      if (!ignoreAssocToLocalized && targetFor[artName])
-        nextEntities.push(...targetFor[artName]);
-      delete targetFor[artName];
     }
   }
 
@@ -761,7 +692,7 @@ function checkExistingLocalizationViews(csn, options, messageFunctions) {
   let hasNonViews = false;
 
   forEachDefinition(csn, (def, name) => {
-    if (isInLocalizedNamespace(name) || name === 'localized') {
+    if (isInLocalizedNamespace(name)) {
       if (!def.query && !def.projection) {
         if (!name.endsWith('.texts')) {
           hasNonViews = true;

package/lib/transform/odata/flattening.js

@@ -17,7 +17,8 @@ const { cloneCsnNonDict } = require('../../base/cloneCsn');
 const { forEach } = require('../../utils/objectUtils');
 const { assignAnnotation } = require('../../edm/edmUtils');
 
-function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options) {
+function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTypeInfo, isExternalServiceMember, messageFunctions, csnUtils, options) {
+  const { error, warning } = messageFunctions;
   const allMgdAssocDefs = [];
   forEachDefinition(csn, (def, defName) => {
     if (def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
@@ -53,6 +54,14 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
                 adaptManagedAssociationSpecialFields(flatElt, flatEltName, flattenedSubTree);
                 orderedElementList.push([ flatEltName, flatElt ]);
               });
+              // Also, propagate 'default' to flattened leaf element, but only for single-element structures;
+              // warn and ignore for multi-element structures
+              if (child.default?.val !== undefined) {
+                if (flattenedSubTree.length === 1)
+                  flattenedSubTree[0][1].default = { ...child.default };
+                else if (flattenedSubTree.length > 1)
+                  warning('type-default-ignored-for-struct', location, { '#': 'std', name: childName });
+              }
             }
             else {
               // TODO: run adaptManagedAssociationSpecialFields here as well
@@ -246,7 +255,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
     const exprAnnoNames = copyAnnotations(elt, flatElt, false, excludes).filter(pn => pn[0] === '@');
     flattenAndPrefixExprPaths(flatElt, exprAnnoNames, elt.$path, rootPrefix, typeIdx);
     // Copy selected type properties
-    [ 'key', 'virtual', 'masked', 'viaAll', 'localized' ].forEach((p) => {
+    [ 'key', 'virtual', 'viaAll', 'localized' ].forEach((p) => {
       if (elt[p] != null)
         flatElt[p] = elt[p];
     });

package/lib/transform/transformUtils.js

@@ -105,7 +105,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
 
   // For a structured element 'elem', return a dictionary of flattened elements to
   // replace it, flattening names with pathDelimiter's value and propagating all annotations and the
-  // type properties 'key', 'notNull', 'virtual', 'masked' to the flattened elements.
+  // type properties 'key', 'notNull', 'virtual' to the flattened elements.
   // example input:
   //  { elem: {
   //          key: true,
@@ -200,7 +200,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       copyAnnotations(elem, flatElem, false, excludes);
 
       // Copy selected type properties
-      const props = [ 'key', 'virtual', 'masked', 'viaAll' ];
+      const props = [ 'key', 'virtual', 'viaAll' ];
       // 'localized' is needed for OData
       if (options.toOdata)
         props.push('localized');
@@ -209,6 +209,28 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
           flatElem[p] = elem[p];
       }
     });
+
+    // Propagate 'default' to flattened leaf element (SQL only)
+    // Only apply for single-element structures; warn and ignore for multi-element structures
+    if (elem.default?.val !== undefined && (options.transformation === 'sql' || options.transformation === 'effective')) {
+      const flattenedNames = Object.keys(result);
+
+      if (flattenedNames.length === 1) {
+        // Single element: propagate default if leaf doesn't have one
+        const singleElem = result[flattenedNames[0]];
+        if (singleElem.default?.val === undefined) {
+          singleElem.default = elem.default; // Copy entire default object {val, location}
+        }
+      }
+      else if (flattenedNames.length > 1) {
+        // Multi-element structure: warn that default is ignored
+        warning('type-default-ignored-for-struct', pathInCsn, {
+          '#': 'std',
+          name: elemName,
+        });
+      }
+    }
+
     return result;
   }
 
@@ -319,7 +341,7 @@ function getTransformers(model, options, msgFunctions, 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)
         nodeWithType.elements = cloneCsnDict(typeRef.elements, options);
       else if (typeRef.items)
         nodeWithType.items = cloneCsnNonDict(typeRef.items, options);

package/lib/transform/universalCsn/universalCsnEnricher.js

@@ -54,7 +54,7 @@ module.exports = (csn, options) => {
 
   const ruleToFunction = {
     __proto__: null,
-    never: skip,
+    never: skip,   // TODO: should work like corrected `onlyViaParent`, see #13794
     onlyViaParent: skip,        // TODO: not correct
     onlyViaArtifact,
     notWithPersistenceTable,
@@ -67,7 +67,6 @@ module.exports = (csn, options) => {
   const memberPropagationRules = {
     key: skip,
     enum: notWithTypeOrigin,
-    masked: skip,
     virtual: notWithTypeRef,
     items: specialItemsRules,
     elements: (prop, target, source) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "6.9.3",
+  "version": "7.0.1",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -25,6 +25,6 @@
     "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   }
 }