@sap/cds-compiler 2.4.4 → 2.10.2

package/bin/cdsc.js

@@ -17,15 +17,16 @@
 
 const compiler = require('../lib/compiler');
 const main = require('../lib/main');
+const { for_sql, for_hdi, for_hdbcds } = require('../lib/api/main');
 const { compactModel } = require('../lib/json/to-csn');
-const { toOdataWithCsn, toHanaWithCsn, toSqlWithCsn, toCdlWithCsn, toRenameWithCsn, alterConstraintsWithCsn } = require('../lib/backends');
-var util = require('util');
-var fs = require('fs');
-var path = require('path');
-var { reveal } = require('../lib/model/revealInternalProperties');
+const { toRenameWithCsn, alterConstraintsWithCsn } = require('../lib/backends');
+const util = require('util');
+const fs = require('fs');
+const path = require('path');
+const { reveal } = require('../lib/model/revealInternalProperties');
 const enrichCsn = require('../lib/model/enrichCsn');
 const { optionProcessor } = require('../lib/optionProcessor');
-const { explainMessage, hasMessageExplanation, sortMessages } = require('../lib/base/messages')
+const { explainMessage, hasMessageExplanation, sortMessages } = require('../lib/base/messages');
 const term = require('../lib/utils/term');
 const { splitLines } = require('../lib/utils/file');
 const { addLocalizationViews } = require('../lib/transform/localized');
@@ -35,27 +36,59 @@ const { availableBetaFlags } = require('../lib/base/model');
 // but that might truncate the output of stdout and stderr, both of which are async (or rather,
 // may possibly be async, depending on OS and whether I/O goes to TTY, socket, file, ... sigh)
 class ProcessExitError extends Error {
-  constructor(exitCode,...args) {
+  constructor(exitCode, ...args) {
     super(...args);
     this.exitCode = exitCode;
   }
 }
 
+function remapCmdOptions(options, cmdOptions) {
+  if (!cmdOptions)
+    return options;
+
+  for (const [ key, value ] of Object.entries(cmdOptions)) {
+    switch (key) {
+      case 'names':
+        options.sqlMapping = value;
+        break;
+      case 'user':
+        if (!options.magicVars)
+          options.magicVars = {};
+        options.magicVars.user = value;
+        break;
+      case 'dialect':
+        options.sqlDialect = value;
+        break;
+      case 'version':
+        options.odataVersion = value;
+        break;
+      case 'locale':
+        if (!options.magicVars)
+          options.magicVars = {};
+        options.magicVars.locale = value;
+        break;
+      default:
+        options[key] = value;
+    }
+  }
+  return options;
+}
+
 // Parse the command line and translate it into options
 try {
-  let cmdLine = optionProcessor.processCmdLine(process.argv);
+  const cmdLine = optionProcessor.processCmdLine(process.argv);
   // Deal with '--version' explicitly
   if (cmdLine.options.version) {
-    process.stdout.write(main.version() + '\n');
+    process.stdout.write(`${main.version()}\n`);
     throw new ProcessExitError(0);
   }
   // Deal with '--help' explicitly
   if (cmdLine.command) {
     // Command specific help
-    if (cmdLine.options.help || cmdLine.options[cmdLine.command] && cmdLine.options[cmdLine.command].help) {
+    if (cmdLine.options.help || cmdLine.options[cmdLine.command] && cmdLine.options[cmdLine.command].help)
       displayUsage(null, optionProcessor.commands[cmdLine.command].helpText, 0);
-    }
-  } else if (cmdLine.options.help) {
+  }
+  else if (cmdLine.options.help) {
     // General help
     displayUsage(null, optionProcessor.helpText, 0);
   }
@@ -70,20 +103,21 @@ try {
   if (cmdLine.cmdErrors.length > 0) {
     // Command specific errors
     displayUsage(cmdLine.cmdErrors, optionProcessor.commands[cmdLine.command].helpText, 2);
-  } else if (cmdLine.errors.length > 0) {
+  }
+  else if (cmdLine.errors.length > 0) {
     // General errors
     displayUsage(cmdLine.errors, optionProcessor.helpText, 2);
   }
 
   // Default warning level is 2 (info)
   // FIXME: Is that not set anywhere in the API?
-  if (!cmdLine.options.warning) {
+  if (!cmdLine.options.warning)
     cmdLine.options.warning = 2;
-  }
+
   // Default output goes to stdout
-  if (!cmdLine.options.out) {
+  if (!cmdLine.options.out)
     cmdLine.options.out = '-';
-  }
+
   // --cds-home <dir>: modules starting with '@sap/cds/' are searched in <dir>
   if (cmdLine.options.cdsHome) {
     if (!global.cds)
@@ -105,39 +139,43 @@ try {
     cmdLine.options.parseCdl = true;
     if (cmdLine.args.files.length > 1) {
       const err = `'parseCdl' expects exactly one file! ${cmdLine.args.files.length} provided.`;
-      displayUsage(err, optionProcessor.commands['parseCdl'].helpText, 2);
+      displayUsage(err, optionProcessor.commands.parseCdl.helpText, 2);
     }
   }
 
-  if (cmdLine.options.directBackend) {
+  if (cmdLine.options.directBackend)
     validateDirectBackendOption(cmdLine.command, cmdLine.options, cmdLine.args);
-  }
+
 
   if (cmdLine.options.beta) {
     const features = cmdLine.options.beta.split(',');
     cmdLine.options.beta = {};
-    features.forEach((val) => cmdLine.options.beta[val] = true);
+    features.forEach((val) => {
+      cmdLine.options.beta[val] = true;
+    });
   }
 
   // Enable all beta-flags if betaMode is set to true
-  if(cmdLine.options.betaMode) {
+  if (cmdLine.options.betaMode)
     cmdLine.options.beta = availableBetaFlags;
-  }
+
   if (cmdLine.options.deprecated) {
     const features = cmdLine.options.deprecated.split(',');
     cmdLine.options.deprecated = {};
-    features.forEach((val) => cmdLine.options.deprecated[val] = true);
+    features.forEach((val) => {
+      cmdLine.options.deprecated[val] = true;
+    });
   }
   // Do the work for the selected command
   executeCommandLine(cmdLine.command, cmdLine.options, cmdLine.args);
-} catch (err) {
+}
+catch (err) {
   // This whole try/catch is only here because process.exit does not work in combination with
   // stdout/err - see comment at ProcessExitError
-  if (err instanceof ProcessExitError) {
+  if (err instanceof ProcessExitError)
     process.exitCode = err.exitCode;
-  } else {
+  else
     throw err;
-  }
 }
 
 /**
@@ -150,33 +188,32 @@ try {
  * @param {object} args
  */
 function validateDirectBackendOption(command, options, args) {
-  if (!['toCdl', 'toOdata', 'toHana', 'toCsn', 'toSql'].includes(command)) {
+  if (![ 'toCdl', 'toOdata', 'toHana', 'toCsn', 'toSql' ].includes(command)) {
     displayUsage(`Option '--direct-backend' can't be used with command '${command}'`,
-      optionProcessor.helpText, 2);
+                 optionProcessor.helpText, 2);
   }
   if (!args.files || args.files.length !== 1) {
     displayUsage(`Option '--direct-backend' expects exactly one JSON file, but ${args.files.length} given`,
-      optionProcessor.helpText, 2);
+                 optionProcessor.helpText, 2);
   }
   const filename = args.files[0];
   if (!filename.endsWith('.csn') && !filename.endsWith('.json')) {
-    displayUsage(`Option '--direct-backend' expects a filename with a *.csn or *.json suffix`,
-      optionProcessor.helpText, 2);
+    displayUsage('Option \'--direct-backend\' expects a filename with a *.csn or *.json suffix',
+                 optionProcessor.helpText, 2);
   }
 }
 
 // Display help text 'helpText' and 'error' (if any), then exit with exit code <code>
 function displayUsage(error, helpText, code) {
   // Display non-error output (like help) to stdout
-  let out = (code === 0 && !error) ? process.stdout : process.stderr;
+  const out = (code === 0 && !error) ? process.stdout : process.stderr;
   // Display help text first, error at the end (more readable, no scrolling)
   out.write(`${helpText}\n`);
   if (error) {
-    if (error instanceof Array) {
-      out.write(error.map(error => `cdsc: ERROR: ${error}`).join('\n') + '\n');
-    } else {
+    if (error instanceof Array)
+      out.write(`${error.map(error => `cdsc: ERROR: ${error}`).join('\n')}\n`);
+    else
       out.write(`cdsc: ERROR: ${error}\n`);
-    }
   }
   throw new ProcessExitError(code);
 }
@@ -184,14 +221,16 @@ function displayUsage(error, helpText, code) {
 // Executes a command line that has been translated to 'command' (what to do), 'options' (how) and 'args' (which files)
 function executeCommandLine(command, options, args) {
   const normalizeFilename = options.testMode && process.platform === 'win32';
-  const messageLevels = { Error: 0, Warning: 1, Info: 2, None: 3 };
+  const messageLevels = {
+    Error: 0, Warning: 1, Info: 2, None: 3,
+  };
   // All messages are put into the message array, even those which should not
   // been displayed (severity 'None')
 
   // Create output directory if necessary
-  if (options.out && options.out !== '-' && !fs.existsSync(options.out)) {
+  if (options.out && options.out !== '-' && !fs.existsSync(options.out))
     fs.mkdirSync(options.out);
-  }
+
 
   // Add implementation functions corresponding to commands here
   const commands = {
@@ -207,9 +246,9 @@ function executeCommandLine(command, options, args) {
     explain,
   };
 
-  if (!commands[command] && !commandsWithoutCompilation[command]) {
+  if (!commands[command] && !commandsWithoutCompilation[command])
     throw new Error(`Missing implementation for command ${command}`);
-  }
+
 
   if (commandsWithoutCompilation[command]) {
     commandsWithoutCompilation[command]();
@@ -218,14 +257,14 @@ function executeCommandLine(command, options, args) {
 
   options.messages = [];
 
-  const fileCache = Object.create(null)
-  const compiled = options.directBackend ?
-    util.promisify(fs.readFile)( args.files[0], 'utf-8' ).then((str) => JSON.parse( str )) :
-    compiler.compileX( args.files, undefined, options, fileCache );
+  const fileCache = Object.create(null);
+  const compiled = options.directBackend
+    ? util.promisify(fs.readFile)( args.files[0], 'utf-8' ).then(str => JSON.parse( str ))
+    : compiler.compileX( args.files, undefined, options, fileCache );
 
   compiled.then( commands[command] )
-          .then( displayMessages, displayErrors )
-          .catch( catchErrors );
+    .then( displayMessages, displayErrors )
+    .catch( catchErrors );
 
   return; // below are only command implementations.
 
@@ -233,10 +272,10 @@ function executeCommandLine(command, options, args) {
   // Return the original model (for chaining)
   function toCdl( model ) {
     const csn = options.directBackend ? model : compactModel(model, options);
-    const cdlResult = toCdlWithCsn(csn, options).result;
-    for (const name in cdlResult) {
-      writeToFileOrDisplay(options.out, name + '.cds', cdlResult[name]);
-    }
+    const cdlResult = main.to.cdl(csn, remapCmdOptions(options));
+    for (const name in cdlResult)
+      writeToFileOrDisplay(options.out, `${name}.cds`, cdlResult[name]);
+
     return model;
   }
 
@@ -245,7 +284,8 @@ function executeCommandLine(command, options, args) {
   function toCsn( model ) {
     if (options.directBackend) {
       displayNamedCsn(model, 'csn', options);
-    } else {
+    }
+    else {
       // Result already provided by caller
       displayNamedXsn(model, 'csn', options);
     }
@@ -256,99 +296,105 @@ function executeCommandLine(command, options, args) {
   // Return the original model (for chaining)
   function toHana( model ) {
     const csn = options.directBackend ? model : compactModel(model, options);
-    const hanaResult = toHanaWithCsn(csn, options);
-    for( const pluginName of ['hdbcds', 'hdbconstraint']){
-      for(const name in hanaResult[pluginName]){
-        writeToFileOrDisplay(options.out, `${name}.${pluginName}`, hanaResult[pluginName][name]);
-      }
+
+    if (options.toHana && options.toHana.csn) {
+      displayNamedCsn(for_hdbcds(csn, remapCmdOptions(options, options.toHana)), 'hana_csn', options);
     }
-    displayNamedCsn(hanaResult.csn, 'hana_csn', options);
+    else {
+      const hanaResult = main.to.hdbcds(csn, remapCmdOptions(options, options.toHana));
+      for (const name in hanaResult)
+        writeToFileOrDisplay(options.out, name, hanaResult[name]);
+    }
+
     return model;
   }
 
   // Execute the command line option '--to-odata' and display the results.
   // Return the original model (for chaining)
   function toOdata( model ) {
-    if(options.toOdata &&
+    if (options.toOdata &&
       options.toOdata.version === 'v4x') {
       options.toOdata.version = 'v4';
       options.toOdata.odataFormat = 'structured';
       options.toOdata.odataContainment = true;
     }
-    let csn = options.directBackend ? model : compactModel(model, options);
-    const odataResult = toOdataWithCsn(csn, options);
-    for (let serviceName in odataResult.services) {
-      // <service>_metadata.xml (metadata)
-      if (odataResult.services[serviceName].metadata) {
-        writeToFileOrDisplay(options.out, serviceName + '_metadata.xml', odataResult.services[serviceName].metadata);
-      }
-      // <service>_annotations.xml (annotations)
-      if (odataResult.services[serviceName].annotations) {
-        writeToFileOrDisplay(options.out, serviceName + '_annotations.xml', odataResult.services[serviceName].annotations);
-      }
-      // <service>.xml (combined)
-      if (odataResult.services[serviceName].combined) {
-        writeToFileOrDisplay(options.out, serviceName + '.xml', odataResult.services[serviceName].combined);
-      }
-      // <service>.json (metadata_json)
-      if (odataResult.services[serviceName].metadata_json) {
-        writeToFileOrDisplay(options.out, serviceName + '.json', odataResult.services[serviceName].metadata_json);
-      }
+    const csn = options.directBackend ? model : compactModel(model, options);
+    const odataCsn = main.for.odata(csn, remapCmdOptions(options, options.toOdata));
+    if (options.toOdata && options.toOdata.csn) {
+      displayNamedCsn(odataCsn, 'odata_csn', options);
+    }
+    else if (options.toOdata && options.toOdata.json) {
+      const result = main.to.edm.all(odataCsn, options);
+      for (const serviceName in result)
+        writeToFileOrDisplay(options.out, `${serviceName}.json`, result[serviceName]);
+    }
+    else {
+      const result = main.to.edmx.all(odataCsn, options);
+      for (const serviceName in result)
+        writeToFileOrDisplay(options.out, `${serviceName}.xml`, result[serviceName]);
     }
-    displayNamedCsn(odataResult.csn, 'odata_csn', options);
     return model;
   }
 
   // Execute the command line option '--to-rename' and display the results.
   // Return the original model (for chaining)
   //
-  /// THIS MUST SURVIVE IF WE REMOVE THE OLD API
-  /// DO NOT DELETE THIS TORENAME FUNCTIONALITY!!
+  // / THIS MUST SURVIVE IF WE REMOVE THE OLD API
+  // / DO NOT DELETE THIS TORENAME FUNCTIONALITY!!
   function toRename( model ) {
-    let csn = options.directBackend ? model : compactModel(model, options);
-    let renameResult = toRenameWithCsn(csn, options);
-    let storedProcedure = 'PROCEDURE RENAME_' + renameResult.options.toRename.names.toUpperCase() + '_TO_PLAIN LANGUAGE SQLSCRIPT AS BEGIN\n';
-    for (let name in renameResult.rename) {
-      storedProcedure += '  --\n  -- ' + name + '\n  --\n';
+    const csn = options.directBackend ? model : compactModel(model, options);
+    const renameResult = toRenameWithCsn(csn, options);
+    let storedProcedure = `PROCEDURE RENAME_${renameResult.options.toRename.names.toUpperCase()}_TO_PLAIN LANGUAGE SQLSCRIPT AS BEGIN\n`;
+    for (const name in renameResult.rename) {
+      storedProcedure += `  --\n  -- ${name}\n  --\n`;
       storedProcedure += renameResult.rename[name];
     }
-    storedProcedure += "END;\n";
-    writeToFileOrDisplay(options.out, 'storedProcedure_' + renameResult.options.toRename.names + '_to_plain.sql', storedProcedure, true);
+    storedProcedure += 'END;\n';
+    writeToFileOrDisplay(options.out, `storedProcedure_${renameResult.options.toRename.names}_to_plain.sql`, storedProcedure, true);
     return model;
   }
 
-   // Execute the command line option 'manageConstraints' and display the results.
+  // Execute the command line option 'manageConstraints' and display the results.
   function manageConstraints( model ) {
     const csn = options.directBackend ? model : compactModel(model, options);
     const alterConstraintsResult = alterConstraintsWithCsn(csn, options);
     const { src } = options.manageConstraints || {};
     Object.keys(alterConstraintsResult).forEach((id) => {
       const renderedConstraintStatement = alterConstraintsResult[id];
-      if(src === 'hdi')
+      if (src === 'hdi')
         writeToFileOrDisplay(options.out, `${id}.hdbconstraint`, renderedConstraintStatement);
       else
         writeToFileOrDisplay(options.out, `${id}.sql`, renderedConstraintStatement);
-    })
+    });
   }
 
   // Execute the command line option '--to-sql' and display the results.
   // Return the original model (for chaining)
   function toSql( model ) {
     const csn = options.directBackend ? model : compactModel(model, options);
-    const sqlResult = toSqlWithCsn(csn, options);
-
-    ['hdbtabletype', 'hdbtable', 'hdbindex', 'hdbfulltextindex', 'hdbview', 'hdbconstraint', 'sql'].forEach(pluginName => {
-      for(let name in sqlResult[pluginName]) {
-        writeToFileOrDisplay(options.out, name + '.' + pluginName, sqlResult[pluginName][name] + '\n', true);
+    if (options.toSql && options.toSql.src === 'hdi') {
+      if (options.toSql.csn) {
+        displayNamedCsn(for_hdi(csn, remapCmdOptions(options, options.toSql)), 'hdi_csn', options);
       }
-    });
-    displayNamedCsn(sqlResult.csn, 'sql_csn', options);
+      else {
+        const hdiResult = main.to.hdi(csn, remapCmdOptions(options, options.toSql));
+        for (const name in hdiResult)
+          writeToFileOrDisplay(options.out, name, hdiResult[name]);
+      }
+    }
+    else if (options.toSql && options.toSql.csn) {
+      displayNamedCsn(for_sql(csn, remapCmdOptions(options, options.toSql)), 'sql_csn', options);
+    }
+    else {
+      const sqlResult = main.to.sql(csn, remapCmdOptions(options, options.toSql));
+      writeToFileOrDisplay(options.out, 'model.sql', sqlResult.join('\n'), true);
+    }
     return model;
   }
 
   function explain() {
     if (args.length !== 1)
-      displayUsage(`Command 'explain' expects exactly one message-id.`, optionProcessor.commands['explain'].helpText, 2);
+      displayUsage('Command \'explain\' expects exactly one message-id.', optionProcessor.commands.explain.helpText, 2);
 
     const id = args.files[0];
     if (!hasMessageExplanation(id))
@@ -360,23 +406,24 @@ function executeCommandLine(command, options, args) {
   // Display error messages in `err` resulting from a compilation.  Also set
   // process.exitCode - process.exit() will force the process to exit as quickly
   // as possible = is problematic, since console.error() might be asynchronous
-  function displayErrors (err) {
+  function displayErrors(err) {
     if (err instanceof main.CompilationError) {
       if (options.rawOutput)
         console.error( util.inspect( reveal( err.model, options.rawOutput ), false, null ));
       else
-        displayMessages( err.model, err.errors );
+        displayMessages( err.model, err.messages );
       process.exitCode = 1;
     }
     else if (err instanceof compiler.InvocationError) {
       console.error( '' );
-      for (let sub of err.errors)
+      for (const sub of err.errors)
         console.error( sub.message );
       console.error( '' );
       process.exitCode = 2;
     }
-    else
+    else {
       throw err;
+    }
 
     err.hasBeenReported = true;
     throw err;
@@ -397,11 +444,11 @@ function executeCommandLine(command, options, args) {
     sortMessages(messages);
 
     if (options.internalMsg) {
-      messages.map(msg => util.inspect( msg, { depth: null, maxArrayLength: null} ) )
+      messages.map(msg => util.inspect( msg, { depth: null, maxArrayLength: null } ) )
         .forEach(msg => log(msg));
     }
     else if (options.noMessageContext) {
-      messages.filter(msg => (messageLevels[ msg.severity ] <= options.warning))
+      messages.filter(msg => (messageLevels[msg.severity] <= options.warning))
         .forEach(msg => log(main.messageString(msg, normalizeFilename, !options.showMessageId)));
     }
     else {
@@ -413,19 +460,20 @@ function executeCommandLine(command, options, args) {
         return splitCache[name];
       };
       let hasAtLeastOneExplanation = false;
-      messages.filter(msg => messageLevels[ msg.severity ] <= options.warning).forEach(msg => {
-        hasAtLeastOneExplanation = hasAtLeastOneExplanation || main.hasMessageExplanation(msg.messageId)
+      messages.filter(msg => messageLevels[msg.severity] <= options.warning).forEach((msg) => {
+        hasAtLeastOneExplanation = hasAtLeastOneExplanation || main.hasMessageExplanation(msg.messageId);
         const name = msg.location && msg.location.file;
         const fullFilePath = name ? path.resolve('', name) : undefined;
         const context = fullFilePath && sourceLines(fullFilePath);
-        log(main.messageStringMultiline(msg, { normalizeFilename, noMessageId: !options.showMessageId, withLineSpacer: true, hintExplanation: true }));
+        log(main.messageStringMultiline(msg, {
+          normalizeFilename, noMessageId: !options.showMessageId, withLineSpacer: true, hintExplanation: true,
+        }));
         if (context)
           log(main.messageContext(context, msg));
-        log() // newline
+        log(); // newline
       });
-      if (options.showMessageId && hasAtLeastOneExplanation) {
-        log(`${term.help('help')}: Messages marked with '…' have an explanation text. Use \`cdsc explain <message-id>\` for a more detailed error description.`)
-      }
+      if (options.showMessageId && hasAtLeastOneExplanation)
+        log(`${term.help('help')}: Messages marked with '…' have an explanation text. Use \`cdsc explain <message-id>\` for a more detailed error description.`);
     }
     return model;
   }
@@ -436,18 +484,18 @@ function executeCommandLine(command, options, args) {
   // written in raw form to '<name>_raw.txt'.
   function displayNamedXsn(xsn, name, options) {
     if (options.rawOutput) {
-      writeToFileOrDisplay(options.out, name + '_raw.txt', util.inspect(reveal(xsn, options.rawOutput), false, null), true);
+      writeToFileOrDisplay(options.out, `${name}_raw.txt`, util.inspect(reveal(xsn, options.rawOutput), false, null), true);
     }
     else if (options.internalMsg) {
-      writeToFileOrDisplay(options.out, name + '_raw.txt', util.inspect(reveal(xsn).messages, { depth: null, maxArrayLength: null}), true);
+      writeToFileOrDisplay(options.out, `${name}_raw.txt`, util.inspect(reveal(xsn).messages, { depth: null, maxArrayLength: null }), true);
     }
     else if (!options.lintMode) {
-      let csn = compactModel(xsn, options);
+      const csn = compactModel(xsn, options);
       if (command === 'toCsn' && options.toCsn && options.toCsn.withLocalized)
         addLocalizationViews(csn, options);
       if (options.enrichCsn)
         enrichCsn( csn, options );
-      writeToFileOrDisplay(options.out, name + '.json', csn, true);
+      writeToFileOrDisplay(options.out, `${name}.json`, csn, true);
     }
   }
 
@@ -460,12 +508,12 @@ function executeCommandLine(command, options, args) {
     if (!csn) // only print CSN if it is set.
       return;
     if (options.internalMsg) {
-      writeToFileOrDisplay(options.out, name + '_raw.txt', options.messages, true);
+      writeToFileOrDisplay(options.out, `${name}_raw.txt`, options.messages, true);
     }
     else if (!options.lintMode && !options.internalMsg) {
       if (command === 'toCsn' && options.toCsn && options.toCsn.withLocalized)
         addLocalizationViews(csn, options);
-      writeToFileOrDisplay(options.out, name + '.json', csn, true);
+      writeToFileOrDisplay(options.out, `${name}.json`, csn, true);
     }
   }
 
@@ -480,28 +528,28 @@ function executeCommandLine(command, options, args) {
     fileName = fileName.replace(/[:/\\]/g, '_');
 
     // replace all dots with underscore to get deployable .hdbcds sources (except the one before the file extension)
-    if(options.toHana)
-      fileName = fileName.replace(/\.(?=.*?\.)/g, '_')
+    if (options.transformation === 'hdbcds')
+      fileName = fileName.replace(/\.(?=.*?\.)/g, '_');
 
-    if (!(content instanceof String || typeof content === 'string')) {
+    if (!(content instanceof String || typeof content === 'string'))
       content = JSON.stringify(content, null, 2);
-    }
+
     if (dir === '-') {
-      if (!omitHeadline) {
+      if (!omitHeadline)
         process.stdout.write(`// ------------------- ${fileName} -------------------\n`);
-      }
+
       process.stdout.write(`${content}\n`);
-      if (!omitHeadline) {
-        process.stdout.write(`\n`);
-      }
-    } else {
+      if (!omitHeadline)
+        process.stdout.write('\n');
+    }
+    else {
       // TODO: We might consider using async file-system API ...
       fs.writeFileSync(path.join(dir, fileName), content);
     }
   }
 
-  function catchErrors (err) {
-    if (err instanceof Error && err['hasBeenReported'])
+  function catchErrors(err) {
+    if (err instanceof Error && err.hasBeenReported)
       return;
     console.error( '' );
     console.error( 'INTERNAL ERROR: %s', err );

package/bin/cdshi.js

@@ -16,28 +16,35 @@ const fs = require('fs');
 fs.readFile( '/dev/stdin', 'utf8', highlight );
 
 const categoryChars = {
-  artref: 'm', paramname: 'b',
-  Entity: 'D', Enum: 'H', Index: 'J', AnnoDef: 'V', Extend: 'Z', Annotate: 'Z', Event: 'Y'
-}
+  artref: 'm',
+  paramname: 'b',
+  Entity: 'D',
+  Enum: 'H',
+  Index: 'J',
+  AnnoDef: 'V',
+  Extend: 'Z',
+  Annotate: 'Z',
+  Event: 'Y',
+};
 
 function highlight( err, buf ) {
   if (err) {
     console.error( 'ERROR:', err.toString() );
     return;
   }
-  let ts = compiler.parseX( buf, 'hi.cds', { attachTokens: true, messages: [] } ).tokenStream;
+  const ts = compiler.parseX( buf, 'hi.cds', { attachTokens: true, messages: [] } ).tokenStream;
   if (!buf.length || !ts.tokens || !ts.tokens.length)
     return;
-  let chars = [...buf];
-  for (let tok of ts.tokens) {
-    let cat = tok.isIdentifier;
+  const chars = [ ...buf ];
+  for (const tok of ts.tokens) {
+    const cat = tok.isIdentifier;
     if (cat && tok.start >= 0) {
-      if (cat !== 'ref' || chars[ tok.start ] !== '$')
-        chars[ tok.start ] = categoryChars[ cat ] || cat.charAt(0);
+      if (cat !== 'ref' || chars[tok.start] !== '$')
+        chars[tok.start] = categoryChars[cat] || cat.charAt(0);
       if (tok.stop > tok.start) // stop in ANTLR at last char, not behind
-        chars[ tok.start+1 ] = '_';
+        chars[tok.start + 1] = '_';
     }
   }
-  for (let c of chars)
+  for (const c of chars)
     process.stdout.write( c );
 }