@sap/eslint-plugin-cds 2.2.2 → 2.3.3

package/lib/{impl/utils → utils}/validate.js

@@ -12,38 +12,25 @@ module.exports = {
    * @returns
    */
   isValidRule: function (context, rules) {
-    if (rules.includes(context.ruleID.replace("@sap/cds/", ""))) {
+    if (rules.includes(context.id.replace("@sap/cds/", ""))) {
       return true;
     }
     return false;
   },
 
   /**
-   * Checks whether a well-defined cds model exists
+   * Checks whether a cds model is error-free
    * @param context cds context object
    * @returns
    */
   isValidModel: function (context) {
     const cds = context.cds;
-    if (cds && cds.model && !cds.model.err) {
-      return true;
+    if (cds) {
+      if (cds.model) {
+        return !cds.model.err;
+      }
+      return true;  // allow no model
     }
     return false;
-  },
-
-  /**
-   * Checks whether a well-defined cds environment exists
-   * @param context cds context object
-   * @returns
-   */
-  isValidEnv: function (context) {
-    if (
-      context.options &&
-      context.options[0] &&
-      context.options[0].environment
-    ) {
-      return true;
-    }
-    return false;
-  },
+  }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/eslint-plugin-cds",
-  "version": "2.2.2",
+  "version": "2.3.3",
   "description": "ESLint plugin including recommended SAP Cloud Application Programming model and environment rules",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -12,7 +12,7 @@
   ],
   "author": "SAP SE (https://www.sap.com)",
   "license": "See LICENSE file",
-  "main": "lib/impl/index.js",
+  "main": "lib/index.js",
   "files": [
     "lib/",
     "CHANGELOG.md",
@@ -20,7 +20,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@sap/cds": "^5.0.0",
+    "@sap/cds": "^5.6.0",
     "semver": "^7.3.4"
   },
   "peerDependencies": {

package/lib/api/formatter.js

@@ -1,182 +0,0 @@
-/**
- * Custom ESLint formatter:
- * https://eslint.org/docs/developer-guide/working-with-custom-formatters
- * Here, we take the ESLint.LintResult[] and format it into ESLint's standard (stylish) error report.
- * Then, we adapt it to report environment errors:
- * - Separately from model errors
- * - Report them within a project scope but independent of a specific file within that scope
- */
- const fs = require("fs");
- const path = require("path");
- const formatter = require("eslint/lib/cli-engine/formatters/stylish");
-
- const { Cache } = require("../impl/utils/model");
- const { styleText, isEditor } = require("../impl/utils/helpers");
-
- const CONSTANTS = require("../impl/constants");
- /* eslint-disable-next-line no-control-regex */
- const REGEX_STRIP_ANSI = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
- const REGEX_NEWLINE = /\r?\n/g;
-
- let projects = Cache.get('configpaths') || [];
-
- module.exports = function (results, data) {
-   let output = "";
-   // Get plugin ruleIDs
-   const rules = getPluginRules(data);
-   // Get ruleIDs from custom rules
-   const customRules = [];
-   projects.forEach((project) => {
-     const customRulesPath = path.resolve(project, CONSTANTS.customRulesDir, "rules");
-     if (fs.existsSync(customRulesPath)) {
-       fs.readdirSync(customRulesPath).forEach((customRule) => {
-         const ruleID = path.basename(customRule, ".js");
-         if (!customRules.includes(ruleID)) {
-           customRules.push(ruleID);
-         }
-       });
-     }
-   });
-   if (!Cache.has("err")) {
-     // Filter out error messages not from plugin or custom rules
-     if (!isEditor()) {
-       results.forEach((result) => {
-         result.messages = result.messages.filter(
-           (msg) =>
-             rules.model.includes(msg.ruleId) ||
-             rules.environment.includes(msg.ruleId) ||
-             customRules.includes(msg.ruleId)
-         );
-       });
-     }
-     // Get standard ESLint 'stylish' output
-     const outputStylish = formatter(results);
-
-     // Split according to category
-     const msgs = splitOutput(outputStylish, rules);
-
-     // Format new CDSLint output
-     output = formatOutput(output, msgs);
-   }
-   return output;
- };
-
- /**
-  * Splits rules by config and category
-  * @param data Rules meta data
-  * @returns rules object based on category
-  */
- function getPluginRules(data) {
-   const rules = { environment: [], model: [], recommended: [] };
-   Object.keys(data.rulesMeta).forEach((rule) => {
-     if (data.rulesMeta[rule]) {
-       const category = data.rulesMeta[rule].docs.category;
-       if (category === CONSTANTS.categories.model) {
-         rules.model.push(rule);
-         rules.recommended.push(rule);
-       } else if (category === CONSTANTS.categories.env) {
-         rules.environment.push(rule);
-         rules.recommended.push(rule);
-       }
-     }
-   });
-   return rules;
- }
-
- /**
-  * Obtains ESLint's standard (*stylish*) output, then splits and reccollects error messages
-  * based on rule category and content type (msg vs. error count/report)
-  * @param outputStylish ESLint's standard output
-  * @param rules Plugin rules based on category
-  * @returns Collected msgs
-  */
- function splitOutput(outputStylish, rules) {
-   const msgs = { environment: {}, model: {}, report: [] };
-   let file = "";
-   outputStylish.split(REGEX_NEWLINE).forEach((line) => {
-     const lineStripped = line.replace(REGEX_STRIP_ANSI, "");
-     // Collect model file (default)
-     const lineStrippedSplit = lineStripped.split(" ");
-     const rule = lineStrippedSplit[lineStrippedSplit.length - 1];
-     if (
-       !lineStripped.startsWith(" ") &&
-       !rules.recommended.includes(rule) &&
-       !lineStripped.startsWith("✖")
-     ) {
-       file = line;
-       if (process.argv[1].includes("jest") || process.argv[1].includes("mocha")) {
-         projects = [path.dirname(lineStripped)];
-       }
-     } else if (rules.environment.includes(rule)) {
-       // Collect error/warning messages from @sap/cds/ rules
-       const delimiter = line.split(/  +/, 2)[1];
-       const lineWithoutLocation = line.split(delimiter)[1];
-       let project = "";
-       for (let i = 0; i < projects.length; i++) {
-         project = projects[i];
-         if (file.includes(project)) {
-           project = styleText(project, ["link"]);
-           break;
-         }
-       }
-       if (project) {
-         if (!Object.keys(msgs.environment).includes(project)) {
-           msgs.environment[project] = [lineWithoutLocation];
-         } else if (!msgs.environment[project].includes(lineWithoutLocation)) {
-           msgs.environment[project].push(lineWithoutLocation);
-         }
-       }
-     } else if (
-       lineStripped &&
-       !rules.environment.includes(rule) &&
-       !lineStripped.includes("potentially fixable") &&
-       !lineStripped.startsWith("✖")
-     ) {
-       if (lineStripped) {
-         if (!msgs.model[file]) {
-           msgs.model[file] = [line];
-         } else {
-           msgs.model[file].push(line);
-         }
-       }
-     } else if (lineStripped.startsWith("✖") || lineStripped.includes("potentially fixable")) {
-       msgs.report.push(line);
-     }
-   });
-   return msgs;
- }
-
- /**
-  * Takes the collected error messages and collects them
-  * in a final string for ESLint to output
-  * @param output final string to output
-  * @param msgs error messages based on category
-  * @returns
-  */
- function formatOutput(output, msgs) {
-   // First, output model msgs per file (from ESLint 'stylish' output)
-   for (const fileModel in msgs.model) {
-     if (msgs.model[fileModel].length > 0) {
-       output += `${fileModel}\n`;
-       output += `${msgs.model[fileModel].join("\n")}\n\n`;
-     }
-   }
-   // Next, output env msgs (file-independent but associated to project)
-   for (const fileModel in msgs.environment) {
-     if (msgs.environment[fileModel].length > 0) {
-       output += `${fileModel}\n`;
-       output += `${msgs.environment[fileModel].join("\n")}\n\n`;
-     }
-   }
-   // Finally output error/warning report count
-   if (output && msgs.report) {
-     output += `${msgs.report.join("\n")}`;
-   }
-   if (output) {
-     output = `\n${output}`;
-     if (Cache.has('linted')) {
-       output += `\n\nTotal files linted: ${Cache.get('linted').files.length}\n`;
-     }
-   }
-   return output;
- }

package/lib/impl/constants.js

@@ -1,40 +0,0 @@
-/**
- * This file contains all constants for:
- * - categories: The category labels we use to for model and environment rules
- * - customRulesDir: The custom rules directory name in the user's project home
- *                   which contains the subdirs 'docs', 'rules' and 'tests'
- * - recommended: The set of this plugin's recommended rules and their severities
- * - globals: The globals which should be exposed to ESLint by this plugin
- * - files: Any additional file extensions which ESLint should lint
- */
-
-module.exports = {
-  categories: {
-    env: "Environment",
-    model: "Model Validation",
-  },
-  customRulesDir: ".eslint",
-  recommended: {
-    "@sap/cds/assoc2many-ambiguous-key": 1,
-    "@sap/cds/cds-compile-error": 2,
-    "@sap/cds/min-node-version": 2,
-    "@sap/cds/no-join-on-draft-enabled-entities": 1,
-    "@sap/cds/no-db-keywords": 2,
-    "@sap/cds/require-2many-oncond": 2,
-    "@sap/cds/sql-cast-suggestion": 1,
-  },
-  globals: {
-    SELECT: true,
-    INSERT: true,
-    UPDATE: true,
-    DELETE: true,
-    CREATE: true,
-    DROP: true,
-    CDL: true,
-    CQL: true,
-    CXL: true,
-    cds: true,
-  },
-  files: ["*.cds", "*.csn"],
-  modelFiles: ["*.cds", "*.csn"],
-};

package/lib/impl/index.js

@@ -1,58 +0,0 @@
-/**
- * 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,
-};

package/lib/impl/processor.js

@@ -1,23 +0,0 @@
-/**
- * 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,311 +0,0 @@
-/**
- * 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);
-            }
-          }
-        },
-      };
-    },
-  };
-}
-
-/**
- * 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);
-              }
-            }
-        });
-      }
-    },
-  });
-}
-
-/**
- * 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);
-              }
-            }
-          }
-        });
-      }
-    },
-  };
-  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) {
-  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");
-    }
-    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 };