@sap/cds-compiler 3.9.2 → 4.0.0

package/lib/json/from-csn.js

@@ -11,72 +11,97 @@
  * Overview of properties in schema specifications (values in 'schema' dictionary):
  *
  * @typedef {object} SchemaSpec
- * @property {TransformerFunction}   [type] Transformation and test function (i.e. type). The first
- *                                          four arguments are the same for all functions. Further
- *                                          ones may be accepted as well.
- * @property {string}               [class] A schemaClass. Possible values are keys of the variable
- *                                          "schemaClasses". Essentially all properties of the class
- *                                          are copied.
- * @property {Function}           [arrayOf] Alternative to "type". The property should be an array.
- *                                          Value is passed to arrayOf().
- *                                          Value is ignored if "type" is set. Then it is only used
- *                                          for better error messages.
- * @property {Function}      [dictionaryOf] Alternative to "type". The property should be an object
- *                                          in dictionary form (i.e. Object.<string, type>).
- *                                          Value is passed to dictionaryOf().
- *                                          Value is ignored if "type" is set. Then it is only used
- *                                          for better error messages.
- * @property {Object.<string, SchemaSpec>} [schema] If some sub-properties have a different
- *                                                  semantic in this property than the default then
- *                                                  switch the currently used spec to this value.
- * @property {string}                [prop] Name of the property. compileSchema() sets it to the
- *                                          dictionary key by default.
- * @property {string}             [msgProp] Display name of the property. compileSchema() sets it to
- *                                          the dictionary key (+ optional '[]') by default.
- * @property {string}          [msgVariant] Use this message variant instead of the default one.
- *                                          Allows more precise and detailed error messages.
- * @property {string|string[]|false} [requires] If the value is a string, then the given sub-
- *                                              property is required. If 'undefined', then at
- *                                              least one property is required. If false the no
- *                                              sub-properties are required.
- * @property {boolean}           [noPrefix] Only used for '#' at the moment. Signals that the entry
- *                                          should not be used for keys like '#key'. getSchema(...)
- *                                          normally checks if schema[prop] exists and if not,
- *                                          checks for schema[prop.charAt(0)]. This is intended for
- *                                          annotations and similar (which start with special
- *                                          characters).
- * @property {boolean}             [ignore] Don't issue warnings.
- * @property {string[]}          [optional] Optional sub-properties that may be used. Warnings are
- *                                          issued if unknown properties are set.
- * @property {string}         [defaultKind] Default kind for sub-elements, e.g. objects in
- *                                          "elements".
- * @property {string[]|Function}   [inKind] Specifies in what definition type this property may
- *                                          be used, e.g. "virtual" may only be used for elements.
- *                                          If it is a function then it takes two arguments "kind"
- *                                          and "parentSpec" should return a boolean
- * @property {string[]}        [validKinds] What "kind" values are possible in a definition. The
- *                                          root "definitions" properties allows more kinds than
- *                                          e.g. definitions inside "elements".
- * @property {string|string[]}   [onlyWith] Defines that the property *must* be used with these
- *                                          properties.
- * @property {number}           [minLength] Minimum number of elements that an array must have.
- * @property {boolean}            [inValue] Puts the value into an XSN property "value",
- *                                          e.g. { value: ... }
- * @property {string[]}         [xorGroups] Corresponding xor groups. It references a value of
- *                                          xorGroups. If set then only one property of the
- *                                          xorGroup may be set, e.g. if target is set, elements
- *                                          may not.
- * @property {string}               [xsnOp] Defines the operator to be used for XSN. Used for SET
- *                                          and SELECT. See queryTerm().
- * @property {string}            [vZeroFor] Marks the property as a CSN 0.1.0 property. It is
- *                                          replaced by this CSN 1.0 property (value of vZeroFor).
- * @property {string}         [vZeroIgnore] Marks the property as a CSN 0.1.0 property. The
- *                                          property is ignored and a warning may be issues about
- *                                          it.
- * @property {string}        [xorException] A property name that is allowed besides another property
- *                                          of an xorGroup (as an exception to the rule).
- * @property {boolean}        [ignoreExtra] Whether extra properties are ignored and not put
- *                                          into $extra.
+ *
+ * @property {TransformerFunction}  [type]
+ *     Transformation and test function (i.e. type). The first four arguments are the same for
+ *     all functions.  Further ones may be accepted as well.
+ *
+ * @property {string}  [class]
+ *     A schemaClass. Possible values are keys of the variable "schemaClasses".
+ *     Essentially all properties of the class are copied.
+ *
+ * @property {Function}  [arrayOf]
+ *     Alternative to "type". The property should be an array. Value is passed to arrayOf().
+ *     Value is ignored if "type" is set. Then it is only used for better error messages.
+ *
+ * @property {Function}  [dictionaryOf]
+ *     Alternative to "type". The property should be an object in dictionary form (i.e.
+ *     Object.<string, type>).  Value is passed to dictionaryOf(). Value is ignored if "type"
+ *     is set. Then it is only used for better error messages.
+ *
+ * @property {Object.<string, SchemaSpec>}  [schema]
+ *     If some sub-properties have a different semantic in this property than the default then
+ *     switch the currently used spec to this value.
+ *
+ * @property {string}  [prop]
+ *     Name of the property. compileSchema() sets it to the dictionary key by default.
+ *
+ * @property {string}  [msgProp]
+ *     Display name of the property. compileSchema() sets it to the dictionary key
+ *     (+ optional '[]') by default.
+ *
+ * @property {string}  [msgVariant]
+ *     Use this message variant instead of the default one.
+ *     Allows more precise and detailed error messages.
+ *
+ * @property {string|string[]|false}  [requires]
+ *     If the value is a string, then the given sub-property is required. If 'undefined', then at
+ *     least one property is required. If false the no sub-properties are required.
+ *
+ * @property {boolean}  [noPrefix]
+ *     Only used for '#' at the moment. Signals that the entry should not be used for keys
+ *     like '#key'.  `getSchema(...)` normally checks if `schema[prop]` exists and if not, checks
+ *     for `schema[prop.charAt(0)]`.
+ *     This is intended for annotations and similar (which start with special characters).
+ *
+ * @property {boolean}  [ignore]
+ *     Don't issue warnings.
+ *
+ * @property {string[]}  [optional]
+ *     Optional sub-properties that may be used. Warnings are issued if unknown properties are set.
+ *
+ * @property {string}  [defaultKind]
+ *     Default kind for sub-elements, e.g. objects in "elements".
+ *
+ * @property {string[]|Function} [inKind]
+ *     Specifies in what definition type this property may be used, e.g. "virtual" may only be
+ *     used for elements. If it is a function then it takes two arguments "kind" and "parentSpec"
+ *     should return a boolean.
+ *
+ * @property {string[]}  [validKinds]
+ *     What "kind" values are possible in a definition. The root "definitions" properties allows
+ *     more kinds than e.g. definitions inside "elements".
+ *
+ * @property {string|string[]}  [onlyWith]
+ *     Defines that the property *must* be used with these properties.
+ *
+ * @property {number}           [minLength]
+ *     Minimum number of elements that an array must have.
+ *
+ * @property {boolean}            [inValue]
+ *     Puts the value into an XSN property "value", e.g. { value: ... }
+ *
+ * @property {string[]}         [xorGroups]
+ *     Corresponding xor groups. It references a value of xorGroups. If set then only one property
+ *     of the xorGroup may be set, e.g. if target is set, elements may not.
+ *
+ * @property {string}               [xsnOp]
+ *     Defines the operator to be used for XSN. Used for SET and SELECT. See queryTerm().
+ *
+ * @property {string}            [vZeroFor]
+ *     Marks the property as a CSN 0.1.0 property. It is replaced by this CSN 1.0
+ *     property (value of vZeroFor).
+ *
+ * @property {string}         [vZeroIgnore]
+ *     Marks the property as a CSN 0.1.0 property. The property is ignored and a warning may be
+ *     issues about it.
+ *
+ * @property {string}        [xorException]
+ *     A property name that is allowed besides another property of an xorGroup (as an exception
+ *     to the rule).
+ *
+ * @property {boolean}        [ignoreExtra]
+ *     Whether extra properties are ignored and not put into $extra.
  */
 
 /**
@@ -92,7 +117,6 @@
 const { dictAdd } = require('../base/dictionaries');
 const { quotedLiteralPatterns } = require('../compiler/builtins');
 const { CompilerAssertion } = require('../base/error');
-const { isBetaEnabled } = require('../base/model');
 
 const $location = Symbol.for('cds.$location');
 
@@ -114,7 +138,7 @@ const typeProperties = [
 const exprProperties = [
   // do not include CSN v0.1.0 properties here:
   'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET', // Core Compiler checks SELECT/SET
-  'param', 'global', 'literal', 'args', 'cast', // only with 'ref'/'ref'/'val'/'func'
+  'param', 'literal', 'args', 'cast', // only with 'ref'/'ref'/'val'/'func'
 ];
 
 // Groups of properties which cannot be used together:
@@ -128,9 +152,16 @@ const xorGroups = {
   ':col': [ 'expand', 'inline' ],
   ':ext': [ 'annotate', 'extend' ], // TODO: better msg for test/negative/UnexpectedProperties.csn
   ':assoc': [ 'on', 'keys', 'foreignKeys', 'onCond' ], // 'foreignKeys'/'onCond' is CSN v0.1.0
+
+  // TODO: Maybe use a field "notWith", similar to "onlyWith" on `elements`/`items`?
+  ':length': [ 'elements', 'items', 'length' ],
+  ':srid': [ 'elements', 'items', 'srid' ],
+  ':precision': [ 'elements', 'items', 'precision' ],
+  ':scale': [ 'elements', 'items', 'scale' ],
+
   // TODO - improve consequential errors: assume no name given with `join` or `inline`?
   as: [ 'as', 'join', 'inline' ],
-  scope: [ 'param', 'global' ],
+  scope: [ 'param' ],
   quantifier: [ 'some', 'any', 'distinct', 'all' ],
   // quantifiers 'some' and 'any are 'xpr' token strings in CSN v1.0
 };
@@ -249,7 +280,7 @@ const schema = compileSchema( {
     inKind: [ 'event' ],
   },
   actions: {
-    dictionaryOf: definition,
+    dictionaryOf: actions,
     defaultKind: 'action',
     validKinds: [ 'action', 'function' ],
     inKind: [ 'entity', 'aspect', 'annotate', 'extend' ],
@@ -318,7 +349,7 @@ const schema = compileSchema( {
   type: {
     type: typeArtifactRef,
     msgVariant: 'or-object',    // for 'syntax-expecting-string',
-    optional: [ 'ref', 'global' ],
+    optional: [ 'ref' ],
     inKind: [ 'element', 'type', 'param', 'mixin', 'event', 'annotation', 'extend' ],
     schema: {
       ref: {
@@ -410,7 +441,11 @@ const schema = compileSchema( {
     msgVariant: 'or-object',    // for 'syntax-expecting-string',
     minLength: 1,
     requires: 'id',
-    optional: [ 'id', 'args', 'cardinality', 'where' ],
+    optional: [
+      'id', 'args', 'cardinality', 'where',
+      // Support once we allow them in non-parse-only CDL.
+      // 'groupBy', 'having', 'orderBy', 'limit',
+    ],
     xorException: 'expand',     // see xorGroup :expr
     inKind: [ '$column', 'key' ],
   },
@@ -422,11 +457,6 @@ const schema = compileSchema( {
     onlyWith: 'ref',
     inKind: [ '$column' ],
   },
-  global: {
-    type: asScope,              // is bool, stored as string in XSN property 'scope'
-    onlyWith: 'ref',
-    inKind: [ '$column' ],
-  },
   func: {
     type: func,
     xorException: 'xpr',       // see xorGroup :expr
@@ -535,7 +565,7 @@ const schema = compileSchema( {
     },
     inKind: [ '$column' ],
   },
-  op: {                                   // used for UNION etc in CSN v1.0
+  op: {                                   // used for UNION etc. in CSN v1.0
     vZeroFor: 'xpr',
     vZeroIgnore: 'call', // is also used in CSN v0.1.0 for "normal" expressions
     type: setOp,
@@ -545,8 +575,8 @@ const schema = compileSchema( {
     type: join,                 // string like 'cross' - TODO: test for valid ones?
   },
   from: {
-    type: object,
-    optional: [ 'ref', 'global', 'join', 'cardinality', 'args', 'on', 'SELECT', 'SET', 'as' ],
+    type: fromObject,
+    optional: [ 'ref', 'join', 'cardinality', 'args', 'on', 'SELECT', 'SET', 'as' ],
     schema: {
       cardinality: {
         type: object,
@@ -554,9 +584,9 @@ const schema = compileSchema( {
         onlyWith: 'join',
       },
       args: {
-        arrayOf: object,
+        arrayOf: fromObject,
         minLength: 2,
-        optional: [ 'ref', 'global', 'join', 'cardinality', 'args', 'on', 'SELECT', 'SET', 'as' ],
+        optional: [ 'ref', 'join', 'cardinality', 'args', 'on', 'SELECT', 'SET', 'as' ],
         onlyWith: 'join',
         schema: {},             // 'args' in 'args' in 'from' is same as 'args' in 'from'
       },
@@ -698,7 +728,7 @@ const schema = compileSchema( {
     class: 'expression',        // calculated elements
     vZeroFor: 'val',            // CSN v0.1.0 property for `val` in enum def
     // type: annoValue,
-    inKind: [ 'element' ],
+    inKind: [ 'element', 'enum' ], // TODO: Remove "enum" again; currently for extensions
     optional: exprProperties.concat([ 'stored' ]),
   },
   stored: {
@@ -777,8 +807,6 @@ let virtualLine = 1;
 /** @type {CSN.Location[]} */
 let dollarLocations = [];
 let arrayLevelCount = 0;
-/** @type {CSN.Options} */
-let userOptions = null; // must be reset!
 
 /**
  * @param {Object.<string, SchemaSpec>} specs
@@ -935,7 +963,7 @@ function object( obj, spec ) {
 
 function vZeroDelete( o, spec ) { // for old-CSN property 'origin'
   if (!csnVersionZero) {
-    warning( 'syntax-deprecated-property', location(true),
+    message( 'syntax-deprecated-property', location(true),
              { '#': 'zero', prop: spec.msgProp } );
   }
   ignore( o );
@@ -964,13 +992,15 @@ function definition( def, spec, xsn, csn, name ) {
 
   // If we have `extend … with { name = 3 }`, it could mean adding an element or an enum.
   // We use `elements: { name: { val: 3 } }` to represent this ambiguity.
-  if (savedInExtensions === '' && prop === 'elements' && !def.value &&
-      (def.val !== undefined || def['#'] !== undefined) &&
+  if (savedInExtensions === '' && prop === 'elements' &&
+      (def.val !== undefined || def['#'] !== undefined ||
+       def.value?.val !== undefined || def.value?.['#'] !== undefined) &&
       def.virtual === undefined && def.key === undefined && def.masked === undefined &&
       def.type === undefined && def.elements === undefined) {
     r.$syntax = 'enum';
     kind = 'enum';              // for function expected()
   }
+
   if (csnProps.length) {
     const valueName = (prop === 'keys' || prop === 'foreignKeys' ? 'targetElement' : 'value');
     // the next is basically object() + the inValue handling
@@ -1024,6 +1054,20 @@ function definition( def, spec, xsn, csn, name ) {
   }
 }
 
+function actions( def, spec, xsn, csn, name ) {
+  if (def.kind === 'extend' && (def.elements || def.enum)) {
+    // TODO: Handle this case in extend.js; already done for `returns`
+    //       See message ext-expecting-returns
+    error( 'syntax-unexpected-property', location(true), {
+      '#': def.kind,
+      prop: def.enum ? 'enum' : 'elements',
+      parentprop: spec.msgProp,
+      kind: def.kind,
+    } );
+  }
+  return definition( def, spec, xsn, csn, name );
+}
+
 // A dictionary is expected. Uses spec.dictionaryOf. If unset, default is "definition".
 function dictionaryOf( elementFct ) {
   return function dictionary( dict, spec ) {
@@ -1078,14 +1122,7 @@ function selectItem( def, spec, xsn, csn ) {
 }
 
 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;
+  return definition( def, spec, xsn, csn, '' );
 }
 
 // For v1 CSNs with annotation definitions
@@ -1151,8 +1188,9 @@ function validKind( val, spec, xsn ) {
   if (val === xsn.kind)         // has been set in definition - the same = ok!
     return undefined;           // already set in definition
   if (val === 'view' && xsn.kind === 'entity') {
-    warning( 'syntax-deprecated-value', location(true),
-             { '#': 'replace', prop: spec.msgProp, value: 'entity' } );
+    warning( 'syntax-deprecated-kind', location(true),
+             { prop: spec.msgProp, value: 'entity' },
+             'Replace value in $(PROP) by $(VALUE)' );
   }
   else if (val !== 'entity' && val !== 'type' || xsn.kind !== 'aspect') {
     error( 'syntax-invalid-kind', location(true), { prop: spec.msgProp },
@@ -1169,13 +1207,22 @@ function typeArtifactRef( ref, spec ) {
   return artifactRef( ref, spec );
 }
 
+function fromObject( ref, spec ) {
+  const r = object( ref, spec );
+  if (r?.path?.length > 1)
+    r.scope = 1; // `type`/`from` ref in CSN: elements start after definitions name
+  return r;
+}
+
 // Use with spec.msgVariant: 'or-object'
 function artifactRef( ref, spec ) {
   if (!ref || typeof ref !== 'string') {
-    if (ref && typeof ref === 'object' && !Array.isArray( ref ))
-      return object( ref, spec );
+    if (!ref || typeof ref !== 'object' || Array.isArray( ref ))
+      return string( ref, spec );
     // use error message 'syntax-expecting-string' (string more likely than object):
-    return string( ref, spec );
+    return (!ref || typeof ref !== 'object' || Array.isArray( ref ))
+      ? string( ref, spec )
+      : fromObject( ref, spec );
   }
   if (spec.prop !== 'type')
     return stringRef( ref, spec );
@@ -1184,11 +1231,12 @@ function artifactRef( ref, spec ) {
   if (idx < 0)
     return stringRef( ref, spec );
   if (!csnVersionZero) {
-    warning( 'syntax-deprecated-value', location(true),
+    message( 'syntax-deprecated-value', location(true),
              { '#': 'zero-replace', prop: spec.msgProp, value: '{ ref: […] }' } );
   }
   const r = refSplit( ref.substring( idx + 2 ), 'type' );
   r.path.unshift( { id: ref.substring( 0, idx ), location: location() } );
+  r.scope = 1;
   return r;
 }
 
@@ -1375,8 +1423,6 @@ function annoValue( val, spec ) {
     // TODO: Have xprInAnnoProperties centrally for other backends to use as well (toCdl)
     const valKeys = Object.keys(val);
     if (valKeys.length > 1 &&
-       (isBetaEnabled(userOptions, 'annotationExpressions') ||
-        isBetaEnabled(userOptions, 'v4preview')) &&
         xprInAnnoProperties.some(prop => val[prop] !== undefined)) {
       const s = schema['@'].schema['-expr'];
       const r = { location: location() };
@@ -1400,7 +1446,7 @@ function annoValue( val, spec ) {
       return xsn;
     }
   }
-  else if (val['...'] && Object.keys( val ).length === 1) {
+  else if (val['...'] !== undefined && Object.keys( val ).length === 1) {
     // TODO: only if not nested - see error above
     ++virtualLine;
     const ell = val['...'];
@@ -1598,6 +1644,7 @@ function exprArgs( cond, spec ) {
   // TODO: do that in definer.js, neither here nor in CDL parser
   if (Array.isArray( rxsn )) {
     for (let i = 0; i < rxsn.length - 1; i++) {
+      // TODO: disallow param ref - write test
       if (rxsn[i]?.val === 'exists' && rxsn[i].literal === 'token' && rxsn[i + 1].path)
         rxsn[++i].$expected = 'exists';
     }
@@ -1680,8 +1727,8 @@ function join( val, spec, xsn ) {
 
 function queryArgs( val, spec, xsn, csn ) {
   if (Array.isArray( val ) && val.length > 1 && !csn.op) {
-    // Make it error 'syntax-missing-property#sibling' in v4:
-    warning( 'syntax-deprecated-auto-union', location(true),
+    // Make it error 'syntax-missing-property#sibling' in v6:
+    message( 'syntax-deprecated-auto-union', location(true),
              { siblingprop: 'args', prop: 'op' },
              'Object with property $(SIBLINGPROP) must also have a property $(PROP)' );
     xsn.op = { val: 'union', location: location() };
@@ -1726,7 +1773,7 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
     if (s.ignore)
       return { type: ignore };
     if (s.vZeroIgnore && s.vZeroIgnore === csn[prop]) { // for "op": "call"
-      warning( 'syntax-deprecated-property', location(true), { '#': 'zero', prop } );
+      message( 'syntax-deprecated-property', location(true), { '#': 'zero', prop } );
       return { type: ignore };
     }
     const zero = s.vZeroFor;
@@ -1851,7 +1898,7 @@ function implicitName( ref ) {
 function replaceZeroProp( prop, otherprop ) {
   if (csnVersionZero)
     return;
-  warning( 'syntax-deprecated-property', location(true),
+  message( 'syntax-deprecated-property', location(true),
            { '#': 'zero-replace', prop, otherprop } );
 }
 
@@ -1881,10 +1928,10 @@ function refSplit( name, prop ) {
   return { path: path.map( id => ({ id, location: location() }) ), location: location() };
 }
 
-function replaceZeroValue( spec, msgVariant, otherprop ) {
+function replaceZeroValue( spec, msgVariant, newValue ) {
   if (!csnVersionZero && !spec.vZeroFor) {
-    warning( 'syntax-deprecated-value', location(true),
-             { '#': msgVariant, prop: spec.msgProp, otherprop } );
+    message( 'syntax-deprecated-value', location(true),
+             { '#': msgVariant, prop: spec.msgProp, value: newValue } );
   }
 }
 
@@ -1939,7 +1986,6 @@ function popLocation( obj ) {
 function resetHeapModuleVars() {
   vocabInDefinitions = null;
   dollarLocations = [];
-  userOptions = null;
   message = () => undefined;
   error = () => undefined;
   warning = () => undefined;
@@ -1964,7 +2010,6 @@ function toXsn( csn, filename, options, messageFunctions ) {
   arrayLevelCount = 0;
   inExtensions = null;
   vocabInDefinitions = null;
-  userOptions = options;
 
   const xsn = { $frontend: 'json' };