@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/assert-consistency.js

@@ -67,6 +67,9 @@
 'use strict';
 
 const { locationString, hasErrors } = require('../base/messages');
+const {
+  XsnSource, XsnName, XsnArtifact, CsnLocation,
+} = require('./classes');
 
 
 // Properties that can appear where a type can have type arguments.
@@ -77,14 +80,15 @@ const typeProperties = [
 
 class InternalConsistencyError extends Error {
   constructor(msg) {
-    super(`cds-compiler XSN consistency: ${ msg }`);
+    super( `cds-compiler XSN consistency: ${ msg }` );
   }
 }
 
 function assertConsistency( model, stage ) {
   const stageParser = typeof stage === 'object';
   const options = stageParser && stage || model.options || { testMode: true };
-  if (!options.testMode || options.parseOnly && !stageParser)
+  if (!options.testMode || options.testMode === '$noAssertConsistency' ||
+      options.parseOnly && !stageParser)
     return;
 
   const schema = {
@@ -105,6 +109,7 @@ function assertConsistency( model, stage ) {
         '$blocks',
         '$messageFunctions',
         '$functions',
+        '$assert',
         '_sortedSources',
       ],
     },
@@ -122,12 +127,14 @@ function assertConsistency( model, stage ) {
         '$withLocalized',
         '$sources',
       ],
+      instanceOf: XsnSource,
     },
     location: {
       // every thing with a $location in CSN must have a XSN location even
       // with syntax errors (currently even internal artifacts like $using):
       isRequired: parent => noSyntaxErrors() || parent && parent.kind,
       kind: true,
+      instanceOf: CsnLocation,
       requires: [ 'file' ],     // line is optional in top-level location
       optional: [ 'line', 'col', 'endLine', 'endCol', '$notFound' ],
       schema: {
@@ -138,8 +145,8 @@ function assertConsistency( model, stage ) {
         $notFound: { test: isBoolean },
       },
     },
-    sources: { test: isDictionary( isObject ) },
-    _sortedSources: { test: isArray( isObject ) },
+    sources: { test: isDictionary( isObject ), instanceOf: XsnSource },
+    _sortedSources: { test: isArray( isObject ), instanceOf: XsnSource },
     file: { test: isString },
     dirname: { test: isString },  // TODO: really necessary?
     realname: { test: isString }, // TODO: really necessary?
@@ -158,11 +165,13 @@ function assertConsistency( model, stage ) {
       test: isDictionary( definition ),
       requires: [ 'kind', 'location', 'name' ],
       optional: thoseWithKind,
+      instanceOf: XsnArtifact,
     },
     vocabularies: {
       test: isDictionary( definition ),
       requires: [ 'kind', 'name' ],
       optional: thoseWithKind,
+      instanceOf: XsnArtifact,
     },
     extensions: {
       kind: [ 'context' ],        // syntax error (as opposed to HANA CDS), but still there
@@ -174,7 +183,7 @@ function assertConsistency( model, stage ) {
     i18n: {
       test: isDictionary( ( val, parent, prop, spec, lang ) => {
         const textValueIsString = (v, p, textProp, s, textKey) => {
-          isString(v.val, p, textKey, s);
+          isString( v.val, p, textKey, s );
         };
         const innerDict = isDictionary( textValueIsString );
         return innerDict( val, parent, lang, spec );
@@ -197,7 +206,7 @@ function assertConsistency( model, stage ) {
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
-            name: { test: isObject, requires: [ 'id', 'element' ] },
+            name: { test: isObject, instanceOf: XsnName, requires: [ 'id', 'element' ] },
             $autoElement: { test: isString },
             $uncheckedElements: { test: isBoolean },
             $requireElementAccess: { test: isBoolean },
@@ -240,7 +249,7 @@ function assertConsistency( model, stage ) {
     typeProps$: { kind: true, enumerable: false, test: TODO },
     actions: { kind: true, inherits: 'definitions' },
     enum: { kind: true, inherits: 'definitions' },
-    foreignKeys: { kind: true, inherits: 'definitions' },
+    foreignKeys: { kind: true, inherits: 'definitions', instanceOf: 'ignore' },
     $keysNavigation: { kind: true, test: TODO },
     params: { kind: true, inherits: 'definitions' },
     _extendType: { kind: true, test: TODO },
@@ -261,7 +270,8 @@ function assertConsistency( model, stage ) {
         requires: [ 'op', 'location', 'from' ],
         optional: [
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
-          'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit', '_origin', '_block',
+          'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit', '$limit',
+          '_origin', '_block',
           '_projections', '_parent', '_main', '_effectiveType', '$effectiveSeqNo', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
         ],
@@ -275,7 +285,7 @@ function assertConsistency( model, stage ) {
         requires: [ 'op', 'location', 'args', 'join' ],
         optional: [
           'on', '$parens', 'cardinality',
-          'kind', 'name', '_block', '_parent', '_main',
+          'kind', 'name', '_block', '_parent', '_main', '_user',
           '$tableAliases', '_combined', '_joinParent', '$joinArgsIndex',
           '_leadingQuery', '_$next', '_deps',
         ],
@@ -306,6 +316,7 @@ function assertConsistency( model, stage ) {
     columns: {
       kind: [ 'extend', '$column' ],
       test: isArray( column ),
+      instanceOf: XsnArtifact,
       optional: thoseWithKind,
       enum: [ '*' ],
       requires: [ 'location' ],
@@ -325,6 +336,7 @@ function assertConsistency( model, stage ) {
     nulls: { test: locationVal( isString ), enum: [ 'first', 'last' ] },
     $orderBy: { inherits: 'orderBy' },
     groupBy: { inherits: 'value', test: isArray( expression ) },
+    $limit: { test: TODO },
     limit: { requires: [ 'rows' ], optional: [ 'offset', 'location' ] },
     rows: { inherits: 'value' },
     offset: { inherits: 'value' },
@@ -383,6 +395,7 @@ function assertConsistency( model, stage ) {
         'select', '$join', 'mixin',
         'source', 'namespace', 'using',
         '$tableAlias', '$navElement',
+        'builtin', // magic variables
       ],
     },
     // locations of parentheses pairs around expression:
@@ -496,11 +509,12 @@ function assertConsistency( model, stage ) {
       ],
       // TODO: name requires if not in parser?
     },
-    $priority: { test: isOneOf([ undefined, false, 'extend', 'annotate' ]) },
+    $priority: { test: isOneOf( [ undefined, false, 'extend', 'annotate' ] ) },
     $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
     name: {
       isRequired: stageParser && (() => false), // not required in parser
       kind: true,
+      instanceOf: 'ignore', // TODO: XsnName,
       schema: {
         select: { test: TODO },
       }, // TODO: rename query prop in name
@@ -527,6 +541,7 @@ function assertConsistency( model, stage ) {
       kind: [ 'action', 'function' ],
       requires: [ 'kind', 'location' ],
       optional: thoseWithKind,
+      instanceOf: XsnArtifact,
     },
     items: {
       kind: true,
@@ -592,7 +607,8 @@ function assertConsistency( model, stage ) {
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
-        'limit', '_status', '_origin', '_effectiveType', '$effectiveSeqNo',
+        '$limit', 'limit', '_status', '_origin',
+        '_effectiveType', '$effectiveSeqNo',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -634,7 +650,7 @@ function assertConsistency( model, stage ) {
     $inferred: {
       parser: true,
       kind: true,
-      test: isOneOf([
+      test: isOneOf( [
         '', // constructed “super annotate” statement, redirected user-provided target
         // Uppercase values are used in logic, lowercase value are "just for us", i.e.
         // debugging or to add properties such as $generated in Universal CSN.
@@ -666,7 +682,7 @@ function assertConsistency( model, stage ) {
         'rewrite', // on-conditions or FKeys are rewritten
         'parent-origin', // annotation/property copied from parent that does not come through
         //                  $origin and is not a direct annotation
-      ]),
+      ] ),
     },
 
     // Helper property for the XSN-to-CSN transformation, see function setExpandStatus():
@@ -675,7 +691,7 @@ function assertConsistency( model, stage ) {
     $expand: {
       kind: true,
       // See description of `setExpandStatus()` of in `lib/compiler/utils.js`.
-      test: isOneOf([ 'origin', 'annotate', 'target' ]),
+      test: isOneOf( [ 'origin', 'annotate', 'target' ] ),
     },
     $inCycle: { kind: true, test: isBoolean },
 
@@ -683,9 +699,10 @@ function assertConsistency( model, stage ) {
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
     $withLocalized: { test: isBoolean },
     $sources: { parser: true, test: isArray( isString ) },
-    $expected: { parser: true, test: isOneOf([ 'approved-exists', 'exists' ]) },
+    $expected: { parser: true, test: isOneOf( [ 'approved-exists', 'exists' ] ) },
     $messageFunctions: { test: TODO },
     $functions: { test: TODO },
+    $assert: { test: TODO },    // currently just for missing Error[ref-cycle]
   };
   let _noSyntaxErrors = null;
   assertProp( model, null, stageParser ? ':parser' : ':model', null, true );
@@ -714,8 +731,10 @@ function assertConsistency( model, stage ) {
           : {}.propertyIsEnumerable.call( parent, prop ) !== enumerable)
         throw new InternalConsistencyError( `Unexpected enumerability ${ !enumerable }${ at( [ node, parent ], prop ) }` );
     }
-    (spec.test || standard)( node, parent, prop, spec,
-                             typeof noPropertyTest === 'string' && noPropertyTest );
+    if (node !== undefined) { // ignore if undefined
+      (spec.test || standard)( node, parent, prop, spec,
+                               typeof noPropertyTest === 'string' && noPropertyTest );
+    }
   }
 
   function definition( node, parent, prop, spec, name ) {
@@ -768,7 +787,7 @@ function assertConsistency( model, stage ) {
     const requires = spec.requires || [];
     // Do not test 'requires' with parse errors:
     for (const p of requires) {
-      if (!names.includes(p)) {
+      if (!names.includes( p )) {
         const req = spec.schema && spec.schema[p] && spec.schema[p].isRequired;
         if ((req || schema[p] && schema[p].isRequired || noSyntaxErrors)( node ))
           throw new InternalConsistencyError( `Required property '${ p }' missing in object${ at( [ node, parent ], prop, name ) }` );
@@ -776,13 +795,14 @@ function assertConsistency( model, stage ) {
     }
     const optional = spec.optional || [];
     for (const n of names) {
-      const opt = Array.isArray(optional)
+      const opt = Array.isArray( optional )
         ? optional.includes( n ) || optional.includes( n.charAt(0) )
         : optional( n, spec );
-      if (!(opt || requires.includes( n ) || n === '$extra'))
-        throw new InternalConsistencyError( `Property '${ n }' is not expected${ at( [ node[n], node, parent ], prop, name ) }` );
-
-      assertProp( node[n], node, n, spec.schema && spec.schema[n] );
+      if (node[n] !== undefined) {
+        if (!(opt || requires.includes( n ) || n === '$extra'))
+          throw new InternalConsistencyError( `Property '${ n }' is not expected${ at( [ node[n], node, parent ], prop, name ) }` );
+        assertProp( node[n], node, n, spec.schema && spec.schema[n] );
+      }
     }
   }
 
@@ -838,7 +858,7 @@ function assertConsistency( model, stage ) {
     // TODO CSN parser?: { val: <token>, literal: 'token' } for keywords
     if (typeof node === 'string')
       return;
-    while (Array.isArray(node)) {
+    while (Array.isArray( node )) {
       // TODO: also check getOwnPropertyNames(node)
       if (node.length !== 1) {
         node.forEach( n => expression( n, parent, prop, spec ) );
@@ -850,7 +870,7 @@ function assertConsistency( model, stage ) {
       return;
     isObject( node, parent, prop, spec, idx );
 
-    const s = spec[expressionSpec(node)] || {};
+    const s = spec[expressionSpec( node )] || {};
     const sub = Object.assign( {}, s.inherits && schema[s.inherits], s );
     if (spec.requires && sub.requires)
       sub.requires = [ ...sub.requires, ...spec.requires ];
@@ -873,9 +893,9 @@ function assertConsistency( model, stage ) {
   }
 
   function args( node, parent, prop, spec ) {
-    if (Array.isArray(node)) {
+    if (Array.isArray( node )) {
       if (parent.op && parent.op.val === 'xpr') // remove keywords for `xpr` expressions
-        node = node.filter( a => typeof a !== 'string');
+        node = node.filter( a => typeof a !== 'string' );
       node.forEach( (item, idx) => expression( item, parent, prop, spec, idx ) );
     }
     else if (node && typeof node === 'object' && !Object.getPrototypeOf( node )) {
@@ -910,7 +930,7 @@ function assertConsistency( model, stage ) {
 
   function isArray( func = standard ) {
     return function vector( node, parent, prop, spec ) {
-      if (!Array.isArray(node))
+      if (!Array.isArray( node ))
         throw new InternalConsistencyError( `Expected array${ at( [ null, parent ], prop ) }` );
       node.forEach( (item, n) => func( item, parent, prop, spec, n ) );
     };
@@ -921,7 +941,9 @@ function assertConsistency( model, stage ) {
       const valSchema = { val: Object.assign( {}, spec, { test: func } ) };
       const requires = [ 'val', 'location' ];
       const optional = [ 'literal', '$inferred', '$priority', '_pathHead' ];
-      standard( node, parent, prop, { schema: valSchema, requires, optional }, name );
+      standard( node, parent, prop, {
+        schema: valSchema, requires, optional, instanceOf: spec.instanceOf,
+      }, name );
     };
   }
 
@@ -941,33 +963,42 @@ function assertConsistency( model, stage ) {
 
   function isOneOf( values ) {
     return function isOneOfInner( node, parent, prop ) {
-      if (!values.includes(node))
-        throw new InternalConsistencyError( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
+      if (!values.includes( node ))
+        throw new InternalConsistencyError( `Unexpected value '${ node }', expected ${ JSON.stringify( values ) }${ at( [ node, parent ], prop ) }` );
     };
   }
 
   function isString( node, parent, prop, spec ) {
     if (typeof node !== 'string')
-      throw new InternalConsistencyError( `Expected string${ at( [ node, parent ], prop ) }` );
+      throw new InternalConsistencyError( `Expected string but found ${ typeof node }${ at( [ node, parent ], prop ) }` );
       // TODO: also check getOwnPropertyNames(node)
     if (spec.enum && !spec.enum.includes( node ))
       throw new InternalConsistencyError( `Unexpected value '${ node }'${ at( [ node, parent ], prop ) }` );
   }
 
   function isVal( node, parent, prop, spec ) {
-    if (Array.isArray(node))
+    if (Array.isArray( node ))
       node.forEach( (item, n) => standard( item, parent, prop, spec, n ) );
     else if (node !== null && ![ 'string', 'number', 'boolean' ].includes( typeof node ))
       throw new InternalConsistencyError( `Expected array or simple value${ at( [ null, parent ], prop ) }` );
   }
 
   function isObject( node, parent, prop, spec, name ) {
-    if (!node || typeof node !== 'object' || Object.getPrototypeOf( node ) !== Object.prototype)
-      throw new InternalConsistencyError( `Expected standard object${ at( [ null, parent ], prop, name ) }` );
+    if (!node || typeof node !== 'object' )
+      throw new InternalConsistencyError( `Expected object${ at( [ null, parent ], prop, name ) }` );
+    const found = Object.getPrototypeOf( node )?.constructor?.name || 'null';
+    if (!spec.instanceOf && Object.getPrototypeOf( node ) !== Object.prototype)
+      throw new InternalConsistencyError( `Expected standard object but found ${ found }${ at( [ null, parent ], prop, name ) }` );
+    // TODO
+    // else if (spec.instanceOf && spec.instanceOf !== 'ignore' &&
+    //    Object.getPrototypeOf( node ) !== spec.instanceOf.prototype)
+    // eslint-disable-next-line max-len
+    //  throw new InternalConsistencyError( `Expected object of class ${ spec.instanceOf.name } but found ${ found }${ at( [ null, parent ], prop, name ) }` );
   }
 
+
   function inDefinitions( art, parent, prop, spec, name ) {
-    if (Array.isArray(art))   // do not check with redefinitions
+    if (Array.isArray( art ))   // do not check with redefinitions
       return;
     isObject( art, parent, prop, spec, name );
     if (stageParser) {
@@ -979,7 +1010,7 @@ function assertConsistency( model, stage ) {
              !(model.vocabularies && model.vocabularies[art.name.absolute])) {
       // TODO: sign ignored artifacts with $inferred = 'IGNORED'
       if (parent.kind === 'source' ||
-          art.name.absolute && art.name.absolute.startsWith('localized.'))
+          art.name.absolute && art.name.absolute.startsWith( 'localized.' ))
         standard( art, parent, prop, spec, name );
       else
         throw new InternalConsistencyError( `Expected definition${ at( [ art, parent ], prop, name ) }` );
@@ -988,11 +1019,11 @@ function assertConsistency( model, stage ) {
 
   function isScope( node, parent, prop ) {
     // artifact refs in CDL have scope:0 in XSN
-    if (Number.isInteger(node))
+    if (Number.isInteger( node ))
       return;
     const validValues = [ 'typeOf', 'global', 'param' ];
-    if (!validValues.includes(node))
-      throw new InternalConsistencyError( `Property '${ prop }' must be either "${ validValues.join('", "') }" or a number but was "${ node }"` );
+    if (!validValues.includes( node ))
+      throw new InternalConsistencyError( `Property '${ prop }' must be either "${ validValues.join( '", "' ) }" or a number but was "${ node }"` );
   }
 
   function TODO() { /* no-op */ }

package/lib/compiler/base.js

@@ -29,7 +29,11 @@ const kindProperties = {
   $inline: { normalized: 'element' }, // column with inline property
   event: { elements: true, include: true },
   type: { elements: propExists, enum: propExists, include: true },
-  aspect: { elements: propExists, actions: true, include: true },
+  aspect: {
+    elements: propExists,
+    actions: ( _p, parent ) => propExists( 'elements', parent ),
+    include: true,
+  },
   annotation: { elements: propExists, enum: propExists },
   enum: { normalized: 'element', dict: 'enum' },
   element: { elements: propExists, enum: propExists, dict: 'elements' },
@@ -72,6 +76,7 @@ function propExists( prop, parent ) {
  * have a "sparse" name structure.
  *
  * @param {XSN.Artifact} art
+ * @returns {XSN.Name}
  */
 function getArtifactName( art ) {
   if (!art.name || art.name.absolute) // no name or “old style”
@@ -109,7 +114,7 @@ function getMemberNameProp( elem, kind ) {
     obj = obj.items;
   if (obj.elements || obj.enum)
     return 'element';
-  throw new CompilerAssertion( `Member not found in parent properties ${ Object.keys( obj ).join('+') }` );
+  throw new CompilerAssertion( `Member not found in parent properties ${ Object.keys( obj ).join( '+' ) }` );
 }
 
 module.exports = {

package/lib/compiler/builtins.js

@@ -235,7 +235,7 @@ const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i;
 const quotedLiteralPatterns = {
   x: {
     test_variant: 'uneven-hex',
-    test_fn: (str => Number.isInteger(str.length / 2)),
+    test_fn: (str => Number.isInteger( str.length / 2 )),
     unexpected_variant: 'invalid-hex',
     unexpected_char: /[^0-9a-f]/i,
     json_type: 'string',
@@ -293,12 +293,12 @@ const quotedLiteralPatterns = {
  */
 function checkDate( year, month, day ) {
   // Negative years are allowed
-  year = Math.abs(Number.parseInt(year, 10));
-  month = Number.parseInt(month, 10);
-  day = Number.parseInt(day, 10);
+  year = Math.abs( Number.parseInt( year, 10 ) );
+  month = Number.parseInt( month, 10 );
+  day = Number.parseInt( day, 10 );
   // If any is NaN, the condition will be false.
   // Year 0 does not exist, but ISO 8601 allows it and defines it as 1 BC.
-  return !Number.isNaN(year) && month > 0 && month < 13 && day > 0 && day < 32;
+  return !Number.isNaN( year ) && month > 0 && month < 13 && day > 0 && day < 32;
 }
 
 /**
@@ -308,9 +308,9 @@ function checkDate( year, month, day ) {
  * @returns {boolean} True if the date is valid.
  */
 function checkTime( hour, minutes, seconds ) {
-  hour = Number.parseInt(hour, 10);
-  minutes = Number.parseInt(minutes, 10);
-  seconds = seconds ? Number.parseInt(seconds, 10) : 0;
+  hour = Number.parseInt( hour, 10 );
+  minutes = Number.parseInt( minutes, 10 );
+  seconds = seconds ? Number.parseInt( seconds, 10 ) : 0;
   if (hour === 24) // allow 24:00:00 (ISO 8601 version earlier than 2019)
     return minutes === 0 && seconds === 0;
   // If any is NaN, the condition will be false.
@@ -332,47 +332,47 @@ const typeCategories = {
   geo: [],
 };
 // Fill type categories with `cds.*` types
-Object.keys(core).forEach((type) => {
+Object.keys( core ).forEach( (type) => {
   if (core[type].category)
-    typeCategories[core[type].category].push(`cds.${ type }`);
-});
+    typeCategories[core[type].category].push( `cds.${ type }` );
+} );
 // Fill type categories with `cds.hana.*` types
-Object.keys(coreHana).forEach((type) => {
+Object.keys( coreHana ).forEach( (type) => {
   if (coreHana[type].category)
-    typeCategories[coreHana[type].category].push(`cds.hana.${ type }`);
-});
+    typeCategories[coreHana[type].category].push( `cds.hana.${ type }` );
+} );
 
 /** @param {string} typeName */
 function isIntegerTypeName( typeName ) {
-  return typeCategories.integer.includes(typeName);
+  return typeCategories.integer.includes( typeName );
 }
 /** @param {string} typeName */
 function isDecimalTypeName( typeName ) {
-  return typeCategories.decimal.includes(typeName);
+  return typeCategories.decimal.includes( typeName );
 }
 /** @param {string} typeName */
 function isNumericTypeName( typeName ) {
-  return isIntegerTypeName(typeName) || isDecimalTypeName(typeName);
+  return isIntegerTypeName( typeName ) || isDecimalTypeName( typeName );
 }
 /** @param {string} typeName */
 function isStringTypeName( typeName ) {
-  return typeCategories.string.includes(typeName);
+  return typeCategories.string.includes( typeName );
 }
 /** @param {string} typeName */
 function isDateOrTimeTypeName( typeName ) {
-  return typeCategories.dateTime.includes(typeName);
+  return typeCategories.dateTime.includes( typeName );
 }
 /** @param {string} typeName */
 function isBooleanTypeName( typeName ) {
-  return typeCategories.boolean.includes(typeName);
+  return typeCategories.boolean.includes( typeName );
 }
 /** @param {string} typeName */
 function isBinaryTypeName( typeName ) {
-  return typeCategories.binary.includes(typeName);
+  return typeCategories.binary.includes( typeName );
 }
 /** @param {string} typeName */
 function isGeoTypeName( typeName ) {
-  return typeCategories.geo.includes(typeName);
+  return typeCategories.geo.includes( typeName );
 }
 /**
  * Whether the given type name is a relation, i.e. an association or composition.
@@ -380,7 +380,7 @@ function isGeoTypeName( typeName ) {
  * @param {string} typeName
  */
 function isRelationTypeName( typeName ) {
-  return typeCategories.relation.includes(typeName);
+  return typeCategories.relation.includes( typeName );
 }
 
 /**
@@ -390,10 +390,10 @@ function isRelationTypeName( typeName ) {
  * @returns {boolean}
  */
 function isInReservedNamespace( absolute ) {
-  return absolute.startsWith( 'cds.') &&
-    !absolute.match(/^cds\.foundation(\.|$)/) &&
-    !absolute.match(/^cds\.outbox(\.|$)/) && // Requested by Node runtime
-    !absolute.match(/^cds\.xt(\.|$)/); // Requested by Mtx
+  return absolute === 'cds' || absolute.startsWith( 'cds.' ) &&
+    !absolute.match( /^cds\.foundation(\.|$)/ ) &&
+    !absolute.match( /^cds\.outbox(\.|$)/ ) && // Requested by Node runtime
+    !absolute.match( /^cds\.xt(\.|$)/ ); // Requested by Mtx
 }
 
 /**
@@ -408,7 +408,7 @@ function isInReservedNamespace( absolute ) {
  * @returns {boolean}
  */
 function isBuiltinType( type ) {
-  return typeof type === 'string' && isInReservedNamespace(type);
+  return typeof type === 'string' && isInReservedNamespace( type );
 }
 
 /**
@@ -446,7 +446,7 @@ function initBuiltins( model ) {
       builtin,
       location: builtinLocation(),
     };
-    setProp( art, '_subArtifacts', Object.create(null) );
+    setProp( art, '_subArtifacts', Object.create( null ) );
     return art;
   }
 
@@ -460,7 +460,7 @@ function initBuiltins( model ) {
    * @returns {object} Artifacts dictionary with the builtin artifacts without prefixes.
    */
   function env( builtins, prefix, parent ) {
-    const artifacts = Object.create(null);
+    const artifacts = Object.create( null );
     for (const name of Object.keys( builtins )) {
       const absolute = prefix + name;
       // TODO: reconsider whether to set a type to itself - looks wrong
@@ -481,11 +481,14 @@ function initBuiltins( model ) {
   }
 
   function setMagicVariables( builtins ) {
-    const artifacts = Object.create(null);
+    const artifacts = Object.create( null );
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
-      const art = { kind: 'builtin', name: { id: name, absolute: name } };
+      const art = {
+        kind: 'builtin',
+        name: { id: name, absolute: '', element: name },
+      };
       artifacts[name] = art;
 
       if (magic.$autoElement)
@@ -507,18 +510,14 @@ function initBuiltins( model ) {
     if (!elements)
       return;
 
-    const names = Object.keys(elements);
+    const names = Object.keys( elements );
     if (names.length > 0 && !art.elements)
-      art.elements = Object.create(null);
+      art.elements = Object.create( null );
 
     for (const n of names) {
       const magic = {
-        kind: 'builtin',
-        name: {
-          id: n,
-          absolute: art.name.absolute,
-          element: art.name.element ? `${ art.name.element }.${ n }` : n,
-        },
+        kind: 'builtin',        // TODO: '$variable'
+        name: { id: n, absolute: '', element: `${ art.name.element }.${ n }` },
       };
       // Propagate this property so that it is available for sub-elements.
       if (art.$uncheckedElements)
@@ -526,7 +525,7 @@ function initBuiltins( model ) {
       setProp( magic, '_parent', art );
       // setProp( magic, '_effectiveType', magic );
       if (elements[n] && typeof elements[n] === 'object')
-        createMagicElements(magic, elements[n]);
+        createMagicElements( magic, elements[n] );
 
       art.elements[n] = magic;
     }