@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/base/dictionaries.js

@@ -28,6 +28,7 @@ function dictAdd( dict, name, entry, duplicateCallback ) {
 }
 
 function dictForEach( dict, callback ) {
+  // TODO: probably define an extra dictForEachArray()
   for (const name in dict) {
     const entry = dict[name];
     if (Array.isArray(entry)) {
@@ -35,7 +36,7 @@ function dictForEach( dict, callback ) {
     }
     else {
       callback( entry );
-      if (Array.isArray(entry.$duplicates))
+      if (Array.isArray( entry.$duplicates ))
         entry.$duplicates.forEach( callback );
     }
   }

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' },
@@ -88,6 +118,7 @@ const centralMessages = {
   'syntax-anno-after-params': { severity: 'Error', configurableFor: true }, // does not hurt
   'syntax-anno-after-struct': { severity: 'Error', configurableFor: true }, // does not hurt
   'syntax-csn-expected-cardinality': { severity: 'Error' }, // TODO: more than 30 chars
+  'syntax-csn-expected-length': { severity: 'Error' },
   'syntax-csn-expected-translation': { severity: 'Error' }, // TODO: more than 30 chars
   'syntax-csn-required-subproperty': { severity: 'Error' }, // TODO: more than 30 chars
   'syntax-csn-unexpected-property': { severity: 'Error', configurableFor: true }, // is the removed
@@ -100,8 +131,13 @@ 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-no-key':  { severity: 'Warning' },
+  '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
 };
@@ -126,6 +162,11 @@ const centralMessageTexts = {
     $tableImplicit: 'The resulting table alias starts with $(NAME) and might shadow a special variable - specify another name with $(KEYWORD)',
     mixin: 'A mixin name starting with $(NAME) might shadow a special variable - replace by another name' ,
   },
+  'syntax-csn-expected-length': {
+    std: 'Expected array in $(PROP) to have at least $(N) items',
+    one: 'Expected array in $(PROP) to have at least one item',
+    suffix: 'With sibling property $(OTHERPROP), expected array in $(PROP) to have at least one item',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -169,13 +210,13 @@ const centralMessageTexts = {
   'duplicate-definition': {
     std: 'Duplicate definition of $(NAME)',
     absolute: 'Duplicate definition of artifact $(NAME)',
-    namespace: 'Other definition blocks $(NAME) for namespace name',
+    annotation: 'Duplicate definition of annotation vocabulary $(NAME)',
     element: 'Duplicate definition of element $(NAME)',
     enum: 'Duplicate definition of enum $(NAME)',
     key: 'Duplicate definition of key $(NAME)',
     action: 'Duplicate definition of action or function $(NAME)',
     param: 'Duplicate definition of parameter $(NAME)',
-    $tableAlias: 'Duplicate definition of table alias or mixin $(NAME)',
+    alias: 'Duplicate definition of table alias or mixin $(NAME)',
   },
 
   // TODO: rename to ref-expected-XYZ
@@ -191,6 +232,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 +249,30 @@ 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-no-key': 'Expected entity to have a primary key',
+  '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,8 +1,10 @@
 // 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');
+const { term } = require('../utils/term');
 const { locationString } = require('./location');
 const { isDeprecatedEnabled } = require('./model');
 const { centralMessages, centralMessageTexts } = require('./message-registry');
@@ -13,6 +15,8 @@ const { analyseCsnPath, traverseQuery } = require('../model/csnRefs');
 const fs = require('fs');
 const path = require('path');
 
+// term instance for messages
+const colorTerm = term();
 
 // Functions ensuring message consistency during runtime with --test-mode
 
@@ -92,14 +96,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 +217,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 +302,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 +344,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 +360,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 +376,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 +393,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 +523,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 +535,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 +651,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,
@@ -815,19 +855,26 @@ function messageHash(msg) {
  *
  * Example:
  * ```txt
- * Error[message-id]: Can't find type `nu` in this scope (in entity:“E”/element:“e”)
+ * Error[message-id]: Can't find type `nu` in this scope
  *    |
- *   <source>.cds:3:11, at entity:“E”
+ *   <source>.cds:3:11, at entity:“E”/element:“e”
  * ```
+ *
  * @param {CSN.Message} err
  * @param {object} [config = {}]
  * @param {boolean} [config.normalizeFilename] Replace windows `\` with forward slashes `/`.
  * @param {boolean} [config.noMessageId]
  * @param {boolean} [config.hintExplanation] If true, messages with explanations will get a "…" marker.
- * @param {boolean} [config.withLineSpacer] If true, an additional line (with `|`) will be inserted between message and location.
+ * @param {boolean} [config.withLineSpacer]  If true, an additional line (with `|`) will be inserted between message and location.
+ * @param {boolean | 'auto'} [config.color]  If true, ANSI escape codes will be used for coloring the severity.  If false, no
+ *                                           coloring will be used.  If 'auto', we will decide based on certain factors such
+ *                                           as whether the shell is a TTY and whether the environment variable 'NO_COLOR' is
+ *                                           unset.
  * @returns {string}
  */
 function messageStringMultiline( err, config = {} ) {
+  colorTerm.changeColorMode(config ? config.color : 'auto');
+
   const explainHelp = (config.hintExplanation && hasMessageExplanation(err.messageId)) ? '…' : '';
   const msgId = (err.messageId && !config.noMessageId) ? `[${ err.messageId }${ explainHelp }]` : '';
   const home = !err.home ? '' : ('at ' + err.home);
@@ -840,7 +887,7 @@ function messageStringMultiline( err, config = {} ) {
       location += ', '
   }
   else if (!home)
-    return term.asSeverity(severity, severity + msgId) + ' ' + err.message;
+    return colorTerm.severity(severity, severity + msgId) + ' ' + err.message;
 
   let lineSpacer = '';
   if (config.withLineSpacer) {
@@ -848,8 +895,7 @@ function messageStringMultiline( err, config = {} ) {
     lineSpacer = `\n  ${ ' '.repeat( additionalIndent ) }|`;
   }
 
-  // TODO: use ':' before text
-  return term.asSeverity(severity, severity + msgId) + ': ' + err.message + lineSpacer + '\n  ' + location + home;
+  return colorTerm.severity(severity, severity + msgId) + ': ' + err.message + lineSpacer + '\n  ' + location + home;
 }
 
 /**
@@ -863,9 +909,15 @@ function messageStringMultiline( err, config = {} ) {
  * @param {string[]} sourceLines The source code split up into lines, e.g. by `splitLines(src)`
  *                               from `lib/utils/file.js`
  * @param {CSN.Message} err Error object containing all details like line, message, etc.
+ * @param {object} [config = {}]
+ * @param {boolean | 'auto'} [config.color] If true, ANSI escape codes will be used for coloring the `^`.  If false, no
+ *                                          coloring will be used.  If 'auto', we will decide based on certain factors such
+ *                                          as whether the shell is a TTY and whether the environment variable 'NO_COLOR' is
+ *                                          unset.
  * @returns {string}
  */
-function messageContext(sourceLines, err) {
+function messageContext(sourceLines, err, config) {
+  colorTerm.changeColorMode(config ? config.color : 'auto');
   const MAX_COL_LENGTH = 100;
 
   const loc = err.$location;
@@ -917,7 +969,7 @@ function messageContext(sourceLines, err) {
     // Indicate that the error is further to the right.
     if (endColumn === MAX_COL_LENGTH)
       highlighter = highlighter.replace('  ^', '..^');
-    msg += indent + '| ' + term.asSeverity(severity, highlighter);
+    msg += indent + '| ' + colorTerm.severity(severity, highlighter);
 
   } else if (maxLine !== endLine) {
     // error spans more lines which we don't print
@@ -993,12 +1045,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 +1249,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 +1321,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 +1435,7 @@ module.exports = {
   messageStringMultiline,
   messageContext,
   searchName,
+  createMessageFunctions,
   makeMessageFunction,
   artName,
   handleMessages,

package/lib/base/model.js

@@ -19,8 +19,6 @@ const queryOps = {
  */
 const availableBetaFlags = {
   // enabled by --beta-mode
-  keylessManagedAssoc: true,
-  foreignKeyConstraints: true,
   toRename: true,
   addTextsLanguageAssoc: true,
   assocsWithParams: true,
@@ -28,9 +26,8 @@ const availableBetaFlags = {
   mapAssocToJoinCardinality: true,
   ignoreAssocPublishingInUnion: true,
   nestedProjections: true,
+  enableUniversalCsn: true,
   // disabled by --beta-mode
-  pretransformedCSN: false,
-  renderSQL: false,
   nestedServices: false,
 };
 
@@ -56,15 +53,18 @@ function isBetaEnabled( options, feature ) {
 /**
  * Test for deprecated feature, stored in option `deprecated`.
  * With that, the value of `deprecated` is a dictionary of feature=>Boolean.
+ * If no `feature` is provided, checks if any deprecated option is set.
  *
  * Please do not move this function to the "option processor" code.
  *
  * @param {object} options Options
- * @param {string} feature Feature to check for
+ * @param {string} [feature] Feature to check for
  * @returns {boolean}
  */
-function isDeprecatedEnabled( options, feature ) {
+function isDeprecatedEnabled( options, feature = null ) {
   const { deprecated } = options;
+  if(!feature)
+    return !!deprecated;
   return deprecated && typeof deprecated === 'object' && deprecated[feature];
 }