@sap/cds-compiler 3.9.4 → 4.0.2

package/lib/main.d.ts

@@ -287,6 +287,23 @@ declare namespace compiler {
        */
       $session?: Record<string, string | object>
     }
+    /**
+     * If turned on, renders:
+     *
+     *  - `$user.‹id|locale›` as `session_context( '$user.‹id|locale›' )`
+     *     instead of requiring them to be set in `sqlOptions.variableReplacements`, and
+     *  - `$at.‹from|to›` and `$valid.‹from|to›` as `session_context( '$valid.‹from|to›' )`
+     *     instead of using `strftime(…)`.
+     *
+     * `sqlOptions.variableReplacements` takes precedence for `$user`.  If `$user.id` is set,
+     * the compiler will not render a `session_context(…)` function, even if this option is set.
+     *
+     * Only works with sqlDialect 'sqlite'! Otherwise, it has no effect.
+     *
+     * @since 3.9.0
+     * @beta
+     */
+    betterSqliteSessionVariables?: boolean
   }
 
   /**
@@ -538,7 +555,7 @@ declare namespace compiler {
 
   /**
    * Returns a message string with file- and semantic location if present in compact
-   * form (i.e. one line)
+   * form (i.e. one line).
    *
    * Example:
    * ```
@@ -549,36 +566,113 @@ declare namespace compiler {
    * @param normalizeFilename If true, the file path will be normalized to use `/` as the path separator.
    * @param noMessageId       If true, the message ID will _not_ be part of the string.
    * @param noHome            If true, the semantic location will _not_ be part of the string.
+   *
+   * @deprecated Use messageString(msg, config) instead.
    */
   export function messageString(msg: CompileMessage, normalizeFilename?: boolean, noMessageId?: boolean, noHome?: boolean): string;
 
   /**
-   * Returns a message string with file- and semantic location if present
-   * in multiline form.
-   * The error (+ message id) can colored according to their severity.
+   * Returns a message string with file- and semantic location if present in compact
+   * form (i.e. one line).
    *
    * Example:
    * ```
-   * Error[message-id]: Can't find type `nu` in this scope
-   *    |
-   *   <source>.cds:3:11, at entity:“E”/element:“e”
+   * <source>.cds:3:11: Error message-id: Can't find type `nu` in this scope (in entity:“E”/element:“e”)
    * ```
    *
-   * @param config.normalizeFilename If true, the file path will be normalized to use `/` as the path separator.
-   * @param config.noMessageId       If true, no messages id (in brackets) will be shown.
-   * @param config.hintExplanation   If true, messages with explanations will get a "…" marker, see {@link hasMessageExplanation}.
-   * @param config.withLineSpacer    If true, an additional line (with `|`) will be inserted between message and location.
-   * @param config.color             If true, ANSI escape codes will be used for coloring the severity.  If false, no
-   *                                 coloring will be used.  If 'auto', we will decide based on certain factors such
-   *                                 as whether the shell is a TTY and whether the environment variable `NO_COLOR` is
-   *                                 unset.
+   * Example Usage:
+   *   ```js
+   *   const config = { normalizeFilename: false, noMessageId: true };
+   *   console.log(messages.map(msg => compiler.messageString(msg, config)));
+   *   ```
+   *
+   * @param config.normalizeFilename
+   *     If true, the file path will be normalized to use `/` as the path separator (instead of `\` on Windows).
+   *
+   * @param config.noMessageId
+   *     If true, will _not_ show the message ID (+ explanation hint) in the output.
+   *
+   * @param config.noHome
+   *     If true, will _not_ show message's semantic location.
+   *
+   * @param config.module
+   *     If set, downgradable error messages will get a '‹↓›' marker, depending on whether
+   *     the message can be downgraded for the given module.
+   */
+  export function messageString(msg: CompileMessage, config?: {
+    normalizeFilename?: boolean
+    noMessageId?: boolean
+    noHome?: boolean
+    module?: string
+  }): string;
+
+  /**
+   * Returns a message string with file- and semantic location if present in multiline form
+   * with a source code snippet below that has highlights for the message's location.
+   * The message (+ message id) are colored according to their severity.
+   *
+   * IMPORTANT: Argument `config` should be re-used by subsequent calls to this function,
+   *            because it caches argument `config.sourceLineMap`.
+   *
+   * Example Output:
+   *   ```
+   *   Error[message-id]: Can't find type `nu` in this scope
+   *      |
+   *     <source>.cds:3:10, at entity:“E”/element:“e”
+   *      |
+   *    3 |       e : nu;
+   *      |           ^^
+   *  ```
+   *
+   * Example Usage:
+   *   ```js
+   *   const config = { sourceMap: fileCache, cwd: '' };
+   *   console.log(messages.map(msg => compiler.messageStringMultiline(msg, config)));
+   *   ```
+   *
+   * @param config.normalizeFilename
+   *     If true, the file path will be normalized to use `/` as the path separator (instead of `\` on Windows).
+   *
+   * @param config.noMessageId
+   *     If true, will _not_ show the message ID (+ explanation hint) in the output.
+   *
+   * @param config.hintExplanation
+   *     If true, messages with explanations will get a "…" marker, see {@link hasMessageExplanation}.
+   *
+   * @param config.module
+   *     If set, downgradable error messages will get a '‹↓›' marker, depending on whether
+   *     the message can be downgraded for the given module.
+   *
+   * @param config.sourceMap
+   *     A dictionary of filename<->source-code entries.  You can pass the fileCache that is used
+   *     by the compiler.
+   *
+   * @param config.sourceLineMap
+   *     A dictionary of filename<->source-newline-indices entries. Is used to extract source code
+   *     snippets for message locations.  If not set, will be set and filled by this function on-demand.
+   *     An entry is an array of character/byte offsets to new-lines, for example sourceLineMap[1] is the
+   *     end-newline for the second line.
+   *
+   * @param config.cwd
+   *     The current working directory (cwd) that was passed to the compiler.
+   *     This value is only used if a source map is provided and relative paths needs to be
+   *     resolved to absolute ones.
+   *
+   * @param config.color
+   *     If true/'always', ANSI escape codes will be used for coloring the severity.  If false/'never',
+   *     no coloring will be used.  If 'auto', we will decide based on certain factors such
+   *     as whether the shell is a TTY and whether the environment variable `NO_COLOR` is
+   *     unset.
    */
   export function messageStringMultiline(msg: CompileMessage, config?: {
     normalizeFilename?: boolean
     noMessageId?: boolean
     hintExplanation?: boolean
-    withLineSpacer?: boolean
-    color?: boolean | 'auto'
+    module?: string
+    sourceMap?: Record<string, string>
+    sourceLineMap?: Record<string, number[]>
+    cwd?: string
+    color?: boolean | 'auto' | 'always' | 'never'
   }): string;
 
   /**
@@ -604,6 +698,8 @@ declare namespace compiler {
    *                     coloring will be used.  If 'auto', we will decide based on certain factors such
    *                     as whether the shell is a TTY and whether the environment variable `NO_COLOR` is
    *                     unset.
+   *
+   * @deprecated Use {@link messageStringMultiline} with `config.sourceMap` and `config.sourceLineMap` instead!
    */
   export function messageContext(sourceLines: string[], msg: CompileMessage, config?: {
     color?: boolean | 'auto'
@@ -710,8 +806,8 @@ declare namespace compiler {
        *    // 'OCCURRENCE'
        *    to.cdl.smartId('OCCURRENCE', 'REPLACE_REGEXPR')
        *    // '![OCCURRENCE]'
-       *    to.cdl.smartId('myid')
-       *    // 'myid'
+       *    to.cdl.smartId('myId')
+       *    // 'myId'
        *    ```
        *
        * @param name
@@ -727,8 +823,8 @@ declare namespace compiler {
        *    ```js
        *    to.cdl.smartFunctionId('with ![brackets]')
        *    // '![with ![brackets]]]'
-       *    to.cdl.smartFunctionId('myfunction')
-       *    // 'myfunction'
+       *    to.cdl.smartFunctionId('myFunction')
+       *    // 'myFunction'
        *    ```
        *
        * @param name
@@ -742,8 +838,8 @@ declare namespace compiler {
        *    ```js
        *    to.cdl.delimitedId('with ![brackets]')
        *    // '![with ![brackets]]]'
-       *    to.cdl.delimitedId('myid')
-       *    // '![myid]'
+       *    to.cdl.delimitedId('myId')
+       *    // '![myId]'
        *    ```
        *
        * @param name
@@ -777,8 +873,8 @@ declare namespace compiler {
        *    // '"with ""quotes"""'
        *    to.sql.smartId('SELECT', 'sqlite')
        *    // '"SELECT"'
-       *    to.sql.smartId('myid', 'sqlite')
-       *    // 'myid'
+       *    to.sql.smartId('myId', 'sqlite')
+       *    // 'myId'
        *    ```
        *
        * @param name
@@ -794,8 +890,8 @@ declare namespace compiler {
        *    ```js
        *    to.sql.smartFunctionId('with "quotes"', 'sqlite')
        *    // '"with ""quotes"""'
-       *    to.sql.smartFunctionId('myfunction', 'sqlite')
-       *    // 'myfunction'
+       *    to.sql.smartFunctionId('myFunction', 'sqlite')
+       *    // 'myFunction'
        *    ```
        *
        * @param name
@@ -810,8 +906,8 @@ declare namespace compiler {
        *    ```js
        *    to.sql.delimitedId('with "quotes"', 'sqlite')
        *    // '"with ""quotes"""'
-       *    to.sql.delimitedId('myid', 'sqlite')
-       *    // '"myid"'
+       *    to.sql.delimitedId('myId', 'sqlite')
+       *    // '"myId"'
        *    ```
        *
        * @param name
@@ -1096,19 +1192,19 @@ declare namespace compiler {
 
   /**
    * CDS Schema Notation. Not yet specified in this TypeScript declaration file.
-   * See <https://pages.github.tools.sap/cap/docs/cds/csn> for more.
+   * See <https://cap.cloud.sap/docs/cds/csn> for more.
    */
   export type CSN = any;
 
   /**
    * CDS Query Notation. Not yet specified in this TypeScript declaration file.
-   * See <https://pages.github.tools.sap/cap/docs/cds/cqn> for more.
+   * See <https://cap.cloud.sap/docs/cds/cqn> for more.
    */
   export type CQN = any;
 
   /**
    * CDS Expression Notation. Not yet specified in this TypeScript declaration file.
-   * See <https://pages.github.tools.sap/cap/docs/cds/cxn> for more.
+   * See <https://cap.cloud.sap/docs/cds/cxn> for more.
    */
   export type CXN = any;
 
@@ -1123,10 +1219,6 @@ declare namespace compiler {
 
     severity: MessageSeverity
 
-    /**
-     * @deprecated Use `$location` instead.
-     */
-    location: Location
     /**
      * Location information like file and line/column of the message.
      */

package/lib/main.js

@@ -92,7 +92,7 @@ module.exports = {
   sortMessagesSeverityAware: (...args) => messages.sortMessagesSeverityAware(...args),
   deduplicateMessages: (...args) => messages.deduplicateMessages(...args),
   messageString: (...args) => messages.messageString(...args),
-  messageStringMultiline: (...args) => messages.messageStringMultiline(...args),
+  messageStringMultiline: (err, config) => messages.messageStringMultiline(err, config),
   messageContext: (...args) => messages.messageContext(...args),
   explainMessage: (...args) => messages.explainMessage(...args),
   hasMessageExplanation: (...args) => messages.hasMessageExplanation(...args),

package/lib/model/csnRefs.js

@@ -93,7 +93,7 @@
 // 1. We search in environments constructed by “defining” names “around” the
 //    lexical position of the reference.  In a CSN, these could be the
 //    (explicit and implicit) table alias names and `mixin` definitions of the
-//    current query and its parent queries (according to the query hiearchy).
+//    current query and its parent queries (according to the query hierarchy).
 // 2. If the search according to (1) was not successful and the name starts
 //    with a `$`, we could consider the name to be a “magic” variable with
 //    `$self` (and `$projection`) being a special magic variable.
@@ -210,7 +210,7 @@ const artifactProperties = [ 'elements', 'columns', 'keys', 'mixin', 'enum',
 //   * other (& not provided) = follow target if not last ref item
 const referenceSemantics = {
   $init: { $initOnly: true },
-  type: { lexical: false, dynamic: 'global' }, // TODO: assoc: 'static', see Issue #8458
+  type: { lexical: false, dynamic: 'global', assoc: 'static' },
   includes: { lexical: false, dynamic: 'global', assoc: 'static' }, // no elem ref anyway
   target: { lexical: false, dynamic: 'global', assoc: 'static' },   // no elem ref anyway
   targetAspect: { lexical: false, dynamic: 'global', assoc: 'static' },
@@ -256,6 +256,7 @@ function csnRefs( csn, universalReady ) {
       return getCache( pathItem, '_env' );
     } );
   };
+  artifactRef.from = fromArtifactRef;
   return {
     effectiveType,
     artifactRef,
@@ -311,6 +312,8 @@ function csnRefs( csn, universalReady ) {
     // semantic check)
     while (env.items)
       env = effectiveType( env.items );
+    if (env.elements)           // shortcut
+      return env;
     const target = (staticAssoc ? targetAspect( env ) : env.target);
     if (typeof target !== 'string')
       return target || env;
@@ -347,18 +350,26 @@ function csnRefs( csn, universalReady ) {
     throw new ModelError( `Unknown artifact reference: ${ typeof ref !== 'string' ? JSON.stringify(ref.ref) : ref }` );
   }
 
+  function fromArtifactRef( ref ) {
+    // do not cache while there is second param
+    const art = artifactFromRef( ref, true );
+    if (art)
+      return art;
+    throw new ModelError( `Unknown artifact reference: ${ typeof ref !== 'string' ? JSON.stringify(ref.ref) : ref }` );
+  }
+
   function artifactPathRef( ref ) {
     const [ head, ...tail ] = ref.ref;
     let art = csn.definitions[pathId( head )];
     initDefinition( art );
     for (const elem of tail) {
-      const env = navigationEnv( art ); // TODO: second argument true, see Issue #8458
+      const env = navigationEnv( art, true );
       art = env.elements[pathId( elem )];
     }
     return art;
   }
 
-  function artifactFromRef( ref ) {
+  function artifactFromRef( ref, noLast ) {
     const [ head, ...tail ] = ref.ref;
     let art = csn.definitions[pathId( head )];
     initDefinition( art );
@@ -366,6 +377,8 @@ function csnRefs( csn, universalReady ) {
       const env = navigationEnv( art );
       art = env.elements[pathId( elem )];
     }
+    if (noLast)                 // TODO: delete that param
+      return art;
     return navigationEnv( art );
   }
 
@@ -626,9 +639,10 @@ function csnRefs( csn, universalReady ) {
       if (!qcache)
         throw new CompilerAssertion( `Query not in cache at: ${ locationString(query.$location) }` );
 
-      if (semantics.dynamic === 'query')
+      if (semantics.dynamic === 'query') {
         // TODO: for ON condition in expand, would need to use cached _element
         return resolvePath( path, qcache.elements[head], null, 'query' );
+      }
       for (const name in qcache.$aliases) {
         const alias = qcache.$aliases[name];
         const found = alias.elements[head];
@@ -667,6 +681,8 @@ function csnRefs( csn, universalReady ) {
       links[i - 1].env = parent;
       if (typeof path[i - 1] !== 'string')
         setCache( path[i - 1], '_env', parent );
+      if (!parent.elements)
+        throw new ModelError( `${ parent.from ? 'Query ' : '' }elements not available: ${ Object.keys( parent ).join('+') }`);
       art = parent.elements[pathId( path[i] )];
       if (!art) {
         const { env } = links[i - 1];
@@ -743,6 +759,8 @@ function csnRefs( csn, universalReady ) {
       const { columns } = qcache._select;
       if (elements && columns)
         columns.map( c => initColumnElement( c, qcache ) );
+      else if (columns && !elements)
+        throw new ModelError( `Query elements not available: ${ Object.keys( (index ? qcache._select : main) ).join('+') }`);
     } );
     return all;
   }
@@ -1037,6 +1055,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
       }
       isName = prop;
       // if we want to allow auto-redirect of user-provided target with renamed keys:
+      // (TODO: no, we do not allow that anymore)
       refCtx = (refCtx === '$origin' && prop === 'keys') ? 'keys_origin' : prop;
     }
     else if (prop === 'items' || prop === 'returns') {

package/lib/model/csnUtils.js

@@ -101,7 +101,7 @@ function getUtils( model, universalReady ) {
         return walkArgs(query.SELECT.from.args);
       }
       else if (query.SELECT.from.ref) {
-        let art = artifactRef(query.SELECT.from);
+        let art = artifactRef.from(query.SELECT.from);
 
         if (art.target)
           art = artifactRef(art.target);
@@ -131,7 +131,7 @@ function getUtils( model, universalReady ) {
         elements = mergeElementMaps(elements, walkArgs(arg.args));
       }
       else if (arg.ref) {
-        const art = artifactRef(arg);
+        const art = artifactRef.from(arg);
         elements = mergeElementsIntoMap(elements, art.elements, art.$location, arg.as || implicitAs(arg.ref), implicitAs(arg.ref) || arg.as);
       }
       else if (arg.SELECT || arg.SET) {
@@ -541,10 +541,10 @@ function forEachMember( construct, callback, path = [], ignoreIgnore = true, ite
         forEachMember(construct.returns, callback, [ ...path, 'returns' ], ignoreIgnore, iterateOptions, constructCallback);
     }
     else if (Array.isArray(callback)) {
-      callback.forEach(cb => cb(construct.returns, '', 'params', [ ...path, 'returns' ], construct));
+      callback.forEach(cb => cb(construct.returns, '', 'returns', [ ...path, 'returns' ], construct));
     }
     else {
-      callback(construct.returns, '', 'params', [ ...path, 'returns' ], construct);
+      callback(construct.returns, '', 'returns', [ ...path, 'returns' ], construct);
     }
   }
 }
@@ -906,7 +906,7 @@ function setDependencies( csn, refs = csnRefs(csn) ) {
             handleArgs(artifact, artifactName, query.SELECT.from.args);
 
           else if (typeof query.SELECT.from === 'string' || query.SELECT.from.ref)
-            handleDependency(artifactRef(query.SELECT.from), artifact, artifactName);
+            handleDependency(artifactRef.from(query.SELECT.from), artifact, artifactName);
         }
       }, [ 'definitions', artifactName, (artifact.projection ? 'projection' : 'query') ]);
     }
@@ -921,7 +921,7 @@ function setDependencies( csn, refs = csnRefs(csn) ) {
       if (arg.args)
         handleArgs(artifact, artifactName, arg.args);
       else if (arg.ref)
-        handleDependency(artifactRef(arg), artifact, artifactName);
+        handleDependency(artifactRef.from(arg), artifact, artifactName);
     }
   }
 
@@ -1080,8 +1080,9 @@ function getLastPartOfRef( ref ) {
  * @param {object} fromNode
  * @param {object} toNode
  * @param {boolean} [overwrite]
+ * @param {object} excludes
  */
-function copyAnnotations( fromNode, toNode, overwrite = false ) {
+function copyAnnotations( fromNode, toNode, overwrite = false, excludes = {} ) {
   // Ignore if no toNode (in case of errors)
   if (!toNode)
     return;
@@ -1089,7 +1090,7 @@ function copyAnnotations( fromNode, toNode, overwrite = false ) {
   const annotations = Object.keys(fromNode).filter(key => key.startsWith('@'));
 
   for (const anno of annotations) {
-    if (toNode[anno] === undefined || overwrite)
+    if ((toNode[anno] === undefined || overwrite) && !excludes[anno])
       toNode[anno] = fromNode[anno];
   }
 }

package/lib/model/revealInternalProperties.js

@@ -247,7 +247,7 @@ function revealInternalProperties( model, nameOrPath ) {
   }
 
   function origin( node, parent ) {
-    if (!node || node.$inferred === 'REDIRECTED')
+    if (!node)
       return reveal( node, parent );
     return artifactIdentifier( node, parent );
   }
@@ -311,18 +311,13 @@ function artifactIdentifier( node, parent ) {
     Object.defineProperty( node, '__unique_id__', { value: ++uniqueId } );
   let outer = uniqueId ? `##${ node.__unique_id__ }` : '';
   if (node._outer) {
-    if (node.$inferred === 'REDIRECTED') {
-      outer = `/redirected${ outer }`;
-    }
-    else {
+    // eslint-disable-next-line no-nested-ternary
+    outer = (node._outer.items === node) ? `/items${ outer }`
       // eslint-disable-next-line no-nested-ternary
-      outer = (node._outer.items === node) ? `/items${ outer }`
-        // eslint-disable-next-line no-nested-ternary
-        : (node._outer.returns === node) ? `/returns${ outer }`
-          // eslint-disable-next-line no-nested-ternary
-          : (node._outer.targetAspect === node) ? `/target${ outer }`
-            : `/returns/items${ outer }`;
-    }
+      : (node._outer.returns === node) ? `/returns${ outer }` // TODO returns now normal
+      // eslint-disable-next-line no-nested-ternary
+        : (node._outer.targetAspect === node) ? `/target${ outer }`
+          : `/returns/items${ outer }`;
     node = node._outer;
   }
   if (node === parent)

package/lib/model/sortViews.js

@@ -93,13 +93,12 @@ function _findWithXPointers( definitionsArray, x, _dependents, _dependencies ) {
 module.exports = function sortViews({ sql, csn }) {
   const { cleanup, _dependents, _dependencies } = setDependencies(csn);
   const { layers, leftover } = sortTopologically(csn, _dependents, _dependencies);
-  cleanup.forEach(fn => fn());
   if (leftover.length > 0)
     throw new ModelError('Unable to build a correct dependency graph! Are there cycles?');
 
   const result = [];
   // keep the "artifact name" - needed for to.hdi sorting
-  layers.forEach(layer => layer.forEach(objName => result.push({ name: objName, sql: sql[objName] })));
+  layers.forEach(layer => layer.forEach(objName => result.push({ name: objName, sql: sql[objName], dependents: csn.definitions[objName][_dependents] })));
   // attach sql artifacts which are not considered during the view sorting algorithm
   // --> this is the case for "ALTER TABLE ADD CONSTRAINT" statements,
   //     because their identifiers are not part of the csn.definitions
@@ -107,5 +106,8 @@ module.exports = function sortViews({ sql, csn }) {
     if (!result.some( o => o.name === name )) // not in result but in incoming sql
       result.push({ name, sql: sqlString });
   });
+
+  cleanup.forEach(fn => fn());
+
   return result;
 };

package/lib/modelCompare/compare.js

@@ -174,7 +174,7 @@ function getElementComparator(otherArtifact, addedElementsDict = null, changedEl
       if (relevantTypeChange(element.type, otherElement.type) || typeParametersChanged(element, otherElement)) {
         // Type or parameters, e.g. association target, changed.
         if(otherElement.notNull && element.notNull === undefined) {
-          element.$notNull = false; // Explictily set notNull to the implicit default so we render the correct ALTER
+          element.$notNull = false; // Explicitly set notNull to the implicit default so we render the correct ALTER
         }
         changedElementsDict[name] = changedElement(element, otherElement);
       }

package/lib/modelCompare/utils/filter.js

@@ -3,8 +3,8 @@
 // Each db has some changes that it can and cannot represent, or that cause problems only on that specific db
 // In this file, we define rules for each db-dialect to detect and act on these cases.
 
-const { forEach } = require('../../utils/objectUtils');
-const { isPersistedAsTable } = require('../../model/csnUtils');
+const { forEach, forEachValue, forEachKey } = require('../../utils/objectUtils');
+const { isPersistedAsTable, applyTransformations } = require('../../model/csnUtils');
 
 function isKey( element ) {
   return element.key;
@@ -32,6 +32,7 @@ module.exports = {
   postgres: getFilterObject('postgres'),
   h2: getFilterObject('h2'),
   hana: getFilterObject('hana'),
+  csn: filterCsn,
 };
 
 function getFilterObject( dialect, extensionCallback, migrationCallback ) {
@@ -98,3 +99,40 @@ function typeChangeIsNotCompatible( dialect, before, after ) {
   }
   return true;
 }
+
+/**
+ * Filter non-diff-relevant properties from a db-expanded CSN.
+ * Currently we filter:
+ * - annotations
+ *
+ * @param {CSN.Model} csn CSN to filter
+ * @returns {CSN.Model} Filtered input model
+ */
+function filterCsn( csn ) {
+  const annosToKeep = {
+    '@cds.persistence.skip': true,
+    '@cds.persistence.exists': true,
+    '@cds.persistence.table': true,
+    '@cds.persistence.name': true,
+    '@sql.append': true,
+    '@sql.prepend': true,
+  };
+
+  applyTransformations(csn, {
+    elements: (parent, prop, elements) => {
+      forEachValue(elements, (element) => {
+        forEachKey(element, (key) => {
+          if ((key.startsWith('@') && !annosToKeep[key]) || key === 'keys')
+            delete element[key];
+        });
+      });
+    },
+  }, [ (artifact) => {
+    forEachKey(artifact, (key) => {
+      if (key.startsWith('@') && !annosToKeep[key])
+        delete artifact[key];
+    });
+  } ]);
+
+  return csn;
+}

package/lib/optionProcessor.js

@@ -104,15 +104,12 @@ optionProcessor
                             Valid values are:
                               hanaAssocRealCardinality
                               mapAssocToJoinCardinality
-                              ignoreAssocPublishingInUnion
                               enableUniversalCsn
-                              postgres
                               aspectWithoutElements
                               odataTerms
                               optionalActionFunctionParameters
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
-                              autoCorrectOrderBySourceRefs
                               eagerPersistenceForGeneratedEntities
        --fallback-parser <type>  If the language cannot be deduced by the file's extensions, use this
                                  parser as a fallback. Valid values are: