@sap/cds-compiler 6.2.2 → 6.3.0

package/lib/transform/localized.js

@@ -3,7 +3,6 @@
 const { makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 const { forEachKey } = require('../utils/objectUtils');
-const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
   applyAnnotationsFromExtensions,
   forEachDefinition,
@@ -15,29 +14,9 @@ const {
   cloneCsnDict,
   cloneCsnNonDict,
   sortCsnDefinitionsForTests,
-  sortCsn
+  sortCsn,
 } = require('../model/cloneCsn');
 
-/**
- * Indicator that a definition is localized and has a convenience view.
- * art[_hasLocalizedView]'s value should be the name of the convenience view.
- */
-const _hasLocalizedView = Symbol('_hasLocalizedView');
-/**
- * Whether a convenience view was generated for another view.
- * In that case we have a _vertical_ view.
- */
-const _isViewForView = Symbol('_isViewForView');     // $inferred = 'LOCALIZED-VERTICAL'
-/**
- * Whether a convenience view was generated for an entity that is localized.
- * In that case we have a _horizontal_ view.
- */
-const _isViewForEntity = Symbol('_isViewForEntity'); // $inferred = 'LOCALIZED-HORIZONTAL'
-/**
- * List of artifacts for which the view/entity is a target.
- * Used to transitively create convenience views.
- */
-const _targetFor = Symbol('_targetFor');
 const annoPersistenceSkip = '@cds.persistence.skip';
 
 /**
@@ -50,8 +29,10 @@ const annoPersistenceSkip = '@cds.persistence.skip';
 /**
  * Create transitive localized convenience views.
  *
- * A convenience view is created if the entity/view has a localized element[^1]
- * or if it exposes an association leading to a localized-tagged target.
+ * 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.
  *
  * INTERNALS:
  * We have three kinds of localized convenience views:
@@ -120,9 +101,33 @@ function _addLocalizationViews(csn, options, config) {
   // 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.
+   * localizedViewsFor[name]'s value should be the name of the convenience view.
+   * @type {Record<string, string>}
+   */
+  const localizedViewFor = Object.create(null);
+  /**
+   * Whether a convenience view was generated for another view.
+   * In that case we have a _vertical_ view.
+   * @type {Record<string, boolean>}
+   */
+  const createdForView = Object.create(null);  // $inferred = 'LOCALIZED-VERTICAL'
+  /**
+   * Whether a convenience view was generated for an entity that is localized.
+   * In that case we have a _horizontal_ view.
+   * @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
-  cleanDefinitionSymbols();
   applyAnnotationsForLocalizedViews();
   sortLocalizedForTests(csn, options);
   messageFunctions.throwWithError();
@@ -169,16 +174,16 @@ function _addLocalizationViews(csn, options, config) {
       return;
     }
 
-    art[_hasLocalizedView] = viewName;
+    localizedViewFor[artName] = viewName;
 
     if (acceptLocalizedView && !acceptLocalizedView(viewName, artName))
       return;
 
     let view;
     if (art.query || art.projection)
-      view = createLocalizedViewForView(art);
+      view = createLocalizedViewForView(art, viewName);
     else
-      view = createLocalizedViewForEntity(art, artName, textElements);
+      view = createLocalizedViewForEntity(art, artName, viewName, textElements);
 
     copyPersistenceAnnotations(view, art);
     csn.definitions[viewName] = view;
@@ -191,10 +196,11 @@ function _addLocalizationViews(csn, options, config) {
    *
    * @param {CSN.Definition} entity
    * @param {string} entityName
+   * @param {string} viewName Name of the localized view.
    * @param {string[]} [textElements]
    * @returns {CSN.View}
    */
-  function createLocalizedViewForEntity( entity, entityName, textElements = [] ) {
+  function createLocalizedViewForEntity( entity, entityName, viewName, textElements = [] ) {
     // Only use joins if requested and text elements are provided.
     const shouldUseJoin = useJoins && !!textElements.length;
     const columns = [ ];
@@ -209,14 +215,14 @@ function _addLocalizationViews(csn, options, config) {
         },
       },
       elements: cloneCsnDict(entity.elements, options),
-      [_isViewForEntity]: true,
     };
     copyLocation(convenienceView, entity);
     copyLocation(convenienceView.query, entity);
+    createdForEntity[viewName] = true;
 
     if (shouldUseJoin)
       // Expand elements; (variant 1)
-      columns.push( ...columnsForEntityWithExcludeList( entity, 'L_0', textElements ) )
+      columns.push( ...columnsForEntityWithExcludeList( entity, 'L_0', textElements ) );
     else
       columns.push( '*' ); // (variant 2)
 
@@ -235,11 +241,9 @@ function _addLocalizationViews(csn, options, config) {
 
     return convenienceView;
 
-
     function createFromClauseForEntity() {
-      if (!shouldUseJoin) {
+      if (!shouldUseJoin)
         return createColumnRef( [ entityName ], 'L');
-      }
 
       const from = {
         join: 'left',
@@ -247,7 +251,7 @@ function _addLocalizationViews(csn, options, config) {
           createColumnRef( [ entityName ], 'L_0'),
           createColumnRef( [ textsEntityName(entityName) ], 'localized_1' ),
         ],
-        on: []
+        on: [],
       };
 
       for (const originalElement of textElements) {
@@ -266,37 +270,37 @@ function _addLocalizationViews(csn, options, config) {
 
       return from;
     }
-
   }
 
   /**
-   * Create a localized convenience view for the given definition `view`.
+   * Create a localized convenience view for the given definition `art`.
    * Does _not_ rewrite references.
    *
-   * @param {CSN.Definition} view
+   * @param {CSN.Definition} art View for which a convenience view should be created.
+   * @param {string} viewName    Name of the to-be created convenience view.
    * @returns {CSN.View}
    */
-  function createLocalizedViewForView( view ) {
+  function createLocalizedViewForView( art, viewName ) {
     const convenienceView = {
       kind: 'entity',
-      '@odata.draft.enabled': false
+      '@odata.draft.enabled': false,
     };
 
-    if (view.query)
-      convenienceView.query = cloneCsnNonDict(view.query, options);
-    else if (view.projection)
-      convenienceView.projection = cloneCsnNonDict(view.projection, options);
+    if (art.query)
+      convenienceView.query = cloneCsnNonDict(art.query, options);
+    else if (art.projection)
+      convenienceView.projection = cloneCsnNonDict(art.projection, options);
 
-    convenienceView.elements = cloneCsnDict(view.elements, options);
-    convenienceView[_isViewForView] = true;
-    copyLocation(convenienceView, view);
+    convenienceView.elements = cloneCsnDict(art.elements, options);
+    createdForView[viewName] = true;
+    copyLocation(convenienceView, art);
 
     Object.keys(convenienceView.elements).forEach((elemName) => {
       addCoreComputedIfNecessary(convenienceView.elements, elemName);
     });
 
-    if (view.params)
-      convenienceView.params = cloneCsnDict(view.params, options);
+    if (art.params)
+      convenienceView.params = cloneCsnDict(art.params, options);
 
     return convenienceView;
   }
@@ -309,14 +313,14 @@ function _addLocalizationViews(csn, options, config) {
     const mainName = shouldUseJoins ? 'L_0' : 'L';
     const localizedNames = shouldUseJoins ? [ 'localized_1' ] : [ 'L', 'localized' ];
 
-    if (noCoalesce) {
-      return createColumnRef( [...localizedNames, elementName], elementName );
-    }
+    if (noCoalesce)
+      return createColumnRef( [ ...localizedNames, elementName ], elementName );
+
 
     return {
       func: 'coalesce',
       args: [
-        createColumnRef( [ ...localizedNames, elementName] ),
+        createColumnRef( [ ...localizedNames, elementName ] ),
         createColumnRef( [ mainName, elementName ] ),
       ],
       as: elementName,
@@ -366,7 +370,7 @@ function _addLocalizationViews(csn, options, config) {
     let keyCount = 0;
     let textElements = [];
 
-    forEachGeneric(art, 'elements', (elem, elemName , _prop) => {
+    forEachGeneric(art, 'elements', (elem, elemName, _prop) => {
       if (elem.$ignore) // from SAP HANA backend
         return;
 
@@ -382,8 +386,10 @@ function _addLocalizationViews(csn, options, config) {
       return null;
 
     if (!isEntityPreprocessed( art )) {
-      messageFunctions.info( null, artPath, { name: artName },
-             'Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements' );
+      messageFunctions.info(
+        null, artPath, { name: artName },
+        'Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements'
+      );
       return null;
     }
 
@@ -391,18 +397,24 @@ function _addLocalizationViews(csn, options, config) {
     const textsEntity = csn.definitions[textsName];
 
     if (!textsEntity) {
-      messageFunctions.info( null, artPath, { name: artName },
-             'Skipped creation of convenience view for $(NAME) because its texts entity could not be found' );
+      messageFunctions.info(
+        null, artPath, { name: artName },
+        'Skipped creation of convenience view for $(NAME) because its texts entity could not be found'
+      );
       return null;
     }
     if (!isValidTextsEntity( textsEntity )) {
-      messageFunctions.info( null, [ 'definitions', textsName ], { name: artName },
-             'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid' );
+      messageFunctions.info(
+        null, [ 'definitions', textsName ], { name: artName },
+        'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid'
+      );
       return null;
     }
     if (!art[annoPersistenceSkip] && textsEntity[annoPersistenceSkip]) {
-      messageFunctions.message( 'anno-unexpected-localized-skip', artPath,
-          { name: textsName, art: artName, anno: annoPersistenceSkip } );
+      messageFunctions.message(
+        'anno-unexpected-localized-skip', artPath,
+        { name: textsName, art: artName, anno: annoPersistenceSkip }
+      );
       return null;
     }
 
@@ -433,7 +445,7 @@ function _addLocalizationViews(csn, options, config) {
    *
    *  1. For each view with elements that have `localized: true` markers:
    *      => add view to array `entities`
-   *     For each view/entity with associations:
+   *     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:
@@ -465,7 +477,7 @@ function _addLocalizationViews(csn, options, config) {
       if (isInLocalizedNamespace(artName))
         // Ignore existing `localized.` views.
         return;
-      if (art[_hasLocalizedView])
+      if (localizedViewFor[artName])
         // Entity already has a convenience view.
         return;
 
@@ -486,11 +498,12 @@ function _addLocalizationViews(csn, options, config) {
           }
           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 (def[_hasLocalizedView]) {
+            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);
@@ -498,12 +511,11 @@ function _addLocalizationViews(csn, options, config) {
             else {
               // Otherwise the target view may become localized at a later point so
               // we should add it to a reverse-dependency list.
-              if (!def[_targetFor])
-                def[_targetFor] = [];
-              def[_targetFor].push(artName);
+              targetFor[elem.target] ??= [];
+              targetFor[elem.target].push(artName);
             }
-
-          } else {
+          }
+          else {
             // recursive check
             _collectFromElements(elem.elements);
           }
@@ -518,16 +530,16 @@ function _addLocalizationViews(csn, options, config) {
      * @param {string} artName
      */
     function createViewAndCollectSources( artName ) {
-      const art = csn.definitions[artName];
-      if (art[_hasLocalizedView])
+      if (localizedViewFor[artName]) {
         // view/entity was already processed
         return;
+      }
 
       addLocalizedView(artName);
 
-      if (!ignoreAssocToLocalized && art[_targetFor])
-        nextEntities.push(...art[_targetFor]);
-      delete art[_targetFor];
+      if (!ignoreAssocToLocalized && targetFor[artName])
+        nextEntities.push(...targetFor[artName]);
+      delete targetFor[artName];
     }
   }
 
@@ -538,12 +550,12 @@ function _addLocalizationViews(csn, options, config) {
    * @param {string} artName
    */
   function rewriteToLocalized( art, artName ) {
-    if (art[_isViewForEntity]) {
+    if (createdForEntity[artName]) {
       // For entity convenience views only references in elements need to be rewritten.
       // a.k.a 'LOCALIZED-HORIZONTAL'
       forEachGeneric(art, 'elements', elem => rewriteDirectRefPropsToLocalized(elem));
     }
-    else if (art[_isViewForView]) {
+    else if (createdForView[artName]) {
       // For view convenience views (i.e. transitive views) we need to rewrite `from`
       // references as well as need to handle `mixin` elements.
       // a.k.a 'LOCALIZED-VERTICAL'
@@ -597,8 +609,8 @@ function _addLocalizationViews(csn, options, config) {
       }
       else if (typeof val === 'string') {
         const def = csn.definitions[val];
-        if (def && def[_hasLocalizedView])
-          obj[prop] = def[_hasLocalizedView];
+        if (def && localizedViewFor[val])
+          obj[prop] = localizedViewFor[val];
       }
     }
   }
@@ -614,20 +626,18 @@ function _addLocalizationViews(csn, options, config) {
       return;
     const ref = Array.isArray(obj.ref) ? obj.ref[0] : obj.ref;
     if (typeof ref === 'string') {
-      const def = csn.definitions[ref];
-      if (def && def[_hasLocalizedView]) {
+      if (localizedViewFor[ref]) {
         if (Array.isArray(obj.ref))
-          obj.ref[0] = def[_hasLocalizedView];
+          obj.ref[0] = localizedViewFor[ref];
         else
-        obj.ref = def[_hasLocalizedView];
+          obj.ref = localizedViewFor[ref];
       }
-
-    } else if (ref.id) {
-      const def = csn.definitions[ref.id];
-      if (def && def[_hasLocalizedView])
-        obj.ref[0].id = def[_hasLocalizedView];
-
-    } else if (options.testMode) {
+    }
+    else if (ref.id) {
+      if (localizedViewFor[ref.id])
+        obj.ref[0].id = localizedViewFor[ref.id];
+    }
+    else if (options.testMode) {
       throw new CompilerAssertion('Debug me: Unhandled reference during localized-rewrite!');
     }
   }
@@ -640,19 +650,13 @@ function _addLocalizationViews(csn, options, config) {
     return csn.definitions[artName].elements.texts.target;
   }
 
-  function cleanDefinitionSymbols() {
-    forEachDefinition(csn, function cleanDefinition(definition) {
-      cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor);
-    });
-  }
-
   /**
    * In case that the user tried to annotate `localized.*` artifacts, apply them.
    */
   function applyAnnotationsForLocalizedViews() {
     applyAnnotationsFromExtensions(csn, {
       override: true,
-      filter: (name) => name.startsWith('localized.'),
+      filter: name => name.startsWith('localized.'),
       notFound(name, index) {
         if (!ignoreUnknownExtensions) {
           messageFunctions.message('ext-undefined-def', [ 'extensions', index ],
@@ -673,11 +677,11 @@ function _addLocalizationViews(csn, options, config) {
       const artName = defName.substring(localizedPrefix.length);
       const art = csn.definitions[artName];
       if (def[annoPersistenceSkip] && !art?.[annoPersistenceSkip]) {
-        messageFunctions.message( 'anno-unexpected-localized-skip', ['definitions', defName], {
+        messageFunctions.message( 'anno-unexpected-localized-skip', [ 'definitions', defName ], {
           '#': 'view',
           name: defName,
           art: artName,
-          anno: annoPersistenceSkip
+          anno: annoPersistenceSkip,
         });
       }
     }
@@ -734,9 +738,7 @@ function columnsForEntityWithExcludeList(entity, entityName, excludeList) {
   // @ts-ignore
   return Object.keys(entity.elements)
     .filter(elementName => !excludeList.includes(elementName))
-    .map(elementName => {
-      return { ref: [ entityName, elementName ] };
-    });
+    .map(elementName => ({ ref: [ entityName, elementName ] }));
 }
 
 /**
@@ -758,7 +760,7 @@ function copyLocation(target, source) {
  * @param {CSN.Artifact} source
  */
 function copyPersistenceAnnotations(target, source) {
-  forEachKey(source, anno => {
+  forEachKey(source, (anno) => {
     // Note:
     //   v3/v4: Because `.exists` is copied to the convenience view, it could
     //   lead to some localization views referencing non-existing ones.
@@ -788,13 +790,18 @@ function checkExistingLocalizationViews(csn, options, messageFunctions) {
       if (!def.query && !def.projection) {
         if (!name.endsWith('.texts')) {
           hasNonViews = true;
-          messageFunctions.error('reserved-namespace-localized', ['definitions', name], { name: 'localized' },
-            'The namespace $(NAME) is reserved for localization views');
+          messageFunctions.error(
+            'reserved-namespace-localized', [ 'definitions', name ], { name: 'localized' },
+            'The namespace $(NAME) is reserved for localization views'
+          );
         }
-      } else if (!hasExistingViews) {
+      }
+      else if (!hasExistingViews) {
         hasExistingViews = true;
-        messageFunctions.info( null, [ 'definitions', name ], {},
-          'Input CSN already contains localization views, no further ones will be created' );
+        messageFunctions.info(
+          null, [ 'definitions', name ], {},
+          'Input CSN already contains localization views, no further ones will be created'
+        );
       }
     }
   });
@@ -810,7 +817,7 @@ function isValidTextsEntity(entity) {
   if (!entity)
     return false;
   const requiredTextsProps = [ 'locale' ];
-  return requiredTextsProps.some( prop => !!entity.elements[prop])
+  return requiredTextsProps.some( prop => !!entity.elements[prop]);
 }
 
 /**

package/lib/transform/odata/adaptAnnotationRefs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { transformAnnotationExpression, implicitAs, } = require('../../model/csnUtils');
+const { transformAnnotationExpression, implicitAs } = require('../../model/csnUtils');
 
 /**
  * Used during annotating of foreign keys.
@@ -14,23 +14,27 @@ const { transformAnnotationExpression, implicitAs, } = require('../../model/csnU
  * @param {CSN.Path} elementPath
  */
 function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, elementPath) {
-  if(Array.isArray(generatedForeignKeys?.[0])) {
+  if (Array.isArray(generatedForeignKeys?.[0])) {
     // ensure we are always called with an array of objects. TODO: Cleanup fk creation in for.effective to create array of objects
     adaptAnnotationsRefs(remapToArrayOfObjects(generatedForeignKeys), csnUtils, { error }, elementPath);
-  } else {
+  }
+  else {
     const reportedErrorsForAnnoPath = {};
     generatedForeignKeys.forEach((gfk, index) => {
-      Object.entries(gfk.foreignKey).forEach(([key, value]) => {
-        if (key[0] !== '@') return;
+      Object.entries(gfk.foreignKey).forEach(([ key, value ]) => {
+        if (key[0] !== '@')
+          return;
 
         transformAnnotationExpression(gfk.foreignKey, key, {
           ref: (_parent, _prop, ref, path, _p, _ppn, ctx) => {
             // if the reference is a $self reference, we do nothing,
             // as this is the way to tell that we do not reference the foreign key
-            if (ref[0] === '$self') return;
+            if (ref[0] === '$self')
+              return;
             // if annotation was not propagated from the keys array during foreign keys creation,
             // means that it is not a candidate for foreign key substitution
-            if (gfk.keyAnnotations !== null && !gfk.keyAnnotations.includes(key)) return;
+            if (gfk.keyAnnotations !== null && !gfk.keyAnnotations.includes(key))
+              return;
 
             const art = gfk.originalKey._art ||
             csnUtils.inspectRef(elementPath ? path : getOriginatingKeyPath(gfk, path)).art; // OData uses getOriginatingKeyPath - as it relies on $path
@@ -39,15 +43,16 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
                 error('odata-anno-xpr-ref', path, { elemref: { ref }, anno: key, '#': 'fk_substitution' });
                 reportedErrorsForAnnoPath[path] = true;
               }
-            } else {
+            }
+            else {
               const gfkForRef = findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref);
               if (gfkForRef.length === 1) {
                 ref[0] = gfkForRef[0].prefix;
 
-                if (ctx?.annoExpr?.['=']) {
+                if (ctx?.annoExpr?.['='])
                   ctx.annoExpr['='] = true;
-                }
-              } else {
+              }
+              else {
                 // check if the annotation reference points to a structure that has been expanded,
                 // if so -> report an error
                 const foundInOriginalRef = findOriginalRef(generatedForeignKeys.filter(gfk => gfk.originalKey.$originalKeyRef), ref);
@@ -59,8 +64,8 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
                 }
               }
             }
-          }
-        }, elementPath ? elementPath.concat(['keys', index]) : value?.$path?.slice(0, value.$path.length - 1)); // OData uses $path
+          },
+        }, elementPath ? elementPath.concat([ 'keys', index ]) : value?.$path?.slice(0, value.$path.length - 1)); // OData uses $path
       });
     });
   }
@@ -88,9 +93,9 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
 }
 
 function remapToArrayOfObjects(generatedForeignKeys) {
-  return generatedForeignKeys.map(([ prefix, foreignKey, originalKey ]) => {
-    return { prefix, foreignKey, originalKey, keyAnnotations: null };
-  });
+  return generatedForeignKeys.map(([ prefix, foreignKey, originalKey ]) => ({
+    prefix, foreignKey, originalKey, keyAnnotations: null,
+  }));
 }
 
 module.exports = { adaptAnnotationsRefs };