@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/api/main.js

@@ -2,20 +2,20 @@
 
 'use strict';
 
-const prepareOptions = require('./options');
-const backends = require('../backends');
-const { setProp } = require('../base/model');
-const { emptyLocation } = require('../base/location');
-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');
+const prepareOptions = lazyload('./options');
+const baseModel = lazyload('../base/model');
+const location = lazyload('../base/location');
+const messages = lazyload('../base/messages');
+const compiler = lazyload('../compiler/index');
+const toCsn = lazyload('../json/to-csn');
+const forOdataNew = lazyload('../transform/forOdataNew.js');
+const toSql = lazyload('../render/toSql');
+const toCdl = require('../render/toCdl');
+const modelCompare = lazyload('../modelCompare/compare');
+const sortViews = lazyload('../model/sortViews');
+const csnUtils = lazyload('../model/csnUtils');
+const timetrace = lazyload('../utils/timetrace');
+const forHanaNew = lazyload('../transform/forHanaNew');
 
 /**
  * Return the artifact name for use for the hdbresult object
@@ -26,17 +26,15 @@ const { transformForHanaWithCsn } = require('../transform/forHanaNew');
  * @returns {string} Name with . replaced as _ in some places
  */
 function getFileName(artifactName, csn) {
-  return getResultingName(csn, 'quoted', artifactName);
+  return csnUtils.getResultingName(csn, 'quoted', artifactName);
 }
 
-const propertyToCheck = {
-  odata: 'toOdata',
-};
-
 const { cloneCsnNonDict } = require('../model/csnUtils');
 const { toHdbcdsSource } = require('../render/toHdbcds');
 const { ModelError } = require('../base/error');
 const { forEach, forEachKey } = require('../utils/objectUtils');
+const { checkRemovedDeprecatedFlags } = require('../base/model');
+const { csn2edm, csn2edmAll } = require('../edm/csn2edm');
 
 const relevantGeneralOptions = [ /* for future generic options */ ];
 const relevantOdataOptions = [ 'sqlMapping', 'odataFormat' ];
@@ -54,15 +52,14 @@ const warnAboutMismatchOdata = [ 'odataVersion' ];
 function attachTransformerCharacteristics(csn, transformation, options,
                                           relevantOptionNames, optionalOptionNames = []) {
   const relevant = {};
-  const propName = propertyToCheck[transformation];
   for (const name of relevantOptionNames ) {
-    if (options[propName][name] !== undefined)
-      relevant[name] = options[propName][name];
+    if (options[name] !== undefined)
+      relevant[name] = options[name];
   }
 
   for (const name of optionalOptionNames ) {
-    if (options[propName][name] !== undefined)
-      relevant[name] = options[propName][name];
+    if (options[name] !== undefined)
+      relevant[name] = options[name];
   }
 
   for (const name of relevantGeneralOptions ) {
@@ -70,10 +67,10 @@ function attachTransformerCharacteristics(csn, transformation, options,
       relevant[name] = options[name];
   }
   if (!csn.meta)
-    setProp(csn, 'meta', {});
+    baseModel.setProp(csn, 'meta', {});
 
-  setProp(csn.meta, 'options', relevant);
-  setProp(csn.meta, 'transformation', transformation);
+  baseModel.setProp(csn.meta, 'options', relevant);
+  baseModel.setProp(csn.meta, 'transformation', transformation);
 }
 
 /**
@@ -92,7 +89,7 @@ function checkPreTransformedCsn(csn, options, relevantOptionNames, warnAboutMism
     // Not able to check
     return;
   }
-  const { error, warning, throwWithAnyError } = makeMessageFunction(csn, options, module);
+  const { error, warning, throwWithAnyError } = messages.makeMessageFunction(csn, options, module);
 
   for (const name of relevantOptionNames ) {
     if (options[name] !== csn.meta.options[name])
@@ -128,7 +125,7 @@ function isPreTransformed(csn, transformation) {
  * @returns {object} Return an oData-pre-processed CSN
  */
 function odataInternal(csn, internalOptions) {
-  const oDataCsn = transform4odataWithCsn(csn, internalOptions);
+  const oDataCsn = forOdataNew.transform4odataWithCsn(csn, internalOptions);
   attachTransformerCharacteristics(oDataCsn, 'odata', internalOptions, relevantOdataOptions, warnAboutMismatchOdata);
   return oDataCsn;
 }
@@ -150,13 +147,13 @@ function odata(csn, options = {}) {
  *
  * @param {object} csn CSN to process
  * @param {object} [externalOptions={}] Options
- * @returns {CDL} { <artifactName>: <CDL representation>, ...}
+ * @returns {object} { model: string,  namespace: string, unappliedExtensions: string }
  */
 function cdl(csn, externalOptions = {}) {
   const internalOptions = prepareOptions.to.cdl(externalOptions);
-  const { result } = backends.toCdlWithCsn(cloneCsnNonDict(csn, internalOptions), internalOptions);
-  return result;
+  return toCdl.csnToCdl(cloneCsnNonDict(csn, internalOptions), internalOptions);
 }
+
 /**
  * Transform a CSN like to.sql
  *
@@ -168,8 +165,9 @@ function cdl(csn, externalOptions = {}) {
 function forSql(csn, options = {}) {
   const internalOptions = prepareOptions.to.sql(options);
   internalOptions.transformation = 'sql';
-  internalOptions.toSql.csn = true;
-  return backends.toSqlWithCsn(csn, internalOptions).csn;
+  const transformedCsn = forHanaNew.transformForHanaWithCsn(csn, internalOptions, 'to.sql');
+
+  return internalOptions.testMode ? toCsn.sortCsn(transformedCsn, internalOptions) : transformedCsn;
 }
 /**
  * Transform a CSN like to.hdi
@@ -181,8 +179,10 @@ function forSql(csn, options = {}) {
  */
 function forHdi(csn, options = {}) {
   const internalOptions = prepareOptions.to.hdi(options);
-  internalOptions.toSql.csn = true;
-  return backends.toSqlWithCsn(csn, internalOptions).csn;
+  internalOptions.transformation = 'sql';
+  const transformedCsn = forHanaNew.transformForHanaWithCsn(csn, internalOptions, 'to.hdi');
+
+  return internalOptions.testMode ? toCsn.sortCsn(transformedCsn, internalOptions) : transformedCsn;
 }
 /**
  * Transform a CSN like to.hdbcds
@@ -196,9 +196,9 @@ function forHdbcds(csn, options = {}) {
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
 
-  const hanaCsn = transformForHanaWithCsn(csn, internalOptions, 'to.hdbcds');
+  const hanaCsn = forHanaNew.transformForHanaWithCsn(csn, internalOptions, 'to.hdbcds');
 
-  return internalOptions.testMode ? sortCsn(hanaCsn, internalOptions) : hanaCsn;
+  return internalOptions.testMode ? toCsn.sortCsn(hanaCsn, internalOptions) : hanaCsn;
 }
 
 /**
@@ -212,16 +212,64 @@ function sql(csn, options = {}) {
   const internalOptions = prepareOptions.to.sql(options);
   internalOptions.transformation = 'sql';
 
-  // we need the CSN for view sorting
-  internalOptions.toSql.csn = true;
+  const { error } = messages.makeMessageFunction(csn, internalOptions, 'for.odata');
 
-  const intermediateResult = backends.toSqlWithCsn(csn, internalOptions);
+  if (internalOptions.sqlDialect === 'postgres' && !baseModel.isBetaEnabled(internalOptions, 'postgres'))
+    error(null, null, 'sqlDialect: \'postgres\' is only supported with beta-flag \'postgres\'');
 
-  const result = sortViews(intermediateResult);
+  // we need the CSN for view sorting
+  const transformedCsn = forSql(csn, options);
+  const sqls = toSql.toSqlDdl(transformedCsn, internalOptions);
+
+  const result = sortViews({ csn: transformedCsn, sql: sqls.sql });
 
   return result.map(obj => obj.sql).filter(create => create);
 }
 
+/**
+ * Render the given deltaCSN as SQL.
+ *
+ * @param {CSN.Model} csn A clean input CSN
+ * @param {CSN.Model} deltaCsn A CSN representing new entities and extensions
+ * @param {SqlOptions} [options={}] Options
+ * @returns {object} - definitions: An array of objects with all artifacts in the after-image. Each object specifies
+ *                                  the artifact filename, the suffix, and the corresponding SQL statement to create
+ *                                  the artifact.
+ *                   - deletions:   An array of objects with the deleted artifacts. Each object specifies the artifact
+ *                                  filename and the suffix.
+ *                   - migrations:  An array of objects with the changed (migrated) artifacts. Each object specifies the
+ *                                  artifact filename, the suffix, and the changeset (an array of changes, each specifying
+ *                                  whether it incurs potential data loss, and its respective SQL statement(s), with
+ *                                  multiple statements concatenated as a multi-line string in case the change e.g.
+ *                                  consists of a column drop and add).
+ */
+function mtx(csn, deltaCsn, options = {}) {
+  if (!baseModel.isBetaEnabled(options, 'to.mtx'))
+    throw new Error('to.mtx is only available with beta flag `to.mtx`');
+
+  const internalOptions = prepareOptions.to.sql(options);
+  // TODO: Use compiler.compileSources() when this function is moved to lib/main.js
+  const merged = toCsn.compactModel(compiler.compileSourcesX({ 'base.csn': csn, 'delta.csn': deltaCsn }), options);
+  const baseSql = forSql(csn, options);
+  const mergedSql = forSql(merged, options);
+  const diff = modelCompare.compareModels(baseSql, mergedSql, options);
+  // Delete artifacts that are already present in csn
+  Object.keys(baseSql.definitions).forEach((artifactName) => {
+    if (diff.definitions[artifactName]) // don't render again, but need info for primary key extension
+      diff.definitions[artifactName]['@cds.persistence.skip'] = true;
+  });
+
+  internalOptions.forHana = true;
+  internalOptions.beta.sqlExtensions = true;
+  const { deletions, migrations, ...additions } = toSql.toSqlDdl(diff, internalOptions);
+
+  return {
+    additions: createSqlDefinitions(additions, mergedSql),
+    deletions: createSqlDeletions(deletions, baseSql),
+    migrations: createSqlMigrations(migrations, mergedSql),
+  };
+}
+
 /**
  * Process the given CSN into HDI artifacts.
  *
@@ -233,12 +281,8 @@ function hdi(csn, options = {}) {
   const internalOptions = prepareOptions.to.hdi(options);
 
   // we need the CSN for view sorting
-  internalOptions.toSql.csn = true;
-
-  const intermediateResult = backends.toSqlWithCsn(csn, internalOptions);
-
-  const sqlCSN = intermediateResult.csn;
-  delete intermediateResult.csn;
+  const sqlCSN = forHdi(csn, options);
+  const sqls = toSql.toSqlDdl(sqlCSN, internalOptions);
 
   if (internalOptions.testMode) {
     // All this mapping is needed because sortViews crossmatches
@@ -246,7 +290,7 @@ function hdi(csn, options = {}) {
     // But we also need to return it with the correct file ending in the end
     // so remember and do lot's of mapping here.
 
-    const flat = flattenResultStructure(intermediateResult);
+    const flat = flattenResultStructure(sqls);
 
     const nameMapping = Object.create(null);
     const sqlArtifactsWithCSNNamesToSort = Object.create(null);
@@ -277,7 +321,7 @@ function hdi(csn, options = {}) {
     return sorted;
   }
 
-  return remapNames(flattenResultStructure(intermediateResult), sqlCSN, k => !k.endsWith('.hdbindex'));
+  return remapNames(flattenResultStructure(sqls), sqlCSN, k => !k.endsWith('.hdbindex'));
 }
 /**
  * Remap names so that they stay consistent between v1 and v2
@@ -343,91 +387,69 @@ function remapName(key, csn, filter = () => true) {
  *                                  consists of a column drop and add).
  */
 function hdiMigration(csn, options, beforeImage) {
-  /**
-   * Swap arguments in case of inverted argument order.
-   * This is for backward compatibility with @sap/cds@4.5.(2…3).
-   *
-   * @todo Remove in cds-compiler@2.x
-   * @param {HdiOptions|CSN.Model} inputOptions Options or CSN image
-   * @param {HdiOptions|CSN.Model} inputBeforeImage CSN image or options
-   * @returns {Array} Array where the real options come first
-   */
-  function backwardCompatible(inputOptions, inputBeforeImage) {
-    /**
-     * Check whether the given argument is a CSN
-     *
-     * @param {object} arg Argument to verify
-     * @returns {boolean} True if it is a CSN
-     */
-    function isBeforeImage(arg) {
-      return arg === null || [ 'definitions', 'meta', '$version' ].some(key => key in arg);
-    }
-    return isBeforeImage(inputBeforeImage)
-      ? [ inputOptions, inputBeforeImage ]
-      : [ inputBeforeImage, inputOptions ];
-  }
-  [ options, beforeImage ] = backwardCompatible(options, beforeImage);
-
   const internalOptions = prepareOptions.to.hdi(options);
-  internalOptions.toSql.csn = true;
 
   // Prepare after-image.
-  // FIXME: Is this needed?
-  // cloneCsnMessages(csn, options, internalOptions);
-  const afterImage = backends.toSqlWithCsn(csn, internalOptions).csn;
+  const afterImage = forHdi(csn, options);
 
   // Compare both images.
-  const diff = compareModels(beforeImage || afterImage, afterImage, internalOptions);
+  const diff = modelCompare.compareModels(beforeImage || afterImage, afterImage, internalOptions);
 
   // Convert the diff to SQL.
   internalOptions.forHana = true; // Make it pass the SQL rendering
-  const { deletions, migrations, ...hdbkinds } = toSqlDdl(diff, internalOptions);
+  const { deletions, migrations, ...hdbkinds } = toSql.toSqlDdl(diff, internalOptions);
 
   return {
     afterImage,
-    definitions: createDefinitions(),
-    deletions: createDeletions(),
-    migrations: createMigrations(),
+    definitions: createSqlDefinitions(hdbkinds, afterImage),
+    deletions: createSqlDeletions(deletions, beforeImage),
+    migrations: createSqlMigrations(migrations, afterImage),
   };
+}
 
-  /**
-   * From the given HDI artifacts, create the the correct result structure.
-   *
-   * @returns {object[]} Array of objects, each having: name, suffix and sql
-   */
-  function createDefinitions() {
-    const result = [];
-    forEach(hdbkinds, (kind, artifacts) => {
-      const suffix = `.${ kind }`;
-      forEach(artifacts, (name, sqlStatement) => {
-        if ( kind !== 'hdbindex' )
-          result.push({ name: getFileName(name, afterImage), suffix, sql: sqlStatement });
-        else
-          result.push({ name, suffix, sql: sqlStatement });
-      });
+/**
+ * From the given SQLs, create the correct result structure.
+ *
+ * @param {object} hdbkinds Object of hdbkinds (such as `hdbindex`) mapped to dictionary of artifacts.
+ * @param {CSN.Model} afterImage CSN, used to create correct file names in result structure.
+ * @returns {object[]} Array of objects, each having: name, suffix and sql
+ */
+function createSqlDefinitions(hdbkinds, afterImage) {
+  const result = [];
+  forEach(hdbkinds, (kind, artifacts) => {
+    const suffix = `.${ kind }`;
+    forEach(artifacts, (name, sqlStatement) => {
+      if ( kind !== 'hdbindex' )
+        result.push({ name: getFileName(name, afterImage), suffix, sql: sqlStatement });
+      else
+        result.push({ name, suffix, sql: sqlStatement });
     });
-    return result;
-  }
-  /**
-   * From the given deletions, create the correct result structure.
-   *
-   * @returns {object[]} Array of objects, each having: name and suffix - only .hdbtable as suffix for now
-   */
-  function createDeletions() {
-    const result = [];
-    forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
-    return result;
-  }
-  /**
-   * From the given migrations, create the correct result structure.
-   *
-   * @returns {object[]} Array of objects, each having: name, suffix and changeset.
-   */
-  function createMigrations() {
-    const result = [];
-    forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
-    return result;
-  }
+  });
+  return result;
+}
+/**
+ * From the given deletions, create the correct result structure.
+ *
+ * @param {object} deletions Dictionary of deletions, only keys are used.
+ * @param {CSN.Model} beforeImage CSN used to create correct file names in result structure.
+ * @returns {object[]} Array of objects, each having: name and suffix - only .hdbtable as suffix for now
+ */
+function createSqlDeletions(deletions, beforeImage) {
+  const result = [];
+  forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
+  return result;
+}
+/**
+ * From the given migrations, create the correct result structure.
+ *
+ * @param {object} migrations Dictionary of changesets (migrations).
+ * @param {CSN.Model} afterImage CSN used to create correct file names in result structure.
+ * @returns {object[]} Array of objects, each having: name, suffix and changeset.
+ */
+function createSqlMigrations(migrations, afterImage) {
+  const result = [];
+  forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
+  return result;
 }
 
 hdi.migration = hdiMigration;
@@ -440,14 +462,14 @@ hdi.migration = hdiMigration;
  * @returns {HDBCDS} { <filename>:<content>, ...}
  */
 function hdbcds(csn, options = {}) {
-  timetrace.start('to.hdbcds');
+  timetrace.timetrace.start('to.hdbcds');
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
 
   const hanaCsn = forHdbcds(csn, internalOptions);
 
   const result = flattenResultStructure(toHdbcdsSource(hanaCsn, internalOptions));
-  timetrace.stop();
+  timetrace.timetrace.stop();
   return result;
 }
 /**
@@ -469,11 +491,11 @@ function edm(csn, options = {}) {
   let servicesEdmj;
   if (isPreTransformed(csn, 'odata')) {
     checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions, warnAboutMismatchOdata, 'for.odata');
-    servicesEdmj = backends.preparedCsnToEdm(csn, service, internalOptions);
+    servicesEdmj = preparedCsnToEdm(csn, service, internalOptions);
   }
   else {
     const oDataCsn = odataInternal(csn, internalOptions);
-    servicesEdmj = backends.preparedCsnToEdm(oDataCsn, service, internalOptions);
+    servicesEdmj = preparedCsnToEdm(oDataCsn, service, internalOptions);
   }
   return servicesEdmj.edmj;
 }
@@ -489,9 +511,9 @@ edm.all = edmall;
  */
 function edmall(csn, options = {}) {
   const internalOptions = prepareOptions.to.edm(options);
-  const { error } = makeMessageFunction(csn, internalOptions, 'for.odata');
+  const { error } = messages.makeMessageFunction(csn, internalOptions, 'for.odata');
 
-  if (internalOptions.version === 'v2')
+  if (internalOptions.odataVersion === 'v2')
     error(null, null, 'OData JSON output is not available for OData V2');
 
   const result = {};
@@ -503,13 +525,11 @@ function edmall(csn, options = {}) {
   else
     oDataCsn = odataInternal(csn, internalOptions);
 
-  const servicesJson = backends.preparedCsnToEdmAll(oDataCsn, internalOptions);
+  const servicesJson = 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!
-    result[serviceName] = lEdm;
-  }
+  for (const serviceName in services)
+    result[serviceName] = services[serviceName];
+
   return result;
 }
 /**
@@ -531,11 +551,11 @@ function edmx(csn, options = {}) {
   let services;
   if (isPreTransformed(csn, 'odata')) {
     checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions, warnAboutMismatchOdata, 'for.odata');
-    services = backends.preparedCsnToEdmx(csn, service, internalOptions);
+    services = preparedCsnToEdmx(csn, service, internalOptions);
   }
   else {
     const oDataCsn = odataInternal(csn, internalOptions);
-    services = backends.preparedCsnToEdmx(oDataCsn, service, internalOptions);
+    services = preparedCsnToEdmx(oDataCsn, service, internalOptions);
   }
 
   return services.edmx;
@@ -562,7 +582,7 @@ function edmxall(csn, options = {}) {
   else
     oDataCsn = odataInternal(csn, internalOptions);
 
-  const servicesEdmx = backends.preparedCsnToEdmxAll(oDataCsn, internalOptions);
+  const servicesEdmx = preparedCsnToEdmxAll(oDataCsn, internalOptions);
   const services = servicesEdmx.edmx;
   // Create annotations and metadata once per service
   for (const serviceName in services) {
@@ -573,6 +593,79 @@ function edmxall(csn, options = {}) {
   return result;
 }
 
+/**
+ * Generate edmx for given 'service' based on 'csn' (new-style compact, already prepared for OData)
+ * using 'options'
+ *
+ * @param {CSN.Model} csn Input CSN model. Must be OData transformed CSN.
+ * @param {string} service Service name to use. If you want all services, use preparedCsnToEdmxAll()
+ * @param {ODataOptions} options OData / EDMX specific options.
+ * @returns {object} Rendered EDMX string for the given service.
+ */
+function preparedCsnToEdmx(csn, service, options) {
+  const e = csn2edm(csn, service, options);
+  return {
+    edmx: (e ? e.toXML('all') : undefined),
+  };
+}
+
+/**
+ * Generate edmx for given 'service' based on 'csn' (new-style compact, already prepared for OData)
+ * using 'options'.
+ *
+ * @param {CSN.Model} csn Input CSN model. Must be OData transformed CSN.
+ * @param {ODataOptions} options OData / EDMX specific options.
+ * @returns {object} Dictionary of rendered EDMX strings for each service.
+ */
+function preparedCsnToEdmxAll(csn, options) {
+  const edmxResult = csn2edmAll(csn, options);
+  for (const service in edmxResult)
+    edmxResult[service] = edmxResult[service].toXML('all');
+
+  return {
+    edmx: edmxResult,
+  };
+}
+
+/**
+ * Generate edm-json for given 'service' based on 'csn' (new-style compact, already prepared for OData)
+ * using 'options'
+ *
+ * @param {CSN.Model} csn Input CSN model. Must be OData transformed CSN.
+ * @param {string} service Service name for which EDMX should be rendered.
+ * @param {ODataOptions} options OData / EDMX specific options.
+ * @returns {object} Rendered EDM JSON object for of the given service.
+ */
+function preparedCsnToEdm(csn, service, options) {
+  // Override OData version as edm json is always v4
+  options.odataVersion = 'v4';
+  const e = csn2edm(csn, service, options);
+  return {
+    edmj: (e ? e.toJSON() : undefined),
+  };
+}
+
+/**
+ * Generate edm-json for given 'service' based on 'csn' (new-style compact, already prepared for OData)
+ * using 'options'
+ *
+ * @param {CSN.Model} csn Input CSN model. Must be OData transformed CSN.
+ * @param {ODataOptions} options OData / EDMX specific options.
+ * @returns {object} Dictionary of rendered EDM JSON objects for each service.
+ */
+function preparedCsnToEdmAll(csn, options) {
+  // Override OData version as edm json is always v4
+  options.odataVersion = 'v4';
+  const edmj = csn2edmAll(csn, options);
+  for (const service in edmj)
+    edmj[service] = edmj[service].toJSON();
+
+  return {
+    edmj,
+  };
+}
+
+
 /**
  * Flatten the result structure to a flat map.
  *
@@ -606,7 +699,11 @@ module.exports = {
   for_sql: publishCsnProcessor(forSql, 'for.sql'),
   for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
   for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
-  /** */
+  /** beta - WIP */
+  mtx: publishCsnProcessor(mtx, 'to.mtx'),
+  /** Deprecated, will be removed in cds-compiler@v4 */
+  preparedCsnToEdmx,
+  preparedCsnToEdm,
 };
 
 
@@ -639,25 +736,29 @@ function publishCsnProcessor( processor, _name ) {
    */
   function api( csn, options = {}, ...args ) {
     try {
+      if (options.deprecated) {
+        const messageFunctions = messages.makeMessageFunction(csn, options, 'api');
+        checkRemovedDeprecatedFlags( options, messageFunctions );
+      }
       checkOutdatedOptions( options );
       return processor( csn, options, ...args );
     }
     catch (err) {
-      if (err instanceof CompilationError || options.noRecompile || isPreTransformed(csn, 'odata')) // we cannot recompile a pre-transformed CSN
+      if (err instanceof messages.CompilationError || options.noRecompile || isPreTransformed(csn, 'odata')) // we cannot recompile a pre-transformed CSN
         throw err;
 
       if (options.testMode && !(err instanceof TypeError) &&
         !(err instanceof ModelError))
         throw err;
 
-      const { info } = makeMessageFunction( csn, options, 'compile' );
-      const msg = info( 'api-recompiled-csn', emptyLocation('csn.json'), {}, 'CSN input had to be recompiled' );
+      const { info } = messages.makeMessageFunction( csn, options, 'compile' );
+      const msg = info( 'api-recompiled-csn', location.emptyLocation('csn.json'), {}, 'CSN input had to be recompiled' );
       if (options.internalMsg)
         msg.error = err; // Attach original error
 
       // next line to be replaced by CSN parser call which reads the CSN object
-      const xsn = recompileX(csn, options);
-      const recompiledCsn = compactModel(xsn);
+      const xsn = compiler.recompileX(csn, options);
+      const recompiledCsn = toCsn.compactModel(xsn);
       return processor( recompiledCsn, options, ...args );
     }
   }
@@ -674,34 +775,59 @@ const oldBackendOptionNames = [ 'toSql', 'toOdata', 'toHana', 'forHana' ];
  * @param {CSN.Options} options Backend options
  */
 function checkOutdatedOptions(options) {
-  if (!options)
-    return;
-  const { warning } = makeMessageFunction(null, options, 'api');
+  const { error, throwWithError } = messages.makeMessageFunction(null, options, 'api');
 
-  // This warning has been emitted once, we don't need to emit it again.
-  if (options.messages && options.messages.some(m => m.messageId === 'api-invalid-option'))
+  // This error has been emitted once, we don't need to emit it again.
+  if (options.messages?.some(m => m.messageId === 'api-invalid-option')) {
+    throwWithError();
     return;
+  }
 
   for (const name of oldBackendOptionNames) {
     if (typeof options[name] === 'object') // may be a boolean due to internal options
-      warning('api-invalid-option', null, { '#': 'std', name });
+      error('api-invalid-option', null, { '#': 'std', name });
   }
 
   if (options.magicVars)
-    warning('api-invalid-option', null, { '#': 'magicVars' });
+    error('api-invalid-option', null, { '#': 'magicVars' });
 
   // Don't check `options.magicVars`.  It's likely that the user renamed `magicVars` but
   // forgot about user -> $user and locale -> $user.locale
-  if (options.variableReplacements) {
-    if (options.variableReplacements.user)
-      warning('api-invalid-option', null, { '#': 'user' });
-    if (options.variableReplacements.locale)
-      warning('api-invalid-option', null, { '#': 'locale' });
-  }
+  if (options.variableReplacements?.user)
+    error('api-invalid-option', null, { '#': 'user' });
+  if (options.variableReplacements?.locale)
+    error('api-invalid-option', null, { '#': 'locale' });
 
   forEachKey(options.variableReplacements || {}, (name) => {
     if (!name.startsWith('$') && name !== 'user' && name !== 'locale')
-      warning('api-invalid-option', null, { '#': 'noDollar', name });
+      error('api-invalid-option', null, { '#': 'noDollar', name });
+  });
+
+  throwWithError();
+}
+
+/**
+ * Load the module on-demand and not immediately.
+ *
+ * @param {string} moduleName Name of the module to load - like with require
+ * @returns {object} A Proxy that handles the on-demand loading
+ */
+function lazyload(moduleName) {
+  let module;
+  return new Proxy(((...args) => {
+    if (!module) // eslint-disable-next-line global-require
+      module = require(moduleName);
+
+    if (module.apply && typeof module.apply === 'function')
+      return module.apply(this, args);
+    return module; // for destructured calls
+  }), {
+    get(target, name) {
+      if (!module) // eslint-disable-next-line global-require
+        module = require(moduleName);
+
+      return module[name];
+    },
   });
 }