@sap/eslint-plugin-cds 2.3.4 → 2.5.0

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

@@ -3,11 +3,8 @@ module.exports = {
   meta: {
     docs: {
       description: "Should make suggestions for possible missing SQL casts.",
-      category: "Model Validation",
-      recommended: true,
-      version: "1.0.8",
+      recommended: true
     },
-    severity: "warn",
     type: "suggestion",
     hasSuggestions: true,
     messages: {
@@ -18,35 +15,24 @@ module.exports = {
     return { view: check_sql_cast };
 
     function check_sql_cast(v) {
-      const reports = [];
       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;
               } 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,9 +1,7 @@
 module.exports = {
   meta: {
     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",
     hasSuggestions: true,
@@ -14,31 +12,30 @@ module.exports = {
     fixable: "code",
   },
   create: function (context) {
-    const { cds, filePath, sourcecode } = context;
+    const sourcecode = context.getSourceCode();
 
     return {
       element: check_start_lowercase,
     };
 
     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) => {
+              const loc = context.getLocation(elementName, e);
+              const fix = (fixer, source = sourcecode) => {
                 const elementNameSanitized = elementName.charAt(0).toLowerCase() + elementName.slice(1);
-                const rangeEnd = sourcecode.getIndexFromLoc({
+                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 {
+              context.report({
                 messageId: "startLowercase",
                 loc,
                 file,
@@ -52,7 +49,7 @@ module.exports = {
                     fix,
                   },
                 ],
-              };
+              });
             }
         }
       }

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

@@ -1,11 +1,9 @@
-const { splitEntityName } = require("../utils/ruleHelpers");
+const { splitEntityName } = require("../utils/rules");
 
 module.exports = {
   meta: {
     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",
     hasSuggestions: true,
@@ -16,17 +14,16 @@ module.exports = {
     fixable: "code",
   },
   create: function (context) {
-    const { cds, filePath, sourcecode } = context;
+    const sourcecode = context.getSourceCode();
 
     return { entity: check_starts_uppercase };
 
     function check_starts_uppercase(e) {
-      if (!filePath.endsWith(".cds")) return;
       const entityName = splitEntityName(e).entity;
       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 loc = context.getLocation(entityName, e);
           const fix = (fixer) => {
             const entityNameSanitized = entityName.charAt(0).toUpperCase() + entityName.slice(1);
             const rangeEnd = sourcecode.getIndexFromLoc({
@@ -36,7 +33,7 @@ module.exports = {
             const rangeBeg = rangeEnd ? rangeEnd - entityNameSanitized.length : 0;
             return fixer.replaceTextRange([rangeBeg, rangeEnd], entityNameSanitized);
           };
-          return {
+          context.report({
             messageId: "startUppercase",
             loc,
             file,
@@ -47,7 +44,7 @@ module.exports = {
                 fix,
               },
             ],
-          };
+          });
         }
       }
     }

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

@@ -1,100 +1,100 @@
-const {basename, extname} = require('path')
-const findFuzzy = require('../utils/fuzzySearch')
-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: {
     docs: {
       description: `CSV files for entities must refer to valid element names.`,
       category: "Model Validation",
-      recommended: true,
-      version: "2.3.0",
+      recommended: true
     },
     severity: "warn",
     type: "problem",
     hasSuggestions: true,
     messages: {
       InvalidColumn: `Invalid column '{{column}}'. Did you mean '{{candidates}}'?`,
-      ReplaceColumnWith: `Replace '{{column}}' with '{{candidates}}'`
-    }
+      ReplaceColumnWith: `Replace '{{column}}' with '{{candidates}}'`,
+    },
+    model: "inferred",
   },
   create: function (context) {
-
-    return { all: check_valid_headers }
+    return check_valid_headers;
 
     function check_valid_headers() {
-    const reports = [];
-    const {cds, code, filePath, sourcecode} = context;
+      const filePath = context.getFilename();
+      const sourcecode = context.getSourceCode();
+      const code = sourcecode.getText();
 
-    if (!filePath.endsWith('.csv')) return
-    if (!cds.model)  return
-    let { env, model } = cds;
-    model = cds.compile.for.sql(model, { names:env.sql.names, messages: [] } )
+      let model = context.getModel();
+      if (!filePath.endsWith(".csv")) return;
+      if (!model) return;
 
-    const filename = basename(filePath)
-    const entityName = filename.replace(/-/g,'.').slice(0, -extname(filename).length)
-    const entity = _entity4(entityName, model);
-    if (!entity)  return
+      model = cds.compile.for.sql(model, { names: cds.env.sql.names, messages: [] });
 
-    const elements = Object.values(entity.elements)
-      .filter (e => !!e['@cds.persistence.name'])
-      .map (e => e['@cds.persistence.name'].toUpperCase())
+      const filename = basename(filePath);
+      const entityName = filename.replace(/-/g, ".").slice(0, -extname(filename).length);
+      const entity = _entity4(entityName, model);
+      if (!entity) return;
 
-    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 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()));
+      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) {
+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) {
+  let 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,7 +3,7 @@ import { Linter, Rule, RuleTester, SourceCode } from "eslint";
 
 export interface CDSRuleContext extends Rule.RuleContext {
     cds: any;
-    configPath: string;
+    rootPath: string;
     code: string;
     filePath: string;
     options: [];
@@ -13,16 +13,13 @@ export interface CDSRuleContext extends Rule.RuleContext {
     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
+  }