@sap/cds-compiler 2.4.4 → 2.10.2

package/bin/cdsse.js

@@ -15,8 +15,8 @@
 'use strict';
 
 const commands = {
-  complete, find, lint
-}
+  complete, find, lint,
+};
 
 const fs = require('fs');
 const path = require('path');
@@ -25,12 +25,12 @@ const main = require('../lib/main');
 const { locationString } = require('../lib/base/messages');
 const { availableBetaFlags: beta } = require('../lib/base/model');
 
-let argv = process.argv;
-let cmd = commands[ argv[2] ];
-var line = Number.parseInt( argv[3] );
-let column = Number.parseInt( argv[4] );
-let file = argv[5];
-let frel = path.relative( '', file||'' );
+const { argv } = process;
+const cmd = commands[argv[2]];
+const line = Number.parseInt( argv[3] );
+const column = Number.parseInt( argv[4] );
+const file = argv[5];
+const frel = path.relative( '', file || '' );
 // TODO: proper realname
 
 if (argv.length > 5 && cmd && line > 0 && column > 0)
@@ -62,17 +62,19 @@ function complete( err, buf ) {
     hasId = tokensAt( buf, off.prefix, off.col, false );
   }
   else {
-    let charBefore = buf[ off.prefix-1 ];
-    if ([':', '<', '.', '>', '!', '|', '='].includes( charBefore ))
+    const charBefore = buf[off.prefix - 1];
+    if ([ ':', '<', '.', '>', '!', '|', '=' ].includes( charBefore ))
       // If first of multi-char symbols from 'literalNames' in
       // gen/languageParser, calculate "symbol continuation"
-      tokensAt( buf, off.prefix-1, off.col-1, charBefore );
+      tokensAt( buf, off.prefix - 1, off.col - 1, charBefore );
     hasId = tokensAt( buf, off.prefix, off.col, true );
   }
   if (hasId) {
-    let src = buf.substring( 0, off.prefix ) + '__NO_SUCH_ID__' + buf.substring( off.cursor );
-    let fname = path.resolve( '', file );
-    compiler.compileX( [file], '', { attachValidNames: true, lintMode: true, beta, messages: [] } , { [fname]: src } )
+    const src = `${buf.substring( 0, off.prefix )}__NO_SUCH_ID__${buf.substring( off.cursor )}`;
+    const fname = path.resolve( '', file );
+    compiler.compileX( [ file ], '', {
+      attachValidNames: true, lintMode: true, beta, messages: [],
+    }, { [fname]: src } )
       .then( ident, ident );
   }
   return true;
@@ -80,11 +82,11 @@ function complete( err, buf ) {
   function ident( xsnOrErr ) {
     if (!(xsnOrErr.messages || xsnOrErr.options && xsnOrErr.options.messages))
       return usage( xsnOrErr );
-    let vn = messageAt( xsnOrErr, 'validNames', off.col ) || Object.create(null);
+    const vn = messageAt( xsnOrErr, 'validNames', off.col ) || Object.create(null);
     // TODO: if there is no such message, use console.log( 'arbitrary identifier' )
     // if we want to avoid that the editor switches to fuzzy completion match
     // against the prefix (not yet done anyway)
-    for (let n in vn)
+    for (const n in vn)
       console.log( n, vn[n].kind );
     if (!Object.keys( vn ).length)
       console.log( 'unknown_identifier', 'identifier' );
@@ -104,19 +106,21 @@ function find( err, buf ) {
     return usage();
   if (off.prefix === off.cursor) // not at name
     return true;
-  const src = buf.substring( 0, off.prefix ) + '__NO_SUCH_ID__' + buf.substring( off.cursor );
+  const src = `${buf.substring( 0, off.prefix )}__NO_SUCH_ID__${buf.substring( off.cursor )}`;
   const fname = path.resolve( '', file );
-  compiler.compileX( [file], '', { attachValidNames: true, lintMode: true, beta, messages: [] } , { [fname]: src } )
+  compiler.compileX( [ file ], '', {
+    attachValidNames: true, lintMode: true, beta, messages: [],
+  }, { [fname]: src } )
     .then( show, show );
   return true;
 
-  function show(  xsnOrErr ) {
+  function show( xsnOrErr ) {
     if (!(xsnOrErr.messages || xsnOrErr.options && xsnOrErr.options.messages))
       return usage( xsnOrErr );
-    let vn = messageAt( xsnOrErr, 'validNames', off.col ) || Object.create(null);
+    const vn = messageAt( xsnOrErr, 'validNames', off.col ) || Object.create(null);
     const art = vn[buf.substring( off.prefix, off.cursor )];
     if (art)
-      console.log( locationString( art.name.location || art.location ) + ': Definition' );
+      console.log( `${locationString( art.name.location || art.location )}: Definition` );
     return true;
   }
 }
@@ -124,25 +128,25 @@ function find( err, buf ) {
 function lint( err, buf ) {
   if (err)
     return usage( err );
-  let fname = path.resolve( '', file );
-  compiler.compileX( [file], '', { lintMode: true, beta, messages: [] }, { [fname]: buf } )
+  const fname = path.resolve( '', file );
+  compiler.compileX( [ file ], '', { lintMode: true, beta, messages: [] }, { [fname]: buf } )
     .then( display, display );
   return true;
 
   function display( xsnOrErr ) {
-    let messages = xsnOrErr.messages || xsnOrErr.options && xsnOrErr.options.messages;
+    const messages = xsnOrErr.messages || xsnOrErr.options && xsnOrErr.options.messages;
     if (!messages)
       return usage( xsnOrErr );
-    for (let msg of messages)
+    for (const msg of messages)
       console.log( main.messageString( msg ) );
     return true;
   }
 }
 
 function tokensAt( buf, offset, col, symbol ) {
-  let src = buf.substring( 0, offset ) + '≠' + buf.substring( offset );
-  let et = messageAt( compiler.parseX( src, frel, { messages: [] } ), 'expectedTokens', col ) || [];
-  for (let n of et) {
+  const src = `${buf.substring( 0, offset )}≠${buf.substring( offset )}`;
+  const et = messageAt( compiler.parseX( src, frel, { messages: [] } ), 'expectedTokens', col ) || [];
+  for (const n of et) {
     if (typeof symbol === 'string') {
       if (n.length > 3 && n.charAt(0) === "'" && n.charAt(1) === symbol)
         console.log( n.slice( 2, -1 ), 'symbolCont' );
@@ -154,15 +158,17 @@ function tokensAt( buf, offset, col, symbol ) {
     else if (/^[A-Z_]+$/.test( n )) {
       console.log( n.toLowerCase(), 'keyword' );
     }
-    else if (n !== 'Identifier')
+    else if (n !== 'Identifier') {
       console.log( n, 'unknown' );
+    }
   }
   return et.includes( 'Identifier' );
 }
 
 function messageAt( model, prop, col ) {
-  let msg = (model.messages || model.options && model.options.messages).find(
-    m => m[prop] && m.location.line === line && m.location.col === col && m.location.file === frel );
+  const msg = (model.messages || model.options && model.options.messages).find(
+    m => m[prop] && m.location.line === line && m.location.col === col && m.location.file === frel
+  );
   return msg && msg[prop];
 }
 
@@ -173,7 +179,7 @@ function messageAt( model, prop, col ) {
  */
 function offset( buf, alsoSuffix ) { // for line and column
   let pos = 0;
-  for (let l = line-1; l; --l) {
+  for (let l = line - 1; l; --l) {
     pos = buf.indexOf( '\n', pos ) + 1;
     if (!pos)
       return false;

package/bin/cdsv2m.js

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 
+'use strict';
+
 // Very simple command-line interface to support model migration from compiler
 // v1 to v2.  (If our client command processor would have been not as difficult
 // as after #2629, we could have a cdsc commend "migrate...)
 
-
 const commands = {
-  ria
-}
+  ria,
+};
 const compiler = require('../lib/compiler');
 
-const argv = process.argv;
-const cmd = commands[ argv[2] ];
+const { argv } = process;
+const cmd = commands[argv[2]];
 const files = argv.slice(3);
 const options = { messages: [] };
 
@@ -36,8 +37,8 @@ function ria() {
   // regex match on message text not for productive code!
   for (const msgObj of msgs) {
     const matches = msgObj.message.match( /["“][^"”]+["”]/g );
-    matches.slice(2).forEach( name => {
-      annotates[ name.slice( 1, -1 ) ] = true;
+    matches.slice(2).forEach( (name) => {
+      annotates[name.slice( 1, -1 )] = true;
     } );
   }
   for (const name in annotates)

package/doc/CHANGELOG_BETA.md

@@ -1,12 +1,48 @@
 # ChangeLog of Beta Features for cdx compiler and backends
 
 <!-- markdownlint-disable MD024 -->
+<!-- markdownlint-disable MD004 -->
 <!-- (no-duplicate-heading)-->
 
 Note: `beta` fixes, changes and features are listed in this ChangeLog just for information.
 The compiler behavior concerning `beta` features can change at any time without notice.
 **Don't use `beta` fixes, changes and features in productive mode.**
 
+## Version 2.6.0
+
+### Removed `pretransformedCSN`
+
+### Removed `renderSql`
+
+### Removed `keylessManagedAssoc`
+
+This is now the default - see CHANGELOG entry for 2.6.0
+
+### Fixed `nestedProjections`
+
+- to.sql/hdi/hdbcds: now work correctly when nested projections are used
+
+### Fixed `foreignKeyConstraints`
+
+- Always use the name of the association / backlink compared to
+  `$self` as name suffix for a constraint
+- Composition of one always result in:
+  + ON DELETE RESTRICT
+  + ON UPDATE RESTRICT
+- Composition of one w/o backlink will result in a constraint in
+  the entity where the composition is defined
+
+## Version 2.4.4
+
+### Added `nestedProjections`
+
+- Support `expand`: columns can look like `assoc_or_struct_or_tabalias { col_expression1, … }`,
+  `longer.ref as name { *, … } excluding { … }`, `{ col_expression1 as sub1, … } as name`, etc.
+- Support `inline`: columns can look like `assoc_or_struct_or_tabalias.{ col_expression1, … }`,
+  `longer.ref[filter = condition].{ *, … } excluding { … }`, `assoc_or_struct_or_tabalias.*`, etc.
+- _Some checks are missing and will be added! Minor changes might occur._
+- **The SQL backends might not work properly yet if nested projections are used!**
+
 ## Version 2.4.2
 
 ### Added `keylessManagedAssoc`
@@ -19,7 +55,6 @@ The compiler behavior concerning `beta` features can change at any time without
   Consequently, these associations are not added to the `WITH ASSOCIATIONS` clause or forwarded to HANA CDS.
   Managed Associations without foreign keys must be enabled with `--beta: keylessManagedAssoc`
 
-
 ## Version 2.4.0
 
 ### Changed `foreignKeyConstraints`

package/lib/api/main.js

@@ -4,15 +4,18 @@
 
 const prepareOptions = require('./options');
 const backends = require('../backends');
-const { setProp, isBetaEnabled } = require('../base/model');
+const { setProp } = require('../base/model');
 const { emptyLocation } = require('../base/location');
-const { CompilationError, makeMessageFunction, deduplicateMessages } = require('../base/messages');
-const { compactModel } = require('../json/to-csn');
+const { CompilationError, makeMessageFunction } = require('../base/messages');
+const { recompileX } = require('../compiler/index');
+const { compactModel, sortCsn } = require('../json/to-csn');
 const { transform4odataWithCsn } = require('../transform/forOdataNew.js');
 const { toSqlDdl } = require('../render/toSql');
 const { compareModels } = require('../modelCompare/compare');
 const sortViews = require('../model/sortViews');
 const { getResultingName } = require('../model/csnUtils');
+const timetrace = require('../utils/timetrace');
+const { transformForHanaWithCsn } = require('../transform/forHanaNew');
 
 /**
  * Return the artifact name for use for the hdbresult object
@@ -31,10 +34,10 @@ const propertyToCheck = {
 };
 
 const { cloneCsn } = require('../model/csnUtils');
+const { toHdbcdsSource } = require('../render/toHdbcds');
 
 const relevantGeneralOptions = [ /* for future generic options */ ];
 const relevantOdataOptions = [ 'sqlMapping', 'odataFormat' ];
-const relevantSqlOptions = [ 'sqlMapping', 'sqlDialect' ];
 const warnAboutMismatchOdata = [ 'odataVersion' ];
 
 /**
@@ -152,6 +155,49 @@ function cdl(csn, externalOptions = {}) {
   const { result } = backends.toCdlWithCsn(cloneCsn(csn, internalOptions), internalOptions);
   return result;
 }
+/**
+ * Transform a CSN like to.sql
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {sqlOptions} [options={}] Options
+ * @returns {CSN.Model} CSN transformed like to.sql
+ * @private
+ */
+function forSql(csn, options = {}) {
+  const internalOptions = prepareOptions.to.sql(options);
+  internalOptions.toSql.csn = true;
+  return backends.toSqlWithCsn(csn, internalOptions).csn;
+}
+/**
+ * Transform a CSN like to.hdi
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {hdiOptions} [options={}] Options
+ * @returns {CSN.Model} CSN transformed like to.hdi
+ * @private
+ */
+function forHdi(csn, options = {}) {
+  const internalOptions = prepareOptions.to.hdi(options);
+  internalOptions.toSql.csn = true;
+  return backends.toSqlWithCsn(csn, internalOptions).csn;
+}
+/**
+ * Transform a CSN like to.hdbcds
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {hdbcdsOptions} [options={}] Options
+ * @returns {CSN.Model} CSN transformed like to.hdbcds
+ * @private
+ */
+function forHdbcds(csn, options = {}) {
+  const internalOptions = prepareOptions.to.hdbcds(options);
+  internalOptions.transformation = 'hdbcds';
+
+  const hanaCsn = transformForHanaWithCsn(csn, internalOptions, 'to.hdbcds');
+
+  return internalOptions.testMode ? sortCsn(hanaCsn, internalOptions) : hanaCsn;
+}
+
 /**
  * Process the given CSN into SQL.
  *
@@ -165,18 +211,7 @@ function sql(csn, options = {}) {
   // we need the CSN for view sorting
   internalOptions.toSql.csn = true;
 
-  let intermediateResult;
-  if (isBetaEnabled(internalOptions, 'pretransformedCSN') && isPreTransformed(csn, 'sql')) {
-    internalOptions.noRecompile = true; // pre-transformed cannot be recompiled!
-    checkPreTransformedCsn(csn, internalOptions, relevantSqlOptions, warnAboutMismatchOdata, 'to.sql');
-
-    intermediateResult = backends.renderSqlWithCsn(csn, internalOptions);
-    // attach CSN for view sorting
-    intermediateResult.csn = cloneCsn(csn, internalOptions);
-  }
-  else {
-    intermediateResult = backends.toSqlWithCsn(csn, internalOptions);
-  }
+  const intermediateResult = backends.toSqlWithCsn(csn, internalOptions);
 
   const result = sortViews(intermediateResult);
 
@@ -338,7 +373,7 @@ function hdiMigration(csn, options, beforeImage) {
   const afterImage = backends.toSqlWithCsn(csn, internalOptions).csn;
 
   // Compare both images.
-  const diff = compareModels(beforeImage || afterImage, afterImage);
+  const diff = compareModels(beforeImage || afterImage, afterImage, internalOptions);
 
   // Convert the diff to SQL.
   internalOptions.forHana = true; // Make it pass the SQL rendering
@@ -405,10 +440,15 @@ hdi.migration = hdiMigration;
  * @returns {HDBCDS} { <filename>:<content>, ...}
  */
 function hdbcds(csn, options = {}) {
+  timetrace.start('to.hdbcds');
   const internalOptions = prepareOptions.to.hdbcds(options);
-  const intermediateResult = backends.toHanaWithCsn(csn, internalOptions);
+  internalOptions.transformation = 'hdbcds';
 
-  return flattenResultStructure(intermediateResult);
+  const hanaCsn = forHdbcds(csn, internalOptions);
+
+  const result = flattenResultStructure(toHdbcdsSource(hanaCsn, internalOptions));
+  timetrace.stop();
+  return result;
 }
 /**
  * Generate a edm document for the given service
@@ -454,19 +494,17 @@ function edmall(csn, options = {}) {
   if (internalOptions.version === 'v2')
     error(null, null, 'OData JSON output is not available for OData V2');
 
-  let servicesAll;
-
   const result = {};
+  let oDataCsn = csn;
 
-  if (isPreTransformed(csn, 'odata')) {
+  if (isPreTransformed(csn, 'odata'))
     checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions, warnAboutMismatchOdata, 'for.odata');
-    servicesAll = backends.preparedCsnToEdmAll(csn, internalOptions);
-  }
-  else {
-    const oDataCsn = odataInternal(csn, internalOptions);
-    servicesAll = backends.preparedCsnToEdmAll(oDataCsn, internalOptions);
-  }
-  const services = servicesAll.edmj;
+
+  else
+    oDataCsn = odataInternal(csn, internalOptions);
+
+  const servicesJson = backends.preparedCsnToEdmAll(oDataCsn, internalOptions);
+  const services = servicesJson.edmj;
   for (const serviceName in services) {
     const lEdm = services[serviceName];
     // FIXME: Why only metadata_json - isn't this rather a 'combined_json' ? If so, rename it!
@@ -555,41 +593,6 @@ function flattenResultStructure(toProcess) {
   return result;
 }
 
-/**
- * Compute the .hdbcds files that would have been generated by the csn for an undeploy.json.
- * This is needed for the handover between hdbcds and hdbtable - the existing hdbcds artifacts need to be undeployed.
- *
- * @param {any} csn A clean input CSN
- * @param {hdbcdsOptions} [options={}] Options
- * @returns {string[]} Array of .hdbcds filenames
- */
-function undeploy(csn, options) {
-  const hdbcdsResult = hdbcds(csn, options);
-
-  return Object.keys(hdbcdsResult);
-}
-
-/**
- * This function simply renders the given CSN to SQL - no integrity checks, no transformations, no guarantees for correctness.
- * Strictly for internal evaluation!
- *
- * @param {CSN.Model} csn A CSN - for things to work correctly, this is expected to be a DB transformed CSN. Plain CSN might work - or might not.
- * @param {sqlOptions} [options={}] Options
- * @returns {SQL[]} Array of SQL statements, tables first, views second - the resulting statements might not be a consistent, deployable state!
- */
-function renderSQL(csn, options) {
-  const internalOptions = prepareOptions.to.sql(options);
-  if (!isBetaEnabled(internalOptions, 'renderSQL'))
-    throw new Error('renderSQL is only available with beta-flag "renderSQL".');
-
-
-  // Add flag so it thinks we ran through forHanaNew
-  internalOptions.forHana = true;
-
-  const sqlResult = toSqlDdl(csn, internalOptions);
-  return Object.values(flattenResultStructure(sqlResult));
-}
-
 module.exports = {
   odata: publishCsnProcessor(odata, 'for.odata'),
   cdl: publishCsnProcessor(cdl, 'to.cdl'),
@@ -598,44 +601,14 @@ module.exports = {
   hdbcds: publishCsnProcessor(hdbcds, 'to.hdbcds'),
   edm: publishCsnProcessor(edm, 'to.edm'),
   edmx: publishCsnProcessor(edmx, 'to.edmx'),
-  renderSQL,
-  undeploy,
+  /** Internal only */
+  for_sql: publishCsnProcessor(forSql, 'for.sql'),
+  for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
+  for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
+  /** */
 };
 
 
-/**
- * Recompile the given CSN
- *
- * @param {object} csn Input CSN to recompile to XSN
- * @param {object} options Options
- * @returns {object} XSN
- *
- * TODO: move to lib/compiler/, consider new $recompile option, probaby issue
- * message api-recompiled-csn there.
- */
-function recompile(csn, options) {
-  // TODO: is it really a good idea to set options in the input parameter?
-  // (as long as we have the messages meddling of the option processor...)
-  // OK, I try a copy
-  options = { ...options };
-  // Explicitly set parseCdl to false because backends cannot handle
-  // the option and is only intended for CDL sources.
-  options.parseCdl = false;     // TODO: delete this option
-  // Explicitly delete all toCsn options
-  delete options.toCsn;
-  /* eslint-disable global-require */
-  const { augment } = require('../json/from-csn');
-  const { compileSourcesX } = require('../compiler');
-  /* eslint-enable global-require */
-  const file = csn.$location && csn.$location.file &&
-    csn.$location.file.replace(/[.]cds$/, '.cds.csn') || '<recompile>.csn';
-  const xsn = augment(csn, file, options); // in-place
-  const compiled = compileSourcesX( { [file]: xsn }, { ...options, $recompile: true } );
-  if (options.messages)
-    deduplicateMessages(options.messages);
-  return compiled;
-}
-
 /**
  * @param {any} processor CSN processor
  * @param {string} _name Name of the processor
@@ -675,7 +648,7 @@ function publishCsnProcessor( processor, _name ) {
       const { info } = makeMessageFunction( csn, options, 'compile' );
       info( 'api-recompiled-csn', emptyLocation('csn.json'), {}, 'CSN input had to be recompiled' );
       // next line to be replaced by CSN parser call which reads the CSN object
-      const xsn = recompile(csn, options);
+      const xsn = recompileX(csn, options);
       const recompiledCsn = compactModel(xsn);
       return processor( recompiledCsn, options, ...args );
     }
@@ -707,6 +680,12 @@ function publishCsnProcessor( processor, _name ) {
  * @typedef {'plain' | 'quoted' | 'hdbcds' } NamingMode
  */
 
+/**
+ * Available SQL change modes
+ *
+ * @typedef {'alter' | 'drop' } SqlChangeMode
+ */
+
 /**
  * Available oData versions
  *
@@ -749,6 +728,8 @@ function publishCsnProcessor( processor, _name ) {
  *
  * @typedef {object} hdiOptions
  * @property {NamingMode} [sqlMapping='plain'] Naming mode to use
+ * @property {SqlChangeMode} [sqlChangeMode='alter'] SQL change mode to use (for changed columns)
+ * @property {boolean} [allowCsnDowngrade=false] Allow downgrades of CSN major version (for modelCompare)
  * @property {object} [beta] Enable experimental features - not for productive use!
  * @property {boolean} [longAutoexposed=false] Deprecated: Produce long names (with underscores) for autoexposed entities
  * @property {Map<string, number>} [severities={}] Map of message-id and severity that allows setting the severity for the given message

package/lib/api/options.js

@@ -10,15 +10,18 @@ const publicOptionsNewAPI = [
   // GENERAL
   'beta',
   'deprecated',
+  'addTextsLanguageAssoc',
   'localizedLanguageFallback',  // why can't I define the option type here?
   'severities',
   'messages',
   'withLocations',
   'defaultStringLength',
+  'csnFlavor',
   // DB
   'sqlDialect',
   'sqlMapping',
   'sqlChangeMode',
+  'allowCsnDowngrade',
   'joinfk',
   'magicVars',
   // ODATA
@@ -49,6 +52,7 @@ const privateOptions = [
   'skipDbConstraints',
   'noRecompile',
   'internalMsg',
+  'disableHanaComments',      // in case of issues with hana comment rendering
   'dependentAutoexposed',     // deprecated, no effect - TODO: safe to remove?
   'longAutoexposed',          // deprecated, no effect - TODO: safe to remove?
   'localizedWithoutCoalesce', // deprecated version of 'localizedLanguageFallback',
@@ -66,10 +70,11 @@ const overallOptions = publicOptionsNewAPI.concat(privateOptions);
  * @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
  * @returns {TranslatedOptions} General cds options
  */
 function translateOptions(input = {}, defaults = {}, hardRequire = {},
-                          customValidators = {}, combinationValidators = []) {
+                          customValidators = {}, combinationValidators = [], moduleName = '') {
   const options = Object.assign({}, defaults);
   const inputOptionNames = Object.keys(input);
   for (const name of overallOptions) {
@@ -88,6 +93,7 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
   // Validate the filtered input options
   // only "new-style" options are here
   validate(options,
+           moduleName,
            // TODO: is there a better place to specify the type of option values?
            Object.assign( {
              localizedLanguageFallback: generateStringValidator([ 'none', 'coalesce' ]),
@@ -139,11 +145,11 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
 
 module.exports = {
   to: {
-    cdl: options => translateOptions(options),
+    cdl: options => translateOptions(options, undefined, undefined, undefined, undefined, 'to.cdl'),
     sql: (options) => {
       const hardOptions = { src: 'sql' };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'plain' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ]);
+      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ], 'to.sql');
 
       const result = Object.assign({}, processed);
       result.toSql = Object.assign({}, processed);
@@ -153,7 +159,7 @@ module.exports = {
     hdi: (options) => {
       const hardOptions = { src: 'hdi' };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) });
+      const processed = translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdi');
 
       const result = Object.assign({}, processed);
       result.toSql = Object.assign({}, processed);
@@ -162,17 +168,17 @@ module.exports = {
     },
     hdbcds: (options) => {
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions, {}, { sqlDialect: generateStringValidator([ 'hana' ]) });
+      const processed = translateOptions(options, defaultOptions, {}, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdbcds');
 
       const result = Object.assign({}, processed);
-      result.toHana = Object.assign({}, processed);
+      result.forHana = Object.assign({}, processed);
 
       return result;
     },
     edm: (options) => {
       const hardOptions = { json: true, combined: true };
       const defaultOptions = { odataVersion: 'v4', odataFormat: 'flat' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, { odataVersion: generateStringValidator([ 'v4' ]) }, [ 'valid-structured' ]);
+      const processed = translateOptions(options, defaultOptions, hardOptions, { odataVersion: generateStringValidator([ 'v4' ]) }, [ 'valid-structured' ], 'to.edm');
 
       const result = Object.assign({}, processed);
       result.toOdata = Object.assign({}, processed);
@@ -184,7 +190,7 @@ module.exports = {
       const defaultOptions = {
         odataVersion: 'v4', odataFormat: 'flat',
       };
-      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ]);
+      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.edmx');
 
       const result = Object.assign({}, processed);
       result.toOdata = Object.assign({}, processed);
@@ -196,7 +202,7 @@ module.exports = {
 
     odata: (options) => {
       const defaultOptions = { odataVersion: 'v4', odataFormat: 'flat' };
-      const processed = translateOptions(options, defaultOptions, undefined, undefined, [ 'valid-structured' ]);
+      const processed = translateOptions(options, defaultOptions, undefined, undefined, [ 'valid-structured' ], 'for.odata');
 
       const result = Object.assign({}, processed);
       result.toOdata = Object.assign({}, processed);
@@ -206,10 +212,10 @@ module.exports = {
     },
     hana: (options) => {
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions);
+      const processed = translateOptions(options, defaultOptions, undefined, undefined, undefined, 'for.hana');
 
       const result = Object.assign({}, processed);
-      result.toHana = Object.assign({}, processed);
+      result.forHana = Object.assign({}, processed);
 
 
       return result;