@sap/eslint-plugin-cds 3.1.1 → 3.2.0

package/CHANGELOG.md

@@ -2,16 +2,35 @@
 
 All notable changes to this project will be documented in this file.
 
-This project adheres to [Semantic Versioning](http://semver.org/).
+This project adheres to [Semantic Versioning](https://semver.org/).
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/).
+
+## [3.2.0] - 2025-03-03
+
+### Changed
+
+- Rules `@sap/cds/sql-null-comparison` and `@sap/cds/no-java-keywords` are moved from the `experimental` rule set to `all`.
+
+### Fixed
+
+- Rules `@sap/cds/sql-null-comparison` will not warn about `!= null`, as it may be supported by future CDS compiler versions.
+- Some rules had `docs` meta property `recommended: true`, but were not part of the recommended rules list.
+- When determining a CDS project's root directory, we now consider package.json's with `@sap/cds` as `devDependency` or `peerDependency`
+
+## [3.1.2] - 2024-10-31
+
+### Fixed
+
+- run inferred rules correctly on Microsoft Windows
 
-The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ## [3.1.1] - 2024-10-08
 
 ### Changed
 
 - `no-db-keywords` is no longer part of the 'recommended' rules,
-  as the cds-compiler takes care of quoting SQL keywords, if they are used as identifiers. 
+  as the cds-compiler takes care of quoting SQL keywords, if they are used as identifiers.
 
 ### Fixed
 

package/lib/conf/all.js

@@ -18,4 +18,6 @@ module.exports = {
   '@sap/cds/start-entities-uppercase': 'error',
   '@sap/cds/valid-csv-header': 'error',
   '@sap/cds/extension-restrictions': 'error',
+  '@sap/cds/sql-null-comparison': 'warn',
+  '@sap/cds/no-java-keywords': 'warn',
 }

package/lib/conf/experimental.js

@@ -7,6 +7,5 @@
 // to "all" or even "recommended".
 
 module.exports = {
-  '@sap/cds/sql-null-comparison': 'warn',
-  '@sap/cds/no-java-keywords': 'error',
+  // '@sap/cds/my-rule': 'warn',
 }

package/lib/index.js

@@ -16,8 +16,6 @@
  * - Expose any 'rules' for use in ESLint
  */
 
-const path = require('node:path')
-
 const api = require('./api')
 const getConfigs = require('./conf')
 const rules = Object.assign(
@@ -25,7 +23,7 @@ const rules = Object.assign(
   ...Object.entries(require('./rules')).map(([k, v]) => ({ [k]: v() }))
 )
 
-const packageJson = require(path.join(__dirname, '../package.json'))
+const packageJson = require('../package.json')
 
 const plugin = {
   meta: {

package/lib/parser.js

@@ -11,53 +11,65 @@
  * (parserOptions).
  */
 const cds = require('@sap/cds')
-const Cache = require('./utils/Cache')
+const { globalCache } = require('./utils/Cache')
 const LOG = cds.debug('lint:plugin')
 const colors = require('./utils/Colors')
 const { splitDefName } = require('./utils/rules')
+const packageJson = require('../package.json')
+
+const newLineRegEx = /\r\n?|\n/g
 
 module.exports = {
-  parse: function (code, options) {
-    return module.exports.parseForESLint(code, options).ast
+  meta: {
+    name: packageJson.name,
+    version: packageJson.version
+  },
+  parse(code, parserOptions) {
+    return module.exports.parseForESLint(code, parserOptions).ast
   },
-  parseForESLint: function (code) {
+  // See https://eslint.org/docs/latest/extend/custom-parsers#parseforeslint-return-object
+  // eslint-disable-next-line no-unused-vars
+  parseForESLint(code, parserOptions) {
     return {
       ast: createProgramAST(code),
       services: {
         getParsedCsn: function () {
+          const compileOptions = {
+            messages: [],
+          }
           let compiledModel
           let reflectedModel
-          const messages = []
           try {
-            compiledModel = cds.parse(code)
+            compiledModel = cds.parse(code, compileOptions)
           } catch {
             // Do nothing
           }
           if (compiledModel) {
             try {
               reflectedModel = cds.linked(compiledModel)
-              if (messages) {
-                reflectedModel.messages = messages
+              if (compileOptions.messages) {
+                reflectedModel.messages = compileOptions.messages
               }
             } catch (err) {
-              LOG && LOG(colors.red + 'ERROR:' + colors.reset, err)
-              LOG && LOG('COMPILED', compiledModel)
-              LOG && LOG('REFLECTED', reflectedModel)
+              LOG?.(colors.red + 'ERROR:' + colors.reset, err)
+              LOG?.('COMPILED', compiledModel)
+              LOG?.('REFLECTED', reflectedModel)
             }
           }
           return reflectedModel
         },
+
         getInferredCsn: function () {
-          const rootPath = Cache.get('rootpath')
-          if (Cache.has('test')) {
-            return Cache.get(`model:${rootPath}`)
+          const rootPath = globalCache.get('rootpath')
+          if (globalCache.has('test')) {
+            return globalCache.get(`model:${rootPath}`)
           }
           let compiledModel
           let reflectedModel
           cds.resolve.cache = {}
 
-          if (!Cache.has(`model:${rootPath}`) && rootPath) {
-            const roots = Cache.get(`roots:${rootPath}`)
+          if (!globalCache.has(`model:${rootPath}`) && rootPath) {
+            const roots = globalCache.get(`roots:${rootPath}`)
             const messages = []
             if (roots) {
               try {
@@ -67,27 +79,28 @@ module.exports = {
                   locations: true,
                   messages
                 })
-                Cache.remove('errRootModel')
+                globalCache.remove('errRootModel')
               } catch (err) {
-                Cache.set('errRootModel', err)
+                // TODO: Only catch Compile Errors?
+                globalCache.set('errRootModel', err)
               }
               if (compiledModel) {
                 reflectedModel = cds.linked(compiledModel)
-                Cache.set(`model:${Cache.get('rootpath')}`, reflectedModel)
+                globalCache.set(`model:${globalCache.get('rootpath')}`, reflectedModel)
                 if (messages) {
                   reflectedModel.messages = messages
                 }
               }
             }
           } else {
-            reflectedModel = Cache.get(`model:${rootPath}`)
+            reflectedModel = globalCache.get(`model:${rootPath}`)
           }
           return reflectedModel
         },
         updateInferredCsn: compileModelFromDict,
         getEnvironment: function () {
-          const options = Cache.get('options')
-          return (options && options[0] && options[0].environment) ? options[0].environment : undefined
+          const options = globalCache.get('options')
+          return options?.[0]?.environment
         },
         getLocation: function (name, obj, model) {
           let loc
@@ -141,27 +154,37 @@ module.exports = {
     }
   },
   createProgramAST,
-  compileModelFromDict
+  compileModelFromDict,
 }
 
 /**
- * Generates dummy AST with just single Program node
+ * Generates dummy AST with just single Program node.
  *
  * @param code Parse file contents
  * @param {object} [loc]
- * @returns AST
+ * @returns ESLint AST
  */
 function createProgramAST (code, loc) {
-  loc = loc || {
-    start: {
-      line: 1,
-      column: 0
-    },
-    end: {
-      line: 1,
-      column: 0
+  if (!loc && code.length) {
+    const newLines = [...code.matchAll(newLineRegEx)]
+    const endColumn = newLines.length ? (code.length - newLines.at(-1).index) : code.length
+    loc = {
+      start: {
+        line: 1,
+        column: 1
+      },
+      end: {
+        line: newLines.length + 1,
+        column: endColumn
+      },
+    }
+  } else if (!loc) {
+    loc = {
+      start: { line: 0, column: 0 },
+      end: { line: 0, column: 0 },
     }
   }
+
   return {
     type: 'Program',
     body: [],

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

@@ -12,7 +12,7 @@ module.exports = {
         'Ambiguous key with a `TO MANY` relationship since entries could appear multiple times with the same key.',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/assoc2many-ambiguous-key',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/assoc2many-ambiguous-key',
     },
     messages: {
       ambiguous: `Ambiguous key in '{{name}}'. Element '{{column-name}}' leads to multiple entries so that key '{{key-name}}' is not unique.`,

package/lib/rules/auth-no-empty-restrictions.js

@@ -9,7 +9,7 @@ module.exports = {
       description: '`@restrict` and `@requires` must not be empty.',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/auth-no-empty-restrictions',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/auth-no-empty-restrictions',
     },
     messages: {
       missingRestriction: 'No explicit restrictions provided on {{kind}} `{{name}}` at `{{label}}`.',

package/lib/rules/auth-restrict-grant-service.js

@@ -7,7 +7,7 @@ module.exports = {
       description: '`@restrict.grant` on service level and for bound/unbound actions and functions is limited to grant: \'*\'',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/auth-restrict-grant-service',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/auth-restrict-grant-service',
     },
     messages: {
       limitedGrant: `The grant value provided in @restrict is limited to '*' for {{kind}} '{{name}}'`,

package/lib/rules/auth-use-requires.js

@@ -8,7 +8,7 @@ module.exports = {
       category: 'Model Validation',
       recommended: true,
       version: '2.4.1',
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/auth-use-requires',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/auth-use-requires',
     },
     messages: {
       useRequires: 'Use `@requires` instead of `@restrict.to` at {{kind}} `{{name}}`.'

package/lib/rules/auth-valid-restrict-grant.js

@@ -20,7 +20,7 @@ module.exports = {
       description: '`@restrict.grant` must have valid values.',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/auth-valid-restrict-grant',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/auth-valid-restrict-grant',
     },
     messages: {
       invalidType: 'Invalid type for grant value. Must either be string or array of strings.',

package/lib/rules/auth-valid-restrict-keys.js

@@ -13,7 +13,7 @@ module.exports = {
       description: '`@restrict` must not have properties besides `to`, `grant`, and `where`.',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/auth-valid-restrict-keys',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/auth-valid-restrict-keys',
     },
     messages: {
       misspelledProperty: "Misspelled or unknown property '{{invalid}}'. Did you mean '{{candidates}}'?",

package/lib/rules/auth-valid-restrict-to.js

@@ -9,7 +9,7 @@ module.exports = {
       description: '`@restrict.to` must have valid values.',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/auth-valid-restrict-to',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/auth-valid-restrict-to',
     },
     messages: {
       invalidType: 'Invalid type for value of `@restrict.to`. Must either be string or array of strings.',

package/lib/rules/auth-valid-restrict-where.js

@@ -9,7 +9,7 @@ module.exports = {
       description: '`@restrict.where` must have valid values.',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/auth-valid-restrict-where',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/auth-valid-restrict-where',
     },
     severity: 'error',
     messages: {

package/lib/rules/extension-restrictions.js

@@ -10,7 +10,7 @@ const rule = module.exports = {
       description: 'Extensions must not violate restrictions set by the extended SaaS app.',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/extension-restrictions',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/extension-restrictions',
     },
     hasSuggestions: false,
     type: 'problem',

package/lib/rules/index.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const Cache = require('../utils/Cache')
+const { globalCache } = require('../utils/Cache')
 const createRule = require('../utils/createRule')
 
 const rules = {
@@ -25,6 +25,6 @@ const rules = {
   'extension-restrictions': () => createRule(require('./extension-restrictions'))
 }
 
-Cache.set('rules', rules)
+globalCache.set('rules', rules)
 
 module.exports = rules

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

@@ -12,8 +12,7 @@ module.exports = {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
       description: 'Avoid using reserved SQL keywords.',
-      recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/no-db-keywords',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/no-db-keywords',
     },
     messages: {
       reservedKeyword: `'{{name}}' is a reserved keyword in SQLite`,

package/lib/rules/no-dollar-prefixed-names.js

@@ -6,7 +6,7 @@ module.exports = {
     docs: {
       description: 'Names must not start with $ to avoid possible shadowing of reserved variables.',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/no-dollar-prefixed-names',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/no-dollar-prefixed-names',
     },
     messages: {
       dollarPrefix: `'{{name}}' is prefixed with a dollar sign ($)`,

package/lib/rules/no-java-keywords.js

@@ -27,7 +27,7 @@ module.exports = {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
       description: 'Reject reserved Java keywords as CDS identifiers.',
-      recommended: true
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/no-java-keywords',
     },
     type: 'problem',
     model: 'inferred',

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

@@ -6,7 +6,7 @@ module.exports = {
     docs: {
       description: 'Draft-enabled entities shall not be used in views that make use of `JOIN`.',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/no-join-on-draft',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/no-join-on-draft',
     },
     messages: {
       draftJoin:  'Do not use draft-enabled entities in views that make use of `JOIN`.',

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

@@ -6,7 +6,7 @@ module.exports = {
     docs: {
       description: 'Should make suggestions for possible missing SQL casts.',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/sql-cast-suggestion',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/sql-cast-suggestion',
     },
     type: 'suggestion',
     messages: {

package/lib/rules/sql-null-comparison.js

@@ -2,7 +2,7 @@
 
 const { forEachXprInDefinition } = require('../utils/csnTraversal')
 
-const invalidComparisonOperators = [ '=', '!=', '<>' ]
+const invalidComparisonOperators = [ '=', '<>' ]
 
 module.exports = {
   meta: {
@@ -12,12 +12,12 @@ module.exports = {
       category: 'Model Validation',
       recommended: false,
       // TODO: Add documentation
-      // url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/sql-null-comparison',
+      // url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/sql-null-comparison',
     },
     type: 'problem',
     model: 'parsed',
     messages: {
-      nullComparison: `Comparisons against 'null' are always null. Did you mean 'is not null'?`,
+      nullComparison: `Comparisons against 'null' using '=' and '<>' are always null. Did you mean 'is null'/'is not null'?`,
     }
   },
   create(context) {

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

@@ -1,63 +1,64 @@
 'use strict'
 
+const allowedUpperCaseElements = ['ID']
+
 module.exports = {
   meta: {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
       description: 'Regular element names should start with lowercase letters.',
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/start-elements-lowercase',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/start-elements-lowercase',
     },
     type: 'suggestion',
-    hasSuggestions: true,
     messages: {
-      startLowercase: "Element name '{{entityName}}.{{elementName}}' should start with a lowercase letter.",
-      fixLowercase: 'Start element name with a lowercase letter.'
+      startLowercase: "Element name '{{defName}}:{{elementName}}' should start with a lowercase letter.",
     },
     fixable: 'code',
     model: 'parsed',
   },
   create: function (context) {
-    const sourcecode = context.getSourceCode()
+    const model = context.getModel()
+    if (!model?.definitions)
+      return
 
-    return {
-      element: checkStartLowercase
+    return function checkAllElementsStartWithLowercase() {
+      for (const defName in model.definitions)
+        checkDefinition(defName, model.definitions[defName])
     }
 
-    function checkStartLowercase (e) {
-      const elementName = e.name
-      const entityName = e.parent.name
-      if (elementName && !(entityName.startsWith('localized') || entityName.endsWith('texts'))) {
-        if (elementName.charAt(0) !== elementName.charAt(0).toLowerCase() && !['ID'].includes(elementName)) {
-          if (e.$location && e.$location.file) {
-            const file = e.$location.file
-            const loc = context.getLocation(elementName, e)
-            const fix = (fixer, source = sourcecode) => {
-              const elementNameSanitized = elementName.charAt(0).toLowerCase() + elementName.slice(1)
-              const rangeEnd = source.getIndexFromLoc({
-                line: loc.end.line,
-                column: loc.end.column
-              })
-              const rangeBeg = rangeEnd ? rangeEnd - elementNameSanitized.length : 0
-              return fixer.replaceTextRange([rangeBeg, rangeEnd], elementNameSanitized)
-            }
-            context.report({
-              messageId: 'startLowercase',
-              loc,
-              file,
-              data: {
-                entityName,
-                elementName
-              },
-              suggest: [
-                {
-                  messageId: 'fixLowercase',
-                  fix
-                }
-              ]
-            })
+    function checkDefinition(defName, def) {
+      if (defName.startsWith('localized') || defName.endsWith('texts'))
+        return
+
+      checkElements(def)
+
+      function checkElements(art) {
+        if (art.elements) {
+          for (const elementName in art.elements) {
+            const element = art.elements[elementName]
+            checkStartLowercase(element, elementName)
+            checkElements(element)
           }
         }
       }
+
+      function checkStartLowercase (element, elementName) {
+        if (!element.$location?.file)
+          return // without location, we can't report anything properly
+
+        if (elementName.charAt(0) !== elementName.charAt(0).toLowerCase()
+            && !allowedUpperCaseElements.includes(elementName)) {
+          context.report({
+            messageId: 'startLowercase',
+            loc: context.getLocation(elementName, element),
+            file: element.$location.file,
+            data: {
+              defName,
+              elementName
+            }
+          })
+        }
+      }
     }
   }
 }

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

@@ -7,53 +7,41 @@ module.exports = {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
       description: 'Regular entity names should start with uppercase letters.',
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/start-entities-uppercase',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/start-entities-uppercase',
     },
     type: 'suggestion',
-    hasSuggestions: true,
     messages: {
       startUppercase: "Entity name '{{entityName}}' should start with an uppercase letter.",
-      fixUppercase: 'Start entity name with an uppercase letter.'
     },
     fixable: 'code',
     model: 'parsed',
   },
   create(context) {
-    const sourcecode = context.getSourceCode()
+    const model = context.getModel()
+    if (!model?.definitions)
+      return
 
-    return { entity: checkStartsUppercase }
+    return function checkAllEntitiesStartWithUppercase() {
+      for (const defName in model.definitions) {
+        const def = model.definitions[defName]
+        if (def.kind === 'entity') {
+          checkEntityStartsUppercase(defName, def)
+        }
+      }
+    }
 
-    function checkStartsUppercase (e) {
-      if (e.kind !== 'entity')
-        return // workaround for #424
+    function checkEntityStartsUppercase(name, entity) {
+      if (!entity.$location?.file)
+        return // without location, we can't report anything properly
 
-      const entityName = splitDefName(e).name
+      const entityName = splitDefName(entity, name).name
       if (entityName.charAt(0) !== entityName.charAt(0).toUpperCase()) {
-        if (e.$location?.file) {
-          const file = e.$location.file
-          const loc = context.getLocation(entityName, e)
-          const fix = fixer => {
-            const entityNameSanitized = entityName.charAt(0).toUpperCase() + entityName.slice(1)
-            const rangeEnd = sourcecode.getIndexFromLoc({
-              line: loc.end.line,
-              column: loc.end.column
-            })
-            const rangeBeg = rangeEnd ? rangeEnd - entityNameSanitized.length : 0
-            return fixer.replaceTextRange([rangeBeg, rangeEnd], entityNameSanitized)
-          }
-          context.report({
-            messageId: 'startUppercase',
-            loc,
-            file,
-            data: { entityName },
-            suggest: [
-              {
-                messageId: 'fixUppercase',
-                fix
-              }
-            ]
-          })
-        }
+        context.report({
+          messageId: 'startUppercase',
+          loc: context.getLocation(entityName, entity),
+          file: entity.$location.file,
+          data: { entityName },
+        })
       }
     }
   }

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

@@ -13,7 +13,7 @@ module.exports = {
       description: 'CSV files for entities must refer to valid element names.',
       category: 'Model Validation',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/valid-csv-header',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/valid-csv-header',
     },
     severity: 'warn',
     type: 'problem',

package/lib/utils/Cache.js

@@ -1,35 +1,38 @@
 'use strict'
 
-/**
- * Simple cache to store model and any cds calls made in the rule creation
- * api to modify the model
- */
-const cache = new Map()
 
-module.exports = {
+class Cache {
+  #entries = new Map()
+
   has (key) {
-    return cache.has(key)
-  },
+    return this.#entries.has(key)
+  }
   set (key, value) {
-    return cache.set(key, [value, Date.now()])
-  },
+    return this.#entries.set(key, [value, Date.now()])
+  }
   get (key) {
-    return cache.get(key) ? cache.get(key)[0] : undefined
-  },
+    return this.#entries.has(key) ? this.#entries.get(key)[0] : undefined
+  }
   dump () {
     const dump = {}
-    for (const [key, value] of cache.entries()) {
+    for (const [key, value] of this.#entries.entries()) {
       const timestamp = new Date(value[1])
       dump[key] = { key, value: value[0], timestamp }
     }
     return JSON.stringify(dump, null, 2)
-  },
+  }
   remove (key) {
-    if (cache.has(key)) {
-      cache.delete(key)
+    if (this.#entries.has(key)) {
+      this.#entries.delete(key)
     }
-  },
+  }
   clear () {
-    cache.clear()
+    this.#entries.clear()
   }
 }
+
+
+module.exports = {
+  Cache,
+  globalCache: new Cache(),
+}

package/lib/utils/createRule.js

@@ -17,10 +17,10 @@ const fs = require('fs')
 const path = require('path')
 const cds = require('@sap/cds')
 
-const Cache = require('./Cache')
+const { globalCache } = require('./Cache')
 const constants = require('../constants')
 const isConfiguredFileType = require('./isConfiguredFileType')
-const getProjectRootPath = require('./getProjectRootPath')
+const { getProjectRootPath, hasProjectRoots } = require('./projectRootPath')
 const { CdsLintAssertionError } = require('./LintError')
 
 const LOG = cds.debug('lint:plugin')
@@ -48,18 +48,18 @@ module.exports = function createRule(spec) {
         Program: node => {
           const file = context.getFilename()
           if (file !== filePrev) {
-            LOG && LOG(`File: ${context.getFilename()}`)
+            LOG?.(`File: ${context.getFilename()}`)
           }
-          const cdscontext = extendContext(node, context, meta)
-          Cache.set('context', cdscontext)
-          const { isTest, isValidFile, doEnvironmentChecks, doRootModelChecks, showInEditor } = checkEntryCriteria(meta, cdscontext)
+          const cdsContext = extendContext(node, context, meta)
+          globalCache.set('context', cdsContext)
+          const { isTest, isValidFile, doEnvironmentChecks, doRootModelChecks, showInEditor } = checkEntryCriteria(meta, cdsContext)
           switch (meta.model) {
           case 'none':
             if (doEnvironmentChecks) {
-              if (isTest || !Cache.has(`rule:${cdscontext.id}`)) {
-                LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
-                Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
-                createReport(node, cdscontext, meta, create)
+              if (isTest || !globalCache.has(`rule:${cdsContext.id}`)) {
+                LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
+                globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
+                createReport(node, cdsContext, meta, create)
               }
             }
             break
@@ -67,24 +67,24 @@ module.exports = function createRule(spec) {
           case 'inferred':
             if (isValidFile && doRootModelChecks) {
               if (showInEditor) {
-                Cache.remove(`model:${Cache.get('rootpath')}`)
-                Cache.remove(`rule:${cdscontext.id}:${Cache.get('rootpath')}`)
-                Cache.remove(`report:${context.getFilename()}:${context.id}`)
+                globalCache.remove(`model:${globalCache.get('rootpath')}`)
+                globalCache.remove(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`)
+                globalCache.remove(`report:${context.getFilename()}:${context.id}`)
               }
-              if (isTest || showInEditor || !Cache.has(`rule:${cdscontext.id}:${Cache.get('rootpath')}`)) {
-                LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
+              if (isTest || showInEditor || !globalCache.has(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`)) {
+                LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
                 if (!showInEditor) {
-                  Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
+                  globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
                 }
-                createReport(node, cdscontext, meta, create)
+                createReport(node, cdsContext, meta, create)
               } else {
-                if (Cache.has(`report:${context.getFilename()}:${context.id}`)) {
-                  const reports = Cache.get(`report:${context.getFilename()}:${context.id}`)
+                if (globalCache.has(`report:${context.getFilename()}:${context.id}`)) {
+                  const reports = globalCache.get(`report:${context.getFilename()}:${context.id}`)
                   for (const r of Array.from(reports)) {
                     context.report(JSON.parse(r))
                   }
-                  Cache.remove(`report:${context.getFilename()}:${context.id}`)
-                  Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
+                  globalCache.remove(`report:${context.getFilename()}:${context.id}`)
+                  globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
                 }
               }
             }
@@ -92,8 +92,8 @@ module.exports = function createRule(spec) {
 
           default:
             if (isValidFile) {
-              LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
-              createReport(node, cdscontext, meta, create)
+              LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
+              createReport(node, cdsContext, meta, create)
             }
             break
           }
@@ -105,22 +105,21 @@ module.exports = function createRule(spec) {
 }
 
 function isRunningWithCDSLint () {
-  return process.argv[0].endsWith('node') && process.argv[1].endsWith('cds') && process.argv[2] === 'lint'
+  return process.argv[1].match(/cds(\.js)?$/) && process.argv[2]?.toLowerCase() === 'lint'
 }
 
 function isRunningWithESLint () {
-  return process.argv[0].endsWith('node') && process.argv[1].endsWith('eslint')
+  return process.argv[1].match(/eslint(\.js)?$/)
 }
 
-function checkEntryCriteria (meta, cdscontext) {
-  const isTest = Cache.has('test')
-  const showInEditor = cdscontext.options.includes('show')
-  const hasProjectRoots = Cache.has(`roots:${Cache.get('rootpath')}`)
-  const isValidFile = isConfiguredFileType(cdscontext.getFilename(), 'FILES')
-  const doRootModelChecks = isTest || (hasProjectRoots && (isRunningWithCDSLint() || isRunningWithESLint()) || showInEditor)
+function checkEntryCriteria (meta, cdsContext) {
+  const isTest = globalCache.has('test')
+  const showInEditor = cdsContext.options.includes('show')
+  const isValidFile = isConfiguredFileType(cdsContext.getFilename(), 'FILES')
+  const doRootModelChecks = isTest || (hasProjectRoots() && (isRunningWithCDSLint() || isRunningWithESLint()) || showInEditor)
   // Lint all env rules independent of any parsed file (i.e. 'cds lint' uses the lintText "" API)
   const doEnvironmentChecks =
-    isTest || (isRunningWithCDSLint() && cdscontext.getFilename() === '<text>')
+    isTest || (isRunningWithCDSLint() && cdsContext.getFilename() === '<text>')
   return { isTest, isValidFile, doRootModelChecks, doEnvironmentChecks, showInEditor }
 }
 
@@ -196,11 +195,11 @@ function sanitizeFileLocation (d) {
  * @param meta
  */
 function extendContext (node, context, meta) {
-  if (!Cache.has('test')) {
+  if (!globalCache.has('test')) {
     const filePath = context.getFilename()
     const rootPath = filePath && fs.existsSync(filePath) ? getProjectRootPath(filePath) : ''
     if (rootPath) {
-      Cache.set('rootpath', rootPath)
+      globalCache.set('rootpath', rootPath)
     }
   }
 
@@ -222,7 +221,7 @@ function extendContext (node, context, meta) {
   }
   cdscontext.getLocation = parserServices.getLocation
   cdscontext.getNode = Object.keys(parserServices).length > 0 ? parserServices.getNode : () => node
-  cdscontext.getRootPath = () => Cache.get('rootpath')
+  cdscontext.getRootPath = () => globalCache.get('rootpath')
   return cdscontext
 
   function reportWrapper(r) {
@@ -232,7 +231,7 @@ function extendContext (node, context, meta) {
         if (!r.file) {
           throw new CdsLintAssertionError(`Rule ${context.id} must return a "file" property in the rule report!`)
         }
-        const file = Cache.get('rootpath') ? resolveFilePath(r.file) : r.file
+        const file = globalCache.get('rootpath') ? resolveFilePath(r.file) : r.file
         if (cdscontext.getFilename() === file) {
           delete r.file
           context.report(r)
@@ -280,11 +279,11 @@ function cacheReport (r, filepath, context, meta) {
   }
   if (r) {
     let reports = new Set()
-    if (Cache.has(`report:${filepath}:${context.id}`)) {
-      reports = Cache.get(`report:${filepath}:${context.id}`)
+    if (globalCache.has(`report:${filepath}:${context.id}`)) {
+      reports = globalCache.get(`report:${filepath}:${context.id}`)
     }
     reports.add(JSON.stringify(r))
-    Cache.set(`report:${filepath}:${context.id}`, reports)
+    globalCache.set(`report:${filepath}:${context.id}`, reports)
   }
 }
 
@@ -295,7 +294,7 @@ function cacheReport (r, filepath, context, meta) {
  */
 function getDisabled (code, sourcecode, line) {
   const listDisabled = []
-  const rules = Cache.get('rules')
+  const rules = globalCache.get('rules')
   const rulesDisabled = Object.keys(rules).reduce((o, key) => ({ ...o, [key]: 'on' }), {})
   if (code) {
     const matches = [...code.matchAll(REGEX_COMMENTS)]
@@ -375,5 +374,5 @@ function getLastLine (code) {
  * @param {string} file
  */
 function resolveFilePath (file) {
-  return path.isAbsolute(file) ? file : path.join(Cache.get('rootpath'), file)
+  return path.isAbsolute(file) ? file : path.join(globalCache.get('rootpath'), file)
 }

package/lib/utils/{getProjectRootPath.js → projectRootPath.js}

@@ -2,13 +2,13 @@
 
 const path = require('node:path')
 const cds = require('@sap/cds')
-const Cache = require('./Cache')
+const { globalCache } = require('./Cache')
 const fs = require('node:fs')
 
 const commonCapProjectFiles = ['build.gradle', '.git', 'srv', 'db', 'app']
 
 /**
- * Searches for directory containing cds roots
+ * Searches for a directory containing cds roots.
  *
  * As of today, there is no unified way to find the root directory for a CDS project.
  * ("The root is wherever the user typed `cds init`")
@@ -20,9 +20,8 @@ const commonCapProjectFiles = ['build.gradle', '.git', 'srv', 'db', 'app']
  * @param {string} currentDir start here and search until root dir
  * @returns {string} dir containing cds roots (empty if not exists)
  */
-module.exports = function getProjectRootPath(currentDir = '.') {
+function getProjectRootPath(currentDir = '.') {
   let dir = path.resolve(currentDir)
-
   while (!couldBeProjectRoot(dir)) {
     if (dir === path.resolve(dir, '..'))
       return '' // we reached the file system root -> abort
@@ -32,7 +31,7 @@ module.exports = function getProjectRootPath(currentDir = '.') {
   cds.resolve.cache = {}
   const roots = cds.resolve('*', { root: dir })
   if (roots?.length > 0) {
-    Cache.set(`roots:${dir}`, roots)
+    globalCache.set(`roots:${dir}`, roots)
     return dir
   }
   return ''
@@ -56,8 +55,21 @@ function isRootPackageJson(filepath) {
 
   try {
     const config = JSON.parse(fs.readFileSync(filepath, 'utf8'))
-    return Object.keys(config?.dependencies ?? {}).some(dep => dep === '@sap/cds')
+    return config && (config.cds ||
+      hasCdsPackage(config.dependencies) ||
+      hasCdsPackage(config.peerDependencies) ||
+      hasCdsPackage(config.devDependencies))
+
   } catch {
     return false
   }
 }
+
+function hasCdsPackage(deps) {
+  return deps && (('@sap/cds' in deps) || ('@sap/cds-dk' in deps))
+}
+
+module.exports = {
+  getProjectRootPath,
+  hasProjectRoots: () => globalCache.has(`roots:${globalCache.get('rootpath')}`),
+}

package/lib/utils/runRuleTester.js

@@ -6,7 +6,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 
 const { Linter, RuleTester } = require('eslint')
-const Cache = require('./Cache')
+const { globalCache } = require('./Cache')
 const isConfiguredFileType = require('./isConfiguredFileType')
 const { compileModelFromDict } = require('../parser')
 const rules = require('../rules')
@@ -29,7 +29,7 @@ function testRuleWrapper(rule) {
         _initModelRuleTester(filePath, rule.meta.model)
         const createValue = rule.create(context)
         const result = createValue.Program(node)
-        Cache.clear()
+        globalCache.clear()
         return result
       }
     }
@@ -114,18 +114,18 @@ module.exports = function runRuleTester(options) {
  * @param {string} flavor
  */
 function _initModelRuleTester(filePath, flavor) {
-  Cache.set('rules', rules)
-  Cache.set('test', true)
+  globalCache.set('rules', rules)
+  globalCache.set('test', true)
   const rootPath = path.dirname(filePath)
-  Cache.set('rootpath', rootPath)
+  globalCache.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)
+    globalCache.set(`modelfiles:${rootPath}`, modelfiles)
     const dictFiles = _getDictFiles(rootPath, modelfiles)
-    Cache.set(`dictfiles:${rootPath}`, dictFiles)
+    globalCache.set(`dictfiles:${rootPath}`, dictFiles)
     const reflectedModel = compileModelFromDict(dictFiles, { flavor })
-    Cache.set(`model:${rootPath}`, reflectedModel)
+    globalCache.set(`model:${rootPath}`, reflectedModel)
   }
 }
 
@@ -139,12 +139,12 @@ function _initModelRuleTester(filePath, flavor) {
  */
 function _getDictFiles(input, filenames) {
   let dictFiles = {}
-  if (Cache.has(`dictfiles:${input}`)) {
-    dictFiles = Cache.get(`dictfiles:${input}`)
+  if (globalCache.has(`dictfiles:${input}`)) {
+    dictFiles = globalCache.get(`dictfiles:${input}`)
   } else {
     filenames.forEach(file => {
-      dictFiles[file] = Cache.has(`file:${file}`)
-        ? Cache.get(`file:${file}`)
+      dictFiles[file] = globalCache.has(`file:${file}`)
+        ? globalCache.get(`file:${file}`)
         : fs.readFileSync(file, 'utf8')
     })
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/eslint-plugin-cds",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "ESLint plugin including recommended SAP Cloud Application Programming model and environment rules",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -21,7 +21,7 @@
   ],
   "dependencies": {
     "@sap/cds": ">=7",
-    "semver": "^7.3.4"
+    "semver": "^7.7.1"
   },
   "peerDependencies": {
     "eslint": ">=8"