@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/api/options.js

@@ -24,7 +24,7 @@ const publicOptionsNewAPI = [
   'sqlChangeMode',
   'allowCsnDowngrade',
   'joinfk',
-  'magicVars', // deprecated
+  'magicVars', // deprecated, not removed in v3 as we have specific error messages for it
   'variableReplacements',
   // ODATA
   'odataVersion',
@@ -80,13 +80,12 @@ const overallOptions = publicOptionsNewAPI.concat(privateOptions);
 function translateOptions(input = {}, defaults = {}, hardRequire = {},
                           customValidators = {}, combinationValidators = [], moduleName = '') {
   const options = Object.assign({}, defaults);
-  const inputOptionNames = Object.keys(input);
   for (const name of overallOptions) {
     // Ensure that arrays are not passed as a reference!
     // This caused issues with the way messages are handled in processMessages
-    if (Array.isArray(input[name]) && inputOptionNames.includes(name))
+    if (Array.isArray(input[name]))
       options[name] = [ ...input[name] ];
-    else if (inputOptionNames.includes(name))
+    else if (Object.hasOwnProperty.call(input, name))
       options[name] = input[name];
   }
 
@@ -108,47 +107,10 @@ function translateOptions(input = {}, defaults = {}, hardRequire = {},
   // Overwrite with the hardRequire options - like src: sql in to.sql()
   Object.assign(options, hardRequire);
 
-  for (const optionName in options) {
-    const optionValue = options[optionName];
-    mapToOldNames(optionName, optionValue);
-  }
-
   // Convenience for $user -> $user.id replacement
   if (options.variableReplacements && options.variableReplacements.$user && typeof options.variableReplacements.$user === 'string')
     options.variableReplacements.$user = { id: options.variableReplacements.$user };
 
-  /**
-   * Map a new-style option to it's old format
-   *
-   * @param {string} optionName Name of the option to map
-   * @param {any} optionValue Value of the option to map
-   */
-  function mapToOldNames(optionName, optionValue) {
-    // Keep all input options and add the "compatibility" options
-    switch (optionName) {
-      case 'beta':
-        options.betaMode = optionValue;
-        break;
-      case 'odataVersion':
-        options.version = optionValue;
-        break;
-      case 'sqlDialect':
-        options.dialect = optionValue;
-        break;
-      case 'sqlMapping':
-        options.names = optionValue;
-        break;
-      // No need to remap variableReplacements here - we use the new mechanism with that directly
-      case 'magicVars':
-        if (optionValue.user)
-          options.user = optionValue.user;
-        if (optionValue.locale)
-          options.locale = optionValue.locale;
-        break;
-      default: break;
-    }
-  }
-
   return options;
 }
 
@@ -156,78 +118,45 @@ module.exports = {
   to: {
     cdl: options => translateOptions(options, undefined, undefined, undefined, undefined, 'to.cdl'),
     sql: (options) => {
-      const hardOptions = { src: 'sql' };
+      const hardOptions = { src: 'sql', toSql: true, forHana: true };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'plain' };
       const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ], 'to.sql');
 
-      const result = Object.assign({}, processed);
-      result.toSql = Object.assign({}, processed);
-
-      return result;
+      return Object.assign({}, processed);
     },
     hdi: (options) => {
-      const hardOptions = { src: 'hdi' };
+      const hardOptions = { src: 'hdi', toSql: true, forHana: true };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdi');
-
-      const result = Object.assign({}, processed);
-      result.toSql = Object.assign({}, processed);
-
-      return result;
+      return translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdi');
     },
     hdbcds: (options) => {
+      const hardOptions = { forHana: true };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions, {}, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdbcds');
-
-      const result = Object.assign({}, processed);
-      result.forHana = Object.assign({}, processed);
-
-      return result;
+      return translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdbcds');
     },
     edm: (options) => {
-      const hardOptions = { json: true, combined: true };
+      const hardOptions = { json: true, combined: true, toOdata: true };
       const defaultOptions = { odataVersion: 'v4', odataFormat: 'flat' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, { odataVersion: generateStringValidator([ 'v4' ]) }, [ 'valid-structured' ], 'to.edm');
-
-      const result = Object.assign({}, processed);
-      result.toOdata = Object.assign({}, processed);
-
-      return result;
+      return translateOptions(options, defaultOptions, hardOptions, { odataVersion: generateStringValidator([ 'v4' ]) }, [ 'valid-structured' ], 'to.edm');
     },
     edmx: (options) => {
-      const hardOptions = { xml: true, combined: true };
+      const hardOptions = { xml: true, combined: true, toOdata: true };
       const defaultOptions = {
         odataVersion: 'v4', odataFormat: 'flat',
       };
-      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.edmx');
-
-      const result = Object.assign({}, processed);
-      result.toOdata = Object.assign({}, processed);
-
-      return result;
+      return translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.edmx');
     },
   },
   for: {   // TODO: Rename version to oDataVersion
-
     odata: (options) => {
+      const hardOptions = { toOdata: true };
       const defaultOptions = { odataVersion: 'v4', odataFormat: 'flat' };
-      const processed = translateOptions(options, defaultOptions, undefined, undefined, [ 'valid-structured' ], 'for.odata');
-
-      const result = Object.assign({}, processed);
-      result.toOdata = Object.assign({}, processed);
-
-
-      return result;
+      return translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'for.odata');
     },
     hana: (options) => {
+      const hardOptions = { forHana: true };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
-      const processed = translateOptions(options, defaultOptions, undefined, undefined, undefined, 'for.hana');
-
-      const result = Object.assign({}, processed);
-      result.forHana = Object.assign({}, processed);
-
-
-      return result;
+      return translateOptions(options, defaultOptions, hardOptions, undefined, undefined, 'for.hana');
     },
   },
 };

package/lib/api/validate.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
+const { forEach } = require('../utils/objectUtils');
 
 /* eslint-disable arrow-body-style */
 const booleanValidator = {
@@ -64,13 +65,6 @@ const validators = {
       return val === null ? val : `type ${ typeof val }`;
     },
   },
-  magicVars: {
-    validate: val => val !== null && typeof val === 'object' && !Array.isArray(val),
-    expected: () => 'type object',
-    found: (val) => {
-      return val === null ? val : `type ${ typeof val }`;
-    },
-  },
   // TODO: Maybe do a deep validation of the whole object with leafs?
   variableReplacements: {
     validate: val => val !== null && typeof val === 'object' && !Array.isArray(val),
@@ -84,7 +78,7 @@ const validators = {
     expected: () => 'type array',
     found: val => `type ${ typeof val }`,
   },
-  sqlDialect: generateStringValidator([ 'sqlite', 'hana', 'plain' ]),
+  sqlDialect: generateStringValidator([ 'sqlite', 'hana', 'plain', 'postgres' ]),
   sqlMapping: generateStringValidator([ 'plain', 'quoted', 'hdbcds' ]),
   odataVersion: generateStringValidator([ 'v2', 'v4' ]),
   odataFormat: generateStringValidator([ 'flat', 'structured' ]),
@@ -130,16 +124,19 @@ const allCombinationValidators = {
   'valid-structured': {
     validate: options => options.odataVersion === 'v2' && options.odataFormat === 'structured',
     severity: 'error',
+    getParameters: () => {},
     getMessage: () => 'Structured OData is only supported with OData version v4',
   },
   'sql-dialect-and-naming': {
     validate: options => options.sqlDialect && options.sqlMapping && ![ 'hana' ].includes(options.sqlDialect) && [ 'quoted', 'hdbcds' ].includes(options.sqlMapping),
     severity: 'error',
-    getMessage: options => `sqlDialect '${ options.sqlDialect }' can't be combined with sqlMapping '${ options.sqlMapping }'`,
+    getParameters: options => ({ name: options.sqlDialect, prop: options.sqlMapping }),
+    getMessage: () => 'sqlDialect $(NAME) can\'t be combined with sqlMapping $(PROP)',
   },
   'beta-no-test': {
     validate: options => options.beta && !options.testMode,
     severity: 'warning',
+    getParameters: () => {},
     getMessage: () => 'Option "beta" was used. This option should not be used in productive scenarios!',
   },
 };
@@ -159,16 +156,15 @@ function validate(options, moduleName, customValidators = {}, combinationValidat
   // TODO: issuing messages in this function looks very strange...
   {
     const messageCollector = { messages: [] };
-    const { error, throwWithError } = makeMessageFunction(null, messageCollector, moduleName);
+    const { error, throwWithAnyError } = makeMessageFunction(null, messageCollector, moduleName);
 
-    for (const optionName of Object.keys(options)) {
-      const optionValue = options[optionName];
+    forEach(options, (optionName, optionValue) => {
       const validator = customValidators[optionName] || validators[optionName] || booleanValidator;
 
       if (!validator.validate(optionValue))
         error('invalid-option', null, {}, `Expected option "${ optionName }" to have "${ validator.expected(optionValue) }". Found: "${ validator.found(optionValue) }"`);
-    }
-    throwWithError();
+    });
+    throwWithAnyError();
   }
 
   const message = makeMessageFunction(null, options, moduleName);
@@ -176,10 +172,10 @@ function validate(options, moduleName, customValidators = {}, combinationValidat
   for (const combinationValidatorName of combinationValidators.concat([ 'beta-no-test' ])) {
     const combinationValidator = allCombinationValidators[combinationValidatorName];
     if (combinationValidator.validate(options))
-      message[combinationValidator.severity]('invalid-option-combination', null, {}, combinationValidator.getMessage(options));
+      message[combinationValidator.severity]('invalid-option-combination', null, combinationValidator.getParameters(options), combinationValidator.getMessage(options));
   }
 
-  message.throwWithError();
+  message.throwWithAnyError();
 }
 /* eslint-enable jsdoc/no-undefined-types */