@sap/eslint-plugin-cds 2.0.4 → 2.2.1

package/lib/impl/parser.js

@@ -1,27 +1,39 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseForESLint = exports.parse = void 0;
-const utils_1 = require("./utils");
-const cds_1 = __importDefault(require("@sap/cds"));
-function parse(code, options) {
-    return parseForESLint(code, options).ast;
-}
-exports.parse = parse;
-function parseForESLint(code, options) {
-    cds_1.default.getLocation = utils_1.getLocation;
-    cds_1.default.getRange = utils_1.getRange;
+/**
+ * Custom ESLint parser:
+ * https://eslint.org/docs/developer-guide/working-with-custom-parsers
+ * This file must:
+ * - Expose 'parseForESLint' method on the parser which should return the AST,
+ *   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.
+ */
+
+const {
+  getAST,
+  getCDSProxy,
+  getLocation,
+  getRange,
+} = require("../impl/utils/model");
+const cds = require("@sap/cds");
+
+module.exports = {
+  parse: function (code, options) {
+    return module.exports.parseForESLint(code, options).ast;
+  },
+
+  parseForESLint: function (code) {
+    cds.getLocation = getLocation;
+    cds.getRange = getRange;
     return {
-        ast: utils_1.getAST(code),
-        services: {
-            cdsProxy: utils_1.getProxy(cds_1.default)
-        },
-        scopeManager: null,
-        tokensAndComments: [],
-        visitorKeys: null
+      ast: getAST(code),
+      services: {
+        cdsProxy: getCDSProxy(cds),
+      },
+      scopeManager: null,
+      tokensAndComments: [],
+      visitorKeys: null,
     };
-}
-exports.parseForESLint = parseForESLint;
-//# sourceMappingURL=parser.js.map
+  },
+};

package/lib/impl/processor.js

@@ -0,0 +1,23 @@
+/**
+ * ESLint custom processor:
+ * https://eslint.org/docs/developer-guide/working-with-plugins#processors-in-plugins
+ * This processor is used to avoid parsing errors when this plugin is extended
+ * in ESLint alongside other plugins, such as prettier which then also try to 
+ * read the new file types exposed via globs.
+ * Note, that because we cache the file contents and return empty files, the
+ * plugin's parser is not actually used and we must retrieve the file contents
+ * later on (ruleFactory).  
+ */
+
+const { Cache } = require("./utils/model");
+const { isValidFile } = require("./utils/helpers");
+
+module.exports = {
+  preprocess: function (text, filename) {
+    if (isValidFile(filename)) {
+      Cache.set(`processed:${filename}`, text);
+    }
+    return [{ text: "", filename }];
+  },
+  supportsAutofix: true,
+};

package/lib/impl/ruleFactory.js

@@ -1,117 +1,319 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRuleTester = exports.createRule = void 0;
-const path_1 = __importDefault(require("path"));
-const eslint_1 = require("eslint");
-const utils_1 = require("./utils");
-const constants_1 = require("./constants");
-function createRule(defineMeta, defineReport) {
-    return {
-        meta: Object.assign({}, defineMeta),
-        create(context) {
-            {
-                return cbRuleFunctions(context, defineReport);
-            }
-        }
-    };
-}
-exports.createRule = createRule;
-function cbRuleFunctions(context, defineReport) {
-    return {
-        Program(node) {
-            var _a, _b, _c, _d, _e, _f;
-            const ruleID = context.id;
-            const sourcecode = context.getSourceCode();
-            const code = sourcecode.getText(node);
-            const filePath = context.getFilename();
-            const configPath = path_1.default.dirname(utils_1.getConfigPath(filePath));
-            const cds = context.parserServices.cdsProxy;
-            if (!utils_1.Cache.get('configpath') || configPath !== utils_1.Cache.get('configpath')) {
-                utils_1.Cache.set('configpath', configPath);
-            }
-            if ((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.environment) {
-                utils_1.Cache.set('environment', context.options[0].environment);
-            }
-            if (!utils_1.Cache.has(`modelfiles:${configPath}`)) {
-                utils_1.loadModel(code, configPath, filePath);
-            }
-            if (utils_1.Cache.has(`modelfiles:${configPath}`)) {
-                const modelFiles = utils_1.Cache.get(`modelfiles:${configPath}`);
-                if (modelFiles.includes(filePath) && code !== utils_1.Cache.get(`file:${filePath}`)) {
-                    utils_1.Cache.set(`file:${filePath}`, code);
-                    utils_1.updateModel(code, configPath, filePath);
-                }
-            }
-            let report = [];
-            if (((cds === null || cds === void 0 ? void 0 : cds.model) || (cds === null || cds === void 0 ? void 0 : cds.environment)) && !((_b = cds === null || cds === void 0 ? void 0 : cds.model) === null || _b === void 0 ? void 0 : _b.err) && !(ruleID === '@sap/cds/csn-compile-error' || ruleID === 'csn-compile-error')) {
-                if (utils_1.Cache.has(`err:${configPath}`)) {
-                    utils_1.Cache.remove(`err:${configPath}`);
-                }
-                if ((cds === null || cds === void 0 ? void 0 : cds.model) || (cds === null || cds === void 0 ? void 0 : cds.environment)) {
-                    report = defineReport(cds, context, node);
-                }
-                if (report.length > 0) {
-                    const reportProperties = { filePath, ruleID, code, sourcecode };
-                    reportErrors(report, context, reportProperties);
-                }
-            }
-            else {
-                if ((_c = cds === null || cds === void 0 ? void 0 : cds.model) === null || _c === void 0 ? void 0 : _c.err) {
-                    if ((_f = (_e = (_d = cds === null || cds === void 0 ? void 0 : cds.model) === null || _d === void 0 ? void 0 : _d.err) === null || _e === void 0 ? void 0 : _e.message) === null || _f === void 0 ? void 0 : _f.startsWith('CDS compilation failed')) {
-                        if (ruleID === '@sap/cds/csn-compile-error' || ruleID === 'csn-compile-error') {
-                            report = defineReport(cds, context, node);
-                            if (report.length > 0) {
-                                const reportProperties = { filePath, ruleID, code, sourcecode };
-                                reportErrors(report, context, reportProperties);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    };
-}
-function reportErrors(report, context, properties) {
-    report.forEach((entry, i) => {
-        var _a, _b;
-        if (entry) {
-            const ruleID = properties.ruleID;
-            const fileRel = entry.file;
-            let fileAbs = entry.file || '';
-            if (!path_1.default.isAbsolute(fileAbs)) {
-                fileAbs = (fileRel) ? path_1.default.join(utils_1.Cache.get('configpath'), fileRel) : '';
-            }
-            const line = (_b = (_a = entry === null || entry === void 0 ? void 0 : entry.loc) === null || _a === void 0 ? void 0 : _a.start) === null || _b === void 0 ? void 0 : _b.line;
-            const rulesDisabled = utils_1.getDisabledFromComments(properties.code, properties.sourcecode, line);
-            let isDisabled = false;
-            if (line && ruleID in rulesDisabled && rulesDisabled[ruleID] === "off") {
-                isDisabled = true;
-            }
-            if (!isDisabled) {
-                if (constants_1.Constants.envRules.includes(ruleID) || constants_1.Constants.envRules.includes(ruleID.replace('@sap/cds/', ''))) {
-                    entry.file = utils_1.Cache.get('configpath');
-                    context.report(entry);
-                }
-                else if ((fileRel && ((fileAbs === properties.filePath) || fileRel === '<stdin>.cds'))) {
-                    context.report(entry);
-                }
-            }
-        }
-    });
-}
-function getRuleTester(relPath) {
-    let parser;
-    if (relPath === '') {
-        parser = path_1.default.join(path_1.default.resolve('.'), 'src/impl/parser');
-    }
-    else {
-        const resolvedPlugin = require.resolve('@sap/eslint-plugin-cds', { paths: [path_1.default.resolve(relPath)] });
-        parser = path_1.default.join(path_1.default.dirname(resolvedPlugin), 'parser');
-    }
-    return new eslint_1.RuleTester({ parser });
-}
-exports.getRuleTester = getRuleTester;
-//# sourceMappingURL=ruleFactory.js.map
+/**
+ * Rule report object (as prescribed by ESLint):
+ * 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
+ *
+ * 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()
+ * - 'model':    Loaded cds model (CSN)
+ * - 'cds':      Proxy for cached cds calls
+ *
+ * @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
+ */
+
+ 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 };
+