@sap/eslint-plugin-cds 2.2.2 → 2.3.3

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

@@ -1,28 +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",
   },
   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;
@@ -36,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;
           }
@@ -55,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) {
@@ -87,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("_"),
@@ -117,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;
@@ -148,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,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,35 +1,40 @@
-module.exports = require("../../api").createRule({
+module.exports = {
   meta: {
     docs: {
       description: `Draft-enabled entities shall not be used in views that make use of \`JOIN\`.`,
       category: "Model Validation",
+      recommended: true,
       version: "2.2.1",
     },
+    severity: "warn",
     type: "suggestion",
     messages: {
       noJoinOnDraftEnabledEntities: `Do not use draft-enabled entities in views that make use of \`JOIN\`.`,
     },
   },
   create: function (context) {
-    const m = context.cds.model;
-    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,
+              },
+            ],
+          };
+        }
+      }
+    }
+  },
+};