@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/checks/cdsPersistence.js

@@ -13,7 +13,8 @@
 function validateCdsPersistenceAnnotation(artifact, artifactName, prop, path) {
   if (artifact.kind === 'entity') {
     // filter for 'table', 'udf', 'calcview' === true
-    const TableUdfCv = Object.keys(artifact).filter(p => [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ].includes(p) && artifact[p]);
+    const persistenceAnnos = [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ];
+    const TableUdfCv = Object.keys(artifact).filter(p => persistenceAnnos.includes(p) && artifact[p]);
     if (TableUdfCv.length > 1)
       this.error(null, path, `Annotations ${ TableUdfCv.join(', ') } can't be used in combination`);
   }

package/lib/checks/enricher.js

@@ -30,6 +30,7 @@ function enrichCsn( csn ) {
     type: simpleRef,
     target: simpleRef,
     includes: simpleRef,
+    columns,
     // Annotations are ignored.
     '@': () => { /* ignore annotations */ },
   };
@@ -40,7 +41,7 @@ function enrichCsn( csn ) {
     cleanupCallbacks = [];
   };
 
-  const { inspectRef, artifactRef } = csnRefs( csn );
+  const { inspectRef, artifactRef, getElement } = csnRefs( csn );
   const csnPath = [];
   if (csn.definitions)
     dictionary( csn, 'definitions', csn.definitions );
@@ -82,6 +83,21 @@ function enrichCsn( csn ) {
     csnPath.pop();
   }
 
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function columns( parent, prop, node ) {
+    // Establish the link relationships
+    parent[prop].forEach((column) => {
+      const element = getElement(column);
+      if (element) {
+        setProp(column, '_element', element);
+        cleanupCallbacks.push(() => delete column._element);
+        setProp(element, '_column', column);
+        cleanupCallbacks.push(() => delete element._column);
+      }
+    });
+    standard(parent, prop, node);
+  }
+
   // eslint-disable-next-line jsdoc/require-jsdoc
   function simpleRef( node, prop ) {
     setProp(node, '$path', [ ...csnPath ]);

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/invalidTarget.js

@@ -2,6 +2,8 @@
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
+const { ModelError } = require('../base/error');
+
 /**
  * Assert that targets of associations and compositions are entities.
  *
@@ -22,7 +24,7 @@ function invalidTarget(member) {
     if (mem.target) {
       const target = this.csn.definitions[mem.target];
       if (!target)
-        throw new Error(`Expected target ${ mem.target }`);
+        throw new ModelError(`Expected target ${ mem.target }`);
       if (target.kind !== 'entity') {
         const isAssoc = this.csnUtils.getFinalBaseType(member.type) !== 'cds.Composition';
         this.error(

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/managedWithoutKeys.js

@@ -1,6 +1,8 @@
 'use strict';
 
 
+const { ModelError } = require('../base/error');
+
 /**
  * Trigger a recompilation in case of an association without .keys and without .on
  *
@@ -10,7 +12,7 @@
  */
 function managedWithoutKeys(member, memberName, prop) {
   if (prop === 'elements' && member.target && !member.keys && !member.on) { // trigger recompilation
-    throw new Error('Expected association to have either an on-condition or foreign keys.');
+    throw new ModelError('Expected association to have either an on-condition or foreign keys.');
   }
 }
 

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/selectItems.js

@@ -29,7 +29,7 @@ function validateSelectItems(query) {
     }
   });
   // .call() with 'this' to ensure we have access to the options
-  rejectManagedAssociationsAndStructuresForHdbcsNames.call(this, SELECT, SELECT.$path);
+  rejectManagedAssociationsAndStructuresForHdbcdsNames.call(this, SELECT, SELECT.$path);
 }
 
 
@@ -41,10 +41,10 @@ function validateSelectItems(query) {
  * @param {CSN.Artifact} queryArtifact the query artifact which should be checked
  * @param {CSN.Path} artifactPath the path to that artifact
  */
-function rejectManagedAssociationsAndStructuresForHdbcsNames(queryArtifact, artifactPath) {
+function rejectManagedAssociationsAndStructuresForHdbcdsNames(queryArtifact, artifactPath) {
   if (this.options.transformation === 'hdbcds' && this.options.sqlMapping === 'hdbcds') {
     forEachGeneric(queryArtifact, 'elements', (selectItem, elemName, prop, elementPath) => {
-      if (this.csnUtils.isManagedAssociationElement(selectItem))
+      if (this.csnUtils.isManagedAssociation(selectItem))
         this.error('query-unexpected-assoc-hdbcds', elementPath);
       if (this.csnUtils.isStructured(selectItem))
         this.error('query-unexpected-structure-hdbcds', elementPath);
@@ -52,4 +52,4 @@ function rejectManagedAssociationsAndStructuresForHdbcsNames(queryArtifact, arti
   }
 }
 
-module.exports = { validateSelectItems, rejectManagedAssociationsAndStructuresForHdbcsNames };
+module.exports = { validateSelectItems, rejectManagedAssociationsAndStructuresForHdbcdsNames };

package/lib/checks/sql-snippets.js

@@ -0,0 +1,94 @@
+'use strict';
+
+// 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 (member['@sql.replace'])
+    this.error(null, path, { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+  if (member['@sql.prepend'])
+    this.message('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.message('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.message('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 (artifact.kind !== 'entity') {
+    if (artifact['@sql.prepend'])
+      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.prepend', kind: artifact.kind }, `Annotation $(NAME) can't be used on an artifact of kind $(KIND)` );
+    if (artifact['@sql.append'])
+      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.append', kind: artifact.kind }, `Annotation $(NAME) can't be used on an artifact of kind $(KIND)` );
+  }
+  else if (artifact['@sql.prepend']) {
+    if (artifact.query)
+      this.message('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/types.js

@@ -19,7 +19,7 @@ function checkDecimalScale(member, memberName, prop, path) {
      // skip is already filtered in validator, here for completeness
      hasAnnotationValue(this.artifact, '@cds.persistence.skip'))
     return;
-  if (member.scale && [ 'variable', 'floating' ].includes(member.scale))
+  if (member.scale && (member.scale === 'variable' || member.scale === 'floating'))
     this.error(null, path, { name: member.scale }, 'Unexpected scale $(NAME)');
 }
 

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 ];
@@ -121,7 +129,7 @@ function _validate(csn, that,
                    iterateOptions = {}) {
   const { cleanup } = enrich(csn);
 
-  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], true, { drillRef: true });
+  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], { drillRef: true });
 
   forEachDefinition(csn, (artifact, artifactName, prop, path) => {
     artifactValidators.forEach((artifactValidator) => {
@@ -196,12 +204,9 @@ function forHana(csn, that) {
                    ),
                    forHanaQueryValidators.concat(commonQueryValidators),
                    {
-                     skipArtifact: artifact => artifact.abstract || hasAnnotationValue(artifact, '@cds.persistence.skip'),
-                     skip: [
-                       'action',
-                       'function',
-                       'event',
-                     ],
+                     skipArtifact: artifact => artifact.abstract ||
+                                                hasAnnotationValue(artifact, '@cds.persistence.skip') ||
+                                                [ 'action', 'function', 'event' ].includes(artifact.kind),
                    });
 }
 

package/lib/compiler/assert-consistency.js

@@ -298,6 +298,7 @@ function assertConsistency( model, stage ) {
     },
     expand: { kind: [ 'element' ], inherits: 'columns' },
     inline: { kind: [ 'element' ], inherits: 'columns' },
+    $noOrigin: { kind: [ 'element' ], test: TODO },
     excludingDict: {
       kind: 'element',
       test: isDictionary( definition ), // definition since redef
@@ -325,8 +326,8 @@ function assertConsistency( model, stage ) {
       kind: true,
       requires: [ 'location' ],
       optional: [
-        'path', 'elements', '_outer',
-        'scope', '_artifact', '$inferred', '$expand',
+        'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
+        'scope', '_artifact', '$inferred', '$expand', '$tableAliases', '_$next',
         '_effectiveType',           // by propagation
       ],
     },
@@ -424,9 +425,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',
@@ -638,7 +642,8 @@ function assertConsistency( model, stage ) {
    * and `localized` namespaces.
    */
   function builtin( node, parent, prop, spec, name ) {
-    if (![ 'string', 'boolean' ].includes(typeof node))
+    const type = typeof node;
+    if (type !== 'string' && type !== 'boolean')
       throw new Error(`Property '${ prop }' must be a boolean or string but was '${ typeof node }'${ at( [ node, parent ], prop, name ) }` );
 
     if (parent.kind !== 'namespace')
@@ -792,8 +797,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/builtins.js

@@ -1,9 +1,14 @@
 // The builtin artifacts of CDS
 
+// TODO: split this file
+// - in base/: common definitions
+// - in compiler/: XSN-specific
+// - in ?: CSN-specific
+
 'use strict';
 
 const { builtinLocation } = require('../base/location');
-const { setProp } = require('./utils');
+const { setLink: setProp } = require('./utils');
 
 const core = {
   String: { parameters: [ 'length' ], category: 'string' },
@@ -56,7 +61,6 @@ const coreHana = {
  * (do not add more - make it part of the SQL renderer to remove parentheses for
  * other funny SQL functions like CURRENT_UTCTIMESTAMP).
  */
-
 const functionsWithoutParens = [
   'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
@@ -176,7 +180,8 @@ function isRelationTypeName(typeName) {
 function isInReservedNamespace(absolute) {
   return absolute.startsWith( 'cds.') &&
     !absolute.match(/^cds\.foundation(\.|$)/) &&
-    !absolute.match(/^cds\.outbox(\.|$)/); // Requested by Node runtime
+    !absolute.match(/^cds\.outbox(\.|$)/) && // Requested by Node runtime
+    !absolute.match(/^cds\.xt(\.|$)/); // Requested by Mtx
 }
 
 /**
@@ -214,9 +219,6 @@ function initBuiltins( model ) {
   model.$builtins.hana = hana;
   cds._subArtifacts.hana = hana;
   env( coreHana, 'cds.hana.', hana );
-  // namespace:"localized" stores localized convenience views ---
-  const localized = createNamespace( 'localized', true );
-  model.definitions.localized = localized;
   model.$internal = { $frontend: '$internal' };
   return;
 

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',
+          });
         }
       }
     }
@@ -436,6 +459,10 @@ function check( model ) {       // = XSN
    * 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) {
@@ -471,8 +498,15 @@ function check( model ) {       // = XSN
 
       const missingArgs = [];
       for (const fAName in formalArgs) {
-        if (!actualArgs[fAName] && !formalArgs[fAName].default)
-          missingArgs.push(fAName);
+        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) {
@@ -612,7 +646,7 @@ function check( model ) {       // = XSN
     return checkTreeLikeExpression(xpr, allowAssocTail);
   }
   /**
-   * Check wether the supplied argument is a virtual element
+   * Check whether the supplied argument is a virtual element
    *
    * TO CLARIFY: do we want the "no virtual element" check for virtual elements/columns, too?
    *

package/lib/compiler/cycle-detector.js

@@ -16,7 +16,7 @@
 
 'use strict';
 
-const { setProp } = require('../base/model');
+const { setLink: setProp } = require('./utils'); // check enum/non-enum
 
 // Detect cyclic dependencies between all nodes reachable from `definitions`.
 // If such a dependency is found, call `reportCycle` with arguments `dep.art`