@sap/eslint-plugin-cds 2.1.1 → 2.3.2

package/lib/impl/rules/assoc2many-ambiguous-key.js

@@ -1,151 +1,173 @@
-const cdsLint = require("../../api");
-
-module.exports = cdsLint.createRule(
-  /* Rule meta */
-  {
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-        description: "Ambiguous key with a to-many relationship. Entries could appear multiple times with the same key if they point to an entity using a to-many relationship.",
-        category: "Model Validation",
-        version: "1.0.1",
+      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",
     },
-    type: "problem",
+    severity: "warn",
+    type: "problem"
   },
-  /* Rule logic */
-  (report, cds) => {
-    return createRuleReport(report, cds) || report;
-  }
-);
-
-const createRuleReport = (report, cds) => {
+  create(context) {
     let csnOdata;
-    const m = cds.model;
+    const m = context.cds.model;
     if (m && m.definitions) {
-        csnOdata = cds.compile.for.odata(m);
-        const csnOdataLinked = cds.linked(csnOdata);
-        associationCardinalityFlaw(csnOdataLinked, report, cds);
+      try {
+        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
+      }
     }
-    return report;
-};
-
-
-function associationCardinalityFlaw(csn, report, cds) {
-    const messages = [];
-    processEntity(csn, (definition, sourceEntity, sourceAlias) => {
-        let refCardinalityMult = false;
-        let refPlainElement = false;
-        processElement(
-            csn,
-            definition,
-            sourceEntity,
-            sourceAlias,
-            () => {
-                refCardinalityMult = false;
-                refPlainElement = false;
-            },
-            (refEntity, refElement) => {
-                if (refElement.type === "cds.Association" || refElement.type === "cds.Composition") {
-                    if (refElement.cardinality && refElement.cardinality.max === "*") {
-                        refCardinalityMult = true;
-                    }
-                } else {
-                    refPlainElement = true;
-                }
-            },
-            (column) => {
-                if (
-                    definition.keys &&
-                    Object.keys(definition.keys).length === 1 &&
-                    Object.keys(definition.keys)[0] === "ID" &&
-                    refCardinalityMult &&
-                    refPlainElement
-                ) {
-                    const loc = cds.getLocation(definition.name, definition);
-                    report.push({
-                      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,
-                    });
-                }
-            }
-        );
-    });
-    return [messages];
-}
+  },
+});
 
-function processEntity(csn, eachCallback) {
-    Object.keys(csn.definitions).forEach((name) => {
-        if (name.startsWith("localized.")) {
-            return;
+function associationCardinalityFlaw(csn, context) {
+  processEntity(csn, (definition, sourceEntity, sourceAlias) => {
+    let refCardinalityMult = false;
+    let refPlainElement = false;
+    processElement(
+      csn,
+      definition,
+      sourceEntity,
+      sourceAlias,
+      () => {
+        refCardinalityMult = false;
+        refPlainElement = false;
+      },
+      (refEntity, refElement) => {
+        if (
+          refElement.type === "cds.Association" ||
+          refElement.type === "cds.Composition"
+        ) {
+          if (refElement.cardinality && refElement.cardinality.max === "*") {
+            refCardinalityMult = true;
+          }
+        } else {
+          refPlainElement = true;
         }
-        const definition = csn.definitions[name];
+      },
+      (column) => {
         if (
-            definition.kind === "entity" &&
-            definition.query &&
-            definition.query.SELECT &&
-            definition.query.SELECT.columns
+          definition.keys &&
+          Object.keys(definition.keys).length === 1 &&
+          Object.keys(definition.keys)[0] === "ID" &&
+          refCardinalityMult &&
+          refPlainElement
         ) {
-            let sourceEntity;
-            const sourceAlias = [];
-            if (definition.query.SELECT.from.ref) {
-                // From
-                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(),
-                });
-            } 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("_")];
-                definition.query.SELECT.from.args.forEach((arg) => {
-                    sourceAlias.push({
-                        from: arg.ref.join("_"),
-                        as: arg.as || arg.ref.slice(-1)[0].split(".").pop(),
-                    });
-                });
-            }
-            if (!sourceEntity) {
-                return;
-            }
-            eachCallback(definition, sourceEntity, sourceAlias);
+          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,
+          });
         }
-    });
+      }
+    );
+  });
 }
 
-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;
-            let refAlias = sourceAlias;
-            beforeCallback();
-            column.ref.forEach((ref) => {
-                ref = ref.id || ref;
-                // Alias
-                const matchAlias = refAlias.find((alias) => {
-                    return alias.as === ref;
-                });
-                let refElement;
-                if (matchAlias) {
-                    refEntity = csn.definitions[matchAlias.from];
-                } else {
-                    refElement = refEntity.elements[ref];
-                    // Mixin
-                    if (!refElement) {
-                        refElement = definition.elements[ref];
-                        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];
-                            }
-                        }
-                    }
-                    eachCallback(refEntity, refElement);
-                    if (refElement.type === "cds.Association" || refElement.type === "cds.Composition") {
-                        refEntity = csn.definitions[refElement.target];
-                    }
-                }
-                refAlias = [];
-            });
-            afterCallback(column);
+function processEntity(csn, eachCallback) {
+  Object.keys(csn.definitions).forEach((name) => {
+    if (name.startsWith("localized.")) {
+      return;
+    }
+    const definition = csn.definitions[name];
+    if (
+      definition.kind === "entity" &&
+      definition.query &&
+      definition.query.SELECT &&
+      definition.query.SELECT.columns
+    ) {
+      let sourceEntity;
+      const sourceAlias = [];
+      if (definition.query.SELECT.from.ref) {
+        // From
+        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(),
+        });
+      } 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("_")];
+        definition.query.SELECT.from.args.forEach((arg) => {
+          sourceAlias.push({
+            from: arg.ref.join("_"),
+            as: arg.as || arg.ref.slice(-1)[0].split(".").pop(),
+          });
+        });
+      }
+      if (!sourceEntity) {
+        return;
+      }
+      eachCallback(definition, sourceEntity, sourceAlias);
+    }
+  });
+}
+
+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;
+      let refAlias = sourceAlias;
+      beforeCallback();
+      column.ref.forEach((ref) => {
+        ref = ref.id || ref;
+        // Alias
+        const matchAlias = refAlias.find((alias) => {
+          return alias.as === ref;
+        });
+        let refElement;
+        if (matchAlias) {
+          refEntity = csn.definitions[matchAlias.from];
+        } else {
+          refElement = refEntity.elements[ref];
+          // Mixin
+          if (!refElement) {
+            refElement = definition.elements[ref];
+            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
+                  ];
+              }
+            }
+          }
+          eachCallback(refEntity, refElement);
+          if (
+            refElement.type === "cds.Association" ||
+            refElement.type === "cds.Composition"
+          ) {
+            refEntity = csn.definitions[refElement.target];
+          }
         }
-    });
+        refAlias = [];
+      });
+      afterCallback(column);
+    }
+  });
 }

package/lib/impl/rules/cds-compile-error.js

@@ -1,26 +1,16 @@
-const cdsLint = require("../../api");
-
-module.exports = cdsLint.createRule(
-  /* Rule meta */
-  {
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
       description: `Checks whether the CDS model file can be compiled by the @sap/cds wihtout errors.`,
       category: "Model Validation",
       version: "1.0.0",
     },
+    severity: "error",
     type: "problem",
   },
-
-  /* Rule logic */
-  (report, cds) => {
-    return createReport(report, cds) || report;
-  }
-);
-
-const createReport = (report, cds) => {
-  const m = cds.model;
-  if (m.err) {
-    if (m.err) {
+  create: function (context) {
+    const m = context.cds.model;
+    if (m && m.err) {
       // If any csn compile errors occur
       m.err.messages.forEach((err) => {
         const msg = err.message;
@@ -37,10 +27,8 @@ const createReport = (report, cds) => {
           loc.end.line = err.$location.endLine;
           file = err.$location.file;
         }
-        // Add to ESLint report
-        report.push({ message: `${msg}`, loc, file });
+        context.report({ message: `${msg}`, loc, file });
       });
     }
   }
-  return report;
-};
+});

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

@@ -1,55 +1,51 @@
+const os = require("os");
 const cp = require("child_process");
 const semver = require("semver");
-const cdsLint = require("../../api");
 
-module.exports = cdsLint.createRule(
-  // Rule meta data
-  {
+const IS_WIN = os.platform() === "win32";
+
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-      description: "Checks whether the latest cds version is being used.",
+      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 5.1.0 is available!",
+      latestCDSVersion: `A newer CDS version is available!`,
     },
   },
-
-  // Rule (cds) logic
-  (report, cds) => {
-    return createRuleReport(report, cds) || report;
-  }
-);
-
-const createRuleReport = (report, cds) => {
-  let result;
-  let cdsVersions;
-  const e = cds.environment;
-  if (!e) {
-    try {
-      result = cp
-        .execSync(`npm outdated @sap/cds --json`, {
-          cwd: process.cwd(),
-        })
-        .toString();
-      cdsVersions = JSON.parse(result)["@sap/cds"];
-    } catch (err) {
-      // Do not throw
+  create: function (context) {
+    let result;
+    let cdsVersions;
+    const e = context.cds.environment;
+    if (!e) {
+      try {
+        result = cp
+          .execSync(`npm outdated @sap/cds --json`, {
+            cwd: process.cwd(),
+            shell: IS_WIN,
+            stdio: "pipe",
+          })
+          .toString();
+        cdsVersions = JSON.parse(result)["@sap/cds"];
+      } catch (err) {
+        // Do not throw
+      }
+    } else {
+      cdsVersions = context.cds.environment["@sap/cds"];
     }
-  } else {
-    cdsVersions = cds.environment["@sap/cds"];
-  }
-  // If current cds version is not the latest
-  if (
-    Object.keys(cdsVersions).length !== 0 &&
-    !semver.satisfies(cdsVersions.latest, cdsVersions.current)
-  ) {
-    // Add to ESLint report
-    report.push({
-      message: `A newer CDS version ${cdsVersions.latest} is available!`,
-      loc: { line: 0, column: 0 },
-    });
-  }
-  return report;
-};
+    // If current cds version is not the latest
+    if (
+      Object.keys(cdsVersions).length !== 0 &&
+      !semver.satisfies(cdsVersions.latest, cdsVersions.current)
+    ) {
+      // Add to ESLint report
+      context.report({
+        messageId: "latestCDSVersion",
+      });
+    }
+  },
+});

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

@@ -1,55 +1,44 @@
 const path = require("path");
 const semver = require("semver");
-const cdsLint = require("../../api");
 
-module.exports = cdsLint.createRule(
-  /* Rule meta */
-  {
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-      description:
-        "Checks whether the minimum node version required by the <code>@sap/cds</code> is achieved.",
+      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",
   },
-
-  /* Rule logic */
-  (report, cds, sourcecode, filepath) => {
-    return createReport(report, cds, filepath) || report;
-  }
-);
-
-const createReport = (report, cds, filepath) => {
-  const e = 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(filepath)],
+  create: function (context) {
+    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 = context.cds.environment.nodeVersion;
+      nodeVersionCDS = context.cds.environment.nodeVersionCDS;
+    }
+    if (
+      nodeVersion &&
+      nodeVersionCDS &&
+      !semver.satisfies(nodeVersion, nodeVersionCDS, { loose: true })
+    ) {
+      context.report({
+        message: `CDS minimum node version of ${nodeVersionCDS} required, found ${nodeVersion}!`,
       });
-      const jsonCDS = require(CDSPath);
-      nodeVersion = process.version;
-      nodeVersionCDS = jsonCDS.engines.node;
-    } catch (err) {
-      // Do not throw
     }
-  } else {
-    nodeVersion = cds.environment.nodeVersion;
-    nodeVersionCDS = cds.environment.nodeVersionCDS;
-  }
-  // If required version is not satisfied
-  if (
-    nodeVersion &&
-    nodeVersionCDS &&
-    !semver.satisfies(nodeVersion, nodeVersionCDS, { loose: true })
-  ) {
-    // Add to CDS lint report
-    report.push({
-      message: `CDS minimum node version of ${nodeVersionCDS} required, found ${nodeVersion}!`,
-      loc: { line: 0, column: 1 },
-    });
-  }
-  return report;
-};
+  },
+});

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

@@ -1,25 +1,38 @@
 module.exports = require("../../api").defineRule({
-  meta: { docs: { description: `Avoid using reserved SQL keywords.` }},
-  create (context) {
-    const { db = { kind: 'sql' } } = context.cds.env.requires
-    function _check (d) {
+  meta: {
+    docs: {
+      description: `Avoid using reserved SQL keywords.`,
+      category: "Model Validation",
+      recommended: true,
+      version: "2.1.0",
+    },
+    severity: "error"
+  },
+  create(context) {
+    const { db = { kind: "sql" } } = context.cds.env.requires;
+    function _check(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
+        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()}`
+        return `'${d.name}' is a reserved keyword in ${db.kind.toUpperCase()}`;
       }
     }
-    return { entity: _check, element: _check }
-  }
-})
+    return { entity: _check, element: _check };
+  },
+});
 
 // 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,
-}
+  ORDER: 1,
+  Order: 1,
+  order: 1,
+  GROUP: 1,
+  Group: 1,
+  group: 1,
+  LIMIT: 1,
+  Limit: 1,
+  limit: 1,
+};

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

@@ -0,0 +1,37 @@
+module.exports = require("../../api").createRule({
+  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;  if (!m)  return
+    m.foreach("entity", (entity) => {
+      if (entity["@odata.draft.enabled"]) {
+        if (entity.query.SELECT.from.join) {
+          const location = entity.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({
+              messageId: "noJoinOnDraftEnabledEntities",
+              loc,
+              file: entity.$location.file,
+            });
+          }
+        }
+      }
+    });
+  },
+});