@sap/cds-compiler 4.0.2 → 4.1.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.
@@ -84,7 +87,8 @@ class InternalConsistencyError extends Error {
 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 },
@@ -306,6 +315,7 @@ function assertConsistency( model, stage ) {
     columns: {
       kind: [ 'extend', '$column' ],
       test: isArray( column ),
+      instanceOf: XsnArtifact,
       optional: thoseWithKind,
       enum: [ '*' ],
       requires: [ 'location' ],
@@ -383,6 +393,7 @@ function assertConsistency( model, stage ) {
         'select', '$join', 'mixin',
         'source', 'namespace', 'using',
         '$tableAlias', '$navElement',
+        'builtin', // magic variables
       ],
     },
     // locations of parentheses pairs around expression:
@@ -501,6 +512,7 @@ function assertConsistency( model, stage ) {
     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 +539,7 @@ function assertConsistency( model, stage ) {
       kind: [ 'action', 'function' ],
       requires: [ 'kind', 'location' ],
       optional: thoseWithKind,
+      instanceOf: XsnArtifact,
     },
     items: {
       kind: true,
@@ -686,6 +699,7 @@ function assertConsistency( model, stage ) {
     $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 +728,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 ) {
@@ -779,10 +795,11 @@ function assertConsistency( model, stage ) {
       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] );
+      }
     }
   }
 
@@ -921,7 +938,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 );
     };
   }
 
@@ -948,7 +967,7 @@ function assertConsistency( model, stage ) {
 
   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 ) }` );
@@ -962,10 +981,19 @@ function assertConsistency( model, stage ) {
   }
 
   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
       return;

package/lib/compiler/base.js

@@ -72,6 +72,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”

package/lib/compiler/builtins.js

@@ -390,7 +390,7 @@ function isRelationTypeName( typeName ) {
  * @returns {boolean}
  */
 function isInReservedNamespace( absolute ) {
-  return absolute.startsWith( 'cds.') &&
+  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
@@ -485,7 +485,10 @@ function initBuiltins( model ) {
     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)
@@ -513,12 +516,8 @@ function initBuiltins( model ) {
 
     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)