@sap/cds-compiler 2.5.0 → 2.10.4

package/lib/api/validate.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { makeMessageFunction, handleMessages } = require('../base/messages');
+const { makeMessageFunction } = require('../base/messages');
 
 /* eslint-disable arrow-body-style */
 const booleanValidator = {
@@ -94,6 +94,11 @@ const validators = {
     expected: () => 'Integer literal',
     found: val => `type ${ typeof val }`,
   },
+  csnFlavor: {
+    validate: val => typeof val === 'string',
+    expected: () => 'type string',
+    found: val => `type ${ typeof val }`,
+  },
   dictionaryPrototype: {
     validate: () => true,
   },
@@ -122,15 +127,17 @@ const allCombinationValidators = {
  * Use a custom validator or "default" custom validator, fallback to Boolean validator.
  *
  * @param {object} options Flat options object to validate
+ * @param {string} moduleName The called module, e.g. 'for.odata', 'to.hdi'. Needed to initialize the message functions
  * @param {object} [customValidators] Map of custom validators to use
  * @param {string[]} [combinationValidators] Validate option combinations
  * @returns {void}
  * @throws {CompilationError} Throws in case of invalid option usage
  */
-function validate(options, customValidators = {}, combinationValidators = []) {
+function validate(options, moduleName, customValidators = {}, combinationValidators = []) {
+  // TODO: issuing messages in this function looks very strange...
   {
     const messageCollector = { messages: [] };
-    const { error, throwWithError } = makeMessageFunction(null, messageCollector);
+    const { error, throwWithError } = makeMessageFunction(null, messageCollector, moduleName);
 
     for (const optionName of Object.keys(options)) {
       const optionValue = options[optionName];
@@ -142,7 +149,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
     throwWithError();
   }
 
-  const message = makeMessageFunction(null, options);
+  const message = makeMessageFunction(null, options, moduleName);
 
   for (const combinationValidatorName of combinationValidators.concat([ 'beta-no-test' ])) {
     const combinationValidator = allCombinationValidators[combinationValidatorName];
@@ -150,10 +157,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
       message[combinationValidator.severity]('invalid-option-combination', null, {}, combinationValidator.getMessage(options));
   }
 
-  // TODO: Replace with message.throwWithError():
-  // But be aware that it only throws with non-configurable errors and that this
-  // will lead to issues in test3. See #6037
-  handleMessages(undefined, options);
+  message.throwWithError();
 }
 /* eslint-enable jsdoc/no-undefined-types */
 

package/lib/backends.js

@@ -6,7 +6,6 @@
 const { transformForHanaWithCsn } = require('./transform/forHanaNew');
 const { compactModel, sortCsn } = require('./json/to-csn')
 const { toCdsSourceCsn } = require('./render/toCdl');
-const { toHdbcdsSource } = require('./render/toHdbcds');
 const { toSqlDdl } = require('./render/toSql');
 const { toRenameDdl } = require('./render/toRename');
 const { manageConstraints, listReferentialIntegrityViolations } = require('./render/manageConstraints');
@@ -19,85 +18,6 @@ const timetrace = require('./utils/timetrace');
 const { makeMessageFunction } = require('./base/messages');
 const { forEachDefinition } = require('./model/csnUtils');
 
-/**
- * Transform a CSN into HANA-compatible CDS source.
- * The following options control what is actually generated (see help above):
- *   options : {
- *     toHana.names
- *     toHana.src
- *     toHana.csn
- *   }
- * Options provided here are merged with (and take precedence over) options from 'model'.
- * If 'toHana.names' is not provided, 'quoted' is used.
- * If neither 'toHana.src' nor 'toHana.csn' are provided, the default is to generate only HANA CDS
- * source files.
- * If all provided options are part of 'toHana', the 'toHana' wrapper can be omitted.
- * The result object contains the generation results as follows (as enabled in 'options'):
- *   result : {
- *     csn               : the (compact) transformed CSN model
- *     hdbcds            : a dictionary of top-level artifact names, containing for each name 'X':
- *       <X>             : the HANA CDS source string of the artifact 'X'. Please note that the
- *                         name of 'X' may contain characters that are not legal for filenames on
- *                         all operating systems (e.g. ':', '\' or '/').
- *                         X reflects the naming policy set by toHana.names
- *   }
- * Throws a CompilationError on errors.
- *
- * @param {CSN.Model}   csn
- * @param {CSN.Options} [options]
- */
-function toHanaWithCsn(csn, options) {
-  timetrace.start('toHanaWithCsn');
-  // In case of API usage the options are in the 'options' argument
-  // put the OData specific options under the 'options.toHana' wrapper
-  // and leave the rest under 'options'
-  if (options && !options.toHana) {
-    _wrapRelevantOptionsForCmd(options, 'toHana');
-  }
-  // Provide defaults and merge options with those from model
-  options = mergeOptions({ toHana : getDefaultBackendOptions().toHana }, options);
-
-  // Provide something to generate if nothing else was given (conditional default)
-  if (!options.toHana.src && !options.toHana.csn) {
-    options.toHana.src = true;
-  }
-
-  const { warning } = makeMessageFunction(csn, options, 'to.hdbcds');
-
-  // Verify options
-  optionProcessor.verifyOptions(options, 'toHana', true).forEach(complaint => warning(null, null, `${complaint}`));
-
-  // Special case: For naming variant 'hdbcds' in combination with 'toHana' (and only there!), 'forHana'
-  // must leave namespaces, structs and associations alone.
-  if (options.toHana.names === 'hdbcds') {
-    options = mergeOptions(options, { forHana : { keepNamespaces: true, keepStructsAssocs: true } });
-  }
-
-  options = mergeOptions(options, { forHana: { dialect: 'hana' } }, { forHana : options.toHana });
-
-  // Prepare model for HANA (transferring the options to forHana, and setting 'dialect' to 'hana', because 'toHana' is only used for that)
-  let forHanaCsn = transformForHanaWithCsn(csn, options, 'to.hdbcds');
-
-  // Assemble result
-  let result = {};
-
-  if (options.toHana.src) {
-    if(options.testMode){
-      const sorted = sortCsn(forHanaCsn, options);
-      result = toHdbcdsSource(sorted, options);
-    } else {
-      result = toHdbcdsSource(forHanaCsn, options);
-    }
-  }
-
-  if (options.toHana.csn) {
-    result.csn = options.testMode ? sortCsn(forHanaCsn, options) : forHanaCsn;
-  }
-
-  timetrace.stop();
-  return result;
-}
-
 /**
  * Generate ODATA for `csn` using `options`.
  * The twin of the toOdata function but using CSN
@@ -603,7 +523,6 @@ function _wrapRelevantOptionsForCmd(options, command) {
 }
 
 module.exports = {
-  toHanaWithCsn,
   toOdataWithCsn,
   preparedCsnToEdmx,
   preparedCsnToEdmxAll,

package/lib/base/keywords.js

@@ -194,7 +194,7 @@ module.exports = {
     'OTHERS',
     'TIES',
   ],
-  // HANA keywords, used to warn in 'toSql' renderer with dialect 'hana' or in 'toHana' renderer (both with 'plain' names only)
+  // HANA keywords, used for smart quoting in to-hdi.plain
   // Taken from https://help.sap.com/viewer/7c78579ce9b14a669c1f3295b0d8ca16/Cloud/en-US/28bcd6af3eb6437892719f7c27a8a285.html
   // Better use keywords in ptime/query/parser/syntax/qp_keyword.cc minus those
   // in rule unreserved_keyword_column (=…_common - "CONSTRAINT") in
@@ -673,5 +673,35 @@ module.exports = {
     'WITHIN',
     'XMLTABLE',
     'YEAR'
-  ]  
+  ],
+  // HANA CDS keywords, used for smart quoting in to-hdbcds.plain
+  hdbcds: [
+    'ALL',                'ALTER',             'AS',
+    'BEFORE',             'BEGIN',             'BOTH',
+    'CASE',               'CHAR',              'CONDITION',
+    'CONNECT',            'CROSS',             'CUBE',
+    'CURRENT_CONNECTION', 'CURRENT_DATE',      'CURRENT_SCHEMA',
+    'CURRENT_TIME',       'CURRENT_TIMESTAMP', 'CURRENT_USER',
+    'CURRENT_UTCDATE',    'CURRENT_UTCTIME',   'CURRENT_UTCTIMESTAMP',
+    'CURRVAL',            'CURSOR',            'DECLARE',
+    'DISTINCT',           'ELSE',              'ELSEIF',
+    'ELSIF',              'END',               'EXCEPT',
+    'EXCEPTION',          'EXEC',              'FOR',
+    'FROM',               'FULL',              'GROUP',
+    'HAVING',             'IF',                'IN',
+    'INNER',              'INOUT',             'INTERSECT',
+    'INTO',               'IS',                'JOIN',
+    'LEADING',            'LEFT',              'LIMIT',
+    'LOOP',               'MINUS',             'NATURAL',
+    'NEXTVAL',            'NULL',              'ON',
+    'ORDER',              'OUT',               'OUTER',
+    'PRIOR',              'RETURN',            'RETURNS',
+    'REVERSE',            'RIGHT',             'ROLLUP',
+    'ROWID',              'SELECT',            'SET',
+    'SQL',                'START',             'SYSDATE',
+    'SYSTIME',            'SYSTIMESTAMP',      'SYSUUID',
+    'TOP',                'TRAILING',          'UNION',
+    'USING',              'VALUES',            'WHEN',
+    'WHERE',              'WHILE',             'WITH'
+  ]
 }

package/lib/base/message-registry.js

@@ -1,5 +1,33 @@
 // Central registry for messages.
 
+// `centralMessages` contains all details of a message-id except its standard texts
+// (`standardTexts` exists for that).  Only `severity` is required, all other
+// properties are optional.
+
+// The user can specify "severity wishes" via the option `severities`.  Errors
+// that don't have a `configurableFor` property cannot be reclassified by
+// users.  If a module is used that is _not_ listed in `configurableFor` (if it
+// is an array) property of the message then the message cannot be
+// reclassified.
+
+// We also allow `configurableFor` to have value `true` for errors which are
+// always configurable; useful for issues like deprecated syntax variants which
+// do not affect the compiler or CSN processors.  Temporarily, we also allow
+// value `deprecated` for errors which are only configurable if the option
+// `deprecated.downgradableErrors` is set.
+
+// Messages other than errors can always be reclassified by the user except if
+// the module is listed in the message's `errorFor` property.
+
+// __NEW__: If the future `poc` (proof of concept) or `sloppy` option is set,
+// the module name `compile` is added to all configurable messages, i.e. to all
+// `configurableFor` arrays.  (module `compile` includes all parsers and the
+// core compiler).  This allows creators of _non-productive models_ to
+// reclassify errors which usually cannot be reclassified, and continue the
+// compilation but has the side effect that the result may be unstable, hence
+// "sloppy": with an upcoming _minor_ version of the compiler, the compilation
+// might lead to an error anyway or the compiled CSN might look different.
+
 'use strict';
 
 /**
@@ -59,13 +87,15 @@ const centralMessages = {
   'param-default': { severity: 'Error', configurableFor: 'deprecated' }, // not supported yet
 
   'query-undefined-element': { severity: 'Error' },
+  'query-unexpected-assoc-hdbcds': { severity: 'Error' },
+  'query-unexpected-structure-hdbcds': { severity: 'Error' },
 
   'recalculated-localized': { severity: 'Info' }, // KEEP: Downgrade in lib/transform/translateAssocsToJoins.js
   'redirected-implicitly-ambiguous': { severity: 'Error', configurableFor: true }, // does not hurt us - TODO: ref-ambiguous-target
   'type-ambiguous-target': { severity: 'Warning' },
 
   'ref-autoexposed': { severity: 'Error', configurableFor: 'deprecated' },
-  'ref-undefined-art':    { severity: 'Error' }, // TODO: Remove if shared.js uses makeMessageFunction()
+  'ref-undefined-art':    { severity: 'Error' },
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
@@ -100,8 +130,12 @@ const centralMessages = {
   'unexpected-keys-for-composition': { severity: 'Error' }, // TODO: more than 30 chars
   'unmanaged-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
-  'odata-spec-violation-array-of-v2':  { severity: 'Warning' }, // more than 30 chars
-  'odata-spec-violation-constraints': { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-array':  { severity: 'Warning' }, // more than 30 chars
+  'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
+  'odata-spec-violation-type': { severity: 'Error', configurableFor: [ 'to.edmx' ] },
+  'odata-spec-violation-key-array':  { severity: 'Error' }, // more than 30 chars
+  'odata-spec-violation-key-null': { severity: 'Error' }, // more than 30 chars
+  'odata-spec-violation-key-type': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-property-name': { severity: 'Warning' }, // more than 30 chars
   'odata-spec-violation-namespace-name': { severity: 'Warning' }, // more than 30 chars
 };
@@ -191,6 +225,10 @@ const centralMessageTexts = {
   'expected-target': 'An entity or an aspect is expected here',
   'extend-columns': 'Artifact $(ART) can\'t be extended with columns, only projections can',
   'extend-repeated-intralayer': 'Unstable element order due to repeated extensions in same layer',
+
+  'query-unexpected-assoc-hdbcds': 'Publishing a managed association in a view is not possible for “hdbcds” naming mode',
+  'query-unexpected-structure-hdbcds': 'Publishing a structured element in a view is not possible for “hdbcds” naming mode',
+
   'ref-sloppy-type': 'A type or an element is expected here',
   'ref-sloppy-actionparam-type': 'A type, an element, or a service entity is expected here',
   'ref-sloppy-target': 'An entity or an aspect (not type) is expected here',
@@ -204,13 +242,29 @@ const centralMessageTexts = {
   },
 
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
-  'odata-spec-violation-array-of-v2': 'EDM $(LITERAL) must not have an attribute $(PROP) with the value $(NAME)',
-  'odata-spec-violation-param-v2' : 'Type of EDM FunctionImport Parameter must be an EDM SimpleType or ComplexType',
-  'odata-spec-violation-returns-v2': 'EDM FunctionImport must return EDM SimpleType, ComplexType, EntityType or a collection of one of these',
-  'odata-spec-violation-assoc-v2': 'EDM ComplexType $(NAME) must not contain an EDM NavigationProperty',
-  'odata-spec-violation-attribute': 'EDM Property $(NAME) has no attribute $(PROP)',
-  'odata-spec-violation-property-name': 'EDM Property $(NAME) must not have the same name as the declaring $(TYPE)',
 
+  // OData version dependent messages
+  'odata-spec-violation-array': 'Unexpected array type for $(API)',
+  'odata-spec-violation-param' : 'Expected parameter to be typed with either scalar or structured type for $(API)',
+  'odata-spec-violation-returns': 'Expected $(KIND) to return one or many values of scalar, complex, entity or view type for $(API)',
+  'odata-spec-violation-assoc': 'Unexpected association in structured type for $(API)',
+  'odata-spec-violation-constraints': 'Partial referential constraints produced for $(API)',
+  // version independent messages
+  'odata-spec-violation-key-array': {
+    std: 'Unexpected array type for element $(NAME)',
+    scalar: 'Unexpected array type'
+  },
+  'odata-spec-violation-key-null': {
+    std: 'Expected key element $(NAME) to be not nullable', // structured
+    scalar: 'Expected key element to be not nullable' // flat
+  },
+  'odata-spec-violation-key-type': {
+    std: 'Unexpected $(TYPE) mapped to $(ID) as type for key element $(NAME)', // structured
+    scalar: 'Unexpected $(TYPE) mapped to $(ID) as type for key element' // flat
+  },
+  'odata-spec-violation-type': 'Expected element to have a type',
+  'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(KIND)',
+  'odata-spec-violation-namespace': 'Expected service name not to be one of the reserved names $(NAMES)',
 }
 
 /**

package/lib/base/messages.js

@@ -1,5 +1,7 @@
 // Functions and classes for syntax messages
 
+// See internalDoc/ReportingMessages.md and lib/base/message-registry.js for details.
+
 'use strict';
 
 const term = require('../utils/term');
@@ -92,14 +94,17 @@ class CompilationError extends Error {
 
     /** @type {boolean} model */
     this.hasBeenReported = false; // TODO: remove this bin/cdsc.js specifics
-    // TODO: remove property `model`
+    // property `model` is only set with options.attachValidNames:
     Object.defineProperty( this, 'model', { value: model || undefined, configurable: true } );
   }
   toString() {                  // does not really help -> set message
     return this.message.includes('\n')
       ? this.message
-      : this.message + '\n' + this.errors.map( m => m.toString() ).join('\n');
+      : this.message + '\n' + this.messages.map( m => m.toString() ).join('\n');
   }
+  /**
+   * @deprecated Use `.messages` instead.
+   */
   get errors() {
     return this.messages;
   }
@@ -210,6 +215,7 @@ const severitySpecs = {
  * @returns {CSN.MessageSeverity}
  *
  * TODO: we should pass options as usual
+ * TODO: should be part of the returned function
  */
 function reclassifiedSeverity( id, severity, severities, moduleName, deprecatedDowngradable ) {
   const spec = centralMessages[id] || { severity };
@@ -294,6 +300,30 @@ function searchForLocation( model, path ) {
   return lastLocation;
 }
 
+/**
+ * Create the `message` functions to emit messages.
+ * See internalDoc/ReportingMessages.md for detail
+ *
+ * @example
+ * ```
+ *   const { createMessageFunctions } = require(‘../base/messages’);
+ *   function module( …, options ) {
+ *     const { message, info, throwWithError } = createMessageFunctions( options, moduleName );
+ *     // [...]
+ *     message( 'message-id', <location>, <text-arguments>, <severity>, <text> );
+ *     info( 'message-id', <location>, [<text-arguments>,] <text> );
+ *     // [...]
+ *     throwWithError();
+ *   }
+ * ```
+ * @param {CSN.Options} [options]
+ * @param {string} [moduleName]
+ * @param {object} [model=null] the CSN or XSN model, used for convenience
+ */
+function createMessageFunctions( options, moduleName, model = null ) {
+  return makeMessageFunction( model, options, moduleName, true );
+}
+
 /**
  * Create the `message` function to emit messages.
  *
@@ -312,8 +342,9 @@ function searchForLocation( model, path ) {
  * @param {object} model
  * @param {CSN.Options} [options]
  * @param {string} [moduleName]
+ * @param {boolean} [throwOnlyWithNew=false] behave like createMessageFunctions
  */
-function makeMessageFunction( model, options = model.options || {}, moduleName = null ) {
+function makeMessageFunction( model, options, moduleName = null, throwOnlyWithNew = false ) {
   // ensure message consistency during runtime with --test-mode
   if (options.testMode)
     _check$Init( options );
@@ -327,11 +358,12 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
    *
    * @type {CSN.Message[]}
    */
-  let messages = options && options.messages || [];
-
+  let messages = options.messages || [];
+  let hasNewError = false;
   return {
-    message, error, warning, info, debug,
-    messages, throwWithError, callTransparently
+    message, error, warning, info, debug, messages,
+    throwWithError: (throwOnlyWithNew ? throwWithError : throwWithAnyError),
+    callTransparently, moduleName,
   };
 
   function _message(id, location, textOrArguments, severity, texts = null) {
@@ -342,7 +374,6 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
       texts = { std: textOrArguments };
       textOrArguments = {};
     }
-
     if (id) {
       if (options.testMode && !options.$recompile)
         _check$Consistency( id, moduleName, severity, texts, options )
@@ -360,6 +391,8 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
       msg.$location.address = { definition };
 
     messages.push( msg );
+    hasNewError = hasNewError || msg.severity === 'Error' &&
+      !(options.testMode && msg.messageId && isDowngradable( msg.messageId, moduleName ));
     if (!hasMessageArray)
       console.error( messageString( msg ) );
     return msg;
@@ -488,6 +521,11 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
     return _message(id, location, textOrArguments, 'Debug', texts);
   }
 
+  function throwWithError() {
+    if (hasNewError)
+      throw new CompilationError( messages, options.attachValidNames && model );
+  }
+
   /**
    * Throws a CompilationError exception if there is at least one error message
    * in the model's messages after reclassifying existing messages according to
@@ -495,22 +533,20 @@ function makeMessageFunction( model, options = model.options || {}, moduleName =
    * If `--test-mode` is enabled, this function will only throw if the
    * error *cannot* be downgraded to a warning.  This is done to ensure that
    * developers do not rely on certain errors leading to an exception.
-   *
-   * @param {CSN.Message[]} [msgs] Which messages to check for. Default: The ones of
-   *                               this makeMessageFunction() scope.
    */
-  function throwWithError(msgs = messages) {
-    if (!msgs || !msgs.length)
+  function throwWithAnyError() {
+    if (!messages || !messages.length)
       return;
-    reclassifyMessagesForModule(msgs, severities, moduleName); // TODO: no, at the beginning of the module
+    reclassifyMessagesForModule( messages, severities, moduleName ); // TODO: no, at the beginning of the module
     const hasError = options.testMode ? hasNonDowngradableErrors : hasErrors;
-    if (hasError( msgs, moduleName ))
-      throw new CompilationError( msgs, options.attachValidNames && model );
+    if (hasError( messages, moduleName ))
+      throw new CompilationError( messages, options.attachValidNames && model );
   }
 
   /**
    * Collects all messages during the call of the callback function instead of
    * storing them in the model. Returns the collected messages.
+   * Not yet in use.
    *
    * @param {Function} callback
    * @param  {...any} args
@@ -613,6 +649,8 @@ const paramsTransform = {
   // more complex convenience:
   names: transformManyWith( quoted ),
   number: n => n,
+  line: l => l,
+  col: c => c,
   literal: l => l,
   art: transformArg,
   service: transformArg,
@@ -993,12 +1031,12 @@ function homeSortName( { home, messageId } ) {
 
 /**
  * Removes duplicate messages from the given messages array without destroying
- * references to the array.
+ * references to the array, i.e. removes them in-place.
  *
- * Does NOT keep the original order!
+ * _Note_: Does NOT keep the original order!
  *
  * Two messages are the same if they have the same message hash. See messageHash().
- * If one of the two is more precise then it replaces the other.
+ * If one of the two is more precise, then it replaces the other.
  * A message is more precise if it is contained in the other or if
  * the first does not have an endLine/endCol.
  *
@@ -1197,7 +1235,10 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
         if (!csnPath[index + 1]) {
           result += select();
         }
-        else if (queryProps.includes(csnPath[index + 1]) && !csnPath[index + 2]) {
+        // only print last query prop for paths like
+        // [... 'query', 'SELECT', 'from', 'SELECT', 'elements', 'struct'] -> select:2/element:"struct"
+        // no from in the semantic location in this case
+        else if (queryProps.includes(csnPath[index + 1]) && (!csnPath[index + 2] || query.isOnlySelect)) {
           const clause = csnPath[index + 1];
           result += select();
           result += `/${ clause }`;
@@ -1266,7 +1307,7 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
         if (currentThing.as)
           result += `:${ _quoted(currentThing.as) }`;
         else
-          result += inRef ? `:${ _quoted(currentThing) }` : currentThing.ref ? `:${ _quoted(currentThing.ref.join('.')) }` : '';
+          result += inRef ? `:${ _quoted(currentThing) }` : currentThing.ref ? `:${ _quoted(currentThing.ref.map(r => r.id ? r.id : r).join('.')) }` : '';
 
         break;
       }
@@ -1380,6 +1421,7 @@ module.exports = {
   messageStringMultiline,
   messageContext,
   searchName,
+  createMessageFunctions,
   makeMessageFunction,
   artName,
   handleMessages,

package/lib/base/model.js

@@ -19,7 +19,6 @@ const queryOps = {
  */
 const availableBetaFlags = {
   // enabled by --beta-mode
-  keylessManagedAssoc: true,
   foreignKeyConstraints: true,
   toRename: true,
   addTextsLanguageAssoc: true,
@@ -28,9 +27,9 @@ const availableBetaFlags = {
   mapAssocToJoinCardinality: true,
   ignoreAssocPublishingInUnion: true,
   nestedProjections: true,
+  enableUniversalCsn: true,
+  windowFunctions: true,
   // disabled by --beta-mode
-  pretransformedCSN: false,
-  renderSQL: false,
   nestedServices: false,
 };
 

package/lib/checks/defaultValues.js

@@ -35,8 +35,33 @@ function validateDefaultValues(member, memberName, prop, path) {
  * @param {CSN.Path} path Path to the member
  */
 function rejectParamDefaultsInHanaCds(member, memberName, prop, path) {
-  if (member.default && prop === 'params' && this.options.toHana)
+  if (member.default && prop === 'params' && this.options.transformation === 'hdbcds')
     this.error(null, path, 'Parameter default values are not supported in SAP HANA CDS');
 }
 
-module.exports = { validateDefaultValues, rejectParamDefaultsInHanaCds };
+/**
+ * For HANA CDS, we render a default for a mixin if the projected entity contains
+ * a derived association with a default defined on it. This leads to a deployment error
+ * and should be warned about.
+ *
+ * @param {CSN.Element} member Member to validate
+ * @param {string} memberName Name of the member
+ * @param {string} prop Property being looped over
+ * @param {CSN.Path} path Path to the member
+ */
+function warnAboutDefaultOnAssociationForHanaCds(member, memberName, prop, path) {
+  const art = this.csn.definitions[path[1]];
+  if (!art.query && this.options.transformation === 'hdbcds' && member.target && member.default) {
+    this.warning(null, path, { '#': member._type.type === 'cds.Association' ? 'std' : 'comp' },
+                 {
+                   std: 'Unexpected default defined on association',
+                   comp: 'Unexpected default defined on composition',
+                 });
+  }
+}
+
+module.exports = {
+  validateDefaultValues,
+  rejectParamDefaultsInHanaCds,
+  warnAboutDefaultOnAssociationForHanaCds,
+};

package/lib/checks/elements.js

@@ -2,7 +2,6 @@
 
 const { forEachMember, forEachMemberRecursively } = require('../model/csnUtils');
 const { isGeoTypeName } = require('../compiler/builtins');
-const { isBetaEnabled } = require('../base/model');
 
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
@@ -103,15 +102,11 @@ function checkVirtualElement(member) {
  * @param {CSN.Artifact} art The artifact
  */
 function checkManagedAssoc(art) {
-  forEachMemberRecursively(art, (member, memberName) => {
+  forEachMemberRecursively(art, (member) => {
     if (this.csnUtils.isAssocOrComposition(member.type) &&
         !isManagedComposition.bind(this)(member)) {
       if (member.on)
         return;
-      if (!isBetaEnabled(this.options, 'keylessManagedAssoc') && (!member.keys || member.keys.length === 0)) {
-        this.error(null, member.$path, { name: memberName },
-                   `The managed association $(NAME) has no foreign keys`);
-      }
       const max = member.cardinality && member.cardinality.max;
       if (max === '*' || Number(max) > 1) {
         const isNoDb = art['@cds.persistence.skip'] || art['@cds.persistence.exists'];

package/lib/checks/foreignKeys.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!
 
 /**
@@ -20,17 +18,13 @@ function validateForeignKeys(member) {
 
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem) => {
-    let elementCount = 0;
     for (let i = 0; i < mem.keys.length; i++) {
       if (mem.keys[i].ref) {
         if (!mem.keys[i]._art)
           continue;
         // eslint-disable-next-line no-use-before-define
         checkForItems(mem.keys[i]._art);
-        elementCount++;
       }
-      if (!isBetaEnabled(this.options, 'keylessManagedAssoc') && elementCount === 0)
-        this.error(null, member.$path, 'Empty structured types/elements must not be used as foreign keys');
     }
   };
 

package/lib/checks/managedWithoutKeys.js

@@ -0,0 +1,17 @@
+'use strict';
+
+
+/**
+ * Trigger a recompilation in case of an association without .keys and without .on
+ *
+ * @param {CSN.Element} member the element to be checked
+ * @param {string} memberName the elements name
+ * @param {string} prop which kind of member are we looking at -> only prop "elements"
+ */
+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.');
+  }
+}
+
+module.exports = managedWithoutKeys;