@sap/eslint-plugin-cds 2.3.2 → 2.3.3

package/lib/rules/latest-cds-version.js

@@ -0,0 +1,42 @@
+const cp = require("child_process");
+const semver = require("semver");
+
+module.exports = {
+  meta: {
+    docs: {
+      description: "Checks whether the latest `@sap/cds` version is being used.",
+      category: "Environment",
+      version: "1.0.4",
+    },
+    type: "suggestion",
+    hasSuggestions: true,
+    messages: {
+      latestCDSVersion: `A newer CDS version is available!`,
+    },
+  },
+  create: function (context) {
+    return { all: check_latest_cds_version };
+
+    function check_latest_cds_version() {
+      let cdsVersions;
+      let e = context.cds.environment;
+      if (!e) {
+        e = cp
+          .execSync(`npm outdated @sap/cds --json`, {
+            cwd: process.cwd(),
+            stdio: "pipe",
+          })
+          .toString();
+      }
+      if (e && e["@sap/cds"]) {
+        cdsVersions = e["@sap/cds"];
+        // If current cds version is not the latest
+        if (Object.keys(cdsVersions).length !== 0 && !semver.satisfies(cdsVersions.latest, cdsVersions.current)) {
+          return {
+            messageId: "latestCDSVersion",
+          };
+        }
+      }
+    }
+  },
+};

package/lib/rules/min-node-version.js

@@ -0,0 +1,47 @@
+const path = require("path");
+const semver = require("semver");
+
+module.exports = {
+  meta: {
+    docs: {
+      description: `Checks whether the minimum Node.js version required by \`@sap/cds\` is achieved.`,
+      category: "Environment",
+      recommended: true,
+      version: "1.0.0",
+    },
+    severity: "error",
+    type: "problem",
+  },
+  create: function (context) {
+    return { all: check_min_node_version }
+
+    function check_min_node_version() {
+      const e = context.cds.environment;
+      let nodeVersion, nodeVersionCDS;
+      if (!e) {
+        // Get current and required node versions
+        try {
+          const CDSPath = require.resolve("@sap/cds/package.json", {
+            paths: [path.dirname(context.filePath)],
+          });
+          const jsonCDS = require(CDSPath);
+          nodeVersion = process.version;
+          nodeVersionCDS = jsonCDS.engines.node;
+        } catch (err) {
+          // Do not throw
+        }
+      } else {
+        nodeVersion = e.nodeVersion;
+        nodeVersionCDS = e.nodeVersionCDS;
+      }
+      if (
+        nodeVersion &&
+        nodeVersionCDS &&
+        !semver.satisfies(nodeVersion, nodeVersionCDS, { loose: true })
+      ) {
+        return `CDS minimum node version of ${nodeVersionCDS} required, found ${nodeVersion}!`;
+      }
+    }
+
+  },
+};

package/lib/rules/no-db-keywords.js

@@ -0,0 +1,46 @@
+// TODO: TEST API
+//module.exports = require("../../api").createRule({ // TODO: eliminate that and allow std eslint style module.export = { ...
+module.exports = {
+  meta: {
+    docs: {
+      description: `Avoid using reserved SQL keywords.`,
+      category: "Model Validation", //> values are specific for cds lint
+      recommended: true,
+      version: "2.1.0",
+    },
+    severity: "error" //> convenience option by cds.lint
+  },
+  create(context) {
+    const { cds } = context //> specific for cds lint
+    const { db = { kind: "sql" } } = cds.env.requires
+
+    return { //> return standard eslint visitor callbacks registered to CSN kinds, types, ...
+      entity: check_name_is_not_reserved,
+      element: check_name_is_not_reserved
+    }
+
+    function check_name_is_not_reserved(d) {
+      if (d.name in RESERVED) {
+        // Do not blame in case of external services
+        let srv = d._service || (d.parent && d.parent._service)
+        if (srv && srv["@cds.external"]) return
+
+        // Do blame
+        return `'${d.name}' is a reserved keyword in ${db.kind.toUpperCase()}` //> convenience options by cds lint
+      }
+    }
+  },
+};
+
+// REVISIT: Replace by compiler-provided check
+const RESERVED = {
+  ORDER: 1,
+  Order: 1,
+  order: 1,
+  GROUP: 1,
+  Group: 1,
+  group: 1,
+  LIMIT: 1,
+  Limit: 1,
+  limit: 1,
+};

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

@@ -0,0 +1,47 @@
+module.exports = {
+  meta: {
+    docs: {
+      description: `Names must not start with $ to avoid possible shadowing of reserved variables.`,
+      category: "Model Validation",
+      recommended: true,
+      version: "2.3.3",
+    },
+    severity: "warn",
+  },
+  create(context) {
+    return { element: _check };
+
+    function _check(d) {
+
+      // Do not blame in case of external services
+      let srv = d._service || (d.parent && d.parent._service);
+      if (srv && srv["@cds.external"]) return;
+
+      const results = [];
+      for (const m in context.cds.model.messages) {
+        const msg = context.cds.model.messages[m];
+        if (msg.messageId === "syntax-dollar-ident") {
+          results.push({
+            message: msg.message,
+            loc: {
+              start: { line: msg.location.line, column: msg.location.col - 1 },
+              end: {
+                line: msg.location.endLine,
+                column: !msg.location.endCol
+                          ? context.sourcecode.lines[msg.location.line - 1].length 
+                          : msg.location.endCol - 1,
+              },
+            },
+            file: msg.location.file,
+          });
+        }
+      }
+
+      if (d.name.startsWith("$")) {
+        // Do blame
+        results.push(`“${d.name}” is prefixed with a dollar sign ($)`);
+      }
+      return results.length > 0 ? results : undefined;
+    }
+  },
+};

package/lib/{impl/rules → rules}/no-join-on-draft-enabled-entities.js

@@ -1,4 +1,4 @@
-module.exports = require("../../api").createRule({
+module.exports = {
   meta: {
     docs: {
       description: `Draft-enabled entities shall not be used in views that make use of \`JOIN\`.`,
@@ -13,25 +13,28 @@ module.exports = require("../../api").createRule({
     },
   },
   create: function (context) {
-    const m = context.cds.model;  if (!m)  return
-    m.foreach("entity", (entity) => {
-      if (entity["@odata.draft.enabled"]) {
-        if (entity.query.SELECT.from.join) {
-          const location = entity.query.$location;
+
+    return { entity: check_nojoin_draftenabled }
+
+    function check_nojoin_draftenabled(e) {
+      if (e["@odata.draft.enabled"]) {
+        if (e.query.SELECT.from.join) {
+          const location = e.query.$location;
           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({
+            return {
               messageId: "noJoinOnDraftEnabledEntities",
               loc,
-              file: entity.$location.file,
-            });
+              file: e.$location.file,
+            };
           }
         }
       }
-    });
+    }
+
   },
-});
+};

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

@@ -0,0 +1,27 @@
+module.exports = {
+  meta: {
+    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",
+    },
+    severity: "error",
+    type: "problem",
+  },
+  create: function (context) {
+
+    return { element: check_2many_oncond }
+
+    function check_2many_oncond(e) {
+      if (e.is2many && !e.on && typeof e.target === 'string') {
+        const loc = context.cds.getLocation(e.name, e);
+        return {
+          message: `You must provide an \`ON\` condition for \`TO MANY\` relationship '${e.name}'.`,
+          loc,
+          file: e.parent.$location.file,
+        };
+      }
+    }
+  },
+};

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

@@ -0,0 +1,52 @@
+/* eslint-disable no-undef */
+module.exports = {
+  meta: {
+    docs: {
+      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: "Potential issue - Missing SQL cast for column expression?",
+    },
+  },
+  create: function (context) {
+    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;
+            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,
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+      if (reports.length > 0 ) return reports;    
+    }
+    
+  },
+};

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

@@ -0,0 +1,61 @@
+module.exports = {
+  meta: {
+    docs: {
+      description: "Regular element names should start with lowercase letters.",
+      category: "Model Validation",
+      version: "1.0.4",
+    },
+    type: "suggestion",
+    hasSuggestions: true,
+    messages: {
+      startLowercase: "Element name '{{entityName}}.{{elementName}}' should start with a lowercase letter.",
+      fixLowercase: "Start element name with a lowercase letter.",
+    },
+    fixable: "code",
+  },
+  create: function (context) {
+    const { cds, filePath, sourcecode } = context;
+
+    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 elementNameSanitized = elementName.charAt(0).toLowerCase() + elementName.slice(1);
+                const rangeEnd = sourcecode.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,
+                  },
+                ],
+              };
+            }
+        }
+      }
+    }
+  },
+};

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

@@ -0,0 +1,55 @@
+const { splitEntityName } = require("../utils/ruleHelpers");
+
+module.exports = {
+  meta: {
+    docs: {
+      description: "Regular entity names should start with uppercase letters.",
+      category: "Model Validation",
+      version: "1.0.4",
+    },
+    type: "suggestion",
+    hasSuggestions: true,
+    messages: {
+      startUppercase: "Entity name '{{entityName}}' should start with an uppercase letter.",
+      fixUppercase: "Start entity name with an uppercase letter.",
+    },
+    fixable: "code",
+  },
+  create: function (context) {
+    const { cds, filePath, sourcecode } = context;
+
+    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 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",
+            loc,
+            file,
+            data: { entityName },
+            suggest: [
+              {
+                messageId: "fixUppercase",
+                fix,
+              },
+            ],
+          };
+        }
+      }
+    }
+  },
+};

package/lib/{impl/rules → rules}/valid-csv-header.js

@@ -3,7 +3,7 @@ const findFuzzy = require('../utils/fuzzySearch')
 const SEP = '[,;\t]'
 const EOL = '\\r?\\n'
 
-module.exports = require("../../api").createRule({
+module.exports = {
   meta: {
     docs: {
       description: `CSV files for entities must refer to valid element names.`,
@@ -20,23 +20,28 @@ module.exports = require("../../api").createRule({
     }
   },
   create: function (context) {
-    const {cds, code, filePath, sourcecode} = context
 
-    if (!filePath.endsWith('.csv'))  return
+    return { all: check_valid_headers }
+
+    function check_valid_headers() {
+    const reports = [];
+    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: []} )
+    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)
+    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 [ cols ] = cds.parse.csv(code);
     const missing = cols.filter (col => !elements.includes(col.toUpperCase()))
     missing.forEach(miss => {
       const index = _findInCode (miss, code)
@@ -47,7 +52,7 @@ module.exports = require("../../api").createRule({
         data: {column: miss, candidates:cand},
         fix: (fixer) => fixer.replaceTextRange([index, index+miss.length], cand)
       }})
-      context.report({
+      reports.push({
         messageId: 'InvalidColumn',
         data: {column: miss, candidates},
         loc: {start: loc, end: {line: loc.line, column: loc.column+miss.length}},
@@ -55,9 +60,12 @@ module.exports = require("../../api").createRule({
         suggest
       })
     })
+    return reports
+    }
+
   }
 
-})
+}
 
 function _findInCode (miss, code) {
   // middle

package/lib/utils/helpers.js

@@ -0,0 +1,55 @@
+const { FILES, MODEL_FILES } = require("../constants");
+
+module.exports = {
+  /**
+   * Checks whether the given filePath matches a regex `files`
+   * @param {string} filePath
+   * @returns boolean
+   */
+  isValidFile: function (filePath, fileType) {
+    function genRegex(key) {
+      return new RegExp(
+        `${key
+          .map((file) => {
+            return file.replace("*", "");
+          })
+          .join("$|")}$`
+      );
+    }
+    let isValid = false;
+    switch(fileType) {
+      case 'MODEL_FILES':
+        isValid = genRegex(MODEL_FILES).test(filePath);
+        break;
+      case 'FILES': 
+        isValid = genRegex(FILES).test(filePath);
+        break;
+    }
+    return isValid;
+  },
+  /**
+   * Checks whether the plugin is run via VS Code ESLint extension
+   * @returns boolean
+   */
+  isVSCodeEditor() {
+    return process.argv.join(" ").includes("dbaeumer.vscode-eslint");
+  },
+
+  /**
+   * Checks whether ESLint is running in debug mode
+   * @returns boolean
+   */
+  hasDebugFlag() {
+    return process.argv.includes("--debug");
+  },
+
+  /**
+   * Returns an array of allowed file extensions
+   * the plugin can parse of the form "*.ext"
+   * @returns {ConfigOverrideFiles} Array of file extensions
+   */
+  getFileExtensions: function() {
+    return FILES;
+  },
+
+};