@sap/eslint-plugin-cds 4.1.0 → 4.1.1

package/CHANGELOG.md

@@ -6,8 +6,12 @@ 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.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,69 @@
+'use strict'
+
+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
+  const treeSitterAst = jp.parse(code)
+
+  if (!treeSitterAst) {
+    return { ast: null, ok: false }
+  }
+  if (!treeSitterAst.rootNode) {
+    return { ast: treeSitterAst, ok: false }
+  }
+  return { ast: treeSitterAst, ok: true }
+}
+
+/**
+ * @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/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,59 @@
+'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))
+
+    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.
+          ?? []
+        if (!refersToClass(args[0])) {
+          context.report({
+            node: args[0],
+            messageId: 'selectOnNonClass',
+            data: { target: args[0].text }
+          })
+        }
+      },
+    }
+  }
+}

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.1",
   "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.4.1",
+    "semver": "^7.7.1",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-java": "^0.23.5"
   },
   "peerDependencies": {
     "@sap/cds": ">=9",