@sap/cds-compiler 5.8.2 → 5.9.2

package/lib/json/from-csn.js

@@ -1925,7 +1925,7 @@ function onlyWith( spec, need, csn, prop, xor, expected ) {
 
 /**
  * @param {string[]} groups
- * @param {string} exception
+ * @param {string|Function} exception
  * @param {string} prop
  * @param {object} xor
  * @return {boolean}

package/lib/json/to-csn.js

@@ -780,6 +780,8 @@ function addOrigin( csn, xsn, node ) {
   }
   else if (xsn.includes) {
     csn.$origin = includesOrigin( xsn.includes, xsn );
+    if (xsn.$inferred === 'composition-entity' || xsn.$inferred === 'localized-entity')
+      inferredPropertiesForOrigin( csn, node );
     return;
   }
   let origin = getOrigin( node );
@@ -1170,7 +1172,13 @@ function enumValueOrCalc( v, csn, node ) {
   if (node.kind === 'enum') {
     Object.assign( csn, expression( v ) );
   }
-  else if (node.$syntax === 'calc' || node._parent?.kind === 'extend') {
+  // In XSN, there are combined elem/column objects: do not represent column
+  // expression when presented as element in CSN
+
+  // node.$syntax set in define.el(!), but not inside an `extend`, a _parent might
+  // not be set always for parse-only, especially with CSN input
+  else if (node.$syntax === 'calc' ||
+           !node._parent || node._parent.kind === 'extend') {
     const stored = v.stored ? { stored: value(v.stored) } : {};
     return Object.assign( stored, expression( v ) );
   }
@@ -1275,12 +1283,31 @@ function exprInternal( node, xprParens ) {
   return rargs.length === 1 ? rargs[0] : flattenInternalXpr( rargs, val );
 }
 
-function flattenInternalXpr( array, op ) {
+
+const naryOperators = {
+  __proto__: null,
+  // not '.'
+  '*': true,
+  '/': true,
+  '+': true,
+  '-': true,
+  '||': true,
+  and: true,
+  or: true,
+};
+
+function flattenInternalXpr( array, xprOp ) {
   if (!structXpr)
     return array.flat( Infinity );
   // TODO: do not rely on 'nary' - this dosn't work with CSN input have an
   // `xpr: [{val:1},'+',{val:2},'+',{val:3}]`.
-  if (array.length < 5 || op !== 'nary')
+  const { length } = array;
+  if (length < 5 || length % 2 === 0)
+    return array;
+  const op = array[1];
+  if (typeof op !== 'string' || !naryOperators[op] ||
+      xprOp !== 'nary' &&       // for old CDL parser
+      array.some( ( item, idx ) => item !== op && idx % 2 === 1 ))
     return array;
   // nary: [ ‹a›, '+', ‹b›, '+', ‹c› ] → [ [ ‹a›, '+', ‹b› ], '+', ‹c› ]
   let left = array.slice( 0, 3 );

package/lib/language/genericAntlrParser.js

@@ -102,6 +102,7 @@ Object.assign(GenericAntlrParser.prototype, {
   fragileAlias,
   identAst,
   reportPathNamedManyOrOne,
+  reportVirtualAsRef,
   reportMissingSemicolon,
   pushXprToken,
   pushOpToken,
@@ -812,6 +813,21 @@ function reportPathNamedManyOrOne( { path } ) {
   }
 }
 
+function reportVirtualAsRef() {
+  const { type, text } = this._input.LT(2);
+  if (this.constructor.Number < type && type <= this.constructor.Identifier ||
+      [ '+', '-', '(' ].includes( text )) {
+    // remark: we do not need to include 'not', as condition operators are only
+    // allowed inside parentheses in the old parser
+    const token = this._input.LT(1);
+    this.message( 'syntax-deprecated-ref-virtual', token, {
+      '#': (text === '(' ? 'func' : 'ref'),
+      name: token.text,
+      delimited: token.text,
+    } );
+  }
+}
+
 function reportMissingSemicolon() {
   const next = this._input.LT(1);
   if (next.text !== ';' && next.text !== '' && // ';' by insertSemicolon()

package/lib/main.d.ts

@@ -135,6 +135,15 @@ declare namespace compiler {
      * @since v2.8.0
      */
     addTextsLanguageAssoc?: boolean
+    /**
+     * If set to `true`, add named aspects to the list of 'includes' of the generated entity.
+     * This will cause propagation of actions from aspect to generated entity.
+     *
+     * Will become default in v6.
+     *
+     * @since v5.9.0
+     */
+    compositionIncludes?: boolean
     /**
      * An array of directory names that are used for CDS module lookups.
      * Lookup directory `node_modules/` is appended if not set explicitly.
@@ -435,6 +444,22 @@ declare namespace compiler {
      * @beta
      */
     betterSqliteSessionVariables?: boolean
+    /**
+     * If set, operator `!=` will be treated as a boolean-logic operator,
+     * instead of a three-valued operator, by rendering it as `IS DISTINCT FROM`
+     * on databases that support it, or an equivalent expression.
+     *
+     * Note, that if disabled:
+     * - `!=`, is not translated and is hence treated as `<>`, meaning it uses
+     *   three-valued logic, on databases that support it.
+     * - `==` is still treated as two-valued logic operator.
+     *
+     * This option will become the default in cds-compiler v6.
+     *
+     * @since 5.9.0
+     * @default false
+     */
+    booleanEquality?: boolean
   }
 
   /**
@@ -519,7 +544,52 @@ declare namespace compiler {
    * @note `to.cdl()` currently has no specific options.
    * @see to.cdl()
    */
-  export interface CdlOptions extends Options {}
+  export interface CdlOptions extends Options {
+    /**
+     * If `true`, to.cdl() nests rendered definitions, e.g. all service/context entities
+     * are nested inside a service/context definition.
+     * This shortens definition names, as instead of `entity a.b.c.d.E {…}`,
+     * a `service a.b.c.d {…}` with inner `entity E {…}` is rendered.
+     * May introduce additional USING statements for paths that can't be reached
+     * without one inside the current scope, e.g. when paths are shadowed in inner scopes.
+     *
+     * __Example__ (also using `renderCdlCommonNamespace: true`):
+     *
+     *   ```cds
+     *   namespace S;
+     *   using { S as S_ };
+     *   entity Base {
+     *     key id : String;
+     *   };
+     *   service S {
+     *     entity Base as projection on S_.Base as Base;
+     *   };
+     *   ```
+     *
+     * If `false`, there is no nesting of definitions inside services or contexts.
+     * All definitions are defined using their fully qualified path.
+     *
+     * __Example__:
+     *
+     *   ```cds
+     *   entity S.Base {
+     *     key id : String;
+     *   };
+     *   service S.S {};
+     *   entity S.S.Base as projection on S.Base as Base;
+     *   ```
+     *
+     * @default false
+     */
+    renderCdlDefinitionNesting?: boolean
+    /**
+     * If `true`, `to.cdl()` tries to extract a common namespace that is then rendered
+     * as a `namespace` statement.
+     *
+     * Only usable in combination with `renderCdlDefinitionNesting: true`.
+     */
+    renderCdlCommonNamespace?: boolean
+  }
 
   /**
    * The compiler's package version.
@@ -925,6 +995,14 @@ declare namespace compiler {
      * @internal
      */
     function seal(csn: CSN, options?: EffectiveCsnOptions): CSN;
+    /**
+     * Transform the given (inferred/client) CSN into one that is used by the
+     * CAP Java runtime.  The CSN is structured.
+     * Changes include draft handling and the tenant discriminator if requested.
+     *
+     * @internal
+     */
+    function java(csn: CSN, options?: ODataOptions): CSN;
   }
 
   export { _for as for };

package/lib/model/csnRefs.js

@@ -269,6 +269,7 @@ function csnRefs( csn, universalReady ) {
     effectiveType,
     artifactRef,
     getOrigin,
+    queryForElements,
     inspectRef,
     queryOrMain,
     getColumn: elem => getCache( elem, '_column' ),
@@ -484,6 +485,10 @@ function csnRefs( csn, universalReady ) {
     return art;
   }
 
+  function queryForElements( query ) {
+    return query && cache.get( query.projection || query );
+  }
+
   function initDefinition( main ) {
     const name = typeof main === 'string' && main;
     if (name) {
@@ -753,6 +758,7 @@ function csnRefs( csn, universalReady ) {
   function msgLocations( csnPath ) {
     let location = csn?.$location;
     const artifact = new SemanticLocation();
+    /** @type object */
     let obj = csn;
     let index = 0;
     let inlinePathIndex = null;
@@ -1076,7 +1082,7 @@ function traverseFrom( from, fromSelect, parentQuery, callback ) {
   else if (from.args) {         // join
     from.args.forEach( arg => traverseFrom( arg, fromSelect, parentQuery, callback ) );
     if (from.on)                // join-on, potentially having a sub query (in xpr)
-      from.on.forEach(arg => traverseExpr(arg, fromSelect, callback));
+      from.on.forEach(arg => traverseExpr( arg, fromSelect, callback ));
   }
   else {                        // sub query in FROM
     traverseQuery( from, fromSelect, parentQuery, callback );
@@ -1148,8 +1154,9 @@ function pathId( item ) {
 }
 
 function implicitAs( ref ) {
-  const item = ref[ref.length - 1];
-  const id = (typeof item === 'string') ? item : item.id; // inlined `pathId`
+  if (typeof ref !== 'string')
+    ref = ref[ref.length - 1];
+  const id = (typeof ref === 'string') ? ref : ref.id; // inlined `pathId`
   return id.substring( id.lastIndexOf('.') + 1 );
 }
 
@@ -1282,7 +1289,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     else if (prop === 'orderBy') {
       refCtx = 'orderBy';
     }
-    else if (prop.charAt(0) === '@') {
+    else if (prop[0] === '@') {
       refCtx = 'annotation';
     }
     else if (prop !== 'xpr' && prop !== 'list') {
@@ -1314,7 +1321,7 @@ function isSelectQuery( query ) {
  * If the column is an expression without explicit alias, `false` is returned.
  * Use csnRefs.getColumnName() instead.
  *
- * @returns {string|false}
+ * @returns {string}
  */
 function columnAlias( col ) {
   return col.as || (!col.args && col.func) || (col.ref && implicitAs( col.ref ));

package/lib/model/xprAsTree.js

@@ -0,0 +1,71 @@
+// Create a hierarchical expression tree from an `xpr` array
+//
+// Replace `xpr` arrays and conditions by precedence-aware tree representations.
+// The transformation is deep and destructive.
+//
+// Queries in expressions are _not_ traversed.
+//
+// Function/assoc arguments and filter conditions are
+//  - traversed with expressionAsTree() and conditionAsTree(),
+//  - not traversed with exprAsTree() and condAsTree()
+
+'use strict';
+
+const xprParser = require( '../parsers/XprTree' );
+
+function conditionAsTree( args ) {
+  args.forEach( expressionAsTree );
+  return xprParser.xprAsTree( args, args, true );
+}
+function condAsTree( args ) {
+  args.forEach( exprAsTree );
+  return xprParser.xprAsTree( args, args, true );
+}
+
+function expressionAsTree( expr ) {
+  if (!expr || typeof expr !== 'object')
+    return expr;
+  if (Array.isArray( expr )) {  // hierarchical input
+    // expr.forEach( expressionAsTree );  // do it again?
+    return expr;
+  }
+  if (expr.list)                // expression, ref
+    expr.list.forEach( expressionAsTree );
+  if (expr.args) {               // expression, ref
+    if (Array.isArray( expr.args ) )
+      expr.args.forEach(expressionAsTree);
+    else
+      Object.values(expr.args).forEach(expressionAsTree);
+  }
+  if (expr.ref)                 // expression
+    expr.ref.forEach( expressionAsTree );
+
+  // conditions: change properties
+  if (expr.xpr)                 // expression
+    expr.xpr = conditionAsTree( expr.xpr );
+  if (expr.where)               // ref or query
+    expr.where = conditionAsTree( expr.where );
+
+  return expr;
+}
+function exprAsTree( expr ) {
+  if (!expr || typeof expr !== 'object')
+    return expr;
+  if (Array.isArray( expr )) {  // hierarchical input
+    // expr.forEach( exprAsTree );  // do it again?
+    return expr;
+  }
+  if (expr.list)                // expression, ref
+    expr.list.forEach( exprAsTree );
+  // conditions: change properties
+  if (expr.xpr)                 // expression
+    expr.xpr = condAsTree( expr.xpr );
+  return expr;
+}
+
+module.exports = {
+  conditionAsTree,
+  condAsTree,
+  expressionAsTree,
+  exprAsTree,
+};

package/lib/modelCompare/utils/filter.js

@@ -223,7 +223,7 @@ const details = {
 
 function getDetails(id, name) {
   if (details[id])
-    return `${details[id] } "${ name }" - check warnings for details`;
+    return `${ details[id] } "${ name }" - check warnings for details`;
 
   return null;
 }

package/lib/optionProcessor.js

@@ -1,5 +1,7 @@
 // Compiler options
 
+/* eslint @stylistic/js/max-len: 0 */
+
 // Remarks:
 // - The specification is client-tool centric (bin/cdsc.js):
 //   an option named `fooBar` is “produced” by `.option('  --foo-bar')`.
@@ -21,13 +23,13 @@ optionProcessor
   .option('-h, --help')
   .option('-v, --version')
   .option('    --options <file>')
-  .option('-w, --warning <level>', { valid: ['0', '1', '2', '3'] })
+  .option('-w, --warning <level>', { valid: [ '0', '1', '2', '3' ] })
   .option('    --quiet')
   .option('-i, --stdin')
   .option('    --show-message-id')
   .option('    --no-message-id')
   .option('    --no-message-context')
-  .option('    --color <mode>', { valid: ['auto', 'always', 'never'] })
+  .option('    --color <mode>', { valid: [ 'auto', 'always', 'never' ] })
   .option('-o, --out <dir>')
   .option('    --cds-home <dir>')
   .option('    --module-lookup-directories <list>')
@@ -52,8 +54,10 @@ optionProcessor
   .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
   .option('    --tenant-discriminator')
+  .option('    --no-composition-includes')
   .option('    --default-binary-length <length>')
   .option('    --default-string-length <length>')
+  .option('    --struct-xpr')
   .option('    --no-recompile')
   .option('    --skip-name-check', { optionName: '$skipNameCheck' })
   .positionalArgument('<files...>')
@@ -120,11 +124,11 @@ optionProcessor
        --beta <list>        Comma separated list of unsupported, incomplete (beta) features to use.
                             Valid values are:
                               ${
-  Object.keys(availableBetaFlags)
-    .filter(flag => availableBetaFlags[flag])
-    .sort()
-    .join('\n' + ' '.repeat(30))
-}
+                                Object.keys(availableBetaFlags)
+                                  .filter(flag => availableBetaFlags[flag])
+                                  .sort()
+                                  .join(`\n${ ' '.repeat(30) }`)
+                              }
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
                               eagerPersistenceForGeneratedEntities
@@ -152,7 +156,10 @@ optionProcessor
        --add-texts-language-assoc   In generated texts entities, add association "language"
                                     to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views
+       --no-composition-includes  Do NOT add named aspects to 'includes' property of generated composition entity.
        --no-recompile       Don't recompile in case of internal errors
+       --struct-xpr         Write structured expressions to the compiler CSN output (possibly then
+                            used as input for backends)
        --skip-name-check    Skip certain name checks, e.g. that there must be no '.' in element names.
 
   Commands
@@ -185,7 +192,7 @@ optionProcessor
 // ----------- toHana -----------
 optionProcessor.command('H, toHana')
   .option('-h, --help')
-  .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: ['--names'] })
+  .option('-n, --sql-mapping <style>', { valid: [ 'plain', 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
   .option('    --render-virtual')
   .option('    --joinfk')
   .option('-u, --user <user>')
@@ -193,8 +200,8 @@ optionProcessor.command('H, toHana')
   .option('-c, --csn')
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
-  .option('    --assert-integrity <mode>', { valid: ['true', 'false', 'individual'] })
-  .option('    --assert-integrity-type <type>', { valid: ['RT', 'DB'], ignoreCase: true })
+  .option('    --assert-integrity <mode>', { valid: [ 'true', 'false', 'individual' ] })
+  .option('    --assert-integrity-type <type>', { valid: [ 'RT', 'DB' ], ignoreCase: true })
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
   .option('    --standard-database-functions')
@@ -239,7 +246,7 @@ optionProcessor.command('H, toHana')
 
 optionProcessor.command('O, toOdata')
   .option('-h, --help')
-  .option('-v, --odata-version <version>', { valid: ['v2', 'v4', 'v4x'], aliases: ['--version'] })
+  .option('-v, --odata-version <version>', { valid: [ 'v2', 'v4', 'v4x' ], aliases: [ '--version' ] })
   .option('-x, --xml')
   .option('-j, --json')
   .option('    --odata-containment')
@@ -253,8 +260,8 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-vocabularies <list>')
   .option('    --odata-no-creator')
   .option('-c, --csn')
-  .option('-f, --odata-format <format>', { valid: ['flat', 'structured'] })
-  .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: [ '--names' ] })
+  .option('-f, --odata-format <format>', { valid: [ 'flat', 'structured' ] })
+  .option('-n, --sql-mapping <style>', { valid: [ 'plain', 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
   .option('-s, --service-names <list>')
   .option('    --transitive-localized-views')
   .help(`
@@ -312,6 +319,8 @@ optionProcessor.command('J, forJava')
 
 optionProcessor.command('C, toCdl')
   .option('-h, --help')
+  .option('    --render-cdl-definition-nesting')
+  .option('    --render-cdl-common-namespace')
   .help(`
   Usage: cdsc toCdl [options] <files...>
 
@@ -319,28 +328,34 @@ optionProcessor.command('C, toCdl')
 
   Options
    -h, --help      Show this help text
+       --render-cdl-definition-nesting   If set, definitions will be nested
+                   inside services/contexts instead of having only top-level
+                   definitions.
+       --render-cdl-common-namespace  If true and render-cdl-definition-nesting
+                   is set, a common namespace will be extracted and rendered.
 `);
 
 optionProcessor.command('Q, toSql')
   .option('-h, --help')
-  .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: [ '--names' ] })
-  .option('-d, --sql-dialect <dialect>', { valid: ['hana', 'sqlite', 'plain', 'postgres', 'h2'], aliases: [ '--dialect' ] })
+  .option('-n, --sql-mapping <style>', { valid: [ 'plain', 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
+  .option('-d, --sql-dialect <dialect>', { valid: [ 'hana', 'sqlite', 'plain', 'postgres', 'h2' ], aliases: [ '--dialect' ] })
   .option('    --render-virtual')
   .option('    --joinfk')
   .option('-u, --user <user>')
   .option('-l, --locale <locale>')
-  .option('-s, --src <style>', { valid: ['sql', 'hdi'] })
+  .option('-s, --src <style>', { valid: [ 'sql', 'hdi' ] })
   .option('-c, --csn')
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
-  .option('    --assert-integrity <mode>', { valid: ['true', 'false', 'individual'] })
-  .option('    --assert-integrity-type <type>', { valid: ['RT', 'DB'], ignoreCase: true })
+  .option('    --assert-integrity <mode>', { valid: [ 'true', 'false', 'individual' ] })
+  .option('    --assert-integrity-type <type>', { valid: [ 'RT', 'DB' ], ignoreCase: true })
   .option('    --constraints-in-create-table')
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
   .option('    --generated-by-comment')
   .option('    --better-sqlite-session-variables <bool>')
   .option('    --transitive-localized-views')
+  .option('    --boolean-equality')
   .option('    --with-hana-associations <bool>', { valid: [ 'true', 'false' ] })
   .option('    --standard-database-functions')
   .help(`
@@ -406,11 +421,12 @@ optionProcessor.command('Q, toSql')
                                 true  : (default) Render "WITH ASSOCIATIONS"
                                 false : Do not render "WITH ASSOCIATIONS"
    --standard-database-functions Enable rendering of standard database function mappings.
+   --boolean-equality            Enable support for boolean logic '!=' operator.
 `);
 
 optionProcessor.command('toRename')
   .option('-h, --help')
-  .option('-n, --sql-mapping <style>', { valid: ['quoted', 'hdbcds'], aliases: ['--names'] })
+  .option('-n, --sql-mapping <style>', { valid: [ 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
   .help(`
   Usage: cdsc toRename [options] <files...>
 
@@ -432,14 +448,14 @@ optionProcessor.command('toRename')
 
 optionProcessor.command('manageConstraints')
   .option('-h, --help')
-  .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: ['--names'] })
-  .option('-s, --src <style>', { valid: ['sql', 'hdi'] })
+  .option('-n, --sql-mapping <style>', { valid: [ 'plain', 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
+  .option('-s, --src <style>', { valid: [ 'sql', 'hdi' ] })
   .option('    --drop')
   .option('    --alter')
   .option('    --violations')
   .option('    --integrity-not-validated')
   .option('    --integrity-not-enforced')
-  .option('-d, --sql-dialect <dialect>', { valid: ['hana', 'sqlite', 'plain', 'postgres', 'h2'], aliases: [ '--dialect' ] })
+  .option('-d, --sql-dialect <dialect>', { valid: [ 'hana', 'sqlite', 'plain', 'postgres', 'h2' ], aliases: [ '--dialect' ] })
   .help(`
   Usage: cdsc manageConstraints [options] <files...>
 
@@ -478,10 +494,9 @@ optionProcessor.command('manageConstraints')
 
 optionProcessor.command('toCsn')
   .option('-h, --help')
-  .option('-f, --csn-flavor <flavor>', { valid: ['client', 'gensrc', 'universal'], aliases: ['--flavor'] })
+  .option('-f, --csn-flavor <flavor>', { valid: [ 'client', 'gensrc', 'universal' ], aliases: [ '--flavor' ] })
   .option('    --with-localized')
   .option('    --with-locations')
-  .option('    --struct-xpr')
   .option('    --transitive-localized-views')
   .help(`
   Usage: cdsc toCsn [options] <files...>
@@ -505,7 +520,6 @@ optionProcessor.command('toCsn')
 
   Internal options (for testing only, may be changed/removed at any time)
        --with-localized   Add localized convenience views to the CSN output.
-       --struct-xpr       Write structured expressions to the CSN output.
 `);
 
 optionProcessor.command('parseCdl')
@@ -576,10 +590,10 @@ optionProcessor.command('inspect')
 
 optionProcessor.command('forEffective')
   .option('-h, --help')
-  .option('--resolve-simple-types <val>', { valid: ['true', 'false'] } )
-  .option('--resolve-projections <val>', { valid: ['true', 'false'] } )
-  .option('--remap-odata-annotations <val>', { valid: ['true', 'false'] } )
-  .option('--keep-localized <val>', { valid: ['true', 'false'] } )
+  .option('--resolve-simple-types <val>', { valid: [ 'true', 'false' ] } )
+  .option('--resolve-projections <val>', { valid: [ 'true', 'false' ] } )
+  .option('--remap-odata-annotations <val>', { valid: [ 'true', 'false' ] } )
+  .option('--keep-localized <val>', { valid: [ 'true', 'false' ] } )
   .option('--effective-service-name <name>')
   .positionalArgument('<files...>')
   .help(`
@@ -608,8 +622,8 @@ optionProcessor.command('forEffective')
 
 optionProcessor.command('forSeal')
   .option('-h, --help')
-  .option('--remap-odata-annotations <val>', { valid: ['true', 'false'] } )
-  .option('--derive-analytical-annotations <val>', { valid: ['true', 'false'] })
+  .option('--remap-odata-annotations <val>', { valid: [ 'true', 'false' ] } )
+  .option('--derive-analytical-annotations <val>', { valid: [ 'true', 'false' ] })
   .positionalArgument('<files...>')
   .help(`
   Usage: cdsc forSeal [options] <files...>
@@ -627,5 +641,5 @@ optionProcessor.command('forSeal')
 `);
 
 module.exports = {
-  optionProcessor
+  optionProcessor,
 };