@sap/eslint-plugin-cds 2.3.0 → 2.3.4

package/lib/{impl/rules → rules}/assoc2many-ambiguous-key.js

@@ -1,30 +1,36 @@
-module.exports = require("../../api").createRule({
+module.exports = {
   meta: {
     docs: {
-      description: "Ambiguous key with a `TO MANY` relationship since entries could appear multiple times with the same key.",
+      description:
+        "Ambiguous key with a `TO MANY` relationship since entries could appear multiple times with the same key.",
       category: "Model Validation",
       recommended: true,
       version: "1.0.1",
     },
     severity: "warn",
-    type: "problem"
+    type: "problem",
   },
   create(context) {
-    let csnOdata;
-    const m = context.cds.model;
-    if (m && m.definitions) {
-      try {
+    return { all: check_assoc2many_ambiguous_key };
+
+    function check_assoc2many_ambiguous_key() {
+      let reports = [];
+      let csnOdata;
+      const m = context.cds.model;
+      if (m && m.definitions) {
         csnOdata = context.cds.compile.for.odata(m);
         const csnOdataLinked = context.cds.linked(csnOdata);
-        associationCardinalityFlaw(csnOdataLinked, context);
-      } catch (err) {
-        // Don't continue with rule if model fails to compile
+        reports = associationCardinalityFlaw(csnOdataLinked, context);
+      }
+      if (reports.length > 0) {
+        return reports;
       }
     }
   },
-});
+};
 
 function associationCardinalityFlaw(csn, context) {
+  const reports = [];
   processEntity(csn, (definition, sourceEntity, sourceAlias) => {
     let refCardinalityMult = false;
     let refPlainElement = false;
@@ -38,10 +44,7 @@ function associationCardinalityFlaw(csn, context) {
         refPlainElement = false;
       },
       (refEntity, refElement) => {
-        if (
-          refElement.type === "cds.Association" ||
-          refElement.type === "cds.Composition"
-        ) {
+        if (refElement.type === "cds.Association" || refElement.type === "cds.Composition") {
           if (refElement.cardinality && refElement.cardinality.max === "*") {
             refCardinalityMult = true;
           }
@@ -57,20 +60,35 @@ function associationCardinalityFlaw(csn, context) {
           refCardinalityMult &&
           refPlainElement
         ) {
-          const loc = context.cds.getLocation(definition.name, definition);
-          context.report({
-            message: `Ambiguous key in '${definition.name}'. Element '${
-              column.as ? column.as : column.name
-            }' leads to multiple entries so that key '${
-              Object.keys(definition.keys)[0]
-            }' is not unique.`,
-            loc,
-            file: definition.$location.file,
-          });
+          const keyName = Object.keys(definition.keys)[0];
+          const key = definition.keys[keyName];
+          const keyLoc = context.cds.getLocation(keyName, key, csn);
+          const colName = column.as ? column.as : column.name;
+          if (context.sourcecode.lines[column.$location.line - 1]) {
+            const endCol = context.sourcecode.lines[column.$location.col - 1].length;
+            const colLoc = {
+              start: { line: column.$location.line, column: column.$location.col - 1 },
+              end: { line: column.$location.line, column: endCol },
+            };
+            const message = `Ambiguous key in '${definition.name}'. Element '${colName}' leads to multiple entries so that key '${keyName}' is not unique.`;
+            reports.push(
+              {
+                message,
+                loc: keyLoc,
+                file: key.$location.file,
+              },
+              {
+                message,
+                loc: colLoc,
+                file: column.$location.file,
+              }
+            );
+          }
         }
       }
     );
   });
+  return reports;
 }
 
 function processEntity(csn, eachCallback) {
@@ -89,21 +107,14 @@ function processEntity(csn, eachCallback) {
       const sourceAlias = [];
       if (definition.query.SELECT.from.ref) {
         // From
-        sourceEntity =
-          csn.definitions[definition.query.SELECT.from.ref.join("_")];
+        sourceEntity = csn.definitions[definition.query.SELECT.from.ref.join("_")];
         sourceAlias.push({
           from: sourceEntity.name,
-          as:
-            definition.query.SELECT.from.as ||
-            definition.query.SELECT.from.ref.slice(-1)[0].split(".").pop(),
+          as: definition.query.SELECT.from.as || definition.query.SELECT.from.ref.slice(-1)[0].split(".").pop(),
         });
-      } else if (
-        definition.query.SELECT.from.args &&
-        definition.query.SELECT.from.args[0].ref
-      ) {
+      } else if (definition.query.SELECT.from.args && definition.query.SELECT.from.args[0].ref) {
         // Join
-        sourceEntity =
-          csn.definitions[definition.query.SELECT.from.args[0].ref.join("_")];
+        sourceEntity = csn.definitions[definition.query.SELECT.from.args[0].ref.join("_")];
         definition.query.SELECT.from.args.forEach((arg) => {
           sourceAlias.push({
             from: arg.ref.join("_"),
@@ -119,15 +130,7 @@ function processEntity(csn, eachCallback) {
   });
 }
 
-function processElement(
-  csn,
-  definition,
-  sourceEntity,
-  sourceAlias,
-  beforeCallback,
-  eachCallback,
-  afterCallback
-) {
+function processElement(csn, definition, sourceEntity, sourceAlias, beforeCallback, eachCallback, afterCallback) {
   definition.query.SELECT.columns.forEach((column) => {
     if (column.ref && column.ref.length > 1) {
       let refEntity = sourceEntity;
@@ -150,18 +153,12 @@ function processElement(
             if (!refElement && definition.query.SELECT.mixin) {
               refElement = definition.query.SELECT.mixin[ref];
               if (!refElement && definition.query.SELECT.mixin[column.ref[0]]) {
-                refElement =
-                  definition.query.SELECT.mixin[column.ref[0]]._target.elements[
-                    ref
-                  ];
+                refElement = definition.query.SELECT.mixin[column.ref[0]]._target.elements[ref];
               }
             }
           }
           eachCallback(refEntity, refElement);
-          if (
-            refElement.type === "cds.Association" ||
-            refElement.type === "cds.Composition"
-          ) {
+          if (refElement.type === "cds.Association" || refElement.type === "cds.Composition") {
             refEntity = csn.definitions[refElement.target];
           }
         }

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,49 @@
+const { isVSCodeEditor } = require("../utils/helpers");
+
+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" && !isVSCodeEditor()) {
+          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