@sap/eslint-plugin-cds 2.2.2 → 2.3.0

package/CHANGELOG.md

@@ -6,67 +6,17 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
-## [2.1.2] - 2021-10-05
-
-## Changed
-
-- Allow not only *.js but also other file types (i.e. *.ts, etc) to bypass plugin rules
-
-## [2.1.1] - 2021-10-04
 
-## Changed
-
-- Added preprocessor to avoid (other plugins) parsing errors on cds files
-
-## [2.2.0] - 2021-10-29
+## [2.3.0] - 201-12-03
 
 ## Added
 
-- Added typings to javascript for all exposed apis
+- Added new rule 'valid-csv-header'
 
 ## Changed
 
-- Aligned rule creation and tester api with ESLint
-
-## [2.1.2] - 2021-10-05
-
-## Changed
-
-- Allow not only *.js but also other file types (i.e. *.ts, etc) to bypass plugin rules
-
-## [2.1.1] - 2021-10-04
-
-## Changed
-
-- Added preprocessor to avoid (other plugins) parsing errors on cds files
-
-## [2.2.1] - 2021-10-29
-
-## Changed
-
-- Optimized model loading and fixed bug in loading of 'outsider' files
-
-## [2.2.0] - 2021-10-29
-
-## Added
-
-- Added typings to javascript for all exposed apis
-
-## Changed
-
-- Aligned rule creation and tester api with ESLint
-
-## [2.1.2] - 2021-10-05
-
-## Changed
-
-- Allow not only *.js but also other file types (i.e. *.ts, etc) to bypass plugin rules
-
-## [2.1.1] - 2021-10-04
-
-## Changed
-
-- Added preprocessor to avoid (other plugins) parsing errors on cds files
+- Fixed suggestion messages in editor option (and disabled auto-fix)
+- Added rule properties 'docs.recommended', 'severity'
 
 ## [2.2.2] - 2021-11-08
 

package/lib/impl/constants.js

@@ -3,7 +3,6 @@
  * - categories: The category labels we use to for model and environment rules
  * - customRulesDir: The custom rules directory name in the user's project home
  *                   which contains the subdirs 'docs', 'rules' and 'tests'
- * - recommended: The set of this plugin's recommended rules and their severities
  * - globals: The globals which should be exposed to ESLint by this plugin
  * - files: Any additional file extensions which ESLint should lint
  */
@@ -14,15 +13,6 @@ module.exports = {
     model: "Model Validation",
   },
   customRulesDir: ".eslint",
-  recommended: {
-    "@sap/cds/assoc2many-ambiguous-key": 1,
-    "@sap/cds/cds-compile-error": 2,
-    "@sap/cds/min-node-version": 2,
-    "@sap/cds/no-join-on-draft-enabled-entities": 1,
-    "@sap/cds/no-db-keywords": 2,
-    "@sap/cds/require-2many-oncond": 2,
-    "@sap/cds/sql-cast-suggestion": 1,
-  },
   globals: {
     SELECT: true,
     INSERT: true,
@@ -35,6 +25,6 @@ module.exports = {
     CXL: true,
     cds: true,
   },
-  files: ["*.cds", "*.csn"],
+  files: ["*.cds", "*.csn", "*.csv", "undeploy.json"],
   modelFiles: ["*.cds", "*.csn"],
 };

package/lib/impl/index.js

@@ -22,7 +22,7 @@ const {
   getLocation,
   getRange,
 } = require("../impl/utils/model");
-const { files, globals, recommended } = require("./constants");
+const { files, globals } = require("./constants");
 
 const cds = require("@sap/cds");
 cds.getLocation = getLocation;
@@ -36,6 +36,11 @@ if (!Cache.has("rulesInfo")) {
 } else {
   rulesInfo = Cache.get("rulesInfo");
 }
+const recommended = Object.assign({}, 
+  ...Object.entries(rulesInfo.rules)
+    .filter(([k,v]) => (v.meta.docs.recommended))
+    .map(([k,v]) => ({ [`@sap/cds/${k}`]:v.meta.severity }))
+);
 
 module.exports = {
   configs: {

package/lib/impl/ruleFactory.js

@@ -31,13 +31,14 @@
 const fs = require("fs");
 const path = require("path");
 const { RuleTester, SourceCode } = require("eslint");
-const { isEditor, isValidFile, styleText } = require("./utils/helpers");
+const { isEditor, isValidFile } = require("./utils/helpers");
 const { isValidEnv, isValidModel } = require("./utils/validate");
 const {
   Cache,
   populateModelAndEnv,
   hasCompilationError,
   getAST,
+  initModelRuleTester,
   loadConfigPath,
 } = require("./utils/model");
 const { isRuleDisabled, getRules, populateRules } = require("./utils/rules");
@@ -60,9 +61,6 @@ const { customRulesDir, categories } = require("./constants");
  */
 function createRule(spec) {
   const { meta, create } = spec;
-  if (!meta.type) meta.type = "problem";
-  if (meta.docs && !meta.docs.category)
-    meta.docs.category = categories["model"];
   return {
     meta,
     create: function (context) {
@@ -84,11 +82,11 @@ function createRule(spec) {
               try {
                 create(cdscontext);
               } catch (err) {
-                // Do not throw to avoid ESLint VSCode editor pop-ups
-                styleText(
-                  `Rule ${cdscontext.ruleID} has failed unexpectedly - please report this error!\n`,
-                  ["bold", "red"]
-                );
+                if (isEditor()) {  // Do not throw to avoid ESLint VSCode editor pop-ups
+                  console.error(`An error occurred while linting. Rule: ${cdscontext.ruleID}\n`, err);
+                } else {
+                  throw err;
+                }
               }
               // Show compilation error only on console
             } else if (hasCompilationError(cdscontext) && !isEditor()) {
@@ -210,7 +208,12 @@ function getProxyReport(obj) {
  */
 function createCDSContext(context, node, meta) {
   const filePath = context.getPhysicalFilename();
-  const configPath = loadConfigPath(filePath);
+  let configPath;
+  if (!Cache.has("pluginpath")) {
+    configPath = loadConfigPath(filePath);
+  } else {
+    configPath = Cache.get("configpath")
+  }
   let category = "model";
   if (meta.docs.category === categories["env"]) {
     category = "env";
@@ -234,10 +237,32 @@ function createCDSContext(context, node, meta) {
     options: context.options,
     report: getProxyReport(context.report),
     ruleID: context.id,
-    sourcecode,
+    sourcecode
   };
 }
 
+function getProxyRun(obj) {
+  const handler = {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "object") {
+        return value;
+      }
+      /* eslint no-extra-boolean-cast: "off" */
+      if (!!value) {
+        return new Proxy(value, handler);
+      }
+      return {
+        err: `Property ${prop} prop does not exist on object ${obj}!`,
+      };
+    },
+    apply(target, thisArg, argumentsList) {
+      return thisArg.run();
+    },
+  };
+  return new Proxy(obj, handler);
+}
+
 /**
  * ESLint RuleTester (used by custom rule creator api)
  * Calls ESLint's RuleTester with custom cds parser and input for
@@ -247,20 +272,22 @@ function createCDSContext(context, node, meta) {
  * @param {CDSRuleTestOpts} options RuleTester input options
  * @returns RuleTester results
  */
-function runRuleTester(options) {
-  process.env['RULE_TESTER'] = true;
+function runRuleTester(options, dryRun=false) {
   let parser;
   let rule = {};
+  process.env.LINT_FLAVOR = "inferred";
   const rulename = path.basename(options.root);
   const plugin = "eslint-plugin-cds";
   if (options.root.includes(plugin)) {
     // For plugin's internal tests, resolve parser from here
     parser = require.resolve("./parser");
     rule = require(`./rules/${path.basename(options.root)}`);
+    const pluginPath = path.join(path.dirname(options.root), "../..");
     Cache.set(
       "rulesInfo",
       getRules(path.join(path.dirname(options.root), "../../lib/impl/rules"))
     );
+    Cache.set("pluginpath", pluginPath);
   } else {
     // Otherwise from project root
     const resolvedPlugin = require.resolve("@sap/eslint-plugin-cds", {
@@ -271,7 +298,9 @@ function runRuleTester(options) {
       options.root,
       `../../rules/${path.basename(options.root)}`
     ));
+    const pluginPath = path.join(path.dirname(options.root), "../../../..");
     Cache.set("rulesInfo", getRules(path.join(options.root, "../../rules")));
+    Cache.set("pluginpath", pluginPath);
   }
   let category = categories["model"];
   if (rule.meta) {
@@ -296,11 +325,12 @@ function runRuleTester(options) {
       ];
     } else if (!category || category === categories.model) {
       testerCases[type][0].code = fs.readFileSync(filePath, "utf8");
+      initModelRuleTester(filePath);
     }
     if (type === "invalid") {
       testerCases[type][0].errors = options.errors;
       const fileFixed = path.join(options.root, `fixed/${options.filename}`);
-      if (fs.existsSync(fileFixed)) {
+      if (fs.existsSync(fileFixed) && rule.meta.type !== "suggestion") {
         testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
       }
     }

package/lib/impl/rules/assoc2many-ambiguous-key.js

@@ -1,11 +1,13 @@
 module.exports = require("../../api").createRule({
   meta: {
     docs: {
-      description: `Ambiguous key with a \`TO MANY\` relationship since entries could appear multiple times with the same key.`,
+      description: "Ambiguous key with a `TO MANY` relationship since entries could appear multiple times with the same key.",
       category: "Model Validation",
+      recommended: true,
       version: "1.0.1",
     },
-    type: "problem",
+    severity: "warn",
+    type: "problem"
   },
   create(context) {
     let csnOdata;

package/lib/impl/rules/cds-compile-error.js

@@ -5,31 +5,30 @@ module.exports = require("../../api").createRule({
       category: "Model Validation",
       version: "1.0.0",
     },
+    severity: "error",
     type: "problem",
   },
   create: function (context) {
     const m = context.cds.model;
-    if (m.err) {
-      if (m.err) {
-        // If any csn compile errors occur
-        m.err.messages.forEach((err) => {
-          const msg = err.message;
-          let file = "";
-          const loc = {
-            start: { line: 0, column: 0 },
-            end: { line: 1, column: 0 },
-          };
-          // Get its location if it exists
-          if (err.$location) {
-            loc.start.column = err.$location.col;
-            loc.start.line = err.$location.line;
-            loc.end.column = err.$location.endCol;
-            loc.end.line = err.$location.endLine;
-            file = err.$location.file;
-          }
-          context.report({ message: `${msg}`, loc, file });
-        });
-      }
+    if (m && m.err) {
+      // If any csn compile errors occur
+      m.err.messages.forEach((err) => {
+        const msg = err.message;
+        let file = "";
+        const loc = {
+          start: { line: 0, column: 0 },
+          end: { line: 1, column: 0 },
+        };
+        // Get its location if it exists
+        if (err.$location) {
+          loc.start.column = err.$location.col;
+          loc.start.line = err.$location.line;
+          loc.end.column = err.$location.endCol;
+          loc.end.line = err.$location.endLine;
+          file = err.$location.file;
+        }
+        context.report({ message: `${msg}`, loc, file });
+      });
     }
-  },
+  }
 });

package/lib/impl/rules/latest-cds-version.js

@@ -1,10 +1,13 @@
+const os = require("os");
 const cp = require("child_process");
 const semver = require("semver");
 
+const IS_WIN = os.platform() === "win32";
+
 module.exports = require("../../api").createRule({
   meta: {
     docs: {
-      description: "Checks whether the latest cds version is being used.",
+      description: "Checks whether the latest `@sap/cds` version is being used.",
       category: "Environment",
       version: "1.0.4",
     },
@@ -23,6 +26,8 @@ module.exports = require("../../api").createRule({
         result = cp
           .execSync(`npm outdated @sap/cds --json`, {
             cwd: process.cwd(),
+            shell: IS_WIN,
+            stdio: "pipe",
           })
           .toString();
         cdsVersions = JSON.parse(result)["@sap/cds"];

package/lib/impl/rules/min-node-version.js

@@ -4,10 +4,12 @@ const semver = require("semver");
 module.exports = require("../../api").createRule({
   meta: {
     docs: {
-      description: `Checks whether the minimum node version required by the \`@sap/cds\` is achieved.`,
+      description: `Checks whether the minimum Node.js version required by \`@sap/cds\` is achieved.`,
       category: "Environment",
+      recommended: true,
       version: "1.0.0",
     },
+    severity: "error",
     type: "problem",
   },
   create: function (context) {

package/lib/impl/rules/no-db-keywords.js

@@ -3,7 +3,10 @@ module.exports = require("../../api").defineRule({
     docs: {
       description: `Avoid using reserved SQL keywords.`,
       category: "Model Validation",
+      recommended: true,
+      version: "2.1.0",
     },
+    severity: "error"
   },
   create(context) {
     const { db = { kind: "sql" } } = context.cds.env.requires;

package/lib/impl/rules/no-join-on-draft-enabled-entities.js

@@ -3,15 +3,17 @@ module.exports = require("../../api").createRule({
     docs: {
       description: `Draft-enabled entities shall not be used in views that make use of \`JOIN\`.`,
       category: "Model Validation",
+      recommended: true,
       version: "2.2.1",
     },
+    severity: "warn",
     type: "suggestion",
     messages: {
       noJoinOnDraftEnabledEntities: `Do not use draft-enabled entities in views that make use of \`JOIN\`.`,
     },
   },
   create: function (context) {
-    const m = context.cds.model;
+    const m = context.cds.model;  if (!m)  return
     m.foreach("entity", (entity) => {
       if (entity["@odata.draft.enabled"]) {
         if (entity.query.SELECT.from.join) {

package/lib/impl/rules/require-2many-oncond.js

@@ -3,12 +3,14 @@ module.exports = require("../../api").createRule({
     docs: {
       description: `Foreign key information of a \`TO MANY\` relationship must be defined within the target and specified in an \`ON\` condition.`,
       category: "Model Validation",
+      recommended: true,
       version: "2.1.0",
     },
+    severity: "error",
     type: "problem",
   },
   create: function (context) {
-    const m = context.cds.model;
+    const m = context.cds.model;  if (!m)  return
     m.forall((d) => {
       if (d.name) {
         if (!d.elements) return;

package/lib/impl/rules/sql-cast-suggestion.js

@@ -1,10 +1,12 @@
 module.exports = require("../../api").createRule({
   meta: {
     docs: {
-      description: "Should make suggestions for possible missing sql casts.",
+      description: "Should make suggestions for possible missing SQL casts.",
       category: "Model Validation",
+      recommended: true,
       version: "1.0.8",
     },
+    severity: "warn",
     type: "suggestion",
     hasSuggestions: true,
     messages: {

package/lib/impl/rules/start-elements-lowercase.js

@@ -10,6 +10,8 @@ module.exports = require("../../api").createRule({
     messages: {
       startLowercase:
         "Element name '{{entityName}}.{{elementName}}' should start with a lowercase letter.",
+        fixLowercase:
+        "Start element name with a lowercase letter."
     },
     fixable: "code",
   },
@@ -52,14 +54,13 @@ module.exports = require("../../api").createRule({
                   messageId: "startLowercase",
                   loc,
                   file,
-                  fix,
                   data: {
                     entityName,
                     elementName,
                   },
                   suggest: [
                     {
-                      messageId: "startLowercase",
+                      messageId: "fixLowercase",
                       fix,
                     },
                   ],

package/lib/impl/rules/start-entities-uppercase.js

@@ -10,6 +10,7 @@ module.exports = require("../../api").createRule({
     messages: {
       startUppercase:
         "Entity name '{{entityName}}' should start with an uppercase letter.",
+      fixUppercase: "Start entity name with an uppercase letter.",
     },
     fixable: "code",
   },
@@ -47,11 +48,10 @@ module.exports = require("../../api").createRule({
                 messageId: "startUppercase",
                 loc,
                 file,
-                fix,
                 data: { entityName },
                 suggest: [
                   {
-                    messageId: "startUppercase",
+                    messageId: "fixUppercase",
                     fix,
                   },
                 ],

package/lib/impl/rules/valid-csv-header.js

@@ -0,0 +1,92 @@
+const {basename, extname} = require('path')
+const findFuzzy = require('../utils/fuzzySearch')
+const SEP = '[,;\t]'
+const EOL = '\\r?\\n'
+
+module.exports = require("../../api").createRule({
+  meta: {
+    docs: {
+      description: `CSV files for entities must refer to valid element names.`,
+      category: "Model Validation",
+      recommended: true,
+      version: "2.3.0",
+    },
+    severity: "warn",
+    type: "problem",
+    hasSuggestions: true,
+    messages: {
+      InvalidColumn: `Invalid column '{{column}}'. Did you mean '{{candidates}}'?`,
+      ReplaceColumnWith: `Replace '{{column}}' with '{{candidates}}'`
+    }
+  },
+  create: function (context) {
+    const {cds, code, filePath, sourcecode} = context
+
+    if (!filePath.endsWith('.csv'))  return
+    if (!cds.model)  return
+    let {env, model} = cds;
+    model = cds.compile.for.sql(model, {names:env.sql.names, messages: []} )
+
+    const filename = basename(filePath)
+    const entityName = filename.replace(/-/g,'.').slice(0, -extname(filename).length)
+    const entity = _entity4(entityName, model)
+    if (!entity)  return
+
+    const elements = Object.values(entity.elements)
+      .filter (e => !!e['@cds.persistence.name'])
+      .map (e => e['@cds.persistence.name'].toUpperCase())
+
+    const [ cols ] = cds.parse.csv(code)
+    const missing = cols.filter (col => !elements.includes(col.toUpperCase()))
+    missing.forEach(miss => {
+      const index = _findInCode (miss, code)
+      const loc = sourcecode.getLocFromIndex(index)
+      const candidates = findFuzzy(miss, Object.keys(entity.elements).sort())
+      const suggest = candidates.map(cand => { return {
+        messageId: 'ReplaceColumnWith',
+        data: {column: miss, candidates:cand},
+        fix: (fixer) => fixer.replaceTextRange([index, index+miss.length], cand)
+      }})
+      context.report({
+        messageId: 'InvalidColumn',
+        data: {column: miss, candidates},
+        loc: {start: loc, end: {line: loc.line, column: loc.column+miss.length}},
+        file: filePath,
+        suggest
+      })
+    })
+  }
+
+})
+
+function _findInCode (miss, code) {
+  // middle
+  let match = new RegExp(SEP+miss+SEP).exec(code)
+  if (match)  return match.index+1
+  // end of line
+  match = new RegExp(SEP+miss+EOL).exec(code)
+  if (match)  return match.index+1
+  // start of doc
+  match = new RegExp('^'+miss+SEP).exec(code)
+  if (match)  return match.index
+  // somewhere (fallback)
+  return code.indexOf(miss)
+}
+
+function _entity4 (name, csn) {
+  let entity = csn.definitions [name]
+  if (!entity) {
+    if (/(.+)[._]texts_?/.test (name)) { // 'Books.texts', 'Books.texts_de'
+      const base = csn.definitions [RegExp.$1]
+      return base && _entity4 (base.elements.texts.target, csn)
+    }
+    else return
+  }
+  // we also support simple views if they have no projection
+  const p = entity.query && entity.query.SELECT || entity.projection
+  if (p && !p.columns && p.from.ref && p.from.ref.length === 1) {
+    if (csn.definitions [p.from.ref[0]])  return entity
+  }
+  return entity.name ? entity : { name, __proto__:entity }
+}
+

package/lib/impl/utils/fuzzySearch.js

@@ -0,0 +1,87 @@
+/**
+ * Levenshtein distance algorithm using recursive calls and cache
+ *
+ * @param input search the list for a best match for this string
+ * @param list a list of strings to match input against
+ * @param log logging method to use, might be null if no logging is wanted
+ * @returns array with best matches, is never null but might be empty in case no search was possible
+ */
+
+
+const cache = {};
+
+
+module.exports = (input, list, log) => {
+  let minDistWords = [];
+
+  if (input.length > 50 || list.length > 50) {
+    return minDistWords;
+  }
+
+  let minDist = Number.MAX_SAFE_INTEGER;
+
+  log && log('\nword\t\tlevDist\t\ttime(ms)');
+
+  let runtime = 0;
+
+  for (const word of list) {
+    const start = log && Date.now();
+    const levDist = levDistance(input, word);
+
+    if (log) {
+      const duration = Date.now() - start;
+      runtime = runtime + duration;
+      log(`${word}\t\t${levDist}\t\t${duration}`);
+    }
+
+    if (levDist === minDist) {
+      minDistWords.push(word);
+    }
+
+    if (levDist < minDist) {
+      minDist = levDist;
+      minDistWords = [word];
+    }
+  }
+
+  log && log(`runtime: ${runtime}ms`);
+
+  return minDistWords.sort();
+}
+
+
+const levDistance = (a, b) => {
+
+  if (cache[a] && cache[a][b]) {
+    return cache[a][b];
+  }
+
+  if (a.length === 0) {
+    return addToCache(a, b, b.length);
+  }
+
+  if (b.length === 0) {
+    return addToCache(a, b, a.length);
+  }
+
+  const tail_a = a.substring(1);
+  const tail_b = b.substring(1);
+
+  if (a[0] === b[0]) {
+    return levDistance(tail_a, tail_b);
+  }
+
+  const lev1 = levDistance(tail_a, b);
+  const lev2 = levDistance(a, tail_b);
+  const lev3 = levDistance(tail_a, tail_b);
+
+  const levDist = Math.min(lev1, lev2, lev3) + 1;
+  return addToCache(a, b, levDist);
+}
+
+
+const addToCache = (a, b, value) => {
+  cache[a] = cache[a] || {};
+  cache[a][b] = value;
+  return value;
+}