@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/checks/sql-snippets.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const { isBetaEnabled } = require('../base/model');
-
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
@@ -14,20 +12,18 @@ const { isBetaEnabled } = require('../base/model');
  * @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.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.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);
-    }
+  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);
   }
 }
 
@@ -54,19 +50,24 @@ function checkValidAnnoValue(carrier, annotation, path, error, options) {
  * @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.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);
-  }
+  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.

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

@@ -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,
 ];
 
@@ -129,7 +127,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) => {
@@ -204,12 +202,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

@@ -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 ) {
@@ -298,6 +299,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 +327,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
       ],
     },
@@ -641,7 +643,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')

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

@@ -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' },
@@ -41,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: {},
@@ -56,7 +71,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 +190,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 +229,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;
 
@@ -310,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,69 +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.
-   *
-   * @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] && !formalArgs[fAName].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
@@ -635,7 +577,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?
    *
@@ -945,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/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`