@sap/eslint-plugin-cds 4.1.2 → 4.2.2

package/CHANGELOG.md

@@ -6,6 +6,18 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.2.2] - 2026-05-04
+### Fixed
+- `auth-valid-restrict-grant` now also considers inherited actions.
+
+## [4.2.1] - 2026-02-26
+### Fixed
+- Removed usage of deprecated API in `lib/utils/rules.js`
+
+## [4.2.0] - 2026-02-26
+### Fixed
+- Use ESLint API supported by versions `9` and `10`.
+
 ## [4.1.2] - 2026-02-13
 ### Fixed
 - No longer crash on .java files larger than 32 kB.

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

@@ -8,6 +8,38 @@ const SAME_AS_WRITE_EVENT = [ 'CREATE', 'DELETE', 'UPDATE', 'UPSERT' ]
 // Note that 'INSERT' is not meant to be used by users. They should use 'CREATE' instead.
 const VALID_EVENTS = [ ...SAME_AS_WRITE_EVENT, 'READ', 'INSERT', '*', 'WRITE']
 
+const isJoin = e => Boolean(e.query?.SELECT?.from.join)
+const isProjection = e => Boolean(e.query?.SELECT?.from.ref)
+const isSetUnion = e => Boolean(e.query?.SET?.op === 'union')
+const projectionTarget = e => e.query.SELECT.from.ref[0]
+
+function extractActions (e, csn) {
+  const getActions = e => Object.keys(e.actions ?? {})
+  const queue = [e]
+  const actions = []
+  while (queue.length) {
+    const entity = queue.pop()
+    actions.push(...getActions(entity))
+    if (isJoin(entity)) {
+      for (const { ref } of entity.query.SELECT.from.args[0].args) {
+        const ancestor = csn.definitions[ref[0]]
+        if (ancestor) {
+          queue.push(ancestor)
+        }
+      }
+    } else if (isProjection(entity)) {
+      const ancestor = csn.definitions[projectionTarget(entity)]
+      if (ancestor) {
+        queue.push(ancestor)
+      }
+    } else if (isSetUnion(entity)) {
+      // these are entities/ queries themselves. Just queue those.
+      queue.push(...entity.query.SET.args.map(e => ({query: e}) ))
+    }
+  }
+  return actions
+}
+
 const TYPICAL_ISSUES = {
   __proto__: null,
   any: '*'
@@ -45,7 +77,7 @@ module.exports = {
 
       const node = context.getNode(e)
       const file = e.$location.file
-      const actionNames = e.actions ? Object.keys(e.actions) : []
+      const actionNames = extractActions(e, context.getModel())
       const validEventsAndActions = [ ...VALID_EVENTS, ...actionNames ]
 
       for (const entry of e['@restrict']) {

package/lib/rules/extension-restrictions.js

@@ -31,7 +31,7 @@ const rule = module.exports = {
       const base = baseModel(context)
       if (!base) return
 
-      const file = context.getFilename()
+      const file = context.filename
       const findings = rule.mtxApi().lint(extModel, base.model, base.env)
       for (const finding of findings) {
         context.report({
@@ -48,7 +48,7 @@ const rule = module.exports = {
  * @param {CDSRuleContext} context
  */
 function baseModel (context) {
-  let dir = context.getFilename()
+  let dir = context.filename
   do {
     dir = dirname(dir)
     const projEnv = cds.env.for('cds', dir)

package/lib/rules/java/cql-class-targets.js

@@ -25,13 +25,13 @@ module.exports = {
     const knownClasses = new Set()
 
     /** @param {Node} node */
-    const refersToClass = node =>
-      node.type === 'class_literal'
-      // or part of explicit named imports
-      || knownClasses.has(node.text)
-      // or first letter of last part of text is uppercase: a.b.C -> true
-      // https://unicode.org/reports/tr18/#General_Category_Property
-      || /^\p{Lu}/u.test(node.text.split('.').at(-1))
+    // const refersToClass = node =>
+    //   node.type === 'class_literal'
+    //   // or part of explicit named imports
+    //   || knownClasses.has(node.text)
+    //   // or first letter of last part of text is uppercase: a.b.C -> true
+    //   // https://unicode.org/reports/tr18/#General_Category_Property
+    //   || /^\p{Lu}/u.test(node.text.split('.').at(-1))
 
     const isString = node =>
       node?.type === 'string_literal'

package/lib/rules/js/CdsHandlerRule.js

@@ -13,7 +13,7 @@
  */
 const produceScope = name => ({ name, variables: [] })
 
-const produceHandlerRegistration = ({call, handler}) => ({ call, handler })
+const produceHandlerRegistration = ({ call, handler }) => ({ call, handler })
 
 // matches: @sap/cds, "@sap/cds", '@sap/cds', `@sap/cds`, but not @sap/cds-compiler etc
 const isSapCds = name => Boolean(name?.match(/^\W*@sap\/cds\W*$/))
@@ -21,15 +21,15 @@ const isSapCds = name => Boolean(name?.match(/^\W*@sap\/cds\W*$/))
 /**
  * @param {VariableType} type - type of the variable
  */
-const produceVariable = ({name, type, isCdsVariable, original}) => ({ name, type, original, isCdsVariable })
+const produceVariable = ({ name, type, isCdsVariable, original }) => ({ name, type, original, isCdsVariable })
 
 // like: require('@sap/cds')
 const isCdsRequire = node => Boolean(node?.type === 'CallExpression'
-        && node.callee.type === 'Identifier'
-        && node.callee.name === 'require'
-        && node.arguments.length === 1
-        && node.arguments[0].type === 'Literal'
-        && isSapCds(node.arguments[0].value))
+  && node.callee.type === 'Identifier'
+  && node.callee.name === 'require'
+  && node.arguments.length === 1
+  && node.arguments[0].type === 'Literal'
+  && isSapCds(node.arguments[0].value))
 
 // like: import ... from '@sap/cds'
 const isCdsImport = node => isSapCds(node?.source?.value)
@@ -39,13 +39,13 @@ const isFunctionBody = node => ['FunctionExpression', 'FunctionDeclaration', 'Ar
 
 class CdsHandlerRule {
   get isInsideCapService() { return this.capServiceStack.length > 0 }
-  get isInsideCapHandlerRegistration() {  return this.capHandlerRegistrationStack.length > 0 }
+  get isInsideCapHandlerRegistration() { return this.capHandlerRegistrationStack.length > 0 }
 
-  constructor (context) {
+  constructor(context) {
     /** @type {import('eslint').Rule.RuleContext} */
     this.context = context
     /** @type {Scope[]} */
-    this.functionScopes = [ produceScope('<global>') ]
+    this.functionScopes = [produceScope('<global>')]
     this.capServiceStack = []  // stack of class bodies. Should probably never be more than one...
     this.capHandlerRegistrationStack = [] // stack of handler registration calls. Should probably never be more than one...
   }
@@ -53,7 +53,7 @@ class CdsHandlerRule {
   /**
      * @param {string} varName - name of the variable
      */
-  findDefinitionScope (varName) {
+  findDefinitionScope(varName) {
     const scopes = this.functionScopes
     for (let i = scopes.length - 1; i >= 0; i--) {
       const scope = scopes[i]
@@ -69,22 +69,22 @@ class CdsHandlerRule {
   }
 
   // ClassExpression or ClassDeclaration
-  isCdsServiceClass (node) {
+  isCdsServiceClass(node) {
     const superClass = node.superClass
     if (!superClass) return false  // no extends clause
     let name
     switch (superClass.type) {
-    case 'MemberExpression': {
-      // like: class X extends cds.ApplicationService
-      name = superClass.object.name
-      // TODO: && is *Service?
-      break
-    }
-    case 'Identifier': {
-      // like: class X extends ApplicationService
-      name = superClass.name
-      break
-    }
+      case 'MemberExpression': {
+        // like: class X extends cds.ApplicationService
+        name = superClass.object.name
+        // TODO: && is *Service?
+        break
+      }
+      case 'Identifier': {
+        // like: class X extends ApplicationService
+        name = superClass.name
+        break
+      }
     }
     const info = this.findDefinitionScope(name)
     return info?.variable.isCdsVariable
@@ -93,29 +93,29 @@ class CdsHandlerRule {
   /**
    * @param {ReturnType<typeof produceHandlerRegistration>} registration - the handler registration to add
    */
-  addCapHandlerRegistration (registration) {
+  addCapHandlerRegistration(registration) {
     this.capHandlerRegistrationStack.push(registration)
   }
 
-  removeCapHandlerRegistration () {
+  removeCapHandlerRegistration() {
     this.capHandlerRegistrationStack.pop()
   }
 
   /**
      * @param {Variable} variable
      */
-  addScopeVariable (variable) {
+  addScopeVariable(variable) {
     this.functionScopes.at(-1).variables.push(variable)
   }
 
   /**
    * @param {Scope} scope - the scope to add
    */
-  enterFunctionScope (scope) {
+  enterFunctionScope(scope) {
     this.functionScopes.push(scope)
   }
 
-  leaveFunctionScope () {
+  leaveFunctionScope() {
     this.functionScopes.pop()
   }
 
@@ -123,9 +123,9 @@ class CdsHandlerRule {
      * @abstract
      */
   // eslint-disable-next-line no-unused-vars
-  CAPHandlerRegistration (node) { /* abstract */ }
+  CAPHandlerRegistration(node) { /* abstract */ }
 
-  ClassBody (node) {
+  ClassBody(node) {
     // by hooking into ClassBody and ascending to .parent, we capture declarations and expressions:
     // like: module.exports = class X extends cds.ApplicationService (ClassExpression)
     // like: class X extends cds.ApplicationService (ClassDeclaration)
@@ -164,21 +164,21 @@ class CdsHandlerRule {
   }
 
   BlockStatement(node) {
-    if(isFunctionBody(node)) {
+    if (isFunctionBody(node)) {
       this.enterFunctionScope(produceScope(
         node.parent?.key?.name
-                ?? node.parent?.id?.name
-                ?? node.parent?.parent?.key?.name
-                // const f = function() { ... }
-                ?? (node.parent?.parent?.type === 'VariableDeclarator'
-                  ? node.parent.parent.id.name
-                  : undefined)
-                ?? '<anonymous>'))
+        ?? node.parent?.id?.name
+        ?? node.parent?.parent?.key?.name
+        // const f = function() { ... }
+        ?? (node.parent?.parent?.type === 'VariableDeclarator'
+          ? node.parent.parent.id.name
+          : undefined)
+        ?? '<anonymous>'))
     }
   }
 
   'BlockStatement:exit'(node) {
-    if(isFunctionBody(node)) {
+    if (isFunctionBody(node)) {
       this.leaveFunctionScope()
     }
   }
@@ -199,60 +199,60 @@ class CdsHandlerRule {
     const isCdsVariable = isCdsImport(node)
     for (const specifier of specifiers) {
       switch (specifier.type) {
-      case 'ImportNamespaceSpecifier':
+        case 'ImportNamespaceSpecifier':
         // like: import * as x from y
         // fallthrough
-      case 'ImportDefaultSpecifier':
-        // like: import x from y
-        this.addScopeVariable(produceVariable({
-          original: specifier.local.name,
-          name: specifier.local.name,
-          type: 'import',
-          isCdsVariable
-        }))
-        break
-      case 'ImportSpecifier':
-        // like: import { x, y as foo } from z
-        this.addScopeVariable(produceVariable({
-          original: specifier.imported.name,
-          name: specifier.local.name,
-          type: 'import',
-          isCdsVariable
-        }))
-        break
-      default:
-        throw new Error(`Unexpected specifier type: ${specifier.type}`)
+        case 'ImportDefaultSpecifier':
+          // like: import x from y
+          this.addScopeVariable(produceVariable({
+            original: specifier.local.name,
+            name: specifier.local.name,
+            type: 'import',
+            isCdsVariable
+          }))
+          break
+        case 'ImportSpecifier':
+          // like: import { x, y as foo } from z
+          this.addScopeVariable(produceVariable({
+            original: specifier.imported.name,
+            name: specifier.local.name,
+            type: 'import',
+            isCdsVariable
+          }))
+          break
+        default:
+          throw new Error(`Unexpected specifier type: ${specifier.type}`)
       }
     }
 
   }
 
-  VariableDeclarator({id, init, parent}) {
+  VariableDeclarator({ id, init, parent }) {
     // like: const ... = require('@sap/cds')
     const isCdsVariable = isCdsRequire(init)
     switch (id.type) {
-    case 'Identifier':
-      // like: const x = y
-      this.addScopeVariable(produceVariable({
-        original: id.name,
-        name: id.name,
-        type: parent.kind,
-        isCdsVariable
-      }))
-      break
-    case 'ObjectPattern':
-      // like: const { x, y } = z
-      for (const { key, type, value } of id.properties) {
-        if (type === 'Property' && key.type === 'Identifier') {
-          this.addScopeVariable(produceVariable({
-            original: key.name,
-            type: parent.kind,
-            isCdsVariable,
-            name: value?.name
-          }))
+      case 'Identifier':
+        // like: const x = y
+        this.addScopeVariable(produceVariable({
+          original: id.name,
+          name: id.name,
+          type: parent.kind,
+          isCdsVariable
+        }))
+        break
+      case 'ObjectPattern':
+        // like: const { x, y } = z
+        for (const { key, type, value } of id.properties) {
+          if (type === 'Property' && key.type === 'Identifier') {
+            this.addScopeVariable(produceVariable({
+              original: key.name,
+              type: parent.kind,
+              isCdsVariable,
+              name: value?.name
+            }))
+          }
         }
-      }
-      break
+        break
     }
   }
 
@@ -272,7 +272,7 @@ class CdsHandlerRule {
      * ```
      * in your rule definition, or else the visitor methods will not be called by ESL.
      */
-  asESLintVisitor () {
+  asESLintVisitor() {
     let proto = Object.getPrototypeOf(this)
     const visitors = {}
     while (proto && proto !== Object.prototype) {

package/lib/rules/js/cql-template-strings.js

@@ -32,7 +32,7 @@ class CqlSelectUseTemplateStrings extends CdsHandlerRule {
 
     const [functionName, prefix] =  node.callee.type === 'MemberExpression'
       // for ….where`...` we need to use the full preceding expression in the following replacement
-      ? [node.callee.property?.name, this.context.getSourceCode().getText(node.callee)]
+      ? [node.callee.property?.name, this.context.sourceCode.getText(node.callee)]
       // for SELECT`...` we can use the function name directly
       : [node.callee.name, node.callee.name]
     this.context.report({
@@ -42,7 +42,7 @@ class CqlSelectUseTemplateStrings extends CdsHandlerRule {
       suggest: [{
         desc: 'Use {{functionName}}`...` instead of {{functionName}}(`...`)',
         data: { functionName },
-        fix: fixer => fixer.replaceText(node, `${prefix}${this.context.getSourceCode().getText(arg)}`)
+        fix: fixer => fixer.replaceText(node, `${prefix}${this.context.sourceCode.getText(arg)}`)
       }]
     })
   }

package/lib/rules/js/no-cross-service-import.js

@@ -12,7 +12,7 @@ const MAX_INPUT_STRING_LENGTH = 1_000
  * @param {Node} node
  */
 function compareImportAndFilename (importPath, context, node) {
-  const currentFile = context.getFilename()
+  const currentFile = context.filename
   // ignore stdin
   if (currentFile === '<input>') return
   // ignore excessively long strings

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

@@ -29,8 +29,8 @@ module.exports = {
     return checkValidHeaders
 
     function checkValidHeaders () {
-      const filePath = context.getFilename()
-      const sourcecode = context.getSourceCode()
+      const filePath = context.filename
+      const sourcecode = context.sourceCode
       const code = sourcecode.getText()
 
       let model = context.getModel()

package/lib/utils/createRule.js

@@ -38,64 +38,64 @@ module.exports = function createRule(spec) {
     create: context => {
       // do a fast check to exclude most cases, i.e. irrelevant files
       const isRelevant =
-        context.getSourceCode().lines[0] === '' || // env. rules
-        isConfiguredFileType(context.getFilename(), 'FILES') // file rules
+        context.sourceCode.lines[0] === '' || // env. rules
+        isConfiguredFileType(context.filename, 'FILES') // file rules
       if (!isRelevant) {
         return {}
       }
 
       return {
         Program: node => {
-          const file = context.getFilename()
+          const file = context.filename
           if (file !== filePrev) {
-            LOG?.(`File: ${context.getFilename()}`)
+            LOG?.(`File: ${context.filename}`)
           }
           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 || !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)
+            case 'none':
+              if (doEnvironmentChecks) {
+                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
+              break
 
-          case 'inferred':
-            if (isValidFile && doRootModelChecks) {
-              if (showInEditor) {
-                globalCache.remove(`model:${globalCache.get('rootpath')}`)
-                globalCache.remove(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`)
-                globalCache.remove(`report:${context.getFilename()}:${context.id}`)
-              }
-              if (isTest || showInEditor || !globalCache.has(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`)) {
-                LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
-                if (!showInEditor) {
-                  globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
+            case 'inferred':
+              if (isValidFile && doRootModelChecks) {
+                if (showInEditor) {
+                  globalCache.remove(`model:${globalCache.get('rootpath')}`)
+                  globalCache.remove(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`)
+                  globalCache.remove(`report:${context.filename}:${context.id}`)
                 }
-                createReport(node, cdsContext, meta, create)
-              } else {
-                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))
+                if (isTest || showInEditor || !globalCache.has(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`)) {
+                  LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
+                  if (!showInEditor) {
+                    globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
+                  }
+                  createReport(node, cdsContext, meta, create)
+                } else {
+                  if (globalCache.has(`report:${context.filename}:${context.id}`)) {
+                    const reports = globalCache.get(`report:${context.filename}:${context.id}`)
+                    for (const r of Array.from(reports)) {
+                      context.report(JSON.parse(r))
+                    }
+                    globalCache.remove(`report:${context.filename}:${context.id}`)
+                    globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
                   }
-                  globalCache.remove(`report:${context.getFilename()}:${context.id}`)
-                  globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
                 }
               }
-            }
-            break
+              break
 
-          default:
-            if (isValidFile) {
-              LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
-              createReport(node, cdsContext, meta, create)
-            }
-            break
+            default:
+              if (isValidFile) {
+                LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
+                createReport(node, cdsContext, meta, create)
+              }
+              break
           }
           filePrev = file
         }
@@ -104,26 +104,26 @@ module.exports = function createRule(spec) {
   }
 }
 
-function isRunningWithCDSLint () {
+function isRunningWithCDSLint() {
   return process.argv[1].match(/cds(\.js)?$/) && process.argv[2]?.toLowerCase() === 'lint'
 }
 
-function isRunningWithESLint () {
+function isRunningWithESLint() {
   return process.argv[1].match(/eslint(\.js)?$/)
 }
 
-function checkEntryCriteria (meta, cdsContext) {
+function checkEntryCriteria(meta, cdsContext) {
   const isTest = globalCache.has('test')
   const showInEditor = cdsContext.options.includes('show')
-  const isValidFile = isConfiguredFileType(cdsContext.getFilename(), 'FILES')
+  const isValidFile = isConfiguredFileType(cdsContext.filename, '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.filename === '<text>')
   return { isTest, isValidFile, doRootModelChecks, doEnvironmentChecks, showInEditor }
 }
 
-function setMetaDefaults (meta) {
+function setMetaDefaults(meta) {
   meta ??= {}
   meta.severity ??= constants.DEFAULT_RULE_SEVERITY
   meta.docs ??= {}
@@ -145,7 +145,7 @@ function setMetaDefaults (meta) {
  * @param {Function} create
  * @returns
  */
-function createReport (node, cdsContext, meta, create) {
+function createReport(node, cdsContext, meta, create) {
   const handlers = create(cdsContext)
   /**
    * TODO: Can these be rewritten to have a visitor? Note, that so far,
@@ -155,33 +155,33 @@ function createReport (node, cdsContext, meta, create) {
    *  - Environment rules
    */
   switch (typeof handlers) {
-  case 'function':
-    handlers()
-    break
+    case 'function':
+      handlers()
+      break
 
-  case 'object': {
-    if (meta.model !== 'none') {
-      const model = cdsContext.getModel()
+    case 'object': {
+      if (meta.model !== 'none') {
+        const model = cdsContext.getModel()
 
-      if (model) {
-        model.forall(d => {
-          d = (meta.model === 'inferred') ? sanitizeFileLocation(d) : d
-          const isValidLocation = (meta.model === 'parsed' && d.$location) ||
+        if (model) {
+          model.forall(d => {
+            d = (meta.model === 'inferred') ? sanitizeFileLocation(d) : d
+            const isValidLocation = (meta.model === 'parsed' && d.$location) ||
               (meta.model === 'inferred' && d.$location?.file)
-          Object.entries(handlers)
-            .filter(([type, ]) => d.is(type) && isValidLocation)
-            .forEach(([, handler]) => {
-              handler(d)
-            })
-        })
+            Object.entries(handlers)
+              .filter(([type,]) => d.is(type) && isValidLocation)
+              .forEach(([, handler]) => {
+                handler(d)
+              })
+          })
+        }
       }
+      break
     }
-    break
-  }
   }
 }
 
-function sanitizeFileLocation (d) {
+function sanitizeFileLocation(d) {
   let parent = d
   while (!parent.$location && parent.parent && !parent.parent.definitions)
     parent = d.parent
@@ -195,9 +195,9 @@ function sanitizeFileLocation (d) {
  * @param {CDSRuleContext} context
  * @param meta
  */
-function extendContext (node, context, meta) {
+function extendContext(node, context, meta) {
   if (!globalCache.has('test')) {
-    const filePath = context.getFilename()
+    const filePath = context.filename
     const rootPath = filePath && fs.existsSync(filePath) ? getProjectRootPath(filePath) : ''
     if (rootPath) {
       globalCache.set('rootpath', rootPath)
@@ -236,7 +236,7 @@ function extendContext (node, context, meta) {
           throw new CdsLintAssertionError(`Rule ${context.id} must return a "file" property in the rule report!`)
         }
         const file = globalCache.get('rootpath') ? resolveFilePath(r.file) : r.file
-        if (cdscontext.getFilename() === file) {
+        if (cdscontext.filename === file) {
           delete r.file
           context.report(r)
         }
@@ -255,10 +255,10 @@ function extendContext (node, context, meta) {
  * @param {number} line
  * @param {CDSRuleContext} cdsContext
  */
-function isRuleDisabled (line, cdsContext) {
+function isRuleDisabled(line, cdsContext) {
   let isDisabled = false
   if (cdsContext) {
-    const sourcecode = cdsContext.getSourceCode()
+    const sourcecode = cdsContext.sourceCode
     const rulesDisabled = getDisabled(sourcecode.getText(), sourcecode, line)
     const id = cdsContext.id
     isDisabled = line && id in rulesDisabled && rulesDisabled[id] === 'off'
@@ -272,7 +272,7 @@ function isRuleDisabled (line, cdsContext) {
  * @param {CDSRuleContext} context
  * @param meta
  */
-function cacheReport (r, filepath, context, meta) {
+function cacheReport(r, filepath, context, meta) {
   delete r.file
   if (r.node && r.node.range) {
     r.node.range = []
@@ -296,7 +296,7 @@ function cacheReport (r, filepath, context, meta) {
  * @param {string} sourcecode
  * @param {number} line
  */
-function getDisabled (code, sourcecode, line) {
+function getDisabled(code, sourcecode, line) {
   const listDisabled = []
   const rules = globalCache.get('rules')
   const rulesDisabled = Object.keys(rules).reduce((o, key) => ({ ...o, [key]: 'on' }), {})
@@ -369,7 +369,7 @@ function getDisabled (code, sourcecode, line) {
 /**
  * @param {string} code
  */
-function getLastLine (code) {
+function getLastLine(code) {
   const lines = typeof code === 'string' ? SourceCode.splitLines(code) : code
   return lines.length - 1
 }
@@ -377,6 +377,6 @@ function getLastLine (code) {
 /**
  * @param {string} file
  */
-function resolveFilePath (file) {
+function resolveFilePath(file) {
   return path.isAbsolute(file) ? file : path.join(globalCache.get('rootpath'), file)
 }

package/lib/utils/csnTraversal.js

@@ -72,7 +72,7 @@ class CsnTraversal {
     if (!node || typeof node !== 'object')
       return
 
-    for (const name of Object.getOwnPropertyNames( dict ))
+    for (const name of Object.getOwnPropertyNames( dict ?? {} ))
       this.standard( dict, name, dict[name] )
   }
 

package/lib/utils/rules.js

@@ -92,7 +92,7 @@ module.exports = {
 
   getReplacementsSuggestions: function (context, value, loc) {
     let invalid
-    const lineToReplace = context.sourcecode.lines[loc.line]
+    const lineToReplace = context.sourceCode.lines[loc.line]
     const regExp = /\[([^)]+)\]/
     const matches = regExp.exec(lineToReplace)
     if (matches && matches[0]) {

package/lib/utils/runRuleTester.js

@@ -25,7 +25,7 @@ function testRuleWrapper(rule) {
   function prepareAndRunRule(context) {
     return {
       Program: node => {
-        const filePath = context.getFilename()
+        const filePath = context.filename
         _initModelRuleTester(filePath, rule.meta.model)
         const createValue = rule.create(context)
         const result = createValue.Program(node)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/eslint-plugin-cds",
-  "version": "4.1.2",
+  "version": "4.2.2",
   "description": "ESLint plugin including recommended SAP Cloud Application Programming model and environment rules",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -27,7 +27,7 @@
   },
   "peerDependencies": {
     "@sap/cds": ">=9",
-    "eslint": "^9"
+    "eslint": "^9 || ^10"
   },
   "engines": {
     "node": ">=20"