@sap/eslint-plugin-cds 4.1.1 → 4.1.2

package/CHANGELOG.md

@@ -6,6 +6,12 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## [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

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { TextEncoder } = require('node:util')
 const TreeSitterParser = require('tree-sitter')
 const Java = require('tree-sitter-java')
 const { JavaSourceCode } = require('./java-source-code')
@@ -18,15 +19,17 @@ jp.setLanguage(Java)
  */
 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 }
+  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] }
   }
-  return { ast: treeSitterAst, ok: true }
 }
 
 /**

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/java/cql-class-targets.js

@@ -33,6 +33,9 @@ module.exports = {
       // 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
@@ -46,7 +49,13 @@ module.exports = {
         const args = node.parent.argumentsNode.children
           .filter(c => c.constructor.name !== 'SyntaxNode')  // filter out commas, parens, etc.
           ?? []
-        if (!refersToClass(args[0])) {
+        // 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',

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/eslint-plugin-cds",
-  "version": "4.1.1",
+  "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,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@eslint/plugin-kit": "^0.4.1",
+    "@eslint/plugin-kit": "^0.6.0",
     "semver": "^7.7.1",
     "tree-sitter": "^0.21.1",
     "tree-sitter-java": "^0.23.5"