@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/api/options.js

@@ -15,6 +15,7 @@ const publicOptionsNewAPI = [
   'severities',
   'messages',
   'withLocations',
+  'defaultBinaryLength',
   'defaultStringLength',
   'csnFlavor',
   // DB
@@ -23,7 +24,8 @@ const publicOptionsNewAPI = [
   'sqlChangeMode',
   'allowCsnDowngrade',
   'joinfk',
-  'magicVars',
+  'magicVars', // deprecated
+  'variableReplacements',
   // ODATA
   'odataVersion',
   'odataFormat',
@@ -47,9 +49,11 @@ const privateOptions = [
   'traceParserAmb',
   'testMode',
   'testSortCsn',
-  'constraintsNotEnforced',
-  'constraintsNotValidated',
-  'skipDbConstraints',
+  'constraintsAsAlter',
+  'integrityNotEnforced',
+  'integrityNotValidated',
+  'assertIntegrity',
+  'assertIntegrityType',
   'noRecompile',
   'internalMsg',
   'disableHanaComments',      // in case of issues with hana comment rendering
@@ -80,9 +84,9 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
   for (const name of overallOptions) {
     // Ensure that arrays are not passed as a reference!
     // This caused issues with the way messages are handled in processMessages
-    if (Array.isArray(input[name]) && inputOptionNames.indexOf(name) !== -1)
+    if (Array.isArray(input[name]) && inputOptionNames.includes(name))
       options[name] = [ ...input[name] ];
-    else if (inputOptionNames.indexOf(name) !== -1)
+    else if (inputOptionNames.includes(name))
       options[name] = input[name];
   }
 
@@ -109,6 +113,10 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
     mapToOldNames(optionName, optionValue);
   }
 
+  // Convenience for $user -> $user.id replacement
+  if (options.variableReplacements && options.variableReplacements.$user && typeof options.variableReplacements.$user === 'string')
+    options.variableReplacements.$user = { id: options.variableReplacements.$user };
+
   /**
    * Map a new-style option to it's old format
    *
@@ -130,6 +138,7 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
       case 'sqlMapping':
         options.names = optionValue;
         break;
+      // No need to remap variableReplacements here - we use the new mechanism with that directly
       case 'magicVars':
         if (optionValue.user)
           options.user = optionValue.user;
@@ -149,7 +158,7 @@ module.exports = {
     sql: (options) => {
       const hardOptions = { src: 'sql' };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'plain' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ], 'to.sql');
+      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming', 'constraints-as-alter-sqlite' ], 'to.sql');
 
       const result = Object.assign({}, processed);
       result.toSql = Object.assign({}, processed);
@@ -157,7 +166,7 @@ module.exports = {
       return result;
     },
     hdi: (options) => {
-      const hardOptions = { src: 'hdi' };
+      const hardOptions = { src: 'hdi', constraintsAsAlter: false };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
       const processed = translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdi');
 

package/lib/api/validate.js

@@ -25,13 +25,14 @@ const booleanValidator = {
 /**
  * Generate a Validator that validates that the
  * input is a string and one of the available options.
+ * The validation of the option values is case-insensitive.
  *
  * @param {any} availableValues Available values
  * @returns {Validator} Return a validator for a string in an expected range
  */
 function generateStringValidator(availableValues) {
   return {
-    validate: val => typeof val === 'string' && availableValues.indexOf(val) !== -1,
+    validate: val => typeof val === 'string' && availableValues.some( av => av.toLowerCase() === val.toLowerCase() ),
     expected: (val) => {
       return typeof val !== 'string' ? 'type string' : availableValues.join(', ');
     },
@@ -70,6 +71,14 @@ const validators = {
       return val === null ? val : `type ${ typeof val }`;
     },
   },
+  // TODO: Maybe do a deep validation of the whole object with leafs?
+  variableReplacements: {
+    validate: val => val !== null && typeof val === 'object' && !Array.isArray(val),
+    expected: () => 'type object',
+    found: (val) => {
+      return val === null ? val : `type ${ typeof val }`;
+    },
+  },
   messages: {
     validate: val => Array.isArray(val),
     expected: () => 'type array',
@@ -89,10 +98,17 @@ const validators = {
     expected: () => 'type array of string',
     found: val => `type ${ typeof val }`,
   },
+  defaultBinaryLength: {
+    validate: val => !Number.isNaN(Number(val)) && Number.isInteger(Number.parseFloat(val)),
+
+    expected: () => 'Integer literal',
+    found: val => `${ (!Number.isNaN(Number(val)) ? val : 'Not a Number') }`,
+  },
   defaultStringLength: {
-    validate: val => Number.isInteger(val),
+    validate: val => !Number.isNaN(Number(val)) && Number.isInteger(Number.parseFloat(val)),
+
     expected: () => 'Integer literal',
-    found: val => `type ${ typeof val }`,
+    found: val => `${ (!Number.isNaN(Number(val)) ? val : 'Not a Number') }`,
   },
   csnFlavor: {
     validate: val => typeof val === 'string',
@@ -102,6 +118,12 @@ const validators = {
   dictionaryPrototype: {
     validate: () => true,
   },
+  assertIntegrity: {
+    validate: val => typeof val === 'string' && val === 'individual' || typeof val === 'boolean',
+    expected: () => 'a boolean or a string with value \'individual\'',
+    found: val => (typeof val === 'string' ? val : `type ${ typeof val }`),
+  },
+  assertIntegrityType: generateStringValidator([ 'DB', 'RT' ]),
 };
 
 const allCombinationValidators = {
@@ -120,6 +142,11 @@ const allCombinationValidators = {
     severity: 'warning',
     getMessage: () => 'Option "beta" was used. This option should not be used in productive scenarios!',
   },
+  'constraints-as-alter-sqlite': {
+    validate: options => options.constraintsAsAlter && options.sqlDialect && options.sqlDialect === 'sqlite',
+    severity: 'warning',
+    getMessage: options => `Option 'constraintsAsAlter' is ignored for sqlDialect '${ options.sqlDialect }'`,
+  },
 };
 /* eslint-disable jsdoc/no-undefined-types */
 /**

package/lib/backends.js

@@ -14,7 +14,7 @@ const { csn2edm, csn2edmAll } = require('./edm/csn2edm');
 const { mergeOptions }  = require('./model/csnUtils');
 const { isBetaEnabled } = require('./base/model');
 const { optionProcessor } = require('./optionProcessor')
-const timetrace = require('./utils/timetrace');
+const { timetrace } = require('./utils/timetrace');
 const { makeMessageFunction } = require('./base/messages');
 const { forEachDefinition } = require('./model/csnUtils');
 
@@ -92,9 +92,9 @@ function toOdataWithCsn(csn, options) {
 // Generate edmx for given 'service' based on 'csn' (new-style compact, already prepared for OData)
 // using 'options'
 function preparedCsnToEdmx(csn, service, options) {
-  let edmx = csn2edm(csn, service, options).toXML('all');
+  const e = csn2edm(csn, service, options)
   return {
-    edmx,
+    edmx: (e ? e.toXML('all') : undefined)
   };
 }
 
@@ -115,9 +115,9 @@ function preparedCsnToEdmxAll(csn, options) {
 function preparedCsnToEdm(csn, service, options) {
   // Merge options; override OData version as edm json is always v4
   options = mergeOptions(options, { toOdata : { version : 'v4' }});
-  const edmj = csn2edm(csn, service, options).toJSON();
+  const e = csn2edm(csn, service, options);
   return {
-    edmj,
+    edmj: (e ? e.toJSON() : undefined)
   };
 }
 
@@ -303,9 +303,9 @@ function transformSQLOptions(model, options) {
     }
     // move the locale option(if provided) under user.locale
     if (options.locale) {
-      options.user
+      options.user = options.user
         ? Object.assign(options.user, { locale: options.locale })
-        : options.user = { locale: options.locale };
+        : { locale: options.locale };
       delete options.locale;
     }
   }
@@ -395,19 +395,14 @@ function toRenameWithCsn(csn, options) {
   });
 
   // Assemble result
-  let result = {
+  return {
     rename : toRenameDdl(forHanaCsn, options),
     options
   };
-
-  return result;
 }
 
 function alterConstraintsWithCsn(csn, options) {
   const { error } = makeMessageFunction(csn, options, 'manageConstraints');
-  // Requires beta mode
-  if (!isBetaEnabled(options, 'foreignKeyConstraints'))
-    error(null, null, 'ALTER TABLE statements for adding/modifying referential constraints are only available in beta mode');
 
   const {
     drop, alter, names, src, violations
@@ -420,6 +415,10 @@ function alterConstraintsWithCsn(csn, options) {
     dialect: 'hana',
     names: names || 'plain'
   }
+
+  // Of course we want the database constraints
+  options.assertIntegrityType = 'DB';
+
   const transformedOptions = transformSQLOptions(csn, options);
   const mergedOptions = mergeOptions(transformedOptions.options, { forHana : transformedOptions.forHanaOptions });
   const forSqlCsn = transformForHanaWithCsn(csn, mergedOptions, 'to.sql');

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

@@ -11,7 +11,7 @@ module.exports = {
     'DISTINCT',
     'EXISTS',
     'EXTRACT',
-    'FALSE',
+    'FALSE', // boolean
     'FROM',
     'IN',
     'KEY',
@@ -22,8 +22,9 @@ module.exports = {
     'ON',
     'SELECT',
     'SOME',
+    'WHEN',
     'TRIM',
-    'TRUE',
+    'TRUE', // boolean
     'WHERE',
     'WITH',
   ],

package/lib/base/message-registry.js

@@ -42,6 +42,10 @@ const centralMessages = {
   'anno-definition':        { severity: 'Warning' },
   'anno-duplicate':         { severity: 'Error', configurableFor: true }, // does not hurt us
   'anno-duplicate-unrelated-layer': { severity: 'Error', configurableFor: true }, // does not hurt us
+  'anno-invalid-sql-element': { severity: 'Error'},  // @sql.prepend/append
+  'anno-invalid-sql-struct': { severity: 'Error'},  // @sql.prepend/append
+  'anno-invalid-sql-view': { severity: 'Error' },  // @sql.prepend/append
+  'anno-invalid-sql-view-element': { severity: 'Error'},  // @sql.prepend/append
   'anno-undefined-action':  { severity: 'Info' },
   'anno-undefined-art':     { severity: 'Info' }, // for annotate statement (for CDL path root)
   'anno-undefined-def':     { severity: 'Info' }, // for annotate statement (for CSN or CDL path cont)
@@ -60,7 +64,6 @@ const centralMessages = {
 
   'expr-no-filter': { severity: 'Error', configurableFor: 'deprecated' },
 
-  'empty-entity': { severity: 'Info', errorFor: [ 'to.hdbcds', 'to.sql', 'to.rename' ] },
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
   // Structured types were warned about but made CSN un-recompilable.
@@ -69,7 +72,7 @@ const centralMessages = {
   // TODO: rename to ref-expected-XYZ
   'expected-type': { severity: 'Error' },
   'ref-sloppy-type': { severity: 'Error' },
-  'ref-invalid-typeof': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: make it non-config
+  'type-unexpected-typeof': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: make it non-config
   'expected-actionparam-type': { severity: 'Error' },
   'ref-sloppy-actionparam-type': { severity: 'Error' },
   'expected-event-type': { severity: 'Error' },
@@ -89,6 +92,7 @@ const centralMessages = {
   'query-undefined-element': { severity: 'Error' },
   'query-unexpected-assoc-hdbcds': { severity: 'Error' },
   'query-unexpected-structure-hdbcds': { severity: 'Error' },
+  'query-ignoring-param-nullability': { severity: 'Info' },
 
   '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
@@ -99,6 +103,7 @@ const centralMessages = {
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
+  'ref-unknown-var': { severity: 'Info' },
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: true }, // does not hurt us
   'ref-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
@@ -118,6 +123,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
@@ -125,14 +131,22 @@ const centralMessages = {
   'syntax-fragile-alias': { severity: 'Error', configurableFor: true },
   'syntax-fragile-ident': { severity: 'Error', configurableFor: true },
 
+  'syntax-invalid-text-block' : { severity: 'Error' },
+  'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
+  'syntax-invalid-escape': { severity: 'Error' },
+  'syntax-missing-escape': { severity: 'Error' },
+
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
 
+  'def-missing-element': { severity: 'Error' },
+
   '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':  { 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
@@ -143,7 +157,7 @@ const centralMessages = {
 // For messageIds, where no text has been provided via code (central def)
 const centralMessageTexts = {
   'anno-mismatched-ellipsis': 'An array with $(CODE) can only be used if there is an assignment below with an array value',
-  'anno-unexpected-ellipsis': 'Unexpected $(CODE) in annotation assignment',
+  'anno-unexpected-ellipsis': 'No base annotation available to apply $(CODE)',
   'missing-type-parameter': 'Missing value for type parameter $(NAME) in reference to type $(ID)',
   'syntax-csn-expected-object': 'Expected object for property $(PROP)',
   'syntax-csn-expected-column': 'Expected object or string \'*\' for property $(PROP)',
@@ -160,6 +174,27 @@ 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',
+  },
+  'syntax-invalid-text-block': 'Missing newline in text block',
+  'syntax-unknown-escape': 'Unknown escape sequence $(CODE)',
+  'syntax-invalid-escape': {
+    std: 'Invalid escape sequence $(CODE)',
+    octal: 'Octal escape sequences are not supported. Use unicode escapes instead',
+    whitespace: 'Unknown escape sequence: Can\'t escape whitespace',
+    codepoint: 'Undefined code-point for $(CODE)',
+    'unicode-hex': 'Expected hexadecimal numbers for unicode escape but found $(CODE)',
+    'hex-count': 'Expected $(NUMBER) hexadecimal numbers for escape sequence but found $(CODE)',
+    'unicode-brace': 'Missing closing brace for unicode escape sequence',
+    'language-identifier': 'Escape sequences in text-block\'s language identifier are not allowed',
+  },
+  'syntax-missing-escape':  {
+    std: 'Missing escape. Replace $(CODE) with $(NEWCODE)',
+    placeholder: 'Placeholders are not supported. Replace $(CODE) with $(NEWCODE)',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -171,17 +206,20 @@ const centralMessageTexts = {
     std: 'Element $(ART) has not been found',
     element: 'Artifact $(ART) has no element $(MEMBER)'
   },
+  'ref-unknown-var': {
+    std: 'Replacement $(ID) not found'
+  },
   'ref-rejected-on': {
     std: 'Do not refer to a artefact like $(ID) in the explicit ON of a redirection', // Not used
     mixin: 'Do not refer to a mixin like $(ID) in the explicit ON of a redirection',
     alias: 'Do not refer to a source element (via table alias $(ID)) in the explicit ON of a redirection',
   },
-  'ref-invalid-typeof': {
-    std: 'Do not use $(KEYWORD) for the type reference here',
-    type: 'Do not use $(KEYWORD) for the type of a type',
-    event: 'Do not use $(KEYWORD) for the type of an event',
-    param: 'Do not use $(KEYWORD) for the type of a parameter',
-    select: 'Do not use $(KEYWORD) for type references in queries',
+  'type-unexpected-typeof': {
+    std: 'Unexpected $(KEYWORD) for the type reference here',
+    type: 'Unexpected $(KEYWORD) in type of a type definition',
+    event: 'Unexpected $(KEYWORD) for the type of an event',
+    param: 'Unexpected $(KEYWORD) for the type of a parameter definition',
+    select: 'Unexpected $(KEYWORD) for type references in queries',
   },
   'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
   'anno-undefined-def': 'Artifact $(ART) has not been found',
@@ -200,16 +238,21 @@ const centralMessageTexts = {
     param: 'Artifact $(ART) has no parameter $(MEMBER)'
   },
 
+  'def-missing-element': {
+    std: 'Expecting entity to have at least one non-virtual element',
+    view: 'Expecting view to have at least one non-virtual element'
+  },
+
   '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
@@ -228,6 +271,10 @@ const centralMessageTexts = {
 
   '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',
+  'query-ignoring-param-nullability': {
+    std: 'Ignoring nullability constraint on parameter when generating SAP HANA CDS view',
+    sql: 'Ignoring nullability constraint on parameter when generating SQL view'
+  },
 
   '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',
@@ -262,9 +309,15 @@ const centralMessageTexts = {
     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)',
+  // Other odata/edm errors
+  'odata-definition-exists': {
+    std: 'Entity can\'t be created due to name collision with existing definition $(NAME)',
+    proxy: 'No proxy entity created due to name collision with existing definition $(NAME) of kind $(KIND)'
+  }
 }
 
 /**

package/lib/base/messages.js

@@ -4,7 +4,7 @@
 
 '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');
@@ -15,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
 
@@ -670,13 +672,16 @@ function ignoreTextTransform() {
 
 function transformManyWith( t, sorted ) {
   return function transformMany( many, r, args, texts ) {
-    const prop = ['none','one'][ many.length ];
-    if (!prop || !texts[prop] || args['#'] ) {
-      const names = many.map(t);
-      return (sorted ? names.sort() : names).join(', ');
-    }
+    const prop = ['none','one','two'][ many.length ];
+    const names = many.map(t);
+    if (sorted)
+      names.sort();
+    if (!prop || !texts[prop] || args['#'] )
+      return names.join(', ');
     r['#'] = prop;              // text variant
-    return many.length && t( many[0] );
+    if (many.length === 2)
+      r.second = names[1];
+    return many.length && names[0];
   };
 }
 
@@ -791,7 +796,7 @@ function replaceInString( text, params ) {
     start = pattern.lastIndex;
   }
   parts.push( text.substring( start ) );
-  let remain = ('#' in params) ? [] : Object.keys( params ).filter( n => params[n] );
+  let remain = (params['#']) ? [] : Object.keys( params ).filter( n => params[n] );
   return (remain.length)
          ? parts.join('') + '; ' +
            remain.map( n => n.toUpperCase() + ' = ' + params[n] ).join(', ')
@@ -843,7 +848,10 @@ function messageHash(msg) {
   if(!msg.home)
     return messageString(msg);
   const copy = {...msg};
-  copy.$location = undefined;
+  // Note: This is a hack. deduplicateMessages() would otherwise remove
+  //       all but one message about duplicated artifacts.
+  if (!msg.messageId || !msg.messageId.includes('duplicate'))
+    copy.$location = undefined;
   return messageString(copy);
 }
 
@@ -853,19 +861,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);
@@ -878,7 +893,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) {
@@ -886,8 +901,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;
 }
 
 /**
@@ -901,9 +915,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;
@@ -955,7 +975,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
@@ -1068,7 +1088,7 @@ function deduplicateMessages( messages ) {
 
 function shortArtName( art ) {
   const { name } = art;
-  if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null ) &&
+  if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
       !name.absolute.includes(':'))
     return quote.name( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
   return artName( art );

package/lib/base/model.js

@@ -19,7 +19,6 @@ const queryOps = {
  */
 const availableBetaFlags = {
   // enabled by --beta-mode
-  foreignKeyConstraints: true,
   toRename: true,
   addTextsLanguageAssoc: true,
   assocsWithParams: true,
@@ -28,7 +27,7 @@ const availableBetaFlags = {
   ignoreAssocPublishingInUnion: true,
   nestedProjections: true,
   enableUniversalCsn: true,
-  windowFunctions: true,
+  sqlSnippets: true,
   // disabled by --beta-mode
   nestedServices: false,
 };
@@ -55,15 +54,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];
 }