@sap/eslint-plugin-cds 2.3.2 → 2.3.3

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

@@ -12,7 +12,7 @@ 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;
@@ -32,21 +32,5 @@ module.exports = {
       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.3.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",

package/lib/impl/constants.js

@@ -1,30 +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'
- * - 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",
-  globals: {
-    SELECT: true,
-    INSERT: true,
-    UPDATE: true,
-    DELETE: true,
-    CREATE: true,
-    DROP: true,
-    CDL: true,
-    CQL: true,
-    CXL: true,
-    cds: true,
-  },
-  files: ["*.cds", "*.csn", "*.csv"],
-  modelFiles: ["*.cds", "*.csn"],
-};

package/lib/impl/index.js

@@ -1,63 +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 } = 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");
-}
-const recommended = Object.assign({}, 
-  ...Object.entries(rulesInfo.rules)
-    .filter(([k,v]) => (v.meta.docs.recommended))
-    .map(([k,v]) => ({ [`@sap/cds/${k}`]:v.meta.severity }))
-);
-
-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,360 +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 } = require("./utils/helpers");
-const { isValidEnv, isValidModel } = require("./utils/validate");
-const {
-  Cache,
-  populateModelAndEnv,
-  hasCompilationError,
-  getAST,
-  initModelRuleTester,
-  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;
-  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) {
-                if (isEditor()) {  // Do not throw to avoid ESLint VSCode editor pop-ups
-                  console.error(`An error occurred while linting. Rule: ${cdscontext.ruleID}\n`, err);
-                } else {
-                  throw err;
-                }
-              }
-              // 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 },
-                };
-                if (!seenReport(lint, thisArg.ruleID)) {
-                  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);
-}
-
-function seenReport(msg, ruleID) {
-  let seenReports = [];
-  if (Cache.has("reports")) {
-    seenReports = Cache.get("reports");
-  }
-  const lintString = `configpath:${Cache.get('configpath')}|rule:${ruleID}|` +
-    `message:${msg.message}|` +
-    `loc:${msg.loc.start.line},${msg.loc.start.column}-${msg.loc.end.line},${msg.loc.end.column}`;
-  if (!seenReports.includes(lintString)) {
-    seenReports.push(lintString);
-    Cache.set("reports", seenReports);
-    return false;
-  } else {
-    return true;
-  }
-}
-
-/**
- * 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();
-  let configPath;
-  if (!Cache.has("pluginpath")) {
-    configPath = loadConfigPath(filePath);
-  } else {
-    configPath = Cache.get("configpath")
-  }
-  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
-  };
-}
-
-function getProxyRun(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) {
-      return thisArg.run();
-    },
-  };
-  return new Proxy(obj, handler);
-}
-
-/**
- * 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, dryRun=false) {
-  let parser;
-  let rule = {};
-  process.env.LINT_FLAVOR = "inferred";
-  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)}`);
-    const pluginPath = path.join(path.dirname(options.root), "../..");
-    Cache.set(
-      "rulesInfo",
-      getRules(path.join(path.dirname(options.root), "../../lib/impl/rules"))
-    );
-    Cache.set("pluginpath", pluginPath);
-  } 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)}`
-    ));
-    const pluginPath = path.join(path.dirname(options.root), "../../../..");
-    Cache.set("rulesInfo", getRules(path.join(options.root, "../../rules")));
-    Cache.set("pluginpath", pluginPath);
-  }
-  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");
-      initModelRuleTester(filePath);
-    }
-    if (type === "invalid") {
-      testerCases[type][0].errors = options.errors;
-      const fileFixed = path.join(options.root, `fixed/${options.filename}`);
-      if (fs.existsSync(fileFixed) && rule.meta.type !== "suggestion") {
-        testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
-      }
-    }
-  });
-  return tester.run(rulename, rule, testerCases);
-}
-
-module.exports = { createRule, defineRule, runRuleTester };

package/lib/impl/rules/cds-compile-error.js

@@ -1,34 +0,0 @@
-module.exports = require("../../api").createRule({
-  meta: {
-    docs: {
-      description: `Checks whether the CDS model file can be compiled by the @sap/cds wihtout errors.`,
-      category: "Model Validation",
-      version: "1.0.0",
-    },
-    severity: "error",
-    type: "problem",
-  },
-  create: function (context) {
-    const m = context.cds.model;
-    if (m && m.err) {
-      // If any csn compile errors occur
-      m.err.messages.forEach((err) => {
-        const msg = err.message;
-        let file = "";
-        const loc = {
-          start: { line: 0, column: 0 },
-          end: { line: 1, column: 0 },
-        };
-        // Get its location if it exists
-        if (err.$location) {
-          loc.start.column = err.$location.col;
-          loc.start.line = err.$location.line;
-          loc.end.column = err.$location.endCol;
-          loc.end.line = err.$location.endLine;
-          file = err.$location.file;
-        }
-        context.report({ message: `${msg}`, loc, file });
-      });
-    }
-  }
-});

package/lib/impl/rules/latest-cds-version.js

@@ -1,51 +0,0 @@
-const os = require("os");
-const cp = require("child_process");
-const semver = require("semver");
-
-const IS_WIN = os.platform() === "win32";
-
-module.exports = require("../../api").createRule({
-  meta: {
-    docs: {
-      description: "Checks whether the latest `@sap/cds` version is being used.",
-      category: "Environment",
-      version: "1.0.4",
-    },
-    type: "suggestion",
-    hasSuggestions: true,
-    messages: {
-      latestCDSVersion: `A newer CDS version is available!`,
-    },
-  },
-  create: function (context) {
-    let result;
-    let cdsVersions;
-    const e = context.cds.environment;
-    if (!e) {
-      try {
-        result = cp
-          .execSync(`npm outdated @sap/cds --json`, {
-            cwd: process.cwd(),
-            shell: IS_WIN,
-            stdio: "pipe",
-          })
-          .toString();
-        cdsVersions = JSON.parse(result)["@sap/cds"];
-      } catch (err) {
-        // Do not throw
-      }
-    } else {
-      cdsVersions = context.cds.environment["@sap/cds"];
-    }
-    // If current cds version is not the latest
-    if (
-      Object.keys(cdsVersions).length !== 0 &&
-      !semver.satisfies(cdsVersions.latest, cdsVersions.current)
-    ) {
-      // Add to ESLint report
-      context.report({
-        messageId: "latestCDSVersion",
-      });
-    }
-  },
-});

package/lib/impl/rules/min-node-version.js

@@ -1,44 +0,0 @@
-const path = require("path");
-const semver = require("semver");
-
-module.exports = require("../../api").createRule({
-  meta: {
-    docs: {
-      description: `Checks whether the minimum Node.js version required by \`@sap/cds\` is achieved.`,
-      category: "Environment",
-      recommended: true,
-      version: "1.0.0",
-    },
-    severity: "error",
-    type: "problem",
-  },
-  create: function (context) {
-    const e = context.cds.environment;
-    let nodeVersion, nodeVersionCDS;
-    if (!e) {
-      // Get current and required node versions
-      try {
-        const CDSPath = require.resolve("@sap/cds/package.json", {
-          paths: [path.dirname(context.filePath)],
-        });
-        const jsonCDS = require(CDSPath);
-        nodeVersion = process.version;
-        nodeVersionCDS = jsonCDS.engines.node;
-      } catch (err) {
-        // Do not throw
-      }
-    } else {
-      nodeVersion = context.cds.environment.nodeVersion;
-      nodeVersionCDS = context.cds.environment.nodeVersionCDS;
-    }
-    if (
-      nodeVersion &&
-      nodeVersionCDS &&
-      !semver.satisfies(nodeVersion, nodeVersionCDS, { loose: true })
-    ) {
-      context.report({
-        message: `CDS minimum node version of ${nodeVersionCDS} required, found ${nodeVersion}!`,
-      });
-    }
-  },
-});

package/lib/impl/rules/no-db-keywords.js

@@ -1,38 +0,0 @@
-module.exports = require("../../api").defineRule({
-  meta: {
-    docs: {
-      description: `Avoid using reserved SQL keywords.`,
-      category: "Model Validation",
-      recommended: true,
-      version: "2.1.0",
-    },
-    severity: "error"
-  },
-  create(context) {
-    const { db = { kind: "sql" } } = context.cds.env.requires;
-    function _check(d) {
-      if (d.name in RESERVED) {
-        // Do not blame in case of external services
-        let srv = d._service || (d.parent && d.parent._service);
-        if (srv && srv["@cds.external"]) return;
-
-        // Do blame
-        return `'${d.name}' is a reserved keyword in ${db.kind.toUpperCase()}`;
-      }
-    }
-    return { entity: _check, element: _check };
-  },
-});
-
-// REVISIT: Replace by compiler-provided check
-const RESERVED = {
-  ORDER: 1,
-  Order: 1,
-  order: 1,
-  GROUP: 1,
-  Group: 1,
-  group: 1,
-  LIMIT: 1,
-  Limit: 1,
-  limit: 1,
-};