@sap/eslint-plugin-cds 2.5.0 → 2.6.1

package/lib/rules/no-dollar-prefixed-names.js

@@ -1,23 +1,24 @@
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: `Names must not start with $ to avoid possible shadowing of reserved variables.`,
+      description: 'Names must not start with $ to avoid possible shadowing of reserved variables.',
       recommended: true
     },
-    type: "problem"
+    type: 'problem'
   },
-  create(context) {
-    return { element: _check };
+  create (context) {
+    return { element: _check }
 
-    function _check(d) {
-      let srv = d._service || (d.parent && d.parent._service);
-      if (srv && srv["@cds.external"]) return;
-      if (d.name.startsWith("$")) {
+    function _check (d) {
+      const srv = d._service || (d.parent && d.parent._service)
+      if (srv && srv['@cds.external']) return
+      if (d.name.startsWith('$')) {
         context.report({
-          message: `“${d.name}” is prefixed with a dollar sign ($)`,
+          message: `'${d.name}' is prefixed with a dollar sign ($)`,
           node: context.getNode(d)
-        });
+        })
       }
     }
   }
-};
+}

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,22 +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.`,
+      description: 'Foreign key information of a `TO MANY` relationship must be defined within the target and specified in an `ON` condition.',
       recommended: true
     },
-    type: "problem"
+    type: 'problem'
   },
   create: function (context) {
-    return { element: check_2many_oncond };
+    return { element: check2manyOncond }
 
-    function check_2many_oncond(e) {
-      if (e.is2many && !e.on && typeof e.target === "string") {
+    function check2manyOncond (e) {
+      if (e.is2many && !e.on && typeof e.target === 'string') {
         context.report({
           message: `You must provide an \`ON\` condition for \`TO MANY\` relationship '${e.name}'.`,
           node: context.getNode(e)
-        });
+        })
       }
     }
-
   }
-};
+}

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

@@ -1,38 +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.",
+      description: 'Should make suggestions for possible missing SQL casts.',
       recommended: true
     },
-    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) {
+    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 } = each;
+            const { xpr, cast } = each
             if (cast && xpr) {
               if (xpr[0].xpr && xpr[0].cast) {
-                continue;
+                continue
               } else {
                 context.report({
-                  messageId: "missingSQLCast",
+                  messageId: 'missingSQLCast',
                   node: context.getNode(v)
-                });
+                })
               }
             }
           }
         }
       }
     }
-  },
-};
+  }
+}

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

@@ -1,58 +1,59 @@
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: "Regular element names should start with lowercase letters."
+      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 sourcecode = context.getSourceCode();
+    const sourcecode = context.getSourceCode()
 
     return {
-      element: check_start_lowercase,
-    };
+      element: checkStartLowercase
+    }
 
-    function check_start_lowercase(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,
-                  },
-                ],
-              });
+    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,52 +1,53 @@
-const { splitEntityName } = require("../utils/rules");
+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."
+      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 sourcecode = context.getSourceCode();
+    const sourcecode = context.getSourceCode()
 
-    return { entity: check_starts_uppercase };
+    return { entity: checkStartsUppercase }
 
-    function check_starts_uppercase(e) {
-      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 = context.getLocation(entityName, e);
+          const file = e.$location.file
+          const loc = context.getLocation(entityName, e)
           const fix = (fixer) => {
-            const entityNameSanitized = entityName.charAt(0).toUpperCase() + entityName.slice(1);
+            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);
-          };
+              column: loc.end.column
+            })
+            const rangeBeg = rangeEnd ? rangeEnd - entityNameSanitized.length : 0
+            return fixer.replaceTextRange([rangeBeg, rangeEnd], entityNameSanitized)
+          }
           context.report({
-            messageId: "startUppercase",
+            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 cds = require("@sap/cds");
-const { basename, extname } = require("path");
-const findFuzzy = require("../utils/findFuzzy");
-const SEP = "[,;\t]";
-const EOL = "\\r?\\n";
+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",
+      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",
+    model: 'inferred'
   },
   create: function (context) {
-    return check_valid_headers;
+    return checkValidHeaders
 
-    function check_valid_headers() {
-      const filePath = context.getFilename();
-      const sourcecode = context.getSourceCode();
-      const code = sourcecode.getText();
+    function checkValidHeaders () {
+      const filePath = context.getFilename()
+      const sourcecode = context.getSourceCode()
+      const code = sourcecode.getText()
 
-      let model = context.getModel();
-      if (!filePath.endsWith(".csv")) return;
-      if (!model) return;
+      let model = context.getModel()
+      if (!filePath.endsWith('.csv')) return
+      if (!model) return
 
-      model = cds.compile.for.sql(model, { names: cds.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());
+        .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()));
+      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 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",
+            messageId: 'ReplaceColumnWith',
             data: { column: miss, candidates: cand },
-            fix: (fixer) => fixer.replaceTextRange([index, index + miss.length], cand),
-          };
-        });
+            fix: (fixer) => fixer.replaceTextRange([index, index + miss.length], cand)
+          }
+        })
         context.report({
-          messageId: "InvalidColumn",
+          messageId: 'InvalidColumn',
           data: { column: miss, candidates },
           loc: { start: loc, end: { line: loc.line, column: loc.column + miss.length } },
           file: filePath,
-          suggest,
-        });
+          suggest
+        })
       }
     }
-  },
-};
+  }
+}
 
-function _findInCode(miss, code) {
+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);
+  return code.indexOf(miss)
 }
 
-function _entity4(name, csn) {
-  let entity = csn.definitions[name];
+function _entity4 (name, csn) {
+  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;
+      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/types.d.ts

@@ -9,6 +9,7 @@ export interface CDSRuleContext extends Rule.RuleContext {
     options: [];
     id: string;
     sourcecode: SourceCode;
+    getModel: function;
     report: (CDSRuleReport) => void;
     err: Error;
 }

package/lib/utils/Cache.js

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

package/lib/utils/Colors.js

@@ -1,9 +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
-  }
+  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
+}