@sap/cds-compiler 2.13.8 → 3.0.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,16 +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 { cloneCsn } = require('../model/csnUtils');
+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' ];
@@ -53,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 ) {
@@ -69,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);
 }
 
 /**
@@ -91,7 +89,7 @@ function checkPreTransformedCsn(csn, options, relevantOptionNames, warnAboutMism
     // Not able to check
     return;
   }
-  const { error, warning, throwWithError } = 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])
@@ -103,7 +101,7 @@ function checkPreTransformedCsn(csn, options, relevantOptionNames, warnAboutMism
       warning('options-mismatch-pretransformed-csn', null, `Expected pre-processed CSN to have option "${ name }" set to "${ options[name] }". Found: "${ csn.meta.options[name] }"`);
   }
 
-  throwWithError();
+  throwWithAnyError();
 }
 
 /**
@@ -127,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;
 }
@@ -149,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(cloneCsn(csn, internalOptions), internalOptions);
-  return result;
+  return toCdl.csnToCdl(cloneCsnNonDict(csn, internalOptions), internalOptions);
 }
+
 /**
  * Transform a CSN like to.sql
  *
@@ -167,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
@@ -180,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
@@ -195,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;
 }
 
 /**
@@ -211,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);
 }
@@ -232,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
@@ -245,13 +246,13 @@ 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);
     const sqlArtifactsNotToSort = Object.create(null);
 
-    Object.keys(flat).forEach((key) => {
+    forEach(flat, (key) => {
       const artifactNameLikeInCsn = key.replace(/\.[^/.]+$/, '');
       nameMapping[artifactNameLikeInCsn] = key;
       if (key.endsWith('.hdbtable') || key.endsWith('.hdbview'))
@@ -269,14 +270,14 @@ function hdi(csn, options = {}) {
       }, Object.create(null));
 
     // now add the not-sorted stuff, like indices
-    Object.keys(sqlArtifactsNotToSort).forEach((key) => {
+    forEach(sqlArtifactsNotToSort, (key) => {
       sorted[remapName(key, sqlCSN, k => !k.endsWith('.hdbindex'))] = sqlArtifactsNotToSort[key];
     });
 
     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
@@ -291,10 +292,10 @@ function hdi(csn, options = {}) {
 function remapNames(dict, csn, filter) {
   const result = Object.create(null);
 
-  for (const [ key, value ] of Object.entries(dict)) {
+  forEach(dict, (key, value) => {
     const name = remapName(key, csn, filter);
     result[name] = value;
-  }
+  });
 
   return result;
 }
@@ -342,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,
@@ -396,15 +369,15 @@ function hdiMigration(csn, options, beforeImage) {
    */
   function createDefinitions() {
     const result = [];
-    for (const [ kind, artifacts ] of Object.entries(hdbkinds)) {
+    forEach(hdbkinds, (kind, artifacts) => {
       const suffix = `.${ kind }`;
-      for (const [ name, sqlStatement ] of Object.entries(artifacts)) {
+      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;
   }
   /**
@@ -414,9 +387,7 @@ function hdiMigration(csn, options, beforeImage) {
    */
   function createDeletions() {
     const result = [];
-    for (const [ name ] of Object.entries(deletions))
-      result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' });
-
+    forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
     return result;
   }
   /**
@@ -426,9 +397,7 @@ function hdiMigration(csn, options, beforeImage) {
    */
   function createMigrations() {
     const result = [];
-    for (const [ name, changeset ] of Object.entries(migrations))
-      result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset });
-
+    forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
     return result;
   }
 }
@@ -443,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;
 }
 /**
@@ -472,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;
 }
@@ -492,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 = {};
@@ -506,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;
 }
 /**
@@ -534,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;
@@ -565,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) {
@@ -576,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.
  *
@@ -586,12 +626,13 @@ function edmxall(csn, options = {}) {
  */
 function flattenResultStructure(toProcess) {
   const result = {};
-  for (const [ fileType, artifacts ] of Object.entries(toProcess)) {
+  forEach(toProcess, (fileType, artifacts) => {
     if (fileType === 'messages')
-      continue;
-    for (const filename of Object.keys(artifacts))
+      return;
+    forEach(artifacts, (filename) => {
       result[`${ filename }.${ fileType }`] = artifacts[filename];
-  }
+    });
+  });
 
   return result;
 }
@@ -608,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,
 };
 
 
@@ -641,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.