@sap/eslint-plugin-cds 2.1.0 → 2.3.0

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

@@ -1,39 +1,31 @@
-const cdsLint = require("../../api");
-
-module.exports = cdsLint.createRule(
-  /* Rule meta */
-  {
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-      description: `In relational databases, the foreign key information of a \`TO MANY\` relationship must be defined within the target and specified in an \`ON\` condition.
-        Therefore, all \`TO MANY\` relationships must have a defined \`ON\` condition.`,
+      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",
     },
+    severity: "error",
     type: "problem",
   },
-  /* Rule logic */
-  (report, cds) => {
-    return createReport(report, cds) || report;
-  }
-);
-
-const createReport = (report, cds) => {
-  const m = cds.model;
-  m.forall((d) => {
-    if (d.name) {
-      if (!d.elements) return;
-      for (const elementName in d.elements) {
-        const element = d.elements[elementName];
-        if (element.is2many && !element.on) {
-          const loc = cds.getLocation(elementName, element);
-          report.push({
-            message: `You must provide an \`ON\` condition for \`TO MANY\` relationship '${element.name}'.`,
-            loc,
-            file: d.$location.file,
-          });
+  create: function (context) {
+    const m = context.cds.model;  if (!m)  return
+    m.forall((d) => {
+      if (d.name) {
+        if (!d.elements) return;
+        for (const elementName in d.elements) {
+          const element = d.elements[elementName];
+          if (element.is2many && !element.on) {
+            const loc = context.cds.getLocation(elementName, element);
+            context.report({
+              message: `You must provide an \`ON\` condition for \`TO MANY\` relationship '${element.name}'.`,
+              loc,
+              file: d.$location.file,
+            });
+          }
         }
       }
-    }
-  });
-  return report;
-};
+    });
+  },
+});

package/lib/impl/rules/rule.hbs

@@ -1,26 +1,20 @@
-const cdsLint = require("../../lib/api");
-
-module.exports = cdsLint.createRule(
-  {
+// @ts-check
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-        description: "{{description}}",
-        category: "{{category}}",
-        {{recommended}}
-        {{version}}
+      description: "{{description}}",
+      version: "{{version}}"
       },
-    type: "{{type}}",
-    {{messages}}
+      type:"{{type}}",
   },
-  (cds, model, env, context) => {
-    return createReport(report, cds, {{cds_object}}, report) || report;
+  create: function(context) {
+    const m = cotext.cds.model;
+    m.forall((d)) => {
+      // Add cds logic here, for example
+      return [{
+        message: "{{messages}}",
+        loc: {{loc}}
+      }];
+    }
   }
-);
-
-const createReport = (report, cds, {{cds_object}}, report) => {
-  // Iterate over your model using m.foreach or m.forall...
-  m.forall((d) => {
-    // Add reports when rule is triggered
-    report.push({ mesage: {{error_msg}}, loc, file })
-  })
-  return report;
-};
+})

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

@@ -1,55 +1,52 @@
-const cdsLint = require("../../api");
-
-module.exports = cdsLint.createRule(
-  /* Rule meta */
-  {
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-      description: "Should make suggestions for possible missing sql casts.",
+      description: "Should make suggestions for possible missing SQL casts.",
       category: "Model Validation",
+      recommended: true,
       version: "1.0.8",
     },
+    severity: "warn",
     type: "suggestion",
+    hasSuggestions: true,
     messages: {
-      missingSQLCast: "Missing SQL cast?",
+      missingSQLCast:
+        "Potential issue - Missing SQL cast for column expression?",
     },
   },
-  /* Rule logic */
-  (report, cds, sourcecode) => {
-    return createReport(report, cds, sourcecode) || report;
-  }
-);
-
-const createReport = (report, cds, sourcecode) => {
-  const m = cds.model;
-  if (m) {
-    const view = (d) => d.query;
-    m.foreach(view, (v) => {
-      if (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;
-            if (cast && xpr) {
-              if (xpr[0].xpr && xpr[0].xpr && xpr[0].cast) {
-                continue;
-              } else {
-                if (sourcecode.lines[location.line - 1]) {
-                  const endCol = sourcecode.lines[location.line - 1].length;
-                  const loc = {
-                    start: { line: location.line, column: location.col - 1 },
-                    end: { line: location.line, column: endCol },
-                  };
-                  report.push({
-                    message: `Potential issue - Missing SQL cast for column expression?`,
-                    loc,
-                    file: location.file,
-                  });
+  create: function (context) {
+    const m = context.cds.model;
+    if (m) {
+      const view = (d) => d.query;
+      m.foreach(view, (v) => {
+        if (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;
+              if (cast && xpr) {
+                if (xpr[0].xpr && 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 },
+                    };
+                    context.report({
+                      messageId: "missingSQLCast",
+                      loc,
+                      file: location.file,
+                    });
+                  }
                 }
               }
             }
           }
-        }
-    });
-  }
-  return report;
-};
+      });
+    }
+    return context.report;
+  },
+});

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

@@ -1,69 +1,75 @@
-const cdsLint = require("../../api");
-
-module.exports = cdsLint.createRule(
-  /* Rule meta */
-  {
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-      description: `Regular element names should all be in lowercase.`,
+      description: "Regular element names should start with lowercase letters.",
       category: "Model Validation",
       version: "1.0.4",
     },
     type: "suggestion",
+    hasSuggestions: true,
     messages: {
-      startLowercase: "Start elements with lowercase letters",
+      startLowercase:
+        "Element name '{{entityName}}.{{elementName}}' should start with a lowercase letter.",
+        fixLowercase:
+        "Start element name with a lowercase letter."
     },
     fixable: "code",
   },
-  /* Rule logic */
-  (report, cds, sourcecode) => {
-    return createReport(report, cds, sourcecode) || report;
-  }
-);
-
-const createReport = (report, cds, sourcecode) => {
-  const m = cds.model;
-  if (m && m.definitions) {
-    m.forall((d) => {
-      const entityName = d.name;
-      for (const elementName in d.elements) {
-        const element = d.elements[elementName];
-        if (
-          elementName &&
-          !(entityName.startsWith("localized") || entityName.endsWith("texts"))
-        ) {
+  create: function (context) {
+    const m = context.cds.model;
+    if (m && m.definitions) {
+      m.forall((d) => {
+        const entityName = d.name;
+        for (const elementName in d.elements) {
+          const element = d.elements[elementName];
           if (
-            elementName.charAt(0) !== elementName.charAt(0).toLowerCase() &&
-            !["ID"].includes(elementName)
+            elementName &&
+            !(
+              entityName.startsWith("localized") || entityName.endsWith("texts")
+            )
           ) {
-            if (element.$location && element.$location.file) {
-              const file = element.$location.file;
-              const loc = cds.getLocation(elementName, element);
-              const fix = (fixer) => {
-                const elementNameSanitized =
-                  elementName.charAt(0).toLowerCase() + elementName.slice(1);
-                const rangeEnd = sourcecode.getIndexFromLoc({
-                  line: loc.end.line,
-                  column: loc.end.column,
+            if (
+              elementName.charAt(0) !== elementName.charAt(0).toLowerCase() &&
+              !["ID"].includes(elementName)
+            ) {
+              if (element.$location && element.$location.file) {
+                const file = element.$location.file;
+                const loc = context.cds.getLocation(elementName, element);
+                const fix = (fixer) => {
+                  const elementNameSanitized =
+                    elementName.charAt(0).toLowerCase() + elementName.slice(1);
+                  const rangeEnd = context.sourcecode.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,
+                    },
+                  ],
                 });
-                const rangeBeg = rangeEnd
-                  ? rangeEnd - elementNameSanitized.length
-                  : 0;
-                return fixer.replaceTextRange(
-                  [rangeBeg, rangeEnd],
-                  elementNameSanitized
-                );
-              };
-              report.push({
-                message: `Element '${entityName}.${elementName}' must be lowercase`,
-                loc,
-                fix,
-                file,
-              });
+              }
             }
           }
         }
-      }
-    });
-  }
-  return report;
-};
+      });
+    }
+  },
+});

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

@@ -1,31 +1,23 @@
-const cdsLint = require("../../api");
-
-module.exports = cdsLint.createRule(
-  /* Rule meta */
-  {
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-      description: "Entity names should all be in uppercase.",
+      description: "Regular entity names should start with uppercase letters.",
       category: "Model Validation",
       version: "1.0.4",
     },
     type: "suggestion",
+    hasSuggestions: true,
     messages: {
-      startUppercase: "Start entity and type names with capital letters",
+      startUppercase:
+        "Entity name '{{entityName}}' should start with an uppercase letter.",
+      fixUppercase: "Start entity name with an uppercase letter.",
     },
     fixable: "code",
   },
-  /* Rule logic */
-  (report, cds, sourcecode) => {
-    return createReport(report, cds, sourcecode) || report;
-  }
-);
-
-const createReport = (report, cds, sourcecode) => {
-  const m = cds.model;
-  if (m) {
-    m.foreach(
-      "entity",
-      (e) => {
+  create: function (context) {
+    const m = context.cds.model;
+    if (m) {
+      m.foreach("entity", (e) => {
         let entityName = e.name;
         const names = entityName.split(".");
         entityName = names[names.length - 1];
@@ -35,41 +27,39 @@ const createReport = (report, cds, sourcecode) => {
         ) {
           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) => {
-              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
-              );
-            };
-            const suggest = [
-              {
+              const file = e.$location.file;
+              const loc = context.cds.getLocation(entityName, e);
+              const fix = (fixer) => {
+                const entityNameSanitized =
+                  entityName.charAt(0).toUpperCase() + entityName.slice(1);
+                const rangeEnd = context.sourcecode.getIndexFromLoc({
+                  line: loc.end.line,
+                  column: loc.end.column,
+                });
+                const rangeBeg = rangeEnd
+                  ? rangeEnd - entityNameSanitized.length
+                  : 0;
+                return fixer.replaceTextRange(
+                  [rangeBeg, rangeEnd],
+                  entityNameSanitized
+                );
+              };
+              context.report({
                 messageId: "startUppercase",
-                fix,
-              },
-            ];
-            report.push({
-              message: `Entity '${entityName}' must be uppercase`,
-              loc,
-              file,
-              fix,
-              suggest,
-            });
-          }
+                loc,
+                file,
+                data: { entityName },
+                suggest: [
+                  {
+                    messageId: "fixUppercase",
+                    fix,
+                  },
+                ],
+              });
+            }
           }
         }
-      }
-    );
-  }
-  return report;
-};
+      });
+    }
+  },
+});

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

@@ -0,0 +1,92 @@
+const {basename, extname} = require('path')
+const findFuzzy = require('../utils/fuzzySearch')
+const SEP = '[,;\t]'
+const EOL = '\\r?\\n'
+
+module.exports = require("../../api").createRule({
+  meta: {
+    docs: {
+      description: `CSV files for entities must refer to valid element names.`,
+      category: "Model Validation",
+      recommended: true,
+      version: "2.3.0",
+    },
+    severity: "warn",
+    type: "problem",
+    hasSuggestions: true,
+    messages: {
+      InvalidColumn: `Invalid column '{{column}}'. Did you mean '{{candidates}}'?`,
+      ReplaceColumnWith: `Replace '{{column}}' with '{{candidates}}'`
+    }
+  },
+  create: function (context) {
+    const {cds, code, filePath, sourcecode} = context
+
+    if (!filePath.endsWith('.csv'))  return
+    if (!cds.model)  return
+    let {env, model} = cds;
+    model = cds.compile.for.sql(model, {names: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 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)
+      }})
+      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
+  // end of line
+  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
+  // somewhere (fallback)
+  return code.indexOf(miss)
+}
+
+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
+  }
+  // we also support simple views if they have no 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
+  }
+  return entity.name ? entity : { name, __proto__:entity }
+}
+

package/lib/impl/types.d.ts

@@ -0,0 +1,48 @@
+import { Rule, RuleTester, SourceCode } from "eslint";
+
+export interface CDSRuleMetaData extends Rule.RuleMetaData {
+    docs: {
+        /** provides the short description of the rule in the [rules index](https://eslint.org/docs/rules/) */
+        description: Rule.RuleMetaData['docs']['description'];
+        /** specifies version of @sap/eslint-plugin-cds at which the rule was first implemented */
+        version: string;
+    };
+    messages?: Rule.RuleMetaData['messages'];
+    fixable?: Rule.RuleMetaData['fixable'];
+    schema?: Rule.RuleMetaData['schema'];
+    deprecated?: Rule.RuleMetaData['deprecated'];
+    type?: Rule.RuleMetaData['type'];
+}
+
+export type CDSReport = Rule.ReportDescriptor & { file?: string };
+
+export interface CDSRuleContext extends Rule.RuleContext {
+    cds: any;
+    configPath: string;
+    code: string;
+    filePath: string;
+    options: [];
+    ruleID: string;
+    sourcecode: SourceCode
+}
+export interface CDSRuleSpec {
+    meta: CDSRuleMetaData,
+    create: (arg0: CDSRuleContext) => Rule.ReportDescriptor;
+}
+
+export interface CDSTestCaseError extends RuleTester.TestCaseError {
+    message: string | RegExp;
+}
+
+export interface CDSRuleTestOpts {
+    /** specifies __dirname */
+    root: string;
+    /** requires your rule .js here */
+    rule?: string;
+    /** filename ('schema.cds' for model, 'package.json' for env) */
+    filename: string;
+    /** resolves cds parser path */
+    parser?: string;
+    /** List of warnings/errors from ESLint's [ruleTester](https://eslint.org/docs/developer-guide/nodejs-api#ruletester) */
+    errors: CDSTestCaseError[]
+}