@sap/cds-compiler 6.7.3 → 6.9.0

package/lib/base/{model.js → specialOptions.js}

@@ -1,15 +1,10 @@
-// module- and csn/XSN-independent definitions
+// Definitions for beta and deprecated options
 
-// TODO: move XSN-specific things to lib/compiler/utils/
-// TODO: move CSN-specific things to ???
+// Normal options are in ../base/optionProcessor.js (and some other files),
+// unfortunately partly non-grep-able (option `fooBar` is defined via `--foo-bar`)
 
 'use strict';
 
-const { forEach } = require('../utils/objectUtils');
-
-// Normal options are in ../optionProcessor.js (and some other files),
-// unfortunately partly non-grep-able (option `fooBar` is defined via `--foo-bar`)
-
 /**
  * Object of all available beta flags that will be enabled/disabled by `--beta-mode`
  * through cdsc.  Only intended for INTERNAL USE.
@@ -47,12 +42,12 @@ const availableDeprecatedFlags = {
   ignoreSpecifiedQueryElements: true,
 };
 
-// Deprecated flags that were removed in v5.
-const oldDeprecatedFlagsV5 = [
-  'includesNonShadowedFirst',
-  'eagerPersistenceForGeneratedEntities',
-  'noKeyPropagationWithExpansions',
-];
+// Deprecated flags that were removed in newer version and are complained about.
+const oldDeprecatedFlags = {
+  includesNonShadowedFirst: true,
+  eagerPersistenceForGeneratedEntities: true,
+  noKeyPropagationWithExpansions: true,
+};
 
 /**
  * Test for early-adaptor feature, stored in option `beta`(new-style) / `betaMode`(old-style)
@@ -98,48 +93,30 @@ function isDeprecatedEnabled( options, feature = null ) {
 }
 
 /**
- * In cds-compiler v3, we removed old v2 deprecated flags.  That can lead to silent
+ * In the current cds-compiler, we might have removed old deprecated flags.  That can lead to silent
  * errors such as entity/view names changing.  To ensure that the user is forced
  * to change their code, emit an error if one of such removed flags was used.
  *
  * @param {CSN.Options} options
  * @param error Error message function returned by makeMessageFunction().
  */
-function checkRemovedDeprecatedFlags( options, { error } ) {
+function checkRemovedDeprecatedFlags( { deprecated, messages }, { error } ) {
   // Assume that we emitted these errors once if a message with this ID was found.
-  if (!options.deprecated || options.messages?.some(m => m.messageId === 'api-invalid-deprecated'))
+  if (!deprecated || messages?.some( m => m.messageId === 'api-invalid-deprecated' ))
     return;
 
-  forEach(options.deprecated, (key, val) => {
-    if (val && oldDeprecatedFlagsV5.includes(key)) {
-      error('api-invalid-deprecated', null, { name: key },
-            'Deprecated flag $(NAME) has been removed in CDS compiler v6');
+  Object.keys( deprecated ).forEach( ( key ) => {
+    if (deprecated[key] && oldDeprecatedFlags[key]) { // why testing the value of the option?
+      error( 'api-invalid-deprecated', null, { name: key },
+             'Deprecated flag $(NAME) has been removed in CDS compiler v6' );
     }
   });
 }
 
-/**
- * Like `obj.prop = value`, but not contained in JSON / CSN
- * It's important to set enumerable explicitly to false (although 'false' is the default),
- * as else, if the property already exists, it keeps the old setting for enumerable.
- *
- * @param {object} obj
- * @param {string} prop
- * @param {any} value
- */
-function setProp( obj, prop, value ) {
-  const descriptor = {
-    value, configurable: true, writable: true, enumerable: false,
-  };
-  Object.defineProperty( obj, prop, descriptor );
-  return value;
-}
-
 
 module.exports = {
   isBetaEnabled,
   availableBetaFlags,
   isDeprecatedEnabled,
   checkRemovedDeprecatedFlags,
-  setProp,
 };

package/lib/checks/arrayOfs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { setProp } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
 
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 

package/lib/checks/elements.js

@@ -8,7 +8,7 @@ const {
 } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { isGeoTypeName } = require('../compiler/builtins');
-const { setProp } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
 /**

package/lib/checks/enricher.js

@@ -4,8 +4,8 @@
 
 'use strict';
 
-const { csnRefs } = require('../model/csnRefs');
-const { setProp } = require('../base/model');
+const { csnRefs } = require('../base/csnRefs');
+const { setProp } = require('../utils/objectUtils');
 const { isAnnotationExpression } = require('../base/builtins');
 
 /**

package/lib/checks/featureFlags.js

@@ -1,39 +1,69 @@
 'use strict';
 
-const { setProp } = require('../base/model');
+const { setProp, forEachValue } = require('../utils/objectUtils');
 const { featureFlags } = require('../transform/featureFlags');
 const { isSqlService, isDummyService, isDataProductProductionService } = require('../transform/db/processSqlServices');
 
 /**
+ * Set a feature flag on the CSN model.
  *
- * @param {string} flag
+ * @param {CSN.Model} csn CSN model to set flag on
+ * @param {string} flag Flag name to set
+ */
+function setFeatureFlag( csn, flag ) {
+  if (!csn.meta)
+    setProp(csn, 'meta', {});
+  if (!csn.meta[featureFlags])
+    csn.meta[featureFlags] = {};
+
+  csn.meta[featureFlags][flag] = true;
+}
+
+/**
+ * Get a function that detects and sets feature flags for expand/inline columns in a query.
  *
- * @returns {Function} Function to correctly set the given flag
+ * @param {CSN.Model} csn CSN model to set flags on
+ * @returns {Function} Function to call per query
  */
-function setFeatureFlag( flag ) {
-  return function setFlag() {
-    if (!this.csn.meta)
-      setProp(this.csn, 'meta', {});
-    if (!this.csn.meta[featureFlags])
-      this.csn.meta[featureFlags] = {};
+function getQueryFeatureFlagSetter( csn ) {
+  return function setQueryFeatureFlags(query) {
+    const queryProp = query.SELECT ? 'SELECT' : 'projection';
+    query[queryProp]?.columns?.forEach((column) => {
+      if (column.expand || column.inline)
+        setFeatureFlag(csn, '$expandInline');
+    });
+  };
+}
 
-    this.csn.meta[featureFlags][flag] = true;
+/**
+ * Get a function that detects and sets feature flags for entity/service definitions.
+ * That are calculated elements and SQL services.
+ *
+ * @param {CSN.Model} csn CSN model to set flags on
+ * @param {CSN.Options} options Compiler options
+ * @returns {Function} Function to call per definition
+ */
+function getDefinitionFeatureFlagSetter( csn, options ) {
+  return function setDefinitionFeatureFlags(def) {
+    if (def.kind === 'entity' && def.elements) {
+      forEachValue(def.elements, (element) => {
+        if (element.value)
+          setFeatureFlag(csn, '$calculatedElements');
+      });
+    }
+    else if (def.kind === 'service') {
+      if (isSqlService(def))
+        setFeatureFlag(csn, '$sqlService');
+      if (isDummyService(def, options))
+        setFeatureFlag(csn, '$dummyService');
+      if (isDataProductProductionService(def))
+        setFeatureFlag(csn, '$dataProductService');
+    }
   };
 }
 
-// Export a applyTransformations callback object that sets the feature flags if certain properties are present
+// Export factory functions that create bound feature flag setters for use in transformation loops
 module.exports = {
-  value: setFeatureFlag('$calculatedElements'),
-  expand: setFeatureFlag('$expandInline'),
-  inline: setFeatureFlag('$expandInline'),
-  kind: function setFeatureFlagForSqlService( artifact ) {
-    if (isSqlService(artifact))
-      setFeatureFlag( '$sqlService' ).call(this);
-
-    if (isDummyService(artifact, this.options))
-      setFeatureFlag( '$dummyService' ).call(this);
-
-    if (isDataProductProductionService(artifact, this.options))
-      setFeatureFlag( '$dataProductService' ).call(this);
-  },
+  getQueryFeatureFlagSetter,
+  getDefinitionFeatureFlagSetter,
 };

package/lib/checks/foreignKeys.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { setProp } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 

package/lib/checks/invalidTarget.js

@@ -3,7 +3,7 @@
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 const { ModelError } = require('../base/error');
-const { setProp } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
 
 /**
  * Assert that targets of associations and compositions are entities.

package/lib/checks/managedInType.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { setProp } = require('../base/model');
+const { setProp } = require('../utils/objectUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 

package/lib/checks/onConditions.js

@@ -2,7 +2,7 @@
 
 const { forEachGeneric } = require('../model/csnUtils');
 const { otherSideIsExpandableStructure, resolveArtifactType } = require('./utils');
-const { pathId } = require('../model/csnRefs');
+const { pathId } = require('../base/csnRefs');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 

package/lib/checks/queryNoDbArtifacts.js

@@ -3,7 +3,7 @@
 const { isPersistedOnDatabase, applyTransformationsOnNonDictionary } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { requireForeignKeyAccess } = require('./onConditions');
-const { pathId } = require('../model/csnRefs');
+const { pathId } = require('../base/csnRefs');
 
 const generalQueryProperties = [ 'from', 'columns', 'where', 'groupBy', 'orderBy', 'having', 'limit' ];
 

package/lib/checks/validator.js

@@ -18,7 +18,6 @@ const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
 const { checkAnnotationExpression } = require('./structuredAnnoExpressions');
 const checkForParams = require('./parameters');
-const checkAndRemoveEnums = require('./enums');
 // forOdata
 const { validateDefaultValues } = require('./defaultValues');
 const { checkActionOrFunction } = require('./actionsFunctions');
@@ -54,7 +53,6 @@ const {
   checkSqlAnnotationOnElement,
 } = require('./sql-snippets');
 const assertNoAssocUsageOutsideOfService = require('./assocOutsideService');
-const featureFlags = require('./featureFlags');
 const { timetrace } = require('../utils/timetrace');
 
 const forRelationalDBMemberValidators
@@ -94,7 +92,6 @@ const forRelationalDBCsnValidators = [
   navigationIntoMany,
   expandToMany,
   checkPathsInStoredCalcElement,
-  featureFlags,
 ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
@@ -168,7 +165,7 @@ function _validate( csn, that,
   // TODO: Don't know if that's feasible? Do we really need to enrich annotations always?
   // const { cleanup } = enrich(csn, { processAnnotations: that.options.tranformation === 'odata' });
 
-  applyTransformations(csn, mergeTransformers(csnValidators, that), [], { drillRef: true });
+  applyTransformations(csn, mergeTransformers(csnValidators, that), [], { drillRef: true, ...iterateOptions });
 
   forEachDefinition(csn, (artifact, artifactName, prop, path) => {
     artifactValidators.forEach((artifactValidator) => {
@@ -201,10 +198,8 @@ function _validate( csn, that,
 function getDBCsnValidators( options ) {
   const validations = [ ...forRelationalDBCsnValidators ];
 
-  if (options.transformation !== 'effective') {
-    validations.push(checkAndRemoveEnums);
+  if (options.transformation !== 'effective')
     validations.push(checkForParams.csnValidator);
-  }
 
   if (options.sqlDialect === 'h2' || options.sqlDialect === 'postgres')
     validations.push(checkForHanaTypes);
@@ -221,7 +216,13 @@ function forRelationalDB( csn, that ) {
   const memberValidators = [ ...forRelationalDBMemberValidators, ...commonMemberValidators ];
   if (that.options.transformation === 'hdbcds')
     memberValidators.push(checkForParams.memberValidator);
-
+  // skip artifacts / elements which are not persisted on the database from being validated
+  const iterateOptions = {
+    skipArtifact: artifact => artifact.abstract ||
+      hasPersistenceSkipAnnotation(artifact) ||
+      artifact['@cds.persistence.exists'] ||
+      [ 'action', 'function', 'event' ].includes(artifact.kind),
+  };
   return _validate(csn, that,
                    getDBCsnValidators(that.options),
                    memberValidators,
@@ -246,12 +247,7 @@ function forRelationalDB( csn, that ) {
                      }
                    ),
                    forRelationalDBQueryValidators.concat(commonQueryValidators),
-                   {
-                     skipArtifact: artifact => artifact.abstract ||
-                                                hasPersistenceSkipAnnotation(artifact) ||
-                                                artifact['@cds.persistence.exists'] ||
-                                                [ 'action', 'function', 'event' ].includes(artifact.kind),
-                   });
+                   iterateOptions);
 }
 
 /**

package/lib/compiler/assert-consistency.js

@@ -283,7 +283,7 @@ function assertConsistency( model, stage ) {
           'quantifier', 'orderBy', 'limit', 'name', '$parens', 'kind',
           '_origin', '$contains', // TODO tmp, see TODO in getOriginRaw()
           '_parent', '_main', '_leadingQuery', '_effectiveType', '$effectiveSeqNo', // in FROM
-          '_$next', // parsing error: tableTerm with UNION on rhs.
+          '$expand', '_$next', // parsing error: tableTerm with UNION on rhs.
         ],
       },
       select: {                   // sub query
@@ -309,7 +309,7 @@ function assertConsistency( model, stage ) {
           'on', '$parens', 'cardinality',
           'kind', 'name', '_block', '_parent', '_main', '_user',
           '$tableAliases', '_combined', '_joinParent', '$joinArgsIndex',
-          '_leadingQuery', '_$next', '_deps',
+          '_leadingQuery', '_$next', '_deps', '$expand',
         ],
       },
       ref: {
@@ -329,7 +329,7 @@ function assertConsistency( model, stage ) {
           '$parens',
           'kind', 'name', '_block', '_parent', '_main', 'elements',
           '_effectiveType', '$effectiveSeqNo', '_origin', '_joinParent', '$joinArgsIndex',
-          '$duplicates', // duplicate query in FROM clause
+          '$expand', '$duplicates', // duplicate query in FROM clause
         ],
       },
       none: { optional: () => true }, // parse error
@@ -352,13 +352,13 @@ function assertConsistency( model, stage ) {
       requires: [ 'location', 'name' ],
       optional: [ '$duplicates' ],
     },
-    orderBy: { inherits: 'value', test: isArray( expression ) },
+    orderBy: { kind: [ 'extend' ], inherits: 'value', test: isArray( expression ) },
     sort: { test: locationVal( isString ), enum: [ 'asc', 'desc' ] },
     nulls: { test: locationVal( isString ), enum: [ 'first', 'last' ] },
     $orderBy: { inherits: 'orderBy' },
-    groupBy: { inherits: 'value', test: isArray( expression ) },
+    groupBy: { kind: [ 'extend' ], inherits: 'value', test: isArray( expression ) },
     $limit: { test: TODO },
-    limit: { requires: [ 'rows' ], optional: [ 'offset', 'location' ] },
+    limit: { kind: [ 'extend' ], requires: [ 'rows' ], optional: [ 'offset', 'location' ] },
     rows: { inherits: 'value' },
     offset: { inherits: 'value' },
     _combined: { test: TODO },
@@ -438,6 +438,8 @@ function assertConsistency( model, stage ) {
         'location', '$inferred', 'sort', 'nulls',
         'param', 'scope', // for dynamic parameter '?'
         'args', 'op', 'func', 'suffix',
+        // needed for groupBy extensions - TODO: outside `value`:
+        '$extended', '_block', '_outer',
         // calculated elements on-write - TODO: outside `value`
         'stored',
       ],
@@ -512,8 +514,8 @@ function assertConsistency( model, stage ) {
       test: args,
     },
     on: { kind: true, inherits: 'value', test: expression },
-    where: { inherits: 'value' },
-    having: { inherits: 'value' },
+    where: { kind: [ 'extend' ], inherits: 'value' },
+    having: { kind: [ 'extend' ], inherits: 'value' },
     op: { test: locationVal( isString ) },
     join: { test: locationVal( isString ) },
     quantifier: { test: locationVal( isString ) },
@@ -736,7 +738,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', 'target', 'annotate', 'extend' ] ),
     },
     $inCycle: { kind: true, test: isBoolean },
 

package/lib/compiler/base.js

@@ -3,6 +3,7 @@
 'use strict';
 
 const { CompilerAssertion } = require( '../base/error' );
+const $inferred = Symbol.for( 'cds.$inferred' );
 
 const dictKinds = {
   definitions: 'absolute',
@@ -67,7 +68,8 @@ const kindProperties = {
 
 function propExists( prop, parent ) {
   const obj = parent.returns || parent;
-  return (obj.items || obj.targetAspect || obj)[prop];
+  const members = (obj.items || obj.targetAspect || obj)[prop];
+  return members && !members[$inferred];
 }
 
 /**
@@ -90,6 +92,8 @@ function getArtifactName( art ) {
   const namePath = [];
   let parent = art._outer || art;
   while (parent._main || parent.kind === 'builtin') { // until we hit the main artifact
+    if (!parent.name)
+      return '<error>';
     if (parent.name.$inferred !== '$internal' || parent.kind === '$inline')
       namePath.push( parent );
     if (parent.kind === 'select')

package/lib/compiler/builtins.js

@@ -9,7 +9,7 @@
 
 const { builtinLocation } = require('../base/location');
 const { setLink } = require('./utils');
-const { isBetaEnabled } = require('../base/model');
+const { isBetaEnabled } = require('../base/specialOptions');
 
 // TODO: make type parameters a dict
 const core = {

package/lib/compiler/checks.js

@@ -9,7 +9,7 @@
 
 'use strict';
 
-const { isDeprecatedEnabled } = require('../base/model');
+const { isDeprecatedEnabled } = require('../base/specialOptions');
 const { propagationRules, acceptsExprValues } = require('../base/builtins');
 const { typeParameters } = require('./builtins');
 const {
@@ -132,8 +132,8 @@ function check( model ) {
         typeName === 'cds.Vector' ||
         typeName === 'cds.hana.CLOB' ||
         typeName === 'cds.LargeBinary') {
-      warning( 'def-unsupported-key', [ elem.type?.location || elem.location, elem ],
-               { '#': 'type', keyword: 'key', type: typeName } );
+      warning( 'type-invalid-for-key', [ elem.type?.location || elem.location, elem ],
+               { type: typeName } );
     }
   }
 

package/lib/compiler/define.js

@@ -122,10 +122,10 @@
 
 const { weakLocation, builtinLocation } = require('../base/location');
 
-const shuffleGen = require('../base/shuffle');
+const shuffleGen = require('../utils/shuffle');
 const {
   dictAdd, dictAddArray, dictForEach, pushToDict,
-} = require('../base/dictionaries');
+} = require('./dictionaries');
 const { kindProperties } = require('./base');
 const {
   setLink,
@@ -724,6 +724,9 @@ function define( model ) {
       // ORDER BY and LIMIT to be evaluated in leading query
     }
     else { // with parse error (`select from <EOF>`, `select from E { *, ( select }`)
+      // TODO: call initQuery() anyway to avoid Error[expr-no-subquery] also for
+      // UNIONs (test3/Queries/DollarSelf/CorruptedSource.err.cds), see also
+      // resolveExprNode()
       return undefined;
     }
     return query._leadingQuery || query;
@@ -1004,7 +1007,7 @@ function define( model ) {
     }
     else if ((col.expand || col.value) &&
              !path &&           // no parse error (path without last item)
-             (insideExpand || query._parent.kind !== 'select')) { // not sub-selects
+             (insideExpand || query._parent?.kind !== 'select')) { // not sub-selects
       error( 'query-req-name',
              // TODO: message function: `query` should work directly
              [ (col.value || col).location, (query.name ? query : query._parent ) ],

package/lib/{base → compiler}/dictionaries.js

@@ -2,6 +2,8 @@
 //
 // Warning: this is Core-compiler only stuff
 
+// TODO: probably move to some future lib/xsn/
+
 'use strict';
 
 // New-style duplicate representation - use the style below for artifacts and
@@ -84,9 +86,8 @@ function dictAddArray( dict, name, entry, messageCallback ) {
 function dictFirst( dict ) {
   if (!dict)
     return dict;
-  for (const name in dict)
-    return dict[name];
-  return undefined;
+  const names = Object.keys( dict );
+  return names.length ? dict[names[0]] : null;
 }
 
 // Push `entry` to the array value with key `name` in the dictionary `dict`.