@sap/eslint-plugin-cds 3.0.4 → 3.1.0

package/lib/utils/createRule.js

@@ -1,4 +1,6 @@
-/**
+'use strict'
+
+/*
  * Wrapper for ESLint's Rule creator:
  * https://eslint.org/docs/developer-guide/working-with-rules
  * - Must follow the ESLint prescribed convention for all rule exports
@@ -13,25 +15,27 @@
 const { SourceCode } = require('eslint')
 const fs = require('fs')
 const path = require('path')
+const cds = require('@sap/cds')
+
 const Cache = require('./Cache')
 const constants = require('../constants')
 const isConfiguredFileType = require('./isConfiguredFileType')
 const getProjectRootPath = require('./getProjectRootPath')
-const cds = require('@sap/cds')
-const { exit } = require('process')
+const { CdsLintAssertionError } = require('./LintError')
+
 const LOG = cds.debug('lint:plugin')
 let filePrev = ''
 
 const REGEX_COMMENT_START = '(/\\*|(.+)?//)(\\s?)+eslint-'
 const REGEX_COMMENTS = `${REGEX_COMMENT_START}(enable|disable)(-next)?(-line)?(.+)?`
 
-module.exports = (spec) => {
+module.exports = function createRule(spec) {
   let { meta, create } = spec
   meta = setMetaDefaults(meta)
 
   return {
     meta,
-    create: (context) => {
+    create: context => {
       // do a fast check to exclude most cases, i.e. irrelevant files
       const isRelevant =
         context.getSourceCode().lines[0] === '' || // env. rules
@@ -41,63 +45,59 @@ module.exports = (spec) => {
       }
 
       return {
-        Program: (node) => {
-          try {
-            const file = context.getFilename()
-            if (file !== filePrev) {
-              LOG && LOG(`File: ${context.getFilename()}`)
+        Program: node => {
+          const file = context.getFilename()
+          if (file !== filePrev) {
+            LOG && LOG(`File: ${context.getFilename()}`)
+          }
+          const cdscontext = extendContext(node, context, meta)
+          Cache.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)
+              }
             }
-            const cdscontext = extendContext(node, context, meta)
-            Cache.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)
-                  }
-                }
-                break
+            break
 
-              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}`)
-                  }
-                  if (isTest || showInEditor || Cache.has(`rule:${cdscontext.id}:${Cache.get('rootpath')}`)) {
-                    LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
-                    if (!showInEditor) {
-                      Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
-                    }
-                    createReport(node, cdscontext, meta, create)
-                  } else {
-                    if (Cache.has(`report:${context.getFilename()}:${context.id}`)) {
-                      const reports = Cache.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')
-                    }
+          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}`)
+              }
+              if (isTest || showInEditor || !Cache.has(`rule:${cdscontext.id}:${Cache.get('rootpath')}`)) {
+                LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
+                if (!showInEditor) {
+                  Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
+                }
+                createReport(node, cdscontext, meta, create)
+              } else {
+                if (Cache.has(`report:${context.getFilename()}:${context.id}`)) {
+                  const reports = Cache.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')
                 }
-                break
+              }
+            }
+            break
 
-              default:
-                if (isValidFile) {
-                  LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
-                  createReport(node, cdscontext, meta, create)
-                }
-                break
+          default:
+            if (isValidFile) {
+              LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
+              createReport(node, cdscontext, meta, create)
             }
-            filePrev = file
-          } catch (err) {
-            console.error(err)
+            break
           }
+          filePrev = file
         }
       }
     }
@@ -125,25 +125,30 @@ function checkEntryCriteria (meta, cdscontext) {
 }
 
 function setMetaDefaults (meta) {
-  if (!meta.severity) meta.severity = constants.DEFAULT_RULE_SEVERITY
-  if (meta.docs && !meta.docs.category) meta.docs.category = constants.DEFAULT_RULE_CATEGORY
-  if (!meta.model) meta.model = 'parsed'
+  meta ??= {}
+  meta.severity ??= constants.DEFAULT_RULE_SEVERITY
+  meta.docs ??= {}
+  meta.docs.category ??= constants.DEFAULT_RULE_CATEGORY
+  meta.model ??= 'parsed'
   return meta
 }
 
 /**
- * Get report descriptors from created rules. These can take varios forms,
+ * Get report descriptors from created rules. These can take various forms,
  * from minimal return, up to fully defined ESLint report descriptors values,
  * with or without visitor keys:
  * - String is interpreted as the 'message' property
  * - Object with known CDS Visitor keys and ESLint report descriptor values
- * - Object with ESLint report dedscriptor keys/ values
- * @param {*} cdscontext
- * @param {*} create
+ * - Object with ESLint report descriptor keys/ values
+ *
+ * @param {object} node
+ * @param {CDSRuleContext} cdsContext
+ * @param {object} meta
+ * @param {Function} create
  * @returns
  */
-function createReport (node, cdscontext, meta, create) {
-  const handlers = create(cdscontext)
+function createReport (node, cdsContext, meta, create) {
+  const handlers = create(cdsContext)
   /**
    * TODO: Can these be rewritten to have a visitor? Note, that so far,
    * rules without a visitor cannot use eslint disable comments
@@ -152,33 +157,29 @@ 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, _lazy]) => d.is(type) && isValidLocation)
-              .forEach(([_lazy, handler]) => {
-                try {
-                  handler(d)
-                } catch (err) {
-                  console.log(`Error in rule "${cdscontext.id}" at ${d.name}`, err)
-                }
-              })
-          })
-        }
+          Object.entries(handlers)
+            .filter(([type, ]) => d.is(type) && isValidLocation)
+            .forEach(([, handler]) => {
+              handler(d)
+            })
+        })
       }
-      break
     }
+    break
+  }
   }
 }
 
@@ -189,6 +190,11 @@ function sanitizeFileLocation (d) {
   return d
 }
 
+/**
+ * @param node
+ * @param {CDSRuleContext} context
+ * @param meta
+ */
 function extendContext (node, context, meta) {
   if (!Cache.has('test')) {
     const filePath = context.getFilename()
@@ -198,28 +204,6 @@ function extendContext (node, context, meta) {
     }
   }
 
-  const reportWrapper = (r) => {
-    const line = r.loc ? r.loc.start.line : r.node.loc.start.line
-    if (!isRuleDisabled(line, context)) {
-      if (meta.model === 'inferred') {
-        if (!r.file) {
-          console.error(`Rule ${context.id} must return a "file" property in the rule report!`)
-          exit(1)
-        }
-        const file = Cache.get('rootpath') ? resolveFilePath(r.file) : r.file
-        if (cdscontext.getFilename() === file) {
-          delete r.file
-          context.report(r)
-        }
-        if (r.file) {
-          cacheReport(r, file, context, meta)
-        }
-      } else {
-        context.report(r)
-      }
-    }
-  }
-
   const descriptors = Object.getOwnPropertyDescriptors(context)
   descriptors.report = {
     value: reportWrapper,
@@ -240,20 +224,52 @@ function extendContext (node, context, meta) {
   cdscontext.getNode = Object.keys(parserServices).length > 0 ? parserServices.getNode : () => node
   cdscontext.getRootPath = () => Cache.get('rootpath')
   return cdscontext
+
+  function reportWrapper(r) {
+    const line = r.loc ? r.loc.start.line : r.node.loc.start.line
+    if (!isRuleDisabled(line, context)) {
+      if (meta.model === 'inferred') {
+        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
+        if (cdscontext.getFilename() === file) {
+          delete r.file
+          context.report(r)
+        }
+        if (r.file) {
+          cacheReport(r, file, context, meta)
+        }
+      } else {
+        context.report(r)
+      }
+    }
+  }
 }
 
-function isRuleDisabled (line, cdscontext) {
+
+/**
+ * @param {number} line
+ * @param {CDSRuleContext} cdsContext
+ */
+function isRuleDisabled (line, cdsContext) {
   let isDisabled = false
-  if (cdscontext) {
-    const sourcecode = cdscontext.getSourceCode()
+  if (cdsContext) {
+    const sourcecode = cdsContext.getSourceCode()
     const rulesDisabled = getDisabled(sourcecode.getText(), sourcecode, line)
-    const id = cdscontext.id
+    const id = cdsContext.id
     isDisabled = line && id in rulesDisabled && rulesDisabled[id] === 'off'
   }
   return isDisabled
 }
 
-function cacheReport (r, file, context, meta) {
+/**
+ * @param r
+ * @param {string} filepath
+ * @param {CDSRuleContext} context
+ * @param meta
+ */
+function cacheReport (r, filepath, context, meta) {
   delete r.file
   if (r.node && r.node.range) {
     r.node.range = []
@@ -264,23 +280,27 @@ function cacheReport (r, file, context, meta) {
   }
   if (r) {
     let reports = new Set()
-    if (Cache.has(`report:${file}:${context.id}`)) {
-      reports = Cache.get(`report:${file}:${context.id}`)
+    if (Cache.has(`report:${filepath}:${context.id}`)) {
+      reports = Cache.get(`report:${filepath}:${context.id}`)
     }
     reports.add(JSON.stringify(r))
-    Cache.set(`report:${file}:${context.id}`, reports)
+    Cache.set(`report:${filepath}:${context.id}`, reports)
   }
 }
 
+/**
+ * @param {string} code
+ * @param {string} sourcecode
+ * @param {number} line
+ */
 function getDisabled (code, sourcecode, line) {
   const listDisabled = []
   const rules = Cache.get('rules')
   const rulesDisabled = Object.keys(rules).reduce((o, key) => ({ ...o, [key]: 'on' }), {})
-  let matches = []
   if (code) {
-    matches = [...code.matchAll(REGEX_COMMENTS)]
+    const matches = [...code.matchAll(REGEX_COMMENTS)]
     if (matches.length > 0) {
-      matches.forEach((match) => {
+      matches.forEach(match => {
         if (match) {
           const index = match.index
           match = match[0]
@@ -292,28 +312,28 @@ function getDisabled (code, sourcecode, line) {
           if (match) {
             match = match.trim()
           }
-          ['disable', 'enable'].forEach((keyword) => {
+          ['disable', 'enable'].forEach(keyword => {
             const loc = sourcecode.getLocFromIndex(index)
             const disableType = match.split(' ')[0]
             let disableRules = match.split(`${disableType} `)[1]
             disableRules = disableRules
-              ? disableRules.split(',').map((rule) => rule.trim())
-              : Object.keys(rules).map((rule) => `@sap/cds/${rule}`)
+              ? disableRules.split(',').map(rule => rule.trim())
+              : Object.keys(rules).map(rule => `@sap/cds/${rule}`)
             let comment = {}
             if ([`eslint-${keyword}`, `eslint-${keyword}-line`, `eslint-${keyword}-next-line`].includes(disableType)) {
               comment = disableType.includes('-next-line')
                 ? {
-                    lineComment: loc.line,
-                    lineDisabled: loc.line + 1,
-                    rules: disableRules,
-                    type: keyword
-                  }
+                  lineComment: loc.line,
+                  lineDisabled: loc.line + 1,
+                  rules: disableRules,
+                  type: keyword
+                }
                 : {
-                    lineComment: loc.line,
-                    lineDisabled: loc.line,
-                    rules: disableRules,
-                    type: keyword
-                  }
+                  lineComment: loc.line,
+                  lineDisabled: loc.line,
+                  rules: disableRules,
+                  type: keyword
+                }
               if (!disableType.includes('-line')) {
                 comment.lineDisabled = 'EOF'
               }
@@ -323,13 +343,13 @@ function getDisabled (code, sourcecode, line) {
         }
       })
       for (const el of listDisabled.filter(
-        (d) => d.lineComment < line && (d.lineDisabled === 'EOF' || d.lineDisabled === line)
+        d => d.lineComment < line && (d.lineDisabled === 'EOF' || d.lineDisabled === line)
       )) {
         if (el.lineDisabled === 'EOF') {
           el.lineDisabled = getLastLine(code)
         }
         if (el.rules) {
-          el.rules.forEach((rule) => {
+          el.rules.forEach(rule => {
             if (el.type === 'disable') {
               rulesDisabled[rule] = 'off'
             } else if (el.type === 'enable') {
@@ -343,11 +363,17 @@ function getDisabled (code, sourcecode, line) {
   return rulesDisabled
 }
 
+/**
+ * @param {string} code
+ */
 function getLastLine (code) {
   const lines = typeof code === 'string' ? SourceCode.splitLines(code) : code
   return lines.length - 1
 }
 
+/**
+ * @param {string} file
+ */
 function resolveFilePath (file) {
   return path.isAbsolute(file) ? file : path.join(Cache.get('rootpath'), file)
 }

package/lib/utils/csnTraversal.js

@@ -0,0 +1,163 @@
+'use strict'
+
+/**
+ * Utility class for traversing a CSN.
+ *
+ * Experimental class. Not used directly, but instead wrapped in `forEach*` functions,
+ * which are exported by this file.
+ */
+class CsnTraversal {
+  csnIterators = {
+    __proto__: null,
+
+    definitions: this.dictionary,
+    extensions: this.array,
+
+    type: this.standard,
+    target: this.standard,
+    targetAspect: this.standard,
+    returns: this.standard,
+    items: this.standard,
+    elements: this.dictionary,
+
+    enum: this.dictionary,
+    key: this.array,
+    actions: this.dictionary,
+    params: this.dictionary,
+    mixin: this.dictionary,
+
+    query: this.standard,
+    SELECT: this.standard,
+    SET: this.standard,
+
+    from: this.standard,
+    columns: this.array,
+    expand: this.array,
+    inline: this.array,
+
+    ref: this.array,
+    xpr: this.array,
+    list: this.array,
+
+    args: this.args,
+    on: this.standard,
+    default: this.standard,
+    where: this.standard,
+    groupBy: this.standard,
+    orderBy: this.standard,
+    having: this.standard,
+    limit: this.standard,
+    rows: this.standard,
+    offset: this.standard,
+
+    '@': this.annotation,
+  }
+
+  constructor(callbacks) {
+    this.callbacks = callbacks
+    this.ctx = new CsnTraversalContext
+  }
+
+  array( node, _prop, arr ) {
+    if (!Array.isArray(arr))
+      return
+
+    for (let i = 0; i < arr.length; ++i) {
+      const entry = arr[i]
+      this.standard(arr, i, entry)
+    }
+  }
+
+  dictionary( node, _prop, dict ) {
+    if (!node || typeof node !== 'object')
+      return
+
+    for (const name of Object.getOwnPropertyNames( dict ))
+      this.standard( dict, name, dict[name] )
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  annotation( parent, prop, node ) {
+    // no-op for now; remove eslint-comment once implemented
+  }
+
+  // Arguments can be named (dictionary) or unnamed/positional (array).
+  args( parent, prop, node ) {
+    if (Array.isArray(node))
+      this.array(parent, prop, node)
+    else
+      this.dictionary(parent, prop, node)
+  }
+
+  /**
+   * Traverse a "standard" CSN object, i.e. an object with CSN properties and
+   * not a dictionary such as "elements".
+   */
+  standard( _parent, _prop, node ) {
+    if (!node || typeof node !== 'object')
+      return
+
+    this.ctx.pushLocationOf(node)
+
+    if (Array.isArray(node)) {
+      node.forEach( (n, i) => {
+        this.standard(node, i, n)
+      } )
+    }
+    else {
+      for (const prop of Object.getOwnPropertyNames( node )) {
+        if (this.callbacks[prop]) {
+          this.ctx.pushLocationOf(node[prop])
+          this.ctx.property = prop
+          this.callbacks[prop](node[prop], this.ctx)
+          this.ctx.popLocation()
+        }
+
+        const traverse = this.csnIterators[prop] || this.csnIterators[prop.charAt(0)]
+        if (traverse)
+          traverse.call(this, node, prop, node[prop] )
+      }
+    }
+
+    this.ctx.popLocation()
+  }
+
+}
+
+class CsnTraversalContext {
+  constructor(parent) {
+    this.parent = parent || null
+    this.property = null
+    this.locations = []
+  }
+
+  /** If a location on "node" is available, add it to the stack. */
+  pushLocationOf(node) {
+    this.locations.push(node.$location ?? this.locations.at(-1))
+  }
+  popLocation() {
+    this.locations.pop()
+  }
+
+  get $location() {
+    return this.locations.at(-1)
+  }
+}
+
+/**
+ * For each `xpr` (i.e. expression) in a definition, invoke the callback.
+ *
+ * @param {object} def
+ * @param {Function} callback
+ */
+function forEachXprInDefinition( def, callback ) {
+  const traversal = new CsnTraversal({
+    xpr: callback,
+    where: callback,
+  })
+  traversal.standard(null, def.name, def)
+}
+
+module.exports = {
+  forEachXprInDefinition,
+}

package/lib/utils/findFuzzy.js

@@ -1,15 +1,23 @@
+'use strict'
+
+const cache = {}
+
 /**
  * Levenshtein distance algorithm using recursive calls and cache
  *
  * @param input search the list for a best match for this string
  * @param list a list of strings to match input against
- * @param log logging method to use, might be null if no logging is wanted
- * @returns array with best matches, is never null but might be empty in case no search was possible
+ * @param {Function} [log] logging method to use, might be null if no logging is wanted
+ * @param {boolean} [keepCase]
+ * @param {Number} [threshold]
+ * @returns {string[]} array with best matches, is never null but might be empty in case no search was possible
+ *
+ * @todo: Describe in which range the threshold should be.
  */
+module.exports = function findFuzzy(input, list, log = null, keepCase = false, threshold = Number.MAX_SAFE_INTEGER) {
+  if (typeof input !== 'string')
+    return []
 
-const cache = {}
-
-module.exports = (input, list, log, keepCase = false, threshold = Number.MAX_SAFE_INTEGER) => {
   let minDistWords = []
 
   if (input.length > 50 || list.length > 50) {
@@ -56,7 +64,7 @@ module.exports = (input, list, log, keepCase = false, threshold = Number.MAX_SAF
   return minDistWords.sort()
 }
 
-const levDistance = (a, b) => {
+function levDistance(a, b) {
   if (cache[a] && cache[a][b]) {
     return cache[a][b]
   }
@@ -84,7 +92,7 @@ const levDistance = (a, b) => {
   return addToCache(a, b, levDist)
 }
 
-const addToCache = (a, b, value) => {
+function addToCache(a, b, value) {
   cache[a] = cache[a] || {}
   cache[a][b] = value
   return value

package/lib/utils/getConfigPath.js

@@ -1,3 +1,5 @@
+'use strict'
+
 /**
  * Searches for ESLint config file types (in order or precedence)
  * and returns corresponding directory (usually project's root dir)
@@ -6,8 +8,8 @@
  * @returns {string} dir containing ESLint config file (empty if not exists)
  */
 
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 
 module.exports = (currentDir = '.', legacy=false) => {
   let configFiles = [

package/lib/utils/getConfiguredFileTypes.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const { FILES } = require('../constants')
 
 /**

package/lib/utils/getFileExtensions.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const constants = require('../constants')
 
 /**