@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/compiler/define.js

@@ -77,7 +77,7 @@
 // References are resolved in the "resolve" phase of the compiler, see
 // './resolver.js'.  We then get the properties `type.absolute` and `length`.
 
-// Sub phase 1 (addXYZ) - only for main artifats
+// Sub phase 1 (addXYZ) - only for main artifacts
 //  - set _block links
 //  - store definitions (including context extensions), NO duplicate check
 //  - artifact name check
@@ -505,13 +505,13 @@ function define( model ) {
       initParentLink( parent, definitions );
     }
     if (art.kind !== 'namespace' &&
-        isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' )) {
+        isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' )) {
       let p = parent;
       while (p && kindProperties[p.kind].artifacts)
         p = p._parent;
       if (p) {
         error( 'subartifacts-not-supported', [ art.name.location, art ],
-               { art: p, prop: 'deprecated.generatedEntityNameWithUnderscore' },
+               { art: p, prop: 'deprecated._generatedEntityNameWithUnderscore' },
                // eslint-disable-next-line max-len
                'With the option $(PROP), no sub artifact can be defined for a non-context/service $(ART)' );
       }
@@ -572,7 +572,7 @@ function define( model ) {
     if (query.on)
       initExprForQuery( query.on, query );
     // TODO: MIXIN with name = ...subquery (not yet supported anyway)
-    initSelectItems( query, query.columns );
+    initSelectItems( query, query.columns, query );
     if (query.where)
       initExprForQuery( query.where, query );
     if (query.having)
@@ -580,12 +580,14 @@ function define( model ) {
     initMembers( query, query, query._block );
   }
 
-  function initSelectItems( parent, columns ) {
+  function initSelectItems( parent, columns, user ) {
     // TODO: forbid expand/inline with :param, global:true, in ref-where, outside queries (CSN), ...
     let wildcard = null;
+    let hasItems = false;
     for (const col of columns || parent.expand || parent.inline || []) {
       if (!col)                 // parse error
         continue;
+      hasItems = true;
       if (!columns) {
         if (parent.value)
           setLink( col, '_pathHead', parent ); // also set for '*' in expand/inline
@@ -606,13 +608,27 @@ function define( model ) {
           col.val = null;       // do not consider it for expandWildcard()
         }
       }
-      else if (col.value || col.expand) {
+      // Either expression (value), expand or new association (target && type)
+      else if (col.value || col.expand || (col.target && col.type)) {
         setLink( col, '_block', parent._block );
         defineAnnotations( col, col, parent._block ); // TODO: complain with inline
         // TODO: allow sub queries? at least in top-level expand without parallel ref
         if (columns)
           initExprForQuery( col.value, parent );
-        initSelectItems( col );
+        initSelectItems( col, null, user );
+      }
+    }
+
+    if (hasItems && !wildcard && parent.excludingDict) {
+      // TODO: Better way to get source file?
+      let block = parent;
+      while (block._block)
+        block = block._block;
+
+      if (block.$frontend === 'cdl') {
+        warning('query-ignoring-exclude', [ parent.excludingDict[$location], user ],
+                { prop: '*' },
+                'Excluding elements without wildcard $(PROP) has no effect');
       }
     }
   }
@@ -898,15 +914,43 @@ function define( model ) {
         delete obj.on;          // continuation semantics: not specified
       }
       if (targetAspect.elements) {
+        const inEntity = parent._main && parent._main.kind === 'entity';
+        // TODO: also allow indirectly (component in component in entity)?
         setLink( targetAspect, '_outer', obj );
         setLink( targetAspect, '_parent', parent._parent );
         setLink( targetAspect, '_main', null ); // for name resolution
-        obj = targetAspect;
-        parent = obj;
+
+        parent = targetAspect;
         construct = parent;     // avoid extension behavior
-        obj.kind = 'aspect';   // TODO: probably '$aspect' to detect
-        setLink( obj, '_block', block );
-        initDollarSelf( obj );
+        targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
+        setLink( targetAspect, '_block', block );
+        initDollarSelf( targetAspect );
+        // allow ref of up_ in anonymous aspect inside entity
+        // (TODO: complain if used and the managed composition is included into
+        // another entity - might induce auto-redirection):
+        if (inEntity && !targetAspect.elements.up_) {
+          const up = {
+            name: {
+              id: 'up_',
+              alias: 'up_',
+              element: obj.name.element,
+              absolute: obj.name.absolute,
+            },
+            kind: '$navElement',
+            location: obj.location,
+          };
+          setLink( up, '_parent', targetAspect );
+          setLink( up, '_main', targetAspect ); // used on main artifact
+          // recompilation case: both target and targetAspect → allow up_ in that case, too:
+          const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
+          const entity = name && model.definitions[name];
+          if (entity && entity.elements)
+            setLink( up, '_origin', entity.elements.up_ );
+          // processAspectComposition/expand() sets _origin to element of
+          // generated target entity
+          targetAspect.$tableAliases.up_ = up;
+        }
+        obj = targetAspect;
       }
     }
     if (obj !== parent && obj.elements && parent.enum) {
@@ -926,6 +970,7 @@ function define( model ) {
       if (checkDefinitions( construct, parent, 'enum', obj.enum || false ))
         forEachGeneric( obj, 'enum', init );
     }
+
     if (obj.foreignKeys)  // cannot be extended or annotated - TODO: check anyway?
       forEachInOrder( obj, 'foreignKeys', init );
     if (checkDefinitions( construct, parent, 'actions' ))
@@ -1009,7 +1054,7 @@ function define( model ) {
     // - artifacts (CDL-only anyway) only inside [extend] context|service
     if (!dict)
       return false;
-    const names = Object.getOwnPropertyNames( dict );
+    const names = Object.keys( dict );
     if (!names.length) // TODO: re-check - really allow empty dict if no other?
       return false;
     const feature = kindProperties[parent.kind][prop];
@@ -1046,6 +1091,9 @@ function define( model ) {
       error( 'unexpected-elements', [ location, construct ], {},
              'Elements only exist in entities, types or typed constructs' );
     }
+    else if (prop === 'columns') {
+      error( 'extend-columns', [ location, construct ], { art: construct } );
+    }
     else { // if (prop === 'enum') {
       error( 'unexpected-enum', [ location, construct ], {},
              'Enum symbols can only be defined for types or typed constructs' );

package/lib/compiler/extend.js

@@ -7,8 +7,8 @@
 
 const { searchName, weakLocation } = require('../base/messages');
 const {
-  isDeprecatedEnabled, isBetaEnabled,
-  forEachGeneric, forEachInOrder,
+  isDeprecatedEnabled,
+  forEachGeneric, forEachInOrder, forEachDefinition,
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
@@ -47,15 +47,16 @@ function extend( model ) {
 
   applyExtensions();
 
-  const commonLanguagesEntity // TODO: remove beta after a grace period
-        = (options.addTextsLanguageAssoc || isBetaEnabled( options, 'addTextsLanguageAssoc' )) &&
-        model.definitions['sap.common.Languages'];
+  const commonLanguagesEntity = options.addTextsLanguageAssoc &&
+    model.definitions['sap.common.Languages'];
   const addTextsLanguageAssoc = !!(commonLanguagesEntity && commonLanguagesEntity.elements &&
                                    commonLanguagesEntity.elements.code);
   Object.keys( model.definitions ).forEach( processArtifact );
 
   lateExtensions( false );
 
+  compositionChildPersistence();
+
   /**
    * Process "composition of" artifacts.
    *
@@ -88,6 +89,25 @@ function extend( model ) {
     }
   }
 
+  /**
+   * Copy `@cds.persistence.skip` and `@cds.persistence.skip` from parent to child
+   * for managed compositions.  This needs to be done after extensions, i.e. annotations,
+   * have been applied or `annotate E.comp` would not have an effect on `E.comp.subComp`.
+   */
+  function compositionChildPersistence() {
+    const processed = new WeakSet();
+    forEachDefinition(model, processCompositionPersistence);
+
+    function processCompositionPersistence(def) {
+      if (def.$inferred === 'composition-entity' && !processed.has(def)) {
+        if (def._parent)
+          processCompositionPersistence(def._parent);
+        copyPersistenceAnnotations(def, def._parent, options);
+        processed.add(def);
+      }
+    }
+  }
+
   // extend ------------------------------------------------------------------
 
   /**
@@ -158,6 +178,7 @@ function extend( model ) {
       checkDefinitions( ext, art, 'enum');
       checkDefinitions( ext, art, 'actions');
       checkDefinitions( ext, art, 'params');
+      checkDefinitions( ext, art, 'columns');
       defineAnnotations( ext, art, ext._block, ext.kind );
     }
     return true;
@@ -245,7 +266,7 @@ function extend( model ) {
         while (obj.items)
           obj = obj.items;
         const validDict = obj[prop] || prop === 'elements' && obj.enum;
-        const member = validDict[name];
+        const member = validDict && validDict[name];
         if (!member)
           extendNothing( dict[name], prop, name, art, validDict );
         else if (!(member.$duplicates))
@@ -262,6 +283,10 @@ function extend( model ) {
    */
   function extendColumns( ext, art ) {
     // TODO: consider reportUnstableExtensions
+
+    for (const col of ext.columns)
+      defineAnnotations( col, col, ext._block, ext.kind );
+
     const { location } = ext.name;
     const { query } = art;
     if (!query) {
@@ -487,7 +512,7 @@ function extend( model ) {
     const fioriAnno = art['@fiori.draft.enabled'];
     const fioriEnabled = fioriAnno && (fioriAnno.val === undefined || fioriAnno.val);
 
-    const textsName = (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
+    const textsName = (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
       ? `${ art.name.absolute }_texts`
       : `${ art.name.absolute }.texts`;
     const textsEntity = model.definitions[textsName];
@@ -496,8 +521,9 @@ function extend( model ) {
       return;
     if (textsEntity)            // expanded localized data in source
       return;                   // -> make it idempotent
-    createTextsEntity( art, textsName, localized, fioriEnabled );
+    const newTextsEntity = createTextsEntity( art, textsName, localized, fioriEnabled );
     addTextsAssociations( art, textsName, localized );
+    copyPersistenceAnnotations(newTextsEntity, art, options);
   }
 
   /**
@@ -602,13 +628,18 @@ function extend( model ) {
       elements,
       $inferred: 'localized-entity',
     };
+    // If there is a type `sap.common.Locale`, then use it as the type for the element `locale`.
+    // If not, use the default `cds.String` with a length of 14.
+    const hasLocaleType = model.definitions['sap.common.Locale'] &&
+      model.definitions['sap.common.Locale'].kind === 'type';
     const locale = {
       name: { location, id: 'locale' },
       kind: 'element',
-      type: augmentPath( location, 'cds.String' ),
-      length: { literal: 'number', val: 14, location },
+      type: augmentPath( location, hasLocaleType ? 'sap.common.Locale' : 'cds.String' ),
       location,
     };
+    if (!hasLocaleType)
+      locale.length = { literal: 'number', val: 14, location };
 
     if (!fioriEnabled) {
       locale.key = { val: true, location };
@@ -626,7 +657,7 @@ function extend( model ) {
       };
       dictAdd( art.elements, 'ID_texts', textId );
     }
-    if (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
+    if (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
       setLink( art, '_base', base );
 
     dictAdd( art.elements, 'locale', locale );
@@ -685,6 +716,8 @@ function extend( model ) {
     }
     if (fioriEnabled)
       annotateWith( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
+
+    return art;
   }
 
   /**
@@ -798,7 +831,7 @@ function extend( model ) {
         target = resolvePath( origin.targetAspect, 'compositionTarget', origin );
       if (!target || !target.elements)
         return;
-      const entityName = (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
+      const entityName = (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
         ? `${ base.name.absolute }_${ elem.name.id }`
         : `${ base.name.absolute }.${ elem.name.id }`;
       const entity = allowAspectComposition( target, elem, keys, entityName ) &&
@@ -809,6 +842,13 @@ function extend( model ) {
       };
       setArtifactLink( elem.target, entity );
       if (entity) {
+        // Support using the up_ element in the generated entity to be used
+        // inside the anonymous aspect:
+        const { up_ } = target.$tableAliases;
+        // TODO: invalidate "up_" alias (at least further navigation) if it
+        // already has an _origin (when the managed composition is included)
+        if (up_)
+          setLink( up_, '_origin', entity.elements.up_ );
         model.$compositionTargets[entity.name.absolute] = true;
         processAspectComposition( entity );
         processLocalizedData( entity );
@@ -914,7 +954,7 @@ function extend( model ) {
     // By default, 'up_' is a managed primary key association.
     // If 'up_' shall be rendered unmanaged, infer the parent
     // primary keys and add the ON condition
-    if (isDeprecatedEnabled( options, 'unmanagedUpInComponent' )) {
+    if (isDeprecatedEnabled( options, '_unmanagedUpInComponent' )) {
       addProxyElements( art, keys, 'aspect-composition', target.name && location,
                         'up__', '@odata.containment.ignore' );
       up.on = augmentEqual( location, 'up_', Object.values( keys ), 'up__' );
@@ -925,7 +965,7 @@ function extend( model ) {
       // even if target cardinality is 1..1
       up.notNull = { location, val: true };
     }
-    if (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
+    if (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
       setLink( art, '_base', base._base || base );
 
     dictAdd( art.elements, 'up_', up);
@@ -934,6 +974,10 @@ function extend( model ) {
     setLink( art, '_block', model.$internal );
     model.definitions[entityName] = art;
     initArtifact( art );
+
+    // Copy persistence annotations from aspect.
+    copyPersistenceAnnotations(art, target, options);
+
     return art;
   }
 
@@ -955,6 +999,27 @@ function extend( model ) {
   }
 }
 
+/**
+ * Copy the annotations `@cds.persistence.skip`/`@cds.persistence.exists` from
+ * source to target if present on source but not target.
+ *
+ * @param {object} target
+ * @param {object} source
+ * @param {CSN.Options} options
+ */
+function copyPersistenceAnnotations(target, source, options) {
+  if (!source)
+    return;
+  // Copy @cds.persistence.skip/exists annotation.
+  const noCopyExists = isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+  const existsAnno = '@cds.persistence.exists';
+  const skipAnno = '@cds.persistence.skip';
+  if (!noCopyExists && source[existsAnno] && !target[existsAnno])
+    target[existsAnno] = source[existsAnno];
+  if (source[skipAnno] && !target[skipAnno])
+    target[skipAnno] = source[skipAnno];
+}
+
 function augmentEqual( location, assocname, relations, prefix = '' ) {
   const args = relations.map( eq );
   return (args.length === 1)

package/lib/compiler/finalize-parse-cdl.js

@@ -2,6 +2,7 @@
 
 'use strict';
 
+const { dictAddArray } = require('../base/dictionaries');
 const { forEachGeneric, forEachMember } = require('../base/model');
 const { setLink, setArtifactLink } = require('./utils');
 
@@ -16,7 +17,7 @@ function finalizeParseCdl( model ) {
   const { message, error } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
-    resolveTypeArguments,
+    resolveTypeArgumentsUnchecked,
     defineAnnotations,
     initMembers,
     extensionsDict,
@@ -26,26 +27,32 @@ function finalizeParseCdl( model ) {
   return;
 
   function resolveTypesAndExtensionsForParseCdl() {
-    if (!model.extensions)
-      model.extensions = [];
+    const extensions = [];
 
     // TODO: probably better to loop over extensions of all sources (there is just one)
     for (const name in extensionsDict) {
       for (const ext of extensionsDict[name]) {
         ext.name.absolute = resolveUncheckedPath( ext.name, 'extend', ext );
         // Define annotations of this top-level extension
-        defineAnnotations( ext, ext, ext._block );
+        defineAnnotations( ext, ext, ext._block, 'extend' );
         mergeAnnotatesForSameArtifact( ext );
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );
-        model.extensions.push( ext );
+        extensions.push( ext );
+        for (const col of ext.columns || []) {
+          // Note, no `priority` argument, since we don't apply the extension in the end.
+          defineAnnotations( col, col, ext._block );
+        }
       }
     }
 
     forEachGeneric(model, 'definitions', art => resolveTypesForParseCdl(art, art));
     forEachGeneric(model, 'vocabularies', art => resolveTypesForParseCdl(art, art));
-    if (model.extensions)
+
+    if (extensions.length > 0) {
+      model.extensions = extensions;
       model.extensions.forEach(ext => resolveTypesForParseCdl(ext, ext));
+    }
   }
 
   /**
@@ -144,11 +151,13 @@ function finalizeParseCdl( model ) {
 
   /**
    * Resolves `artWithType.type` in an unchecked manner. Handles `type of` cases.
+   * `artWithType` has the `type` property, i.e. it could be an `items` object.
+   * `user` is the actual artifact, e.g. entity or element.
    *
    * @param {object} artWithType
-   * @param {XSN.Artifact} artifact
+   * @param {XSN.Artifact} user
    */
-  function resolveTypeUnchecked(artWithType, artifact) {
+  function resolveTypeUnchecked(artWithType, user) {
     if (!artWithType.type)
       return;
     const root = artWithType.type.path && artWithType.type.path[0];
@@ -159,19 +168,18 @@ function finalizeParseCdl( model ) {
     // without special treatment.
     if (artWithType.type.scope !== 'typeOf') {
       // elem: Type   or   elem: type of Artifact:elem
-      const name = resolveUncheckedPath(artWithType.type, 'type', artifact);
-      const def = name && model.definitions[name];
-      if (def)
-        resolveTypeArguments( artWithType, def, artifact );
+      const name = resolveUncheckedPath( artWithType.type, 'type', user );
+      const type = name && model.definitions[name] || { name: { absolute: name } };
+      resolveTypeArgumentsUnchecked( artWithType, type, user );
       return;
     }
-    else if (!artifact._main) {
-      error( 'ref-undefined-typeof', [ artWithType.type.location, artifact ], {},
+    else if (!user._main) {
+      error( 'ref-undefined-typeof', [ artWithType.type.location, user ], {},
              'Current artifact has no element to refer to as type' );
       return;
     }
     else if (root.id === '$self' || root.id === '$projection') {
-      setArtifactLink( root, artifact._main );
+      setArtifactLink( root, user._main );
     }
     else {
       // For better error messages, check for invalid TYPE OFs similarly
@@ -179,19 +187,18 @@ function finalizeParseCdl( model ) {
       let struct = artWithType;
       while (struct.kind === 'element')
         struct = struct._parent;
-      if (struct.kind === 'select' || struct !== artifact._main) {
-        message( 'type-unexpected-typeof', [ artWithType.type.location, artifact ],
+      if (struct.kind === 'select' || struct !== user._main) {
+        message( 'type-unexpected-typeof', [ artWithType.type.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         return;
       }
 
-      const fake = { name: { absolute: artifact.name.absolute } };
+      const fake = { name: { absolute: user.name.absolute } };
       // to-csn just needs a fake element whose absolute name and _parent/_main links are correct
-      setLink( fake, '_parent', artifact._parent );
-      setLink( fake, '_main', artifact._main ); // value does not matter...
+      setLink( fake, '_parent', user._parent );
+      setLink( fake, '_main', user._main ); // value does not matter...
       setArtifactLink( root, fake );
     }
-    resolveTypeArguments( artifact, {}, artifact ); // issue error for type args
   }
 
   function chooseAndReportDuplicateAnnotation(artifact, annoName) {
@@ -215,17 +222,27 @@ function finalizeParseCdl( model ) {
 
     forEachMember(ext, sub => mergeAnnotatesForSameArtifact(sub));
 
-    if (ext.$annotations && Array.isArray(ext.$duplicates)) {
-      const annotates = ext.$duplicates.filter(val => (val.kind === 'annotate'));
-      for (const dup of annotates) {
-        ext.$annotations.push(...dup.$annotations);
-        delete dup.$annotations;
+    // do not do a complex merge:
+    if (isComplexExtension( ext ) ||
+        !Array.isArray( ext.$duplicates ) || ext.$duplicates.some( isComplexExtension ))
+      return;
+    for (const dup of ext.$duplicates) {
+      for (const prop in dup) {
+        if (prop.charAt(0) === '@')
+          dictAddArray( ext, prop, dup[prop] );
       }
-      ext.$duplicates = ext.$duplicates.filter(val => (val.kind !== 'annotate'));
-      if (ext.$duplicates.length === 0)
-        delete ext.$duplicates;
     }
+    delete ext.$duplicates;
   }
 }
 
+/**
+ * We only de-duplicate an extend/annotate `ext` in function
+ * mergeAnnotatesForSameArtifact() if the extend/annotate is simple, i.e. has
+ * no members like elements.
+ */
+function isComplexExtension( ext ) {
+  return ext.kind !== 'annotate' || ext.elements || ext.parameters || ext.actions;
+}
+
 module.exports = finalizeParseCdl;