@sap/cds-compiler 2.15.4 → 3.0.0

package/doc/CHANGELOG_BETA.md

@@ -8,12 +8,11 @@ Note: `beta` fixes, changes and features are listed in this ChangeLog just for i
 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.XX.YY
+## Version 3.0.0 - 2022-XX-YY
 
-### Removed `assocsWithParams`
+### Removed `addTextsLanguageAssoc`
 
-Instead, of using the beta flag `assocsWithParams`, you can change the severity of the messages
-`def-unexpected-paramview-assoc` and `def-unexpected-calcview-assoc`.
+Instead, use the option `addTextsLanguageAssoc`, which is available since v2.8.0.
 
 ## Version 2.12.0 - 2022-01-25
 

package/doc/CHANGELOG_DEPRECATED.md

@@ -11,7 +11,41 @@ Note: `deprecated` features are listed in this ChangeLog just for information.
 **When the `deprecated` option is set, the `beta` option is ignored,
 and several new features are not available.**
 
-## Version 2.XX.YY - 2022-MM-DD
+## Version 3.0.0 - 2022-XX-YY
+
+Version 3 of the cds-compiler removes all v2 deprecated flags.
+
+### Removed `createLocalizedViews`
+
+### Removed `downgradableErrors`
+
+### Removed `generatedEntityNameWithUnderscore`
+
+### Removed `longAutoexposed`
+
+### Removed `noElementsExpansion`
+
+### Removed `noInheritedAutoexposeViaComposition`
+
+### Removed `noScopedRedirections`
+
+### Removed `oldVirtualNotNullPropagation`
+
+### Removed `parensAsStrings`
+
+### Removed `projectionAsQuery`
+
+### Removed `redirectInSubQueries`
+
+### Removed `renderVirtualElements`
+
+### Removed `shortAutoexposed`
+
+### Removed `unmanagedUpInComponent`
+
+### Removed `v1KeysForTemporal`
+
+## Version 2.13.0 - 2022-03-22
 
 ### Added `redirectInSubQueries`
 

package/doc/{DeprecatedOptions.md → DeprecatedOptions_v2.md}

@@ -1,8 +1,10 @@
 # Deprecated Options and How to Avoid Them
 
+__Important__: With compiler v3, these deprecated options were removed!
+
 To ease the migration to CDS Compiler Version 2,
 the compiler can be called with an option `deprecated`
-which make the compiler behave more like Compiler Version 1 for certain features.
+which makes the compiler behave more like Compiler Version 1 for certain features.
 
 As the name suggest, this option should be used only for a limited time.
 The support for certain v1 features might also be dropped after a while

package/doc/Versioning.md

@@ -5,6 +5,17 @@ The cds-compiler uses [Semantic Versioning][SemVer] for its version numbers.
 This document clarifies how we use [SemVer] and what you can and what you can‘t
 expect from version updates.
 
+<!-- toc: start -->
+
+1. [Public API](#public-api)
+2. [Patch Versions](#patch-versions)
+3. [Minor Versions](#minor-versions)
+4. [Beta Flags](#beta-flags)
+5. [Deprecated Flags](#deprecated-flags)
+6. [Command Line Tool `cdsc`](#command-line-tool-cdsc)
+
+<!-- toc: end -->
+
 ## Public API
 
 According to [§1] of SemVer, a public API must be made available.  Our public
@@ -41,7 +52,7 @@ we detect invalid CDS code.
 
 ## Beta Flags
 
-The compiler provides so called “beta flags” that enable or disable certain
+The compiler provides so-called “beta flags” that enable or disable certain
 features.  We do not guarantee that any such flags stay consistent between
 patch versions!  Beta flags may change any time.
 
@@ -57,6 +68,14 @@ period.
 Refer to [CHANGELOG_DEPRECATED.md](./CHANGELOG_DEPRECATED.md) for changes
 to deprecated flags.
 
+## Command Line Tool `cdsc`
+
+`bin/cdsc.js` as well as all other command line tools do _not_ guarantee any
+stability.  It is considered a compiler internal tool that only serves for
+debugging.  The official command line tool `cds` of the `@sap/cds` and
+`@sap/cds-dk` packages are to be used by users.  That means commands and
+options may change any time without prior notice.  Changes may still be listed
+in [CHANGELOG.md](../CHANGELOG.md).
 
 [SemVer]: https://semver.org/
 [§1]: https://semver.org/#spec-item-1

package/lib/api/.eslintrc.json

@@ -1,13 +1,13 @@
 {
   "root": true,
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": true
   },
   // we actually do not extend airbnb-base, as it weakens some eslint:recommended rules
   "extends": ["../../.eslintrc-ydkjsi.json", "plugin:jsdoc/recommended"],
   "parserOptions": {
-    "ecmaVersion": 2018,
+    "ecmaVersion": 2020,
     "sourceType": "script"
   },
   "plugins":  [

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 } = require('../utils/objectUtils');
+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,12 +212,16 @@ 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');
+
+  if (internalOptions.sqlDialect === 'postgres' && !baseModel.isBetaEnabled(internalOptions, 'postgres'))
+    error(null, null, 'sqlDialect: \'postgres\' is only supported with beta-flag \'postgres\'');
 
-  const intermediateResult = backends.toSqlWithCsn(csn, internalOptions);
+  // we need the CSN for view sorting
+  const transformedCsn = forSql(csn, options);
+  const sqls = toSql.toSqlDdl(transformedCsn, internalOptions);
 
-  const result = sortViews(intermediateResult);
+  const result = sortViews({ csn: transformedCsn, sql: sqls.sql });
 
   return result.map(obj => obj.sql).filter(create => create);
 }
@@ -233,12 +237,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 +246,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 +277,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,45 +343,17 @@ 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,
@@ -440,14 +412,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 +441,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 +461,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 +475,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 +501,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 +532,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 +543,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 +649,9 @@ module.exports = {
   for_sql: publishCsnProcessor(forSql, 'for.sql'),
   for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
   for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
-  /** */
+  /** Deprecated, will be removed in cds-compiler@v4 */
+  preparedCsnToEdmx,
+  preparedCsnToEdm,
 };
 
 
@@ -639,29 +684,101 @@ 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 );
     }
   }
 }
 
+// Note: No toCsn, because @sap/cds may still use it (2022-06-15)
+const oldBackendOptionNames = [ 'toSql', 'toOdata', 'toHana', 'forHana' ];
+/**
+ * Checks if outdated options are used and if so, throw a compiler error.
+ * These include:
+ *  - magicVars (now variableReplacements)
+ *  - toOdata/toSql/toHana/forHana -> now flat options
+ *
+ * @param {CSN.Options} options Backend options
+ */
+function checkOutdatedOptions(options) {
+  const { error, throwWithError } = messages.makeMessageFunction(null, options, 'api');
+
+  // 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
+      error('api-invalid-option', null, { '#': 'std', name });
+  }
+
+  if (options.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?.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')
+      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];
+    },
+  });
+}
+
 
 /**
  * Option format used by the old API, where they are grouped thematically.