@sap/eslint-plugin-cds 2.5.0 → 2.6.1

package/lib/utils/getConfiguredFileTypes.js

@@ -1,10 +1,10 @@
-const { FILES } = require("../constants");
+const { FILES } = require('../constants')
 
 /**
  * Returns an array of allowed file extensions
  * the plugin can parse of the form "*.ext"
- * @returns {ConfigOverrideFiles} Array of file extensions
+ * @returns { ConfigOverrideFiles } Array of file extensions
  */
 module.exports = () => {
-  return FILES;
-};
+  return FILES
+}

package/lib/utils/getFileExtensions.js

@@ -1,8 +1,8 @@
-const constants = require("../constants");
+const constants = require('../constants')
 
 /**
  * Returns an array of allowed file extensions
  * the plugin can parse of the form "*.ext"
- * @returns {ConfigOverrideFiles} Array of file extensions
+ * @returns { ConfigOverrideFiles } Array of file extensions
  */
-module.exports = () => constants.FILES;
+module.exports = () => constants.FILES

package/lib/utils/getProjectRootPath.js

@@ -0,0 +1,25 @@
+/**
+ * Searches for directory containing cds roots
+ * @param {string} currentDir start here and search until root dir
+ * @returns {string} dir containing cds roots (empty if not exists)
+ */
+
+const path = require('path')
+const cds = require('@sap/cds')
+const Cache = require('./Cache')
+
+module.exports = (currentDir = '.') => {
+  let dir = path.resolve(currentDir)
+  while (dir !== path.resolve(dir, '..')) {
+    // @ts-ignore
+    cds.resolve.cache = {}
+    // @ts-ignore
+    const roots = cds.resolve('*', { root: dir })
+    if (roots && roots.length > 0) {
+      Cache.set(`roots:${dir}`, roots)
+      return dir
+    }
+    dir = path.join(dir, '..')
+  }
+  return ''
+}

package/lib/utils/isConfiguredFileType.js

@@ -1,4 +1,4 @@
-const { FILES, MODEL_FILES } = require("../constants");
+const { FILES, MODEL_FILES } = require('../constants')
 
 /**
  * Checks whether the given filePath matches a regex `files`
@@ -6,15 +6,15 @@ const { FILES, MODEL_FILES } = require("../constants");
  * @returns boolean
  */
 module.exports = (filePath, fileType) => {
-  const genRegex = (key) => new RegExp(`${key.map((file) => file.replace("*", "")).join("$|")}$`);
-  let isValid = false;
+  const genRegex = (key) => new RegExp(`${key.map((file) => file.replace('*', '')).join('$|')}$`)
+  let isValid = false
   switch (fileType) {
-    case "MODEL_FILES":
-      isValid = genRegex(MODEL_FILES).test(filePath);
-      break;
-    case "FILES":
-      isValid = genRegex(FILES).test(filePath);
-      break;
+    case 'MODEL_FILES':
+      isValid = genRegex(MODEL_FILES).test(filePath)
+      break
+    case 'FILES':
+      isValid = genRegex(FILES).test(filePath)
+      break
   }
-  return isValid;
-}
+  return isValid
+}

package/lib/utils/rules.js

@@ -1,7 +1,7 @@
-const SEP = "[,;\t]";
-const EOL = "\\r?\\n";
+const SEP = '[,;\t]'
+const EOL = '\\r?\\n'
 
-const findFuzzy = require("./findFuzzy");
+const findFuzzy = require('./findFuzzy')
 
 module.exports = {
   findFuzzy,
@@ -9,105 +9,105 @@ module.exports = {
    *
    * @param {*} e
    */
-  splitEntityName: function (e) {
+  splitDefName: function (e) {
     // Entity names from CSN are of the form:
-    // <namespace>.<service>.<entity>.<'texts'|'localized'>|<composition value>
-    let prefix = "";
-    let suffix = "";
-    let entityName = e.name;
-    const names = entityName.split(".");
-    entityName = names[names.length - 1];
+    // <namespace>.<service>.<def>.<'texts'|'localized'>|<composition value>
+    let prefix = ''
+    let suffix = ''
+    let defName = e.name
+    const names = defName.split('.')
+    defName = names[names.length - 1]
 
-    if (entityName) {
+    if (defName) {
       // Managed composition get compiler tag `_up`
-      let isManagedComposition = false;
+      let isManagedComposition = false
       if (e.elements) {
-        isManagedComposition = Object.keys(e.elements).some((k) => k === "up_");
+        isManagedComposition = Object.keys(e.elements).some((k) => k === 'up_')
       }
       // Check for compiler tags
-      let compilerTagsToExclude = ["texts", "localized"];
-      const isCompilerTag = compilerTagsToExclude.includes(entityName);
+      const compilerTagsToExclude = ['texts', 'localized']
+      const isCompilerTag = compilerTagsToExclude.includes(defName)
 
       if (isManagedComposition || isCompilerTag) {
-        suffix = names[names.length - 1];
-        entityName = names[names.length - 2];
+        suffix = names[names.length - 1]
+        defName = names[names.length - 2]
       }
-      prefix = e.name.split(`.${entityName}`)[0];
+      prefix = e.name.split(`.${defName}`)[0]
     }
-    return { prefix, entity: entityName, suffix };
+    return { prefix, name: defName, suffix }
   },
 
   _findInCode: function (miss, code) {
     // middle
-    let match = new RegExp(SEP + miss + SEP).exec(code);
-    if (match) return match.index + 1;
+    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;
+    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;
+    match = new RegExp('^' + miss + SEP).exec(code)
+    if (match) return match.index
     // somewhere (fallback)
-    return code.indexOf(miss);
+    return code.indexOf(miss)
   },
 
   isEmptyString: function (value) {
-    if (typeof value !== "string" || (typeof value === "string" && value && value.length > 0)) {
-      return false;
+    if (typeof value !== 'string' || (typeof value === 'string' && value && value.length > 0)) {
+      return false
     }
-    return true;
+    return true
   },
 
   isEmptyObject: function (value) {
-    function isEmpty(object) {
-      for (const property in object) {
-        return false;
+    function isEmpty (object) {
+      if (Object.keys(object).length) {
+        return false
       }
-      return true;
+      return true
     }
-    if (typeof value !== "object" || (typeof value === "object" && !isEmpty(value)) ||
-    (typeof value === "object" && value && value.length > 0)) {
-      return false;
+    if (typeof value !== 'object' || (typeof value === 'object' && !isEmpty(value)) ||
+    (typeof value === 'object' && value && value.length > 0)) {
+      return false
     }
-    return true;
+    return true
   },
 
-  isStringInArray(str, arr, caps=false) {
-    const notIncluded = !arr.includes(str);
+  isStringInArray (str, arr, caps = false) {
+    const notIncluded = !arr.includes(str)
     if (!caps && notIncluded) {
-      return false;
+      return false
     }
-    if (caps && notIncluded && !arr.includes(str.toLowerCase()) && !arr.includes(str.toUpperCase()))  {
-      return false;
+    if (caps && notIncluded && !arr.includes(str.toLowerCase()) && !arr.includes(str.toUpperCase())) {
+      return false
     }
-    return true;
+    return true
   },
 
   getReplacementsSuggestions: function (context, value, loc) {
-    let invalid;
-    const lineToReplace = context.sourcecode.lines[loc.line];
-    var regExp = /\[([^)]+)\]/;
-    var matches = regExp.exec(lineToReplace);
+    let invalid
+    const lineToReplace = context.sourcecode.lines[loc.line]
+    const regExp = /\[([^)]+)\]/
+    const matches = regExp.exec(lineToReplace)
     if (matches && matches[0]) {
-      invalid = matches[0];
+      invalid = matches[0]
     }
-    const startIndex = lineToReplace.indexOf(invalid);
-    const candidates = `['${value}']`;
+    const startIndex = lineToReplace.indexOf(invalid)
+    const candidates = `['${value}']`
     const suggest = {
-      messageId: "ReplaceItemWith",
+      messageId: 'ReplaceItemWith',
       data: { invalid, candidates },
-      fix: (fixer) => fixer.replaceTextRange([startIndex, startIndex + invalid.length] + 1, candidates),
-    };
+      fix: (fixer) => fixer.replaceTextRange([startIndex, startIndex + invalid.length] + 1, candidates)
+    }
     return ({
-      messageId: "InvalidItem",
+      messageId: 'InvalidItem',
       data: { invalid, candidates },
       loc: {
         start: { line: loc.line + 1, column: startIndex },
-        end: { line: loc.line + 1, column: startIndex + invalid.length },
+        end: { line: loc.line + 1, column: startIndex + invalid.length }
       },
       file: loc.file,
       suggest,
-      severity: "warn",
-    });
-  },
-};
+      severity: 'warn'
+    })
+  }
+}

package/lib/utils/runRuleTester.js

@@ -1,11 +1,11 @@
-const fs = require("fs");
-const path = require("path");
+const fs = require('fs')
+const path = require('path')
 
-const { RuleTester } = require("eslint");
-const Cache = require("./Cache");
-const createRule = require("./createRule");
-const isConfiguredFileType = require("./isConfiguredFileType");
-const { compileModelFromDict } = require("../parser");
+const { RuleTester } = require('eslint')
+const Cache = require('./Cache')
+const createRule = require('./createRule')
+const isConfiguredFileType = require('./isConfiguredFileType')
+const { compileModelFromDict } = require('../parser')
 
 /**
  * ESLint RuleTester (used by custom rule creator api)
@@ -13,99 +13,104 @@ const { compileModelFromDict } = require("../parser");
  * valid/invalid checks:
  * Model checks require input 'code' entries
  * Env checks require input 'options' with selected parameters
- * @param {CDSRuleTestOpts} options RuleTester input options
+ * @param { CDSRuleTestOpts } options RuleTester input options
  * @returns RuleTester results
  */
 module.exports = (options) => {
-  let parser;
-  let rule = {};
-  Cache.set("rules", require(path.join(__dirname, "../rules")));
-  const rulename = path.basename(options.root);
-  if (options.root.startsWith(path.resolve(__dirname, "../.."))) {
+  let parser
+  let rule = {}
+  Cache.set('rules', require(path.join(__dirname, '../rules')))
+  const rulename = path.basename(options.root)
+  if (options.root.startsWith(path.resolve(__dirname, '../..'))) {
     // For plugin's internal tests, resolve parser from here
-    parser = require.resolve("../parser");
-    const pluginPath = path.join(path.dirname(options.root), "../..");
-    rule = createRule(require(`../rules/${path.basename(options.root)}`));
-    Cache.set("pluginpath", pluginPath);
+    parser = require.resolve('../parser')
+    const pluginPath = path.join(path.dirname(options.root), '../..')
+    rule = createRule(require(`../rules/${path.basename(options.root)}`))
+    Cache.set('pluginpath', pluginPath)
   } else {
     // Otherwise from project root
-    const resolvedPlugin = require.resolve("@sap/eslint-plugin-cds", {
-      paths: [options.root],
-    });
-    parser = path.join(path.dirname(resolvedPlugin), "parser");
-    rule = require(path.join(options.root, `../rules/${path.basename(options.root)}`));
-    const pluginPath = path.join(path.dirname(options.root), "../../..");
-    Cache.set("pluginpath", pluginPath);
+    const resolvedPlugin = require.resolve('@sap/eslint-plugin-cds', {
+      paths: [options.root]
+    })
+    parser = path.join(path.dirname(resolvedPlugin), 'parser')
+    rule = require(path.join(options.root, `../../rules/${path.basename(options.root)}`))
+    const pluginPath = path.join(path.dirname(options.root), '../../..')
+    Cache.set('pluginpath', pluginPath)
   }
-  let tester = new RuleTester({});
+  let tester = new RuleTester({})
   if (parser) {
-    tester = new RuleTester({ parser });
+    tester = new RuleTester({ parser })
   }
   const testerCases = {};
-  ["valid", "invalid"].forEach((type) => {
-    const filePath = path.join(options.root, `${type}/${options.filename}`);
-    Cache.set("rootpath", path.dirname(filePath));
-    _initModelRuleTester(filePath);
+  ['valid', 'invalid'].forEach((type) => {
+    const filePath = path.join(options.root, `${type}/${options.filename}`)
+    Cache.set('rootpath', path.dirname(filePath))
+    _initModelRuleTester(filePath, rule.meta?.model)
     testerCases[type] = [
       {
-        filename: filePath,
-      },
-    ];
-    if (!isConfiguredFileType(options.filename, "FILES")) {
-      const fileContents = JSON.parse(fs.readFileSync(filePath, "utf8"));
-      testerCases[type][0].code = "";
-      testerCases[type][0].filename = "<text>";
-      testerCases[type][0].options = [{ environment: fileContents }];
+        filename: filePath
+      }
+    ]
+    if (!isConfiguredFileType(options.filename, 'FILES')) {
+      const fileContents = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+      testerCases[type][0].code = ''
+      testerCases[type][0].filename = '<text>'
+      testerCases[type][0].options = [{ environment: fileContents }]
     } else {
-      testerCases[type][0].code = fs.readFileSync(filePath, "utf8");
+      testerCases[type][0].code = fs.readFileSync(filePath, 'utf8')
       if (options.options) {
-        testerCases[type][0].options = options.options;
+        testerCases[type][0].options = options.options
       }
     }
-    if (type === "invalid") {
-      testerCases[type][0].errors = options.errors;
-      const fileFixed = path.join(options.root, `fixed/${options.filename}`);
-      if (fs.existsSync(fileFixed) && rule.meta.type !== "suggestion") {
-        testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
+    if (type === 'invalid') {
+      testerCases[type][0].errors = options.errors
+      const fileFixed = path.join(options.root, `fixed/${options.filename}`)
+      if (fs.existsSync(fileFixed) && rule.meta.type !== 'suggestion') {
+        testerCases[type][0].output = fs.readFileSync(fileFixed, 'utf8')
       }
     }
-  });
-  return tester.run(rulename, rule, testerCases);
+  })
+  if (Cache.get('testerCases')) {
+    Cache.set(`testerCases:${rulename}`, testerCases)
+  }
+  return tester.run(rulename, rule, testerCases)
 }
 
 /**
  * Creates a model for ESLint unit tests
  */
-function _initModelRuleTester(filePath) {
-  Cache.set("test", true);
-  const rootPath = path.dirname(filePath);
-  Cache.set("rootpath", rootPath);
-  let files = fs.readdirSync(rootPath);
-  const modelfiles = files.map((f) => path.join(rootPath, f)).filter((fp) => isConfiguredFileType(fp, "MODEL_FILES"));
-  Cache.set(`modelfiles:${rootPath}`, modelfiles);
-  const dictFiles = _getDictFiles(rootPath, modelfiles);
-  Cache.set(`dictfiles:${rootPath}`, dictFiles);
-  const reflectedModel = compileModelFromDict(dictFiles);
-  Cache.set(`model:${rootPath}`, reflectedModel);
+function _initModelRuleTester (filePath, flavor) {
+  Cache.set('test', true)
+  const rootPath = path.dirname(filePath)
+  Cache.set('rootpath', rootPath)
+  if (flavor !== 'none') { // not for env rules
+    const files = fs.readdirSync(rootPath)
+    const modelfiles = files.map((f) => path.join(rootPath, f)).filter((fp) => isConfiguredFileType(fp, 'MODEL_FILES'))
+    Cache.set(`modelfiles:${rootPath}`, modelfiles)
+    const dictFiles = _getDictFiles(rootPath, modelfiles)
+    Cache.set(`dictfiles:${rootPath}`, dictFiles)
+    const reflectedModel = compileModelFromDict(dictFiles, { flavor })
+    Cache.set(`model:${rootPath}`, reflectedModel)
+  }
 }
 
-  /**
+/**
    * Creates or updates a dictionary of files/file contents for a given
    * project path.
    * @param input
    * @param files
    * @returns dictFiles
    */
-   function _getDictFiles(input, files) {
-    let dictFiles = {};
-    if (Cache.has(`dictfiles:${input}`)) {
-      dictFiles = Cache.get(`dictfiles:${input}`);
-    } else {
-      files.forEach((file) => {
-        dictFiles[file] = Cache.has(`file:${file}`)
-                          ? Cache.get(`file:${file}`)
-                          : fs.readFileSync(file, "utf8")
-      });
-    }
-    return dictFiles;
+function _getDictFiles (input, files) {
+  let dictFiles = {}
+  if (Cache.has(`dictfiles:${input}`)) {
+    dictFiles = Cache.get(`dictfiles:${input}`)
+  } else {
+    files.forEach((file) => {
+      dictFiles[file] = Cache.has(`file:${file}`)
+        ? Cache.get(`file:${file}`)
+        : fs.readFileSync(file, 'utf8')
+    })
   }
+  return dictFiles
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/eslint-plugin-cds",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "ESLint plugin including recommended SAP Cloud Application Programming model and environment rules",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -23,6 +23,12 @@
     "@sap/cds": ">=5.6.0",
     "semver": "^7.3.4"
   },
+  "eslintConfig": {
+    "extends": [
+      "eslint:recommended",
+      "standard"
+    ]
+  },
   "peerDependencies": {
     "eslint": ">=7"
   },

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

@@ -1,25 +0,0 @@
-module.exports = {
-  meta: {
-    docs: {
-      description: `Draft-enabled entities shall not be used in views that make use of \`JOIN\`.`,
-      recommended: true
-    },
-    type: "suggestion",
-    model: "inferred"
-  },
-  create: function (context) {
-    return { entity: check_nojoin_draftenabled };
-
-    function check_nojoin_draftenabled(e) {
-      if (e["@odata.draft.enabled"]) {
-        if (e.query.SELECT.from.join) {
-          context.report({
-            message: `Do not use draft-enabled entities in views that make use of \`JOIN\`.`,
-            node: context.getNode(e),
-            file: e.$location.file
-          });
-        }
-      }
-    }
-  }
-};