@sap/eslint-plugin-cds 2.0.4 → 2.2.1

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

@@ -0,0 +1,153 @@
+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) {
+      csnOdata = context.cds.compile.for.odata(m);
+      const csnOdataLinked = context.cds.linked(csnOdata);
+      associationCardinalityFlaw(csnOdataLinked, context);
+    }
+  },
+});
+
+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,47 @@
-"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',
+        loc: { line: 0, column: 0 },
+      });
     }
-    return report;
-});
-//# sourceMappingURL=latest-cds-version.js.map
+  }
+});

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

@@ -1,40 +1,43 @@
-"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"));
-const fs_1 = __importDefault(require("fs"));
-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 = [];
+    type: "problem",
+  },
+  create: function (context) {
+    const e = context.cds.environment;
     let nodeVersion, nodeVersionCDS;
-    if (!cds.environment) {
-        const jsonCDSFile = path_1.default.join(cds.home, 'package.json');
-        if (fs_1.default.existsSync(jsonCDSFile)) {
-            const jsonCDS = require(jsonCDSFile);
-            nodeVersion = process.version;
-            nodeVersionCDS = (_a = jsonCDS.engines) === null || _a === void 0 ? void 0 : _a.node;
-        }
-    }
-    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}!`,
+        loc: { line: 0, column: 1 },
+      });
     }
-    return report;
+  },
 });
-//# sourceMappingURL=min-node-version.js.map

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

@@ -0,0 +1,25 @@
+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) {
+      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/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,13 @@
+// @ts-check
+module.exports = require("../../api").createRule({
+  meta: {docs: {
+    description: "{{description}}",
+    version: "{{version}}"
+  }},
+  create: function(context) {
+    return [{
+      message: "{{messages}}",
+      loc: {{loc}}
+    }];
+  }
+})

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

@@ -1,44 +1,48 @@
-"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,66 @@
+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,
+                    },
+                  ],
+                });
+              }
+            }
+          }
+        }
+      });
+    }
+  },
+});

package/lib/impl/rules/start-entities-uppercase.js

@@ -0,0 +1,56 @@
+module.exports = require("../../api").createRule({
+  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.",
+    },
+    fixable: "code",
+  },
+  create: function (context) {
+    const m = context.cds.model;
+    if (m) {
+      m.foreach("entity", (e) => {
+        let entityName = e.name;
+        const names = entityName.split(".");
+        entityName = names[names.length - 1];
+        if (entityName && !(entityName.startsWith("localized") || entityName.endsWith("texts"))) {
+          if (entityName.charAt(0) !== entityName.charAt(0).toUpperCase()) {
+            if (e.$location && e.$location.file) {
+              const file = e.$location.file;
+              const loc = context.cds.getLocation(entityName, e);
+              const fix = (fixer) => {
+                const entityNameSanitized =
+                  entityName.charAt(0).toUpperCase() + entityName.slice(1);
+                const rangeEnd = context.sourcecode.getIndexFromLoc({
+                  line: loc.end.line,
+                  column: loc.end.column,
+                });
+                const rangeBeg = rangeEnd ? rangeEnd - entityNameSanitized.length : 0;
+                return fixer.replaceTextRange([rangeBeg, rangeEnd], entityNameSanitized);
+              };
+              context.report({
+                messageId: "startUppercase",
+                loc,
+                file,
+                fix,
+                data: { entityName },
+                suggest: [
+                  {
+                    messageId: "startUppercase",
+                    fix,
+                  },
+                ],
+              });
+            }
+          }
+        }
+      });
+    }
+  },
+});

package/lib/impl/types.d.ts

@@ -0,0 +1,48 @@
+import { Rule, RuleTester, SourceCode } from "eslint";
+
+export interface CDSRuleMetaData extends Rule.RuleMetaData {
+    docs: {
+        /** provides the short description of the rule in the [rules index](https://eslint.org/docs/rules/) */
+        description: Rule.RuleMetaData['docs']['description'];
+        /** specifies version of @sap/eslint-plugin-cds at which the rule was first implemented */
+        version: string;
+    };
+    messages?: Rule.RuleMetaData['messages'];
+    fixable?: Rule.RuleMetaData['fixable'];
+    schema?: Rule.RuleMetaData['schema'];
+    deprecated?: Rule.RuleMetaData['deprecated'];
+    type?: Rule.RuleMetaData['type'];
+}
+
+export type CDSReport = Rule.ReportDescriptor & { file?: string };
+
+export interface CDSRuleContext extends Rule.RuleContext {
+    cds: any;
+    configPath: string;
+    code: string;
+    filePath: string;
+    options: [];
+    ruleID: string;
+    sourcecode: SourceCode
+}
+export interface CDSRuleSpec {
+    meta: CDSRuleMetaData,
+    create: (arg0: CDSRuleContext) => Rule.ReportDescriptor;
+}
+
+export interface CDSTestCaseError extends RuleTester.TestCaseError {
+    message: string | RegExp;
+}
+
+export interface CDSRuleTestOpts {
+    /** specifies __dirname */
+    root: string;
+    /** requires your rule .js here */
+    rule?: string;
+    /** filename ('schema.cds' for model, 'package.json' for env) */
+    filename: string;
+    /** resolves cds parser path */
+    parser?: string;
+    /** List of warnings/errors from ESLint's [ruleTester](https://eslint.org/docs/developer-guide/nodejs-api#ruletester) */
+    errors: CDSTestCaseError[]
+}