@sap/eslint-plugin-cds 2.0.5 → 2.2.2

package/lib/impl/index.js

@@ -1,35 +1,58 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+/**
+ * Custom ESLint plugin:
+ * https://eslint.org/docs/developer-guide/working-with-plugins
+ * 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
+ * We also initiate and cache the objects 'rulesInfo' and 'cds' for later use.
+ */
+
+const path = require("path");
+const processor = require("./processor");
+const plugin = require("../../package.json").name;
+
+const { getRules } = require("../impl/utils/rules");
+const {
+  Cache,
+  getCDSProxy,
+  getLocation,
+  getRange,
+} = require("../impl/utils/model");
+const { files, globals, recommended } = require("./constants");
+
+const cds = require("@sap/cds");
+cds.getLocation = getLocation;
+cds.getRange = getRange;
+Cache.set("cds", getCDSProxy(cds));
+
+let rulesInfo;
+if (!Cache.has("rulesInfo")) {
+  rulesInfo = getRules(path.join(__dirname, "rules"));
+  Cache.set("rulesInfo", rulesInfo);
+} else {
+  rulesInfo = Cache.get("rulesInfo");
+}
+
+module.exports = {
+  configs: {
+    recommended: {
+      globals,
+      plugins: [plugin],
+      overrides: [
+        {
+          files: files,
+          processor: "@sap/cds/cds",
+        },
+      ],
+      rules: recommended,
+    },
+  },
+  processors: {
+    cds: processor,
+  },
+  rules: rulesInfo.rules,
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configs = exports.globals = exports.rules = void 0;
-const constants_1 = require("./constants");
-const csn_compile_error_1 = __importDefault(require("./rules/csn-compile-error"));
-const assocs_card_flaw_1 = __importDefault(require("./rules/assocs-card-flaw"));
-const latest_cds_version_1 = __importDefault(require("./rules/latest-cds-version"));
-const lower_camelcase_elements_1 = __importDefault(require("./rules/lower-camelcase-elements"));
-const min_node_version_1 = __importDefault(require("./rules/min-node-version"));
-const sql_cast_suggestion_1 = __importDefault(require("./rules/sql-cast-suggestion"));
-const upper_camelcase_entities_1 = __importDefault(require("./rules/upper-camelcase-entities"));
-const rules = {
-    "csn-compile-error": csn_compile_error_1.default,
-    "assocs-card-flaw": assocs_card_flaw_1.default,
-    "latest-cds-version": latest_cds_version_1.default,
-    "lower-camelcase-elements": lower_camelcase_elements_1.default,
-    "min-node-version": min_node_version_1.default,
-    "sql-cast-suggestion": sql_cast_suggestion_1.default,
-    "upper-camelcase-entities": upper_camelcase_entities_1.default
-};
-exports.rules = rules;
-const configs = {
-    "recommended": {
-        "plugins": ["@sap/eslint-plugin-cds"],
-        "overrides": constants_1.Constants.overrides,
-        "rules": constants_1.Constants.recRules
-    }
-};
-exports.configs = configs;
-const globals = constants_1.Constants.globals;
-exports.globals = globals;
-//# sourceMappingURL=index.js.map

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(`file:${filename}`, text);
+    }
+    return [{ text: "", filename }];
+  },
+  supportsAutofix: true,
+};

package/lib/impl/ruleFactory.js

@@ -1,159 +1,311 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runRuleTester = exports.createRule = void 0;
-const fs_1 = __importDefault(require("fs"));
-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);
+/**
+ * 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:
+ * - 'category'  : Rule category
+ * - 'cds'       : Proxy for cds object which also caches results
+ * - 'code'      : Code object based on ESLint getFromSourceCode()
+ * - 'ruleID'    : Rule ID ("@sap/cds/...")
+ * - 'filePath'  : ESLint's 'physical' filename
+ * - 'options'   : CDS Environment parameters
+ * - 'report'    : Proxy for ESLint's context.report() for lint filtering
+ * - 'ruleID'    : ESLint's rule ID
+ * - 'sourcecode': ESLint's SourceCode object
+ *
+ * @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, styleText } = require("./utils/helpers");
+const { isValidEnv, isValidModel } = require("./utils/validate");
+const {
+  Cache,
+  populateModelAndEnv,
+  hasCompilationError,
+  getAST,
+  loadConfigPath,
+} = require("./utils/model");
+const { isRuleDisabled, getRules, populateRules } = 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() ---
+          let cdscontext = createCDSContext(context, node, meta);
+          // 1. Is file exension allowed?
+          // (i.e. when using globs + other plugins)
+          if (
+            isValidFile(cdscontext.filePath) ||
+            meta.docs.category === categories["env"]
+          ) {
+            // Update model/env contents and rules (at runtime)
+            populateModelAndEnv(cdscontext);
+            populateRules(cdscontext, customRulesDir);
+            // 2. Is rule allowed and model/env valid?
+            if (isValidEnv(cdscontext) || isValidModel(cdscontext)) {
+              try {
+                create(cdscontext);
+              } catch (err) {
+                // Do not throw to avoid ESLint VSCode editor pop-ups
+                styleText(
+                  `Rule ${cdscontext.ruleID} has failed unexpectedly - please report this error!\n`,
+                  ["bold", "red"]
+                );
+              }
+              // Show compilation error only on console
+            } else if (hasCompilationError(cdscontext) && !isEditor()) {
+              create(cdscontext);
             }
-        }
-    };
+          }
+        },
+      };
+    },
+  };
 }
-exports.createRule = createRule;
-function cbRuleFunctions(context, defineReport) {
-    return {
-        Program(node) {
-            var _a;
-            let report = [];
-            const ruleID = context.id;
-            const cds = context.parserServices.cdsProxy;
-            const sourcecode = context.getSourceCode();
-            const code = sourcecode.getText(node);
-            const filePath = context.getFilename();
-            let configPath = path_1.default.dirname(utils_1.getConfigPath(filePath));
-            utils_1.Cache.set('configpath', configPath);
-            utils_1.loadModel(code, configPath, filePath);
-            utils_1.updateConfigPath(code, configPath, filePath);
-            configPath = utils_1.Cache.get('configpath');
-            if (utils_1.Cache.has(`file:${filePath}`) && code !== utils_1.Cache.get(`file:${filePath}`)) {
-                utils_1.Cache.set(`file:${filePath}`, code);
-                utils_1.updateModel(code, configPath, filePath);
+
+/**
+ * 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);
+              }
             }
-            if ((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.environment) {
-                utils_1.Cache.set(`environment`, context.options[0].environment);
-            }
-            const properties = { filePath, configPath, ruleID, code, sourcecode };
-            if (isValidModel(cds, ruleID)) {
-                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) {
-                    reportErrors(report, context, properties);
-                }
-            }
-            else {
-                if (hasCompilationError(cds, ruleID) && !isEditor()) {
-                    report = defineReport(cds, context, node);
-                    if (report.length > 0) {
-                        reportErrors(report, context, properties);
-                    }
-                }
-            }
-        }
-    };
-}
-function isValidModel(cds, ruleID) {
-    var _a;
-    if (((cds === null || cds === void 0 ? void 0 : cds.model) && !((_a = cds === null || cds === void 0 ? void 0 : cds.model) === null || _a === void 0 ? void 0 : _a.err)) ||
-        (cds === null || cds === void 0 ? void 0 : cds.environment) &&
-            !(ruleID === '@sap/cds/csn-compile-error' || ruleID === 'csn-compile-error')) {
-        return true;
-    }
-    return false;
-}
-function hasCompilationError(cds, ruleID) {
-    var _a, _b, _c, _d;
-    if (((_a = cds === null || cds === void 0 ? void 0 : cds.model) === null || _a === void 0 ? void 0 : _a.err) && ((_d = (_c = (_b = cds === null || cds === void 0 ? void 0 : cds.model) === null || _b === void 0 ? void 0 : _b.err) === null || _c === void 0 ? void 0 : _c.message) === null || _d === void 0 ? void 0 : _d.startsWith('CDS compilation failed'))) {
-        if (ruleID === '@sap/cds/csn-compile-error' || ruleID === 'csn-compile-error') {
-            return true;
-        }
-    }
-    return false;
-}
-function isEditor() {
-    return process.argv.join(' ').includes('dbaeumer.vscode-eslint');
+        });
+      }
+    },
+  });
 }
-function reportErrors(report, context, properties) {
-    report.forEach((entry, i) => {
-        var _a, _b;
-        if (entry) {
-            const ruleID = properties.ruleID;
-            const configPath = properties.configPath;
-            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) : '';
+
+/**
+ * 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() ---
+            // 1. Is lint (loc) not disabled by ESLint disable comments?
+            if (!isRuleDisabled(lint, thisArg)) {
+              const fileRel = lint.file;
+              let fileAbs = lint.file || "";
+              if (!path.isAbsolute(fileAbs)) {
+                fileAbs = fileRel
+                  ? path.join(Cache.get("configpath"), fileRel)
+                  : "";
+              }
+              // Only show 'env' lints on console
+              if (thisArg.category === "env" && !isEditor()) {
+                lint["loc"] = {
+                  start: { line: 0, column: -1 },
+                  end: { line: 0, column: -1 },
+                };
+                report = true;
+                // Only show 'model' lints at corrsponding file
+              } else if (
+                fileAbs === thisArg.filePath ||
+                fileRel === "<stdin>.cds"
+              ) {
+                report = true;
+              }
+              if (report) {
+                return thisArg._context.report(lint);
+              }
             }
-            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/', ''))) {
-                    if (!isEditor()) {
-                        if (!utils_1.Cache.has(`envChecks:${configPath}`)) {
-                            context.report(entry);
-                            utils_1.Cache.set(`envChecks:${configPath}`, [entry.message]);
-                        }
-                        else if (utils_1.Cache.has(`envChecks:${configPath}`) && !utils_1.Cache.get(`envChecks:${configPath}`).includes(entry.message)) {
-                            context.report(entry);
-                            utils_1.Cache.set(`envChecks:${configPath}`, [entry.message]);
-                        }
-                    }
-                }
-                else if ((fileRel && ((fileAbs === properties.filePath) || fileRel === '<stdin>.cds'))) {
-                    context.report(entry);
-                }
-            }
-        }
-    });
+          }
+        });
+      }
+    },
+  };
+  return new Proxy(obj, handler);
+}
+
+/**
+ * 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, meta) {
+  const filePath = context.getPhysicalFilename();
+  const configPath = loadConfigPath(filePath);
+  let category = "model";
+  if (meta.docs.category === categories["env"]) {
+    category = "env";
+  }
+  let sourcecode = context.getSourceCode();
+  let code = sourcecode.getText(node);
+  if (!code) {
+    code = Cache.get(`file:${context.getPhysicalFilename()}`);
+  }
+  if (code) {
+    sourcecode = new SourceCode(code, getAST(code));
+  }
+  return {
+    _context: context,
+    ...context,
+    category,
+    cds: context.parserServices.cdsProxy || Cache.get("cds"),
+    configPath,
+    code,
+    filePath,
+    options: context.options,
+    report: getProxyReport(context.report),
+    ruleID: context.id,
+    sourcecode,
+  };
 }
+
+/**
+ * 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;
-    if (options.root.includes('eslint-plugin-cds')) {
-        parser = path_1.default.join(path_1.default.resolve('.'), 'src/impl/parser');
+  process.env['RULE_TESTER'] = true;
+  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 === categories["env"]) {
+      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");
     }
-    else {
-        const resolvedPlugin = require.resolve('@sap/eslint-plugin-cds', { paths: [options.root] });
-        parser = path_1.default.join(path_1.default.dirname(resolvedPlugin), 'parser');
+    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");
+      }
     }
-    const category = options.rule['meta']['docs']['category'];
-    const rulename = path_1.default.basename(options.root);
-    const tester = new eslint_1.RuleTester({ parser });
-    const testerCases = {};
-    ['valid', 'invalid'].forEach((type) => {
-        const filePath = path_1.default.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_1.default.readFileSync(filePath, 'utf8')) }];
-        }
-        else if (category === 'Model Validation') {
-            testerCases[type][0].code = fs_1.default.readFileSync(filePath, 'utf8');
-        }
-        if (type === 'invalid') {
-            testerCases[type][0].errors = options.errors;
-            const fileFixed = path_1.default.join(options.root, `fixed/${options.filename}`);
-            if (fs_1.default.existsSync(fileFixed)) {
-                testerCases[type][0].output = fs_1.default.readFileSync(fileFixed, 'utf8');
-            }
-        }
-    });
-    return tester.run(rulename, options.rule, testerCases);
+  });
+  return tester.run(rulename, rule, testerCases);
 }
-exports.runRuleTester = runRuleTester;
-//# sourceMappingURL=ruleFactory.js.map
+
+module.exports = { createRule, defineRule, runRuleTester };