@sap/cds-compiler 4.1.2 → 4.2.2

package/lib/checks/selectItems.js

@@ -5,10 +5,12 @@ const { forEachGeneric, applyTransformationsOnNonDictionary } = require('../mode
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
- * Validate select items of a query. If a column reference starts with $self or $projection, it must not contain association steps.
+ * Validate select items of a query. If a column reference starts with $self or
+ * $projection, it must not contain association steps.
  * Furthermore, for to.hdbcds, window functions are not allowed.
  *
- * For to.hdbcds-hdbcds, structures and managed associations are not allowed as they are not flattened - @see rejectManagedAssociationsAndStructuresForHdbcdsNames
+ * For to.hdbcds-hdbcds, structures and managed associations are not allowed
+ * as they are not flattened - @see rejectManagedAssociationsAndStructuresForHdbcdsNames
  *
  * @param {CSN.Query} query query object
  * @todo Why do we care about this with $self?
@@ -17,58 +19,6 @@ function validateSelectItems( query ) {
   const { SELECT } = query;
   if (!SELECT)
     return;
-  /**
-   * Check for a $self.<assoc> in columns etc. - since the $self.<assoc> references the "outside" view
-   * of the association, this is not allowed.
-   *
-   * @param {string} queryPart Part of the query that is being checked
-   * @returns {Function} Function as callback for applyTransformations
-   */
-  function checkRefForInvalid$Self( queryPart ) {
-    const signalError = (error, parent, type) => {
-      if (queryPart === 'columns') {
-        error(null, parent.$path,
-              { name: parent.ref[0], type },
-              'Select items starting with $(NAME) must not contain path steps of type $(TYPE)');
-      }
-      else if (queryPart === 'orderBy') {
-        error(null, parent.$path,
-              { id: queryPart, type },
-              'Items of the $(ID)-clause must not contain path steps of type $(TYPE)');
-      }
-      else {
-        error(null, parent.$path,
-              { id: queryPart, name: parent.ref[0], type },
-              'Items of the $(ID)-clause starting with $(NAME) must not contain path steps of type $(TYPE)');
-      }
-    };
-    return function checkForInvalid$SelfInRef(parent) {
-      if (parent.ref && (parent.$scope === '$self' || parent.$scope === '$query')) {
-        const { _links } = parent;
-        for (let j = parent.$scope === '$self' ? 1 : 0; j < _links.length - 1; j++) {
-          if (_links[j].art.target) {
-            if (_links[j].art.on) {
-              // It's an unmanaged association - traversal is always forbidden
-              signalError(this.error, parent, _links[j].art.type);
-            }
-            else {
-              // It's a managed association - access of the foreign keys is allowed
-              const nextRef = parent.ref[j + 1].id || parent.ref[j + 1];
-              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef))
-                signalError(this.error, parent, _links[j].art.type);
-            }
-          }
-        }
-
-        const last = _links[_links.length - 1];
-
-        if (last.art.target && last.art.on) {
-          // It's an unmanaged association - traversal is always forbidden
-          signalError(this.error, parent, last.art.type);
-        } // managed is okay, can be handled via tuple expansion
-      }
-    };
-  }
 
   /**
    * Check the given assoc filter for usage of $self - in an assoc-filter, you must only
@@ -90,7 +40,6 @@ function validateSelectItems( query ) {
 
   const aTCB = (parent, prop) => {
     applyTransformationsOnNonDictionary(parent, prop, {
-      ref: checkRefForInvalid$Self(prop).bind(this),
       where: checkFilterForInvalid$Self.bind(this),
     }, { skipStandard: { on: true }, drillRef: true });
   };

package/lib/checks/utils.js

@@ -58,8 +58,9 @@ function otherSideIsExpandableStructure( on, startIndex ) {
  * @returns {object} final artifact type
  */
 function resolveArtifactType( art ) {
-  if (art && art.type && !isBuiltinType(art.type))
-    return this.csnUtils.getFinalTypeInfo(art.type);
+  const type = art?._type?.type || art?.type;
+  if (type && !isBuiltinType(type))
+    return this.csnUtils.getFinalTypeInfo(type);
 
   return art;
 }

package/lib/checks/validator.js

@@ -11,6 +11,7 @@ const enrich = require('./enricher');
 const { validateSelectItems } = require('./selectItems');
 const { rejectParamDefaultsInHanaCds, warnAboutDefaultOnAssociationForHanaCds } = require('./defaultValues');
 const validateCdsPersistenceAnnotation = require('./cdsPersistence');
+const navigationIntoMany = require('./manyNavigations');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
@@ -71,7 +72,7 @@ const forRelationalDBArtifactValidators
   checkSqlAnnotationOnArtifact,
 ];
 
-const forRelationalDBCsnValidators = [ nonexpandableStructuredInExpression ];
+const forRelationalDBCsnValidators = [ nonexpandableStructuredInExpression, navigationIntoMany ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */
@@ -233,6 +234,7 @@ function forRelationalDB( csn, that ) {
                    {
                      skipArtifact: artifact => artifact.abstract ||
                                                 hasAnnotationValue(artifact, '@cds.persistence.skip') ||
+                                                hasAnnotationValue(artifact, '@cds.persistence.exists') ||
                                                 [ 'action', 'function', 'event' ].includes(artifact.kind),
                    });
 }

package/lib/compiler/.eslintrc.json

@@ -2,6 +2,7 @@
   "root": true,
   "extends": "../../.eslintrc-ydkjsi.json",
   "rules": {
-    "cds-compiler/message-no-quotes": "warn"
+    "cds-compiler/message-no-quotes": "warn",
+    "cds-compiler/space-in-func-call": "warn"
   }
 }

package/lib/compiler/assert-consistency.js

@@ -80,7 +80,7 @@ const typeProperties = [
 
 class InternalConsistencyError extends Error {
   constructor(msg) {
-    super(`cds-compiler XSN consistency: ${ msg }`);
+    super( `cds-compiler XSN consistency: ${ msg }` );
   }
 }
 
@@ -270,7 +270,8 @@ function assertConsistency( model, stage ) {
         requires: [ 'op', 'location', 'from' ],
         optional: [
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
-          'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit', '_origin', '_block',
+          'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit', '$limit',
+          '_origin', '_block',
           '_projections', '_parent', '_main', '_effectiveType', '$effectiveSeqNo', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
         ],
@@ -284,7 +285,7 @@ function assertConsistency( model, stage ) {
         requires: [ 'op', 'location', 'args', 'join' ],
         optional: [
           'on', '$parens', 'cardinality',
-          'kind', 'name', '_block', '_parent', '_main',
+          'kind', 'name', '_block', '_parent', '_main', '_user',
           '$tableAliases', '_combined', '_joinParent', '$joinArgsIndex',
           '_leadingQuery', '_$next', '_deps',
         ],
@@ -335,6 +336,7 @@ function assertConsistency( model, stage ) {
     nulls: { test: locationVal( isString ), enum: [ 'first', 'last' ] },
     $orderBy: { inherits: 'orderBy' },
     groupBy: { inherits: 'value', test: isArray( expression ) },
+    $limit: { test: TODO },
     limit: { requires: [ 'rows' ], optional: [ 'offset', 'location' ] },
     rows: { inherits: 'value' },
     offset: { inherits: 'value' },
@@ -507,7 +509,7 @@ function assertConsistency( model, stage ) {
       ],
       // TODO: name requires if not in parser?
     },
-    $priority: { test: isOneOf([ undefined, false, 'extend', 'annotate' ]) },
+    $priority: { test: isOneOf( [ undefined, false, 'extend', 'annotate' ] ) },
     $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
     name: {
       isRequired: stageParser && (() => false), // not required in parser
@@ -605,7 +607,8 @@ function assertConsistency( model, stage ) {
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
-        'limit', '_status', '_origin', '_effectiveType', '$effectiveSeqNo',
+        '$limit', 'limit', '_status', '_origin',
+        '_effectiveType', '$effectiveSeqNo',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -647,7 +650,7 @@ function assertConsistency( model, stage ) {
     $inferred: {
       parser: true,
       kind: true,
-      test: isOneOf([
+      test: isOneOf( [
         '', // constructed “super annotate” statement, redirected user-provided target
         // Uppercase values are used in logic, lowercase value are "just for us", i.e.
         // debugging or to add properties such as $generated in Universal CSN.
@@ -679,7 +682,7 @@ function assertConsistency( model, stage ) {
         'rewrite', // on-conditions or FKeys are rewritten
         'parent-origin', // annotation/property copied from parent that does not come through
         //                  $origin and is not a direct annotation
-      ]),
+      ] ),
     },
 
     // Helper property for the XSN-to-CSN transformation, see function setExpandStatus():
@@ -688,7 +691,7 @@ function assertConsistency( model, stage ) {
     $expand: {
       kind: true,
       // See description of `setExpandStatus()` of in `lib/compiler/utils.js`.
-      test: isOneOf([ 'origin', 'annotate', 'target' ]),
+      test: isOneOf( [ 'origin', 'annotate', 'target' ] ),
     },
     $inCycle: { kind: true, test: isBoolean },
 
@@ -696,7 +699,7 @@ function assertConsistency( model, stage ) {
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
     $withLocalized: { test: isBoolean },
     $sources: { parser: true, test: isArray( isString ) },
-    $expected: { parser: true, test: isOneOf([ 'approved-exists', 'exists' ]) },
+    $expected: { parser: true, test: isOneOf( [ 'approved-exists', 'exists' ] ) },
     $messageFunctions: { test: TODO },
     $functions: { test: TODO },
     $assert: { test: TODO },    // currently just for missing Error[ref-cycle]
@@ -784,7 +787,7 @@ function assertConsistency( model, stage ) {
     const requires = spec.requires || [];
     // Do not test 'requires' with parse errors:
     for (const p of requires) {
-      if (!names.includes(p)) {
+      if (!names.includes( p )) {
         const req = spec.schema && spec.schema[p] && spec.schema[p].isRequired;
         if ((req || schema[p] && schema[p].isRequired || noSyntaxErrors)( node ))
           throw new InternalConsistencyError( `Required property '${ p }' missing in object${ at( [ node, parent ], prop, name ) }` );
@@ -792,7 +795,7 @@ function assertConsistency( model, stage ) {
     }
     const optional = spec.optional || [];
     for (const n of names) {
-      const opt = Array.isArray(optional)
+      const opt = Array.isArray( optional )
         ? optional.includes( n ) || optional.includes( n.charAt(0) )
         : optional( n, spec );
       if (node[n] !== undefined) {
@@ -855,7 +858,7 @@ function assertConsistency( model, stage ) {
     // TODO CSN parser?: { val: <token>, literal: 'token' } for keywords
     if (typeof node === 'string')
       return;
-    while (Array.isArray(node)) {
+    while (Array.isArray( node )) {
       // TODO: also check getOwnPropertyNames(node)
       if (node.length !== 1) {
         node.forEach( n => expression( n, parent, prop, spec ) );
@@ -867,7 +870,7 @@ function assertConsistency( model, stage ) {
       return;
     isObject( node, parent, prop, spec, idx );
 
-    const s = spec[expressionSpec(node)] || {};
+    const s = spec[expressionSpec( node )] || {};
     const sub = Object.assign( {}, s.inherits && schema[s.inherits], s );
     if (spec.requires && sub.requires)
       sub.requires = [ ...sub.requires, ...spec.requires ];
@@ -890,9 +893,9 @@ function assertConsistency( model, stage ) {
   }
 
   function args( node, parent, prop, spec ) {
-    if (Array.isArray(node)) {
+    if (Array.isArray( node )) {
       if (parent.op && parent.op.val === 'xpr') // remove keywords for `xpr` expressions
-        node = node.filter( a => typeof a !== 'string');
+        node = node.filter( a => typeof a !== 'string' );
       node.forEach( (item, idx) => expression( item, parent, prop, spec, idx ) );
     }
     else if (node && typeof node === 'object' && !Object.getPrototypeOf( node )) {
@@ -927,7 +930,7 @@ function assertConsistency( model, stage ) {
 
   function isArray( func = standard ) {
     return function vector( node, parent, prop, spec ) {
-      if (!Array.isArray(node))
+      if (!Array.isArray( node ))
         throw new InternalConsistencyError( `Expected array${ at( [ null, parent ], prop ) }` );
       node.forEach( (item, n) => func( item, parent, prop, spec, n ) );
     };
@@ -960,8 +963,8 @@ function assertConsistency( model, stage ) {
 
   function isOneOf( values ) {
     return function isOneOfInner( node, parent, prop ) {
-      if (!values.includes(node))
-        throw new InternalConsistencyError( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
+      if (!values.includes( node ))
+        throw new InternalConsistencyError( `Unexpected value '${ node }', expected ${ JSON.stringify( values ) }${ at( [ node, parent ], prop ) }` );
     };
   }
 
@@ -974,7 +977,7 @@ function assertConsistency( model, stage ) {
   }
 
   function isVal( node, parent, prop, spec ) {
-    if (Array.isArray(node))
+    if (Array.isArray( node ))
       node.forEach( (item, n) => standard( item, parent, prop, spec, n ) );
     else if (node !== null && ![ 'string', 'number', 'boolean' ].includes( typeof node ))
       throw new InternalConsistencyError( `Expected array or simple value${ at( [ null, parent ], prop ) }` );
@@ -995,7 +998,7 @@ function assertConsistency( model, stage ) {
 
 
   function inDefinitions( art, parent, prop, spec, name ) {
-    if (Array.isArray(art))   // do not check with redefinitions
+    if (Array.isArray( art ))   // do not check with redefinitions
       return;
     isObject( art, parent, prop, spec, name );
     if (stageParser) {
@@ -1007,7 +1010,7 @@ function assertConsistency( model, stage ) {
              !(model.vocabularies && model.vocabularies[art.name.absolute])) {
       // TODO: sign ignored artifacts with $inferred = 'IGNORED'
       if (parent.kind === 'source' ||
-          art.name.absolute && art.name.absolute.startsWith('localized.'))
+          art.name.absolute && art.name.absolute.startsWith( 'localized.' ))
         standard( art, parent, prop, spec, name );
       else
         throw new InternalConsistencyError( `Expected definition${ at( [ art, parent ], prop, name ) }` );
@@ -1016,11 +1019,11 @@ function assertConsistency( model, stage ) {
 
   function isScope( node, parent, prop ) {
     // artifact refs in CDL have scope:0 in XSN
-    if (Number.isInteger(node))
+    if (Number.isInteger( node ))
       return;
     const validValues = [ 'typeOf', 'global', 'param' ];
-    if (!validValues.includes(node))
-      throw new InternalConsistencyError( `Property '${ prop }' must be either "${ validValues.join('", "') }" or a number but was "${ node }"` );
+    if (!validValues.includes( node ))
+      throw new InternalConsistencyError( `Property '${ prop }' must be either "${ validValues.join( '", "' ) }" or a number but was "${ node }"` );
   }
 
   function TODO() { /* no-op */ }

package/lib/compiler/base.js

@@ -29,7 +29,11 @@ const kindProperties = {
   $inline: { normalized: 'element' }, // column with inline property
   event: { elements: true, include: true },
   type: { elements: propExists, enum: propExists, include: true },
-  aspect: { elements: propExists, actions: true, include: true },
+  aspect: {
+    elements: propExists,
+    actions: ( _p, parent ) => propExists( 'elements', parent ),
+    include: true,
+  },
   annotation: { elements: propExists, enum: propExists },
   enum: { normalized: 'element', dict: 'enum' },
   element: { elements: propExists, enum: propExists, dict: 'elements' },
@@ -110,7 +114,7 @@ function getMemberNameProp( elem, kind ) {
     obj = obj.items;
   if (obj.elements || obj.enum)
     return 'element';
-  throw new CompilerAssertion( `Member not found in parent properties ${ Object.keys( obj ).join('+') }` );
+  throw new CompilerAssertion( `Member not found in parent properties ${ Object.keys( obj ).join( '+' ) }` );
 }
 
 module.exports = {

package/lib/compiler/builtins.js

@@ -235,7 +235,7 @@ const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i;
 const quotedLiteralPatterns = {
   x: {
     test_variant: 'uneven-hex',
-    test_fn: (str => Number.isInteger(str.length / 2)),
+    test_fn: (str => Number.isInteger( str.length / 2 )),
     unexpected_variant: 'invalid-hex',
     unexpected_char: /[^0-9a-f]/i,
     json_type: 'string',
@@ -293,12 +293,12 @@ const quotedLiteralPatterns = {
  */
 function checkDate( year, month, day ) {
   // Negative years are allowed
-  year = Math.abs(Number.parseInt(year, 10));
-  month = Number.parseInt(month, 10);
-  day = Number.parseInt(day, 10);
+  year = Math.abs( Number.parseInt( year, 10 ) );
+  month = Number.parseInt( month, 10 );
+  day = Number.parseInt( day, 10 );
   // If any is NaN, the condition will be false.
   // Year 0 does not exist, but ISO 8601 allows it and defines it as 1 BC.
-  return !Number.isNaN(year) && month > 0 && month < 13 && day > 0 && day < 32;
+  return !Number.isNaN( year ) && month > 0 && month < 13 && day > 0 && day < 32;
 }
 
 /**
@@ -308,9 +308,9 @@ function checkDate( year, month, day ) {
  * @returns {boolean} True if the date is valid.
  */
 function checkTime( hour, minutes, seconds ) {
-  hour = Number.parseInt(hour, 10);
-  minutes = Number.parseInt(minutes, 10);
-  seconds = seconds ? Number.parseInt(seconds, 10) : 0;
+  hour = Number.parseInt( hour, 10 );
+  minutes = Number.parseInt( minutes, 10 );
+  seconds = seconds ? Number.parseInt( seconds, 10 ) : 0;
   if (hour === 24) // allow 24:00:00 (ISO 8601 version earlier than 2019)
     return minutes === 0 && seconds === 0;
   // If any is NaN, the condition will be false.
@@ -332,47 +332,47 @@ const typeCategories = {
   geo: [],
 };
 // Fill type categories with `cds.*` types
-Object.keys(core).forEach((type) => {
+Object.keys( core ).forEach( (type) => {
   if (core[type].category)
-    typeCategories[core[type].category].push(`cds.${ type }`);
-});
+    typeCategories[core[type].category].push( `cds.${ type }` );
+} );
 // Fill type categories with `cds.hana.*` types
-Object.keys(coreHana).forEach((type) => {
+Object.keys( coreHana ).forEach( (type) => {
   if (coreHana[type].category)
-    typeCategories[coreHana[type].category].push(`cds.hana.${ type }`);
-});
+    typeCategories[coreHana[type].category].push( `cds.hana.${ type }` );
+} );
 
 /** @param {string} typeName */
 function isIntegerTypeName( typeName ) {
-  return typeCategories.integer.includes(typeName);
+  return typeCategories.integer.includes( typeName );
 }
 /** @param {string} typeName */
 function isDecimalTypeName( typeName ) {
-  return typeCategories.decimal.includes(typeName);
+  return typeCategories.decimal.includes( typeName );
 }
 /** @param {string} typeName */
 function isNumericTypeName( typeName ) {
-  return isIntegerTypeName(typeName) || isDecimalTypeName(typeName);
+  return isIntegerTypeName( typeName ) || isDecimalTypeName( typeName );
 }
 /** @param {string} typeName */
 function isStringTypeName( typeName ) {
-  return typeCategories.string.includes(typeName);
+  return typeCategories.string.includes( typeName );
 }
 /** @param {string} typeName */
 function isDateOrTimeTypeName( typeName ) {
-  return typeCategories.dateTime.includes(typeName);
+  return typeCategories.dateTime.includes( typeName );
 }
 /** @param {string} typeName */
 function isBooleanTypeName( typeName ) {
-  return typeCategories.boolean.includes(typeName);
+  return typeCategories.boolean.includes( typeName );
 }
 /** @param {string} typeName */
 function isBinaryTypeName( typeName ) {
-  return typeCategories.binary.includes(typeName);
+  return typeCategories.binary.includes( typeName );
 }
 /** @param {string} typeName */
 function isGeoTypeName( typeName ) {
-  return typeCategories.geo.includes(typeName);
+  return typeCategories.geo.includes( typeName );
 }
 /**
  * Whether the given type name is a relation, i.e. an association or composition.
@@ -380,7 +380,7 @@ function isGeoTypeName( typeName ) {
  * @param {string} typeName
  */
 function isRelationTypeName( typeName ) {
-  return typeCategories.relation.includes(typeName);
+  return typeCategories.relation.includes( typeName );
 }
 
 /**
@@ -390,10 +390,10 @@ function isRelationTypeName( typeName ) {
  * @returns {boolean}
  */
 function isInReservedNamespace( absolute ) {
-  return absolute === 'cds' || absolute.startsWith( 'cds.') &&
-    !absolute.match(/^cds\.foundation(\.|$)/) &&
-    !absolute.match(/^cds\.outbox(\.|$)/) && // Requested by Node runtime
-    !absolute.match(/^cds\.xt(\.|$)/); // Requested by Mtx
+  return absolute === 'cds' || absolute.startsWith( 'cds.' ) &&
+    !absolute.match( /^cds\.foundation(\.|$)/ ) &&
+    !absolute.match( /^cds\.outbox(\.|$)/ ) && // Requested by Node runtime
+    !absolute.match( /^cds\.xt(\.|$)/ ); // Requested by Mtx
 }
 
 /**
@@ -408,7 +408,7 @@ function isInReservedNamespace( absolute ) {
  * @returns {boolean}
  */
 function isBuiltinType( type ) {
-  return typeof type === 'string' && isInReservedNamespace(type);
+  return typeof type === 'string' && isInReservedNamespace( type );
 }
 
 /**
@@ -446,7 +446,7 @@ function initBuiltins( model ) {
       builtin,
       location: builtinLocation(),
     };
-    setProp( art, '_subArtifacts', Object.create(null) );
+    setProp( art, '_subArtifacts', Object.create( null ) );
     return art;
   }
 
@@ -460,7 +460,7 @@ function initBuiltins( model ) {
    * @returns {object} Artifacts dictionary with the builtin artifacts without prefixes.
    */
   function env( builtins, prefix, parent ) {
-    const artifacts = Object.create(null);
+    const artifacts = Object.create( null );
     for (const name of Object.keys( builtins )) {
       const absolute = prefix + name;
       // TODO: reconsider whether to set a type to itself - looks wrong
@@ -481,7 +481,7 @@ function initBuiltins( model ) {
   }
 
   function setMagicVariables( builtins ) {
-    const artifacts = Object.create(null);
+    const artifacts = Object.create( null );
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
@@ -510,9 +510,9 @@ function initBuiltins( model ) {
     if (!elements)
       return;
 
-    const names = Object.keys(elements);
+    const names = Object.keys( elements );
     if (names.length > 0 && !art.elements)
-      art.elements = Object.create(null);
+      art.elements = Object.create( null );
 
     for (const n of names) {
       const magic = {
@@ -525,7 +525,7 @@ function initBuiltins( model ) {
       setProp( magic, '_parent', art );
       // setProp( magic, '_effectiveType', magic );
       if (elements[n] && typeof elements[n] === 'object')
-        createMagicElements(magic, elements[n]);
+        createMagicElements( magic, elements[n] );
 
       art.elements[n] = magic;
     }