@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/api/main.js

@@ -9,6 +9,8 @@ const messages = lazyload('../base/messages');
 const compiler = lazyload('../compiler/index');
 const toCsn = lazyload('../json/to-csn');
 const forOdataNew = lazyload('../transform/forOdata.js');
+const generateDrafts = lazyload('../transform/draft/odata');
+const tenant = lazyload('../transform/addTenantFields');
 const toSql = lazyload('../render/toSql');
 const toCdl = require('../render/toCdl');
 const modelCompare = lazyload('../modelCompare/compare');
@@ -24,10 +26,7 @@ const baseError = lazyload('../base/error');
 const csnToEdm = lazyload('../edm/csn2edm');
 const trace = lazyload('./trace');
 const cloneCsn = lazyload('../model/cloneCsn');
-
-const { forEach, forEachKey } = require('../utils/objectUtils');
-const { makeMessageFunction } = require('../base/messages');
-const { sortCsnForTests } = require('../model/cloneCsn');
+const objectUtils = lazyload('../utils/objectUtils');
 
 /**
  * Return the artifact name for use for the hdbresult object
@@ -57,18 +56,18 @@ const warnAboutMismatchOdata = [ 'odataVersion' ];
 function attachTransformerCharacteristics( csn, transformation, options,
                                            relevantOptionNames, optionalOptionNames = [] ) {
   const relevant = {};
-  for (const name of relevantOptionNames ) {
+  for (const name of relevantOptionNames) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
 
-  for (const name of optionalOptionNames ) {
+  for (const name of optionalOptionNames) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
 
   // eslint-disable-next-line sonarjs/no-empty-collection
-  for (const name of relevantGeneralOptions ) {
+  for (const name of relevantGeneralOptions) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
@@ -140,7 +139,7 @@ function isPreTransformed( csn, transformation ) {
 function odataInternal( csn, internalOptions, messageFunctions ) {
   internalOptions.transformation = 'odata';
   let oDataCsn = forOdataNew.transform4odataWithCsn(csn, internalOptions, messageFunctions);
-  oDataCsn = sortCsnForTests(oDataCsn, internalOptions);
+  oDataCsn = cloneCsn.sortCsnForTests(oDataCsn, internalOptions);
   messageFunctions.setModel(oDataCsn);
   attachTransformerCharacteristics(oDataCsn, 'odata', internalOptions, relevantOdataOptions, warnAboutMismatchOdata);
   return oDataCsn;
@@ -155,11 +154,32 @@ function odataInternal( csn, internalOptions, messageFunctions ) {
  * @returns {oDataCSN} Return an oData-pre-processed CSN
  */
 function odata( csn, options, messageFunctions ) {
-  trace.traceApi('for.odata', options);
   const internalOptions = prepareOptions.for.odata(options);
+  messageFunctions.setOptions( internalOptions );
   return odataInternal(csn, internalOptions, messageFunctions);
 }
 
+/**
+ * Return a structured CSN for the Java Runtime: with drafts and tenant support
+ *
+ * @param {CSN.Model} csn Clean input CSN
+ * @param {ODataOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {CSN.Model} a CSN for the Java Runtime
+ */
+function java( csn, options, messageFunctions ) {
+  const internalOptions = prepareOptions.for.java(options);
+  internalOptions.transformation = 'odata'; // otherwise generateDrafts adds tenant
+  messageFunctions.setOptions( internalOptions );
+  handleTenantDiscriminator(options, internalOptions, messageFunctions);
+
+  const clone = cloneCsn.cloneFullCsn(csn, internalOptions);
+  const draft = generateDrafts(clone, internalOptions, undefined, messageFunctions);
+  if (internalOptions.tenantDiscriminator)
+    tenant.addTenantFields(draft, internalOptions, messageFunctions );
+  return draft;
+}
+
 /**
  * Process the given csn back to cdl.
  *
@@ -169,8 +189,8 @@ function odata( csn, options, messageFunctions ) {
  * @returns {object} { model: string, namespace: string }
  */
 function cdl( csn, options, messageFunctions ) {
-  trace.traceApi('to.cdl', options);
   const internalOptions = prepareOptions.to.cdl(options);
+  messageFunctions.setOptions( internalOptions );
   return toCdl.csnToCdl(csn, internalOptions, messageFunctions);
 }
 
@@ -204,6 +224,7 @@ function csnForSql( csn, internalOptions, messageFunctions ) {
  */
 function forSql( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.sql(options);
+  messageFunctions.setOptions( internalOptions );
   return csnForSql(csn, internalOptions, messageFunctions); // already sorted for test mode
 }
 
@@ -219,6 +240,7 @@ function forSql( csn, options, messageFunctions ) {
 function forHdi( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.hdi(options);
   internalOptions.transformation = 'sql';
+  messageFunctions.setOptions( internalOptions );
   const transformedCsn = forRelationalDB.transformForRelationalDBWithCsn(
     csn, internalOptions, messageFunctions
   );
@@ -236,6 +258,7 @@ function forHdi( csn, options, messageFunctions ) {
 function forHdbcds( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
+  messageFunctions.setOptions( internalOptions );
   const hanaCsn = forRelationalDB.transformForRelationalDBWithCsn(
     csn, internalOptions, messageFunctions
   );
@@ -247,13 +270,13 @@ function forHdbcds( csn, options, messageFunctions ) {
  *
  * @param {CSN.Model} csn Plain input CSN
  * @param {EffectiveCsnOptions} options Options
+ * @param {EffectiveCsnOptions} internalOptions Options that were already processed
  * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {CSN.Model} CSN transformed
  * @private
  */
-function forEffective( csn, options, messageFunctions ) {
-  const internalOptions = prepareOptions.to.sql(options);
-  internalOptions.transformation = 'effective';
+function forEffectiveInternal( csn, options, internalOptions, messageFunctions ) {
+  messageFunctions.setOptions( internalOptions );
   if (options.tenantDiscriminator) {
     messageFunctions.error('api-invalid-option', null, {
       '#': 'forbidden',
@@ -267,6 +290,40 @@ function forEffective( csn, options, messageFunctions ) {
   return cloneCsn.sortCsnForTests(eCsn, internalOptions);
 }
 
+/**
+ * SEAL CSN transformation
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {EffectiveCsnOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {CSN.Model} CSN transformed
+ * @private
+ */
+function forSeal( csn, options, messageFunctions ) {
+  const internalOptions = prepareOptions.for.seal(options);
+  internalOptions.transformation = 'effective';
+  return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+}
+
+/**
+ * Effective CSN transformation
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {EffectiveCsnOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {CSN.Model} CSN transformed
+ * @private
+ */
+function forEffective( csn, options, messageFunctions ) {
+  const internalOptions = prepareOptions.for.effective(options);
+  internalOptions.transformation = 'effective';
+  // for.effective is still beta mode
+  if (!baseModel.isBetaEnabled(options, 'effectiveCsn'))
+    throw new baseError.CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
+
+  return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+}
+
 /**
  * Process the given CSN into SQL.
  *
@@ -276,9 +333,9 @@ function forEffective( csn, options, messageFunctions ) {
  * @returns {SQL[]} Array of SQL statements, tables first, views second
  */
 function sql( csn, options, messageFunctions ) {
-  trace.traceApi('to.sql', options);
   const internalOptions = prepareOptions.to.sql(options);
   internalOptions.transformation = 'sql';
+  messageFunctions.setOptions( internalOptions );
 
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
 
@@ -303,8 +360,8 @@ function sql( csn, options, messageFunctions ) {
  * @returns {HDIArtifacts} { <filename>:<content>, ...}
  */
 function hdi( csn, options, messageFunctions ) {
-  trace.traceApi('to.hdi', options);
   const internalOptions = prepareOptions.to.hdi(options);
+  messageFunctions.setOptions( internalOptions );
 
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
 
@@ -325,7 +382,7 @@ function hdi( csn, options, messageFunctions ) {
     const sqlArtifactsWithCSNNamesToSort = Object.create(null);
     const sqlArtifactsNotToSort = Object.create(null);
 
-    forEach(flat, (key) => {
+    objectUtils.forEach(flat, (key) => {
       const artifactNameLikeInCsn = key.replace(/\.[^/.]+$/, '');
       nameMapping[artifactNameLikeInCsn] = key;
       if (key.endsWith('.hdbtable') || key.endsWith('.hdbview'))
@@ -343,7 +400,7 @@ function hdi( csn, options, messageFunctions ) {
       }, Object.create(null));
 
     // now add the not-sorted stuff, like indices
-    forEach(sqlArtifactsNotToSort, (key) => {
+    objectUtils.forEach(sqlArtifactsNotToSort, (key) => {
       sorted[remapName(key, sqlCSN, k => !k.endsWith('.hdbindex'))] = sqlArtifactsNotToSort[key];
     });
 
@@ -365,7 +422,7 @@ function hdi( csn, options, messageFunctions ) {
 function remapNames( dict, csn, filter ) {
   const result = Object.create(null);
 
-  forEach(dict, (key, value) => {
+  objectUtils.forEach(dict, (key, value) => {
     const name = remapName(key, csn, filter);
     result[name] = value;
   });
@@ -410,8 +467,8 @@ function remapName( key, csn, filter = () => true ) {
  *                                  - createsAndAlters: An array of SQL statements to ALTER/CREATE tables/views
  */
 function sqlMigration( csn, options, messageFunctions, beforeImage ) {
-  trace.traceApi('to.sql.migration', options);
   const internalOptions = prepareOptions.to.sql(options);
+  messageFunctions.setOptions( internalOptions );
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
   const { error, throwWithError } = messageFunctions;
 
@@ -513,7 +570,7 @@ function sqlMigration( csn, options, messageFunctions, beforeImage ) {
   const createAndAlterSqls = [];
   // Turn the structured result into just a flat dictionary of "artifact name": "sql"
   const flatSqlDict = Object.values(hdbkinds).reduce((prev, curr) => {
-    forEach(curr, (name, value) => {
+    objectUtils.forEach(curr, (name, value) => {
       prev[name] = value;
     });
     return prev;
@@ -563,8 +620,8 @@ function sqlMigration( csn, options, messageFunctions, beforeImage ) {
  * @returns {migration} The migration result
  */
 function hdiMigration( csn, options, messageFunctions, beforeImage ) {
-  trace.traceApi('to.hdi.migration', options);
   const internalOptions = prepareOptions.to.hdi(options);
+  messageFunctions.setOptions( internalOptions );
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
 
   // Prepare after-image.
@@ -602,9 +659,9 @@ function hdiMigration( csn, options, messageFunctions, beforeImage ) {
  */
 function createSqlDefinitions( hdbkinds, afterImage ) {
   const result = [];
-  forEach(hdbkinds, (kind, artifacts) => {
+  objectUtils.forEach(hdbkinds, (kind, artifacts) => {
     const suffix = `.${ kind }`;
-    forEach(artifacts, (name, sqlStatement) => {
+    objectUtils.forEach(artifacts, (name, sqlStatement) => {
       if ( kind !== 'hdbindex' )
         result.push({ name: getFileName(name, afterImage), suffix, sql: sqlStatement });
       else
@@ -622,7 +679,7 @@ function createSqlDefinitions( hdbkinds, afterImage ) {
  */
 function createSqlDeletions( deletions, beforeImage ) {
   const result = [];
-  forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
+  objectUtils.forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
   return result;
 }
 /**
@@ -634,7 +691,7 @@ function createSqlDeletions( deletions, beforeImage ) {
  */
 function createSqlMigrations( migrations, afterImage ) {
   const result = [];
-  forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
+  objectUtils.forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
   return result;
 }
 
@@ -651,9 +708,13 @@ sql.migration = sqlMigration;
  * @returns {HDBCDS} { <filename>:<content>, ...}
  */
 function hdbcds( csn, options, messageFunctions ) {
-  trace.traceApi('to.hdbcds', options);
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
+  messageFunctions.setOptions( internalOptions );
+
+  // no "isBetaEnabled", because this warning must also appear with "deprecated" flags
+  if (internalOptions.betaMode || internalOptions.beta?.v5preview)
+    messageFunctions.warning('api-deprecated-v5', null, null);
 
   if (options.tenantDiscriminator) {
     messageFunctions.error('api-invalid-option', null, {
@@ -678,12 +739,12 @@ function hdbcds( csn, options, messageFunctions ) {
  * @returns {edm} The JSON representation of the service
  */
 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)
   );
+  messageFunctions.setOptions( internalOptions );
 
   const { service } = options;
 
@@ -712,8 +773,8 @@ edm.all = edmall;
  * @returns {edms} { <service>:<JSON representation>, ...}
  */
 function edmall( csn, options, messageFunctions ) {
-  trace.traceApi('to.edm.all', options);
   const internalOptions = prepareOptions.to.edm(options);
+  messageFunctions.setOptions( internalOptions );
   const { error } = messageFunctions;
 
   if (internalOptions.odataVersion === 'v2')
@@ -747,12 +808,12 @@ function edmall( csn, options, messageFunctions ) {
  * @returns {edmx} The XML representation of the service
  */
 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)
   );
+  messageFunctions.setOptions( internalOptions );
 
   const { service } = options;
 
@@ -782,8 +843,8 @@ edmx.all = edmxall;
  * @returns {edmxs} { <service>:<XML representation>, ...}
  */
 function edmxall( csn, options, messageFunctions ) {
-  trace.traceApi('to.edmx.all', options);
   const internalOptions = prepareOptions.to.edmx(options);
+  messageFunctions.setOptions( internalOptions );
 
   const result = {};
   let oDataCsn = csn;
@@ -813,18 +874,18 @@ function edmxall( csn, options, messageFunctions ) {
  * 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 {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);
+function odata2( csn, options, messageFunctions ) {
   // 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)
   );
+  messageFunctions.setOptions( internalOptions );
 
   const { service } = options;
 
@@ -859,13 +920,13 @@ odata2.all = odataall;
  * 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 {ODataOptions} options Options
  * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {object} { <protocol>: { <serviceName>: { edmx: <XML representation>, edm: <JSON representation> } } }
  */
-function odataall( csn, options = {}, messageFunctions ) {
-  trace.traceApi('to.odata.all', options);
+function odataall( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.to.odata(options);
+  messageFunctions.setOptions( internalOptions );
   const { error } = messageFunctions;
 
   if (internalOptions.odataVersion === 'v2')
@@ -985,10 +1046,10 @@ function preparedCsnToEdmAll( csn, options, messageFunctions ) {
  */
 function flattenResultStructure( toProcess ) {
   const result = {};
-  forEach(toProcess, (fileType, artifacts) => {
+  objectUtils.forEach(toProcess, (fileType, artifacts) => {
     if (fileType === 'messages')
       return;
-    forEach(artifacts, (filename) => {
+    objectUtils.forEach(artifacts, (filename) => {
       result[`${ filename }.${ fileType }`] = artifacts[filename];
     });
   });
@@ -999,6 +1060,7 @@ function flattenResultStructure( toProcess ) {
 
 module.exports = {
   odata: publishCsnProcessor(odata, 'for.odata'),
+  java: publishCsnProcessor(java, 'for.java'),
   cdl: publishCsnProcessor(cdl, 'to.cdl'),
   sql: publishCsnProcessor(sql, 'to.sql'),
   hdi: publishCsnProcessor(hdi, 'to.hdi'),
@@ -1011,14 +1073,15 @@ module.exports = {
   for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
   for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
   for_effective: publishCsnProcessor(forEffective, 'for.effective'),
+  for_seal: publishCsnProcessor(forSeal, 'for.seal'),
 
   /* Deprecated, will be removed in cds-compiler@v5 */ // TODO(v5): Remove
   preparedCsnToEdmx(csn, service, options) {
-    preparedCsnToEdmx(csn, service, options, makeMessageFunction( csn, options, 'to.edmx' ));
+    preparedCsnToEdmx(csn, service, options, messages.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' ));
+    preparedCsnToEdm(csn, service, options, messages.makeMessageFunction( csn, options, 'to.edm' ));
   },
 };
 
@@ -1048,6 +1111,7 @@ function publishCsnProcessor( processor, _name ) {
    * @returns {any} What ever the processor returns
    */
   function api( csn, options = {}, ...args ) {
+    trace.traceApi(_name, options);
     const originalMessageLength = options.messages?.length;
     try {
       const messageFunctions = messages.makeMessageFunction(csn, options, _name);
@@ -1086,7 +1150,6 @@ function publishCsnProcessor( processor, _name ) {
       if (options.testMode)  // Attach recompilation reason in testMode
         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);
       messageFunctions.setModel(recompiledCsn);
@@ -1132,7 +1195,7 @@ function checkOutdatedOptions( options, messageFunctions ) {
     });
   }
 
-  forEachKey(options.variableReplacements || {}, (name) => {
+  objectUtils.forEachKey(options.variableReplacements || {}, (name) => {
     if (!name.startsWith('$') && name !== 'user' && name !== 'locale') {
       messageFunctions.error('api-invalid-variable-replacement', null, {
         '#': 'noDollar', option: 'variableReplacements', code: '$', name,
@@ -1220,7 +1283,8 @@ function lazyload( moduleName ) {
 }
 
 /**
- * Error when tenantDiscriminator and withHanaAssociations is set by the user.
+ * Error when tenantDiscriminator and withHanaAssociations is set by the user, or
+ * if tenantDiscriminator is used with anything but "plain" mode.
  *
  * Set withHanaAssociations to false when tenantDiscriminator is used.
  *
@@ -1234,12 +1298,21 @@ function handleTenantDiscriminator( options, internalOptions, messageFunctions )
       option: 'tenantDiscriminator',
       prop: 'withHanaAssociations',
     });
+  }
 
-    messageFunctions.throwWithAnyError();
+  if (options.tenantDiscriminator && internalOptions.sqlMapping !== 'plain') {
+    messageFunctions.error('api-invalid-combination', null, {
+      '#': 'tenant-and-naming',
+      option: 'tenantDiscriminator',
+      prop: internalOptions.sqlMapping,
+      value: 'plain',
+    });
   }
-  else if (internalOptions.tenantDiscriminator) {
+
+  messageFunctions.throwWithError();
+
+  if (internalOptions.tenantDiscriminator)
     internalOptions.withHanaAssociations = false;
-  }
 }
 
 

package/lib/api/options.js

@@ -35,6 +35,7 @@ const publicOptionsNewAPI = [
   'withHanaAssociations',
   // ODATA
   'odataOpenapiHints',
+  'edm4OpenAPI',
   'odataVersion',
   'odataFormat',
   'odataContainment',
@@ -48,6 +49,11 @@ const publicOptionsNewAPI = [
   'serviceNames',
   //
   'dictionaryPrototype',
+  // for.effective
+  'resolveSimpleTypes',
+  'resolveProjections',
+  'remapOdataAnnotations',
+  'keepLocalized',
 ];
 
 // Internal options used for testing/debugging etc.
@@ -119,6 +125,8 @@ function translateOptions( input = {}, defaults = {}, hardRequire = {},
   // Overwrite with the hardRequire options - like src: sql in to.sql()
   Object.assign(options, hardRequire);
 
+  reclassifyErrorsForOpenApi( options );
+
   // Convenience for $user -> $user.id replacement
   if (options.variableReplacements && options.variableReplacements.$user && typeof options.variableReplacements.$user === 'string')
     options.variableReplacements.$user = { id: options.variableReplacements.$user };
@@ -126,6 +134,30 @@ function translateOptions( input = {}, defaults = {}, hardRequire = {},
   return options;
 }
 
+/**
+ * Reclassify certain OData errors to warnings for the OData/EDM/EDMX backends.
+ * Some errors are not necessary for openAPI generation.
+ *
+ * @param {CSN.Options} options OData options
+ */
+function reclassifyErrorsForOpenApi( options ) {
+  if (options.edm4OpenAPI) {
+    // shallow clone, so that we can modify severities without changing the user's.
+    options.severities = Object.assign({}, options.severities ?? {});
+
+    options.severities['odata-spec-violation-array'] = 'Warning';
+    options.severities['odata-spec-violation-assoc'] = 'Warning';
+    options.severities['odata-spec-violation-namespace'] = 'Warning';
+    options.severities['odata-spec-violation-param'] = 'Warning';
+    options.severities['odata-spec-violation-returns'] = 'Warning';
+    options.severities['odata-spec-violation-type-unknown'] = 'Warning';
+    options.severities['odata-spec-violation-no-key'] = 'Warning';
+    options.severities['odata-spec-violation-key-type'] = 'Warning';
+    options.severities['odata-spec-violation-property-name'] = 'Warning';
+  }
+}
+
+
 module.exports = {
   to: {
     cdl: options => translateOptions(options, undefined, undefined, undefined, undefined, 'to.cdl'),
@@ -181,6 +213,25 @@ module.exports = {
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
       return translateOptions(options, defaultOptions, hardOptions, undefined, undefined, 'for.hana');
     },
+    effective: (options) => {
+      const hardOptions = {};
+      const defaultOptions = {
+        sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true, remapOdataAnnotations: false, keepLocalized: false,
+      };
+      const processed = translateOptions(options, defaultOptions, hardOptions, null, [ 'sql-dialect-and-naming' ], 'for.effective');
+
+      return Object.assign({}, processed);
+    },
+    seal: (options) => {
+      const hardOptions = {
+        sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true, keepLocalized: false,
+      };
+      const defaultOptions = { remapOdataAnnotations: true };
+      const processed = translateOptions(options, defaultOptions, hardOptions, null, [ 'sql-dialect-and-naming' ], 'for.effective');
+
+      return Object.assign({}, processed);
+    },
+    java: options => translateOptions(options, { sqlMapping: 'plain' }, {}, undefined, undefined, 'for.java'),
   },
   overallOptions, // exported for testing
 };

package/lib/api/validate.js

@@ -140,17 +140,13 @@ const allCombinationValidators = {
     if (options.sqlDialect && options.sqlMapping && options.sqlDialect !== 'hana' && [ 'quoted', 'hdbcds' ].includes(options.sqlMapping))
       message.error('api-invalid-combination', null, { '#': 'sql-dialect-and-naming', name: options.sqlDialect, prop: options.sqlMapping });
   },
-  'sql-dialect-and-localized': (options, message) => {
-    if (options.fewerLocalizedViews && options.sqlDialect === 'hana' && (options.withHanaAssociations || options.withHanaAssociations === undefined))
-      message.error('api-invalid-combination', null, { '#': 'sql-dialect-and-localized', option: 'fewerLocalizedViews', value: 'hana' });
-  },
   'beta-no-test': (options, message) => {
     if (options.beta && !options.testMode)
       message.warning('api-unexpected-combination', null, { '#': 'beta-no-test', option: 'beta' });
   },
 };
 
-const alwaysRunValidators = [ 'beta-no-test', 'sql-dialect-and-localized' ];
+const alwaysRunValidators = [ 'beta-no-test' ];
 
 /**
  * Run the validations for each option.