@sap/eslint-plugin-cds 2.1.1 → 2.2.1

package/lib/impl/ruleFactory.js

@@ -3,367 +3,317 @@
  * https://eslint.org/docs/developer-guide/working-with-rules
  *
  * Each ESLint rule module must be composed of a 'meta', 'create' object:
- * - 'meta': meta data for rule (docs, fixable, etc.)
- * - 'create': ingests rule context and returns object with nodes to visit
- *             while traversing the AST
+ * - 'meta':     meta data for rule (docs, fixable, etc.)
+ * - 'create':   ingests rule context and returns object with nodes to visit
+ *               while traversing the AST
  *
- * Since for the cds we want to lint without an AST, we simplified the context
- * object to explicitly pass a subset of ESLint's context arguments:
- * - 'code': code object based on ESLint getFromSourceCode()
+ * Since we want to lint cds models without an AST, we adapted the context
+ * object to explicitly pass some additional information:
+ * - 'code':     code object based on ESLint getFromSourceCode()
  * - 'filePath': ESLint getFilename()
- * We add two custom properties to aid in model rule creation:
- * - 'model': Loaded cds model (CSN)
- * - 'cds': Proxy for cached cds calls
- */
-
-const fs = require("fs");
-const path = require("path");
-const { RuleTester } = require("eslint");
-const { isEditor } = require("./utils/helpers");
-const { Cache, getConfigPath, getSourcecode, loadModel, updateModel, updateConfigPath } = require("./utils/model");
-const { getFileExtensions, getDisabledFromComments, getEnvRules, getModelRules } = require("./utils/rules");
-const envRules = getEnvRules(path.join(__dirname, "rules"));
-const modelRules = getModelRules(path.join(__dirname, "rules"));
-const rules = envRules.concat(modelRules).map((rule) => `@sap/cds/${rule}`);
-
-const CONSTANTS = require("./constants");
-
-// Types:
-// Interface CDSRuleMetaData extends Rule.RuleMetaData {
-//      docs?: Rule.RuleMetaData['docs'] & {
-//          version?: string;
-//      }
-//  }
-// Interface CDSRuleContext {
-//      (cds: any,
-//          context: Rule.RuleContext,
-//          node: Rule.Node): Rule.ReportDescriptor[]
-//  }
-// CDSReport = Rule.ReportDescriptor & { file?: string };
-// RuleModule = Rule.RuleModule;
-
-/**
- * ESLint Rule creator:
- * https://eslint.org/docs/developer-guide/working-with-rules
- * - Must follow the ESLint prescribed convention for all rule exports
- * - defineMeta:
- * - defineReport: Our wrapper for ESLint's 'create' rule function used by ESLint to traverse
- *   its AST nodes. Since we do not work with an AST, we just access our dummy Programm node
- *   and collect the required cds parameters for our rules
+ * - 'model':    Loaded cds model (CSN)
+ * - 'cds':      Proxy for cached cds calls
  *
- * @param defineMeta
- * @param defineReport
- * @returns
+ * @typedef { import('eslint').Rule.RuleModule } RuleModule
+ * @typedef { import('eslint').Rule.RuleContext } RuleContext
+ * @typedef { import('eslint').Rule.Node } RuleNode
+ * @typedef { import("./types").CDSRuleSpec } CDSRuleSpec
+ * @typedef { import("./types").CDSRuleMetaData } CDSRuleMetaData
+ * @typedef { import("./types").CDSRuleContext } CDSRuleContext
+ * @typedef { import("./types").CDSRuleTestOpts } CDSRuleTestOpts
  */
 
-// Types: { defineMeta: CDSRuleMetaData, defineReport: CDSRuleContext): RuleModule }
-function createRule(defineMeta, defineReport) {
-  return {
-    meta: {
-      ...defineMeta,
-    },
-    // Types: { context: Rule.RuleContext }
-    create(context) {
-      {
-        return cbRuleFunctions(context, defineReport);
-      }
-    },
-  };
-}
-
-/**
- * More eslint-like API with more convenience re error reports
- */
-function defineRule (spec) {
-  const { meta, create } = spec
-  if (!meta.type) meta.type = 'problem'
-  if (meta.docs && !meta.docs.category) meta.docs.category = "Model Validation"
-  return createRule (meta, (report, cds) => {
-    const handlers = create({ cds, model:cds.model, report:(r)=>report.push(r) })
-    cds.model.forall (d => {
-      for (let each in handlers) if (d.is(each)) {
-        let r = handlers[each](d)
-        if (r) {
-          if (typeof r === 'string') r = { message: r }
-          if (!r.loc) r.loc = cds.getLocation(d.name,d)
-          if (!r.file) r.file = d.$location && d.$location.file || 'unknown.cds'
-        }
-        report.push (r)
-      }
-    })
-    return report
-  })
-}
-
-
-/**
- * ESLint Rule creator callback object
- * - Must return an object with nodes ESLint can visit while traversing the AST
- *   (here, an empty Program node)
- * - Must ingest 'context' object which contains info in each rule's context
- * https://eslint.org/docs/developer-guide/working-with-rules#the-context-object
- *
- * @param context rule context info
- * @param defineReport rule report
- * @returns rule callback function
- */
-// Types: { context: Rule.RuleContext, defineReport: CDSRuleContext }
-function cbRuleFunctions(context, defineReport) {
-  return {
-    Program(node) {
-      let report = [];
-      const ruleID = context.id;
-      let cds = context.parserServices.cdsProxy || Cache.get('cds');
-      let sourcecode = context.getSourceCode()
-      let filePath = context.getFilename();
-
-      if (!filePath.endsWith('.js')) {
-        filePath = `${filePath.split('.cds')[0]}.cds`;
-        if (filePath.endsWith('.cds')) {
-          const code = sourcecode.getText(node) || Cache.get(`file:${filePath}`);
-          if (code) sourcecode = getSourcecode(code);
-
-          let category = CONSTANTS.categories.model;
-          if (envRules.includes(ruleID.replace("@sap/cds/", ""))) {
-            category = CONSTANTS.categories.env;
-          }
-
-          // Set configPath according to filePath
-          let configPath = path.dirname(getConfigPath(filePath));
-          Cache.set("configpath", configPath);
-
-          // Get cds model for current project
-          loadModel(code, configPath, filePath);
-
-          // Update config path (any files not part of the above model)
-          // Can only do this if model.$sources are known, otherwise no
-          // way to distinguish between 'model' vs 'outsider' files
-          if (cds && cds.model && !cds.model.err) {
-            updateConfigPath(code, configPath, filePath);
-            configPath = Cache.get("configpath");
-          }
-
-          // Update cds model on every 'type' event
-          if (
-            Cache.has(`file:${filePath}`) &&
-            code !== Cache.get(`file:${filePath}`)
-          ) {
-            // Update file contents in Cache
-            Cache.set(`file:${filePath}`, code);
-            updateModel(code, configPath, filePath);
-          }
-
-          // Get cds environment (when called from ruleTester)
-          if (context.options[0] && context.options[0].environment) {
-            Cache.set(`environment`, context.options[0].environment);
-          }
-
-          // Get report for triggered cds 'environment' and 'model' rules
-          const properties = { filePath, configPath, ruleID, code, sourcecode };
-          if (cds && isValidModel(cds, ruleID)) {
-            if (
-              (category === CONSTANTS.categories.model && cds.model &&
-                getFileExtensions().includes(`*${path.extname(filePath)}`)) ||
-              (category === CONSTANTS.categories.env && cds.environment)
-            ) {
-              report = defineReport(report, cds, sourcecode, node, filePath);
-            }
-            if (report.length > 0) {
-              reportErrors(report, context, properties);
-            }
-          } else {
-            // Add any compilation errors to ESLint report, except when plugin
-            // is used within VS Code ESLint extension editor as it would duplicate
-            // CDS compile messages
-            if (hasCompilationError(cds, ruleID) && !isEditor()) {
-              report = defineReport(report, cds, sourcecode, node);
-              if (report.length > 0) {
-                reportErrors(report, context, properties);
-              }
-            }
-          }
-        }
-      }      
-    },
-  };
-}
-
-/**
- * Checks whether the compiled cds model or environment
- * is eligible for performing the plugin's rule checks
- * @param cds cds object
- * @param ruleID rule name
- * @returns
- */
-function isValidModel(cds, ruleID) {
-  if (
-    (cds && cds.model && !cds.model.err) ||
-    (cds.environment &&
-      !(
-        ruleID === "@sap/cds/cds-compile-error" ||
-        ruleID === "cds-compile-error"
-      ))
-  ) {
-    return true;
-  }
-  return false;
-}
-
-/**
- * Checks whether the compiled cds model contains compilation errors
- * which should only be reported via the 'cds-compile-error' rule
- * @param cds cds object
- * @param ruleID rule name
- * @returns
- */
-function hasCompilationError(cds, ruleID) {
-  if (
-    cds &&
-    cds.model &&
-    cds.model.err &&
-    cds.model.err.message.startsWith("CDS compilation failed")
-  ) {
-    if (
-      ruleID === "@sap/cds/cds-compile-error" ||
-      ruleID === "cds-compile-error"
-    ) {
-      cds.model.err
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Allows to pass on every ESLint error report only for its corresponding file
- * @param report rule report
- * @param context ESLint rule context
- * @param properties Current file/path/rule association
- * Only send report if:
- * - Rule is not disabled via comment
- * - Rule is an environment check
- * - Rule is a model check and:
- *   - Error/warning can be allocated to an actual file
- *   - File is <stdin>.cds from model rule test
- */
-// Types: { report: any[], context: Rule.RuleContext, properties: any }
-function reportErrors(report, context, properties) {
-  // Types: { entry: CDSReport, i: number }
-  report.forEach((entry) => {
-    if (entry) {
-      const ruleID = properties.ruleID;
-      const configPath = properties.configPath;
-      const fileRel = entry.file;
-      let fileAbs = entry.file || "";
-      if (!path.isAbsolute(fileAbs)) {
-        fileAbs = fileRel ? path.join(Cache.get("configpath"), fileRel) : "";
-      }
-      let isDisabled = false;
-      if (entry.loc && entry.loc.start) {
-        const line = entry.loc.start.line;
-        const rulesDisabled = getDisabledFromComments(
-          rules,
-          properties.code,
-          properties.sourcecode,
-          line
-        );
-        if (
-          line &&
-          ruleID in rulesDisabled &&
-          rulesDisabled[ruleID] === "off"
-        ) {
-          isDisabled = true;
-        }
-      }
-      if (!isDisabled) {
-        if (
-          envRules.includes(ruleID) ||
-          envRules.includes(ruleID.replace("@sap/cds/", ""))
-        ) {
-          if (!isEditor()) {
-            if (!Cache.has(`envChecks:${configPath}`)) {
-              context.report(entry);
-              Cache.set(`envChecks:${configPath}`, [entry.message]);
-            } else if (
-              Cache.has(`envChecks:${configPath}`) &&
-              !Cache.get(`envChecks:${configPath}`).includes(entry.message)
-            ) {
-              context.report(entry);
-              Cache.set(`envChecks:${configPath}`, [entry.message]);
-            }
-          }
-        } else if (
-          fileRel &&
-          (fileAbs === properties.filePath || fileRel === "<stdin>.cds")
-        ) {
-          context.report(entry);
-        }
-      }
-    }
-  });
-}
-
-/**
- * ESLint RuleTester (used by custom rule creator api)
- * Calls ESLint's RuleTester with custom cds parser and input for
- * valid/invalid checks:
- * Model checks require input 'code' entries
- * Env checks require input 'options' with selected parameters
- * @param options RuleTester input options
- * @returns RuleTester results
- */
-function runRuleTester(options) {
-  let parser;
-  let rule = {};
-  const rulename = path.basename(options.root);
-  const plugin = "eslint-plugin-cds";
-  if (options.root.includes(plugin)) {
-    // For internal plugin tests, resolve parser from here
-    try {
-      parser = options.parser;
-      rule = options.rule;
-    } catch (err) {
-      throw new Error(err);
-    }
-  } else {
-    // Otherwise from project root
-    const resolvedPlugin = require.resolve("@sap/eslint-plugin-cds", {
-      paths: [options.root],
-    });
-    parser = path.join(path.dirname(resolvedPlugin), "parser");
-    rule = require(path.join(
-      path.dirname(resolvedPlugin),
-      `rules/${rulename}`
-    ));
-  }
-
-  const category = rule.meta.docs.category;
-  const tester = new RuleTester({ parser });
-  const testerCases = {};
-  ["valid", "invalid"].forEach((type) => {
-    const filePath = path.join(options.root, `${type}/${options.filename}`);
-    testerCases[type] = [
-      {
-        filename: filePath,
-      },
-    ];
-    if (category === "Environment") {
-      testerCases[type][0].code = "";
-      testerCases[type][0].options = [
-        { environment: JSON.parse(fs.readFileSync(filePath, "utf8")) },
-      ];
-    } else if (category === CONSTANTS.categories.model) {
-      testerCases[type][0].code = fs.readFileSync(filePath, "utf8");
-    }
-    if (type === "invalid") {
-      testerCases[type][0].errors = options.errors;
-      const fileFixed = path.join(options.root, `fixed/${options.filename}`);
-      if (fs.existsSync(fileFixed)) {
-        testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
-      }
-    }
-  });
-  return tester.run(rulename, rule, testerCases);
-}
-
-module.exports = { defineRule, createRule, runRuleTester };
+ const fs = require("fs");
+ const path = require("path");
+ const { RuleTester, SourceCode } = require("eslint");
+ const { isEditor, isValidFile, hasCompilationError, isTest } = require("./utils/helpers");
+ const { isValidModel, isValidEnv, isValidRule } = require("./utils/validate");
+ const { Cache, getAST, updateCache } = require("./utils/model");
+ const { checkDisabled, getRules } = require("./utils/rules");
+ const { customRulesDir, categories } = require("./constants");
+ 
+ /**
+  * Wrapper for ESLint's Rule creator:
+  * https://eslint.org/docs/developer-guide/working-with-rules
+  * - Must follow the ESLint prescribed convention for all rule exports
+  * - ESLint uses 'create' function to traverse its AST nodes
+  * - Since we do not work with an AST for cds models, a dummy 'Programm'
+  *   node is used as an entry point
+  * - For all ESLint rules, we have two entry points for additional checks:
+  *     1. Before ESLint's rule creation via create()
+  *        (see below)
+  *     2. Before ESLint's report via context.report()
+  *        (see getProxyReport())
+  * @param {CDSRuleSpec} spec
+  * @returns {RuleModule}
+  */
+ function createRule(spec) {
+   const { meta, create } = spec;
+   if (!meta.type) meta.type = "problem";
+   if (meta.docs && !meta.docs.category) meta.docs.category = categories["model"];
+   return {
+     meta,
+     create: function (context) {
+       return {
+         Program: function (node) {
+           // --- Checks before create() ---
+           // If plugin rules have been loaded
+           if (Cache.has("rulesInfo")) {
+             let { listEnvRules, listModelRules, listRules } = Cache.get("rulesInfo");
+             let cdscontext = createCDSContext(context, node, listEnvRules, listModelRules, listRules);
+ 
+             // If file has plugin's allowed extension or a valid environment
+             if (isValidFile(cdscontext.filePath) || isValidEnv(cdscontext.options)) {
+               cdscontext = updateCache(cdscontext);
+ 
+               // If rule has not already been evaluated for this model
+               if (!Cache.get(`done:${cdscontext.configPath}:${cdscontext.ruleID}` === cdscontext.filePath)) {
+                 let customRulesPath = path.join(Cache.get(`configpath`), customRulesDir, "rules");
+                 const stats = fs.statSync(Cache.get("configpath"));
+                 if (stats.isFile()) {
+                   customRulesPath = path.join(Cache.get('projectpath'), customRulesDir, "rules");
+                 }
+                 let customRulesInfo;
+                 if (fs.existsSync(customRulesPath)) {
+                   customRulesInfo = getRules(customRulesPath);
+                   listEnvRules = listEnvRules.concat(customRulesInfo.listEnvRules);
+                   listModelRules = listModelRules.concat(customRulesInfo.listModelRules);
+                 }
+ 
+                 // If valid rule and model/env
+                 if (
+                   isValidRule(cdscontext, listEnvRules) ||
+                   (isValidRule(cdscontext, listModelRules) &&
+                     isValidModel(cdscontext) &&
+                     !hasCompilationError(cdscontext))
+                 ) {
+                   create(cdscontext);
+                   Cache.set(`done:${cdscontext.configPath}:${cdscontext.ruleID}`, cdscontext.filePath);
+ 
+                 // If compilation error (only shown on console, not in editor)
+                 } else if (hasCompilationError(cdscontext) && !isEditor()) {
+                   create(cdscontext);
+                 }
+               }
+             }
+           }
+         },
+       };
+     },
+   };
+ }
+ 
+ /**
+  * Generates proxy for ESLint's context object which adds caching
+  * @param obj ESLint's context object
+  * @returns Proxy for cds
+  */
+ function getProxyReport(obj) {
+   const handler = {
+     get(target, prop, receiver) {
+       const value = Reflect.get(target, prop, receiver);
+       if (typeof value !== "object") {
+         return value;
+       }
+       /* eslint no-extra-boolean-cast: "off" */
+       if (!!value) {
+         return new Proxy(value, handler);
+       }
+       return {
+         err: `Property ${prop} prop does not exist on object ${obj}!`,
+       };
+     },
+     apply(target, thisArg, argumentsList) {
+       let report = false;
+       if (argumentsList.length > 0) {
+         argumentsList.forEach((lint) => {
+           if (lint) {
+             // --- Checks before context.report() ---
+             let { listEnvRules, listModelRules, listRules } = Cache.get("rulesInfo");
+ 
+             // If rule/loc not disabled by ESLint disable comment
+             if (!checkDisabled(lint, thisArg, listRules, listEnvRules, listModelRules)) {
+               const fileRel = lint.file;
+               let fileAbs = lint.file || "";
+               if (!path.isAbsolute(fileAbs)) {
+                 fileAbs = fileRel ? path.join(Cache.get("configpath"), fileRel) : "";
+               }
+               const stats = fs.statSync(Cache.get("configpath"));
+               if (stats.isFile()) {
+                 fileAbs = Cache.get("configpath");
+               }
+               
+               // If environment rule, only report once per configPath
+               if (
+                 listEnvRules.includes(thisArg.ruleID) ||
+                 listEnvRules.includes(thisArg.ruleID.replace("@sap/cds/", ""))
+               ) {
+                 if (!isEditor()) {
+                   if (!Cache.has(`envChecks:${thisArg.configPath}`)) {
+                     report = true;
+                     Cache.set(`envChecks:${thisArg.configPath}`, [lint.message]);
+                   } else if (
+                     Cache.has(`envChecks:${thisArg.configPath}`) &&
+                     !Cache.get(`envChecks:${thisArg.configPath}`).includes(lint.message)
+                   ) {
+                     report = true;
+                     Cache.set(`envChecks:${thisArg.configPath}`, [lint.message]);
+                   }
+                 }
+ 
+                 // If model rules, only report if file matches that of report
+               } else if (
+                 fileAbs === thisArg.filePath ||
+                 fileAbs === thisArg.configPath ||
+                 fileRel === "<stdin>.cds" ||
+                 isTest()
+               ) {
+                 report = true;
+               }
+               if (report) {
+                 return thisArg._context.report(lint);
+               }
+             }
+           }
+         });
+       }
+     },
+   };
+   return new Proxy(obj, handler);
+ }
+ 
+ /**
+  * Experimental wrapper for 'createRule' to yield:
+  * - More eslint-like API
+  * - More convenience re error reports
+  * @param {CDSRuleSpec} spec
+  * @returns {RuleModule}
+  */
+ function defineRule(spec) {
+   const { meta, create } = spec;
+   if (!meta.type) meta.type = "problem";
+   if (meta.docs && !meta.docs.category) meta.docs.category = "Model Validation";
+   return createRule({
+     meta,
+     create: (context) => {
+       const { cds, report } = context;
+       const handlers = create({
+         cds,
+         model: cds.model,
+         report: (r) => report(r),
+       });
+       if (cds.model) {
+         cds.model.forall((d) => {
+           for (let each in handlers)
+             if (d.is(each)) {
+               let r = handlers[each](d);
+               if (r) {
+                 if (typeof r === "string") r = { message: r };
+                 if (!r.loc) r.loc = cds.getLocation(d.name, d);
+                 if (!r.file) r.file = (d.$location && d.$location.file) || "unknown.cds";
+                 context.report(r);
+               }
+             }
+         });
+       }
+     },
+   });
+ }
+ 
+ /**
+  * Expands CDS context object with some CDS properties
+  * We also retrieve the file contents cached by the preprocessor
+  * @param {RuleContext} context
+  * @param {RuleNode} node
+  * @returns cdscontext
+  */
+ function createCDSContext(context, node, envRules, modelRules, rules) {
+   let sourcecode = context.getSourceCode();
+   let code = sourcecode.getText(node);
+   if (!code) {
+     code = Cache.get(`processed:${context.getPhysicalFilename()}`);
+   }
+   if (code) {
+     sourcecode = new SourceCode(code, getAST(code));
+   }
+   return {
+     _context: context,
+     ...context,
+     cds: context.parserServices.cdsProxy || Cache.get("cds"),
+     configPath: Cache.get("configpath"),
+     code,
+     filePath: context.getPhysicalFilename(),
+     options: context.options,
+     ruleID: context.id,
+     sourcecode,
+     envRules,
+     modelRules,
+     node,
+     rules,
+     report: getProxyReport(context.report),
+   };
+ }
+ 
+ /**
+  * ESLint RuleTester (used by custom rule creator api)
+  * Calls ESLint's RuleTester with custom cds parser and input for
+  * valid/invalid checks:
+  * Model checks require input 'code' entries
+  * Env checks require input 'options' with selected parameters
+  * @param {CDSRuleTestOpts} options RuleTester input options
+  * @returns RuleTester results
+  */
+ function runRuleTester(options) {
+   let parser;
+   let rule = {};
+   const rulename = path.basename(options.root);
+   const plugin = "eslint-plugin-cds";
+   if (options.root.includes(plugin)) {
+     // For plugin's internal tests, resolve parser from here
+     parser = require.resolve("./parser");
+     rule = require(`./rules/${path.basename(options.root)}`);
+     Cache.set("rulesInfo", getRules(path.join(path.dirname(options.root), "../../lib/impl/rules")));
+   } else {
+     // Otherwise from project root
+     const resolvedPlugin = require.resolve("@sap/eslint-plugin-cds", {
+       paths: [options.root],
+     });
+     parser = path.join(path.dirname(resolvedPlugin), "parser");
+     rule = require(path.join(options.root, `../../rules/${path.basename(options.root)}`));
+     Cache.set("rulesInfo", getRules(path.join(options.root, "../../rules")));
+   }
+   let category = categories["model"];
+   if (rule.meta) {
+     category = rule.meta.docs.category;
+   }
+   let tester = new RuleTester({});
+   if (parser) {
+     tester = new RuleTester({ parser });
+   }
+   const testerCases = {};
+   ["valid", "invalid"].forEach((type) => {
+     const filePath = path.join(options.root, `${type}/${options.filename}`);
+     testerCases[type] = [
+       {
+         filename: filePath,
+       },
+     ];
+     if (category === "Environment") {
+       testerCases[type][0].code = "";
+       testerCases[type][0].options = [{ environment: JSON.parse(fs.readFileSync(filePath, "utf8")) }];
+     } else if (!category || category === categories.model) {
+       testerCases[type][0].code = fs.readFileSync(filePath, "utf8");
+     }
+     if (type === "invalid") {
+       testerCases[type][0].errors = options.errors;
+       const fileFixed = path.join(options.root, `fixed/${options.filename}`);
+       if (fs.existsSync(fileFixed)) {
+         testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
+       }
+     }
+   });
+   return tester.run(rulename, rule, testerCases);
+ }
+ 
+ module.exports = { createRule, defineRule, runRuleTester };
+