@sap/cds-compiler 5.6.0 → 5.7.0

package/lib/base/message-registry.js

@@ -28,6 +28,10 @@
 // "sloppy": with an upcoming _minor_ version of the compiler, the compilation
 // might lead to an error anyway or the compiled CSN might look different.
 
+/* eslint @stylistic/js/no-multi-spaces: 0 */
+/* eslint @stylistic/js/max-len: 0 */
+/* eslint @stylistic/js/key-spacing: 0 */
+
 'use strict';
 
 const { CompilerAssertion } = require('./error');
@@ -75,6 +79,7 @@ const centralMessages = {
   'def-unexpected-calcview-assoc': { severity: 'Error' },
   'chained-array-of': { severity: 'Error' },
   'def-missing-type':    { severity: 'Error', configurableFor: [ 'compile' ] },
+  'def-missing-argument':    { severity: 'Error' },
   'check-proper-type-of': { severity: 'Info',  errorFor: [ 'for.odata', 'to.edmx', 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename', 'for.effective' ] },
 
   'def-duplicate-autoexposed': { severity: 'Error' },
@@ -127,8 +132,9 @@ const centralMessages = {
   'anno-undefined-element': { severity: 'Error' },
   'ref-unknown-var': { severity: 'Info' },
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: 'v4' },
-           // does not hurt us, but makes it tedious to detect parameter refs
+  // 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' ] },
   'anno-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
   'ref-expected-element': { severity: 'Error' },
@@ -205,12 +211,12 @@ const centralMessages = {
   'odata-anno-def': { severity: 'Info' },
   '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'] },
-  'migration-unsupported-length-change': { severity: 'Error', configurableFor: [ 'to.sql.migration-script'] },
-  'migration-unsupported-scale-change': { severity: 'Error', configurableFor: [ 'to.sql.migration-script'] },
-  'migration-unsupported-change': { severity: 'Error', configurableFor: [ 'to.sql.migration-script'] },
-  'migration-unsupported-table-drop': { severity: 'Error', configurableFor: [ 'to.sql.migration-script'] }
+  'migration-unsupported-precision-change': { severity: 'Error', configurableFor: [ 'to.sql.migration-script' ]  },
+  'migration-unsupported-element-drop': { severity: 'Error', configurableFor: [ 'to.sql.migration-script' ] },
+  'migration-unsupported-length-change': { severity: 'Error', configurableFor: [ 'to.sql.migration-script' ] },
+  'migration-unsupported-scale-change': { severity: 'Error', configurableFor: [ 'to.sql.migration-script' ] },
+  'migration-unsupported-change': { severity: 'Error', configurableFor: [ 'to.sql.migration-script' ] },
+  'migration-unsupported-table-drop': { severity: 'Error', configurableFor: [ 'to.sql.migration-script' ] },
   // end of to.sql.migration specific
 };
 
@@ -247,7 +253,7 @@ for (const oldName in oldMessageIds) {
 
 const centralMessageTexts = {
   'api-deprecated-v5': {
-    std: 'Support for generating hdbcds output is deprecated with @sap/cds-compiler v5 and later'
+    std: 'Support for generating hdbcds output is deprecated with @sap/cds-compiler v5 and later',
   },
   'api-invalid-option': {
     std: 'Invalid option $(NAME)!',
@@ -256,14 +262,14 @@ const centralMessageTexts = {
     value: 'Expected option $(PROP) to have $(VALUE). Found: $(OTHERVALUE)',
     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)'
+    forbidden: 'Option $(OPTION) can\'t be used with API function $(MODULE)',
   },
 
   'api-invalid-variable-replacement': {
     std: 'Option $(OPTION) does not support $(NAME)',
     user: 'Option $(OPTION) expects $(PROP) instead of $(OTHERPROP). See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
     locale: 'Option $(OPTION) expects $(PROP) instead of $(OTHERPROP). See <https://cap.cloud.sap/docs/guides/databases#configuring-variables> for details',
-    'noDollar': 'Option $(OPTION) does not know $(NAME). Did you forget a leading $(CODE)?'
+    noDollar: 'Option $(OPTION) does not know $(NAME). Did you forget a leading $(CODE)?',
   },
 
   'api-invalid-combination': {
@@ -325,7 +331,7 @@ const centralMessageTexts = {
   },
 
   'name-duplicate-element': {
-    'std': 'Generated element $(NAME) conflicts with another element',
+    std: 'Generated element $(NAME) conflicts with another element',
     'flatten-element-gen': 'Generated element $(NAME) conflicts with other generated element',
     'flatten-element-exist': 'Flattened name of structured element conflicts with existing element $(NAME)',
     'flatten-fkey-gen': 'Duplicate definition of foreign key element $(NAME) for association $(ART)',
@@ -341,7 +347,7 @@ const centralMessageTexts = {
   'name-missing-alias': {
     std: 'Missing table alias for this subquery',
     duplicate: 'Missing table alias for this subquery; add $(CODE) to fix name clash of internal and explicit table alias',
-    hdbcds: 'Missing table alias for a subquery; SAP HANA CDS requires table aliases'
+    hdbcds: 'Missing table alias for a subquery; SAP HANA CDS requires table aliases',
   },
 
   // Syntax messages, both CDL and CSN parser: ----------------------------------
@@ -361,7 +367,7 @@ const centralMessageTexts = {
     'or-asterisk': 'Expecting a non-negative integer or string $(OP) for property $(PROP)',
   },
   'syntax-ignoring-decimal': {
-    std: 'Ignoring decimal places, because an integer was expected'
+    std: 'Ignoring decimal places, because an integer was expected',
   },
   'syntax-unexpected-anno': {
     std: 'Annotations can\'t be used in a column with $(CODE)',
@@ -382,19 +388,19 @@ const centralMessageTexts = {
     type: 'The dot-separated element name parts in property $(PROP) must not be empty', // CSN v0
   },
   'syntax-invalid-literal': {
-    'std': 'Invalid literal value',
+    std: 'Invalid literal value',
     'uneven-hex': 'A binary literal must have an even number of characters',
     'invalid-hex': 'A binary literal must only contain characters ‹0-9›, ‹a-f› and ‹A-F›',
-    'time': 'A time literal must look like ‹hh:mm:ss› or ‹hh:mm› where each letter represents a digit. A timezone is optional',
-    'date': 'A date literal must look like ‹YYYY-MM-DD› where each letter represents a digit',
-    'timestamp': 'A timestamp literal must look like ‹YYYY-MM-DD hh:mm:ss.u…u› or ‹YYYY-MM-DD hh:mm› where each letter represents a digit, ‹u…u› represents 1 to 7 digits. A timezone is optional',
-    'number': 'The string value in property $(PROP) does not represent a number',
-    'expecting': 'Expecting literal type $(OP) for the value in property $(OTHERPROP)',
-    'typeof': 'String $(RAWVALUE) is no valid literal type for the string value in property $(OTHERPROP)',
+    time: 'A time literal must look like ‹hh:mm:ss› or ‹hh:mm› where each letter represents a digit. A timezone is optional',
+    date: 'A date literal must look like ‹YYYY-MM-DD› where each letter represents a digit',
+    timestamp: 'A timestamp literal must look like ‹YYYY-MM-DD hh:mm:ss.u…u› or ‹YYYY-MM-DD hh:mm› where each letter represents a digit, ‹u…u› represents 1 to 7 digits. A timezone is optional',
+    number: 'The string value in property $(PROP) does not represent a number',
+    expecting: 'Expecting literal type $(OP) for the value in property $(OTHERPROP)',
+    typeof: 'String $(RAWVALUE) is no valid literal type for the string value in property $(OTHERPROP)',
   },
   'syntax-invalid-source': {
     std: 'The given source is invalid', // unused
-    'cdl-stackoverflow': 'The parser ran into a stack overflow. Does your CDS file contain too many nested artifacts?'
+    'cdl-stackoverflow': 'The parser ran into a stack overflow. Does your CDS file contain too many nested artifacts?',
   },
   'syntax-missing-ellipsis': 'Expecting an array item $(NEWCODE) after an item with $(CODE)',
   'syntax-unexpected-ellipsis': {
@@ -403,6 +409,12 @@ const centralMessageTexts = {
     'csn-duplicate': 'Unexpected object with property $(PROP) after previous array item $(CODE)',
     'csn-nested': 'Unexpected object with property $(PROP) in nested array',
   },
+  'syntax-invalid-anno': {
+    std: 'Unexpected $(OFFENDING), invalid annotation value, expecting $(EXPECTING)',
+    empty: 'Unexpected $(OFFENDING), empty structure flattens to nothing, expecting $(EXPECTING)',
+    ellipsis: 'Unexpected $(OFFENDING) in inner array value, expecting $(EXPECTING)',
+    bracket: 'Missing array item $(CODE) before $(OFFENDING), expecting $(EXPECTING)',
+  },
   'syntax-unsupported-masked': { // configurable Error
     std: 'The keyword $(KEYWORD) is not supported',
     csn: 'The property $(PROP) is not supported',
@@ -442,16 +454,24 @@ const centralMessageTexts = {
   'syntax-invalid-text-block': 'Missing newline in text block',
   // 'syntax-missing-newline' (Warning), 'syntax-missing-as',
   // 'syntax-missing-token'
-  'syntax-unexpected-extension': 'Unexpected $(KEYWORD) inside $(CODE) block',
+  'syntax-unexpected-extension': {
+    std: 'Unexpected $(KEYWORD) inside $(CODE) block',
+    'new-parser': 'Unexpected $(OFFENDING) inside $(CODE) block, expecting $(EXPECTING)',
+  },
   'syntax-unexpected-null': 'Keyword $(KEYWORD) must appear after the enum definition and not before',
   'syntax-unexpected-token': {
     std: 'Mismatched $(OFFENDING), expecting $(EXPECTING)',
-    unwanted: 'Extraneous $(OFFENDING), expecting $(EXPECTING)'
+    unwanted: 'Extraneous $(OFFENDING), expecting $(EXPECTING)',
+    noRepeatedCardinality: 'Unexpected $(OFFENDING), cardinality already provided at $(LOCATION) via $(CODE), expecting $(EXPECTING)',
+    nestedExpand: 'Unexpected $(OFFENDING), nested projections are valid after a reference only, expecting $(EXPECTING)',
   },
   'syntax-unexpected-vocabulary': {
-    std: 'Annotations can\'t be defined inside contexts or services', // not used
+    std: 'Annotations can\'t be defined inside contexts or services', // used inside extensions
     service: 'Annotations can\'t be defined inside services',
     context: 'Annotations can\'t be defined inside contexts',
+    'extend-new': 'Unexpected $(OFFENDING) definition inside a context or service, expecting $(EXPECTING)',
+    'service-new': 'Unexpected $(OFFENDING) definition inside a service, expecting $(EXPECTING)',
+    'context-new': 'Unexpected $(OFFENDING) definition inside a context, expecting $(EXPECTING)',
   },
   // 'syntax-unexpected-alias' (is 'syntax-unexpected-property' in CSN)
   'syntax-unsupported-param': {
@@ -471,7 +491,7 @@ const centralMessageTexts = {
   },
   'syntax-deprecated-property': {  // Configurable error
     std: 'Deprecated property $(PROP)', // unused
-    'zero': 'Deprecated CSN v0.1.0 property $(PROP) is ignored',
+    zero: 'Deprecated CSN v0.1.0 property $(PROP) is ignored',
     'zero-replace': 'Replace CSN v0.1.0 property $(PROP) by $(OTHERPROP)',
   },
   'syntax-deprecated-value': {  // Configurable error
@@ -557,7 +577,7 @@ const centralMessageTexts = {
     std: 'Calculated elements are not supported, yet',
     nested: 'Calculated elements in structures are not supported, yet',
     'on-write': 'Calculated elements on-write are not supported, yet',
-    'hdbcds': 'Calculated elements on-write are not supported for HDBCDS',
+    hdbcds: 'Calculated elements on-write are not supported for HDBCDS',
   },
   // 'syntax-unknown-property' (Warning? Better configurable Error)
 
@@ -583,7 +603,7 @@ const centralMessageTexts = {
   '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)',
-    unmanaged: 'Expected to find a matching element in $self-comparison for $(PROP) of association $(NAME)'
+    unmanaged: 'Expected to find a matching element in $self-comparison for $(PROP) of association $(NAME)',
   },
   'ref-unexpected-self': {
     std: 'Unexpected $(ID) reference; is valid only in ON-conditions of unmanaged associations',
@@ -622,7 +642,7 @@ const centralMessageTexts = {
     aspect: 'Element $(ID) has not been found in the anonymous target aspect',
     query: 'The current query has no element $(ART)',
     alias: 'Element $(ART) has not been found in the sub query for alias $(ALIAS)',
-    virtual: 'Element $(ART) has not been found. Use $(CODE) to add virtual elements in queries'
+    virtual: 'Element $(ART) has not been found. Use $(CODE) to add virtual elements in queries',
   },
   'anno-undefined-element': {
     std: 'Element $(ART) has not been found',
@@ -638,8 +658,9 @@ 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-unknown-var': {
-    std: 'No replacement found for special variable $(ID)'
+    std: 'No replacement found for special variable $(ID)',
   },
   'ref-unexpected-draft-enabled': 'Composition in draft-enabled entity can\'t lead to another entity with $(ANNO)',
   'ref-rejected-on': {          // TODO: currently not used - just remove?
@@ -683,7 +704,7 @@ const centralMessageTexts = {
     'assoc-stored': 'Associations and compositions can\'t be used as values in stored calculated elements',
 
     'managed-filter': 'Unexpected managed association $(NAME) in filter expression of $(ID)',
-    'unmanaged-filter': 'Unexpected unmanaged association $(NAME) in filter expression of $(ID)'
+    'unmanaged-filter': 'Unexpected unmanaged association $(NAME) in filter expression of $(ID)',
   },
   'ref-unexpected-calculated': {
     std: 'Unexpected reference to calculated element',
@@ -705,30 +726,30 @@ const centralMessageTexts = {
   'ref-unexpected-filter': {
     std: 'Unexpected filter in path $(ELEMREF)', // unused
     'on-condition': 'ON-conditions must not contain filters, step $(ID) of path $(ELEMREF)',
-    calc:  'Unexpected filter in path $(ELEMREF) of stored calculated element; only simple paths can be used here'
+    calc:  'Unexpected filter in path $(ELEMREF) of stored calculated element; only simple paths can be used here',
   },
   'ref-unexpected-args': {
     std: 'Unexpected arguments in path $(ELEMREF)', // unused
     'on-condition': 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)',
-    calc: 'Unexpected arguments in path $(ELEMREF) of stored calculated element; only simple paths can be used here'
+    calc: 'Unexpected arguments in path $(ELEMREF) of stored calculated element; only simple paths can be used here',
   },
   'ref-unsupported-type': {
     std: 'Type $(TYPE) is not supported',
     dialect: 'Type $(TYPE) is not supported for SQL dialect $(VALUE)',
     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)'
+    odata: 'Type $(TYPE) is not supported for OData $(VERSION)',
   },
   'ref-unexpected-var': {
     std: 'Variable $(NAME) can\'t be used here',
-    'annotation': 'Variable $(NAME) can only be used in annotation values',
+    annotation: 'Variable $(NAME) can only be used in annotation values',
   },
 
   'rewrite-not-supported': {
     // TODO: Better text ?
     std: 'The ON-condition is not rewritten here - provide an explicit ON-condition',
     'inline-expand': 'The ON-condition is not rewritten in nested projections - provide an explicit ON-condition',
-    'secondary': 'The ON-condition is not rewritten due to multiple associations in this path - provide an explicit ON-condition',
+    secondary: 'The ON-condition is not rewritten due to multiple associations in this path - provide an explicit ON-condition',
   },
   'rewrite-not-projected': {
     std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
@@ -736,7 +757,7 @@ const centralMessageTexts = {
   },
   'type-unsupported-rewrite': {
     std:  'Rewriting the ON-condition not supported here', // unused: merge with 'rewrite-not-supported'
-    'sub-element': 'Rewriting the ON-condition of unmanaged association in sub element is not supported'
+    'sub-element': 'Rewriting the ON-condition of unmanaged association in sub element is not supported',
   },
   'rewrite-undefined-key': 'Expected element $(ID) to be available in $(TARGET), as it is required to match the foreign key of $(NAME)',
 
@@ -780,8 +801,8 @@ const centralMessageTexts = {
     std: 'Unexpected $(KEYWORD) on an association/composition', // unused
     multi: 'Unexpected $(KEYWORD); expected exactly one foreign key in combination with default value, but found $(COUNT)',
     structuredKey: 'Unexpected $(KEYWORD) in combination with structured foreign key $(NAME); $(KEYWORD) requires a non-structured foreign key',
-    'onCond': 'Unexpected $(KEYWORD) on an association/composition with ON-condition; $(KEYWORD) requires exactly one foreign key',
-    'targetAspect': 'Unexpected $(KEYWORD) on composition of aspect',
+    onCond: 'Unexpected $(KEYWORD) on an association/composition with ON-condition; $(KEYWORD) requires exactly one foreign key',
+    targetAspect: 'Unexpected $(KEYWORD) on composition of aspect',
     map: 'Unexpected $(KEYWORD) for type $(TYPE)',
   },
   'type-expecting-service-target': {
@@ -805,17 +826,17 @@ const centralMessageTexts = {
   'ext-undefined-key': 'Foreign key $(NAME) has not been found',
   'ext-undefined-action': {
     std: 'Action $(ART) has not been found',
-    action: 'Artifact $(ART) has no action $(NAME)'
+    action: 'Artifact $(ART) has no action $(NAME)',
   },
   'ext-undefined-param': {
     std: 'Parameter $(ART) has not been found',
-    param: 'Artifact $(ART) has no parameter $(NAME)'
+    param: 'Artifact $(ART) has no parameter $(NAME)',
   },
 
   // annotation checks against their definition
   'anno-expecting-value': {
-    'std':  'Expecting a value for the annotation; see annotation definition for $(ANNO)',
-    'type':  'Expecting a value of type $(TYPE) for the annotation'
+    std:  'Expecting a value for the annotation; see annotation definition for $(ANNO)',
+    type:  'Expecting a value of type $(TYPE) for the annotation',
   },
 
   'def-unexpected-paramview-assoc': {
@@ -831,8 +852,8 @@ const centralMessageTexts = {
   },
   'def-unexpected-calcview-assoc': {
     std: 'unused',
-    'source': 'Unexpected definition of an association in an entity annotated with $(ANNO)',
-    'target': 'Expected association target not to be annotated with $(ANNO)',
+    source: 'Unexpected definition of an association in an entity annotated with $(ANNO)',
+    target: 'Expected association target not to be annotated with $(ANNO)',
   },
   'def-invalid-key': {
     std: 'The current element can\'t be defined as primary key', // (unused)
@@ -865,7 +886,12 @@ const centralMessageTexts = {
 
   'def-missing-element': {
     std: 'Expecting entity to have at least one element which is neither virtual nor calculated',
-    view: 'Expecting view to have at least one non-virtual element'
+    view: 'Expecting view to have at least one non-virtual element',
+  },
+
+  'def-missing-argument': {
+    std: 'Expected function $(NAME) to have $(N) arguments, received $(LITERAL)',
+    alternative: 'Expected function $(NAME) to have $(N) or $(M) arguments, received $(LITERAL)',
   },
 
   'def-invalid-texts-aspect': {
@@ -873,7 +899,7 @@ const centralMessageTexts = {
     'no-aspect': '$(ART) must be an aspect',
     key: '$(ART) must be a key',
     'no-key': '$(ART) must not be key',
-    'missing': '$(ART) must have an element $(NAME)',
+    missing: '$(ART) must have an element $(NAME)',
   },
   'def-invalid-element-type': {
     std: 'Element $(ELEMREF) of $(ART) must be of type $(TYPE)',
@@ -961,7 +987,7 @@ const centralMessageTexts = {
   'ext-duplicate-extend-type-unrelated-layer': 'Duplicate type extension for type $(TYPE)',
   'ext-invalid-type-property':  {
     std: 'Type property $(PROP) can only be extended',
-    'indirect': 'Type property $(PROP) can only be extended if directly provided at the definition',
+    indirect: 'Type property $(PROP) can only be extended if directly provided at the definition',
     'new-prop': 'Type property $(PROP) can only be extended, not added',
     string: 'Only numerical properties can be extended, but found string for $(PROP)',
     number: 'Value of type property $(PROP) must be $(NUMBER) or higher, it can\'t be smaller than originally provided',
@@ -979,11 +1005,11 @@ const centralMessageTexts = {
     std: 'Target $(TARGET) of $(NAME) is missing element $(ID); use $(KEYWORD) with an explicit ON-condition',
     redirected: 'Target $(TARGET) of $(NAME) is missing element $(ID); add an ON-condition to $(KEYWORD)',
   },
-  '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-unexpected-assoc-hdbcds': 'Publishing a managed association in a view is not possible for “hdbcds” naming mode',    // eslint-disable-line cds-compiler/message-no-quotes
+  'query-unexpected-structure-hdbcds': 'Publishing a structured element in a view is not possible for “hdbcds” naming mode', // eslint-disable-line cds-compiler/message-no-quotes
   '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'
+    sql: 'Ignoring nullability constraint on parameter when generating SQL view',
   },
   'query-ignoring-filter': {
     std: 'Ignoring filter on published association due to explicit redirection', // unused
@@ -996,7 +1022,7 @@ const centralMessageTexts = {
   },
   'query-unsupported-calc': {
     std: 'Using nested projections next to calculated elements is not supported, yet',
-    inside: 'Using calculated elements in nested projections is not supported, yet'
+    inside: 'Using calculated elements in nested projections is not supported, yet',
   },
   'query-mismatched-element': {
     std: 'Specified element $(NAME) differs from inferred element in property $(PROP)',
@@ -1017,8 +1043,8 @@ const centralMessageTexts = {
     calculatedElement: 'Unexpected property $(PROP) in the specified element $(NAME); calculated elements are not supported in queries',
   },
   'query-ignoring-assoc-in-union': {
-    'managed': 'Ignoring managed association $(NAME) that is published in a UNION',
-    'std': 'Ignoring association $(NAME) that is published in a UNION'
+    managed: 'Ignoring managed association $(NAME) that is published in a UNION',
+    std: 'Ignoring association $(NAME) that is published in a UNION',
   },
   'query-missing-element': {
     std: 'Element $(ID) is missing in specified elements',
@@ -1060,7 +1086,7 @@ const centralMessageTexts = {
 
   'type-unsupported-key-sqlite': {
     std: 'Added element $(ID) is a primary key change and will not work with dialect $(NAME)',
-    changed: 'Changed element $(ID) is a primary key change and will not work with dialect $(NAME)'
+    changed: 'Changed element $(ID) is a primary key change and will not work with dialect $(NAME)',
   },
 
   'type-invalid-cast': {
@@ -1070,7 +1096,7 @@ const centralMessageTexts = {
     'expr-to-structure': 'Can\'t cast an expression to a structured type',
     'val-to-structure': 'Can\'t cast $(VALUE) to a structured type',
     'from-assoc': 'Invalid type cast on an association',
-    'assoc': 'Can\'t cast to an association',
+    assoc: 'Can\'t cast to an association',
   },
 
   // -----------------------------------------------------------------------------------
@@ -1119,9 +1145,9 @@ const centralMessageTexts = {
   'odata-spec-violation-constraints': 'Partial referential constraints produced for OData $(VERSION)',
   'odata-spec-violation-id': {
     std: 'Expected EDM 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 EDM Name $(ID) for OData $(VERSION)',
-    'qualifier': 'Expected 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 vocabulary reference attribute $(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 EDM Name $(ID) for OData $(VERSION)',
+    qualifier: 'Expected 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 vocabulary reference attribute $(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': {
@@ -1134,7 +1160,7 @@ const centralMessageTexts = {
   },
   '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
+    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)',
@@ -1146,7 +1172,7 @@ const centralMessageTexts = {
     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)'
+    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': {
@@ -1162,15 +1188,15 @@ const centralMessageTexts = {
   },
   '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)'
+    oncond: 'No OData navigation property generated for association with arbitrary ON-condition and target $(TARGET) 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)',
   'odata-ignoring-param-default': {
-    'std': 'Ignoring default value',
-    'xpr': 'Ignoring unexpected expression as default value',
-    'colitem': 'Ignoring unexpected default value for a structured or collection like parameter',
+    std: 'Ignoring default value',
+    xpr: 'Ignoring unexpected expression as default value',
+    colitem: 'Ignoring unexpected default value for a structured or collection like parameter',
   },
   // -----------------------------------------------------------------------------------
   // All odata-anno MUST have a '$(ANNO)' parameter to indicate error location
@@ -1178,101 +1204,100 @@ const centralMessageTexts = {
   // Annotation Preprocessing:
   // -----------------------------------------------------------------------------------
   'odata-anno-preproc': {
-    'std': 'unused message text',
-    'nokey': 'Expected target $(NAME) to have a key element for $(ANNO)',
-    'multkeys': 'Expected target $(NAME) to have only one key element for $(ANNO)',
-    'vhlnokey': 'Expected value help list entity $(NAME) to have a key element for $(ANNO)',
-    'vhlmultkeys': 'Expected value help list entity $(NAME) to have only one key element for $(ANNO)',
-    'notforentity': 'Unexpected usage of $(ANNO) for an entity',
-    'viaassoc': 'Expected value to be a path for $(ANNO)',
-    'noassoc': 'Expected association $(ID) to exist for $(ANNO)',
-    'vallistignored': '$(NAME) is ignored for $(ANNO) as $(CODE) is present',
-    'notastring': 'Expected value to be a string for $(ANNO)',
-    'notexist': 'Expected entity $(ID) to exist for $(ANNO)',
-    'txtarr': 'Expected $(ANNO) shortcut to have a $(NAME) annotation'
+    std: 'unused message text',
+    nokey: 'Expected target $(NAME) to have a key element for $(ANNO)',
+    multkeys: 'Expected target $(NAME) to have only one key element for $(ANNO)',
+    vhlnokey: 'Expected value help list entity $(NAME) to have a key element for $(ANNO)',
+    vhlmultkeys: 'Expected value help list entity $(NAME) to have only one key element for $(ANNO)',
+    notforentity: 'Unexpected usage of $(ANNO) for an entity',
+    viaassoc: 'Expected value to be a path for $(ANNO)',
+    noassoc: 'Expected association $(ID) to exist for $(ANNO)',
+    vallistignored: '$(NAME) is ignored for $(ANNO) as $(CODE) is present',
+    notastring: 'Expected value to be a string for $(ANNO)',
+    notexist: 'Expected entity $(ID) to exist for $(ANNO)',
+    txtarr: 'Expected $(ANNO) shortcut to have a $(NAME) annotation',
   },
   // -----------------------------------------------------------------------------------
   // GenericTranslation:
   // -----------------------------------------------------------------------------------
   'odata-anno-dict': {
     // ANNO w/o sub elements, term qualifiers and context stack
-    'std': 'Vocabulary dictionary inconsistency: Type $(TYPE) not found for $(ANNO)',
-    'experimental': '$(ANNO) is experimental and can be changed or removed at any time, do not use productively!',
-    'redefinition': '$(ANNO) is an official OASIS/SAP annotation and can\'t be redefined'
+    std: 'Vocabulary dictionary inconsistency: Type $(TYPE) not found for $(ANNO)',
+    experimental: '$(ANNO) is experimental and can be changed or removed at any time, do not use productively!',
+    redefinition: '$(ANNO) is an official OASIS/SAP annotation and can\'t be redefined',
   },
   'odata-anno-vocref': {
-    'std': 'Vocabulary reference $(ID) doesn\'t match alias $(NAME), reference is ignored',
-    'redef': 'Vocabulary reference $(ID) is the alias of the official OASIS/SAP vocabulary $(TYPE) which can\'t be redefined, reference is ignored',
-    'service': 'Vocabulary reference collides with service $(NAME), reference is ignored',
-    'malformed': 'Vocabulary reference $(ID) has invalid or missing value for attribute $(NAME), reference is ignored'
+    std: 'Vocabulary reference $(ID) doesn\'t match alias $(NAME), reference is ignored',
+    redef: 'Vocabulary reference $(ID) is the alias of the official OASIS/SAP vocabulary $(TYPE) which can\'t be redefined, reference is ignored',
+    service: 'Vocabulary reference collides with service $(NAME), reference is ignored',
+    malformed: 'Vocabulary reference $(ID) has invalid or missing value for attribute $(NAME), reference is ignored',
   },
   'odata-anno-dict-enum': {
-    'std' : 'Unexpected annotation definition $(NAME) with many enum type',
-    'type': 'Unexpected annotation definition $(NAME) with many enum type $(TYPE)',
-    'value': 'Expected all enum elements of type $(TYPE) to have a value in annotation definition $(NAME)'
+    std : 'Unexpected annotation definition $(NAME) with many enum type',
+    type: 'Unexpected annotation definition $(NAME) with many enum type $(TYPE)',
+    value: 'Expected all enum elements of type $(TYPE) to have a value in annotation definition $(NAME)',
   },
   'odata-anno-value': {
-    'nested': 'Missing $(STR) annotation for $(ANNO)',
+    nested: 'Missing $(STR) annotation for $(ANNO)',
     // -----------------------------------------------------------------------------------
     // All messages of odata-anno-value below here MUST have $(ANNO) filled with msgctx.anno
     // -----------------------------------------------------------------------------------
-    '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)',
-    'multexpr': 'EDM JSON code contains more than one dynamic expression: $(RAWVALUES) for $(ANNO)',
+    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)',
+    multexpr: 'EDM JSON code contains more than one dynamic expression: $(RAWVALUES) for $(ANNO)',
   },
   'odata-anno-type': {
-    'std': '$(NAME) is not a known property for $(ANNO) of type $(TYPE)',
-    'unknown': '$(TYPE) is not a known vocabulary type for $(ANNO)',
-    'abstract': 'Unexpected abstract type $(TYPE) for $(ANNO), use $(CODE) to specify a concrete type',
-    'derived': 'Expected specified $(TYPE) to be derived from $(NAME) for $(ANNO)',
-    'literal': 'Expected value $(RAWVALUE) of specified $(CODE) to be a string literal for $(ANNO)'
+    std: '$(NAME) is not a known property for $(ANNO) of type $(TYPE)',
+    unknown: '$(TYPE) is not a known vocabulary type for $(ANNO)',
+    abstract: 'Unexpected abstract type $(TYPE) for $(ANNO), use $(CODE) to specify a concrete type',
+    derived: 'Expected specified $(TYPE) to be derived from $(NAME) for $(ANNO)',
+    literal: 'Expected value $(RAWVALUE) of specified $(CODE) to be a string literal for $(ANNO)',
   },
   'odata-anno-def': {
     // All $(ANNO) w/o sub elements, term qualifiers and context stack
-    'std': '$(ANNO) is not a known annotation in an official OASIS/SAP namespace',
-    'deprecated': '$(ANNO) is deprecated. $(DEPR)',
-    'notapplied': '$(ANNO) is not applied (AppliesTo: $(RAWVALUES))',
+    std: '$(ANNO) is not a known annotation in an official OASIS/SAP namespace',
+    deprecated: '$(ANNO) is deprecated. $(DEPR)',
+    notapplied: '$(ANNO) is not applied (AppliesTo: $(RAWVALUES))',
   },
   'odata-anno-xpr': {
-    'std': 'unused',
-    'notadynexpr': '$(OP) is not a renderable dynamic expression in $(ANNO)',
-    'use': 'Function $(OP) is not a renderable dynamic expression in $(ANNO), use $(CODE) instead',
-    'canonfuncalias': 'Expected function name $(CODE) to be of the form $(META).$(OTHERMETA) for $(OP) in $(ANNO)',
-    'unexpected': 'Unexpected expression in $(ANNO)',
-  }
-  ,
+    std: 'unused',
+    notadynexpr: '$(OP) is not a renderable dynamic expression in $(ANNO)',
+    use: 'Function $(OP) is not a renderable dynamic expression in $(ANNO), use $(CODE) instead',
+    canonfuncalias: 'Expected function name $(CODE) to be of the form $(META).$(OTHERMETA) for $(OP) in $(ANNO)',
+    unexpected: 'Unexpected expression in $(ANNO)',
+  },
   'odata-anno-xpr-type': {
-    'std': 'Expected one qualified type name for $(OP) in $(ANNO)',
-    'edm': 'Expected a qualified EDM type name for $(OP) in $(ANNO) but found $(TYPE)'
+    std: 'Expected one qualified type name for $(OP) in $(ANNO)',
+    edm: 'Expected a qualified EDM type name for $(OP) in $(ANNO) but found $(TYPE)',
   },
   'odata-anno-xpr-args': {
-    'std': 'Unexpected arguments for $(OP) in $(ANNO)',
-    'exactly': 'Expected exactly $(COUNT) argument(s) for $(OP) in $(ANNO)',
-    'atleast': 'Expected at least $(COUNT) argument(s) for $(OP) in $(ANNO)',
-    'atmost': 'Expected at most $(COUNT) argument(s) for $(OP) in $(ANNO)',
-    'wrongcount': 'Expected exactly one $(PROP) for $(OP) in $(ANNO)',
-    'wrongval': 'Unexpected value for $(OP) in $(ANNO)',
-    'wrongval_meta': 'Expected value for $(OP) to be a $(META) in $(ANNO)',
-    'wrongval_meta_list': 'Expected value for $(OP) to be a $(META) or $(RAWVALUES) in $(ANNO)',
+    std: 'Unexpected arguments for $(OP) in $(ANNO)',
+    exactly: 'Expected exactly $(COUNT) argument(s) for $(OP) in $(ANNO)',
+    atleast: 'Expected at least $(COUNT) argument(s) for $(OP) in $(ANNO)',
+    atmost: 'Expected at most $(COUNT) argument(s) for $(OP) in $(ANNO)',
+    wrongcount: 'Expected exactly one $(PROP) for $(OP) in $(ANNO)',
+    wrongval: 'Unexpected value for $(OP) in $(ANNO)',
+    wrongval_meta: 'Expected value for $(OP) to be a $(META) in $(ANNO)',
+    wrongval_meta_list: 'Expected value for $(OP) to be a $(META) or $(RAWVALUES) in $(ANNO)',
   },
   'odata-anno-xpr-ref': {
-    'std': '$(ANNO) can\'t be propagated to $(NAME) because path $(ELEMREF) is not resolvable via type reference $(CODE)',
-    'args': 'Unexpected arguments or filters in $(ELEMREF) in $(ANNO)',
-    'flatten_builtin': 'Expected path $(ELEMREF) in $(ANNO) to end in a scalar typed leaf element while flattening $(NAME)',
-    'flatten_builtin_type': 'Expected path $(ELEMREF) in $(ANNO) to end in a scalar typed leaf element while flattening',
-    'invalid': 'Invalid path $(ELEMREF) in $(ANNO)',
+    std: '$(ANNO) can\'t be propagated to $(NAME) because path $(ELEMREF) is not resolvable via type reference $(CODE)',
+    args: 'Unexpected arguments or filters in $(ELEMREF) in $(ANNO)',
+    flatten_builtin: 'Expected path $(ELEMREF) in $(ANNO) to end in a scalar typed leaf element while flattening $(NAME)',
+    flatten_builtin_type: 'Expected path $(ELEMREF) in $(ANNO) to end in a scalar typed leaf element while flattening',
+    invalid: 'Invalid path $(ELEMREF) in $(ANNO)',
     // genericTranslation
-    'notaparam': 'EDM Element path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a parameter entity',
-    'notaneelement': 'EDM Parameter path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a type entity',
-    'notrendered': 'EDM Path step $(COUNT) of $(ELEMREF) in $(ANNO) refers to an unrendered property in the OData API',
-    'magic': 'Unexpected magic variable $(ELEMREF) in $(ANNO)',
-    'bparam_v2_expl': 'Unexpected explicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
-    'bparam_v2_impl': 'Unexpected implicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
+    notaparam: 'EDM Element path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a parameter entity',
+    notaneelement: 'EDM Parameter path $(ELEMREF) can\'t be used in $(ANNO) which is applied to a type entity',
+    notrendered: 'EDM Path step $(COUNT) of $(ELEMREF) in $(ANNO) refers to an unrendered property in the OData API',
+    magic: 'Unexpected magic variable $(ELEMREF) in $(ANNO)',
+    bparam_v2_expl: 'Unexpected explicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
+    bparam_v2_impl: 'Unexpected implicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
     // forOdata/generateForeignKeys
-    'fk_substitution': 'Expected foreign key path $(ELEMREF) in $(ANNO) to end in a scalar typed leaf element',
+    fk_substitution: 'Expected foreign key path $(ELEMREF) in $(ANNO) to end in a scalar typed leaf element',
   },
   // -----------------------------------------------------------------------------------
   // OData Message section ends here, no messages below this line
@@ -1282,36 +1307,36 @@ const centralMessageTexts = {
   // -----------------------------------------------------------------------------------
   'migration-unsupported-key-change': {
     std: 'Added element $(ID) is a primary key change and will not work if the table contains data',
-    changed: 'Changed element $(ID) is a primary key change and will not work if the table contains data'
+    changed: 'Changed element $(ID) is a primary key change and will not work if the table contains data',
   },
-  'migration-unsupported-precision-change': { 
+  'migration-unsupported-precision-change': {
     std: 'Changed element $(ID) is a precision change and is not supported',
-    script: 'Changed element $(ID) is a precision change and might lead to data loss'
+    script: 'Changed element $(ID) is a precision change and might lead to data loss',
   },
-  'migration-unsupported-element-drop': { 
+  'migration-unsupported-element-drop': {
     std: 'Dropping elements is not supported',
-    script: 'Dropping elements leads to data loss'
+    script: 'Dropping elements leads to data loss',
   },
-  'migration-unsupported-length-change': { 
+  'migration-unsupported-length-change': {
     std: 'Changed element $(ID) is a length reduction and is not supported',
-    script: 'Changed element $(ID) is a length reduction and might lead to data loss'
+    script: 'Changed element $(ID) is a length reduction and might lead to data loss',
   },
-  'migration-unsupported-scale-change': { 
+  'migration-unsupported-scale-change': {
     std: 'Changed element $(ID) is a scale change and is not supported',
-    script: 'Changed element $(ID) is a scale change and might lead to data loss'
+    script: 'Changed element $(ID) is a scale change and might lead to data loss',
   },
-  'migration-unsupported-change': { 
+  'migration-unsupported-change': {
     std: 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported',
-    script: 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and might lead to data loss'
+    script: 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and might lead to data loss',
   },
-  'migration-unsupported-table-drop': { 
+  'migration-unsupported-table-drop': {
     std: 'Dropping tables is not supported',
-    script: 'Dropping tables leads to data loss'
+    script: 'Dropping tables leads to data loss',
   },
   // -----------------------------------------------------------------------------------
   // to.sql.migration specific error messages end here
   // -----------------------------------------------------------------------------------
-}
+};
 
 /**
  * Configuration for a message in the central message register.