@sap/cds-compiler 5.9.4 → 6.0.10

package/lib/base/message-registry.js

@@ -35,22 +35,49 @@
 
 'use strict';
 
-const { CompilerAssertion } = require('./error');
-const { createDict } = require('../utils/objectUtils');
+const { CompilerAssertion } = require( './error' );
+const { isDeprecatedEnabled } = require( './model' );
+
+const configurableForValidValues = {
+  __proto__: null,
+  // can always be downgraded, we do not really care:
+  true: () => true,
+  // like `true`, but is intended to be removed or made 'deprecated' with v7:
+  v7: () => true,
+  // only configurable if option deprecated.downgradableErrors is set:
+  deprecated: options => isDeprecatedEnabled( options, 'downgradableErrors' ),
+  // still allow to produce output in tests:
+  test: options => options.testMode != null,
+};
 
+const validModules = [          // for configurableFor and errorFor
+  'v7',               // pseudo module in errorFor: planned as error
+  'compile',
+  'for.odata',
+  'to.edmx',
+  'to.hdbcds',
+  'to.hdi',
+  'to.sql',
+  'to.sql.migration',
+  'to.sql.migration-script',
+  'to.rename',
+  'for.effective',
+];
 /**
  * Central register of messages and their configuration.
  * Group by id-category.
  *
- * configurableFor: truthy = error can be downgraded in certain situations
- *  - true = can always be downgraded, we do not really care
- *  - 'v4', 'v6' etc: like `true`, but is intended to be removed with next major
- *  - [‹module›, …] = can be downgraded in compiler function ‹module›
- *  - 'deprecated' = severity can only be changed with deprecated.downgradableErrors
+ * Message with severity 'Error' can have a configurableFor property.  Its value
+ * is either array of modules (see validModules) where the error can be
+ * downgraded, or a value in configurableForValidValues.
+ *
+ * Messages with another severity can have an errorFor property.  Its value is an
+ * array of modules (see validModules) where the message is turned into an error.
  *
  * @type {Object<string, MessageConfig>}
  */
 const centralMessages = {
+  'api-deprecated-hdbcds': { severity: 'Error', configurableFor: true },
   '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
@@ -76,9 +103,7 @@ const centralMessages = {
 
   'type-invalid-items': { severity: 'Error' }, // not supported yet
   'assoc-as-type':  { severity: 'Error' }, // TODO: allow more, but not all
-  // the following is not really an error in v6, but gets a different semantics:
-  'assoc-incomplete-to-many': { severity: 'Warning', errorFor: [ 'v6' ] },
-  'def-unexpected-nested-proj': { severity: 'Error', configurableFor: 'v4' },
+  'def-unexpected-nested-proj': { severity: 'Error' },
   'def-unexpected-paramview-assoc': { severity: 'Error' },
   'def-unexpected-calcview-assoc': { severity: 'Error' },
   'chained-array-of': { severity: 'Error' },
@@ -100,7 +125,7 @@ const centralMessages = {
   'ref-unexpected-self': { severity: 'Error' },
   'ref-invalid-include': { severity: 'Error' },
   'type-unexpected-typeof': { severity: 'Error' },
-  'type-unexpected-null': { severity: 'Warning', errorFor: [ 'v6' ] },
+  'type-unexpected-null': { severity: 'Error', configurableFor: true },
   'type-ignoring-argument': { severity: 'Error', configurableFor: true },
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'type-expecting-service-target': { severity: 'Error', configurableFor: true },
@@ -109,7 +134,7 @@ const centralMessages = {
   'ref-invalid-source': { severity: 'Error' },
   'ref-invalid-target': { severity: 'Error' },
   'ref-missing-self-counterpart': { severity: 'Error', configurableFor: true },
-  'ref-sloppy-target': { severity: 'Error', configurableFor: 'v4' },
+  'ref-sloppy-target': { severity: 'Error', configurableFor: 'deprecated' },
 
   'extend-repeated-intralayer': { severity: 'Warning' },
   'extend-unrelated-layer':     { severity: 'Info' },
@@ -137,10 +162,11 @@ const centralMessages = {
   'ref-undefined-element': { severity: 'Error' },
   'anno-undefined-element': { severity: 'Error' },
   'ref-unknown-var': { severity: 'Info' },
-  'ref-obsolete-parameters': { severity: 'Error', configurableFor: 'v4' },
+  'ref-obsolete-parameters': { severity: 'Error', configurableFor: 'deprecated' },
   // does not hurt us, but makes it tedious to detect parameter refs
   'ref-undefined-param': { severity: 'Error' },
   'ref-undefined-enum': { severity: 'Warning', errorFor: [ 'to.sql', 'to.hdbcds', 'to.hdi' ] },
+  'ref-unexpected-enum': { severity: 'Warning', errorFor: [ 'to.sql', 'to.hdbcds', 'to.hdi' ] },
   'anno-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
   'ref-expected-element': { severity: 'Error' },
@@ -155,60 +181,62 @@ const centralMessages = {
 
   'expr-unexpected-operator': { severity: 'Error', configurableFor: true },
 
-  'syntax-deprecated-auto-union': { severity: 'Error', configurableFor: 'v4' },
   // Published! Used in @sap/cds-lsp; if renamed, add to oldMessageIds and contact colleagues
   // Also used by other projects that rely on double-quotes for delimited identifiers.
   'syntax-deprecated-ident': { severity: 'Error', configurableFor: true },
-  'syntax-deprecated-property': { severity: 'Error', configurableFor: 'v4' }, // v0 prop
-  'syntax-deprecated-value': { severity: 'Error', configurableFor: 'v4' },    // v0 prop
+  'syntax-deprecated-property': { severity: 'Error', configurableFor: 'test' }, // v0 prop
+  'syntax-deprecated-value': { severity: 'Error', configurableFor: 'test' }, // v0 prop
   // 'syntax-duplicate-annotate' came late with v3 - make it configurable as
   // fallback, but then parse.cdl is not supposed to work correctly (it can
   // then either issue an error or produce a CSN missing some annotations):
   'syntax-duplicate-annotate': { severity: 'Error' },
-  'syntax-duplicate-clause': { severity: 'Error', configurableFor: [ 'v6' ] },
+  'syntax-duplicate-clause': { severity: 'Error' },
   // remark: a hard syntax error in new parser for `null` together with `not null`
-  'syntax-duplicate-equal-clause': { severity: 'Warning', errorFor: [ 'v6' ] },
-  'syntax-invalid-name': { severity: 'Error', configurableFor: 'deprecated' },
+  'syntax-duplicate-equal-clause': { severity: 'Warning' },
+  'syntax-invalid-name': { severity: 'Error' },
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
   'syntax-missing-proj-semicolon': { severity: 'Warning' },
-  'syntax-unexpected-after': { severity: 'Warning', errorFor: [ 'v6' ] },
-  'syntax-unexpected-filter': { severity: 'Warning', errorFor: [ 'v6' ] },
-  'syntax-unexpected-many-one': { severity: 'Error', configurableFor: true }, // TODO: remove `configurableFor` soon, latest v6
-  'syntax-deprecated-ref-virtual': { severity: 'Warning', errorFor: [ 'v6' ] },
+  'syntax-unexpected-after': { severity: 'Error' },
+  'syntax-unexpected-filter': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-many-one': { severity: 'Error' },
+  'syntax-deprecated-ref-virtual': { severity: 'Error' },
   'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-unexpected-sql-clause': { severity: 'Error' }, // TODO: configurableFor:'tests'?
-  'syntax-invalid-space': { severity: 'Error', configurableFor: 'test' },
+  'syntax-invalid-space': { severity: 'Error', configurableFor: true },
   'syntax-expecting-space': { severity: 'Error' },
   'syntax-unexpected-anno': { severity: 'Error' },
   'migration-unsupported-key-change': { severity: 'Error', configurableFor: [ 'to.sql.migration', 'to.sql.migration-script' ] },
-  'type-missing-enum-value': { severity: 'Error', configurableFor: 'test' },
+  'type-missing-enum-value': { severity: 'Error', configurableFor: 'deprecated' },
 
   'def-missing-element': { severity: 'Error' },
+  'def-missing-virtual': { severity: 'Error', configurableFor: true },
   'def-expected-structured': { severity: 'Error', configurableFor: true },
   'def-unsupported-calc-elem': { severity: 'Error', configurableFor: true },
 
   'def-invalid-key-cardinality': { severity: 'Error' },
-  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-array': { severity: 'Warning' }, // more than 30 chars
-  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-assoc': { severity: 'Warning' }, // more than 30 chars
-  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-constraints': { severity: 'Info' }, // more than 30 chars
-  'odata-spec-violation-id': { severity: 'Error', configurableFor: true },
-  'odata-spec-violation-namespace': { severity: 'Warning' }, // more than 30 chars
-  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-param': { severity: 'Warning' }, // more than 30 chars
-  // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
-  'odata-spec-violation-returns': { severity: 'Warning' }, // more than 30 chars
-  'odata-spec-violation-type': { severity: 'Error', configurableFor: true },
-  'odata-spec-violation-type-unknown': { severity: 'Error', configurableFor: true },
-  'odata-spec-violation-no-key':  { severity: 'Error', configurableFor: true },
-  'odata-spec-violation-key-array':  { severity: 'Error', configurableFor: true }, // more than 30 chars
-  'odata-spec-violation-key-null': { severity: 'Error', configurableFor: true }, // 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-unexpected-array': { severity: 'Warning' },
+  'odata-unexpected-assoc': { severity: 'Warning' },
+  'odata-incomplete-constraints': { severity: 'Info' },
+  'odata-invalid-name': { severity: 'Error', configurableFor: true },
+  'odata-invalid-vocabulary-alias': { severity: 'Error', configurableFor: true },
+  'odata-invalid-qualifier': { severity: 'Error', configurableFor: true },
+  'odata-invalid-service-name': { severity: 'Warning' },
+  'odata-invalid-param-type': { severity: 'Warning' },
+  'odata-invalid-return-type': { severity: 'Warning' },
+  'odata-missing-type': { severity: 'Error', configurableFor: true },
+  'odata-invalid-scale': { severity: 'Error', configurableFor: true },
+  'odata-unexpected-edm-facet': { severity: 'Error', configurableFor: true },
+  'odata-invalid-external-type': { severity: 'Error', configurableFor: true },
+  'odata-unexpected-edm-type': { severity: 'Error', configurableFor: true },
+  'odata-unknown-edm-type': { severity: 'Error', configurableFor: true },
+  'odata-missing-key':  { severity: 'Error', configurableFor: true },
+  'odata-unexpected-arrayed-key':  { severity: 'Error', configurableFor: true },
+  'odata-unexpected-nullable-key': { severity: 'Error', configurableFor: true },
+  'odata-invalid-key-type': { severity: 'Warning' },
+  'odata-invalid-property-name': { severity: 'Warning' },
   'odata-anno-preproc': { severity: 'Warning' },
   'odata-anno-dict': { severity: 'Warning' },
   'odata-anno-vocref': { severity: 'Warning' },
@@ -216,7 +244,11 @@ const centralMessages = {
   'odata-anno-value': { severity: 'Warning' },
   'odata-anno-type': { severity: 'Warning' },
   'odata-anno-def': { severity: 'Info' },
+  'odata-duplicate-definition': { severity: 'Error' },
+  'odata-duplicate-proxy': { severity: 'Warning' },
+
   'query-ignoring-assoc-in-union': { severity: 'Info' },
+
   // for to.sql.migration - cannot be supplied by the user!
   'migration-unsupported-precision-change': { severity: 'Error', configurableFor: [ 'to.sql.migration-script' ]  },
   'migration-unsupported-element-drop': { severity: 'Error', configurableFor: [ 'to.sql.migration-script' ] },
@@ -231,26 +263,46 @@ const centralMessages = {
 // We keep them in a separate array for easier access. No need to go through all
 // existing messages and search for the old one in `oldNames` property.
 // The keys will be added to `oldNames` of the new message, which is used for reclassification.
-const oldMessageIds = createDict({
+const oldMessageIds = {
+  __proto__: null,
+
   'old-anno-duplicate': 'anno-duplicate', // Example
+
   'assoc-in-array': 'type-invalid-items',
   'duplicate-autoexposed': 'def-duplicate-autoexposed',
   'expr-no-filter': 'expr-unexpected-filter',
   'check-proper-type': 'def-missing-type',
-});
+
+  // All odata messages were renamed in v6. Some were split up into separate ones.
+  'odata-spec-violation-array': 'odata-unexpected-array',
+  'odata-spec-violation-assoc': 'odata-unexpected-assoc',
+  'odata-spec-violation-constraints': 'odata-incomplete-constraints',
+  'odata-spec-violation-id': [ 'odata-invalid-name', 'odata-invalid-vocabulary-alias', 'odata-invalid-qualifier' ],
+  'odata-spec-violation-namespace': 'odata-invalid-service-name',
+  'odata-spec-violation-param': 'odata-invalid-param-type',
+  'odata-spec-violation-returns': 'odata-invalid-return-type',
+  'odata-spec-violation-type': [ 'odata-unexpected-edm-facet', 'odata-missing-type', 'odata-invalid-scale', 'odata-unexpected-edm-type', 'odata-invalid-external-type' ],
+  'odata-spec-violation-type-unknown': 'odata-unknown-edm-type',
+  'odata-spec-violation-no-key': 'odata-missing-key',
+  'odata-spec-violation-key-array': 'odata-unexpected-arrayed-key',
+  'odata-spec-violation-key-type': 'odata-invalid-key-type',
+  'odata-spec-violation-key-null': 'odata-unexpected-nullable-key',
+  'odata-spec-violation-property-name': 'odata-invalid-property-name',
+  'odata-definition-exists': [ 'odata-duplicate-definition', 'odata-duplicate-proxy' ],
+};
 
 // Set up the old-to-new message ID mapping in the message registry.
 for (const oldName in oldMessageIds) {
-  const newName = oldMessageIds[oldName];
   if (centralMessages[oldName])
     throw new CompilerAssertion(`Mapping from ${ oldName } not possible: ID is still used in message registry.`);
-  if (!centralMessages[newName])
-    throw new CompilerAssertion(`Mapping from ${ oldName } to new message ID ${ newName } does not exist!`);
 
-  if (!centralMessages[newName].oldNames)
-    centralMessages[newName].oldNames = [ oldName ];
-  else
+  const newNames = Array.isArray(oldMessageIds[oldName]) ? oldMessageIds[oldName] : [ oldMessageIds[oldName] ];
+  for (const newName of newNames) {
+    if (!centralMessages[newName])
+      throw new CompilerAssertion(`Mapping from ${ oldName } to new message ID ${ newName } does not exist!`);
+    centralMessages[newName].oldNames ??= [ ];
     centralMessages[newName].oldNames.push(oldName);
+  }
 }
 
 
@@ -259,9 +311,7 @@ for (const oldName in oldMessageIds) {
 // If you change it, keep in sync with scripts/eslint/rules/message-text.js
 
 const centralMessageTexts = {
-  'api-deprecated-v5': {
-    std: 'Support for generating hdbcds output is deprecated with @sap/cds-compiler v5 and later',
-  },
+  'api-deprecated-hdbcds': 'Support for generating hdbcds output is deprecated with @sap/cds-compiler v5 and later',
   'api-invalid-option': {
     std: 'Invalid option $(NAME)!',
     deprecated: 'Option $(NAME) is no longer supported! Use latest API options instead',
@@ -270,10 +320,12 @@ const centralMessageTexts = {
     value2: 'Expected option $(OPTION) to have value $(VALUE) or $(RAWVALUE); found: $(OTHERVALUE)',
     type: 'Expected option $(OPTION) to be of type $(VALUE). Found: $(OTHERVALUE)',
     forbidden: 'Option $(OPTION) can\'t be used with API function $(MODULE)',
+    odataV2json: 'OData JSON output is not available for OData V2',
   },
   'def-upcoming-virtual-change': {
-    std: 'This select item will be a new element in cds-compiler v6, without referencing $(NAME); prepend a table alias if you want to keep the virtual element as a reference; see https://cap.cloud.sap/docs/cds/compiler/messages#def-upcoming-virtual-change for details',
+    std: 'This select item is a new element in cds-compiler v6, but only supported with the new parser',
   },
+  'query-invalid-virtual-struct': 'For a virtual structure in a query, use a defined structure type, or add $(CODE) when you meant to specify references',
 
   'api-invalid-variable-replacement': {
     std: 'Option $(OPTION) does not support $(NAME)',
@@ -282,12 +334,18 @@ const centralMessageTexts = {
     noDollar: 'Option $(OPTION) does not know $(NAME). Did you forget a leading $(CODE)?',
   },
 
+  'api-invalid-version': {
+    std: 'Invalid CSN version: $(VERSION)',
+    migrationComparison: 'Incompatible CSN versions: $(VALUE) is a major downgrade from $(OTHERVALUE). Is @sap/cds-compiler version $(VERSION) outdated?',
+  },
+
   'api-invalid-combination': {
     std: 'Invalid option combination found: $(OPTION) and $(PROP)', // unused
     'valid-structured': 'Structured OData is only supported with OData version v4',
     'sql-dialect-and-naming': 'sqlDialect $(NAME) can\'t be combined with sqlMapping $(PROP)',
     'tenant-and-naming': 'Option $(OPTION) can\'t be combined with sqlMapping $(PROP) - expected sqlMapping $(VALUE)',
     'dry-and-script': 'script:true must be combined with dry:true, found $(VALUE)',
+    'hana-migration': 'SQL dialect $(VALUE) is not supported with API function "to.sql.migration" - use HDI via "to.hdi" and "to.hdi.migration"',
     'effectiveServiceName-and-type-resolution': 'Option $(NAME) can\'t be used without $(PROP)',
   },
   'api-unexpected-combination': {
@@ -448,6 +506,8 @@ const centralMessageTexts = {
     std: 'You have already provided this clause',
     cardinality: 'You have already provided a target cardinality $(CODE) instead, at line $(LINE), column $(COL)',
     notNull: 'You have already provided $(CODE) instead, at line $(LINE), column $(COL) below',
+    orderByLimit: 'You have already provided $(CODE) before',
+    setForCsn: 'You have provided property $(PROP)/$(SIBLINGPROP) inside and outside $(PARENTPROP)',
   },
   'syntax-duplicate-equal-clause': {
     std: 'You have already provided the same clause',
@@ -611,6 +671,7 @@ const centralMessageTexts = {
     // to help users for `… from E:toF { toF[…].x }`
     tableAlias: 'A filter can only be provided when navigating along associations, but found table alias',
     from: 'A filter can only be provided for the source entity or associations',
+    'model-only': 'A filter can\'t be provided for a to-many association without ON-condition',
   },
 
   // multi-line strings: --------------------------------------------------------
@@ -632,6 +693,12 @@ const centralMessageTexts = {
 
   // Messages for erroneous references -----------------------------------------
   // location at erroneous reference (if possible)
+  'ref-cyclic': {
+    std: 'Illegal circular reference to $(ART)',
+    element: 'Illegal circular reference to element $(MEMBER) of $(ART)',
+    target: 'Illegal circular reference to target $(ART)',
+    type: 'Illegal recursive type definition to $(TYPE)',
+  },
   'ref-deprecated-orderby': 'Replace source element reference $(ID) by $(NEWCODE); auto-corrected',
   'ref-missing-self-counterpart' : {
     std: 'Expected to find a matching element in $self-comparison for foreign key $(PROP) of association $(NAME)',
@@ -690,7 +757,13 @@ const centralMessageTexts = {
     self: 'Variable $(ID) has not been found. Use $(ALIAS) to refer an element with the same name',
     value: 'No value found for variable $(ID). Use option $(OPTION) to specify a value for $(ID)',
   },
-  'ref-undefined-enum' : 'Enum symbol $(ID) is not defined in $(TYPE)',
+  'ref-undefined-enum': 'Enum symbol $(ID) is not defined in $(TYPE)',
+  'ref-unexpected-enum': {
+    std: 'Unexpected enum reference $(ENUM)',
+    symbolDef: 'References to other values are not allowed as enum values',
+    untyped: 'Unexpected enum reference $(ENUM); no type can be inferred for it',
+    invalidType: 'Unexpected enum reference $(ENUM) as value for a non-enum type $(TYPE)',
+  },
   'ref-unknown-var': {
     std: 'No replacement found for special variable $(ID)',
   },
@@ -738,6 +811,13 @@ const centralMessageTexts = {
     'managed-filter': 'Unexpected managed association $(NAME) in filter expression of $(ID)',
     'unmanaged-filter': 'Unexpected unmanaged association $(NAME) in filter expression of $(ID)',
   },
+  'ref-unexpected-assoc-type': {
+    std: 'An association is not allowed as this artifact\'s type', // Not used
+    'action-param': 'An association is not allowed as action\'s parameter type',
+    'function-param': 'An association is not allowed as function\'s parameter type',
+    'action-returns': 'An association is not allowed as action\'s return type',
+    'function-returns': 'An association is not allowed as function\'s return type',
+  },
   'ref-unexpected-calculated': {
     std: 'Unexpected reference to calculated element',
     on: 'Calculated elements (on-read) can\'t be used in ON-conditions of unmanaged associations',
@@ -771,6 +851,7 @@ const centralMessageTexts = {
     hana: 'Type $(TYPE) is only supported for SQL dialect $(VALUE), not $(OTHERVALUE)',
     hdbcds:'Type $(TYPE) is not supported in HDBCDS',
     odata: 'Type $(TYPE) is not supported for OData $(VERSION)',
+    key: 'Type $(TYPE) can\'t be used as primary key in element $(NAME)',
   },
   'ref-unexpected-var': {
     std: 'Variable $(NAME) can\'t be used here',
@@ -918,6 +999,7 @@ const centralMessageTexts = {
   },
   'def-unexpected-localized-struct': '$(KEYWORD) is not fully supported for structures',
   'def-unexpected-localized-anno': 'Annotations can\'t have localized elements',
+  'def-unexpected-virtual': 'Unexpected $(KEYWORD): an element can\'t be virtual and an association/composition',
   'type-unexpected-structure': {
     std: 'Unexpected structured type', // unused variant
     calc: 'A structured type can\'t be used for calculated elements',
@@ -1070,6 +1152,7 @@ const centralMessageTexts = {
     std: 'Using nested projections next to calculated elements is not supported, yet',
     inside: 'Using calculated elements in nested projections is not supported, yet',
   },
+  'query-unsupported-asterisk': 'Unsupported asterisk in $(CODE) inside a nested projection',
   'query-mismatched-element': {
     std: 'Specified element $(NAME) differs from inferred element in property $(PROP)',
     type: 'Expected type of specified element $(NAME) to be the same as the inferred element\'s type',
@@ -1158,6 +1241,12 @@ const centralMessageTexts = {
     targetVal: 'Target minimum cardinality must not be greater than target maximum cardinality',
   },
 
+  'type-invalid-self': 'An association that uses $(NAME) in its ON-condition can\'t be compared to $(NAME)',
+  'type-invalid-foreign-key': {
+    std: 'Unexpected type $(TYPE) in foreign key',
+    items: 'Unexpected arrayed element as foreign keys',
+  },
+
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
 
   'expr-missing-foreign-key': {
@@ -1184,58 +1273,58 @@ const centralMessageTexts = {
   // OData Message section starts here
   // -----------------------------------------------------------------------------------
   // OData version dependent messages
-  'odata-spec-violation-array': 'Unexpected array type for OData $(VERSION)',
-  'odata-spec-violation-param' : 'Expected parameter to be typed with either scalar or structured type for OData $(VERSION)',
-  'odata-spec-violation-returns': 'Expected $(KIND) to return one or many values of scalar, complex, entity or view type for OData $(VERSION)',
-  'odata-spec-violation-assoc': 'Unexpected association in structured type for OData $(VERSION)',
-  'odata-spec-violation-constraints': 'Partial referential constraints produced for OData $(VERSION)',
-  'odata-spec-violation-id': {
+  'odata-unexpected-array': 'Unexpected array type for OData $(VERSION)',
+  'odata-invalid-param-type' : 'Expected parameter to be typed with either scalar or structured type for OData $(VERSION)',
+  'odata-invalid-return-type': 'Expected $(KIND) to return one or many values of scalar, complex, entity or view type for OData $(VERSION)',
+  'odata-unexpected-assoc': 'Unexpected association in structured type for OData $(VERSION)',
+  'odata-incomplete-constraints': 'Partial referential constraints produced for OData $(VERSION)',
+  'odata-invalid-name': {
     std: 'Expected OData name $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
     v2firstChar: 'Unexpected first character $(PROP) of OData name $(ID) for OData $(VERSION)',
-    qualifier: 'Expected OData annotation qualifier $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
-    vocRefAlias: 'Expected value $(VALUE) of OData vocabulary reference attribute $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
   },
+  'odata-invalid-vocabulary-alias': 'Expected value $(VALUE) of OData vocabulary reference attribute $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
+  'odata-invalid-qualifier': 'Expected OData annotation qualifier $(ID) to start with an alphabetic character or underscore, followed by a maximum of 127 alphabetic characters, digits, or underscores',
   // version independent messages
-  'odata-spec-violation-key-array': {
-    std: 'Unexpected array type for primary key $(NAME)',
-    assoc: 'Unexpected target cardinality $(VALUE) for primary key $(NAME)',
-  },
-  'odata-spec-violation-key-null': {
+  'odata-unexpected-nullable-key': {
     std: 'Expected key element $(NAME) to be not nullable', // flat
     scalar: 'Expected key element $(NAME) to be not nullable', // structured
   },
-  'odata-spec-violation-key-type': {
+  'odata-unexpected-arrayed-key': {
+    std: 'Unexpected array type for primary key $(NAME)',
+    assoc: 'Unexpected target cardinality $(VALUE) for primary key $(NAME)',
+  },
+  'odata-invalid-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-unknown': 'Unknown EDM Type $(TYPE)',
-  'odata-spec-violation-type': {
-    std: 'Expected element to have a type',
-    incompatible: 'Unexpected EDM Type $(TYPE) for OData $(VERSION)',
-    incompatible_anno: 'Unexpected EDM Type $(TYPE) for OData $(VERSION) in $(ANNO)',
-    facet: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION)',
-    facet_anno: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION) in $(ANNO)',
-    external: 'Referenced type $(TYPE) marked as $(ANNO) can\'t be rendered as $(CODE) in service $(NAME) for OData $(VERSION)',
-    scale: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE)',
-    scale_anno: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE) in $(ANNO)',
-  },
-  'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(META)',
-  'odata-spec-violation-namespace': {
+  'odata-missing-key': 'Expected entity to have a primary key',
+  'odata-unknown-edm-type': 'Unknown EDM Type $(TYPE)',
+  'odata-unexpected-edm-type': {
+    std: 'Unexpected EDM Type $(TYPE) for OData $(VERSION)',
+    anno: 'Unexpected EDM Type $(TYPE) for OData $(VERSION) in $(ANNO)',
+  },
+  'odata-missing-type': 'Expected element to have a type',
+  'odata-unexpected-edm-facet': {
+    std: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION)',
+    anno: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION) in $(ANNO)',
+  },
+  'odata-invalid-external-type': 'Referenced type $(TYPE) marked as $(ANNO) can\'t be rendered as $(CODE) in service $(NAME) for OData $(VERSION)',
+  'odata-invalid-scale': {
+    std: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE)',
+    anno: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE) in $(ANNO)',
+  },
+  'odata-invalid-property-name': 'Expected element name to be different from declaring $(META)',
+  'odata-invalid-service-name': {
     std: 'Expected service name not to be one of the reserved names $(NAMES)',
     length: 'Expected service name not to exceed 511 characters',
   },
   // Other odata/edm errors
-  'odata-definition-exists': {
+  'odata-duplicate-proxy': 'No proxy entity created due to name collision with existing definition $(NAME) of kind $(KIND)',
+  'odata-duplicate-definition': {
     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)',
     anno: 'Name of annotation definition $(ANNO) conflicts with existing service definition',
-    termredef: 'Unexpected redefinition of annotation $(ANNO)',
-  },
-  'odata-navigation': {
-    std: 'No OData navigation property generated, target $(TARGET) is outside of service $(SERVICE)',
-    oncond: 'No OData navigation property generated for association with arbitrary ON-condition and target $(TARGET) outside of service $(SERVICE)',
   },
+  'odata-navigation': 'No OData navigation property generated, target $(TARGET) is outside of service $(SERVICE)',
   'odata-parameter-order': 'Unexpected mandatory after optional parameter',
   'odata-key-recursive': 'Unexpected recursive key $(NAME)',
   'odata-key-uuid-default-anno': 'Expected element of type $(TYPE) to be annotated with $(ANNO) when used as primary key in $(ID)',
@@ -1291,8 +1380,8 @@ const centralMessageTexts = {
     enum: 'Value $(VALUE) is not one out of $(RAWVALUES) for $(ANNO) of type $(TYPE)',
     std: 'Unexpected value $(VALUE) for $(ANNO) of type $(TYPE)',
     incompval: 'Unexpected $(STR) value for $(ANNO) of type $(TYPE)',
-    nestedcollection: 'Nested collections are not supported for $(ANNO)',
-    enumincollection: 'Enum inside collection is not supported for $(ANNO)',
+    nestedCollection: 'Nested collections are not supported for $(ANNO)',
+    enuminCollection: 'Enum inside collection is not supported for $(ANNO)',
     multexpr: 'EDM JSON code contains more than one dynamic expression: $(RAWVALUES) for $(ANNO)',
   },
   'odata-anno-type': {
@@ -1394,7 +1483,6 @@ const centralMessageTexts = {
  *        If not `true` then an array is expected with specified modules in which the error is downgradable.
  *        Only has an effect if default severity is 'Error'.
  *        'deprecated': severity can only be changed with deprecated.downgradableErrors.
- *        TODO: Value `true` is temporary. Use an array instead.
  * @property {string[]} [errorFor] Array of module names where the message shall be reclassified to an error.
  * @property {boolean} [throughMessageCall]
  *        If set, it means that a message-id was added to the registry in test-mode through a `message.<severity>()`
@@ -1405,4 +1493,10 @@ const centralMessageTexts = {
 
 // console.log('FOO')
 
-module.exports = { centralMessages, centralMessageTexts, oldMessageIds };
+module.exports = {
+  centralMessages,
+  configurableForValidValues,
+  validModules,
+  centralMessageTexts,
+  oldMessageIds,
+};