@sap/eslint-plugin-cds 4.1.0 → 4.1.2

package/CHANGELOG.md

@@ -6,8 +6,18 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
-## [4.1.0] - 2025-08-18
+## [4.1.2] - 2026-02-13
+### Fixed
+- No longer crash on .java files larger than 32 kB.
+- Weaken `java/cql-class-targets` to only warn when a string literal is passed as parameter.
+- `assoc2many-ambiguous-key` no longer falsely warns about 1-n joins when an infix filter reduces the joined relation to a single row.
+
+## [4.1.1] - 2025-12-04
+### Added
+- Top level type definitions for package export
+
 
+## [4.1.0] - 2025-08-18
 ### Added
 - Add new rule `case-sensitive-well-known-events` to detect when a well known event is not cased correctly.
 

package/lib/conf/index.js

@@ -4,6 +4,18 @@ const path = require('node:path')
 const { FILES, GLOBALS } = require('../constants')
 const { parserPath } = require('../api')
 
+function _createJavaConfig (plugin, configName) {
+  return {
+    name: '@sap/cds/java',
+    plugins: {
+      '@sap/cds': plugin,
+    },
+    files: ['**/*.java'],
+    language: '@sap/cds/java',
+    rules: require(path.join(__dirname, 'java', configName)),
+  }
+}
+
 function _createJsConfig (plugin, configName) {
   return {
     name: '@sap/cds/js',
@@ -43,6 +55,11 @@ module.exports = function (plugin) {
     js: {
       all: _createJsConfig(plugin, 'all'),
       recommended: _createJsConfig(plugin, 'recommended')
+    },
+    java: {
+      all: _createJavaConfig(plugin, 'all'),
+      recommended: _createJavaConfig(plugin, 'recommended'),
+      experimental: _createJavaConfig(plugin, 'experimental')
     }
   }
 }

package/lib/conf/java/all.js

@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports = {
+  '@sap/cds/cql-class-targets': 'warn',
+}

package/lib/conf/java/experimental.js

@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports = {
+  '@sap/cds/cql-class-targets': 'warn',
+}

package/lib/conf/java/recommended.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = {}

package/lib/conf/js/all.js

@@ -2,7 +2,7 @@
 
 module.exports = {
   '@sap/cds/no-shared-handler-variable': 'error',
-  '@sap/cds/use-cql-select-template-strings': 'error',
+  '@sap/cds/cql-template-strings': 'error',
   '@sap/cds/no-cross-service-import': 'warn',
   '@sap/cds/no-deep-sap-cds-import': 'warn',
   '@sap/cds/case-sensitive-well-known-events': 'warn',

package/lib/conf/js/recommended.js

@@ -2,7 +2,7 @@
 
 module.exports = {
   '@sap/cds/no-shared-handler-variable': 'error',
-  '@sap/cds/use-cql-select-template-strings': 'error',
+  '@sap/cds/cql-template-strings': 'error',
   '@sap/cds/no-cross-service-import': 'warn',
   '@sap/cds/no-deep-sap-cds-import': 'warn',
   '@sap/cds/case-sensitive-well-known-events': 'warn',

package/lib/constants.js

@@ -21,6 +21,7 @@ const RULE_CATEGORIES = {
   javascript: 'JavaScript Validation',
   environment: 'Environment Validation',
   csv: 'CSV Validation',
+  java: 'Java Validation'
 }
 const DEFAULT_RULE_CATEGORY = 'Model Validation'
 const DEFAULT_RULE_FLAVOR = RULE_FLAVORS[0]

package/lib/index.js

@@ -18,18 +18,20 @@
 
 const api = require('./api')
 const getConfigs = require('./conf')
-const rules = Object.assign(
-  {},
-  ...Object.entries(require('./rules')).map(([k, v]) => ({ [k]: v() }))
-)
-
+const { allRules, initialiseRules } = require('./rules')
+const { javaLanguage } = require('./languages/java/java-language')
 const packageJson = require('../package.json')
 
+const rules = initialiseRules(allRules)
+
 const plugin = {
   meta: {
     name: packageJson.name,
     version: packageJson.version
   },
+  languages: {
+    java: javaLanguage
+  },
   configs: {},
   rules,
   ...api

package/lib/languages/java/java-language.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const { TextEncoder } = require('node:util')
+const TreeSitterParser = require('tree-sitter')
+const Java = require('tree-sitter-java')
+const { JavaSourceCode } = require('./java-source-code')
+
+/**
+ * @typedef {object} JavaLanguageOptions
+ * @typedef {{languageOptions: JavaLanguageOptions}} JavaLanguageContext
+ */
+
+const jp = new TreeSitterParser()
+jp.setLanguage(Java)
+
+/**
+ * @param {import('@eslint/core').File} file
+ * @param {JavaLanguageContext} context
+ */
+function parseJavaCode (file /*, context*/) {
+  const code = file.body
+  try {
+    // https://stackoverflow.com/a/79771252
+    const codeByteSize = new TextEncoder().encode(code).length
+    const treeSitterAst = jp.parse(code, undefined, { bufferSize: codeByteSize + 32 })  // adding some extra buffer space
+    if (!treeSitterAst) return { ast: null, ok: false, errors: [] }
+    if (!treeSitterAst.rootNode) return { ast: treeSitterAst, ok: false, errors: [] }
+    return { ast: treeSitterAst, ok: true, errors: [] }
+  } catch (e) {
+    // most likely a parsing error. This could mean we have to update the parser for newer Java versions
+    return { ast: null, ok: false, errors: [e] }
+  }
+}
+
+/**
+ * @param {import('@eslint/core').File} file
+ * @param {ReturnType<typeof parseJavaCode>} parseResult
+ * @param {JavaLanguageContext} context
+ */
+function createJavaSourceCode(file, parseResult /*, context*/) {
+  if (!parseResult.ok || !parseResult.ast) {
+    throw new Error('createJavaSourceCode: parseResult is not ok or has no AST', {
+      ok: parseResult.ok,
+      hasAst: !!parseResult.ast
+    })
+  }
+  return new JavaSourceCode({ text: file.body, ast: parseResult.ast })
+}
+
+/**
+ * @param {JavaLanguageOptions} languageOptions
+ */
+function validateJavaLanguageOptions(/*languageOptions*/) {
+  // No specific options to validate for Java currently
+}
+
+/**
+ * @link https://eslint.org/docs/latest/extend/languages#the-language-object
+ */
+const javaLanguage = /** @type {const}*/({
+  fileType: 'text',
+  lineStart: 0,
+  columnStart: 0,
+  nodeTypeKey: 'type',
+  validateLanguageOptions: validateJavaLanguageOptions,
+  parse: parseJavaCode,
+  createSourceCode: createJavaSourceCode
+})
+
+module.exports = {
+  javaLanguage,
+}

package/lib/languages/java/java-source-code.js

@@ -0,0 +1,179 @@
+'use strict'
+
+// not 100% accurate, as it matches _any_ comment containing 'eslint-disable' etc.
+// but in Java sources, users will hopefully only mention eslint-* when they
+// actually mean to configure ESLint.
+const INLINE_CONFIG = /eslint(?:-enable|-disable(?:(?:-next)?-line)?)?(?:\s|$)/u
+
+/**
+ * @link see https://github.com/eslint/json/blob/main/src/languages/json-source-code.js
+ */
+const {
+  VisitNodeStep,
+  TextSourceCodeBase,
+  Directive
+} = require('@eslint/plugin-kit')
+
+/** @typedef {'disable' | 'enable' | 'disable-next-line' | 'disable-line'} DirectiveType */
+
+
+/**
+ * @param {import('tree-sitter').SyntaxNode} comment
+ * @returns {{
+ *  label: 'eslint-disable' | 'eslint-enable' | 'eslint-disable-next-line' | 'eslint-disable-line',
+ *  value: string,
+ *  justification: string | undefined
+ * }}
+ */
+function parseDirective(comment) {
+  // label, value, justification
+  //      * but before the "--" that indicates the justification.
+  const [, label, value, justification] = comment.text.match(/^\W*(eslint[\w-]*) (\S+)(?: -- (.+))?/)
+  return { label, value, justification}
+}
+
+class JavaTraversalStep extends VisitNodeStep {
+  /** @param {{ target: unknown, phase: 1|2, args: Array<any> }} arg0 */
+  constructor({ target, phase, args }) {
+    super({ target, phase, args })
+  }
+}
+
+/**
+ * @param {import('tree-sitter').SyntaxNode} node
+ * @param {(node: import('tree-sitter').SyntaxNode) => void} enterAction
+ * @param {undefined | (node: import('tree-sitter').SyntaxNode) => void} exitAction
+ */
+function traverse(node, enterAction, exitAction) {
+  enterAction?.(node)
+  //steps.push(new JavaTraversalStep({ target: node, phase: 1, args: [] }))
+  for (const child of node.children) {
+    traverse(child, enterAction, exitAction)
+  }
+  exitAction?.(node)
+}
+
+
+/** @param {import('tree-sitter').SyntaxNode} node */
+const getAncestors = node => !node
+  ? []
+  : [...getAncestors(node.parent), node]
+
+/**
+ * @link https://eslint.org/docs/latest/extend/languages#the-sourcecode-object
+ */
+class JavaSourceCode extends TextSourceCodeBase {
+  /** @type {undefined | import('tree-sitter').SyntaxNode[]} */
+  #comments
+  /** @type {undefined | import('tree-sitter').SyntaxNode[]} */
+  #inlineConfigComments
+
+  get comments() {
+    if (!this.#comments) {
+      this.#comments = []
+      traverse(this.ast.rootNode, node => {
+        if (['line_comment', 'block_comment'].includes(node.type)) {
+          this.#comments.push(node)
+        }
+      })
+    }
+    return this.#comments
+  }
+
+  get inlineConfigNodes() {
+    if (!this.#inlineConfigComments) {
+      this.#inlineConfigComments = this
+        .comments
+        .filter(comment =>
+          INLINE_CONFIG.test(comment.text),
+        ) ?? []
+    }
+
+    return this.#inlineConfigComments
+  }
+
+  get lines () { return this.text.split(/\r\n|\r|\n/)  }
+
+  /** @param {import('tree-sitter').SyntaxNode} node */
+  getLoc(node) {
+    return {
+      start: { line: node.startPosition.row, column: node.startPosition.column },
+      end: { line: node.endPosition.row, column: node.endPosition.column }
+    }
+  }
+
+  /** @param {import('tree-sitter').SyntaxNode} node */
+  getRange(node) {
+    return [node.startIndex, node.endIndex]
+  }
+
+  /** @param {import('tree-sitter').SyntaxNode} node */
+  getParent(node) {
+    return node.parent ?? undefined  // .parent is null if root, we need undefined
+  }
+
+  /** @param {import('tree-sitter').SyntaxNode} node */
+  getAncestors(node) {
+    // ESLint wants ancestors excluding the node itself
+    return getAncestors(node.parent)
+  }
+
+  /** @param {import('tree-sitter').SyntaxNode} node */
+  getText(node) {
+    return node.text
+  }
+
+  getDisableDirectives() {
+    /** @type {FileProblem[]} */
+    const problems = []
+    /** @type {Directive[]} */
+    const directives = []
+
+    for (const comment of this.inlineConfigNodes) {
+      const { label, value, justification } = parseDirective(comment)
+
+      // `eslint-disable-line` directives are not allowed to span multiple lines as it would be confusing to which lines they apply
+      if (label === 'eslint-disable-line' && comment.loc.start.line !== comment.loc.end.line) {
+        problems.push({
+          ruleId: null,
+          message: `${label} comment should not span multiple lines.`,
+          loc: comment.loc,
+        })
+      } else if (['eslint-disable', 'eslint-enable', 'eslint-disable-next-line', 'eslint-disable-line'].includes(label)) {
+        directives.push(
+          new Directive({
+            type: /** @type {DirectiveType} */ (label.slice('eslint-'.length)),
+            node: comment,
+            value,
+            justification,
+          }),
+        )
+      }
+    }
+    return { problems, directives }
+  }
+
+  traverse() {
+    const steps = []
+    if (!this.ast || !this.ast.rootNode) {
+      return steps
+    }
+    traverse(this.ast.rootNode, node => {
+      steps.push(new JavaTraversalStep({ target: node, phase: 1 }))
+    }, node => {
+      steps.push(new JavaTraversalStep({ target: node, phase: 2 }))
+    })
+    return steps
+  }
+
+  /** @param {{text: string, ast: import('tree-sitter').Tree}} param0 */
+  constructor({text, ast}) {
+    super({text, ast})
+    this.text = text
+    this.ast = ast
+  }
+}
+
+module.exports = {
+  JavaSourceCode
+}

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

@@ -4,12 +4,47 @@ const cds = require('@sap/cds')
 
 /** @type {import('../types').Rule} */
 
+const isAssociationOrComposition = element => ['cds.Association', 'cds.Composition'].includes(element?.type)
+const isEntity = element => element?.kind === 'entity'
+const isStarCardinality = element => element?.cardinality?.max === '*'
+/**
+ * Using infix filters, one-to-many associations can be reduced to one-to-one.
+ * @example
+ * ```cds
+ * SELECT name, books[1: favorite=true].title from Authors
+ * ```
+ */
+const isScalarInfixFilter = element => element?.ref?.[0]?.cardinality?.max === 1
+
+function resolveSourceAlias (csn, definition) {
+  const from = definition.query.SELECT.from
+  let sourceEntity
+  const sourceAlias = []
+  if (from?.ref) {
+    // From
+    sourceEntity = csn.definitions[from.ref.join('_')]
+    sourceAlias.push({
+      from: sourceEntity.name,
+      as: from.as ?? from.ref.at(-1).split('.').pop()
+    })
+  } else if (from?.args?.[0].ref) {
+    // Join
+    sourceEntity = csn.definitions[from.args[0].ref.join('_')]
+    for (const arg of from.args) {
+      sourceAlias.push({
+        from: arg.ref.join('_'),
+        as: arg.as ?? arg.ref.at(-1).split('.').pop()
+      })
+    }
+  }
+  return { sourceEntity, sourceAlias }
+}
+
 module.exports = {
   meta: {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     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,
       url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/assoc2many-ambiguous-key',
@@ -26,8 +61,7 @@ module.exports = {
     function checkAssocs () {
       let csnOdata
       const m = context.getModel()
-      if (!m) return
-      if (m && m.definitions) {
+      if (m?.definitions) {
         try {
           csnOdata = cds.compile.for.odata(m)
           const csnOdataLinked = cds.linked(csnOdata)
@@ -42,142 +76,85 @@ module.exports = {
 }
 
 /**
- * @param {object} csn
- * @param {CDSRuleContext} context
+ * @param {import('../types').CSN} csn
+ * @param {import('../types').CDSRuleContext} context
  */
 function associationCardinalityFlaw (csn, context) {
-  processEntity(csn, (definition, sourceEntity, sourceAlias) => {
-    let refCardinalityMult = false
-    let refPlainElement = false
-    processElement(
-      csn,
-      definition,
-      sourceEntity,
-      sourceAlias,
-      () => {
-        refCardinalityMult = false
-        refPlainElement = false
-      },
-      (refEntity, refElement) => {
-        if (refElement.type === 'cds.Association' || refElement.type === 'cds.Composition') {
-          if (refElement.cardinality && refElement.cardinality.max === '*') {
-            refCardinalityMult = true
-          }
-        } else {
-          refPlainElement = true
-        }
-      },
-      column => {
-        if (
-          definition.keys &&
-          Object.keys(definition.keys).length === 1 &&
-          Object.keys(definition.keys)[0] === 'ID' &&
-          refCardinalityMult &&
-          refPlainElement
-        ) {
-          const keyName = Object.keys(definition.keys)[0]
-          const key = definition.keys[keyName]
-          const keyLoc = context.getLocation(keyName, key, csn)
-          const colName = column.as ? column.as : column.name
-          context.report({
-            messageId: 'ambiguous',
-            data: { name: definition.name, 'column-name': colName, 'key-name': keyName },
-            loc: keyLoc,
-            file: key.$location.file
-          })
-        }
-      }
-    )
-  })
+  for (const [name, definition] of Object.entries(csn.definitions)) {
+    if (!name.startsWith('localized.')) {
+      processEntity({ definition, csn, context})
+    }
+  }
 }
 
 /**
- * @param {object} csn
- * @param {Function} eachCallback
+ * @param {import('../types').CSN} csn
  */
-function processEntity (csn, eachCallback) {
-  Object.keys(csn.definitions).forEach(name => {
-    if (name.startsWith('localized.')) {
-      return
-    }
-    const definition = csn.definitions[name]
-    if (
-      definition.kind === 'entity' &&
-      definition.query &&
-      definition.query.SELECT &&
-      definition.query.SELECT.columns
-    ) {
-      let sourceEntity
-      const sourceAlias = []
-      if (definition.query.SELECT.from.ref) {
-        // From
-        sourceEntity = csn.definitions[definition.query.SELECT.from.ref.join('_')]
-        sourceAlias.push({
-          from: sourceEntity.name,
-          as: definition.query.SELECT.from.as || definition.query.SELECT.from.ref.slice(-1)[0].split('.').pop()
-        })
-      } else if (definition.query.SELECT.from.args && definition.query.SELECT.from.args[0].ref) {
-        // Join
-        sourceEntity = csn.definitions[definition.query.SELECT.from.args[0].ref.join('_')]
-        definition.query.SELECT.from.args.forEach(arg => {
-          sourceAlias.push({
-            from: arg.ref.join('_'),
-            as: arg.as || arg.ref.slice(-1)[0].split('.').pop()
-          })
-        })
-      }
-      if (!sourceEntity) {
-        return
-      }
-      eachCallback(definition, sourceEntity, sourceAlias)
-    }
-  })
+function processEntity ({ definition, csn, context}) {
+  if (!isEntity(definition) || !definition.query?.SELECT?.columns) return
+
+  const { sourceEntity, sourceAlias } = resolveSourceAlias(csn, definition)
+  if (!sourceEntity) return
+
+  for (const column of definition.query.SELECT.columns) {
+    processElement({ csn, definition, column, sourceEntity, sourceAlias, context })
+  }
 }
 
 /**
- * @param {object} csn
- * @param {object} definition
- * @param {object} sourceEntity
- * @param {string} sourceAlias
- * @param {Function} beforeCallback
- * @param {Function} eachCallback
- * @param {Function} afterCallback
+ * @param {object} p
+ * @param {import('../types').CSN} p.csn
+ * @param {object} p.column
+ * @param {object} p.definition
+ * @param {object} p.sourceEntity
+ * @param {string} p.sourceAlias
+ * @param {import('../types').CDSRuleContext} p.context
  */
-function processElement (csn, definition, sourceEntity, sourceAlias, beforeCallback, eachCallback, afterCallback) {
-  definition.query.SELECT.columns.forEach(column => {
-    if (column.ref && column.ref.length > 1) {
-      let refEntity = sourceEntity
-      let refAlias = sourceAlias
-      beforeCallback()
-      column.ref.forEach(ref => {
-        ref = ref.id || ref
-        // Alias
-        const matchAlias = refAlias.find(alias => {
-          return alias.as === ref
-        })
-        let refElement
-        if (matchAlias) {
-          refEntity = csn.definitions[matchAlias.from]
-        } else {
-          refElement = refEntity.elements[ref]
+function processElement ({csn, definition, column, sourceEntity, sourceAlias, context}) {
+  if (!(column.ref && column.ref.length > 1)) return
+
+  let refPlainElement = false
+  let refCardinalityMult = false
+  let refEntity = sourceEntity
+  const refAlias = sourceAlias
+  for (const ref of column.ref.map(ref => ref.id ?? ref)) {
+    // Alias
+    const matchAlias = refAlias.find(alias => alias.as === ref)
+    let refElement
+    if (matchAlias) {
+      refEntity = csn.definitions[matchAlias.from]
+    } else {
+      refElement = refEntity.elements[ref]
           // Mixin
-          if (!refElement) {
-            refElement = definition.elements[ref]
-            if (!refElement && definition.query.SELECT.mixin) {
-              refElement = definition.query.SELECT.mixin[ref]
-              if (!refElement && definition.query.SELECT.mixin[column.ref[0]]) {
-                refElement = definition.query.SELECT.mixin[column.ref[0]]._target.elements[ref]
-              }
-            }
-          }
-          eachCallback(refEntity, refElement)
-          if (refElement.type === 'cds.Association' || refElement.type === 'cds.Composition') {
-            refEntity = csn.definitions[refElement.target]
-          }
-        }
-        refAlias = []
-      })
-      afterCallback(column)
+          ?? definition.elements[ref]
+          ?? definition.query.SELECT.mixin[ref]
+          ?? definition.query.SELECT.mixin[column.ref[0]]?._target?.elements[ref]
+
+      if (isAssociationOrComposition(refElement)) {
+        refCardinalityMult = isStarCardinality(refElement)
+      } else {
+        refPlainElement = true
+      }
+    }
+
+    if (isAssociationOrComposition(refElement)) {
+      refEntity = csn.definitions[refElement.target]
     }
-  })
+  }
+
+  const keyNames = Object.keys(definition.keys ?? {})
+  const [firstkey] = keyNames
+  if (keyNames.length === 1 && firstkey === 'ID' && refCardinalityMult && refPlainElement && !isScalarInfixFilter(column)) {
+    const key = definition.keys[firstkey]
+    context.report({
+      messageId: 'ambiguous',
+      data: {
+        name: definition.name,
+        'column-name': column.as ?? column.name,
+        'key-name': firstkey
+      },
+      loc: context.getLocation(firstkey, key, csn),
+      file: key.$location.file
+    })
+  }
 }

package/lib/rules/index.js

@@ -17,10 +17,28 @@ const readRulesFromDir = (dir, post) => Object.fromEntries(fs.readdirSync(path.j
   .filter(([,module]) => Object.hasOwn(module, 'create'))  // create() is required to exist on top level by eslint -> good check to find actual rules
   .map(([file, module]) => [file, () => post(module)]))
 
+/**
+ * Calls the initialisation function for each rule in the given rule set.
+ * @param {Record<string, () => unknown>} ruleSet
+ * @returns {Record<string, unknown>}
+ */
+const initialiseRules = ruleSet => Object.fromEntries(
+  Object.entries(ruleSet)
+    .map(([k, v]) => [[k], v()]))
+
 const cdsRules = readRulesFromDir('.', createRule)
 const jsRules = readRulesFromDir('js', module => module)
-const rules = {...cdsRules, ...jsRules}
+// backwards compat, remove in next minor
+jsRules['use-cql-select-template-strings'] = jsRules['cql-template-strings']
+const javaRules = readRulesFromDir('java', module => module)
+const allRules = {...cdsRules, ...jsRules, ...javaRules}
 
-globalCache.set('rules', rules)
+globalCache.set('rules', allRules)
 
-module.exports = rules
+module.exports = {
+  allRules,
+  jsRules,
+  javaRules,
+  cdsRules,
+  initialiseRules
+}

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

@@ -0,0 +1,68 @@
+'use strict'
+
+/**
+ * In Select.from(x), x should be a class literal.
+ */
+
+const { RULE_CATEGORIES } = require('../../constants')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      recommended: true,
+      category: RULE_CATEGORIES.java,
+      description: 'java.'
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      selectOnNonClass: `'{{target}}' is not a class. Prefer to pass class literals to Select.from!`,
+    },
+    hasSuggestions: true
+  },
+  create: context => {
+    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 isString = node =>
+      node?.type === 'string_literal'
+
+    return {
+      'import_declaration > scoped_identifier': function(node) {
+        if (!node) return
+        if (node.nameNode) {
+          knownClasses.add(node.nameNode.text)
+        }
+      },
+
+      "method_invocation > identifier[text='from']": function(node) {
+        if (!node?.parent?.argumentsNode) return
+        const args = node.parent.argumentsNode.children
+          .filter(c => c.constructor.name !== 'SyntaxNode')  // filter out commas, parens, etc.
+          ?? []
+        // we actually want to detect anything that is NOT a class literal,
+        // but there are some edge cases we need to care for in the future,
+        // such as parameters passing in a class:
+        // void myMethod(Class<MyClass> cls) { Select.from(cls); }
+        // for the time being, we will just warn on string literals
+        //if (!refersToClass(args[0])) {
+        if (isString(args[0])) {
+          context.report({
+            node: args[0],
+            messageId: 'selectOnNonClass',
+            data: { target: args[0].text }
+          })
+        }
+      },
+    }
+  }
+}

package/lib/types.d.ts

@@ -44,3 +44,9 @@ export interface CDSRuleTestOpts {
     /** list of errors from ESLint's [RuleTester](https://eslint.org/docs/developer-guide/nodejs-api#ruletester) */
     errors: CDSTestCaseError[]
 }
+
+// FIXME: this is just a dummy and needs to go
+// once we consolidate the various CSN types across packages
+export type CSN = {
+    definitions: {}
+}

package/lib/utils/runRuleTester.js

@@ -9,7 +9,7 @@ const { RuleTester } = require('eslint')
 const { globalCache } = require('./Cache')
 const isConfiguredFileType = require('./isConfiguredFileType')
 const { compileModelFromDict } = require('../parser')
-const rules = require('../rules')
+const { allRules: rules } = require('../rules')
 
 /**
  * A wrapper around the return value of `createRule()` that initializes the global

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/eslint-plugin-cds",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "description": "ESLint plugin including recommended SAP Cloud Application Programming model and environment rules",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -20,7 +20,10 @@
     "README.md"
   ],
   "dependencies": {
-    "semver": "^7.7.1"
+    "@eslint/plugin-kit": "^0.6.0",
+    "semver": "^7.7.1",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-java": "^0.23.5"
   },
   "peerDependencies": {
     "@sap/cds": ">=9",