@sap/cds-compiler 2.11.4 → 2.12.0

package/lib/checks/actionsFunctions.js

@@ -110,7 +110,8 @@ function checkActionOrFunction(art, artName, prop, path) {
    * @param {CSN.Path} currPath The current path
    */
   function checkUserDefinedType(type, typeName, currPath) {
-    if (!isBuiltinType(type) && type.kind && type.kind !== 'type') {
+    // TODO: isBuiltinType does not resolve any type-chains.
+    if (!isBuiltinType(type.type) && type.kind && type.kind !== 'type') {
       const serviceOfType = this.csnUtils.getServiceName(typeName);
       if (serviceName && serviceName !== serviceOfType) {
         // if (!(isMultiSchema && serviceOfType)) {

package/lib/checks/foreignKeys.js

@@ -18,12 +18,12 @@ function validateForeignKeys(member) {
 
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem) => {
-    for (let i = 0; i < mem.keys.length; i++) {
-      if (mem.keys[i].ref) {
-        if (!mem.keys[i]._art)
+    for (const key of mem.keys) {
+      if (key.ref) {
+        if (!key._art)
           continue;
         // eslint-disable-next-line no-use-before-define
-        checkForItems(mem.keys[i]._art);
+        checkForItems(key._art);
       }
     }
   };

package/lib/checks/managedInType.js

@@ -13,11 +13,11 @@
 function checkUsedTypesForAnonymousAspectComposition(member) {
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem, fn) => {
-    for (let i = 0; i < mem.keys.length; i++) {
-      if (mem.keys[i].ref) {
-        if (!mem.keys[i]._art)
+    for (const key of mem.keys) {
+      if (key.ref) {
+        if (!key._art)
           continue;
-        fn(mem.keys[i]._art);
+        fn(key._art);
       }
     }
   };

package/lib/checks/queryNoDbArtifacts.js

@@ -124,10 +124,8 @@ function checkQueryForNoDBArtifacts(query) {
     for (const prop of generalQueryProperties) {
       const queryPart = (query.SELECT || query.SET)[prop];
       if (Array.isArray(queryPart)) {
-        for (let i = 0; i < queryPart.length; i++) {
-          const part = queryPart[i];
+        for (const part of queryPart)
           checkRef(part, prop === 'columns');
-        }
       }
       else if (typeof queryPart === 'object') {
         checkRef(queryPart, prop === 'columns');

package/lib/checks/sql-snippets.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { isBetaEnabled } = require('../base/model');
+
+// Only to be used with validator.js - a correct this value needs to be provided!
+
+/**
+ * Check that @sql.prepend annotation is not used on any elements and @sql.append is not used on elements in views.
+ *
+ * @param {CSN.Element} member
+ * @param {string} memberName
+ * @param {string} prop
+ * @param {CSN.Path} path
+ * @returns {void}
+ */
+function checkSqlAnnotationOnElement(member, memberName, prop, path) {
+  if (isBetaEnabled(this.options, 'sqlSnippets')) {
+    if (member['@sql.replace'])
+      this.error(null, path, { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+    if (member['@sql.prepend'])
+      this.error('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, `Annotation $(ANNO) can't be used on elements` );
+
+    if (member['@sql.append']) {
+      if (this.artifact.query)
+        this.error('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on elements in views` );
+      else if (this.csnUtils.isStructured(member))
+        this.error('anno-invalid-sql-struct', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on structured elements` );
+      else
+        checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
+    }
+  }
+}
+
+/**
+ * @param {object} carrier element which has the annotation
+ * @param {string} annotation
+ * @param {CSN.Path} path
+ * @param {Function} error
+ * @param {CSN.Options} options
+ */
+function checkValidAnnoValue(carrier, annotation, path, error, options) {
+  if (carrier[annotation] !== undefined && carrier[annotation] !== null) {
+    if (typeof carrier[annotation] !== 'string')
+      error(null, path, { anno: annotation.slice(1), type: typeof carrier[annotation] }, `Annotation $(ANNO) must be a string, found $(TYPE)` );
+    else if (options.transformation === 'sql') // HDI and HDBCDS do their own checks
+      guardAgainstInjection(annotation, carrier[annotation], path, error);
+  }
+}
+
+/**
+ * Check that @sql.prepend is not used on views - only supported for entities (tables)
+ *
+ * @param {CSN.Artifact} artifact
+ * @param {string} artifactName
+ */
+function checkSqlAnnotationOnArtifact(artifact, artifactName) {
+  if (isBetaEnabled(this.options, 'sqlSnippets')) {
+    if (artifact['@sql.prepend']) {
+      if (artifact.query)
+        this.error('anno-invalid-sql-view', [ 'definitions', artifactName ], { name: '@sql.prepend' }, `Annotation $(NAME) can't be used on views` );
+      else
+        checkValidAnnoValue(artifact, '@sql.prepend', [ 'definitions', artifactName ], this.error, this.options);
+    }
+
+    if (artifact['@sql.replace'])
+      this.error(null, [ 'definitions', artifactName ], { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+
+    checkValidAnnoValue(artifact, '@sql.append', [ 'definitions', artifactName ], this.error, this.options);
+  }
+}
+
+// Anything that could terminate the "old" statement and start a new one basically.
+const invalidInSnippet = [ ';', '--', '/*', '*/' ];
+
+/**
+ * Check that the common characters used to terminate the current statement and start a fresh one are not used.
+ *
+ * @param {string} annoName
+ * @param {string} annoValue
+ * @param {CSN.Path} path
+ * @param {Function} error
+ */
+function guardAgainstInjection(annoName, annoValue, path, error) {
+  for (const invalid of invalidInSnippet) {
+    if (annoValue.indexOf(invalid) !== -1) // These should probably not be configurable, right?
+      error(null, path, { name: annoName, prop: invalid }, 'Annotation $(NAME) must not contain $(PROP)');
+  }
+}
+
+module.exports = {
+  checkSqlAnnotationOnArtifact,
+  checkSqlAnnotationOnElement,
+};

package/lib/checks/validator.js

@@ -35,6 +35,10 @@ const checkExplicitlyNullableKeys = require('./nullableKeys');
 const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
 const unknownMagic = require('./unknownMagic');
 const managedWithoutKeys = require('./managedWithoutKeys');
+const {
+  checkSqlAnnotationOnArtifact,
+  checkSqlAnnotationOnElement,
+} = require('./sql-snippets');
 
 const forHanaMemberValidators
 = [
@@ -45,6 +49,8 @@ const forHanaMemberValidators
   checkExplicitlyNullableKeys,
   managedWithoutKeys,
   warnAboutDefaultOnAssociationForHanaCds,
+  // sql.prepend/append
+  checkSqlAnnotationOnElement,
 ];
 
 const forHanaArtifactValidators
@@ -53,6 +59,8 @@ const forHanaArtifactValidators
   validateCdsPersistenceAnnotation,
   // virtual items are not persisted on the db
   checkForEmptyOrOnlyVirtual,
+  // sql.prepend/append
+  checkSqlAnnotationOnArtifact,
 ];
 
 const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];

package/lib/compiler/assert-consistency.js

@@ -424,9 +424,12 @@ function assertConsistency( model, stage ) {
     val: {
       test: isVal,              // the following for array/struct value
       requires: [ 'location' ],
-      optional: [ 'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicate' ],
+      optional: [
+        'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicate', 'upTo',
+      ],
       // TODO: restrict path to #simplePath
     },
+    upTo: { test: TODO },
     struct: { inherits: 'val', test: isDictionary( definition ) }, // def because double @
     args: {
       inherits: 'value',
@@ -792,8 +795,7 @@ function assertConsistency( model, stage ) {
   }
 
   function at( nodes, prop, name ) {
-    // eslint-disable-next-line no-nested-ternary
-    const n = name ? (typeof name === 'number' ? ` for index ${ name }` : ` for "${ name }"`) : '';
+    const n = name && (typeof name === 'number' ? ` for index ${ name }` : ` for "${ name }"`) || '';
     const loc = nodes.find( o => o && typeof o === 'object' && (o.location || o.start) );
     const f = (prop) ? `${ n } in property '${ prop }'` : n;
     const l = locationString( loc && loc.location || loc || model.location );

package/lib/compiler/base.js

@@ -1,6 +1,5 @@
 // Base Definitions for the Core Compiler
 
-
 'use strict';
 
 const dictKinds = {

package/lib/compiler/checks.js

@@ -87,6 +87,17 @@ function check( model ) {       // = XSN
                 'Keyword “localized” may only be used in combination with string types');
       }
     }
+    // "key" keyword at localized element in SELECT list.
+    // TODO: This check should be moved to localized.js
+    if (elem.key && elem.key.val && elem._main && elem._main.query) {
+      // original element is localized but not key, as that would have
+      // already resulted in a warning
+      if (elem._origin && elem._origin.localized && elem._origin.localized.val &&
+        ( !elem._origin.key || !elem._origin.key.val)) {
+        warning('localized-key', [ elem.key.location, elem ], { keyword: 'localized' },
+                'Keyword $(KEYWORD) is ignored for primary keys');
+      }
+    }
   }
 
   function checkQuery( query ) {
@@ -334,11 +345,17 @@ function check( model ) {       // = XSN
     // Max cardinalities must be a positive number or '*'
     for (const prop of [ 'sourceMax', 'targetMax' ]) {
       if (elem.cardinality[prop]) {
-        if (!(elem.cardinality[prop].literal === 'number' && elem.cardinality[prop].val > 0 ||
-              elem.cardinality[prop].literal === 'string' && elem.cardinality[prop].val === '*')) {
-          error(null, [ elem.cardinality[prop].location, elem ],
-                { code: elem.cardinality[prop].val },
-                'Illegal value $(CODE) for max cardinality (must be a positive number or "*")');
+        const { literal, val, location } = elem.cardinality[prop];
+        if (!(literal === 'number' && val > 0 ||
+              literal === 'string' && val === '*')) {
+          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
+            // eslint-disable-next-line max-len
+            std: 'Value $(CODE) is invalid for maximum cardinality, expecting a positive number or ‘*’',
+            // eslint-disable-next-line max-len
+            sourceMax: 'Value $(CODE) is invalid for maximum source cardinality, expecting a positive number or ‘*’',
+            // eslint-disable-next-line max-len
+            targetMax: 'Value $(CODE) is invalid for maximum target cardinality, expecting a positive number or ‘*’',
+          });
         }
       }
     }
@@ -348,10 +365,16 @@ function check( model ) {       // = XSN
     //       from-csn.json (expected non-negative number)
     for (const prop of [ 'sourceMin', 'targetMin' ]) {
       if (elem.cardinality[prop]) {
-        if (!(elem.cardinality[prop].literal === 'number' && elem.cardinality[prop].val >= 0)) {
-          error(null, [ elem.cardinality[prop].location, elem ],
-                { code: elem.cardinality[prop].val },
-                'Illegal value $(CODE) for min cardinality (must be a non-negative number)');
+        const { literal, val, location } = elem.cardinality[prop];
+        if (!(literal === 'number' && val >= 0)) {
+          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
+            // eslint-disable-next-line max-len
+            std: 'Value $(CODE) is invalid for minimum cardinality, expecting a non-negative number',
+            // eslint-disable-next-line max-len
+            targetMin: 'Value $(CODE) is invalid for minimum target cardinality, expecting a non-negative number',
+            // eslint-disable-next-line max-len
+            sourceMin: 'Value $(CODE) is invalid for minimum source cardinality, expecting a non-negative number',
+          });
         }
       }
     }

package/lib/compiler/definer.js

@@ -370,7 +370,7 @@ function define( model ) {
     // TODO: check name: no "."
     if (path[0].id === 'localized' || path[0].id.startsWith( 'localized.' )) {
       decl.$inferred = 'LOCALIZED-IGNORED';
-      warning( 'using-localized-view', [ path.location, decl ], {},
+      warning( 'using-localized-view', [ decl.location, decl ], {},
                'Localization views can\'t be referred to - ignored USING' );
       // actually not ignored anymore
     }
@@ -1152,7 +1152,8 @@ function define( model ) {
         break;                  // only direct projection for auto-exposed
     }
     let ancestors = art && (!autoexposed && art._ancestors || []);
-    for (const a of chain.reverse()) {
+    chain.reverse();
+    for (const a of chain) {
       ancestors = (ancestors ? [ ...ancestors, art ] : []);
       setProp( a, '_ancestors', ancestors );
       art = a;
@@ -1274,6 +1275,9 @@ function define( model ) {
     }
   }
 
+  /**
+   * @returns {boolean|0} `true`, if allowed, `false` if forbidden, `0` if circular containment.
+   */
   function allowAspectComposition( target, elem, keys, entityName ) {
     if (!target.elements || Object.values( target.elements ).some( e => e.$duplicates ))
       return false;             // no elements or with redefinitions
@@ -1520,8 +1524,15 @@ function define( model ) {
       forEachMemberRecursivelyWithQuery(art, checkArtifact);
     }
 
-    // Function for parse.cdl
-    /** @param {XSN.Artifact} artifact */
+    /**
+     * Function for parse.cdl.
+     * This parse.cdl function resolves types inside the artifact ("resolveTypeUnchecked").
+     *
+     * @todo This function needs to be properly reworked because at the moment we simply
+     *       added checks as issues arose (e.g. for "artifact.value").
+     *
+     * @param {XSN.Artifact} artifact
+     * */
     function checkArtifact( artifact ) {
       // columns are initialized (and made to elements) in the resolver - do init here
       for (const col of artifact.columns || []) {
@@ -1532,11 +1543,21 @@ function define( model ) {
           recursivelyResolveExpressionCastTypes(col.value, artifact);
       }
 
+      // Possible inside expand/inline
+      if (artifact.value)
+        recursivelyResolveExpressionCastTypes(artifact.value, artifact);
+
       resolveTypeUnchecked(artifact, artifact);
 
       if (artifact.items)
         resolveTypeUnchecked(artifact.items, artifact);
 
+      if (Array.isArray(artifact.expand))
+        artifact.expand.forEach(art => checkArtifact(art));
+
+      if (Array.isArray(artifact.inline))
+        artifact.inline.forEach(art => checkArtifact(art));
+
       for (const include of (artifact.includes || []))
         resolveUncheckedPath(include, 'include', artifact);
 

package/lib/compiler/index.js

@@ -64,7 +64,7 @@ class ArgumentError extends Error {
  * @param {object} options Compile options
  * @param {object} messageFunctions If not provided, parse errors will not lead to an exception
  */
-function parseX( source, filename, options = {}, messageFunctions ) {
+function parseX( source, filename, options = {}, messageFunctions = null ) {
   if (!messageFunctions)
     messageFunctions = createMessageFunctions( options, 'parse' );
   const ext = path.extname( filename ).toLowerCase();

package/lib/compiler/propagator.js

@@ -19,6 +19,8 @@ function propagate( model ) {
     '@cds.persistence.calcview': never,
     '@cds.persistence.udf': never,
     '@cds.persistence.skip': notWithPersistenceTable,
+    '@sql.prepend': never,
+    '@sql.append': never,
     '@Analytics.hidden': never,
     '@Analytics.visible': never,
     '@cds.autoexpose': onlyViaArtifact,
@@ -64,8 +66,7 @@ function propagate( model ) {
     if (!art)
       return;
     if (!checkAndSetStatus( art )) {
-      if ( art.status !== 'propagated')
-        runMembers( art );
+      runMembers( art );
       return;
     }
     // console.log('RUN:', art.name, art.elements ? Object.keys(art.elements) : 0)

package/lib/compiler/resolver.js

@@ -54,6 +54,7 @@ const {
   setLink,
   annotationVal,
   augmentPath,
+  pathName,
   splitIntoPath,
   linkToOrigin,
   setMemberParent,
@@ -1108,7 +1109,6 @@ function resolve( model ) {
         // or use userQuery( query ) in the following, too?
         setMemberParent( col, `.${ q.$inlines.length }`, query );
         initFromColumns( query, col.inline, col );
-        continue;
       }
       else if (!col.$replacement) {
         const id = ensureColumnName( col, query );
@@ -1602,9 +1602,17 @@ function resolve( model ) {
     }
   }
 
-  function annotateMembers( art, extensions = [], prop, name, parent, kind ) {
+  /**
+   * @param {XSN.Artifact} art
+   * @param {XSN.Extension[]} [extensions]
+   * @param {string} [prop]
+   * @param {string} [name]
+   * @param {object} [parent]
+   * @param {string} [kind]
+   */
+  function annotateMembers( art, extensions, prop, name, parent, kind ) {
     const showMsg = !art && parent && parent.kind !== 'annotate';
-    if (!art && extensions.length) {
+    if (!art && extensions && extensions.length) {
       if (Array.isArray( parent ))
         return;
       const parentExt = extensionFor(parent);
@@ -1620,7 +1628,7 @@ function resolve( model ) {
       }
     }
 
-    for (const ext of extensions) {
+    for (const ext of extensions || []) {
       if ('_artifact' in ext.name) // already applied
         continue;
       setProp( ext.name, '_artifact', art );
@@ -1849,7 +1857,7 @@ function resolve( model ) {
                          [ mergeSource.name.location, art ], { code: '...' } );
                   return;
                 }
-                mergeTarget.val.splice(pos, 1, ...mergeSource.val);
+                mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
               }
             }
           });
@@ -1869,7 +1877,7 @@ function resolve( model ) {
                    [ mergeSource.name.location, art ], { code: '...' } );
             return mergeTarget;
           }
-          mergeTarget.val.splice(pos, 1, ...mergeSource.val);
+          mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
           layer = layers.layer( mergeSource._block );
           delete layerAnnos[(layer) ? layer.realname : ''];
           pos = findEllipsis( mergeTarget );
@@ -1880,6 +1888,89 @@ function resolve( model ) {
       return mergeTarget;
     }
 
+    function mergeArrayValues( previousValue, arraySpec ) {
+      let prevPos = 0;
+      const result = [];
+      for (const item of arraySpec) {
+        const ell = item && item.literal === 'token' && item.val === '...';
+        if (!ell) {
+          result.push( item );
+        }
+        else {
+          let upToSpec = item.upTo && checkUpToSpec( item.upTo, true );
+          while (prevPos < previousValue.length) {
+            const prevItem = previousValue[prevPos++];
+            result.push( prevItem );
+            if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
+              upToSpec = false;
+              break;
+            }
+          }
+          if (upToSpec) {       // non-matched UP TO
+            warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
+                     'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+          }
+        }
+      }
+      return result;
+    }
+
+    function checkUpToSpec( upToSpec, trueIfFullUpTo ) {
+      const { literal } = upToSpec;
+      if (trueIfFullUpTo !== true) { // inside struct of UP TO
+        if (![ 'struct', 'array' ].includes( literal ))
+          return true;
+      }
+      else if (literal === 'struct') {
+        return Object.values( upToSpec.struct ).every( checkUpToSpec );
+      }
+      else if (![ 'array', 'boolean', 'null' ].includes( literal )) {
+        return true;
+      }
+      error( null, [ upToSpec.location, art ],
+             { anno: annoName, code: '... up to', '#': literal },
+             {
+               std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
+               array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
+               // eslint-disable-next-line max-len
+               struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
+               boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
+               null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
+             } );
+      return false;
+    }
+
+    function equalUpTo( previousItem, upToSpec ) {
+      if (!previousItem)
+        return false;
+      if ('val' in upToSpec) {
+        if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
+          return true;
+        const typeUpTo = typeof upToSpec.val;
+        const typePrev = typeof previousItem.val;
+        if (typeUpTo === 'number')
+          return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
+        if (typePrev === 'number')
+          return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
+      }
+      else if (upToSpec.path) {
+        return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
+      }
+      else if (upToSpec.sym) {
+        return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
+      }
+      else if (upToSpec.struct && previousItem.struct) {
+        return Object.entries( upToSpec.struct )
+          .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
+      }
+      return false;
+    }
+
+    function normalizeRef( node ) { // see to-csn.js
+      const ref = pathName( node.path );
+      return node.variant ? `${ ref }#${ node.variant.id }` : ref;
+    }
+
     function removeEllipsis(a, pos = findEllipsis( a )) {
       let count = 0;
       while (a.literal === 'array' && pos > -1) {

package/lib/compiler/shared.js

@@ -26,7 +26,6 @@ function artifactsEnv( art ) {
  */
 // TODO: yes, this function will be renamed
 function fns( model ) {
-  /** @type {CSN.Options} */
   const { options } = model;
   const {
     info, warning, error, message,
@@ -173,16 +172,25 @@ function fns( model ) {
     return !(art.elements && !art.query && !art.type && !art.params);
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkTypeRef( art ) {
     if (art.kind === 'type' || art.kind === 'element')
       return false;
     return ![ 'entity', 'aspect', 'event' ].includes( art.kind ) || 'sloppy';
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkActionParamTypeRef( art ) {
     return !(art.kind === 'entity' && art._service) && checkTypeRef( art );
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkEventTypeRef( art ) {
     return art.kind !== 'event' && checkActionParamTypeRef( art );
   }
@@ -191,6 +199,9 @@ function fns( model ) {
     return art.kind !== 'entity';
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkTargetRef( art ) {
     if (art.kind === 'entity' || art.kind === 'aspect')
       return false;

package/lib/compiler/utils.js

@@ -30,6 +30,13 @@ function annotationIsFalse( anno ) {                   // falsy, but not null (u
   return anno && (anno.val === false || anno.val === 0 || anno.val === '');
 }
 
+/**
+ * @param {XSN.Artifact} art
+ * @param {string} anno
+ * @param {XSN.Location} [location]
+ * @param {*} [val]
+ * @param {string} [literal]
+ */
 function annotateWith( art, anno, location = art.location, val = true, literal = 'boolean' ) {
   if (art[anno])  // do not overwrite user-defined including null
     return;