@sap/eslint-plugin-cds 2.1.1 → 2.2.1

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

@@ -1,151 +1,153 @@
-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",
+      version: "1.0.1",
     },
     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);
+      csnOdata = context.cds.compile.for.odata(m);
+      const csnOdataLinked = context.cds.linked(csnOdata);
+      associationCardinalityFlaw(csnOdataLinked, context);
     }
-    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 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);
+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,8 +1,5 @@
-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",
@@ -10,37 +7,29 @@ module.exports = cdsLint.createRule(
     },
     type: "problem",
   },
-
-  /* Rule logic */
-  (report, cds) => {
-    return createReport(report, cds) || report;
-  }
-);
-
-const createReport = (report, cds) => {
-  const m = cds.model;
-  if (m.err) {
+  create: function (context) {
+    const m = context.cds.model;
     if (m.err) {
-      // If any csn compile errors occur
-      m.err.messages.forEach((err) => {
-        const msg = err.message;
-        let file = "";
-        const loc = {
-          start: { line: 0, column: 0 },
-          end: { line: 1, column: 0 },
-        };
-        // Get its location if it exists
-        if (err.$location) {
-          loc.start.column = err.$location.col;
-          loc.start.line = err.$location.line;
-          loc.end.column = err.$location.endCol;
-          loc.end.line = err.$location.endLine;
-          file = err.$location.file;
-        }
-        // Add to ESLint report
-        report.push({ message: `${msg}`, loc, file });
-      });
+      if (m.err) {
+        // If any csn compile errors occur
+        m.err.messages.forEach((err) => {
+          const msg = err.message;
+          let file = "";
+          const loc = {
+            start: { line: 0, column: 0 },
+            end: { line: 1, column: 0 },
+          };
+          // Get its location if it exists
+          if (err.$location) {
+            loc.start.column = err.$location.col;
+            loc.start.line = err.$location.line;
+            loc.end.column = err.$location.endCol;
+            loc.end.line = err.$location.endLine;
+            file = err.$location.file;
+          }
+          context.report({ message: `${msg}`, loc, file });
+        });
+      }
     }
-  }
-  return report;
-};
+  },
+});

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

@@ -1,55 +1,47 @@
 const cp = require("child_process");
 const semver = require("semver");
-const cdsLint = require("../../api");
 
-module.exports = cdsLint.createRule(
-  // Rule meta data
-  {
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
       description: "Checks whether the latest 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(),
+          })
+          .toString();
+        cdsVersions = JSON.parse(result)["@sap/cds"];
+      } catch (err) {
+        // Do not throw
+      }
+    } else {
+      cdsVersions = context.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
+      context.report({
+        messageId: 'latestCDSVersion',
+        loc: { line: 0, column: 0 },
+      });
     }
-  } 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;
-};
+});

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

@@ -1,55 +1,43 @@
 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 version required by the \`@sap/cds\` is achieved.`,
       category: "Environment",
       version: "1.0.0",
     },
     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}!`,
+        loc: { line: 0, column: 1 },
       });
-      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

@@ -22,4 +22,4 @@ const RESERVED = {
   ORDER: 1, Order: 1, order: 1,
   GROUP: 1, Group: 1, group: 1,
   LIMIT: 1, Limit: 1, limit: 1,
-}
+}

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

@@ -1,39 +1,29 @@
-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",
       version: "2.1.0",
     },
     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;
+    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,13 @@
-const cdsLint = require("../../lib/api");
-
-module.exports = cdsLint.createRule(
-  {
-    docs: {
-        description: "{{description}}",
-        category: "{{category}}",
-        {{recommended}}
-        {{version}}
-      },
-    type: "{{type}}",
-    {{messages}}
-  },
-  (cds, model, env, context) => {
-    return createReport(report, cds, {{cds_object}}, report) || report;
+// @ts-check
+module.exports = require("../../api").createRule({
+  meta: {docs: {
+    description: "{{description}}",
+    version: "{{version}}"
+  }},
+  create: function(context) {
+    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;
-};
+})