@sap/eslint-plugin-cds 2.4.1 → 2.6.0

package/lib/rules/no-join-on-draft.js

@@ -0,0 +1,27 @@
+module.exports = {
+  meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
+    docs: {
+      // eslint-disable-next-line quotes
+      description: "Draft-enabled entities shall not be used in views that make use of `JOIN`.",
+      recommended: true
+    },
+    type: 'suggestion',
+    model: 'inferred'
+  },
+  create: function (context) {
+    return { entity: checkNojoinDraftenabled }
+
+    function checkNojoinDraftenabled (e) {
+      if (e['@odata.draft.enabled']) {
+        if (e.query.SELECT.from.join) {
+          context.report({
+            message: 'Do not use draft-enabled entities in views that make use of `JOIN`.',
+            node: context.getNode(e),
+            file: e.$location.file
+          })
+        }
+      }
+    }
+  }
+}

package/lib/rules/require-2many-oncond.js

@@ -1,27 +1,22 @@
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: `Foreign key information of a \`TO MANY\` relationship must be defined within the target and specified in an \`ON\` condition.`,
-      category: "Model Validation",
-      recommended: true,
-      version: "2.1.0",
+      description: 'Foreign key information of a `TO MANY` relationship must be defined within the target and specified in an `ON` condition.',
+      recommended: true
     },
-    severity: "error",
-    type: "problem",
+    type: 'problem'
   },
   create: function (context) {
+    return { element: check2manyOncond }
 
-    return { element: check_2many_oncond }
-
-    function check_2many_oncond(e) {
+    function check2manyOncond (e) {
       if (e.is2many && !e.on && typeof e.target === 'string') {
-        const loc = context.cds.getLocation(e.name, e);
-        return {
+        context.report({
           message: `You must provide an \`ON\` condition for \`TO MANY\` relationship '${e.name}'.`,
-          loc,
-          file: e.parent.$location.file,
-        };
+          node: context.getNode(e)
+        })
       }
     }
-  },
-};
+  }
+}

package/lib/rules/sql-cast-suggestion.js

@@ -1,52 +1,39 @@
 /* eslint-disable no-undef */
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: "Should make suggestions for possible missing SQL casts.",
-      category: "Model Validation",
-      recommended: true,
-      version: "1.0.8",
+      description: 'Should make suggestions for possible missing SQL casts.',
+      recommended: true
     },
-    severity: "warn",
-    type: "suggestion",
+    type: 'suggestion',
     hasSuggestions: true,
     messages: {
-      missingSQLCast: "Potential issue - Missing SQL cast for column expression?",
-    },
+      missingSQLCast: 'Potential issue - Missing SQL cast for column expression?'
+    }
   },
   create: function (context) {
-    return { view: check_sql_cast };
+    return { view: checkSqlCast }
 
-    function check_sql_cast(v) {
-      const reports = [];
+    function checkSqlCast (v) {
       if (v.query && v.query.SET) {
         for (const { SELECT } of v.query.SET.args) {
           // Only in UNION cases?
           for (const each of SELECT.columns || []) {
-            const { xpr, cast, $location: location } = each;
+            const { xpr, cast } = each
             if (cast && xpr) {
               if (xpr[0].xpr && xpr[0].cast) {
-                continue;
+                continue
               } else {
-                if (context.sourcecode.lines[location.line - 1]) {
-                  const endCol = context.sourcecode.lines[location.line - 1].length;
-                  const loc = {
-                    start: { line: location.line, column: location.col - 1 },
-                    end: { line: location.line, column: endCol },
-                  };
-                  reports.push({
-                    messageId: "missingSQLCast",
-                    loc,
-                    file: location.file,
-                  });
-                }
+                context.report({
+                  messageId: 'missingSQLCast',
+                  node: context.getNode(v)
+                })
               }
             }
           }
         }
       }
-      if (reports.length > 0 ) return reports;    
     }
-    
-  },
-};
+  }
+}

package/lib/rules/start-elements-lowercase.js

@@ -1,61 +1,59 @@
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: "Regular element names should start with lowercase letters.",
-      category: "Model Validation",
-      version: "1.0.4",
+      description: 'Regular element names should start with lowercase letters.'
     },
-    type: "suggestion",
+    type: 'suggestion',
     hasSuggestions: true,
     messages: {
       startLowercase: "Element name '{{entityName}}.{{elementName}}' should start with a lowercase letter.",
-      fixLowercase: "Start element name with a lowercase letter.",
+      fixLowercase: 'Start element name with a lowercase letter.'
     },
-    fixable: "code",
+    fixable: 'code'
   },
   create: function (context) {
-    const { cds, filePath, sourcecode } = context;
+    const sourcecode = context.getSourceCode()
 
     return {
-      element: check_start_lowercase,
-    };
+      element: checkStartLowercase
+    }
 
-    function check_start_lowercase(e) {
-      if (!filePath.endsWith(".cds")) return;
-        const elementName = e.name;
-        const entityName = e.parent.name;
-        if (elementName && !(entityName.startsWith("localized") || entityName.endsWith("texts"))) {
-          if (elementName.charAt(0) !== elementName.charAt(0).toLowerCase() && !["ID"].includes(elementName)) {
-            if (e.$location && e.$location.file) {
-              const file = e.$location.file;
-              const loc = cds.getLocation(elementName, e);
-              const fix = (fixer, source = sourcecode) => {
-                const elementNameSanitized = elementName.charAt(0).toLowerCase() + elementName.slice(1);
-                const rangeEnd = source.getIndexFromLoc({
-                  line: loc.end.line,
-                  column: loc.end.column,
-                });
-                const rangeBeg = rangeEnd ? rangeEnd - elementNameSanitized.length : 0;
-                return fixer.replaceTextRange([rangeBeg, rangeEnd], elementNameSanitized);
-              };
-              return {
-                messageId: "startLowercase",
-                loc,
-                file,
-                data: {
-                  entityName,
-                  elementName,
-                },
-                suggest: [
-                  {
-                    messageId: "fixLowercase",
-                    fix,
-                  },
-                ],
-              };
+    function checkStartLowercase (e) {
+      const elementName = e.name
+      const entityName = e.parent.name
+      if (elementName && !(entityName.startsWith('localized') || entityName.endsWith('texts'))) {
+        if (elementName.charAt(0) !== elementName.charAt(0).toLowerCase() && !['ID'].includes(elementName)) {
+          if (e.$location && e.$location.file) {
+            const file = e.$location.file
+            const loc = context.getLocation(elementName, e)
+            const fix = (fixer, source = sourcecode) => {
+              const elementNameSanitized = elementName.charAt(0).toLowerCase() + elementName.slice(1)
+              const rangeEnd = source.getIndexFromLoc({
+                line: loc.end.line,
+                column: loc.end.column
+              })
+              const rangeBeg = rangeEnd ? rangeEnd - elementNameSanitized.length : 0
+              return fixer.replaceTextRange([rangeBeg, rangeEnd], elementNameSanitized)
             }
+            context.report({
+              messageId: 'startLowercase',
+              loc,
+              file,
+              data: {
+                entityName,
+                elementName
+              },
+              suggest: [
+                {
+                  messageId: 'fixLowercase',
+                  fix
+                }
+              ]
+            })
+          }
         }
       }
     }
-  },
-};
+  }
+}

package/lib/rules/start-entities-uppercase.js

@@ -1,55 +1,53 @@
-const { splitEntityName } = require("../utils/ruleHelpers");
+const { splitDefName } = require('../utils/rules')
 
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: "Regular entity names should start with uppercase letters.",
-      category: "Model Validation",
-      version: "1.0.4",
+      description: 'Regular entity names should start with uppercase letters.'
     },
-    type: "suggestion",
+    type: 'suggestion',
     hasSuggestions: true,
     messages: {
       startUppercase: "Entity name '{{entityName}}' should start with an uppercase letter.",
-      fixUppercase: "Start entity name with an uppercase letter.",
+      fixUppercase: 'Start entity name with an uppercase letter.'
     },
-    fixable: "code",
+    fixable: 'code'
   },
   create: function (context) {
-    const { cds, filePath, sourcecode } = context;
+    const sourcecode = context.getSourceCode()
 
-    return { entity: check_starts_uppercase };
+    return { entity: checkStartsUppercase }
 
-    function check_starts_uppercase(e) {
-      if (!filePath.endsWith(".cds")) return;
-      const entityName = splitEntityName(e).entity;
+    function checkStartsUppercase (e) {
+      const entityName = splitDefName(e).name
       if (entityName.charAt(0) !== entityName.charAt(0).toUpperCase()) {
         if (e.$location && e.$location.file) {
-          const file = e.$location.file;
-          const loc = cds.getLocation(entityName, e);
-          const fix = (fixer, source = sourcecode) => {
-            const entityNameSanitized = entityName.charAt(0).toUpperCase() + entityName.slice(1);
-            const rangeEnd = source.getIndexFromLoc({
+          const file = e.$location.file
+          const loc = context.getLocation(entityName, e)
+          const fix = (fixer) => {
+            const entityNameSanitized = entityName.charAt(0).toUpperCase() + entityName.slice(1)
+            const rangeEnd = sourcecode.getIndexFromLoc({
               line: loc.end.line,
-              column: loc.end.column,
-            });
-            const rangeBeg = rangeEnd ? rangeEnd - entityNameSanitized.length : 0;
-            return fixer.replaceTextRange([rangeBeg, rangeEnd], entityNameSanitized);
-          };
-          return {
-            messageId: "startUppercase",
+              column: loc.end.column
+            })
+            const rangeBeg = rangeEnd ? rangeEnd - entityNameSanitized.length : 0
+            return fixer.replaceTextRange([rangeBeg, rangeEnd], entityNameSanitized)
+          }
+          context.report({
+            messageId: 'startUppercase',
             loc,
             file,
             data: { entityName },
             suggest: [
               {
-                messageId: "fixUppercase",
-                fix,
-              },
-            ],
-          };
+                messageId: 'fixUppercase',
+                fix
+              }
+            ]
+          })
         }
       }
     }
-  },
-};
+  }
+}

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

@@ -1,100 +1,101 @@
-const {basename, extname} = require('path')
-const findFuzzy = require('../utils/fuzzySearch')
+const cds = require('@sap/cds')
+const { basename, extname } = require('path')
+const findFuzzy = require('../utils/findFuzzy')
 const SEP = '[,;\t]'
 const EOL = '\\r?\\n'
 
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: `CSV files for entities must refer to valid element names.`,
-      category: "Model Validation",
-      recommended: true,
-      version: "2.3.0",
+      description: 'CSV files for entities must refer to valid element names.',
+      category: 'Model Validation',
+      recommended: true
     },
-    severity: "warn",
-    type: "problem",
+    severity: 'warn',
+    type: 'problem',
     hasSuggestions: true,
     messages: {
-      InvalidColumn: `Invalid column '{{column}}'. Did you mean '{{candidates}}'?`,
-      ReplaceColumnWith: `Replace '{{column}}' with '{{candidates}}'`
-    }
+      InvalidColumn: "Invalid column '{{column}}'. Did you mean '{{candidates}}'?",
+      ReplaceColumnWith: "Replace '{{column}}' with '{{candidates}}'"
+    },
+    model: 'inferred'
   },
   create: function (context) {
+    return checkValidHeaders
 
-    return { all: check_valid_headers }
+    function checkValidHeaders () {
+      const filePath = context.getFilename()
+      const sourcecode = context.getSourceCode()
+      const code = sourcecode.getText()
 
-    function check_valid_headers() {
-    const reports = [];
-    const {cds, code, filePath, sourcecode} = context;
+      let model = context.getModel()
+      if (!filePath.endsWith('.csv')) return
+      if (!model) return
 
-    if (!filePath.endsWith('.csv')) return
-    if (!cds.model)  return
-    let { env, model } = cds;
-    model = cds.compile.for.sql(model, { names:env.sql.names, messages: [] } )
+      model = cds.compile.for.sql(model, { names: cds.env.sql.names, messages: [] })
 
-    const filename = basename(filePath)
-    const entityName = filename.replace(/-/g,'.').slice(0, -extname(filename).length)
-    const entity = _entity4(entityName, model);
-    if (!entity)  return
+      const filename = basename(filePath)
+      const entityName = filename.replace(/-/g, '.').slice(0, -extname(filename).length)
+      const entity = _entity4(entityName, model)
+      if (!entity) return
 
-    const elements = Object.values(entity.elements)
-      .filter (e => !!e['@cds.persistence.name'])
-      .map (e => e['@cds.persistence.name'].toUpperCase())
+      const elements = Object.values(entity.elements)
+        .filter((e) => !!e['@cds.persistence.name'])
+        .map((e) => e['@cds.persistence.name'].toUpperCase())
 
-    const [ cols ] = cds.parse.csv(code);
-    const missing = cols.filter (col => !elements.includes(col.toUpperCase()))
-    missing.forEach(miss => {
-      const index = _findInCode (miss, code)
-      const loc = sourcecode.getLocFromIndex(index)
-      const candidates = findFuzzy(miss, Object.keys(entity.elements).sort())
-      const suggest = candidates.map(cand => { return {
-        messageId: 'ReplaceColumnWith',
-        data: {column: miss, candidates:cand},
-        fix: (fixer) => fixer.replaceTextRange([index, index+miss.length], cand)
-      }})
-      reports.push({
-        messageId: 'InvalidColumn',
-        data: {column: miss, candidates},
-        loc: {start: loc, end: {line: loc.line, column: loc.column+miss.length}},
-        file: filePath,
-        suggest
-      })
-    })
-    return reports
+      const [cols] = cds.parse.csv(code)
+      const missing = cols.filter((col) => !elements.includes(col.toUpperCase()))
+      for (const miss of missing) {
+        const index = _findInCode(miss, code)
+        const loc = sourcecode.getLocFromIndex(index)
+        const candidates = findFuzzy(miss, Object.keys(entity.elements).sort())
+        const suggest = candidates.map((cand) => {
+          return {
+            messageId: 'ReplaceColumnWith',
+            data: { column: miss, candidates: cand },
+            fix: (fixer) => fixer.replaceTextRange([index, index + miss.length], cand)
+          }
+        })
+        context.report({
+          messageId: 'InvalidColumn',
+          data: { column: miss, candidates },
+          loc: { start: loc, end: { line: loc.line, column: loc.column + miss.length } },
+          file: filePath,
+          suggest
+        })
+      }
     }
-
   }
-
 }
 
 function _findInCode (miss, code) {
   // middle
-  let match = new RegExp(SEP+miss+SEP).exec(code)
-  if (match)  return match.index+1
+  let match = new RegExp(SEP + miss + SEP).exec(code)
+  if (match) return match.index + 1
   // end of line
-  match = new RegExp(SEP+miss+EOL).exec(code)
-  if (match)  return match.index+1
+  match = new RegExp(SEP + miss + EOL).exec(code)
+  if (match) return match.index + 1
   // start of doc
-  match = new RegExp('^'+miss+SEP).exec(code)
-  if (match)  return match.index
+  match = new RegExp('^' + miss + SEP).exec(code)
+  if (match) return match.index
   // somewhere (fallback)
   return code.indexOf(miss)
 }
 
 function _entity4 (name, csn) {
-  let entity = csn.definitions [name]
+  const entity = csn.definitions[name]
   if (!entity) {
-    if (/(.+)[._]texts_?/.test (name)) { // 'Books.texts', 'Books.texts_de'
-      const base = csn.definitions [RegExp.$1]
-      return base && _entity4 (base.elements.texts.target, csn)
-    }
-    else return
+    if (/(.+)[._]texts_?/.test(name)) {
+      // 'Books.texts', 'Books.texts_de'
+      const base = csn.definitions[RegExp.$1]
+      return base && _entity4(base.elements.texts.target, csn)
+    } else return
   }
   // we also support simple views if they have no projection
-  const p = entity.query && entity.query.SELECT || entity.projection
+  const p = (entity.query && entity.query.SELECT) || entity.projection
   if (p && !p.columns && p.from.ref && p.from.ref.length === 1) {
-    if (csn.definitions [p.from.ref[0]])  return entity
+    if (csn.definitions[p.from.ref[0]]) return entity
   }
-  return entity.name ? entity : { name, __proto__:entity }
+  return entity.name ? entity : { name, __proto__: entity }
 }
-

package/lib/{api/lint.d.ts → types.d.ts}

@@ -3,26 +3,24 @@ import { Linter, Rule, RuleTester, SourceCode } from "eslint";
 
 export interface CDSRuleContext extends Rule.RuleContext {
     cds: any;
-    configPath: string;
+    rootPath: string;
     code: string;
     filePath: string;
     options: [];
     id: string;
     sourcecode: SourceCode;
+    getModel: function;
     report: (CDSRuleReport) => void;
     err: Error;
 }
 
-export interface CDSRuleSpec {
-    meta: CDSRuleMetaData,
+export interface Rule {
+    meta: RuleMetaData,
     create: (context: CDSRuleContext) => void;
 }
 
 export interface CDSRuleMetaData extends Rule.RuleMetaData {
-    docs: Rule.RuleMetaData['docs'] & {
-        version: string;
-    };
-    severity?: Linter.RuleLevel;
+    model?: "parsed" | "inferred" | "none";
 }
 
 export type CDSRuleReport = Rule.ReportDescriptor & {

package/lib/utils/Cache.js

@@ -0,0 +1,33 @@
+/**
+ * Simple cache to store model and any cds calls made in the rule creation
+ * api to modify the model
+ */
+const cache = new Map()
+
+module.exports = {
+  has (key) {
+    return cache.has(key)
+  },
+  set (key, value) {
+    return cache.set(key, [value, Date.now()])
+  },
+  get (key) {
+    return cache.get(key) ? cache.get(key)[0] : undefined
+  },
+  dump () {
+    const dump = {}
+    for (const [key, value] of cache.entries()) {
+      const timestamp = new Date(value[1])
+      dump[key] = { key, value: JSON.stringify(value[0]), timestamp }
+    }
+    return dump
+  },
+  remove (key) {
+    if (cache.has(key)) {
+      cache.delete(key)
+    }
+  },
+  clear () {
+    cache.clear()
+  }
+}

package/lib/utils/Colors.js

@@ -0,0 +1,9 @@
+module.exports = {
+  reset: '\x1b[0m', // Default
+  bold: '\x1b[1m', // Bold/Bright
+  link: '\x1b[4m', // underline
+  red: '\x1b[91m', // Bright Foreground Red
+  green: '\x1b[32m', // Foreground Green
+  blue: '\x1b[34m', // Foreground Blue
+  orange: '\x1b[38;2;255;140;0m' // darker orange, works with bright and dark background
+}