@sap/eslint-plugin-cds 2.0.5 → 2.2.2

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

@@ -0,0 +1,171 @@
+module.exports = require("../../api").createRule({
+  meta: {
+    docs: {
+      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",
+  },
+  create(context) {
+    let csnOdata;
+    const m = context.cds.model;
+    if (m && m.definitions) {
+      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
+      }
+    }
+  },
+});
+
+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;
+        }
+      },
+      (column) => {
+        if (
+          definition.keys &&
+          Object.keys(definition.keys).length === 1 &&
+          Object.keys(definition.keys)[0] === "ID" &&
+          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,
+          });
+        }
+      }
+    );
+  });
+}
+
+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

@@ -0,0 +1,35 @@
+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",
+    },
+    type: "problem",
+  },
+  create: function (context) {
+    const m = context.cds.model;
+    if (m.err) {
+      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 });
+        });
+      }
+    }
+  },
+});

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

@@ -1,40 +1,46 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const ruleFactory_1 = require("../ruleFactory");
-const child_process_1 = __importDefault(require("child_process"));
-const semver_1 = __importDefault(require("semver"));
-module.exports = ruleFactory_1.createRule({
-    type: 'suggestion',
+const cp = require("child_process");
+const semver = require("semver");
+
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-        description: `Checks whether the latest cds version is being used.`,
-        category: 'Environment',
-        version: '1.0.4'
+      description: "Checks whether the latest cds version is being used.",
+      category: "Environment",
+      version: "1.0.4",
     },
-}, (cds, context) => {
-    const report = [];
+    type: "suggestion",
+    hasSuggestions: true,
+    messages: {
+      latestCDSVersion: `A newer CDS version is available!`,
+    },
+  },
+  create: function (context) {
     let result;
     let cdsVersions;
-    if (!cds.environment) {
-        try {
-            result = child_process_1.default.execSync(`npm outdated @sap/cds --json`, {
-                cwd: process.cwd()
-            }).toString();
-            cdsVersions = JSON.parse(result)['@sap/cds'];
-        }
-        catch (err) {
-        }
-    }
-    else {
-        cdsVersions = cds.environment['@sap/cds'];
+    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 (Object.keys(cdsVersions).length !== 0 && !semver_1.default.satisfies(cdsVersions.latest, cdsVersions.current)) {
-        report.push({
-            message: `A newer CDS version ${cdsVersions.latest} is available!`,
-            loc: { line: 0, column: 0 }
-        });
+    // 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",
+      });
     }
-    return report;
+  },
 });
-//# sourceMappingURL=latest-cds-version.js.map

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

@@ -1,42 +1,42 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const ruleFactory_1 = require("../ruleFactory");
-const semver_1 = __importDefault(require("semver"));
-const path_1 = __importDefault(require("path"));
-module.exports = ruleFactory_1.createRule({
-    type: 'problem',
+const path = require("path");
+const semver = require("semver");
+
+module.exports = require("../../api").createRule({
+  meta: {
     docs: {
-        description: `Checks whether the minimum node version required by the <code>@sap/cds</code> is achieved.`,
-        category: 'Environment',
-        version: '1.0.0'
+      description: `Checks whether the minimum node version required by the \`@sap/cds\` is achieved.`,
+      category: "Environment",
+      version: "1.0.0",
     },
-}, (cds, context) => {
-    var _a;
-    const report = [];
-    const filepath = context.getFilename();
+    type: "problem",
+  },
+  create: function (context) {
+    const e = context.cds.environment;
     let nodeVersion, nodeVersionCDS;
-    if (!cds.environment) {
-        try {
-            const CDSPath = require.resolve("@sap/cds/package.json", { paths: [path_1.default.dirname(filepath)] });
-            const jsonCDS = require(CDSPath);
-            nodeVersion = process.version;
-            nodeVersionCDS = (_a = jsonCDS.engines) === null || _a === void 0 ? void 0 : _a.node;
-        }
-        catch (_b) {
-        }
-    }
-    else {
-        nodeVersion = cds.environment.nodeVersion;
-        nodeVersionCDS = cds.environment.nodeVersionCDS;
-    }
-    if (nodeVersion && nodeVersionCDS && !semver_1.default.satisfies(nodeVersion, nodeVersionCDS, { loose: true })) {
-        report.push({
-            message: `CDS minimum node version of ${nodeVersionCDS} required, found ${nodeVersion}!`,
-            loc: { line: 0, column: 1 }
+    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}!`,
+      });
     }
-    return report;
+  },
 });
-//# sourceMappingURL=min-node-version.js.map

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

@@ -0,0 +1,35 @@
+module.exports = require("../../api").defineRule({
+  meta: {
+    docs: {
+      description: `Avoid using reserved SQL keywords.`,
+      category: "Model Validation",
+    },
+  },
+  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;
+
+        // Do blame
+        return `'${d.name}' is a reserved keyword in ${db.kind.toUpperCase()}`;
+      }
+    }
+    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,
+};

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

@@ -0,0 +1,35 @@
+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",
+      version: "2.2.1",
+    },
+    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;
+          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,
+            });
+          }
+        }
+      }
+    });
+  },
+});

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

@@ -0,0 +1,29 @@
+module.exports = require("../../api").createRule({
+  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",
+      version: "2.1.0",
+    },
+    type: "problem",
+  },
+  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,
+            });
+          }
+        }
+      }
+    });
+  },
+});

package/lib/impl/rules/rule.hbs

@@ -0,0 +1,20 @@
+// @ts-check
+module.exports = require("../../api").createRule({
+  meta: {
+    docs: {
+      description: "{{description}}",
+      version: "{{version}}"
+      },
+      type:"{{type}}",
+  },
+  create: function(context) {
+    const m = cotext.cds.model;
+    m.forall((d)) => {
+      // Add cds logic here, for example
+      return [{
+        message: "{{messages}}",
+        loc: {{loc}}
+      }];
+    }
+  }
+})

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

@@ -1,44 +1,50 @@
-"use strict";
-const ruleFactory_1 = require("../ruleFactory");
-function suggestSQLCast(m) {
-    const results = [];
-    const view = (d) => d.query;
-    const check = (m) => m.foreach(view, (v) => {
+module.exports = require("../../api").createRule({
+  meta: {
+    docs: {
+      description: "Should make suggestions for possible missing sql casts.",
+      category: "Model Validation",
+      version: "1.0.8",
+    },
+    type: "suggestion",
+    hasSuggestions: true,
+    messages: {
+      missingSQLCast:
+        "Potential issue - Missing SQL cast for column expression?",
+    },
+  },
+  create: function (context) {
+    const m = context.cds.model;
+    if (m) {
+      const view = (d) => d.query;
+      m.foreach(view, (v) => {
         if (v.query.SET)
-            for (const { SELECT } of v.query.SET.args) {
-                for (const each of SELECT.columns || []) {
-                    const { xpr, cast, $location: loc } = each;
-                    if (cast && xpr) {
-                        if (xpr[0].xpr && xpr[0].xpr && xpr[0].cast) {
-                            continue;
-                        }
-                        else {
-                            results.push({ message: `Potential issue: Missing SQL cast for column expression?`, loc, file: loc.file });
-                        }
-                    }
+          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].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 },
+                    };
+                    context.report({
+                      messageId: "missingSQLCast",
+                      loc,
+                      file: location.file,
+                    });
+                  }
                 }
+              }
             }
-    });
-    check(m);
-    return results;
-}
-module.exports = ruleFactory_1.createRule({
-    type: 'problem',
-    docs: {
-        description: `Should make suggestions for possible missing sql casts.`,
-        category: 'Model Validation',
-        version: '1.0.8'
-    },
-    fixable: 'code'
-}, (cds, context) => {
-    let report = [];
-    const filepath = context.getFilename();
-    if (filepath.endsWith('.cds')) {
-        const m = cds.linked(cds.model);
-        if (m) {
-            report = suggestSQLCast(m);
-        }
+          }
+      });
     }
-    return report;
+    return context.report;
+  },
 });
-//# sourceMappingURL=sql-cast-suggestion.js.map

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

@@ -0,0 +1,74 @@
+module.exports = require("../../api").createRule({
+  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.",
+    },
+    fixable: "code",
+  },
+  create: function (context) {
+    const m = context.cds.model;
+    if (m && m.definitions) {
+      m.forall((d) => {
+        const entityName = d.name;
+        for (const elementName in d.elements) {
+          const element = d.elements[elementName];
+          if (
+            elementName &&
+            !(
+              entityName.startsWith("localized") || entityName.endsWith("texts")
+            )
+          ) {
+            if (
+              elementName.charAt(0) !== elementName.charAt(0).toLowerCase() &&
+              !["ID"].includes(elementName)
+            ) {
+              if (element.$location && element.$location.file) {
+                const file = element.$location.file;
+                const loc = context.cds.getLocation(elementName, element);
+                const fix = (fixer) => {
+                  const elementNameSanitized =
+                    elementName.charAt(0).toLowerCase() + elementName.slice(1);
+                  const rangeEnd = context.sourcecode.getIndexFromLoc({
+                    line: loc.end.line,
+                    column: loc.end.column,
+                  });
+                  const rangeBeg = rangeEnd
+                    ? rangeEnd - elementNameSanitized.length
+                    : 0;
+                  return fixer.replaceTextRange(
+                    [rangeBeg, rangeEnd],
+                    elementNameSanitized
+                  );
+                };
+                context.report({
+                  messageId: "startLowercase",
+                  loc,
+                  file,
+                  fix,
+                  data: {
+                    entityName,
+                    elementName,
+                  },
+                  suggest: [
+                    {
+                      messageId: "startLowercase",
+                      fix,
+                    },
+                  ],
+                });
+              }
+            }
+          }
+        }
+      });
+    }
+  },
+});