@sap/cds-compiler 3.4.0 → 3.4.4

package/CHANGELOG.md

@@ -7,11 +7,31 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+
+## Version 3.4.4 - 2022-11-25
+
+### Fixed
+
+- compiler: CSN flavor `gensrc` (known as `xtended` in `@sap/cds`) lost annotations
+  on enum values and projection columns.
+
+## Version 3.4.2 - 2022-11-11
+
+### Fixed
+
+- Don't propagate `@cds.external` (The CDS Importer adds `@cds.external` for all
+  imported definitions beginning with cds-dk@6.3.0, see CAP release log).
+- for.odata: Ignore all `@cds.external` definitions.
+- to.sql: For sql dialect `h2`, don't turn a Decimal with length 0 into a Decfloat.
+- Extending a projection with an aspect could result in incorrect auto-redirection.
+- Annotations of aspects were not properly propagated to projections under some order-specific circumstances.
+
 ## Version 3.4.0 - 2022-10-26
 
 ### Added
 
-- to.sql: Add support for sql dialect `h2`, which renders SQL for H2 2.x
+- to.sql: Add support for sql dialect `h2`, which renders SQL for H2 2.x.
+- Projections can now be extended by annotation-only aspects, e.g. `extend P with MyAspect;`.
 
 ### Fixed
 

package/bin/cdsc.js

@@ -505,7 +505,7 @@ function executeCommandLine(command, options, args) {
       let hasAtLeastOneExplanation = false;
       messages.filter(msg => messageLevels[msg.severity] <= options.warning).forEach((msg) => {
         hasAtLeastOneExplanation = hasAtLeastOneExplanation || main.hasMessageExplanation(msg.messageId);
-        const name = msg.location && msg.location.file;
+        const name = msg.$location && msg.$location.file;
         const fullFilePath = name ? path.resolve('', name) : undefined;
         log(main.messageStringMultiline(msg, {
           normalizeFilename,
@@ -514,9 +514,8 @@ function executeCommandLine(command, options, args) {
           hintExplanation: true,
           color: options.color,
         }));
-        if (fullFilePath && msg.location.col) {
-          // A message context only makes sense, if we have at least a medium precision,
-          // i.e. line and column for start position.
+        if (fullFilePath && msg.$location.line) {
+          // A message context only makes sense, if we have at least start line
           const context = sourceLines(fullFilePath);
           log(main.messageContext(context, msg, { color: options.color }));
         }

package/bin/cdshi.js

@@ -37,12 +37,25 @@ function highlight( err, buf ) {
     return;
   const chars = [ ...buf ];
   for (const tok of ts.tokens) {
-    const cat = tok.isIdentifier;
-    if (cat && tok.start >= 0) {
-      if (cat !== 'ref' || chars[tok.start] !== '$')
-        chars[tok.start] = categoryChars[cat] || cat.charAt(0);
-      if (tok.stop > tok.start) // stop in ANTLR at last char, not behind
-        chars[tok.start + 1] = '_';
+    if (tok.start < 0)
+      continue;
+    if (tok.$isSkipped) {
+      if (tok.stop > tok.start) {
+        chars[tok.start] = (tok.$isSkipped === true ? '\x0f' : '\x16');
+        chars[tok.stop] = '\x17';
+      }
+      else {
+        chars[tok.start] = (tok.$isSkipped === true ? '\x0e' : '\x15');
+      }
+    }
+    else {
+      const cat = tok.isIdentifier;
+      if (cat) {
+        if (cat !== 'ref' || chars[tok.start] !== '$')
+          chars[tok.start] = categoryChars[cat] || cat.charAt(0);
+        if (tok.stop > tok.start) // stop in ANTLR at last char, not behind
+          chars[tok.start + 1] = '_';
+      }
     }
   }
   for (const c of chars)

package/doc/CHANGELOG_ARCHIVE.md

@@ -154,7 +154,7 @@ The compiler behaviour concerning `beta` features can change at any time without
 - When the option `addTextsLanguageAssoc` is set to true and
   the model contains an entity `sap.common.Languages` with an element `code`,
   all generated texts entities additionally contain an element `language`
-  which is an association to `sap.common.Languages` using element `local`.
+  which is an association to `sap.common.Languages` using element `locale`.
 - for.odata:
   + In `--odata-format=flat`, structured view parameters are flattened like elements.
 - to.hdbcds

package/lib/api/main.js

@@ -12,11 +12,12 @@ const forOdataNew = lazyload('../transform/forOdataNew.js');
 const toSql = lazyload('../render/toSql');
 const toCdl = require('../render/toCdl');
 const modelCompare = lazyload('../modelCompare/compare');
-const diffFilter = lazyload('../modelCompare/filter');
+const diffFilter = lazyload('../modelCompare/utils/filter');
 const sortViews = lazyload('../model/sortViews');
 const csnUtils = lazyload('../model/csnUtils');
 const timetrace = lazyload('../utils/timetrace');
 const forRelationalDB = lazyload('../transform/forRelationalDB');
+const sqlUtils = lazyload('../render/utils/sql');
 
 /**
  * Return the artifact name for use for the hdbresult object
@@ -398,10 +399,12 @@ function sqlMigration(csn, options, beforeImage) {
     Object.entries(diff.deletions).forEach(entry => diffFilterObj.deletion(entry, error));
   }
 
+  const identifierUtils = sqlUtils.getIdentifierUtils(internalOptions);
+
   const drops = {
     creates: {},
     final: Object.entries(diff.deletions).reduce((previous, [ name, artifact ]) => {
-      previous[name] = `DROP ${ (artifact.query || artifact.projection) ? 'VIEW' : 'TABLE' } ${ artifact['@cds.persistence.name'] };`;
+      previous[name] = `DROP ${ (artifact.query || artifact.projection) ? 'VIEW' : 'TABLE' } ${ identifierUtils.quoteSqlId(artifact['@cds.persistence.name']) };`;
       return previous;
     }, {}),
   };
@@ -417,7 +420,7 @@ function sqlMigration(csn, options, beforeImage) {
         (diffArtifact.query || diffArtifact.projection) &&
         (diffArtifact[modelCompare.isChanged] === true || // we know it changed because we compared two views
           diffArtifact[modelCompare.isChanged] === undefined)) { // if it was removed in the after, then we don't have the flag
-        drops.creates[artifactName] = `DROP VIEW ${ diffArtifact['@cds.persistence.name'] };`;
+        drops.creates[artifactName] = `DROP VIEW ${ identifierUtils.quoteSqlId(diffArtifact['@cds.persistence.name']) };`;
       } // TODO: What happens with a changed kind -> entity becomes a view?
       else if (diffArtifact &&
         diffArtifact['@cds.persistence.skip'] !== true &&

package/lib/base/message-registry.js

@@ -98,7 +98,7 @@ const centralMessages = {
   'ref-sloppy-target': { severity: 'Warning' },
 
   'extend-repeated-intralayer': { severity: 'Warning' },
-  'extend-unrelated-layer':     { severity: 'Warning' },
+  'extend-unrelated-layer':     { severity: 'Info' },
 
   'ext-duplicate-extend-type': { severity: 'Error' },
   'ext-duplicate-extend-type-unrelated-layer': { severity: 'Error', configurableFor: true },
@@ -116,6 +116,7 @@ const centralMessages = {
   'type-ambiguous-target': { severity: 'Warning' },
 
   'ref-autoexposed': { severity: 'Error', configurableFor: 'deprecated' },
+  // Published! Used in @sap/cds-lsp; if renamed, add to oldMessageIds and contact colleagues
   'ref-undefined-art':    { severity: 'Error' },
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
@@ -137,20 +138,22 @@ const centralMessages = {
 
   'expr-unexpected-operator': { severity: 'Error', configurableFor: true },
 
+  // 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-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', configurableFor: true },
-  'syntax-unexpected-property': { severity: 'Error' },
-  'syntax-deprecated-ident': { severity: 'Error', configurableFor: true },
-  'syntax-fragile-alias': { severity: 'Error', configurableFor: true },
-  'syntax-fragile-ident': { severity: 'Error', configurableFor: true },
+  'syntax-duplicate-annotate': { severity: 'Error', configurableFor: 'v3' },
+  'syntax-invalid-name': { severity: 'Error', configurableFor: 'v3' },
+  'syntax-missing-as': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
+  'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
-
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'v3' },
-  'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
 
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
+  'type-unsupported-precision-change': { severity: 'Error'},
 
   'def-missing-element': { severity: 'Error' },
 
@@ -231,7 +234,7 @@ const centralMessageTexts = {
     'flatten-fkey-gen': 'Duplicate definition of foreign key element $(NAME) for association $(ART)',
     'flatten-fkey-exists': 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element',
   },
-  
+
   // Syntax messages, both CDL and CSN parser: ----------------------------------
   'syntax-dollar-ident': {      // Warning, TODO: make it name-invalid-alias
     std: 'An artifact starting with $(NAME) might shadow a special variable - replace by another name',
@@ -239,14 +242,25 @@ 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-duplicate-excluding' (TODO: also CDL)
+
+  'syntax-deprecated-abstract': 'Abstract entity definitions are deprecated; use aspect definitions instead', // Warning, TODO: also use for CSN
+  'syntax-duplicate-excluding': {
+    std: 'Duplicate $(NAME) in the $(KEYWORD) clause',
+    csn: 'Duplicate $(NAME) in property $(PROP)',
+  },
+  'syntax-expecting-integer': { // TODO: currently 'syntax-expecting-natnum' in CSN
+    std: 'A safe integer is expected here',
+    normal: 'An integer number is expected here',
+    unsafe: 'The provided integer is too large',
+  },
   'syntax-ignoring-anno': {
-    std: 'Annotations can\'t be used at prefix references',
-    doc: 'Doc comments can\'t be used at prefix references',
+    std: 'Annotations can\'t be used in a column with $(CODE)',
+    doc: 'Doc comments can\'t be used in a column with $(CODE)',
   },
   'syntax-invalid-name': {
-    std: 'Identifier for name must not be empty', // TODO: use
+    std: 'Identifier must consist of at least one character',
     csn: 'Property name in dictionary $(PARENTPROP) must not be empty',
+    as: 'String in property $(PROP) must not be empty', // TODO: use
   },
   'syntax-invalid-literal': {   // TODO: write texts less CDL specific
     'std': 'Invalid literal',
@@ -268,20 +282,44 @@ const centralMessageTexts = {
     csn: 'The property $(PROP) is not supported',
   },
 
-  // Syntax messages, CDL parser - default: Error  ------------------------------
+  // Syntax messages, CDL parser  -----------------------------------------------
+  // 'syntax-deprecated-auto-as', 'syntax-deprecated-ident'
   'syntax-duplicate-annotate': 'You can\'t refer to $(NAME) repeatedly with property $(PROP) in the same annotate statement',
+  'syntax-duplicate-argument': {
+    std: 'Duplicate value for parameter $(NAME)',
+    type: 'Duplicate value for type parameter $(NAME)',
+  },
   'syntax-duplicate-extend': {
     std: 'You can\'t define and refer to $(NAME) repeatedly in the same extend statement',
     define: 'You can\'t refer to $(NAME) in the same extend statement where it was defined',
     extend: 'You can\'t refer to $(NAME) repeatedly in the same extend statement',
   },
-  'syntax-invalid-extend': 'Can\'t extend an element with $(KIND)',
+  // 'syntax-duplicate-anno', 'syntax-duplicate-doc-comment', 'syntax-duplicate-cardinality',
+  // 'syntax-duplicate-property'
+  'syntax-unexpected-reserved-word': '$(CODE) is a reserved word - write $(DELIMITED) instead if you want to use it as name',
   'syntax-invalid-text-block': 'Missing newline in text block',
+  // 'syntax-missing-newline' (Warning), 'syntax-missing-as',
+  // 'syntax-missing-token'
+  '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)'
+  },
+  'syntax-unexpected-vocabulary': {
+    std: 'Annotations can\'t be defined inside contexts or services', // not used
+    service: 'Annotations can\'t be defined inside services',
+    context: 'Annotations can\'t be defined inside contexts',
+  },
+  // 'syntax-unexpected-space', 'syntax-unexpected-doc-comment' (TODO is: -ignoring-, Info)
+  // 'syntax-unexpected-alias' (is 'syntax-unexpected-property' in CSN),
+  // 'syntax-unexpected-right-paren'
+  'syntax-unsupported-calc-field': 'Calculated fields are not supported',
   'syntax-unsupported-param': {
     std: 'Parameter not supported', // unused
-    dynamic: 'Dynamic parameter $(NAME) is not supported',
-    positional: 'Positional parameter $(NAME) is not supported',
+    dynamic: 'Dynamic parameter $(CODE) is not supported',
+    positional: 'Positional parameter $(CODE) is not supported',
   },
+  // 'syntax-unsupported-method', 'syntax-unsupported-new'
 
   // Syntax messages, CSN parser - default: Error  ------------------------------
   // TODO: use one id with text variants instead of several message ids
@@ -314,10 +352,10 @@ const centralMessageTexts = {
     std: 'Object in $(PROP) must have at least one valid CSN property',
     as: 'Object in $(PROP) must have at least one valid CSN property other than $(OTHERPROP)',
   },
-  // 'syntax-invalid-ref' (Warning?), 'syntax-invalid-kind', 'syntax-invalid-literal' (Warning)
   'syntax-invalid-string': {
     std: 'Invalid string value in property $(PROP)',
   },
+  // 'syntax-invalid-ref' (Warning?), 'syntax-invalid-kind', 'syntax-invalid-literal' (Warning)
   'syntax-missing-property': {  // location at sibling or '}' otherwise
     std: 'Object in $(PARENTPROP) must have the property $(PROP)',
     sibling: 'Object with property $(SIBLINGPROP) must also have a property $(PROP)',
@@ -335,6 +373,7 @@ const centralMessageTexts = {
   },
   // 'syntax-unknown-property' (Warning? Better configurable Error)
 
+  // multi-line strings: --------------------------------------------------------
   'syntax-unknown-escape': 'Unknown escape sequence $(CODE)',
   'syntax-invalid-escape': {
     std: 'Invalid escape sequence $(CODE)',
@@ -350,24 +389,6 @@ const centralMessageTexts = {
     std: 'Missing escape. Replace $(CODE) with $(NEWCODE)',
     placeholder: 'Placeholders are not supported. Replace $(CODE) with $(NEWCODE)',
   },
-  'syntax-expecting-integer': {
-    std: 'A safe integer is expected here',
-    normal: 'An integer number is expected here',
-    unsafe: 'The provided integer is too large',
-  },
-  'syntax-duplicate-argument': { // TODO: also CDL
-    std: 'Unexpected argument $(CODE)',
-    unknown: 'Unknown argument $(CODE)', // huh?
-    duplicate: 'Duplicate argument $(CODE)',
-  },
-  'syntax-unexpected-null': 'Keyword $(KEYWORD) must appear after the enum definition and not before',
-  'syntax-unexpected-vocabulary': {
-    std: 'Annotations can\'t be defined inside contexts or services',
-    service: 'Annotations can\'t be defined inside services',
-    context: 'Annotations can\'t be defined inside contexts',
-  },
-  'syntax-fragile-ident': '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it',
-  'syntax-unsupported-field': 'Calculated fields are not supported, yet',
 
   // Syntax messages for errorneous references ----------------------------------
   // location at errorneous reference (if possible)
@@ -543,7 +564,7 @@ const centralMessageTexts = {
   // version independent messages
   'odata-spec-violation-key-array': {
     std: 'Unexpected array type for element $(NAME)',
-    scalar: 'Unexpected array type'
+    scalar: 'Unexpected array type',
   },
   'odata-spec-violation-key-null': {
     std: 'Expected key element $(NAME) to be not nullable', // structured
@@ -559,6 +580,8 @@ const centralMessageTexts = {
     std: 'Expected element to have a type',
     incompatible: 'Unexpected EDM Type $(TYPE) for OData $(VERSION)',
     facet: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION)',
+    missing: 'Expected referenced type $(TYPE) to be included in service $(NAME)',
+    external: 'Referenced type $(TYPE) marked as $(ANNO) can\'t be rendered as $(CODE) in service $(NAME) for OData $(VERSION)',
   },
   'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(KIND)',
   'odata-spec-violation-namespace': {
@@ -583,7 +606,7 @@ const centralMessageTexts = {
  *
  * @typedef {object} MessageConfig
  * @property {MessageSeverity} severity Default severity for the message.
- * @property {string[]|'deprecated'|true} [configurableFor]
+ * @property {string[]|'deprecated'|'v3'|true} [configurableFor]
  *        Whether the error can be reclassified to a warning or lower.
  *        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'.

package/lib/base/messages.js

@@ -655,7 +655,7 @@ const paramsTransform = {
   alias: quoted,
   anno: a => (a.charAt(0) === '@' ? quote.double( a ) : quote.double( '@' + a )),
   annos: anno => anno.map(paramsTransform.anno).join(', '),
-  delimited: n => '![' + n + ']', // TODO: use quote.single around?
+  delimited: n => quote.single( `![${ n }]` ), // represent as delimited id (TODO: double-']')
   file: quote.single,
   prop: quote.single,
   siblingprop: quote.single,
@@ -671,6 +671,7 @@ const paramsTransform = {
   line: quote.number,
   col: quote.number,
   value: n => (typeof n !== 'number' ? quote.single( n ) : quote.number( n )),
+  values: value => value.map(paramsTransform.value).join(', '),
   othervalue: n => (typeof n !== 'number' ? quote.single( n ) : quote.number( n )),
   art: transformArg,
   service: transformArg,
@@ -707,7 +708,9 @@ function transformManyWith( t, sorted ) {
 }
 
 function quoted( name ) {
-  return (name) ? quote.double( name ) : quote.angle( '?' ); // TODO: failure in --test-mode, then remove
+  if (typeof name === 'string')
+    return quote.double( name );
+  throw new CompilerAssertion( `Expecting a string, not ${ name }` );
 }
 
 function tokenSymbol( token ) {
@@ -799,7 +802,8 @@ function messageText( texts, params, transform ) {
   let args = {};
   for (let p in params) {
     let t = transform && transform[p] || paramsTransform[p];
-    args[p] = (t) ? t( params[p], args, params, texts ) : params[p];
+    if (params[p] !== undefined)
+      args[p] = (t) ? t( params[p], args, params, texts ) : params[p];
   }
   let variant = args['#'];
   return replaceInString( variant && texts[ variant ] || texts.std, args );

package/lib/checks/.eslintrc.json

@@ -14,6 +14,8 @@
     "jsdoc/require-property": 0,
     // most of the main functions have the normal forEachArtifact/Member signature anyway
     "jsdoc/require-param-description": 0,
+    // there seem to be false positives
+    "jsdoc/require-returns-check": 0,
     // =airbnb, >eslint:
     "max-len": [ "error", {
       "code": 110,

package/lib/compiler/.eslintrc.json

@@ -1,4 +1,7 @@
 {
   "root": true,
-  "extends": "../../.eslintrc-ydkjsi.json"
+  "extends": "../../.eslintrc-ydkjsi.json",
+  "rules": {
+    "cds-compiler/space-in-func-decl": "error"
+  }
 }

package/lib/compiler/assert-consistency.js

@@ -404,7 +404,6 @@ function assertConsistency( model, stage ) {
       // TODO: "yes" instead "none": val: true, optional literal/location
       val: {
         requires: [ 'literal', 'location' ],
-        // TODO: rename symbol to sym
         // TODO: struct and variant only for annotation assignments
         optional: [
           'val', 'sym', 'name', '$inferred', '$parens',
@@ -441,7 +440,7 @@ function assertConsistency( model, stage ) {
       test: isVal,              // the following for array/struct value
       requires: [ 'location' ],
       optional: [
-        'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicate', 'upTo',
+        'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
       ],
       // TODO: restrict path to #simplePath
     },
@@ -462,7 +461,10 @@ function assertConsistency( model, stage ) {
     join: { test: locationVal( isString ) },
     quantifier: { test: locationVal( isString ) },
     // preliminary -----------------------------------------------------------
-    doc: { kind: true, test: locationVal( isStringOrNull ) }, // doc comment
+    doc: {
+      kind: true,
+      test: locationVal( isStringOrNull ),
+    }, // doc comment
     '@': {
       kind: true,
       inherits: 'value',
@@ -888,7 +890,7 @@ function assertConsistency( model, stage ) {
     return function valWithLocation( node, parent, prop, spec, name ) {
       const valSchema = { val: Object.assign( {}, spec, { test: func } ) };
       const requires = [ 'val', 'location' ];
-      const optional = [ 'literal', '$inferred', '_pathHead' ];
+      const optional = [ 'literal', '$inferred', '$priority', '_pathHead' ];
       standard( node, parent, prop, { schema: valSchema, requires, optional }, name );
     };
   }
@@ -912,7 +914,7 @@ function assertConsistency( model, stage ) {
       isString(node, parent, prop, spec);
   }
 
-  function isOneOf(values) {
+  function isOneOf( values ) {
     return function isOneOfInner( node, parent, prop ) {
       if (!values.includes(node))
         throw new Error( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
@@ -959,7 +961,7 @@ function assertConsistency( model, stage ) {
     }
   }
 
-  function isScope(node, parent, prop) {
+  function isScope( node, parent, prop ) {
     // artifact refs in CDL have scope:0 in XSN
     if (Number.isInteger(node))
       return;

package/lib/compiler/builtins.js

@@ -259,7 +259,7 @@ const quotedLiteralPatterns = {
  *
  * @returns {boolean} True if the date is valid.
  */
-function checkDate(year, month, day) {
+function checkDate( year, month, day ) {
   // Negative years are allowed
   year = Math.abs(Number.parseInt(year, 10));
   month = Number.parseInt(month, 10);
@@ -275,7 +275,7 @@ function checkDate(year, month, day) {
  *
  * @returns {boolean} True if the date is valid.
  */
-function checkTime(hour, minutes, seconds) {
+function checkTime( hour, minutes, seconds ) {
   hour = Number.parseInt(hour, 10);
   minutes = Number.parseInt(minutes, 10);
   seconds = seconds ? Number.parseInt(seconds, 10) : 0;
@@ -311,35 +311,35 @@ Object.keys(coreHana).forEach((type) => {
 });
 
 /** @param {string} typeName */
-function isIntegerTypeName(typeName) {
+function isIntegerTypeName( typeName ) {
   return typeCategories.integer.includes(typeName);
 }
 /** @param {string} typeName */
-function isDecimalTypeName(typeName) {
+function isDecimalTypeName( typeName ) {
   return typeCategories.decimal.includes(typeName);
 }
 /** @param {string} typeName */
-function isNumericTypeName(typeName) {
+function isNumericTypeName( typeName ) {
   return isIntegerTypeName(typeName) || isDecimalTypeName(typeName);
 }
 /** @param {string} typeName */
-function isStringTypeName(typeName) {
+function isStringTypeName( typeName ) {
   return typeCategories.string.includes(typeName);
 }
 /** @param {string} typeName */
-function isDateOrTimeTypeName(typeName) {
+function isDateOrTimeTypeName( typeName ) {
   return typeCategories.dateTime.includes(typeName);
 }
 /** @param {string} typeName */
-function isBooleanTypeName(typeName) {
+function isBooleanTypeName( typeName ) {
   return typeCategories.boolean.includes(typeName);
 }
 /** @param {string} typeName */
-function isBinaryTypeName(typeName) {
+function isBinaryTypeName( typeName ) {
   return typeCategories.binary.includes(typeName);
 }
 /** @param {string} typeName */
-function isGeoTypeName(typeName) {
+function isGeoTypeName( typeName ) {
   return typeCategories.geo.includes(typeName);
 }
 /**
@@ -347,7 +347,7 @@ function isGeoTypeName(typeName) {
  *
  * @param {string} typeName
  */
-function isRelationTypeName(typeName) {
+function isRelationTypeName( typeName ) {
   return typeCategories.relation.includes(typeName);
 }
 
@@ -357,7 +357,7 @@ function isRelationTypeName(typeName) {
  * @param {string} absolute
  * @returns {boolean}
  */
-function isInReservedNamespace(absolute) {
+function isInReservedNamespace( absolute ) {
   return absolute.startsWith( 'cds.') &&
     !absolute.match(/^cds\.foundation(\.|$)/) &&
     !absolute.match(/^cds\.outbox(\.|$)/) && // Requested by Node runtime
@@ -375,7 +375,7 @@ function isInReservedNamespace(absolute) {
  * @param {string} type
  * @returns {boolean}
  */
-function isBuiltinType(type) {
+function isBuiltinType( type ) {
   return typeof type === 'string' && isInReservedNamespace(type);
 }