@sap/cds-compiler 2.13.8 → 2.15.6

package/lib/checks/annotationsOData.js

@@ -13,42 +13,22 @@
  * @param {CSN.Element} member Member to be checked
  */
 function checkCoreMediaTypeAllowence(member) {
-  const allowedCoreMediaTypes = [
-    'cds.String',
-    'cds.LargeString',
-    'cds.hana.VARCHAR',
-    'cds.hana.CHAR',
-    'cds.Binary',
-    'cds.LargeBinary',
-    'cds.hana.CLOB',
-    'cds.hana.BINARY',
-  ];
-  if (member['@Core.MediaType'] && member.type && !allowedCoreMediaTypes.includes(member.type)) {
+  const allowedCoreMediaTypes = {
+    'cds.String': 1,
+    'cds.LargeString': 1,
+    'cds.hana.VARCHAR': 1,
+    'cds.hana.CHAR': 1,
+    'cds.Binary': 1,
+    'cds.LargeBinary': 1,
+    'cds.hana.CLOB': 1,
+    'cds.hana.BINARY': 1,
+  };
+  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseType(member.type) in allowedCoreMediaTypes)) {
     this.warning(null, member.$path, { names: [ 'Edm.String', 'Edm.Binary' ] },
                  'Element annotated with “@Core.MediaType” should be of a type mapped to $(NAMES)');
   }
 }
 
-/**
- * Make sure only one element in a definition is annotated with `@Core.MediaType`
- * This is only OData V2 relevant.
- *
- * @param {CSN.Artifact} artifact Definition to be checked
- * @param {string} artifactName The name of the artifact
- */
-function checkForMultipleCoreMediaTypes(artifact, artifactName) {
-  if (!this.csnUtils.getServiceName(artifactName))
-    return;
-  if (this.options.toOdata && this.options.toOdata.version === 'v2' && artifact.elements) {
-    const mediaTypeElementsNames = Object.keys(artifact.elements)
-      .filter(elementName => artifact.elements[elementName]['@Core.MediaType']);
-    if (mediaTypeElementsNames.length > 1) {
-      this.error(null, artifact.$path, { names: mediaTypeElementsNames },
-                 `Multiple elements $(NAMES) annotated with “@Core.MediaType”, OData V2 allows only one`);
-    }
-  }
-}
-
 /**
  * Check if `@Aggregation.default` is assigned together with `@Analytics.Measure`
  *
@@ -88,7 +68,6 @@ function checkReadOnlyAndInsertOnly(artifact, artifactName) {
 
 module.exports = {
   checkCoreMediaTypeAllowence,
-  checkForMultipleCoreMediaTypes,
   checkAnalytics,
   checkAtSapAnnotations,
   checkReadOnlyAndInsertOnly,

package/lib/checks/arrayOfs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const { forEachMemberRecursively } = require('../model/csnUtils');
-
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
 /**
@@ -43,35 +41,4 @@ function validateAssociationsInItems(member) {
   }
 }
 
-/**
- * Check that there are no .items containing .items.
- *
- * @param {CSN.Artifact} art Artifact
- * @param {string} artName Name of the artifact
- */
-function checkChainedArray(art, artName) {
-  if (!this.csnUtils.getServiceName(artName))
-    return;
-  checkIfItemsOfItems.bind(this)(art);
-  forEachMemberRecursively(art, checkIfItemsOfItems.bind(this));
-
-  /**
-   *
-   * @param {object} construct the construct to be checked
-   */
-  function checkIfItemsOfItems(construct) {
-    const constructType = this.csnUtils.effectiveType(construct);
-    if (constructType.items) {
-      if (constructType.items.items) {
-        this.error('chained-array-of', construct.$path, '"Array of"/"many" must not be chained with another "array of"/"many" inside a service');
-        return;
-      }
-
-      const itemsType = this.csnUtils.effectiveType(constructType.items);
-      if (itemsType.items)
-        this.error('chained-array-of', construct.$path, '"Array of"/"many" must not be chained with another "array of"/"many" inside a service');
-    }
-  }
-}
-
-module.exports = { validateAssociationsInItems, checkChainedArray };
+module.exports = { validateAssociationsInItems };

package/lib/checks/validator.js

@@ -14,11 +14,10 @@ const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const checkForEmptyOrOnlyVirtual = require('./emptyOrOnlyVirtual');
 // forOdata
 const { validateDefaultValues } = require('./defaultValues');
-// const { checkChainedArray } = require('./arrayOfs');
 const { checkActionOrFunction } = require('./actionsFunctions');
 const {
-  checkCoreMediaTypeAllowence, checkForMultipleCoreMediaTypes,
-  checkAnalytics, checkAtSapAnnotations, checkReadOnlyAndInsertOnly,
+  checkCoreMediaTypeAllowence, checkAnalytics,
+  checkAtSapAnnotations, checkReadOnlyAndInsertOnly,
 } = require('./annotationsOData');
 // both
 const { validateOnCondition, validateMixinOnCondition } = require('./onConditions');
@@ -92,7 +91,6 @@ const forOdataArtifactValidators
   //       the renderer does not work because the enricher can't handle certain
   //       OData specifics.
   // checkChainedArray,
-  checkForMultipleCoreMediaTypes,
   checkReadOnlyAndInsertOnly,
 ];
 

package/lib/compiler/assert-consistency.js

@@ -72,6 +72,7 @@ const { locationString, hasErrors } = require('../base/messages');
 // Properties that can appear where a type can have type arguments.
 const typeProperties = [
   'type', '$typeArgs', 'length', 'precision', 'scale', 'srid',
+  '_effectiveType',
 ];
 
 function assertConsistency( model, stage ) {

package/lib/compiler/base.js

@@ -45,6 +45,7 @@ const kindProperties = {
     noDep: 'special',
     elements: true, /* only for parse-cdl */
     actions: true,  /* only for parse-cdl */
+    enum: true,     /* only for parse-cdl */
   },
   annotate: {
     isExtension: true, noDep: 'special', elements: true, enum: true, actions: true, params: true,

package/lib/compiler/builtins.js

@@ -46,6 +46,16 @@ const coreHana = {
   ST_GEOMETRY: { parameters: [ { name: 'srid', literal: 'number', val: 0 } ], category: 'geo' },
 };
 
+const typeParameters = {
+  expectedLiteralsFor: {
+    length: [ 'number' ],
+    scale: [ 'number', 'string' ],
+    precision: [ 'number' ],
+    srid: [ 'number' ],
+  },
+};
+typeParameters.list = Object.keys( typeParameters.expectedLiteralsFor );
+
 // const hana = {
 //   BinaryFloat: {},
 //   LocalDate: {},
@@ -312,6 +322,7 @@ function initBuiltins( model ) {
 }
 
 module.exports = {
+  typeParameters,
   functionsWithoutParens,
   specialFunctions,
   initBuiltins,

package/lib/compiler/checks.js

@@ -24,6 +24,7 @@ function check( model ) {       // = XSN
     error, warning, message,
   } = model.$messageFunctions;
   forEachDefinition( model, checkArtifact );
+  checkSapCommonLocale( model, model.$messageFunctions );
   return;
 
   function checkArtifact( art ) {
@@ -447,80 +448,10 @@ function check( model ) {       // = XSN
         // params are limited to actual values and params
         if (pathStep.args)
           checkExpression(pathStep.args);
-
-        if (!path[0] || !path[0]._navigation) { // TODO: Discuss (see #4108)
-          checkPathForMissingArguments(pathStep);
-        }
       }
     });
   }
 
-  /**
-   * Check whether the argument count of the given path expression matches its artifact.
-   * If there is a mismatch, an error is issued.
-   *
-   * TODO: remove this function - it also checks for parameter in type
-   * references.  We could have a warning, see also configurable errors
-   * 'args-no-params', 'args-undefined-param'.
-   *
-   * @param {object} pathStep The expression to check
-   */
-  function checkPathForMissingArguments(pathStep) {
-    // _artifact may not be set, e.g. for functions like `convert_currency( amount => 3 )`
-    // _navigation must not be set or we would (for example) check each field of an entity
-    if (!pathStep._artifact || pathStep._navigation)
-      return;
-
-    const isAssociation = !!pathStep._artifact.target;
-    if (isAssociation) {
-      const targetFinalType = pathStep._artifact.target._artifact &&
-            pathStep._artifact.target._artifact._effectiveType;
-      const finalTypeParams = targetFinalType ? targetFinalType.params : null;
-      compareActualNamedArgsWithFormalNamedArgs(pathStep.args, finalTypeParams);
-    }
-    else {
-      // Parameters can only be provided when navigating along associations, so because this path
-      // is for non-associations, checking arguments along a navigation is unnecessary and faulty.
-      compareActualNamedArgsWithFormalNamedArgs(pathStep.args, pathStep._artifact.params);
-    }
-
-    /**
-     * Compare two argument dictionaries for correct argument count.
-     * @param {object}   actualArgs
-     * @param {object}   formalArgs
-     */
-    function compareActualNamedArgsWithFormalNamedArgs(actualArgs, formalArgs) {
-      actualArgs = actualArgs || {};
-      formalArgs = formalArgs || {};
-
-      const aArgsCount = Object.keys(actualArgs).length;
-      const expectedNames = Object.keys(formalArgs);
-
-      const missingArgs = [];
-      for (const fAName in formalArgs) {
-        if (!actualArgs[fAName]) {
-          // Note: _effectiveType points to cds.String for `type T : DefaultString`.
-          //       And `default` may appear at any `type` in the hierarchy.
-          let fArg = formalArgs[fAName];
-          while (fArg.type && !fArg.default)
-            fArg = fArg.type._artifact;
-          if (!fArg.default)
-            missingArgs.push(fAName);
-        }
-      }
-
-      if (missingArgs.length) {
-        error(null, [ pathStep.location, pathStep ],
-              { names: missingArgs, expected: expectedNames.length, given: aArgsCount },
-              'Expected $(EXPECTED) arguments but $(GIVEN) given; missing: $(NAMES)');
-      }
-      // Note:
-      // Unknown arguments are already handled by messages
-      // args-expected-named and args-undefined-param
-    }
-  }
-
-
   function checkAssociation(elem) {
     // TODO: yes, a check similar to this could make it into the compiler)
     // when virtual element is part of association
@@ -956,6 +887,27 @@ function check( model ) {       // = XSN
   }
 }
 
+/**
+ * Checks that sap.common.Locale is of type cds.String.  This limitation may
+ * be lifted later on.
+ *
+ * @param {XSN.Model} model
+ * @param {object} messageFunctions
+ */
+function checkSapCommonLocale( model, messageFunctions ) {
+  const localeArt = model.definitions['sap.common.Locale'];
+  if (localeArt) {
+    const type = localeArt._effectiveType;
+    const isCdsString = type && type.name && type.name.absolute === 'cds.String';
+    if (!isCdsString) {
+      const { message } = messageFunctions;
+      message('type-expected-builtin', [ localeArt.name.location, localeArt ],
+              { name: 'sap.common.Locale' },
+              'Expected $(NAME) to be a string type');
+    }
+  }
+}
+
 // For each property named 'path' in 'node' (recursively), call callback(path, node)
 //
 // TODO: remove - this is not a good way to traverse expressions

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
@@ -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

@@ -158,6 +158,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 +246,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 +263,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) {
@@ -602,13 +607,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 };
@@ -809,6 +819,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 );

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

@@ -16,7 +16,7 @@ function finalizeParseCdl( model ) {
   const { message, error } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
-    resolveTypeArguments,
+    resolveTypeArgumentsUnchecked,
     defineAnnotations,
     initMembers,
     extensionsDict,
@@ -26,8 +26,7 @@ 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) {
@@ -38,14 +37,21 @@ function finalizeParseCdl( model ) {
         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 +150,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 +167,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 +186,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) {