@sap/eslint-plugin-cds 2.4.1 → 2.5.0

package/CHANGELOG.md

@@ -6,14 +6,28 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## [2.5.0] - 2022-08-04
+
+### Changed
+
+- Model Validation rules use `parsed` flavor by default (`meta.model` property)
+- Environment rules have { model: "none" }
+
+### Added
+
+- Flavor in `model` property on `meta` object of rule
+- Context function `getNode()` returns Node with proper location
+
 ## [2.4.1] - 2022-06-17
 
-- Added authorization rules 'auth-*'.
+### Added
+
+- Authorization rules 'auth-*'.
 
 ### Changed
 
 - Node.js 14 is now the minimum required Node.js version.  Version 12 is no longer supported.
-
+- Default CSN flavor in rules is `parsed`.
 
 ## [2.4.0] - 2022-04-14
 

package/lib/api/index.js

@@ -4,22 +4,23 @@
  * Our custom ESLint plugin API should:
  * - Expose 'createRule' and 'runRuleTester' to
  *   support the addition of *custom* CDS Lint rules at runtime
- * - Expose 'getConfigPath', 'getFileExtensions', and 'genDocs' for usage in
+ * - Expose 'getFileExtensions', and 'genDocs' for usage in
  *   'cds lint' client (@sap/cds-dk)
  * - Expose 'parserPath' for CDS Lint rule unit tests with ESLint's ruleTester
  */
 
-const { runRuleTester } = require("../utils/ruleTester")
-const { getConfigPath } = require("../utils/model");
-const { getFileExtensions } = require("../utils/helpers");
-const { createRule, genDocs } = require("../utils/rules");
+const runRuleTester = require("../utils/runRuleTester");
+const createRule = require("../utils/createRule");
+const genDocs = require("../utils/genDocs");
+const getConfigPath = require("../utils/getConfigPath");
+const getConfiguredFileTypes = require("../utils/getConfiguredFileTypes");
 const parserPath = require.resolve("../parser");
 
 module.exports = {
-  createRule,
   runRuleTester,
-  getConfigPath,
-  getFileExtensions,
+  createRule,
   genDocs,
+  getConfigPath,
+  getFileExtensions: getConfiguredFileTypes,
   parserPath,
 };

package/lib/conf/all.js

@@ -0,0 +1,21 @@
+"use strict";
+
+module.exports = {
+  "@sap/cds/assoc2many-ambiguous-key": 2,
+  "@sap/cds/auth-no-empty-restrictions": 2,
+  "@sap/cds/auth-use-requires": 1,
+  "@sap/cds/auth-valid-restrict-grant": 1,
+  "@sap/cds/auth-valid-restrict-keys": 1,
+  "@sap/cds/auth-valid-restrict-to": "warn",
+  "@sap/cds/auth-valid-restrict-where": "warn",
+  "@sap/cds/latest-cds-version": "warn",
+  "@sap/cds/min-node-version": "error",
+  "@sap/cds/no-db-keywords": "error",
+  "@sap/cds/no-dollar-prefixed-names": "warn",
+  "@sap/cds/no-join-on-draft-enabled-entities": "warn",
+  "@sap/cds/require-2many-oncond": "error",
+  "@sap/cds/sql-cast-suggestion": "warn",
+  "@sap/cds/start-elements-uppercase": "warn",
+  "@sap/cds/start-entities-uppercase": "warn",
+  "@sap/cds/valid-csv-header": "error"
+};

package/lib/conf/index.js

@@ -0,0 +1,22 @@
+const { FILES, GLOBALS, PLUGIN_NAME } = require("../constants");
+const { parserPath } = require("../api");
+
+function _createConfig(config) {
+  return {
+    root: true,
+    globals: GLOBALS,
+    plugins: [PLUGIN_NAME],
+    overrides: [
+      {
+        files: FILES,
+        parser: parserPath,
+      },
+    ],
+    rules: config,
+  };
+}
+
+module.exports = {
+  all: _createConfig(require("./all")),
+  recommended: _createConfig(require("./recommended")),
+};

package/lib/conf/recommended.js

@@ -0,0 +1,18 @@
+"use strict";
+
+module.exports = {
+  "@sap/cds/assoc2many-ambiguous-key": [2, "hide"],
+  "@sap/cds/auth-no-empty-restrictions": 2,
+  "@sap/cds/auth-use-requires": 1,
+  "@sap/cds/auth-valid-restrict-grant": 1,
+  "@sap/cds/auth-valid-restrict-keys": 1,
+  "@sap/cds/auth-valid-restrict-to": 1,
+  "@sap/cds/auth-valid-restrict-where": 1,
+  "@sap/cds/min-node-version": 2,
+  "@sap/cds/no-db-keywords": 2,
+  "@sap/cds/no-dollar-prefixed-names": 1,
+  "@sap/cds/no-join-on-draft-enabled-entities": [1, "hide"],
+  "@sap/cds/require-2many-oncond": 2,
+  "@sap/cds/sql-cast-suggestion": 1,
+  "@sap/cds/valid-csv-header": 1
+};

package/lib/constants.js

@@ -1,6 +1,5 @@
 /**
  * This file is used to store/share any constants for this plugin:
- * - RULE_CATEGORIES:       List of plugin's rule categories (used purely as documentation labels)
  * - DEFAULT_RULE_CATEGORY: Default rule category (must be one of plugin's rule categories)
  * - DEFAULT_RULE_SEVERITY: Default rule severity (must be one of those define by ESLint):
  *                          https://eslint.org/docs/user-guide/configuring/rules#configuring-rules
@@ -13,14 +12,17 @@
  * - GLOBALS:               Globals which should be exposed to ESLint by this plugin
  */
 
-const RULE_CATEGORIES = ["Model Validation", "Environment"];
-const DEFAULT_RULE_CATEGORY = RULE_CATEGORIES[0];
+const RULE_FLAVORS = ["parsed" , "inferred"];
+
+const DEFAULT_RULE_FLAVOR = RULE_FLAVORS[0];
+
 const DEFAULT_RULE_SEVERITY = "error";
 const DEFAULT_RULE_TYPE = "problem";
 
 const PLUGIN_NAME = require("../package.json").name;
-const PLUGIN_PREFIX = "@sap/cds";
-const PROCESSOR_NAME = `${PLUGIN_PREFIX}/cds`
+
+const PLUGIN_SCOPE = "@sap";
+const PLUGIN_PREFIX = `${PLUGIN_SCOPE}/cds`;
 const CUSTOM_RULES_DIR = ".cdslint";
 
 const FILES = ["*.cds", "*.csn", "*.csv"];
@@ -40,13 +42,13 @@ const GLOBALS = {
 };
 
 module.exports = {
-  RULE_CATEGORIES,
-  DEFAULT_RULE_CATEGORY,
+  RULE_FLAVORS,
+  DEFAULT_RULE_FLAVOR,
   DEFAULT_RULE_SEVERITY,
   DEFAULT_RULE_TYPE,
   PLUGIN_NAME,
+  PLUGIN_SCOPE,
   PLUGIN_PREFIX,
-  PROCESSOR_NAME,
   CUSTOM_RULES_DIR,
   FILES,
   MODEL_FILES,

package/lib/index.js

@@ -1,44 +1,23 @@
 /**
  * Custom ESLint plugin:
  * https://eslint.org/docs/developer-guide/working-with-plugins
- * This file exposes our plugins ESLint configuration, which must:
+ * This file exposes our plugins' ESLint configuration, which must:
  * - Expose any 'configs' for prescribed rule configuration bundles
  *     (i.e. "recommended"). See shareable configs:
  *     https://eslint.org/docs/developer-guide/shareable-configs
- * - Expose any 'globals' for use in ESLint
- * - Expose any 'processors' for use in ESLint
  * - Expose any 'rules' for use in ESLint
  */
 
-const path = require("path");
-const processor = require("./processor");
-
-const { FILES, GLOBALS, PLUGIN_NAME, PROCESSOR_NAME } = require("./constants");
-const { getRules } = require("./utils/rules");
-
-const rules = getRules(path.join(__dirname, "rules"));
-
-function _getConfig(configName) {
-    return {
-        globals: GLOBALS,
-        plugins: [PLUGIN_NAME],
-        overrides: [
-            {
-                files: FILES,
-                processor: PROCESSOR_NAME,
-            },
-        ],
-        rules: rules[configName],
-    };
-}
+const api = require("./api");
+const rules =  Object.assign(
+    {},
+    ...Object.entries(require("./rules")).map(([k, v]) => ({
+        [k]: v() }))
+    );
+const configs = require("./conf");
 
 module.exports = {
-    configs: {
-        recommended: _getConfig("recommended"),
-        all: _getConfig("all"),
-    },
-    processors: {
-        cds: processor,
-    },
-    rules: rules.sources,
+    configs,
+    rules,
+    ...api
 };

package/lib/parser.js

@@ -6,23 +6,174 @@
  *   optional properties services, a scopeManager, and visitorKeys
  * - Expose default method 'parse' which should return the AST
  * Both methods should take in the source code and an optional configuration
- * (parserOptions). Note, that because we use a 'empty' preprocessor, the
- * parser is only used by ESLint's ruleTester.
+ * (parserOptions).
  */
- const { getAST } = require("./utils/model");
+const cds = require("@sap/cds");
+const Cache = require("./utils/Cache");
+const LOG = cds.debug("lint:plugin");
+const colors = require("./utils/Colors");
 
 module.exports = {
   parse: function (code, options) {
     return module.exports.parseForESLint(code, options).ast;
   },
-
   parseForESLint: function (code) {
     return {
-      ast: getAST(code),
-      services: {},
+      ast: createProgramAST(code),
+      services: {
+        getParsedCsn: function () {
+          let compiledModel;
+          let reflectedModel;
+          const messages = [];
+          try {
+            compiledModel = cds.parse(code);
+          } catch (err) {
+            // Do nothing
+          }
+          if (compiledModel) {
+            try {
+              reflectedModel = cds.linked(compiledModel);
+              if (messages) {
+                reflectedModel.messages = messages;
+              }
+            } catch (err) {
+              LOG && LOG(colors.red + 'ERROR:' +  colors.reset, err)
+              LOG && LOG('COMPILED', compiledModel)
+              LOG && LOG('REFLECTED', reflectedModel)
+            }
+          }
+          return reflectedModel;
+        },
+        getInferredCsn: function() {
+          const rootPath = Cache.get(`rootpath`);
+          if (Cache.has("test")) {
+            return Cache.get(`model:${rootPath}`);
+          }
+          let compiledModel;
+          let reflectedModel;
+          cds.resolve.cache = {};
+
+          if (!Cache.has(`model:${rootPath}`)) {
+            const roots = cds.resolve("*", { root: rootPath });
+            const messages = [];
+            if (roots) {
+                try {
+                  compiledModel = cds.load(roots, {
+                    cwd: ".",
+                    sync: true,
+                    locations: true,
+                    messages,
+                  });
+                  Cache.remove('errRootModel');
+                } catch (err) {
+                  Cache.set('errRootModel', err);
+                }
+                if (compiledModel) {
+                  reflectedModel = cds.linked(compiledModel);
+                  Cache.set(`model:${Cache.get(`rootpath`)}`, reflectedModel);
+                  if (messages) {
+                    reflectedModel.messages = messages;
+                  }
+                }
+              }
+          } else {
+              reflectedModel = Cache.get(`model:${rootPath}`);
+          }
+          return reflectedModel;
+        },
+        updateInferredCsn: compileModelFromDict,
+        getEnvironment: function () {
+          const options = Cache.get("options");
+          return (options && options[0] && options[0].environment) ? options[0].environment : undefined
+        },
+        getLocation: function(name, obj, model) {
+          let loc;
+          const defaultLoc = {
+            start: { line: 0, column: 0 },
+            end: { line: 1, column: 0 },
+          };
+          if (obj.$location) {
+            const nameloc = obj.$location;
+            if (nameloc) {
+              // CSN entry with column 0 is equivalent to 'undefined'
+              // It means that the column in that line cannot be determined,
+              // so we assign a value 1 to get a column location of 0
+              if (nameloc.col === 0) {
+                nameloc.col = 1;
+              }
+              loc = defaultLoc;
+              loc.start.column = nameloc.col - 1;
+              loc.start.line = nameloc.line;
+              loc.end.column = nameloc.col - 1 + name.length;
+              loc.end.line = nameloc.line;
+            } else if (obj.parent) {
+              this.getLocation(name, obj.parent, model);
+            }
+          }
+          // Empty locations default to line 0, column 0
+          if (!loc) {
+            loc = defaultLoc;
+          }
+          return loc;
+        },
+        getNode: function(obj) {
+          let loc;
+          if (obj && obj.name) {
+            loc = this.getLocation(obj.name, obj);
+          }
+          return createProgramAST(code, loc)
+        }
+      },
       scopeManager: null,
       tokensAndComments: [],
-      visitorKeys: null,
+      visitorKeys: [],
     };
   },
+  createProgramAST,
+  compileModelFromDict,
 };
+
+/**
+ * Generates dummy AST with just single Program node
+ * @param code Parse file contents
+ * @returns AST
+ */
+function createProgramAST(code, loc) {
+  loc = loc || {
+    start: {
+      line: 1,
+      column: 0,
+    },
+    end: {
+      line: 1,
+      column: 0,
+    }
+  };
+  return {
+    type: "Program",
+    body: [],
+    sourceType: "module",
+    tokens: [],
+    comments: [],
+    range: [0, code.length],
+    loc
+  };
+}
+
+function compileModelFromDict(dictFiles, options) {
+  let reflectedModel;
+  const messages = [];
+  const compiledModel = cds.compile(dictFiles, {
+    sync: true,
+    locations: true,
+    messages,
+    ...options,
+  });
+  if (compiledModel) {
+    reflectedModel = cds.linked(compiledModel);
+    if (messages) {
+      reflectedModel.messages = messages;
+    }
+  }
+  return reflectedModel;
+}

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

@@ -1,36 +1,35 @@
+const cds = require("@sap/cds");
+
+/** @type {import('../types').Rule} */
+
 module.exports = {
   meta: {
     docs: {
       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",
+      recommended: true
     },
-    severity: "warn",
     type: "problem",
+    model: "inferred"
   },
   create(context) {
-    return { all: check_assoc2many_ambiguous_key };
+    return check_assoc2many_ambiguous_key;
 
     function check_assoc2many_ambiguous_key() {
-      let reports = [];
       let csnOdata;
-      const m = context.cds.model;
+      const m = context.getModel();
+      if (!m) return;
       if (m && m.definitions) {
-        csnOdata = context.cds.compile.for.odata(m);
-        const csnOdataLinked = context.cds.linked(csnOdata);
-        reports = associationCardinalityFlaw(csnOdataLinked, context);
-      }
-      if (reports.length > 0) {
-        return reports;
+        csnOdata = cds.compile.for.odata(m);
+        const csnOdataLinked = cds.linked(csnOdata);
+        associationCardinalityFlaw(csnOdataLinked, context);
       }
     }
-  },
+  }
 };
 
 function associationCardinalityFlaw(csn, context) {
-  const reports = [];
   processEntity(csn, (definition, sourceEntity, sourceAlias) => {
     let refCardinalityMult = false;
     let refPlainElement = false;
@@ -62,33 +61,17 @@ function associationCardinalityFlaw(csn, context) {
         ) {
           const keyName = Object.keys(definition.keys)[0];
           const key = definition.keys[keyName];
-          const keyLoc = context.cds.getLocation(keyName, key, csn);
+          const keyLoc = context.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,
-              }
-            );
-          }
+          context.report({
+            message: `Ambiguous key in '${definition.name}'. Element '${colName}' leads to multiple entries so that key '${keyName}' is not unique.`,
+            loc: keyLoc,
+            file: key.$location.file
+          });
         }
       }
     );
   });
-  return reports;
 }
 
 function processEntity(csn, eachCallback) {
@@ -110,7 +93,7 @@ function processEntity(csn, eachCallback) {
         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) {
         // Join
@@ -118,7 +101,7 @@ function processEntity(csn, eachCallback) {
         definition.query.SELECT.from.args.forEach((arg) => {
           sourceAlias.push({
             from: arg.ref.join("_"),
-            as: arg.as || arg.ref.slice(-1)[0].split(".").pop(),
+            as: arg.as || arg.ref.slice(-1)[0].split(".").pop()
           });
         });
       }

package/lib/rules/auth-no-empty-restrictions.js

@@ -1,45 +1,37 @@
-const { splitEntityName } = require("../utils/ruleHelpers");
-
-const SEVERITY = "warn";
 const LABELS = ["@restrict", "@requires"];
 
 module.exports = {
   meta: {
     docs: {
-      description: "`@restrict` and `@requires` must not be empty",
+      description: "`@restrict` and `@requires` must not be empty.",
       category: "Model Validation",
-      recommended: true,
-      version: "2.4.1",
+      recommended: true
     },
-    severity: SEVERITY,
     hasSuggestions: true,
     messages: {
       InvalidItem: `Invalid item '{{invalid}}'. Did you mean '{{candidates}}'?`,
-      ReplaceItemWith: `Replace '{{invalid}}' with '{{candidates}}'`,
+      ReplaceItemWith: `Replace '{{invalid}}' with '{{candidates}}'`
     },
+    type: "problem",
+    model: "inferred"
   },
   create(context) {
     return {
       entity: check_restrictions,
-      service: check_restrictions,
+      service: check_restrictions
     };
 
     function check_restrictions(e) {
-      const reports = [];
-
-      LABELS.forEach((l) => {
-        const invalid = (e[l] && typeof e[l] === "object" && e[l].length === 0) || (typeof e[l] === "string" && !e[l]);
+      for (const l of LABELS) {
+        const invalid = (typeof e[l] === "object" && e[l].length === 0) || (typeof e[l] === "string" && e[l] === "");
         if (invalid) {
-          const entityName = splitEntityName(e).entity;
-          const loc = context.cds.getLocation(entityName, e);
-          reports.push({
+          context.report({
             message: `No explicit restrictions provided on ${e.kind} \`${e.name}\` at \`${l}\`.`,
-            loc,
+            node: context.getNode(e),
+            file: e.$location.file
           });
         }
-      });
-
-      return reports.length > 0 ? reports : undefined;
+      }
     }
-  },
+  }
 };

package/lib/rules/auth-use-requires.js

@@ -1,38 +1,38 @@
-const SEVERITY = "warn";
-
 module.exports = {
   meta: {
     docs: {
-      description: "Use `@requires` instead of `@restrict.to` in actions and services with unrestricted events",
+      description: "Use `@requires` instead of `@restrict.to` in actions and services with unrestricted events.",
       category: "Model Validation",
       recommended: true,
-      version: "2.4.1",
+      version: "2.4.1"
     },
-    severity: SEVERITY,
     hasSuggestions: true,
     messages: {
       InvalidItem: `Invalid item '{{invalid}}'. Did you mean '{{candidates}}'?`,
-      ReplaceItemWith: `Replace '{{invalid}}' with '{{candidates}}'`,
+      ReplaceItemWith: `Replace '{{invalid}}' with '{{candidates}}'`
     },
+    type: "problem",
+    model: "inferred"
   },
-  create() {
+  create(context) {
     return {
       service: check_restrict,
-      action: check_restrict,
+      action: check_restrict
     };
 
     function check_restrict(e) {
-      const reports = [];
-
       if (e && e["@restrict"] && typeof e["@restrict"] === "object") {
-        e["@restrict"].forEach((entry) => {
+        for (const entry of e["@restrict"]) {
           const keys = Object.keys(entry);
           if (keys.includes("to") && keys.includes("grant") && entry.grant === "*") {
-            reports.push(`Use \`@requires\` instead of \`@restrict.to\` at ${e.kind} \`${e.name}\`.`);
+            context.report({
+              message: `Use \`@requires\` instead of \`@restrict.to\` at ${e.kind} \`${e.name}\`.`,
+              node: context.getNode(e),
+              file: e.$location.file
+            });
           }
-        });
+        }
       }
-      return reports.length > 0 ? reports : undefined;
     }
-  },
+  }
 };