@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/api/options.js

@@ -31,6 +31,7 @@ const publicOptionsNewAPI = [
   'generatedByComment',
   'betterSqliteSessionVariables',
   'fewerLocalizedViews',
+  'withHanaAssociations',
   // ODATA
   'odataOpenapiHints',
   'odataVersion',
@@ -42,7 +43,6 @@ const publicOptionsNewAPI = [
   'odataXServiceRefs',
   'odataV2PartialConstr',
   'odataVocabularies',
-  'odataOpenType',
   'service',
   'serviceNames',
   //
@@ -67,6 +67,7 @@ const privateOptions = [
   'noRecompile',
   'internalMsg',
   'disableHanaComments',      // in case of issues with hana comment rendering
+  'tenantAsColumn',           // not published yet
   'localizedWithoutCoalesce', // deprecated version of 'localizedLanguageFallback', TODO(v5): Remove option
 ];
 
@@ -77,9 +78,9 @@ const overallOptions = publicOptionsNewAPI.concat(privateOptions);
  * Apply defaults and make sure that the "hard requirements" are met,
  * i.e. src: sql if to.sql() was called.
  *
- * @param {FlatOptions} [input={}] Input options
- * @param {FlatOptions} [defaults={}] Default options to apply
- * @param {FlatOptions} [hardRequire={}] Hard requirements to enforce
+ * @param {FlatOptions} [input] Input options
+ * @param {FlatOptions} [defaults] Default options to apply
+ * @param {FlatOptions} [hardRequire] Hard requirements to enforce
  * @param {object} [customValidators] Custom validations to run instead of defaults
  * @param {string[]} [combinationValidators] Option combinations to validate
  * @param {string} moduleName The called module, e.g. 'for.odata', 'to.hdi'. Needed to initialize the message functions
@@ -127,14 +128,18 @@ module.exports = {
     cdl: options => translateOptions(options, undefined, undefined, undefined, undefined, 'to.cdl'),
     sql: (options) => {
       const hardOptions = { src: 'sql', toSql: true, forHana: true };
-      const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'plain', generatedByComment: true };
+      const defaultOptions = {
+        sqlMapping: 'plain', sqlDialect: 'plain', generatedByComment: true, withHanaAssociations: true,
+      };
       const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ], 'to.sql');
 
       return Object.assign({}, processed);
     },
     hdi: (options) => {
       const hardOptions = { src: 'hdi', toSql: true, forHana: true };
-      const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana', generatedByComment: false };
+      const defaultOptions = {
+        sqlMapping: 'plain', sqlDialect: 'hana', generatedByComment: false, withHanaAssociations: true,
+      };
       return translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdi');
     },
     hdbcds: (options) => {
@@ -154,6 +159,13 @@ module.exports = {
       };
       return translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.edmx');
     },
+    odata: (options) => {
+      const hardOptions = { combined: true, toOdata: true };
+      const defaultOptions = {
+        odataVersion: 'v4', odataFormat: 'flat',
+      };
+      return translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.odata');
+    },
   },
   for: {   // TODO: Rename version to oDataVersion
     odata: (options) => {

package/lib/api/validate.js

@@ -141,7 +141,7 @@ const allCombinationValidators = {
       message.error('api-invalid-combination', null, { '#': 'sql-dialect-and-naming', name: options.sqlDialect, prop: options.sqlMapping });
   },
   'sql-dialect-and-localized': (options, message) => {
-    if (options.fewerLocalizedViews && options.sqlDialect === 'hana')
+    if (options.fewerLocalizedViews && options.sqlDialect === 'hana' && (options.withHanaAssociations || options.withHanaAssociations === undefined))
       message.error('api-invalid-combination', null, { '#': 'sql-dialect-and-localized', option: 'fewerLocalizedViews', value: 'hana' });
   },
   'beta-no-test': (options, message) => {

package/lib/base/message-registry.js

@@ -121,12 +121,12 @@ const centralMessages = {
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
-  'anno-undefined-element': { severity: 'Warning' },
-  'ref-unknown-var': { severity: 'Info', errorFor: [ 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
+  'anno-undefined-element': { severity: 'Error' },
+  'ref-unknown-var': { severity: 'Info' },
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: 'v4' },
            // does not hurt us, but makes it tedious to detect parameter refs
   'ref-undefined-param': { severity: 'Error' },
-  'anno-undefined-param': { severity: 'Warning' },
+  'anno-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
   'ref-expected-element': { severity: 'Error' },
 
@@ -254,11 +254,16 @@ const centralMessageTexts = {
     std: 'Unexpected option combination: $(OPTION) and $(PROP)', // unused
     'beta-no-test':'Option $(OPTION) was used. This option should not be used in productive scenarios!',
   },
+  'api-unexpected-option': 'Option $(OPTION) can\'t be used in backend $(MODULE)',
   'api-invalid-lookup-dir': {
     std: '',
     slash: 'Expected directory $(VALUE) in option $(OPTION) to end with $(OTHERVALUE)',
     relative: 'Expected directory $(VALUE) in option $(OPTION) to not start with $(OTHERVALUE)',
   },
+  'api-unsupported-csn-flavor': {
+    std: 'Module $(NAME) expects a client/inferred CSN, not $(OPTION)',
+    'parsed-requires': 'Module $(NAME) expects a client/inferred CSN, or a parsed CSN without dependencies, but found $(PROP) property',
+  },
 
   'anno-duplicate': {
     std: 'Duplicate assignment with $(ANNO)',
@@ -281,6 +286,11 @@ const centralMessageTexts = {
     view: 'Compiler generated view $(NAME) must not be annotated with $(ANNO) if $(ART) is not skipped',
   },
 
+  'anno-missing-rewrite': {
+    std: 'Assign a value for $(ANNO), the value inherited from $(ART) would contain invalid references like $(ELEMREF)',
+    unrelated: 'Assign a value for $(ANNO), the value inherited from $(ART) would contain references like $(ELEMREF) to unrelated elements',
+  },
+
   'chained-array-of': '"Array of"/"many" must not be chained with another "array of"/"many" inside a service',
 
   'check-proper-type-of': {
@@ -326,6 +336,9 @@ const centralMessageTexts = {
     csn: 'Expecting a non-negative integer for property $(PROP)',
     'or-asterisk': 'Expecting a non-negative integer or string $(OP) for property $(PROP)',
   },
+  'syntax-ignoring-decimal': {
+    std: 'Ignoring decimal places, because an integer was expected'
+  },
   'syntax-ignoring-anno': {
     std: 'Annotations can\'t be used in a column with $(CODE)',
     doc: 'Doc comments can\'t be used in a column with $(CODE)',
@@ -573,6 +586,7 @@ const centralMessageTexts = {
     std: 'Variable $(ID) has not been found',
     alias: 'Variable $(ID) has not been found. Use table alias $(ALIAS) to refer an element with the same name',
     self: 'Variable $(ID) has not been found. Use $(ALIAS) to refer an element with the same name',
+    value: 'No value found for variable $(ID). Use option $(OPTION) to specify a value for $(ID)',
   },
   'ref-unknown-var': {
     std: 'No replacement found for special variable $(ID)'
@@ -614,6 +628,7 @@ const centralMessageTexts = {
     self: 'A reference to an unmanaged association is only valid when compared via $(CODE)',
     expr: 'Associations can\'t be used as values in expressions',
     'expr-comp': 'Compositions can\'t be used as values in expressions',
+    'assoc-stored': 'Associations and compositions can\'t be used as values in stored calculated elements',
     cast: 'Casting to an association is not supported',
 
     'managed-filter': 'Unexpected managed association $(NAME) in filter expression of $(ID)',
@@ -646,9 +661,19 @@ const centralMessageTexts = {
     'on-condition': 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)',
     calc: 'Unexpected arguments in path $(ELEMREF) of stored calculated element; only simple paths can be used here'
   },
+  'ref-unsupported-type': {
+    std: 'Type $(TYPE) is not supported',
+    hana: 'Type $(TYPE) is only supported for SQL dialect $(VALUE), not $(OTHERVALUE)',
+    hdbcds:'Type $(TYPE) is not supported in HDBCDS',
+    odata: 'Type $(TYPE) is not supported for OData'
+  },
 
   // TODO: Better text ?
   'rewrite-not-supported': 'The ON-condition is not rewritten here - provide an explicit ON-condition',
+  'type-unsupported-rewrite': {
+    std:  'Rewriting the ON-condition not supported here', // unused: merge with 'rewrite-not-supported'
+    'sub-element': 'Rewriting the ON-condition of unmanaged association in sub element is not supported'
+  },
 
   'type-unexpected-typeof': {
     std: 'Unexpected $(KEYWORD) for the type reference here',
@@ -835,9 +860,15 @@ const centralMessageTexts = {
     param: 'A type, an element, or a service entity is expected here',
     event: 'A type, an element, an event, or a service entity is expected here',
   },
-  // TODO: text variant if the association does not start an entity
-  'ref-invalid-source': 'A query source must be an entity or an association',
-  'extend-columns': 'Artifact $(ART) can\'t be extended with columns, only projections can',
+  'ref-invalid-source': {
+    std: 'A query source must be an entity or an association',
+    event: 'An event\'s projection source must be an entity, structured type, event or an association',
+  },
+  'extend-columns': {
+    std: 'Artifact $(ART) can\'t be extended with columns, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with columns, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with columns, because it contains a UNION',
+  },
   'extend-repeated-intralayer': 'Unstable element order due to repeated extensions in same layer',
   'extend-unexpected-include': 'Can\'t extend $(META) with includes',
 
@@ -889,6 +920,7 @@ const centralMessageTexts = {
     std: 'Specified element $(NAME) differs from inferred element in property $(PROP)',
     type: 'Expected type of specified element $(NAME) to be the same as the inferred element\'s type',
     typeName: 'Expected type $(TYPE) of specified element $(NAME) to be the same as the inferred element\'s type $(OTHERTYPE)',
+    typeExtra: 'Element $(NAME) does not have an inferred type property, but an unexpected type $(TYPE) was specified',
     missing: 'Specified element $(NAME) differs from inferred element: it is missing property $(PROP)',
     extra: 'Specified element $(NAME) differs from inferred element: it has an additional property $(PROP)',
     target: 'Expected target $(TARGET) of specified element $(NAME) to be the same as the inferred element\'s target $(ART)',
@@ -937,7 +969,8 @@ const centralMessageTexts = {
     'to-structure': 'Can\'t cast to a structured type',
     'from-structure':  'Structured elements can\'t be cast to a different type',
     'expr-to-structure': 'Can\'t cast an expression to a structured type',
-    'val-to-structure': 'Can\'t cast $(VALUE) to a structured type'
+    'val-to-structure': 'Can\'t cast $(VALUE) to a structured type',
+    'from-assoc': 'Invalid type cast on an association'
   },
 
   // -----------------------------------------------------------------------------------
@@ -1018,6 +1051,7 @@ const centralMessageTexts = {
   },
   'odata-parameter-order': 'Unexpected mandatory after optional parameter',
   'odata-key-recursive': 'Unexpected recursive key $(NAME)',
+  'odata-key-uuid-default-anno': 'Expected element of type $(TYPE) to be annotated with $(ANNO) when used as primary key in $(ID)',
   // -----------------------------------------------------------------------------------
   // All odata-anno MUST have a '$(ANNO)' parameter to indicate error location
   // -----------------------------------------------------------------------------------
@@ -1026,7 +1060,7 @@ const centralMessageTexts = {
   'odata-anno-preproc': {
     'std': 'unused message text',
     'nokey': 'Expected target $(NAME) to have a key element for $(ANNO)',
-    'multkeys': 'Expected target $(NAME) to have only one key element',
+    'multkeys': 'Expected target $(NAME) to have only one key element for $(ANNO)',
     'vhlnokey': 'Expected value help list entity $(NAME) to have a key element for $(ANNO)',
     'vhlmultkeys': 'Expected value help list entity $(NAME) to have only one key element for $(ANNO)',
     'notforentity': 'Unexpected usage of $(ANNO) for an entity',
@@ -1034,8 +1068,8 @@ const centralMessageTexts = {
     'noassoc': 'Expected association $(ID) to exist for $(ANNO)',
     'vallistignored': '$(NAME) is ignored for $(ANNO) as $(CODE) is present',
     'notastring': 'Expected value to be a string for $(ANNO)',
-    'notexist': 'Expect entity $(ID) to exist for $(ANNO)',
-    'txtarr': 'Expect $(ANNO) shortcut to have a $(NAME) annotation'
+    'notexist': 'Expected entity $(ID) to exist for $(ANNO)',
+    'txtarr': 'Expected $(ANNO) shortcut to have a $(NAME) annotation'
   },
   // -----------------------------------------------------------------------------------
   // GenericTranslation:
@@ -1074,6 +1108,7 @@ const centralMessageTexts = {
     'unknown': '$(TYPE) is not a known vocabulary type for $(ANNO)',
     'abstract': 'Unexpected abstract type $(TYPE) for $(ANNO), use $(CODE) to specify a concrete type',
     'derived': 'Expected specified $(TYPE) to be derived from $(NAME) for $(ANNO)',
+    'literal': 'Expected value $(RAWVALUE) of specified $(CODE) to be a string literal for $(ANNO)'
   },
   'odata-anno-def': {
     // All $(ANNO) w/o sub elements, term qualifiers and context stack

package/lib/base/messages.js

@@ -305,14 +305,14 @@ function makeMessageFunction( model, options, moduleName = null ) {
       throw new CompilerAssertion('makeMessageFunction() expects options.messages to exist in testMode!');
   }
 
-  const hasMessageArray = !!options.messages;
+  const hasMessageArray = Array.isArray(options.messages);
   /**
    * Array of collected compiler messages. Only use it for debugging. Will not
    * contain the messages created during a `callTransparently` call.
    *
    * @type {CompileMessage[]}
    */
-  let messages = options.messages || [];
+  let messages = hasMessageArray ? options.messages : [];
   /**
    * Whether an error was emitted in the module. Also includes reclassified errors.
    * @type {boolean}
@@ -332,6 +332,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     throwWithAnyError,
     callTransparently,
     moduleName,
+    setModel,
   };
 
   function _message( id, location, textOrArguments, severity, texts = null ) {
@@ -550,6 +551,16 @@ function makeMessageFunction( model, options, moduleName = null ) {
     messages = backup;
     return collected;
   }
+
+  /**
+   * Change the model used to calculate CSN locations.
+   * This is necessary if you change the model heavily and rely on $paths relative to the new model.
+   *
+   * @param {CSN.Model} _model
+   */
+  function setModel( _model ) {
+    model = _model;
+  }
 }
 
 /**
@@ -679,6 +690,7 @@ const paramsTransform = {
   meta: quote.angle,
   othermeta: quote.angle,
   keyword,
+  module: quote.single,
   // more complex convenience:
   names: transformManyWith( quoted ),
   number: quote.single,         // number cited from source or expected in source
@@ -797,15 +809,16 @@ function tokenSymbol( token ) {
  * Transform an element reference (/path), e.g. on-condition path.
  */
 function transformElementRef( arg ) {
-  if (arg.ref) {
-    // Can be used by CSN backends to create a simple path such as E:elem
-    return quoted(arg.ref.map((ref) => {
-      if (ref.id)
-        return `${ ref.id }${ref.args ? '(…)' : ''}${ref.where ? '[…]' : ''}`;
-      return ref;
-    }).join('.'));
-  }
-  return quoted(arg);
+  const ref = arg.ref || arg.path;
+  if (!ref)
+    return quoted( arg );
+  // Can be used by CSN backends or compiler to create a simple path such as E:elem
+  return quoted(
+    ref.map(
+      item => (typeof item !== 'string'
+               ? `${ item.id }${item.args ? '(…)' : ''}${item.where ? '[…]' : ''}`
+               : item) )
+      .join('.') );
 }
 
 function transformArg( arg, r, args, texts ) {
@@ -1299,7 +1312,7 @@ function deduplicateMessages( messages ) {
 }
 
 function shortArtName( art ) {
-  if (!art.name)
+  if (!art.name || art.kind === '$annotation')
     return artName( art );
   const name = getArtifactName( art );
   if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
@@ -1310,7 +1323,7 @@ function shortArtName( art ) {
 
 function artName( art, omit ) {
   let suffix = 0;
-  while (!art.name && art._outer) {
+  while (!art.name && art._outer && art.kind !== '$annotation') {
     ++suffix;
     art = art._outer;
   }
@@ -1367,8 +1380,12 @@ function homeName( art, absoluteOnly ) {
     return art;
   if (art._user)               // when providing a path item with filter as “user”
     return homeName( art._user, absoluteOnly );
-  if (art._outer)               // in items property
-    return homeName( art._outer, absoluteOnly );
+  if (art._outer) {              // in items property, or annotation with path
+    const outer = homeName( art._outer, absoluteOnly );
+    return (art.kind === '$annotation')
+      ? `${ outer }/${ quoted( '@' + art.name.id ) }`
+      : outer;
+  }
   else if (art.kind === 'source' || !art.name) // error reported in parser or on source level
     return null;
   else if (art.kind === 'using')
@@ -1578,7 +1595,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
     else if (step === 'targetAspect') {
       // skip
     }
-    else if (step === 'xpr' || step === 'ref' || step === 'as' || step === 'value') {
+    else if (step === 'xpr' || step === 'default' || step === 'ref' || step === 'as' || step === 'value') {
       break; // don't go into xprs, refs, aliases, values, etc.
     }
     else if (step === 'returns') {

package/lib/base/model.js

@@ -27,6 +27,7 @@ const queryOps = {
 const availableBetaFlags = {
   // enabled by --beta-mode
   annotationExpressions: true,
+  odataAnnotationExpressions: true,
   assocsWithParams: true, // beta, because runtimes don't support it, yet.
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
@@ -35,6 +36,9 @@ const availableBetaFlags = {
   optionalActionFunctionParameters: true, // not supported by runtime, yet.
   annotateForeignKeys: true,
   effectiveCsn: true,
+  tenantVariable: true,
+  calcAssoc: true,
+  vectorType: true,
   // disabled by --beta-mode
   nestedServices: false,
 };