@sap/cds-compiler 2.5.2 → 2.11.0

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' ];
 
 /**
@@ -132,7 +135,7 @@ function odataInternal(csn, internalOptions) {
  * Return a odata-transformed CSN
  *
  * @param {CSN.Model} csn Clean input CSN
- * @param {oDataOptions} [options={}] Options
+ * @param {ODataOptions} [options={}] Options
  * @returns {oDataCSN} Return an oData-pre-processed CSN
  */
 function odata(csn, options = {}) {
@@ -188,8 +191,11 @@ function forHdi(csn, options = {}) {
  */
 function forHdbcds(csn, options = {}) {
   const internalOptions = prepareOptions.to.hdbcds(options);
-  internalOptions.toHana.csn = true;
-  return backends.toHanaWithCsn(csn, internalOptions).csn;
+  internalOptions.transformation = 'hdbcds';
+
+  const hanaCsn = transformForHanaWithCsn(csn, internalOptions, 'to.hdbcds');
+
+  return internalOptions.testMode ? sortCsn(hanaCsn, internalOptions) : hanaCsn;
 }
 
 /**
@@ -205,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);
 
@@ -445,16 +440,21 @@ 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
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {oDataOptions} [options={}] Options
+ * @param {ODataOptions} [options={}] Options
  * @returns {edm} The JSON representation of the service
  */
 function edm(csn, options = {}) {
@@ -484,7 +484,7 @@ edm.all = edmall;
  * Generate edm documents for all services
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {oDataOptions} [options={}] Options
+ * @param {ODataOptions} [options={}] Options
  * @returns {edms} { <service>:<JSON representation>, ...}
  */
 function edmall(csn, options = {}) {
@@ -494,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!
@@ -518,7 +516,7 @@ function edmall(csn, options = {}) {
  * Generate a edmx document for the given service
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {oDataOptions} [options={}] Options
+ * @param {ODataOptions} [options={}] Options
  * @returns {edmx} The XML representation of the service
  */
 function edmx(csn, options = {}) {
@@ -549,7 +547,7 @@ edmx.all = edmxall;
  * Generate edmx documents for all services
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {oDataOptions} [options={}] Options
+ * @param {ODataOptions} [options={}] Options
  * @returns {edmxs} { <service>:<XML representation>, ...}
  */
 function edmxall(csn, options = {}) {
@@ -595,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'),
@@ -642,45 +605,10 @@ module.exports = {
   for_sql: publishCsnProcessor(forSql, 'for.sql'),
   for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
   for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
-  renderSQL,
-  undeploy,
   /** */
 };
 
 
-/**
- * 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
@@ -720,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 );
     }
@@ -781,20 +709,6 @@ function publishCsnProcessor( processor, _name ) {
  * @property {Array} [messages] Allows collecting all messages in the options instead of printing them to stderr.
  */
 
-/**
- * Options available for all oData-based functions
- *
- * @typedef {object} oDataOptions
- * @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
- * @property {Array} [messages] Allows collecting all messages in the options instead of printing them to stderr.
- * @property {oDataVersion} [odataVersion='v4'] Odata version to use
- * @property {oDataFormat} [odataFormat='flat'] Wether to generate oData as flat or as structured. Structured only with v4.
- * @property {NamingMode} [sqlMapping='plain'] Naming mode to use
- * @property {string} [service] If a single service is to be rendered
- */
-
 /**
  * Options available for to.hdi
  *
@@ -825,9 +739,9 @@ function publishCsnProcessor( processor, _name ) {
  * @typedef {object} sqlOptions
  * @property {NamingMode} [sqlMapping='plain'] Naming mode to use
  * @property {SQLDialect} [sqlDialect='sqlite'] SQL dialect to use
- * @property {object} [magicVars] Object containing values for magic variables like "$user"
- * @property {string} [magicVars.locale] Value for the "$user.locale" in "sqlite" dialect
- * @property {string} [magicVars.user] Value for the "$user" variable in "sqlite" dialect
+ * @property {object} [variableReplacements] Object containing values for magic variables like "$user"
+ * @property {string} [variableReplacements.$user.locale] Value for the "$user.locale" variable
+ * @property {string} [variableReplacements.$user.id] Value for the "$userid" variable
  * @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,18 +10,22 @@ const publicOptionsNewAPI = [
   // GENERAL
   'beta',
   'deprecated',
+  'addTextsLanguageAssoc',
   'localizedLanguageFallback',  // why can't I define the option type here?
   'severities',
   'messages',
   'withLocations',
+  'defaultBinaryLength',
   'defaultStringLength',
+  'csnFlavor',
   // DB
   'sqlDialect',
   'sqlMapping',
   'sqlChangeMode',
   'allowCsnDowngrade',
   'joinfk',
-  'magicVars',
+  'magicVars', // deprecated
+  'variableReplacements',
   // ODATA
   'odataVersion',
   'odataFormat',
@@ -45,9 +49,10 @@ const privateOptions = [
   'traceParserAmb',
   'testMode',
   'testSortCsn',
-  'constraintsNotEnforced',
-  'constraintsNotValidated',
-  'skipDbConstraints',
+  'integrityNotEnforced',
+  'integrityNotValidated',
+  'assertIntegrity',
+  'assertIntegrityType',
   'noRecompile',
   'internalMsg',
   'disableHanaComments',      // in case of issues with hana comment rendering
@@ -68,10 +73,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) {
@@ -90,6 +96,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' ]),
@@ -105,6 +112,10 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
     mapToOldNames(optionName, optionValue);
   }
 
+  // Convenience for $user -> $user.id replacement
+  if (options.variableReplacements && options.variableReplacements.$user && typeof options.variableReplacements.$user === 'string')
+    options.variableReplacements.$user = { id: options.variableReplacements.$user };
+
   /**
    * Map a new-style option to it's old format
    *
@@ -126,6 +137,7 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
       case 'sqlMapping':
         options.names = optionValue;
         break;
+      // No need to remap variableReplacements here - we use the new mechanism with that directly
       case 'magicVars':
         if (optionValue.user)
           options.user = optionValue.user;
@@ -141,11 +153,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);
@@ -155,7 +167,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);
@@ -164,17 +176,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);
@@ -186,7 +198,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);
@@ -198,7 +210,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);
@@ -208,10 +220,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;

package/lib/api/validate.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { makeMessageFunction, handleMessages } = require('../base/messages');
+const { makeMessageFunction } = require('../base/messages');
 
 /* eslint-disable arrow-body-style */
 const booleanValidator = {
@@ -70,6 +70,14 @@ const validators = {
       return val === null ? val : `type ${ typeof val }`;
     },
   },
+  // TODO: Maybe do a deep validation of the whole object with leafs?
+  variableReplacements: {
+    validate: val => val !== null && typeof val === 'object' && !Array.isArray(val),
+    expected: () => 'type object',
+    found: (val) => {
+      return val === null ? val : `type ${ typeof val }`;
+    },
+  },
   messages: {
     validate: val => Array.isArray(val),
     expected: () => 'type array',
@@ -89,14 +97,32 @@ const validators = {
     expected: () => 'type array of string',
     found: val => `type ${ typeof val }`,
   },
+  defaultBinaryLength: {
+    validate: val => !Number.isNaN(Number(val)) && Number.isInteger(Number.parseFloat(val)),
+
+    expected: () => 'Integer literal',
+    found: val => `${ (!Number.isNaN(Number(val)) ? val : 'Not a Number') }`,
+  },
   defaultStringLength: {
-    validate: val => Number.isInteger(val),
+    validate: val => !Number.isNaN(Number(val)) && Number.isInteger(Number.parseFloat(val)),
+
     expected: () => 'Integer literal',
+    found: val => `${ (!Number.isNaN(Number(val)) ? val : 'Not a Number') }`,
+  },
+  csnFlavor: {
+    validate: val => typeof val === 'string',
+    expected: () => 'type string',
     found: val => `type ${ typeof val }`,
   },
   dictionaryPrototype: {
     validate: () => true,
   },
+  assertIntegrity: {
+    validate: val => typeof val === 'string' && val === 'individual' || typeof val === 'boolean',
+    expected: () => 'a boolean or a string with value \'individual\'',
+    found: val => (typeof val === 'string' ? val : `type ${ typeof val }`),
+  },
+  assertIntegrityType: generateStringValidator([ 'DB', 'RT' ]),
 };
 
 const allCombinationValidators = {
@@ -122,15 +148,17 @@ const allCombinationValidators = {
  * Use a custom validator or "default" custom validator, fallback to Boolean validator.
  *
  * @param {object} options Flat options object to validate
+ * @param {string} moduleName The called module, e.g. 'for.odata', 'to.hdi'. Needed to initialize the message functions
  * @param {object} [customValidators] Map of custom validators to use
  * @param {string[]} [combinationValidators] Validate option combinations
  * @returns {void}
  * @throws {CompilationError} Throws in case of invalid option usage
  */
-function validate(options, customValidators = {}, combinationValidators = []) {
+function validate(options, moduleName, customValidators = {}, combinationValidators = []) {
+  // TODO: issuing messages in this function looks very strange...
   {
     const messageCollector = { messages: [] };
-    const { error, throwWithError } = makeMessageFunction(null, messageCollector);
+    const { error, throwWithError } = makeMessageFunction(null, messageCollector, moduleName);
 
     for (const optionName of Object.keys(options)) {
       const optionValue = options[optionName];
@@ -142,7 +170,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
     throwWithError();
   }
 
-  const message = makeMessageFunction(null, options);
+  const message = makeMessageFunction(null, options, moduleName);
 
   for (const combinationValidatorName of combinationValidators.concat([ 'beta-no-test' ])) {
     const combinationValidator = allCombinationValidators[combinationValidatorName];
@@ -150,10 +178,7 @@ function validate(options, customValidators = {}, combinationValidators = []) {
       message[combinationValidator.severity]('invalid-option-combination', null, {}, combinationValidator.getMessage(options));
   }
 
-  // TODO: Replace with message.throwWithError():
-  // But be aware that it only throws with non-configurable errors and that this
-  // will lead to issues in test3. See #6037
-  handleMessages(undefined, options);
+  message.throwWithError();
 }
 /* eslint-enable jsdoc/no-undefined-types */
 

package/lib/backends.js

@@ -6,7 +6,6 @@
 const { transformForHanaWithCsn } = require('./transform/forHanaNew');
 const { compactModel, sortCsn } = require('./json/to-csn')
 const { toCdsSourceCsn } = require('./render/toCdl');
-const { toHdbcdsSource } = require('./render/toHdbcds');
 const { toSqlDdl } = require('./render/toSql');
 const { toRenameDdl } = require('./render/toRename');
 const { manageConstraints, listReferentialIntegrityViolations } = require('./render/manageConstraints');
@@ -15,89 +14,10 @@ const { csn2edm, csn2edmAll } = require('./edm/csn2edm');
 const { mergeOptions }  = require('./model/csnUtils');
 const { isBetaEnabled } = require('./base/model');
 const { optionProcessor } = require('./optionProcessor')
-const timetrace = require('./utils/timetrace');
+const { timetrace } = require('./utils/timetrace');
 const { makeMessageFunction } = require('./base/messages');
 const { forEachDefinition } = require('./model/csnUtils');
 
-/**
- * Transform a CSN into HANA-compatible CDS source.
- * The following options control what is actually generated (see help above):
- *   options : {
- *     toHana.names
- *     toHana.src
- *     toHana.csn
- *   }
- * Options provided here are merged with (and take precedence over) options from 'model'.
- * If 'toHana.names' is not provided, 'quoted' is used.
- * If neither 'toHana.src' nor 'toHana.csn' are provided, the default is to generate only HANA CDS
- * source files.
- * If all provided options are part of 'toHana', the 'toHana' wrapper can be omitted.
- * The result object contains the generation results as follows (as enabled in 'options'):
- *   result : {
- *     csn               : the (compact) transformed CSN model
- *     hdbcds            : a dictionary of top-level artifact names, containing for each name 'X':
- *       <X>             : the HANA CDS source string of the artifact 'X'. Please note that the
- *                         name of 'X' may contain characters that are not legal for filenames on
- *                         all operating systems (e.g. ':', '\' or '/').
- *                         X reflects the naming policy set by toHana.names
- *   }
- * Throws a CompilationError on errors.
- *
- * @param {CSN.Model}   csn
- * @param {CSN.Options} [options]
- */
-function toHanaWithCsn(csn, options) {
-  timetrace.start('toHanaWithCsn');
-  // In case of API usage the options are in the 'options' argument
-  // put the OData specific options under the 'options.toHana' wrapper
-  // and leave the rest under 'options'
-  if (options && !options.toHana) {
-    _wrapRelevantOptionsForCmd(options, 'toHana');
-  }
-  // Provide defaults and merge options with those from model
-  options = mergeOptions({ toHana : getDefaultBackendOptions().toHana }, options);
-
-  // Provide something to generate if nothing else was given (conditional default)
-  if (!options.toHana.src && !options.toHana.csn) {
-    options.toHana.src = true;
-  }
-
-  const { warning } = makeMessageFunction(csn, options, 'to.hdbcds');
-
-  // Verify options
-  optionProcessor.verifyOptions(options, 'toHana', true).forEach(complaint => warning(null, null, `${complaint}`));
-
-  // Special case: For naming variant 'hdbcds' in combination with 'toHana' (and only there!), 'forHana'
-  // must leave namespaces, structs and associations alone.
-  if (options.toHana.names === 'hdbcds') {
-    options = mergeOptions(options, { forHana : { keepNamespaces: true, keepStructsAssocs: true } });
-  }
-
-  options = mergeOptions(options, { forHana: { dialect: 'hana' } }, { forHana : options.toHana });
-
-  // Prepare model for HANA (transferring the options to forHana, and setting 'dialect' to 'hana', because 'toHana' is only used for that)
-  let forHanaCsn = transformForHanaWithCsn(csn, options, 'to.hdbcds');
-
-  // Assemble result
-  let result = {};
-
-  if (options.toHana.src) {
-    if(options.testMode){
-      const sorted = sortCsn(forHanaCsn, options);
-      result = toHdbcdsSource(sorted, options);
-    } else {
-      result = toHdbcdsSource(forHanaCsn, options);
-    }
-  }
-
-  if (options.toHana.csn) {
-    result.csn = options.testMode ? sortCsn(forHanaCsn, options) : forHanaCsn;
-  }
-
-  timetrace.stop();
-  return result;
-}
-
 /**
  * Generate ODATA for `csn` using `options`.
  * The twin of the toOdata function but using CSN
@@ -172,9 +92,9 @@ function toOdataWithCsn(csn, options) {
 // Generate edmx for given 'service' based on 'csn' (new-style compact, already prepared for OData)
 // using 'options'
 function preparedCsnToEdmx(csn, service, options) {
-  let edmx = csn2edm(csn, service, options).toXML('all');
+  const e = csn2edm(csn, service, options)
   return {
-    edmx,
+    edmx: (e ? e.toXML('all') : undefined)
   };
 }
 
@@ -195,9 +115,9 @@ function preparedCsnToEdmxAll(csn, options) {
 function preparedCsnToEdm(csn, service, options) {
   // Merge options; override OData version as edm json is always v4
   options = mergeOptions(options, { toOdata : { version : 'v4' }});
-  const edmj = csn2edm(csn, service, options).toJSON();
+  const e = csn2edm(csn, service, options);
   return {
-    edmj,
+    edmj: (e ? e.toJSON() : undefined)
   };
 }
 
@@ -485,9 +405,6 @@ function toRenameWithCsn(csn, options) {
 
 function alterConstraintsWithCsn(csn, options) {
   const { error } = makeMessageFunction(csn, options, 'manageConstraints');
-  // Requires beta mode
-  if (!isBetaEnabled(options, 'foreignKeyConstraints'))
-    error(null, null, 'ALTER TABLE statements for adding/modifying referential constraints are only available in beta mode');
 
   const {
     drop, alter, names, src, violations
@@ -500,6 +417,10 @@ function alterConstraintsWithCsn(csn, options) {
     dialect: 'hana',
     names: names || 'plain'
   }
+
+  // Of course we want the database constraints
+  options.assertIntegrityType = 'DB';
+
   const transformedOptions = transformSQLOptions(csn, options);
   const mergedOptions = mergeOptions(transformedOptions.options, { forHana : transformedOptions.forHanaOptions });
   const forSqlCsn = transformForHanaWithCsn(csn, mergedOptions, 'to.sql');
@@ -603,7 +524,6 @@ function _wrapRelevantOptionsForCmd(options, command) {
 }
 
 module.exports = {
-  toHanaWithCsn,
   toOdataWithCsn,
   preparedCsnToEdmx,
   preparedCsnToEdmxAll,