@sap/cds-dk 8.7.1 → 8.7.3

package/lib/lint/Linter.js

@@ -1,42 +1,185 @@
 const term = require("../util/term");
-
 const io = require("./io");
 const checks = require("./checks");
 const generators = require("./generators");
-
 const cds = require("../../lib/cds");
 const { path, exists, isdir, isfile, readdir } = cds.utils
 const { exit } = require("process");
+
 const LOG = cds.debug("lint");
 const LOG_CONFIG = cds.debug("lint:config");
-
 const GENERAL_ERROR = 1;
 
-class Linter {
-  constructor() {
-    this.eslintCmd = "";
-    this.eslintCmdShort = "eslint";
-    this.eslintCmdFileExpr = "";
-    this.isFile = false;
-    this.help = "";
-    this.debug = "";
-    this.flags = [];
-    this.configPath = "";
-    this.configContents = {};
-    this.cdsdkPath = path.join(__dirname, "../..");
-    this.globalPath = path.join(this.cdsdkPath, "../..");
-    this.extendsPlugin = false;
-    this.fileExtensions = [];
-    this.pluginPath = "";
-    this.pluginApi = {};
-    this.lintType = "global";
-    this.ruleOpts = {};
-    this.customRulesOpts = [];
-    this.pluginRules = [];
-    this.init = this.init.bind(this);
-    this.lint = this.lint.bind(this);
+/**
+ * Safely require a module, return empty object if module not found
+ * @param {string} module - module to require
+ * @param {boolean} esm - whether to use dynamic import to accomodate ESM
+ * @returns {Promise<ReturnType<NodeRequire> | {}>} module or empty object
+ */
+async function tryRequire(module, esm = false) {
+  try {
+    return esm ? import(module) : require(module)
+  } catch (e) {
+    if (e.code === 'MODULE_NOT_FOUND' && e.message.includes(module)) return {}
+    // target module is either .mjs (etc) or user project is ESM
+    if (['ERR_REQUIRE_ASYNC_MODULE', 'ERR_REQUIRE_ESM'].includes(e.code)) return tryRequire(module, true)
+    throw e
+  }
+}
+
+/**
+ * Load ESLint module
+ * @param {string} currentDir - current directory to start search
+ * @returns {Promise<ReturnType<NodeRequire>>} - ESLint module
+ */
+async function _loadEslint(currentDir) {
+  const { loadESLint, ESLint } = require('eslint')
+  const DefaultESLint = loadESLint
+    ? await loadESLint({ cwd: currentDir }) // ESLint 9
+    : new ESLint({ cwd: currentDir }) // ESLint 8
+  return DefaultESLint;
+}
+
+/**
+ * @param {string[]} configFiles - possible config file paths
+ * @param {string} currentDir - current directory to start search
+ * @returns {string} - path to config file
+ */
+async function findConfigPath (configFiles, currentDir = '.') {
+  let configDir = path.resolve(currentDir)
+  while (configDir && configDir !== path.dirname(configDir)) {
+    for (const configFile of configFiles) {
+      const configPath = path.join(configDir, configFile)
+      const config = await tryRequire(configPath)
+      if (configFile !== 'package.json' || config?.eslintConfig) {
+        if (exists(configPath) && isfile(configPath)) { // TODO exists neccessary ?
+          return configPath
+        }
+      }
+    }
+    configDir = path.dirname(configDir);
+  }
+  return ''
+}
+
+/** 
+ * This class and its subclasses are an attempt to smoothen out some of the
+ * workflow in the Linter class. It gets rid of some of the isESLintLegacy ? ... : ...
+ * assignments, although not all. The remaining branching is too closely coupled
+ * to some properties of the Linter class to be easily abstracted away.
+ * @abstract
+ */
+class ESLintLoader {
+  /** 
+   * Searches for ESLint config file types (in order or precedence)
+   * and returns corresponding directory (usually project's root dir)
+   * https://eslint.org/docs/user-guide/configuring#configuration-file-formats
+   * @param {string} currentDir start here and search until root dir
+   * @returns {string} dir containing ESLint config file (empty if not exists)
+   * @abstract
+   */
+  // eslint-disable-next-line no-unused-vars
+  async getConfigPath (currentDir = '.') { throw new Error("Not implemented") }
+  /** @type {import('./io').sanitizeEslintConfig} */
+  // eslint-disable-next-line no-unused-vars
+  sanitizeEslintConfig (configIn, customRuleExample, logger) { throw new Error("Not implemented") }
+  /** @type {import('./io').readEslintConfig} */
+  // eslint-disable-next-line no-unused-vars
+  readEslintConfig(configPath) { throw new Error("Not implemented") }
+}
+
+class ESLint8Loader extends ESLintLoader {
+  async getConfigPath(currentDir = '.') {
+    return findConfigPath([
+      ".eslintrc.js",
+      ".eslintrc.cjs",
+      ".eslintrc.yaml",
+      ".eslintrc.yml",
+      ".eslintrc.json",
+      ".eslintrc",
+      "package.json",
+    ], currentDir)
+  }
+
+  sanitizeEslintConfig (configIn, customRuleExample, logger) {
+    return io.sanitizeEslintConfigLegacy(configIn, customRuleExample, logger)
+  }
+
+  readEslintConfig(configPath) {
+    return io.readEslintConfigLegacy(configPath)
+  }
+}
+
+class ESLint9Loader extends ESLintLoader {
+  async getConfigPath(currentDir = '.') {
+    return findConfigPath([
+      "eslint.config.js",
+      "eslint.config.cjs",
+      "eslint.config.mjs",
+      // the following 3 formats require additional setup by the user as of today,
+      // see https://eslint.org/docs/latest/use/configure/configuration-files#typescript-configuration-files
+      "eslint.config.ts",
+      "eslint.config.mts",
+      "eslint.config.cts",
+    ], currentDir)
+  }
+
+  sanitizeEslintConfig (configIn, customRuleExample, logger) {
+    return io.sanitizeEslintConfig(configIn, customRuleExample, logger)
   }
 
+  readEslintConfig(configPath) {
+    return io.readEslintConfig(configPath)
+  }
+}
+
+class Linter {
+  /** @type {string | undefined} */
+  eslintCmd = "";
+  /** @type {string} */
+  eslintCmdShort = "eslint";
+  /** @type {string | string[]} */
+  eslintCmdFileExpr = "";
+  /** @type {boolean} */
+  isFile = false;
+  /** @type {string} */    
+  help = "";
+  /** @type {string} */
+  debug = "";
+  /** @type {string[]} */
+  flags = [];
+  /** @type {string} */
+  configPath = "";
+  /** @type {object} */
+  configContents = {};
+  /** @type {import("fs").PathLike} */
+  cdsdkPath = path.join(__dirname, "../..");
+  /** @type {import("fs").PathLike} */
+  globalPath = path.join(this.cdsdkPath, "../..");
+  /** @type {boolean} */
+  extendsPlugin = false;
+  /** @type {string[]} */
+  fileExtensions = [];
+  /** @type {string} */
+  pluginPath = "";
+  /** @type {object} */
+  pluginApi = {};
+  /** @type {'global' | 'local'} */
+  lintType = "global";
+  /** @type {object} */
+  ruleOpts = {};
+  /** @type {array} */
+  customRulesOpts = [];
+  /** @type {array} */
+  pluginRules = [];
+  /** @type {ESLintLoader | undefined} */
+  #loader = undefined;
+  get loader () {
+    return this.#loader ??= this.isESLintLegacy
+      ? new ESLint8Loader()
+      : new ESLint9Loader()
+  };
+
   /**
    * Initializes `cds lint` call and generates the required content
    * object for `cds` executable
@@ -59,146 +202,69 @@ class Linter {
   /**
    * Runner for 'cds lint' which is a wrapper for eslint cmd calls
    * that detects and adds the required cmd line arguments
-   * @param {*} args files/globs for eslint to lint
-   * @param {*} options options/flag passed by user
+   * @param {string[]} args files/globs for eslint to lint
+   * @param {{[key: string]: unknown}} options options/flag passed by user
    */
   async lint(args, options) {
     // Check for ESLint (legacy)
     const currentDir = process.cwd();
-    const DefaultESLint = await this._loadEslint(currentDir);
+    const DefaultESLint = await _loadEslint(currentDir)
     this.isESLintLegacy = DefaultESLint.configType === "eslintrc";
-
-    this.eslintCmdOpts = this._sanitizeUserOpts(options);
+    this.eslintCmdOpts = options;  // these should probably be passed on in #runEsLint!
     this.eslintCmdFileExpr = args.length ? args : ["."];
-    if (this.eslintCmdOpts.help) {
-      this._printHelp();
-    } else {
-      // Determine if case "local" or "global" and resolve plugin accordingly
-      await this._getConfigFileAndSetProjectPath(args);
-
-      if (this.pluginPath) {
-        const overwriteRules = checks.hasEslintConfigContent(this.configContents, "rules");
-        // Overwrite rules severities
-        if (overwriteRules) {
-          await this._overwriteRuleSeverities();
-        }
 
-        // Limit to CDS file extensions
-        this._addExtensions();
+    if (this.eslintCmdOpts.help) {
+      this.#printHelp();
+      return
+    }
+    // Determine if case "local" or "global" and resolve plugin accordingly
+    await this.#getConfigFileAndSetProjectPath(args);
+
+    if (this.pluginPath) {
+      const overwriteRules = checks.hasEslintConfigContent(this.configContents, "rules");
+      // Overwrite rules severities
+      if (overwriteRules) {
+        await this.#overwriteRuleSeverities();
       }
 
-      // Run ESLint with collected options
-      try {
-        await this._runEslint(currentDir, DefaultESLint);
-      } catch (err) {
-        term.error(err);
-      }
+      // Limit to CDS file extensions
+      this.#addExtensions();
     }
-  }
-
-  _printHelp() {
-    console.log(this.help.replace(/ \*([^*]+)\*/g, ` ${term.codes.bold}$1${term.codes.reset}`));
-  }
 
-  _sanitizeUserOpts(options) {
-    for (let key in options) {
-      let value = options[key];
-      if (value && typeof value === "string") {
-        value = value.replace(/'/g, "").replace(/"/g, "");
-      }
+    // Run ESLint with collected options
+    try {
+      await this.#runEslint(currentDir, DefaultESLint);
+    } catch (err) {
+      term.error(err);
     }
-    return options;
   }
 
   /**
-   * Searches for ESLint config file types (in order or precedence)
-   * and returns corresponding directory (usually project's root dir)
-   * https://eslint.org/docs/user-guide/configuring#configuration-file-formats
-   * @param {string} currentDir start here and search until root dir
-   * @returns {string} dir containing ESLint config file (empty if not exists)
+   * Prints help message
    */
-  async _getConfigPathLegacy(currentDir = ".") {
-    const configFiles = [
-      ".eslintrc.js",
-      ".eslintrc.cjs",
-      ".eslintrc.yaml",
-      ".eslintrc.yml",
-      ".eslintrc.json",
-      ".eslintrc",
-      "package.json",
-    ];
-    let configDir = path.resolve(currentDir);
-    while (configDir && configDir !== path.dirname(configDir)) {
-      for (let i = 0; i < configFiles.length; i++) {
-        const configPath = path.join(configDir, configFiles[i]);
-        const config = this.safeRequire(configPath)
-
-        if (configFiles[i] !== "package.json" || config?.eslintConfig) {
-          if (exists(configPath) && await isfile(configPath)) {
-            return configPath;
-          }
-        }
-      }
-
-      configDir = path.dirname(configDir);
-    }
-    return "";
-  }
-
-  /**
- * Searches for ESLint config file types (in order or precedence)
- * and returns corresponding directory (usually project's root dir)
- * https://eslint.org/docs/user-guide/configuring#configuration-file-formats
- * @param {string} currentDir start here and search until root dir
- * @returns {string} dir containing ESLint config file (empty if not exists)
- */
-  async _getConfigPath(currentDir = ".") {
-    const configFiles = [
-      "eslint.config.js",
-      "eslint.config.cjs",
-      "eslint.config.mjs"
-    ];
-    let configDir = path.resolve(currentDir);
-    while (configDir && configDir !== path.dirname(configDir)) {
-      for (let i = 0; i < configFiles.length; i++) {
-        const configPath = path.join(configDir, configFiles[i]);
-        const config = this.safeRequire(configPath)
-        if (configFiles[i] !== "package.json" || config?.eslintConfig) {
-          if (exists(configPath) && await isfile(configPath)) { // TODO exists neccessary ?
-            return configPath;
-          }
-        }
-      }
-      configDir = path.dirname(configDir);
-    }
-    return "";
+  #printHelp() {
+    console.log(this.help.replace(/ \*([^*]+)\*/g, ` ${term.codes.bold}$1${term.codes.reset}`));
   }
 
-  _addExtensions() {
+  #addExtensions() {
     // Add CDS file extensions to lint
-    this.fileExtensions = this.pluginApi.getFileExtensions().map((ext) => path.extname(ext));
+    this.fileExtensions = this.pluginApi.getFileExtensions()
+      .map((ext) => path.extname(ext));
     // Only lint file extensions prescribed by plugin
-    this.ignorePatterns = [];
-    this.fileExtensions.forEach((ext) => {
-      this.ignorePatterns.push(`!${ext}`);
-    });
+    this.ignorePatterns = this.fileExtensions
+      .map(ext => `!${ext}`)
   }
 
-  async _runEslint(currentDir, DefaultESLint) {
+  async #runEslint(currentDir, DefaultESLint) {
     try {
-
-      let eslintOpts = {
+      const eslintOpts = this.lintType === "global"
+      ? {
+        cwd: process.cwd(),
+        overrideConfig: {},
+      }
+      : {
         cwd: currentDir,
-        overrideConfig: {
-          ...this.configContents,
-        },
-      };
-
-      if (this.lintType === "global") {
-        eslintOpts = {
-          cwd: process.cwd(),
-          overrideConfig: {},
-        };
+        overrideConfig: {...this.configContents},
       }
 
       if (this.isESLintLegacy) {
@@ -213,7 +279,7 @@ class Linter {
       } else {
         LOG?.("Using flat ESLint configuration");
         const cdsPlugin = require(this.pluginPath)
-        // Exvlude our own apis from plugin to avoid wrapper errors
+        // Exclude our own apis from plugin to avoid wrapper errors
         delete cdsPlugin.configs.recommended?.plugins?.['@sap/cds']
         eslintOpts.overrideConfig = [cdsPlugin.configs.recommended]
       }
@@ -224,17 +290,22 @@ class Linter {
 
       LOG_CONFIG?.(eslintOpts);
 
-      let lintString = `eslint`;
-      if (this.fileExtensions) { lintString += ` --ext "${this.fileExtensions.join(",")}"` }
+      if (LOG) {
+        let lintString = `eslint`;
 
-      for (const ruleOpt of Object.entries(this.ruleOpts)) {
-        lintString += ` --rule ${ruleOpt[0]}:${ruleOpt[1]}`;
-      }
-      if (this.customRulesOpts && this.customRulesOpts.length > 0) {
-        lintString += ` --rulesdir "${this.customRulesOpts}"`
-      }
+        if (this.fileExtensions) {
+          lintString += ` --ext "${this.fileExtensions.join(",")}"`
+        }
 
-      LOG?.(lintString);
+        for (const [name, rule] of Object.entries(this.ruleOpts)) {
+          lintString += ` --rule ${name}:${rule}`
+        }
+        if (this.customRulesOpts && this.customRulesOpts.length > 0) {
+          lintString += ` --rulesdir "${this.customRulesOpts}"`
+        }
+
+        LOG(lintString);
+      }
 
       if (!process.env.isTest) {
         const eslint = new DefaultESLint(eslintOpts);
@@ -252,7 +323,7 @@ class Linter {
           results = results.concat(resultsModel);
         }
 
-        if (results && results.length > 0) {
+        if (results?.length > 0) {
           console.log(formatter.format(results));
         }
       }
@@ -272,31 +343,17 @@ class Linter {
     }
   }
 
-  async _getConfigFileAndSetProjectPath(args) {
-    let input;
+  async #getConfigFileAndSetProjectPath(args) {
     // Get config path
     if (args.length > 0) {
       const firstArg = args[0];
-      if (firstArg === "." || (isfile(firstArg) || isdir(firstArg))) {
-        this.isFile = true;
-      }
-      input = args.join(" ");
-      if (!input) {
-        input = ".";
-      }
+      this.isFile = firstArg === "." || isfile(firstArg) || isdir(firstArg)
     }
-    this.configPath = this.isESLintLegacy
-      ? await this._getConfigPathLegacy(process.cwd())
-      : await this._getConfigPath(process.cwd());
+    this.configPath = await this.loader.getConfigPath(process.cwd())
     if (!this.configPath) {
-      this.lintType === "global";
-      this.configContents = this.isESLintLegacy
-        ? await io.sanitizeEslintConfigLegacy({}, false, LOG)
-        : await io.sanitizeEslintConfig({}, false, LOG);
+      this.configContents = this.loader.sanitizeEslintConfig({}, false, LOG)
     } else {
-      const configContents = this.isESLintLegacy
-        ? await io.readEslintConfigLegacy(this.configPath)
-        : await io.readEslintConfig(this.configPath);
+      const configContents = this.loader.readEslintConfig(this.configPath)
       this.configContents = configContents;
       if (this.isESLintLegacy) {
         this.configContents = await io.sanitizeEslintConfig(configContents, false, LOG);
@@ -313,14 +370,16 @@ class Linter {
                   paths: [path.dirname(this.configPath)],
                 });
                 this.pluginApi = require(this.pluginPath.replace("index.js", "api"));
-              } catch (err) {
+              } catch {
                 // CLI will report (no locally installed plugin)
               }
             }
           }
         }
       } else {
-        const cdsConfig = configContents?.filter(c => c.files?.includes("*.cds"))[0] ?? {}
+        const cdsConfig = Array.isArray(configContents)
+          ? configContents?.find(c => c.files?.includes("*.cds")) ?? {}
+          : configContents
         this.configContents = cdsConfig.files
           ? {
             ...cdsConfig.plugins.configs?.recommended,
@@ -337,7 +396,7 @@ class Linter {
           paths: [this.cdsdkPath],
         });
         this.pluginApi = require(this.pluginPath.replace("index.js", "api"));
-      } catch (err) {
+      } catch {
         // CLI will report (no globally installed plugin)
       }
     }
@@ -345,46 +404,28 @@ class Linter {
     LOG?.(`ESLint CDS plugin resolved: ${this.pluginPath}`);
   }
 
-  async _overwriteRuleSeverities() {
+  async #overwriteRuleSeverities() {
     let configContents = {};
     if (this.configPath) {
       configContents = await io.readEslintConfigLegacy(this.configPath);
     } else {
-      configContents = this.isESLintLegacy
-        ? await io.readEslintConfigLegacy(await this._getConfigPath(this.cdsdkPath))
-        : await io.readEslintConfig(await this._getConfigPath(this.cdsdkPath));
+      configContents = this.loader.readEslintConfig(await this.loader.getConfigPath(this.cdsdkPath))
     }
-    let rules = configContents?.rules || {};
+    const rules = configContents?.rules ?? {};
     // Allow recommended plugin rules in cds-dk to be overwritten
     // by user by adding rule to cmd line (because of precedence)
     const pluginRules = require(this.pluginPath).configs.recommended.rules;
     if (rules && pluginRules) {
-      for (const rule of Object.keys(rules)) {
-        if (typeof rules[rule] !== "undefined" && rules[rule] != pluginRules[rule] ||
-          isfile(path.relative(".", ".eslint", "rules", rule))) {
-          pluginRules[rule] = rules[rule];
-          this.ruleOpts[rule] = rules[rule];
+      for (const [name, rule] of Object.entries(rules)) {
+        if (typeof rule !== "undefined" && rule != pluginRules[name] ||
+          isfile(path.relative(".", ".eslint", "rules", name))) {
+          pluginRules[name] = rule;
+          this.ruleOpts[name] = rule;
           this.pluginRules = pluginRules;
         }
       }
     }
   }
-
-  async _loadEslint(currentDir) {
-    const { loadESLint, ESLint } = require("eslint");
-    const DefaultESLint = loadESLint
-      ? await loadESLint({ cwd: currentDir }) // ESLint 9
-      : new ESLint({ cwd: currentDir }) // ESLint 8
-    return DefaultESLint;
-  }
-
-  safeRequire(module) {
-    try {
-      return require(module)
-    } catch (e) {
-      return {}
-    }
-  }
 }
 
 module.exports = Linter;

package/lib/lint/io.js

@@ -8,7 +8,7 @@ module.exports = {
   /**
    * Reads ESLint config contents from file
    * @param {*} configPath config file path to read from
-   * @returns config file contents
+   * @returns {object[] | object} config file contents
    */
   async readEslintConfigLegacy(configPath) {
     let config;
@@ -19,7 +19,7 @@ module.exports = {
       case ".eslintrc.cjs":
         try {
           config = JSONC.parse((configString.replace(/^module\.exports =/, "")));
-        } catch (err) {
+        } catch {
           config = {};
         }
         break;
@@ -102,7 +102,6 @@ module.exports = {
  * (2) Option "root": false to stop further config merging
  * (3) Add's custom rule example 'no-entity-moo' if requested
  * @param {*} configPath ESLint config file
- * @returns {void}
  */
   async sanitizeEslintConfigLegacy(configIn, customRuleExample = false, logger = console) {
     let configContents = {};
@@ -121,10 +120,8 @@ module.exports = {
         if (!configContents["extends"].includes(extendsValue)) {
           configContents["extends"].push(extendsValue);
         }
-      } else {
-        if (configContents["extends"] !== extendsValue) {
-          configContents["extends"] = [configContents["extends"], extendsValue];
-        }
+      } else if (configContents["extends"] !== extendsValue) {
+        configContents["extends"] = [configContents["extends"], extendsValue];
       }
     } else {
       configContents["extends"] = extendsValue;

package/lib/util/cf.js

@@ -44,7 +44,7 @@ module.exports = new class CfUtil {
         args = args.map(arg => arg.replace(/"/g, '\\"'));
         const cmdLine = `${CF_COMMAND} "${args.join('" "')}"`;
         DEBUG?.time(cmdLine);
-        LOG.debug('>>>', cmdLine);
+        DEBUG?.('>>>', cmdLine);
 
         try {
             const result = await execAsync(cmdLine, {
@@ -146,13 +146,21 @@ module.exports = new class CfUtil {
         }
     }
 
+    #token
     async _getCfAuthorization() {
-        DEBUG?.('getting authorization');
-        try {
-            return (await this.cfRun('oauth-token')).stdout;
-        } catch (err) {
-            throw err.message;
+        if (this.#token) return this.#token
+        if (!this._tokenPromise) {
+            this._tokenPromise = this.cfRun('oauth-token')
+            .then(result => {
+                this.#token = result.stdout
+                return this.#token
+            })
+            .catch(err => {
+                this._tokenPromise = null
+                throw err.message
+            })
         }
+        return this._tokenPromise
     }
 
     async getCfTarget() {
@@ -163,7 +171,10 @@ module.exports = new class CfUtil {
         return target;
     }
 
+    #checkedVersion = false
     async _checkCliVersion() {
+        if (this.#checkedVersion) return
+        this.#checkedVersion = true
         const result = await this.cfRun('-v');
         const version = result?.stdout?.match(/version.*(\d+\.\d+\.\d+)/i)
         if (parseInt(version?.[1]) < CF_CLIENT_MINIMUM_VERSION) {
@@ -358,7 +369,7 @@ Deployment will stop in the near future for Cloud Foundry client versions < ${CF
     async getOrCreateServiceKey(serviceInstance, serviceKeyName, parameters, { silent = false, create = true } = {}) {
         const serviceKey = await this._getServiceKey(serviceInstance, serviceKeyName, false);
         if (serviceKey || !create) {
-            if (serviceKey && !silent) console.log(`getting service key ${bold(serviceKeyName)}`);
+            if (serviceKey && !silent) DEBUG?.(`getting service key ${bold(serviceKeyName)}`);
             return serviceKey;
         }
 
@@ -389,4 +400,4 @@ Deployment will stop in the near future for Cloud Foundry client versions < ${CF
 
         throw `Could not create service key ${bold(serviceKeyName)}`;
     }
-}
+}

package/lib/util/write.js

@@ -88,7 +88,7 @@ function _write (content, /*to:*/ dest, _many) { // NOSONAR
 	}
 
 	file = path.resolve (cds.root,file)
-	// write to the target file, creating parent folders if neccessary
+	// write to the target file, creating parent folders if necessary
 	return mkdirp (dirname(file))
 	.then (()=> fs.writeFile (file, typeof content === 'string' ? content : JSON.stringify (content, null, 2)))
 	.then (()=> dest.foreach && dest.foreach(file))