@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/json/from-csn.js

@@ -145,7 +145,7 @@ const schemaClasses = {
     type: natnumOrStar,
     msgId: 'syntax-csn-expected-cardinality',
   },
-  column: {
+  columns: {
     arrayOf: selectItem,
     msgId: 'syntax-csn-expected-column',
     defaultKind: '$column',
@@ -238,15 +238,15 @@ const schema = compileSchema( {
     validKinds: [],
   },
   columns: {
-    class: 'column',
+    class: 'columns',
     inKind: [ 'extend' ], // only valid in extend and SELECT/projection
   },
   expand: {
-    class: 'column',
+    class: 'columns',
     inKind: [ '$column' ], // only valid in $column
   },
   inline: {
-    class: 'column',
+    class: 'columns',
     inKind: [ '$column' ], // only valid in $column
   },
   keys: {
@@ -272,7 +272,7 @@ const schema = compileSchema( {
   },
   annotate: {
     type: kindAndName,
-    inKind: (kind => kind === 'annotate'), // using array would test 'entity' for extensions[]
+    inKind: [ 'annotate' ],
   },
   extend: {
     type: kindAndName,
@@ -326,7 +326,7 @@ const schema = compileSchema( {
     inKind: [ 'element', 'type', 'param', 'annotation' ],
   },
   scale: {
-    type: natnum,
+    type: scalenum,
     inKind: [ 'element', 'type', 'param', 'annotation' ],
   },
   srid: {
@@ -609,10 +609,10 @@ const schema = compileSchema( {
     inKind: [ 'entity', 'type', 'aspect', 'event', 'extend' ],
   },
   returns: {
-    type: definition,
+    type: returnsDefinition,
     defaultKind: 'param',
     validKinds: [ 'param' ],
-    inKind: [ 'action', 'function' ],
+    inKind: [ 'action', 'function', 'annotate' ],
   },
   technicalConfig: {            // treat it like external_property
     type: extra,
@@ -739,14 +739,15 @@ function compileSchema( specs, proto = null) {
         throw new Error( `Missing type specification for property "${ p }"` );
     }
   }
-  if (proto)
-    return r;
+  // Set property 'xorGroup' in main and sub schema:
   for (const group in xorGroups) {
     for (const prop of xorGroups[group]) {
       if (r[prop].xorGroup === undefined)
         r[prop].xorGroup = group;
     }
   }
+  if (proto)
+    return r;
   for (const prop of exprProperties) {
     if (r[prop].inValue === undefined)
       r[prop].inValue = true;
@@ -772,12 +773,8 @@ function arrayOf( fn, filter = undefined ) {
     } );
     const minLength = spec.minLength || 0;
     if (minLength > val.length) {
-      error( 'syntax-csn-expected-length', location(true),
-             { prop: spec.prop, n: minLength, '#': minLength === 1 ? 'one' : 'std' },
-             {
-               std: 'Expected array in $(PROP) to have at least $(N) items',
-               one: 'Expected array in $(PROP) to have at least one item',
-             } );
+      message( 'syntax-csn-expected-length', location(true),
+               { prop: spec.prop, n: minLength, '#': minLength === 1 ? 'one' : 'std' });
     }
     if (val.length)
       ++virtualLine;          // [] in one JSON line
@@ -912,7 +909,7 @@ function definition( def, spec, xsn, csn, name ) {
       ++virtualLine;
     }
   }
-  if (!r.name && name) {
+  if (!r.name && name != null) {
     r.name = { id: name, location: r.location };
     if (prop === 'columns' || prop === 'keys' || prop === 'foreignKeys')
       r.name.$inferred = 'as';
@@ -944,7 +941,10 @@ function definition( def, spec, xsn, csn, name ) {
       return s.inKind && s.inKind( kind, spec );
     return s.inKind.includes( kind ) &&
       // for an 'annotate', both 'annotate' and the "host" kind must be expected
-      (!inExtensions || s.inKind.includes( inExtensions ));
+      (!inExtensions || s.inKind.includes( inExtensions ) ||
+       // extending elements in returns can be without 'returns' in CSN
+       // TODO: with warning/info?
+       inExtensions === 'action' && p === 'elements');
   }
 }
 
@@ -992,12 +992,23 @@ function keys( array, spec, xsn ) {
 }
 
 function selectItem( def, spec, xsn, csn ) {
-  if (def === '*')
+  if (def === '*')              // compile() will complain about repeated '*'s
     return { val: '*', location: location() };
 
   return definition( def, spec, xsn, csn, null ); // definer sets name
 }
 
+function returnsDefinition( def, spec, xsn, csn ) {
+  // TODO: be stricter in what is allowed inside returns
+  if (!inExtensions)
+    return definition( def, spec, xsn, csn, '' );
+  // for the moment, flatten elements in returns in an annotate
+  // TODO: bigger Core Compiler changes would have to be done otherwise
+  xsn.elements = definition( def, spec, xsn, csn, '' ).elements;
+  xsn.$syntax = 'returns';
+  return undefined;
+}
+
 // For v1 CSNs with annotation definitions
 function attachVocabInDefinitions( csn ) {
   if (!csn.vocabularies) {
@@ -1124,6 +1135,12 @@ function stringValOrNull( val, spec ) {
   return stringVal(val, spec);
 }
 
+function scalenum( val, spec ) {
+  if ([ 'floating', 'variable' ].includes(val))
+    return { val, literal: 'string', location: location() };
+  return natnum(val, spec );
+}
+
 function natnum( val, spec ) {
   if (typeof val === 'number' && val >= 0)
     //  XSN TODO: do not require literal
@@ -1248,9 +1265,18 @@ function func( val, spec, xsn ) {
   return { path: [ { id: val, location: location() } ], location: location() };
 }
 
-function xpr( exprs, spec, xsn ) {
-  xsn.op = { val: 'xpr', location: location() };
-  xsn.args = exists( exprs, spec, xsn );
+function xpr( exprs, spec, xsn, csn ) {
+  if (csn.func) {
+    if (!exprs.length) {
+      message( 'syntax-csn-expected-length', location(true),
+               { prop: 'xpr', otherprop: 'func', '#': 'suffix' });
+    }
+    xsn.suffix = exprArgs( exprs, spec );
+  }
+  else {
+    xsn.op = { val: 'xpr', location: location() };
+    xsn.args = exprArgs( exprs, spec, xsn );
+  }
 }
 
 function list( exprs, spec, xsn ) {
@@ -1258,15 +1284,15 @@ function list( exprs, spec, xsn ) {
   xsn.args = arrayOf( exprOrString )( exprs, spec, xsn );
 }
 
-function xprInValue( exprs, spec, xsn ) {
+function xprInValue( exprs, spec, xsn, csn ) {
   // if the top-level xpr is just for a cast:
   if (exprs.length === 1 && exprs[0].cast) {
     const x = {};
-    xpr( exprs, spec, x );
+    xpr( exprs, spec, x, csn );
     Object.assign( xsn, x.args[0] );
   }
   else {
-    xpr( exprs, spec, xsn );
+    xpr( exprs, spec, xsn, csn );
   }
 }
 
@@ -1315,9 +1341,9 @@ function exprOrString( e, spec ) {
 }
 
 // mark path argument of 'exits' predicate with $expected:'exists'
-function exists( cond, spec, xsn, csn ) {
-  const rxsn = arrayOf( exprOrString )(cond, spec, xsn, csn);
-  if (Array.isArray(rxsn) && rxsn.some(x => x === 'exists')) {
+function exprArgs( cond, spec, xsn, csn ) {
+  const rxsn = arrayOf( exprOrString )( cond, spec, xsn, csn );
+  if (Array.isArray( rxsn ) && rxsn.some( x => x === 'exists' )) {
     for (let i = 0; i < rxsn.length - 1; i++) {
       if (rxsn[i] === 'exists' && rxsn[i + 1].path)
         rxsn[++i].$expected = 'exists';
@@ -1330,7 +1356,7 @@ function condition( cond, spec ) {
   const loc = location();
   const x = {
     op: { val: 'xpr', location: loc },
-    args: exists( cond, spec ),
+    args: exprArgs( cond, spec ),
     location: loc,
   };
   return x;
@@ -1500,7 +1526,7 @@ function calculateKind( def, spec ) {
     return 'annotate';
   }
   if (spec.prop === 'extensions') {
-    inExtensions = (def.extend) ? '' : 'entity';
+    inExtensions = (def.extend) ? '' : 'annotate';
     return (def.extend) ? 'extend' : 'annotate';
   }
   const kind = (def.kind === 'view') ? 'entity' : def.kind; // 'view' is CSN v0.1.0
@@ -1556,6 +1582,9 @@ function checkAndSetXorGroup( group, prop, xor ) {
     xor[group] = prop;
     return true;
   }
+  if (prop === 'func' && xor[group] === 'xpr' ||
+      prop === 'xpr' && xor[group] === 'func')
+    return true;                // hack for window function: both func and xpr is allowed
   error( 'syntax-csn-excluded-property', location(true),
          { prop, otherprop: xor[group] },
          'CSN property $(PROP) can only be used alternatively to $(OTHERPROP)');