@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/api/main.js

@@ -19,6 +19,14 @@ const timetrace = lazyload('../utils/timetrace');
 const forRelationalDB = lazyload('../transform/forRelationalDB');
 const sqlUtils = lazyload('../render/utils/sql');
 const effective = lazyload('../transform/effective/main');
+const toHdbcds = lazyload('../render/toHdbcds');
+const baseError = lazyload('../base/error');
+const csnToEdm = lazyload('../edm/csn2edm');
+const trace = lazyload('./trace');
+
+const { forEach, forEachKey } = require('../utils/objectUtils');
+const { checkRemovedDeprecatedFlags } = require('../base/model');
+const { makeMessageFunction } = require('../base/messages');
 
 /**
  * Return the artifact name for use for the hdbresult object
@@ -32,13 +40,6 @@ function getFileName( artifactName, csn ) {
   return csnUtils.getResultingName(csn, 'quoted', artifactName);
 }
 
-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 { traceApi } = require('./trace');
-
 const relevantGeneralOptions = [ /* for future generic options */ ];
 const relevantOdataOptions = [ 'sqlMapping', 'odataFormat' ];
 const warnAboutMismatchOdata = [ 'odataVersion' ];
@@ -50,7 +51,7 @@ const warnAboutMismatchOdata = [ 'odataVersion' ];
  * @param {string} transformation Name of the transformation - odata or hana
  * @param {NestedOptions} options Options used for the transformation
  * @param {string[]} relevantOptionNames Option names that are defining characteristics
- * @param {string[]} [optionalOptionNames=[]] Option names that should be attached as a fyi
+ * @param {string[]} [optionalOptionNames] Option names that should be attached as a fyi
  */
 function attachTransformerCharacteristics( csn, transformation, options,
                                            relevantOptionNames, optionalOptionNames = [] ) {
@@ -86,17 +87,19 @@ function attachTransformerCharacteristics( csn, transformation, options,
  * @param {NestedOptions} options Options used for the transformation - scanned top-level
  * @param {string[]} relevantOptionNames Option names that are defining characteristics
  * @param {string[]} warnAboutMismatch Option names to warn about, but not error on
- * @param {string} module Name of the module that calls this function, e.g. `for.odata`
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  */
-function checkPreTransformedCsn( csn, options, relevantOptionNames, warnAboutMismatch, module ) {
-  if (!csn.meta) {
+function checkPreTransformedCsn( csn, options,
+                                 relevantOptionNames, warnAboutMismatch,
+                                 messageFunctions ) {
+  if (!csn.meta?.options) {
     // Not able to check
     return;
   }
-  const { error, warning, throwWithAnyError } = messages.makeMessageFunction(csn, options, module);
+  const { error, warning, throwWithAnyError } = messageFunctions;
 
   for (const name of relevantOptionNames ) {
-    if (options[name] !== csn.meta.options?.[name]) {
+    if (options[name] !== csn.meta.options[name]) {
       error('api-invalid-option-preprocessed', null, { prop: name, value: options[name], othervalue: csn.meta.options[name] },
             'Expected pre-processed CSN to have option $(PROP) set to $(VALUE). Found: $(OTHERVALUE)');
     }
@@ -130,11 +133,13 @@ function isPreTransformed( csn, transformation ) {
  *
  * @param {CSN.Model} csn Clean input CSN
  * @param {object} internalOptions processed options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} Return an oData-pre-processed CSN
  */
-function odataInternal( csn, internalOptions ) {
+function odataInternal( csn, internalOptions, messageFunctions ) {
   internalOptions.transformation = 'odata';
-  const oDataCsn = forOdataNew.transform4odataWithCsn(csn, internalOptions);
+  const oDataCsn = forOdataNew.transform4odataWithCsn(csn, internalOptions, messageFunctions);
+  messageFunctions.setModel(oDataCsn);
   attachTransformerCharacteristics(oDataCsn, 'odata', internalOptions, relevantOdataOptions, warnAboutMismatchOdata);
   return oDataCsn;
 }
@@ -143,26 +148,28 @@ function odataInternal( csn, internalOptions ) {
  * Return a odata-transformed CSN
  *
  * @param {CSN.Model} csn Clean input CSN
- * @param {ODataOptions} [options={}] Options
+ * @param {ODataOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {oDataCSN} Return an oData-pre-processed CSN
  */
-function odata( csn, options = {} ) {
-  traceApi('for.odata', options);
+function odata( csn, options, messageFunctions ) {
+  trace.traceApi('for.odata', options);
   const internalOptions = prepareOptions.for.odata(options);
-  return odataInternal(csn, internalOptions);
+  return odataInternal(csn, internalOptions, messageFunctions);
 }
 
 /**
  * Process the given csn back to cdl.
  *
  * @param {object} csn CSN to process
- * @param {object} [options={}] Options
+ * @param {object} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} { model: string, namespace: string }
  */
-function cdl( csn, options = {} ) {
-  traceApi('to.cdl', options);
+function cdl( csn, options, messageFunctions ) {
+  trace.traceApi('to.cdl', options);
   const internalOptions = prepareOptions.to.cdl(options);
-  return toCdl.csnToCdl(csn, internalOptions);
+  return toCdl.csnToCdl(csn, internalOptions, messageFunctions);
 }
 
 /**
@@ -171,13 +178,15 @@ function cdl( csn, options = {} ) {
  *
  * @param {CSN.Model} csn Plain input CSN
  * @param {SqlOptions} internalOptions Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {CSN.Model} CSN transformed like to.sql
  * @private
  */
-function csnForSql( csn, internalOptions ) {
+function csnForSql( csn, internalOptions, messageFunctions ) {
   internalOptions.transformation = 'sql';
-  const transformedCsn = forRelationalDB.transformForRelationalDBWithCsn(csn, internalOptions, 'to.sql');
-
+  const transformedCsn = forRelationalDB.transformForRelationalDBWithCsn(
+    csn, internalOptions, messageFunctions
+  );
   return internalOptions.testMode ? toCsn.sortCsn(transformedCsn, internalOptions) : transformedCsn;
 }
 
@@ -186,44 +195,48 @@ function csnForSql( csn, internalOptions ) {
  * Pseudo-public version of csnForSql().
  *
  * @param {CSN.Model} csn Plain input CSN
- * @param {SqlOptions} [options={}] Options
+ * @param {SqlOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {CSN.Model} CSN transformed like to.sql
  * @private
  */
-function forSql( csn, options = {} ) {
+function forSql( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.sql(options);
-  return csnForSql(csn, internalOptions);
+  return csnForSql(csn, internalOptions, messageFunctions);
 }
 
 /**
  * Transform a CSN like to.hdi
  *
  * @param {CSN.Model} csn Plain input CSN
- * @param {HdiOptions} [options={}] Options
+ * @param {HdiOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {CSN.Model} CSN transformed like to.hdi
  * @private
  */
-function forHdi( csn, options = {} ) {
+function forHdi( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.hdi(options);
   internalOptions.transformation = 'sql';
-  const transformedCsn = forRelationalDB.transformForRelationalDBWithCsn(csn, internalOptions, 'to.hdi');
-
+  const transformedCsn = forRelationalDB.transformForRelationalDBWithCsn(
+    csn, internalOptions, messageFunctions
+  );
   return internalOptions.testMode ? toCsn.sortCsn(transformedCsn, internalOptions) : transformedCsn;
 }
 /**
  * Transform a CSN like to.hdbcds
  *
  * @param {CSN.Model} csn Plain input CSN
- * @param {HdbcdsOptions} [options={}] Options
+ * @param {HdbcdsOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {CSN.Model} CSN transformed like to.hdbcds
  * @private
  */
-function forHdbcds( csn, options = {} ) {
+function forHdbcds( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
-
-  const hanaCsn = forRelationalDB.transformForRelationalDBWithCsn(csn, internalOptions, 'to.hdbcds');
-
+  const hanaCsn = forRelationalDB.transformForRelationalDBWithCsn(
+    csn, internalOptions, messageFunctions
+  );
   return internalOptions.testMode ? toCsn.sortCsn(hanaCsn, internalOptions) : hanaCsn;
 }
 
@@ -231,16 +244,16 @@ function forHdbcds( csn, options = {} ) {
  * Effective CSN transformation
  *
  * @param {CSN.Model} csn Plain input CSN
- * @param {EffectiveCsnOptions} [options={}] Options
+ * @param {EffectiveCsnOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {CSN.Model} CSN transformed
  * @private
  */
-function forEffective( csn, options = {} ) {
+function forEffective( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.sql(options);
   internalOptions.transformation = 'effective';
 
-  const eCsn = effective.effectiveCsn(csn, internalOptions);
-
+  const eCsn = effective.effectiveCsn(csn, internalOptions, messageFunctions);
   return internalOptions.testMode ? toCsn.sortCsn(eCsn, internalOptions) : eCsn;
 }
 
@@ -248,17 +261,19 @@ function forEffective( csn, options = {} ) {
  * Process the given CSN into SQL.
  *
  * @param {CSN.Model} csn A clean input CSN
- * @param {SqlOptions} [options={}] Options
+ * @param {SqlOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {SQL[]} Array of SQL statements, tables first, views second
  */
-function sql( csn, options = {} ) {
-  traceApi('to.sql', options);
+function sql( csn, options, messageFunctions ) {
+  trace.traceApi('to.sql', options);
   const internalOptions = prepareOptions.to.sql(options);
   internalOptions.transformation = 'sql';
 
   // we need the CSN for view sorting
-  const transformedCsn = csnForSql(csn, internalOptions);
-  const sqls = toSql.toSqlDdl(transformedCsn, internalOptions);
+  const transformedCsn = csnForSql(csn, internalOptions, messageFunctions);
+  messageFunctions.setModel(transformedCsn);
+  const sqls = toSql.toSqlDdl(transformedCsn, internalOptions, messageFunctions);
 
   const result = sortViews({ csn: transformedCsn, sql: sqls.sql });
   return [
@@ -271,16 +286,18 @@ function sql( csn, options = {} ) {
  * Process the given CSN into HDI artifacts.
  *
  * @param {CSN.Model} csn A clean input CSN
- * @param {HdiOptions} [options={}] Options
+ * @param {HdiOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {HDIArtifacts} { <filename>:<content>, ...}
  */
-function hdi( csn, options = {} ) {
-  traceApi('to.hdi', options);
+function hdi( csn, options, messageFunctions ) {
+  trace.traceApi('to.hdi', options);
   const internalOptions = prepareOptions.to.hdi(options);
 
   // we need the CSN for view sorting
-  const sqlCSN = forHdi(csn, options);
-  const sqls = toSql.toSqlDdl(sqlCSN, internalOptions);
+  const sqlCSN = forHdi(csn, options, messageFunctions);
+  messageFunctions.setModel(sqlCSN);
+  const sqls = toSql.toSqlDdl(sqlCSN, internalOptions, messageFunctions);
 
   if (internalOptions.testMode) {
     // All this mapping is needed because sortViews crossmatches
@@ -370,6 +387,7 @@ function remapName( key, csn, filter = () => true ) {
  *
  * @param {CSN.Model}  csn          A clean input CSN representing the desired "after-image"
  * @param {HdiOptions} options      Options
+ * @param {object}     messageFunctions Message functions such as `error()`, `info()`, …
  * @param {CSN.Model}  beforeImage  A db-transformed CSN representing the "before-image", or null in case no such image
  *                                  is known, i.e. for the very first migration step.
  * @returns {object}                An object with three properties:
@@ -377,27 +395,23 @@ function remapName( key, csn, filter = () => true ) {
  *                                  - drops: An array of SQL statements to drop views/tables
  *                                  - createsAndAlters: An array of SQL statements to ALTER/CREATE tables/views
  */
-function sqlMigration( csn, options, beforeImage ) {
-  traceApi('to.sql.migration', options);
+function sqlMigration( csn, options, messageFunctions, beforeImage ) {
+  trace.traceApi('to.sql.migration', options);
   const internalOptions = prepareOptions.to.sql(options);
-  const {
-    error, warning, info, throwWithError, message,
-  } = messages.makeMessageFunction(csn, internalOptions, 'to.sql.migration');
+  const { error, throwWithError } = messageFunctions;
 
   // Prepare after-image.
-  const afterImage = internalOptions.filterCsn
-    ? diffFilter.csn(csnForSql(csn, internalOptions)) : csnForSql(csn, internalOptions);
+  let afterImage = csnForSql(csn, internalOptions, messageFunctions);
+  if (internalOptions.filterCsn)
+    afterImage = diffFilter.csn(afterImage);
   // Compare both images.
   const diff = modelCompare.compareModels(beforeImage || afterImage, afterImage, internalOptions);
+  messageFunctions.setModel(diff);
   const diffFilterObj = diffFilter[internalOptions.sqlDialect];
 
   if (diffFilterObj) {
-    diff.extensions = diff.extensions.filter(ex => diffFilterObj.extension(ex, {
-      error, warning, info, throwWithError, message,
-    }));
-    diff.migrations.forEach(migration => diffFilterObj.migration(migration, {
-      error, warning, info, throwWithError, message,
-    }));
+    diff.extensions = diff.extensions.filter(ex => diffFilterObj.extension(ex, messageFunctions));
+    diff.migrations.forEach(migration => diffFilterObj.migration(migration, messageFunctions));
     Object.entries(diff.deletions).forEach(entry => diffFilterObj.deletion(entry, error));
     diff.changedPrimaryKeys = diff.changedPrimaryKeys
       .filter(an => diffFilterObj.changedPrimaryKeys(an));
@@ -475,7 +489,7 @@ function sqlMigration( csn, options, beforeImage ) {
   const {
     // eslint-disable-next-line no-unused-vars
     deletions, constraintDeletions, migrations, constraints, ...hdbkinds
-  } = toSql.toSqlDdl(diff, internalOptions);
+  } = toSql.toSqlDdl(diff, internalOptions, messageFunctions);
 
   cleanup.forEach(fn => fn());
   // TODO: Handle `ADD CONSTRAINT` etc!
@@ -528,18 +542,20 @@ function sqlMigration( csn, options, beforeImage ) {
  *
  * @param {CSN.Model}  csn          A clean input CSN representing the desired "after-image"
  * @param {HdiOptions} options      Options
+ * @param {object}     messageFunctions Message functions such as `error()`, `info()`, …
  * @param {CSN.Model}  beforeImage  A HANA-transformed CSN representing the "before-image", or null in case no such image
  *                                  is known, i.e. for the very first migration step
  * @returns {migration} The migration result
  */
-function hdiMigration( csn, options, beforeImage ) {
-  traceApi('to.hdi.migration', options);
+function hdiMigration( csn, options, messageFunctions, beforeImage ) {
+  trace.traceApi('to.hdi.migration', options);
   const internalOptions = prepareOptions.to.hdi(options);
 
   // Prepare after-image.
-  const afterImage = forHdi(csn, options);
+  const afterImage = forHdi(csn, options, messageFunctions);
 
   const diff = modelCompare.compareModels(beforeImage || afterImage, afterImage, internalOptions);
+  messageFunctions.setModel(diff);
 
   // Convert the diff to SQL.
   if (!internalOptions.beta)
@@ -551,7 +567,7 @@ function hdiMigration( csn, options, beforeImage ) {
   const {
     // eslint-disable-next-line no-unused-vars
     deletions, migrations, constraintDeletions, ...hdbkinds
-  } = toSql.toSqlDdl(diff, internalOptions);
+  } = toSql.toSqlDdl(diff, internalOptions, messageFunctions);
 
   return {
     afterImage,
@@ -614,29 +630,31 @@ sql.migration = sqlMigration;
  * Process the given CSN into HDBCDS artifacts.
  *
  * @param {any} csn A clean input CSN
- * @param {HdbcdsOptions} [options={}] Options
+ * @param {HdbcdsOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {HDBCDS} { <filename>:<content>, ...}
  */
-function hdbcds( csn, options = {} ) {
-  traceApi('to.hdbcds', options);
+function hdbcds( csn, options, messageFunctions ) {
+  trace.traceApi('to.hdbcds', options);
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
 
-  const hanaCsn = forHdbcds(csn, internalOptions);
-
-  const result = flattenResultStructure(toHdbcdsSource(hanaCsn, internalOptions));
-  return result;
+  const hanaCsn = forHdbcds(csn, internalOptions, messageFunctions);
+  messageFunctions.setModel(hanaCsn);
+  const result = toHdbcds.toHdbcdsSource(hanaCsn, internalOptions, messageFunctions);
+  return flattenResultStructure(result);
 }
 /**
- * Generate a edm document for the given service
+ * Generate an 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
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {edm} The JSON representation of the service
  */
-function edm( csn, options = {} ) {
-  traceApi('to.edm', options);
-  // If not provided at all, set service to undefined to trigger validation
+function edm( csn, options, messageFunctions ) {
+  trace.traceApi('to.edm', options);
+  // If not provided at all, set service to 'undefined' to trigger validation
   const internalOptions = prepareOptions.to.edm(
     // eslint-disable-next-line comma-dangle
     options.service ? options : Object.assign({ service: undefined }, options)
@@ -646,12 +664,14 @@ function edm( csn, options = {} ) {
 
   let servicesEdmj;
   if (isPreTransformed(csn, 'odata')) {
-    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions, warnAboutMismatchOdata, 'for.odata');
-    servicesEdmj = preparedCsnToEdm(csn, service, internalOptions);
+    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions,
+                           warnAboutMismatchOdata, messageFunctions);
+    servicesEdmj = preparedCsnToEdm(csn, service, internalOptions, messageFunctions);
   }
   else {
-    const oDataCsn = odataInternal(csn, internalOptions);
-    servicesEdmj = preparedCsnToEdm(oDataCsn, service, internalOptions);
+    const oDataCsn = odataInternal(csn, internalOptions, messageFunctions);
+    messageFunctions.setModel(oDataCsn);
+    servicesEdmj = preparedCsnToEdm(oDataCsn, service, internalOptions, messageFunctions);
   }
   return servicesEdmj.edmj;
 }
@@ -662,13 +682,14 @@ 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
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {edms} { <service>:<JSON representation>, ...}
  */
-function edmall( csn, options = {} ) {
-  traceApi('to.edm.all', options);
+function edmall( csn, options, messageFunctions ) {
+  trace.traceApi('to.edm.all', options);
   const internalOptions = prepareOptions.to.edm(options);
-  const { error } = messages.makeMessageFunction(csn, internalOptions, 'for.odata');
+  const { error } = messageFunctions;
 
   if (internalOptions.odataVersion === 'v2')
     error(null, null, {}, 'OData JSON output is not available for OData V2');
@@ -676,13 +697,16 @@ function edmall( csn, options = {} ) {
   const result = {};
   let oDataCsn = csn;
 
-  if (isPreTransformed(csn, 'odata'))
-    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions, warnAboutMismatchOdata, 'for.odata');
-
-  else
-    oDataCsn = odataInternal(csn, internalOptions);
+  if (isPreTransformed(csn, 'odata')) {
+    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions,
+                           warnAboutMismatchOdata, messageFunctions);
+  }
+  else {
+    oDataCsn = odataInternal(csn, internalOptions, messageFunctions);
+  }
 
-  const servicesJson = preparedCsnToEdmAll(oDataCsn, internalOptions);
+  messageFunctions.setModel(oDataCsn);
+  const servicesJson = preparedCsnToEdmAll(oDataCsn, internalOptions, messageFunctions);
   const services = servicesJson.edmj;
   for (const serviceName in services)
     result[serviceName] = services[serviceName];
@@ -690,15 +714,16 @@ function edmall( csn, options = {} ) {
   return result;
 }
 /**
- * Generate a edmx document for the given service
+ * Generate an 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
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {edmx} The XML representation of the service
  */
-function edmx( csn, options = {} ) {
-  traceApi('to.edmx', options);
-  // If not provided at all, set service to undefined to trigger validation
+function edmx( csn, options, messageFunctions ) {
+  trace.traceApi('to.edmx', options);
+  // If not provided at all, set service to 'undefined' to trigger validation
   const internalOptions = prepareOptions.to.edmx(
     // eslint-disable-next-line comma-dangle
     options.service ? options : Object.assign({ service: undefined }, options)
@@ -708,12 +733,14 @@ function edmx( csn, options = {} ) {
 
   let services;
   if (isPreTransformed(csn, 'odata')) {
-    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions, warnAboutMismatchOdata, 'for.odata');
-    services = preparedCsnToEdmx(csn, service, internalOptions);
+    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions,
+                           warnAboutMismatchOdata, messageFunctions);
+    services = preparedCsnToEdmx(csn, service, internalOptions, messageFunctions);
   }
   else {
-    const oDataCsn = odataInternal(csn, internalOptions);
-    services = preparedCsnToEdmx(oDataCsn, service, internalOptions);
+    const oDataCsn = odataInternal(csn, internalOptions, messageFunctions);
+    messageFunctions.setModel(oDataCsn);
+    services = preparedCsnToEdmx(oDataCsn, service, internalOptions, messageFunctions);
   }
 
   return services.edmx;
@@ -725,23 +752,27 @@ 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
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {edmxs} { <service>:<XML representation>, ...}
  */
-function edmxall( csn, options = {} ) {
-  traceApi('to.edmx.all', options);
+function edmxall( csn, options, messageFunctions ) {
+  trace.traceApi('to.edmx.all', options);
   const internalOptions = prepareOptions.to.edmx(options);
 
   const result = {};
   let oDataCsn = csn;
 
-  if (isPreTransformed(csn, 'odata'))
-    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions, warnAboutMismatchOdata, 'for.odata');
-
-  else
-    oDataCsn = odataInternal(csn, internalOptions);
+  if (isPreTransformed(csn, 'odata')) {
+    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions,
+                           warnAboutMismatchOdata, messageFunctions);
+  }
+  else {
+    oDataCsn = odataInternal(csn, internalOptions, messageFunctions);
+  }
 
-  const servicesEdmx = preparedCsnToEdmxAll(oDataCsn, internalOptions);
+  messageFunctions.setModel(oDataCsn);
+  const servicesEdmx = preparedCsnToEdmxAll(oDataCsn, internalOptions, messageFunctions);
   const services = servicesEdmx.edmx;
   // Create annotations and metadata once per service
   for (const serviceName in services) {
@@ -752,6 +783,97 @@ function edmxall( csn, options = {} ) {
   return result;
 }
 
+/**
+ * Generate an EDM document for the given service in XML and JSON representation
+ * If odataVersion is not 'v4', then no JSON is rendered
+ *
+ * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
+ * @param {ODataOptions} [options={}] Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {object} { <protocol> : { <ServiceName>: { edmx: <XML representation>, edm: <JSON representation> } } }
+ */
+// @ts-ignore
+function odata2( csn, options = {}, messageFunctions ) {
+  trace.traceApi('to.odata', options);
+  // If not provided at all, set service to undefined to trigger validation
+  const internalOptions = prepareOptions.to.odata(
+    // eslint-disable-next-line comma-dangle
+    options.service ? options : Object.assign({ service: undefined }, options)
+  );
+
+  const { service } = options;
+
+  let oDataCsn = csn;
+  if (isPreTransformed(csn, 'odata')) {
+    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions,
+                           warnAboutMismatchOdata, messageFunctions);
+  }
+  else {
+    oDataCsn = odataInternal(csn, internalOptions, messageFunctions);
+    messageFunctions.setModel(oDataCsn);
+  }
+
+  const edmIR = csnToEdm.csn2edm(oDataCsn, service, internalOptions, messageFunctions);
+
+
+  const version = internalOptions.odataVersion;
+  const result = { [version]: { [service]: {} } };
+
+  if (edmIR) {
+    result[version][service].edmx = edmIR.toXML();
+    if (version === 'v4')
+      result[version][service].edm = edmIR.toJSON();
+  }
+  return result;
+}
+
+odata2.all = odataall;
+
+/**
+ * Generate EDM documents for all services in XML and JSON representation
+ * If odataVersion is not 'v4', then no JSON is rendered
+ *
+ * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
+ * @param {ODataOptions} [options={}] Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {object} { <protocol>: { <serviceName>: { edmx: <XML representation>, edm: <JSON representation> } } }
+ */
+// @ts-ignore
+function odataall( csn, options = {}, messageFunctions ) {
+  trace.traceApi('to.odata.all', options);
+  const internalOptions = prepareOptions.to.odata(options);
+  const { error } = messageFunctions;
+
+  if (internalOptions.odataVersion === 'v2')
+    error(null, null, {}, 'OData JSON output is not available for OData V2');
+
+  let oDataCsn = csn;
+  if (isPreTransformed(csn, 'odata')) {
+    checkPreTransformedCsn(csn, internalOptions, relevantOdataOptions,
+                           warnAboutMismatchOdata, messageFunctions);
+  }
+  else {
+    oDataCsn = odataInternal(csn, internalOptions, messageFunctions);
+    messageFunctions.setModel(oDataCsn);
+  }
+
+  const edmIR = csnToEdm.csn2edmAll(oDataCsn, internalOptions, undefined, messageFunctions);
+
+  const version = internalOptions.odataVersion;
+
+  const result = {};
+  result[version] = {};
+
+  if (edmIR) {
+    for (const serviceName in edmIR) {
+      result[version][serviceName] = { edmx: edmIR[serviceName].toXML() };
+      if (internalOptions.odataVersion === 'v4')
+        result[version][serviceName].edm = edmIR[serviceName].toJSON();
+    }
+  }
+  return result;
+}
+
 /**
  * Generate edmx for given 'service' based on 'csn' (new-style compact, already prepared for OData)
  * using 'options'
@@ -759,11 +881,12 @@ function edmxall( csn, 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.
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} Rendered EDMX string for the given service.
  */
-function preparedCsnToEdmx( csn, service, options ) {
+function preparedCsnToEdmx( csn, service, options, messageFunctions ) {
   timetrace.timetrace.start('EDMX rendering');
-  const e = csn2edm(csn, service, options)?.toXML('all');
+  const e = csnToEdm.csn2edm(csn, service, options, messageFunctions)?.toXML('all');
   timetrace.timetrace.stop('EDMX rendering');
   return { edmx: e };
 }
@@ -774,11 +897,12 @@ function preparedCsnToEdmx( csn, service, options ) {
  *
  * @param {CSN.Model} csn Input CSN model. Must be OData transformed CSN.
  * @param {ODataOptions} options OData / EDMX specific options.
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} Dictionary of rendered EDMX strings for each service.
  */
-function preparedCsnToEdmxAll( csn, options ) {
+function preparedCsnToEdmxAll( csn, options, messageFunctions ) {
   timetrace.timetrace.start('EDMX all rendering');
-  const edmxResult = csn2edmAll(csn, options);
+  const edmxResult = csnToEdm.csn2edmAll(csn, options, undefined, messageFunctions);
   for (const service in edmxResult)
     edmxResult[service] = edmxResult[service].toXML('all');
   timetrace.timetrace.stop('EDMX all rendering');
@@ -792,13 +916,14 @@ function preparedCsnToEdmxAll( csn, 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.
+ * @param {object} [messageFunctions] Message functions such as `error()`, `info()`, …
  * @returns {object} Rendered EDM JSON object for of the given service.
  */
-function preparedCsnToEdm( csn, service, options ) {
+function preparedCsnToEdm( csn, service, options, messageFunctions ) {
   timetrace.timetrace.start('EDM rendering');
   // Override OData version as edm json is always v4
   options.odataVersion = 'v4';
-  const e = csn2edm(csn, service, options)?.toJSON();
+  const e = csnToEdm.csn2edm(csn, service, options, messageFunctions)?.toJSON();
   timetrace.timetrace.stop('EDM rendering');
   return { edmj: e };
 }
@@ -809,13 +934,14 @@ function preparedCsnToEdm( csn, service, options ) {
  *
  * @param {CSN.Model} csn Input CSN model. Must be OData transformed CSN.
  * @param {ODataOptions} options OData / EDMX specific options.
+ * @param {object} [messageFunctions] Message functions such as `error()`, `info()`, …
  * @returns {object} Dictionary of rendered EDM JSON objects for each service.
  */
-function preparedCsnToEdmAll( csn, options ) {
+function preparedCsnToEdmAll( csn, options, messageFunctions ) {
   timetrace.timetrace.start('EDM all rendering');
   // Override OData version as edm json is always v4
   options.odataVersion = 'v4';
-  const edmj = csn2edmAll(csn, options);
+  const edmj = csnToEdm.csn2edmAll(csn, options, undefined, messageFunctions);
   for (const service in edmj)
     edmj[service] = edmj[service].toJSON();
   timetrace.timetrace.stop('EDM all rendering');
@@ -855,14 +981,21 @@ module.exports = {
   hdbcds: publishCsnProcessor(hdbcds, 'to.hdbcds'),
   edm: publishCsnProcessor(edm, 'to.edm'),
   edmx: publishCsnProcessor(edmx, 'to.edmx'),
+  odata2: publishCsnProcessor(odata2, 'to.odata'),
   /** Internal only */
   for_sql: publishCsnProcessor(forSql, 'for.sql'),
   for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
   for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
   for_effective: publishCsnProcessor(forEffective, 'for.effective'),
-  /** Deprecated, will be removed in cds-compiler@v4 */
-  preparedCsnToEdmx,
-  preparedCsnToEdm,
+
+  /* Deprecated, will be removed in cds-compiler@v5 */ // TODO(v5): Remove
+  preparedCsnToEdmx(csn, service, options) {
+    preparedCsnToEdmx(csn, service, options, makeMessageFunction( csn, options, 'to.edmx' ));
+  },
+  /* Deprecated, will be removed in cds-compiler@v5 */ // TODO(v5): Remove
+  preparedCsnToEdm(csn, service, options) {
+    preparedCsnToEdm(csn, service, options, makeMessageFunction( csn, options, 'to.edm' ));
+  },
 };
 
 
@@ -891,18 +1024,19 @@ function publishCsnProcessor( processor, _name ) {
    * @returns {any} What ever the processor returns
    */
   function api( csn, options = {}, ...args ) {
+    const originalMessageLength = options.messages?.length;
     try {
-      const messageFunctions = messages.makeMessageFunction(csn, options, 'api');
+      const messageFunctions = messages.makeMessageFunction(csn, options, _name);
       if (options.deprecated)
         checkRemovedDeprecatedFlags( options, messageFunctions );
 
       checkOutdatedOptions( options, messageFunctions );
-      checkCsnFlavor( csn, options, messageFunctions, _name );
-
+      csn = ensureClientCsn( csn, options, messageFunctions, _name );
       messageFunctions.throwWithError();
+      messageFunctions.setModel(csn);
 
       timetrace.timetrace.start(_name);
-      const result = processor( csn, options, ...args );
+      const result = processor( csn, options, messageFunctions, ...args );
       timetrace.timetrace.stop(_name);
       return result;
     }
@@ -912,20 +1046,27 @@ function publishCsnProcessor( processor, _name ) {
         throw err;
 
       if (options.testMode && !(err instanceof TypeError) &&
-        !(err instanceof ModelError))
+        !(err instanceof baseError.ModelError))
         throw err;
 
-      const { info } = messages.makeMessageFunction( csn, options, 'compile' );
-      const msg = info( 'api-recompiled-csn', location.emptyLocation('csn.json'), {}, 'CSN input had to be recompiled' );
+      // Reset messages to what we had before the backend crashed.
+      // Backends may report the same issues again after compilation.
+      if (originalMessageLength !== undefined)
+        options.messages.length = originalMessageLength;
+
+      const messageFunctions = messages.makeMessageFunction( csn, options, _name );
+      const recompileMsg = messageFunctions.info( 'api-recompiled-csn', location.emptyLocation('csn.json'), {},
+                                                  'CSN input had to be recompiled' );
       if (options.internalMsg || options.testMode)
-        msg.error = err; // Attach original error;
+        recompileMsg.error = err; // Attach original error;
       if (options.testMode)  // Attach recompilation reason in testMode
-        msg.message += `\n   ↳ cause: ${ err.message }`;
+        recompileMsg.message += `\n   ↳ cause: ${ err.message }`;
 
       // next line to be replaced by CSN parser call which reads the CSN object
       const xsn = compiler.recompileX(csn, options);
       const recompiledCsn = toCsn.compactModel(xsn);
-      return processor( recompiledCsn, options, ...args );
+      messageFunctions.setModel(recompiledCsn);
+      return processor( recompiledCsn, options, messageFunctions, ...args );
     }
   }
 }
@@ -946,7 +1087,6 @@ function checkOutdatedOptions( options, messageFunctions ) {
   if (options.messages?.some(m => m.messageId === 'api-invalid-option' || m.messageId === 'api-invalid-variable-replacement'))
     return;
 
-
   for (const name of oldBackendOptionNames) {
     if (typeof options[name] === 'object') // may be a boolean due to internal options
       messageFunctions.error('api-invalid-option', null, { '#': 'deprecated', name });
@@ -981,6 +1121,12 @@ function checkOutdatedOptions( options, messageFunctions ) {
  * Checks that the given CSN is usable by our backends, e.g. that
  * the CSN is not a gensrc (a.k.a. xtended) for most backends.
  *
+ * Returns the input CSN if it is acceptable or compiles the input CSN if it does not
+ * have the expected CSN flavor.
+ *
+ * The compiler does not set any marker in `meta`; we use the umbrella one
+ * for easier debugging.
+ *
  * For reference, cds-compiler/cds-dk CSN flavor map:
  *  - client -> inferred
  *  - gensrc -> xtended
@@ -989,23 +1135,39 @@ function checkOutdatedOptions( options, messageFunctions ) {
  * If this function becomes more complex (e.g. more module conditions),
  * move it from then generic api wrapper to the individual module.
  *
- * TODO: The compiler does not set any marker in `meta`; we use the umbrella one
- *       for easier debugging.
- *
  * @param {CSN.Model} csn User CSN
  * @param {CSN.Options} options User options
  * @param {object} messageFunctions Functions returned by makeMessageFunction()
  * @param {string} module Backend module, e.g. to.cdl or to.sql
+ * @returns {CSN.Model} CSN that works for backends.
  */
-function checkCsnFlavor( csn, options, messageFunctions, module ) {
+function ensureClientCsn( csn, options, messageFunctions, module ) {
   if (module === 'to.cdl' || !csn)
-    return; // to.cdl allows every CSN flavor
+    return csn; // to.cdl allows every CSN flavor
 
   if (csn.meta?.flavor === 'xtended') {
-    // TODO: csn.meta?.flavor === 'parsed'; currently used by `@sap/cds` tests.
-    messageFunctions.error('api-unsupported-csn-flavor', null, { name: module, option: csn.meta?.flavor },
-                           'Module $(NAME) expects a client/inferred CSN, not $(OPTION)');
+    messageFunctions.error('api-unsupported-csn-flavor', null, { name: module, option: csn.meta?.flavor });
+    return csn;
   }
+
+  // `parsed` CSN is allowed if it can be compiled (i.e. no `requires`).
+  // Still return false, because it's not client CSN. The caller must handle it.
+  if (csn.meta?.flavor === 'parsed') {
+    if (csn.requires?.length > 0) {
+      messageFunctions.error('api-unsupported-csn-flavor', null, {
+        '#': 'parsed-requires',
+        name: module,
+        prop: 'requires',
+      });
+      return csn;
+    }
+
+    // TODO: next line to be replaced by CSN parser call which reads the CSN object once the two API files are merged.
+    const xsn = compiler.recompileX(csn, options);
+    return toCsn.compactModel(xsn);
+  }
+
+  return csn;
 }
 
 /**