@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/base/optionProcessorHelper.js

@@ -16,7 +16,8 @@
  *   optionProcessor.command('toXyz')
  *     .help(`Help text for command "toXyz")
  *     .option('-y  --y-in-long-form')
- *     .option('    --bar-wiz <w>', ['bla', 'foo'])
+ *     .option('    --bar-wiz <w>', { valid: ['bla', 'foo'] })
+ *     .option('-z  --name-in-cdsc', { optionName: 'nameInOptions' })
  * ```
  *
  * Options *must* have a long form, can have at most one <param>, and optionally
@@ -34,29 +35,27 @@ function createOptionProcessor() {
     optionClashes: [],
     option,
     command,
-    positionalArgument: (argumentDefinition) => {
+    positionalArgument(argumentDefinition) {
       // Default positional arguments; may be overwritten by commands.
       _setPositionalArguments(argumentDefinition);
       return optionProcessor;
     },
     help,
     processCmdLine,
-    verifyOptions,
-    camelOptionsForCommand,
-    // TODO: Why exported?
-    _parseCommandString,
-    _parseOptionString,
   };
   return optionProcessor;
 
   /**
    * API: Define a general option.
    * @param {string} optString Option string describing the command line option.
-   * @param {string[]} [validValues] Array of valid values for the options.
-   * @param {object} [options] Further options such as `ignoreCase: true`
+   * @param {object} [options] Further options such as `ignoreCase: true` and `valid: []`.
+   * @param {string[]} [options.valid] Valid values for the option.
+   * @param {string[]} [options.ignoreCase] Ignore the case for "options.valid".
+   * @param {string[]} [options.optionName] Name of the option after parsing CLI arguments.
+   *                                        Defaults to the camelified name of the long name.
    */
-  function option( optString, validValues, options ) {
-    return _addOption(optionProcessor, optString, validValues, options);
+  function option( optString, options ) {
+    return _addOption(optionProcessor, optString, options);
   }
 
   /**
@@ -78,7 +77,7 @@ function createOptionProcessor() {
       options: {},
       positionalArguments: [],
       option: commandOption,
-      positionalArgument: (argumentDefinition) => {
+      positionalArgument(argumentDefinition) {
         _setPositionalArguments(argumentDefinition, cmd.positionalArguments);
         return cmd;
       },
@@ -99,8 +98,8 @@ function createOptionProcessor() {
     return cmd;
 
     // Command API: Define a command option
-    function commandOption( optString, validValues, options ) {
-      return _addOption(cmd, optString, validValues, options);
+    function commandOption( optString, options ) {
+      return _addOption(cmd, optString, options);
     }
 
     // Command API: Define the command help text
@@ -124,13 +123,15 @@ function createOptionProcessor() {
     if (argList.find(arg => arg.isDynamic))
       throw new Error('Can\'t add positional arguments after a dynamic one');
 
-
     const registeredNames = argList.map(arg => arg.name);
     const args = argumentDefinition.split(' ');
 
     for (const arg of args) {
       // Remove braces, dots and camelify.
-      const argName = arg.replace('<', '').replace('>', '').replace('...', '').replace(/[ -]./g, s => s.substring(1).toUpperCase());
+      const argName = arg.replace('<', '')
+        .replace('>', '')
+        .replace('...', '')
+        .replace(/[ -]./g, s => s.substring(1).toUpperCase());
 
       if (registeredNames.includes(argName))
         throw new Error(`Duplicate positional argument: ${ arg }`);
@@ -138,7 +139,6 @@ function createOptionProcessor() {
       if (!isParam(arg) && !isDynamicPositionalArgument(arg))
         throw new Error(`Unknown positional argument syntax: ${ arg }`);
 
-
       argList.push({
         name: argName,
         isDynamic: isDynamicPositionalArgument(arg),
@@ -157,65 +157,42 @@ function createOptionProcessor() {
    * @private
    * @see option()
    */
-  function _addOption( cmd, optString, validValues, options ) {
-    const cliOpt = _parseOptionString(optString, validValues);
+  function _addOption( cmd, optString, options ) {
+    const cliOpt = _parseOptionString(optString, options);
     Object.assign(cliOpt, options);
-    _addLongOption(cmd, cliOpt.longName, cliOpt);
-    _addShortOption(cmd, cliOpt.shortName, cliOpt);
+    _addOptionName(cmd, cliOpt.longName, cliOpt);
+    _addOptionName(cmd, cliOpt.shortName, cliOpt);
 
     for (const alias of cliOpt.aliases || []) {
       const aliasOpt = Object.assign({ }, cliOpt, { isAlias: true });
-      _addLongOption(cmd, alias, aliasOpt); // use same camelName, etc. for alias
+      _addOptionName(cmd, alias, aliasOpt); // use same optionName, etc. for alias
     }
 
     return cmd;
   }
 
   /**
-   * Internal: Add longName to the list of options.
-   * Throws if the option is already registered in the given command context.
-   * or in the given command.
-   * `longName` may differ from `opt.longName`, e.g. for aliases.
-   *
-   * @private
-   * @see _addOption()
-   */
-  function _addLongOption( cmd, longName, opt ) {
-    if (cmd.options[longName]) {
-      throw new Error(`Duplicate assignment for long option ${ longName }`);
-    }
-    else if (optionProcessor.options[longName]) {
-      // This path is only taken if optString is for commands
-      optionProcessor.optionClashes.push({
-        option: longName,
-        description: `Command '${ cmd.longName }' has option clash with general options for: ${ longName }`,
-      });
-    }
-    cmd.options[longName] = opt;
-  }
-  /**
-   * Internal: Add shortName to the list of options.
+   * Internal: Add a name to the list of options.
    * Throws if the option is already registered in the given command context.
    * or in the given command.
-   * `longName` may differ from `opt.longName`, e.g. for aliases.
    *
    * @private
    * @see _addOption()
    */
-  function _addShortOption( cmd, shortName, opt ) {
-    if (!shortName)
+  function _addOptionName( cmd, name, opt ) {
+    if (!name)
       return;
-    if (cmd.options[shortName]) {
-      throw new Error(`Duplicate assignment for short option ${ shortName }`);
+    if (cmd.options[name]) {
+      throw new Error(`Duplicate assignment for option ${ name }`);
     }
-    else if (optionProcessor.options[shortName]) {
+    else if (optionProcessor.options[name]) {
       // This path is only taken if optString is for commands
       optionProcessor.optionClashes.push({
-        option: shortName,
-        description: `Command '${ cmd.longName }' has option clash with general options for: ${ shortName }`,
+        option: name,
+        description: `Command '${ cmd.longName }' has option clash with general options for: ${ name }`,
       });
     }
-    cmd.options[shortName] = opt;
+    cmd.options[name] = opt;
   }
 
   // Internal: Parse one command string like "F, toFoo". Return an object like this
@@ -251,11 +228,11 @@ function createOptionProcessor() {
   // {
   //   longName: '--foo-bar',
   //   shortName: '-f',
-  //   camelName: 'fooBar',
+  //   optionName: 'fooBar', // or options.optionName if provided
   //   param: '<p>'
-  //   validValues
+  //   valid
   // }
-  function _parseOptionString( optString, validValues ) {
+  function _parseOptionString( optString, options ) {
     let longName;
     let shortName;
     let param;
@@ -294,11 +271,11 @@ function createOptionProcessor() {
     if (!longName)
       throw new Error(`Invalid option description, missing long name: ${ optString }`);
 
-    if (!param && validValues)
+    if (!param && options?.valid)
       throw new Error(`Option description has valid values but no param: ${ optString }`);
 
-    if (validValues) {
-      validValues.forEach((value) => {
+    if (options?.valid) {
+      options.valid.forEach((value) => {
         if (typeof value !== 'string')
           throw new Error(`Valid values must be of type string: ${ optString }`);
       });
@@ -307,9 +284,9 @@ function createOptionProcessor() {
     return {
       longName,
       shortName,
-      camelName: camelifyLongOption(longName),
+      optionName: options?.option ?? camelifyLongOption(longName),
       param,
-      validValues,
+      valid: options?.valid,
       isAlias: false, // default
     };
   }
@@ -520,10 +497,10 @@ function createOptionProcessor() {
         if (currentCommand) {
           if (!result.options[currentCommand])
             result.options[currentCommand] = {};
-          result.options[currentCommand][currentOption.camelName] = val;
+          result.options[currentCommand][currentOption.optionName] = val;
         }
         else {
-          result.options[currentOption.camelName] = val;
+          result.options[currentOption.optionName] = val;
         }
       }
 
@@ -542,7 +519,7 @@ function createOptionProcessor() {
       function reportInvalidValue( opt, value ) {
         const shortOption = opt.shortName ? `${ opt.shortName }, ` : '';
         const errors = currentCommand ? result.cmdErrors : result.errors;
-        errors.push(`Invalid value "${ value }" for option "${ shortOption }${ opt.longName }" - use one of [${ opt.validValues }]`);
+        errors.push(`Invalid value "${ value }" for option "${ shortOption }${ opt.longName }" - use one of [${ opt.valid }]`);
       }
 
       /**
@@ -580,114 +557,14 @@ function createOptionProcessor() {
     }
   }
 
-  // Assuming that 'options' came from this option processor, verify options therein.
-  // If 'command' is supplied, check only 'options.command', otherwise check
-  // only top-level options
-  // Return an array of complaints (possibly empty)
-  function verifyOptions( options, commandName = undefined, silent = false ) {
-    const result = [];
-    let opts;
-
-    if ((options.betaMode || options.beta) && !options.testMode && !silent) {
-      const mode = options.beta ? 'beta' : 'beta-mode';
-      result.push(`Option --${ mode } was used. This option should not be used in productive scenarios!`);
-    }
-
-    if (options) {
-      [
-        'defaultBinaryLength', 'defaultStringLength',
-        /* 'length', 'precision', 'scale' */
-      ].forEach((facet) => {
-        if (options[facet] && isNaN(options[facet]))
-          result.push(`Invalid value "${ options[facet] }" for option "--${ facet }" - not an Integer`);
-        else
-          options[facet] = parseInt(options[facet]);
-      });
-    }
-
-    if (commandName) {
-      const cmd = optionProcessor.commands[commandName];
-      if (!cmd)
-        throw new Error(`Expected existing command: "${ cmd }"`);
-
-      opts = cmd.options;
-      options = options[cmd] || {};
-      if (typeof options === 'boolean') {
-        // Special case: command without options
-        options = {};
-      }
-    }
-    else {
-      opts = optionProcessor.options;
-    }
-    // Look at each supplied option
-    for (const camelName in options) {
-      const opt = opts[uncamelifyLongOption(camelName)];
-      let error;
-      if (!opt) {
-        // Don't report commands in top-level options
-        if ((commandName || !optionProcessor.commands[camelName]) && !silent) {
-          const prefix = commandName ? `${commandName}.` : '';
-          error = `Unknown option "${prefix}${camelName}"`;
-        }
-      }
-      else {
-        const param = options[camelName];
-        error = verifyOptionParam(param, opt, commandName ? `${ commandName }.` : '');
-      }
-      if (error)
-        result.push(error);
-    }
-    // hard-coded option dependencies (they disappear with command)
-    return result;
-
-    /**
-     * Verify parameter value 'param' against option definition 'opt'. Return an error
-     * string or false for an accepted param. Use 'prefix' when mentioning the option name.
-     *
-     * @param param
-     * @param opt
-     * @param prefix
-     * @return {string|boolean}
-     */
-    function verifyOptionParam( param, opt, prefix ) {
-      if (opt.param) {
-        // Parameter is required for this option
-        if (typeof param === 'boolean')
-          return `Missing value for option "${ prefix }${ opt.camelName }"`;
-        else if (!isValidOptionValue(opt, param))
-          return `Invalid value "${ param }" for option "${ prefix }${ opt.camelName }" - use one of [${ opt.validValues }]`;
-
-        return false;
-      }
-      // Option does not expect a parameter
-      if (typeof param !== 'boolean') {
-        // FIXME: Might be a bit too strict in case of internal sub-options like 'forHana' etc...
-        return `Expecting boolean value for option "${ prefix }${ opt.camelName }"`;
-      }
-
-      return false;
-    }
-  }
-
   function isValidOptionValue( opt, value ) {
     // Explicitly convert to string, input 'value' may be boolean
     value = String(value);
-    if (!opt.validValues || !opt.validValues.length)
+    if (!opt.valid?.length)
       return true;
     if (opt.ignoreCase)
-      return opt.validValues.some( valid => valid.toLowerCase() === value.toLowerCase() );
-    return opt.validValues.includes(value);
-  }
-
-  // Return an array of unique camelNames of the options for the specified command
-  // If invalid command -> an empty array
-  function camelOptionsForCommand( cmd ) {
-    if (!cmd || !optionProcessor.commands[cmd])
-      return [];
-    cmd = optionProcessor.commands[cmd];
-    const names = Object.keys(cmd.options).map(name => cmd.options[name].camelName);
-    return [ ...new Set(names) ];
+      return opt.valid.some( valid => valid.toLowerCase() === value.toLowerCase() );
+    return opt.valid.includes(value);
   }
 }
 
@@ -713,14 +590,6 @@ function camelifyLongOption( opt ) {
   return opt.substring(2).replace(/-./g, s => s.substring(1).toUpperCase());
 }
 
-/**
- * Return a long option name like "--foo-bar" for a camel-case name "fooBar"
- */
-function uncamelifyLongOption( opt ) {
-  const longForm = opt.replace(/[A-Z]/g, s => `-${ s.toLowerCase() }`);
-  return `--${ longForm }`;
-}
-
 /**
  * Check if 'opt' looks like a "-f" short option
  */

package/lib/checks/annotationsOData.js

@@ -66,9 +66,58 @@ function checkReadOnlyAndInsertOnly( artifact, artifactName ) {
     this.warning(null, artifact.$path, {}, 'Annotations “@readonly” and “@insertonly” can\'t be assigned in combination');
 }
 
+/**
+ * Check temporal annotations @cds.valid.from, @cds.valid.to, @cds.valid.key
+ * assignment for the given artifact. This consists of the following:
+ * - @cds.valid.from/to/key annotation is assigned only once in the scope of the definition
+ * - annotation is assigned only to allowed element types. Not allowed on association/composition,
+ *   structured elements, leaf element of a structure
+ * - when @cds.valid.key is used, it requires also @cds.valid.from and @cds.valid.to to be defined
+ * @param {CSN.Artifact} artifact
+ * @param {string} artifactName
+ */
+function checkTemporalAnnotationsAssignment( artifact, artifactName ) {
+  const valid = { from: [], to: [], key: [] };
+
+  // collect annotation assignments throughout the elements of the definition
+  this.recurseElements( artifact, artifact.$path || [ 'definitions', artifactName ], (member, path) => {
+    checkForAnnoAssignmentAndApplicability.bind(this)('from', member, path);
+    checkForAnnoAssignmentAndApplicability.bind(this)('to', member, path);
+    checkForAnnoAssignmentAndApplicability.bind(this)('key', member, path);
+  });
+
+  // check if the annotations are assigned more than once in the scope of the current artifact
+  this.checkMultipleAssignments(valid.from, '@cds.valid.from', artifact, artifactName);
+  this.checkMultipleAssignments(valid.to, '@cds.valid.to', artifact, artifactName);
+  this.checkMultipleAssignments(valid.key, '@cds.valid.key', artifact, artifactName);
+
+  // if @cds.valid.key is defined, check whether @cds.valid.from and @cds.valid.to are also there
+  if (valid.key.length && !(valid.from.length && valid.to.length))
+    this.error(null, [ 'definitions', artifactName ], 'Annotation “@cds.valid.key” was used but “@cds.valid.from” and “@cds.valid.to” are missing');
+
+  /**
+   * Check if the given annotation is assigned to the current member and collect the path if so.
+   * Also determine whether the annotation is applicable for the member type. @cds.valid.from/to.key annotations
+   * are NOT allowed for elements which are: association/composition, structured or leaf element of a structure
+   *
+   * @param {string} annoIdentifier
+   * @param {CSN.Element} member
+   * @param {CSN.Path} path
+   */
+  function checkForAnnoAssignmentAndApplicability( annoIdentifier, member, path ) {
+    if (this.csnUtils.hasAnnotationValue(member, `@cds.valid.${ annoIdentifier }`)) {
+      valid[annoIdentifier].push(path);
+      // check whether annotation is not assigned to not allowed element type, these are: association, structured elements, leaf element of a structure
+      if (this.csnUtils.isAssocOrComposition(member) || this.csnUtils.isStructured(member) || path.length > 5)
+        this.error(null, member.$path, { anno: `@cds.valid.${ annoIdentifier }` }, 'Element can\'t be annotated with $(ANNO)');
+    }
+  }
+}
+
 module.exports = {
   checkCoreMediaTypeAllowance,
   checkAnalytics,
   checkAtSapAnnotations,
   checkReadOnlyAndInsertOnly,
+  checkTemporalAnnotationsAssignment,
 };

package/lib/checks/elements.js

@@ -112,45 +112,43 @@ function checkVirtualElement( member ) {
  * Checks whether managed associations
  * with cardinality 'to many' have an on-condition.
  *
- * @param {CSN.Artifact} art The artifact
- * @todo this is a member validator, is it not?
+ * @param {CSN.Artifact} member The member (e.g. element artifact)
  */
-function checkManagedAssoc( art ) {
-  forEachMemberRecursively(art, (member) => {
-    if (this.csnUtils.isAssocOrComposition(member) &&
-        !isManagedComposition.bind(this)(member)) {
-      // Implementation note:  Imported services (i.e. external ones) may contain to-many associations
-      // with an empty foreign key list.  If the user (in this case importer) explicitly sets an empty
-      // foreign key array, we won't emit a warning to avoid spamming the user.
-      const max = member.cardinality?.max ? member.cardinality.max : 1;
-      if (max !== 1 && !member.on && (!member.keys || member.keys.length > 0)) {
-        const isNoDb = art['@cds.persistence.skip'] || art['@cds.persistence.exists'];
-        this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality ? member.cardinality.$path : member.$path, {
-          value: cardinality2str(member, false),
-          '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
-        }, {
-          std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
-          comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
-        });
-      }
-    }
-  });
+function checkManagedAssoc( member ) {
+  if (!member.target || isManagedComposition.bind(this)(member))
+    return;
 
-  /**
-   *
-   * @param {CSN.Element} member The member
-   * @returns {boolean} Whether the member is managed composition
-   */
-  function isManagedComposition( member ) {
-    if (member.targetAspect)
-      return true;
-    if (!member.target)
-      return false;
-    const target = typeof member.target === 'object' ? member.target : this.csnUtils.getCsnDef(member.target);
-    return target.kind !== 'entity';
+  // Implementation note:  Imported services (i.e. external ones) may contain to-many associations
+  // with an empty foreign key list.  If the user (in this case importer) explicitly sets an empty
+  // foreign key array, we won't emit a warning to avoid spamming the user.
+  const max = member.cardinality?.max ? member.cardinality.max : 1;
+  if (max !== 1 && !member.on && (!member.keys || member.keys.length > 0)) {
+    const isNoDb = this.artifact['@cds.persistence.skip'] || this.artifact['@cds.persistence.exists'];
+    this.warning(isNoDb ? 'to-many-no-on-noDB' : 'to-many-no-on', member.cardinality ? member.cardinality.$path : member.$path, {
+      value: cardinality2str(member, false),
+      '#': this.csnUtils.isComposition(member) ? 'comp' : 'std',
+    }, {
+      std: 'Expected association with target cardinality $(VALUE) to have an ON-condition',
+      comp: 'Expected composition with target cardinality $(VALUE) to have an ON-condition',
+    });
   }
 }
 
+/**
+ *
+ * @param {CSN.Element} member The member
+ * @returns {boolean} Whether the member is managed composition
+ */
+function isManagedComposition( member ) {
+  if (member.targetAspect)
+    return true;
+  if (!member.target)
+    return false;
+  const target = typeof member.target === 'object' ? member.target : this.csnUtils.getCsnDef(member.target);
+  return target.kind !== 'entity';
+}
+
+
 /**
  * All DB  & OData flat mode must reject recursive type usages in entities
  * 'items' break recursion as 'items' will turn into an NCLOB and the path

package/lib/checks/enricher.js

@@ -6,6 +6,8 @@
 
 const { csnRefs } = require('../model/csnRefs');
 const { setProp } = require('../base/model');
+const { xprInAnnoProperties } = require('../compiler/builtins');
+
 /**
  * The following properties are attached as non-enumerable where appropriate:
  *
@@ -16,9 +18,10 @@ const { setProp } = require('../base/model');
  *- `$path` has the csnPath to reach that property.
  *
  * @param {CSN.Model} csn CSN to enrich in-place
+ * @param {enrichCsnOptions} [options={}]
  * @returns {{ csn: CSN.Model, cleanup: () => void }} CSN with all ref's pre-resolved
  */
-function enrichCsn( csn ) {
+function enrichCsn( csn, options ) {
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -31,8 +34,7 @@ function enrichCsn( csn ) {
     target,
     includes: simpleRef,
     columns,
-    // Annotations are ignored.
-    '@': () => { /* ignore annotations */ },
+    '@': annotation,
   };
   let cleanupCallbacks = [];
 
@@ -83,6 +85,35 @@ function enrichCsn( csn ) {
     csnPath.pop();
   }
 
+  /**
+   * Transformer for things that are annotations. When we have a "=" plus an expression of some sorts,
+   * we treat it like a "standard" thing.
+   *
+   * @param {object | Array} _parent the thing that has _prop
+   * @param {string|number} _prop the name of the current property or index
+   * @param {object} node The value of node[_prop]
+   */
+  function annotation( _parent, _prop, node ) {
+    if (options.processAnnotations) {
+      if (node?.['='] !== undefined && xprInAnnoProperties.some(xProp => node[xProp] !== undefined)) {
+        standard(_parent, _prop, node);
+      }
+      else if (node && typeof node === 'object') {
+        csnPath.push(_prop);
+
+        if (Array.isArray(node)) {
+          node.forEach( (n, i) => annotation( node, i, n ) );
+        }
+        else {
+          for (const name of Object.getOwnPropertyNames( node ))
+            annotation( node, name, node[name] );
+        }
+
+        csnPath.pop();
+      }
+    }
+  }
+
   // eslint-disable-next-line jsdoc/require-jsdoc
   function columns( parent, prop, node ) {
     // Establish the link relationships
@@ -178,3 +209,8 @@ function enrichCsn( csn ) {
 }
 
 module.exports = enrichCsn;
+
+/**
+ * @typedef {object} enrichCsnOptions
+ * @property {boolean} [processAnnotations=false] Wether to process annotations and call custom transformers on them
+ */

package/lib/checks/validator.js

@@ -22,6 +22,7 @@ const { checkActionOrFunction } = require('./actionsFunctions');
 const {
   checkCoreMediaTypeAllowance, checkAnalytics,
   checkAtSapAnnotations, checkReadOnlyAndInsertOnly,
+  checkTemporalAnnotationsAssignment,
 } = require('./annotationsOData');
 // both
 const { validateOnCondition, validateMixinOnCondition } = require('./onConditions');
@@ -120,12 +121,11 @@ const forOdataQueryValidators = [];
 const commonMemberValidators
 = [ validateOnCondition, validateForeignKeys,
   validateAssociationsInItems, checkForInvalidTarget,
-  checkVirtualElement ];
+  checkVirtualElement, checkManagedAssoc ];
 
 // TODO: checkManagedAssoc is a forEachMemberRecursively!
 const commonArtifactValidators = [
   checkTypeDefinitionHasType,
-  checkManagedAssoc,
   checkRecursiveTypeUsage,
 ];
 // TODO: Does it make sense to run the on-condition check as part of a CSN validator?
@@ -136,10 +136,10 @@ const commonQueryValidators = [ validateMixinOnCondition ];
  *
  * @param {CSN.Model} csn CSN to check
  * @param {object} that Will be provided to the validators via "this"
- * @param {object[]} [csnValidators=[]] Validations on whole CSN using applyTransformations
- * @param {Function[]} [memberValidators=[]] Validations on member-level
- * @param {Function[]} [artifactValidators=[]] Validations on artifact-level
- * @param {Function[]} [queryValidators=[]] Validations on query-level
+ * @param {object[]} [csnValidators] Validations on whole CSN using applyTransformations
+ * @param {Function[]} [memberValidators] Validations on member-level
+ * @param {Function[]} [artifactValidators] Validations on artifact-level
+ * @param {Function[]} [queryValidators] Validations on query-level
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated e.g. 'action' and 'function' for hana
  * @returns {Function} Function taking no parameters, that cleans up the attached helpers
  */
@@ -149,7 +149,7 @@ function _validate( csn, that,
                     artifactValidators = [],
                     queryValidators = [],
                     iterateOptions = {} ) {
-  const { cleanup } = enrich(csn);
+  const { cleanup } = enrich(csn, { processAnnotations: that.options.tranformation === 'odata' });
 
   applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], { drillRef: true });
 
@@ -267,6 +267,7 @@ function forOdata( csn, that ) {
                            checkAtSapAnnotations.bind(that),
                          ]);
                        }
+                       checkTemporalAnnotationsAssignment.bind(that)(artifact, artifactName);
                      }
                    ),
                    // eslint-disable-next-line sonarjs/no-empty-collection