@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/json/from-csn.js

@@ -87,11 +87,11 @@
  * @returns {any} XSN property (e.g. string, object, ...)
  */
 
-const { makeMessageFunction } = require('../base/messages');
 const { dictAdd } = require('../base/dictionaries');
 
 let inExtensions = null;
-let vocabInDefinitions = null;
+
+let vocabInDefinitions = null;  // must be reset!
 
 // CSN property names reserved for CAP
 const ourpropsRegex = /^[_$]?[a-zA-Z]+[0-9]*$/;
@@ -145,6 +145,21 @@ const schemaClasses = {
     type: natnumOrStar,
     msgId: 'syntax-csn-expected-cardinality',
   },
+  columns: {
+    arrayOf: selectItem,
+    msgId: 'syntax-csn-expected-column',
+    defaultKind: '$column',
+    validKinds: [], // pseudo kind '$column'
+    requires: [ 'ref', 'xpr', 'val', '#', 'func', 'list', 'SELECT', 'SET', 'expand' ],
+    schema: {
+      xpr: {
+        class: 'condition',
+        type: xprInValue,
+        inKind: [ '$column' ],
+        inValue: true,
+      },
+    },
+  },
 };
 
 // TODO: also have stricter tests for strings in in xpr/args, join, op, sort, nulls ?
@@ -223,35 +238,15 @@ const schema = compileSchema( {
     validKinds: [],
   },
   columns: {
-    arrayOf: selectItem,
-    msgId: 'syntax-csn-expected-column',
-    defaultKind: '$column',
-    validKinds: [], // pseudo kind '$column'
-    requires: [ 'ref', 'xpr', 'val', '#', 'func', 'list', 'SELECT', 'SET' ], // requires one of...
-    inKind: [ 'extend' ], // only valid in extend and SELECT
-    schema: {
-      xpr: {
-        class: 'condition',
-        type: xprInValue,
-        inKind: [ '$column' ],
-        inValue: true,
-      },
-    },
+    class: 'columns',
+    inKind: [ 'extend' ], // only valid in extend and SELECT/projection
   },
   expand: {
-    arrayOf: selectItem,        // TODO: more specific
-    msgId: 'syntax-csn-expected-column',
-    defaultKind: '$column',
-    validKinds: [], // pseudo kind '$column'
-    requires: [ 'ref' ], // requires one of...
+    class: 'columns',
     inKind: [ '$column' ], // only valid in $column
   },
   inline: {
-    arrayOf: selectItem,        // TODO: more specific
-    msgId: 'syntax-csn-expected-column',
-    defaultKind: '$column',
-    validKinds: [], // pseudo kind '$column'
-    requires: [ 'ref' ], // requires one of...
+    class: 'columns',
     inKind: [ '$column' ], // only valid in $column
   },
   keys: {
@@ -277,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,
@@ -331,7 +326,7 @@ const schema = compileSchema( {
     inKind: [ 'element', 'type', 'param', 'annotation' ],
   },
   scale: {
-    type: natnum,
+    type: scalenum,
     inKind: [ 'element', 'type', 'param', 'annotation' ],
   },
   srid: {
@@ -461,9 +456,19 @@ const schema = compileSchema( {
     requires: 'from',
     optional: [
       'from', 'mixin', 'all', 'distinct', 'columns', 'excluding',
-      'where', 'groupBy', 'having', 'orderBy', 'limit',
+      'where', 'groupBy', 'having', 'orderBy', 'limit', 'elements',
     ],
     inKind: [ '$column' ],
+    schema: {
+      elements: {
+        dictionaryOf: definition,
+        type: ( ...a ) => {
+          dictionaryOf( definition )( ...a );
+        },                      // ignore, but test
+        defaultKind: 'element',
+        validKinds: [ 'element' ],
+      },
+    },
   },
   SET: {
     type: queryTerm,
@@ -513,6 +518,7 @@ const schema = compileSchema( {
   all: { type: asQuantifier },
   // further query properties: -----------------------------------------------
   excluding: {
+    inKind: [ '$column' ],
     arrayOf: string,
     type: excluding,
   },
@@ -556,7 +562,7 @@ const schema = compileSchema( {
   },
   // miscellaneous properties in definitions: --------------------------------
   doc: {
-    type: stringVal,
+    type: stringValOrNull,
     inKind: () => true,         // allowed in all definitions (including columns and extensions)
   },
   '@': {                        // for all properties starting with '@'
@@ -603,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,
@@ -654,7 +660,8 @@ const schema = compileSchema( {
   indexNo: {                    // CSN v0.1.0, but ignored without message
     ignore: true, type: ignore,
   },
-  $: { type: ignore, ignore: true }, // including $env
+  // TODO: should we keep $parens ?
+  $: { type: ignore, ignore: true }, // including $origin
   _: { type: ignore, ignore: true },
 } );
 
@@ -682,7 +689,7 @@ const validLiteralsExtra = Object.assign( Object.create(null), {
 
 /** @type {(id, location, textOrArguments, texts?) => void} */
 // eslint-disable-next-line no-unused-vars
-let message = (id, loc, textOrArguments, texts) => undefined;
+let message = (_id, loc, textOrArguments, texts) => undefined;
 /** @type {(id, location, textOrArguments, texts?) => void} */
 // eslint-disable-next-line no-unused-vars
 let error = (id, loc, textOrArguments, texts) => undefined;
@@ -698,6 +705,7 @@ let csnFilename = '';
 let virtualLine = 1;
 /** @type {CSN.Location[]} */
 let dollarLocations = [];
+let arrayLvlCnt = 0;
 
 /**
  * @param {Object.<string, SchemaSpec>} specs
@@ -731,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;
@@ -936,7 +945,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');
   }
 }
 
@@ -984,12 +996,34 @@ 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, name ) {
+  // TODO: be stricter in what is allowed inside returns
+  if (!inExtensions)
+    return definition( def, spec, xsn, csn, name );
+  // 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, name ).elements;
+  xsn.$syntax = 'returns';
+  return undefined;
+}
+
+// For v1 CSNs with annotation definitions
+function attachVocabInDefinitions( csn ) {
+  if (!csn.vocabularies) {
+    csn.vocabularies = vocabInDefinitions;
+  }
+  else {
+    for (const name in vocabInDefinitions)
+      dictAdd( csn.vocabularies, name, vocabInDefinitions[name] );
+  }
+}
+
 // Kind, names and references (std signature) --------------------------------
 
 function kindAndName( id, spec, xsn ) {
@@ -1098,6 +1132,19 @@ function stringVal( val, spec ) {
   return ignore( val );
 }
 
+function stringValOrNull( val, spec ) {
+  if (val === null)
+    return { val, location: location() };
+
+  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
@@ -1128,11 +1175,23 @@ function annoValue( val, spec ) {
   if (lit !== 'object')
     return { val, literal: lit, location: location() };
   if (Array.isArray( val )) {
-    return {
+    const ec = val.reduce((c, v) => ((v && v['...'] && Object.keys(v).length === 1) ? ++c : c), 0);
+    if (arrayLvlCnt === 0 && ec > 1) {
+      error( 'syntax-csn-duplicate-ellipsis', location(true), { code: '...' },
+             'Expected no more than one $(CODE)' );
+    }
+    if (arrayLvlCnt > 0 && ec > 0) {
+      error( 'syntax-csn-unexpected-ellipsis', location(true), { code: '...' },
+             'Unexpected $(CODE) in nested array' );
+    }
+    arrayLvlCnt++;
+    const retval = {
       location: location(),
       val: arrayOf( annoValue )( val, spec ),
       literal: 'array',
     };
+    arrayLvlCnt--;
+    return retval;
   }
   if (typeof val['#'] === 'string') {
     if (Object.keys( val ).length === 1) {
@@ -1150,6 +1209,13 @@ function annoValue( val, spec ) {
       return refSplit( val['='], '=' );
     }
   }
+  else if (val['...'] && Object.keys(val).length === 1) {
+    return {
+      val: '...',
+      literal: 'token',
+      location: location(),
+    };
+  }
   const struct = Object.create(null);
   ++virtualLine;
   for (const name of Object.keys( val )) {
@@ -1203,9 +1269,14 @@ 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) {
+    xsn.suffix = exprArgs( exprs, spec );
+  }
+  else {
+    xsn.op = { val: 'xpr', location: location() };
+    xsn.args = exprArgs( exprs, spec, xsn );
+  }
 }
 
 function list( exprs, spec, xsn ) {
@@ -1213,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 );
   }
 }
 
@@ -1270,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';
@@ -1285,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;
@@ -1455,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
@@ -1511,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)');
@@ -1612,6 +1686,15 @@ function popLocation( obj ) {
     dollarLocations.pop();
 }
 
+function resetHeapModuleVars() {
+  vocabInDefinitions = null;
+  dollarLocations = [];
+  message = () => undefined;
+  error = () => undefined;
+  warning = () => undefined;
+  info = () => undefined;
+}
+
 // API -----------------------------------------------------------------------
 
 /**
@@ -1622,7 +1705,7 @@ function popLocation( obj ) {
  * @param {CSN.Options} options
  * @returns {object} Augmented CSN (a.k.a XSN)
  */
-function augment( csn, filename, options ) {
+function toXsn( csn, filename, options, messageFunctions ) {
   csnVersionZero = csn.version && csn.version.csn === '0.1.0';
   csnFilename = filename;
   virtualLine = 1;
@@ -1631,11 +1714,8 @@ function augment( csn, filename, options ) {
   vocabInDefinitions = null;
   const xsn = { $frontend: 'json' };
 
-  const msgFcts = makeMessageFunction( xsn, options, 'parse' );
-  message = msgFcts.message;
-  error = msgFcts.error;
-  warning = msgFcts.warning;
-  info = msgFcts.info;
+  // eslint-disable-next-line object-curly-newline
+  ({ message, error, warning, info } = messageFunctions);
 
   if (csnVersionZero) {
     warning( 'syntax-csn-zero-version', location(true),
@@ -1644,25 +1724,31 @@ function augment( csn, filename, options ) {
   const r = object( csn, topLevelSpec );
   if (vocabInDefinitions)
     attachVocabInDefinitions( r );
+  if (csn.$sources && Array.isArray( csn.$sources ) &&
+      csn.$sources.every( fname => typeof fname === 'string' ))
+    // non-enumerable or enumerable, ignore with wrong value
+    r.$sources = csn.$sources;
+  resetHeapModuleVars();
   return Object.assign( xsn, r );
 }
 
-// For v1 CSNs with annotation definitions
-function attachVocabInDefinitions( csn ) {
-  if (!csn.vocabularies) {
-    csn.vocabularies = vocabInDefinitions;
+
+function augment( csn, filename = 'csn.json', options = {}, messageFunctions ) {
+  try {
+    return toXsn( csn, filename, options, messageFunctions );
   }
-  else {
-    for (const name in vocabInDefinitions)
-      dictAdd( csn.vocabularies, name, vocabInDefinitions[name] );
+  catch ( e ) {
+    resetHeapModuleVars();
+    throw e;
   }
 }
 
-function parse( source, filename = 'csn.json', options = {} ) {
+function parse( source, filename = 'csn.json', options = {}, messageFunctions ) {
   try {
-    return augment( JSON.parse(source), filename, options );
+    return augment( JSON.parse(source), filename, options, messageFunctions );
   }
   catch ( e ) {
+    resetHeapModuleVars();
     if (!(e instanceof SyntaxError))
       throw e;
     const xsn = {};
@@ -1688,8 +1774,7 @@ function parse( source, filename = 'csn.json', options = {} ) {
       line,
       col: column,
     };
-    const msgs = makeMessageFunction( xsn, options, 'parse' );
-    msgs.error( 'syntax-csn-illegal-json', loc, { msg }, 'Illegal JSON: $(MSG)' );
+    messageFunctions.error( 'syntax-csn-illegal-json', loc, { msg }, 'Illegal JSON: $(MSG)' );
     return xsn;
   }
 }