@sap/eslint-plugin-cds 2.1.1 → 2.3.2

package/lib/impl/utils/model.js

@@ -1,15 +1,20 @@
+/**
+ * @typedef { import("eslint").AST.SourceLocation } SourceLocation
+ */
+
 const fs = require("fs");
 const path = require("path");
 const cds = require("@sap/cds");
 const { SourceCode } = require("eslint");
-const { isTest } = require("./helpers");
+const { isValidFile } = require("./helpers");
+const { isValidEnv } = require("./validate");
 
 const cache = new Map();
 
 module.exports = {
   /**
-   * Simple cache to store model and any cds calls made
-   * in the rule creation api to modify the model
+   * Simple cache to store model and any cds calls made in the rule creation
+   * api to modify the model
    */
   Cache: {
     has(key) {
@@ -33,15 +38,6 @@ module.exports = {
       }
       return dump;
     },
-    getModels() {
-      const models = [];
-      for (const key of cache.keys()) {
-        if (key.startsWith("model:")) {
-          models.push(key.replace("model:", ""));
-        }
-      }
-      return models;
-    },
     remove(key) {
       if (cache.has(key)) {
         cache.delete(key);
@@ -54,12 +50,135 @@ module.exports = {
     },
   },
 
+  hasModelError: function (filePath) {
+    if (module.exports.Cache.has(`model:${filePath}`)) {
+      const model = module.exports.Cache.get(`model:${filePath}`);
+      if (model.err) {
+        return true;
+      }
+    }
+    return false;
+  },
+
+  /**
+   * Checks whether the compiled cds model contains compilation errors which
+   * should only be reported via the 'cds-compile-error' rule
+   * @param cds cds object
+   * @param ruleID rule name
+   * @returns
+   */
+  hasCompilationError: function (context) {
+    const cds = context.cds;
+    const ruleID = context.ruleID;
+    if (
+      cds &&
+      cds.model &&
+      cds.model.err &&
+      cds.model.err.message.startsWith("CDS compilation failed")
+    ) {
+      if (
+        ruleID === "@sap/cds/cds-compile-error" ||
+        ruleID === "cds-compile-error"
+      ) {
+        cds.model.err;
+        return true;
+      }
+    }
+    return false;
+  },
+
+  /**
+   * Takes care of all of the cds modeling:
+   * - Loads the model and assigns relevant files to it
+   * - Updates the model (according to 'type' events in the editor)
+   * - Updates the ESLint configuration file path (i.e. mono-repo with
+   *   multiple models)
+   * @param context
+   * @returns
+   */
+  populateModelAndEnv: function (context) {
+    // Update file and config paths
+    module.exports.Cache.set("filepath", context.filePath);
+
+    // Get CDS reflected model
+
+    if (
+      process.env["LINT_FLAVOR"] !== "parsed" &&
+      isValidFile(context.filePath, "model") &&
+      (module.exports.isNewFile(context.filePath) ||
+        module.exports.isNewConfigPath(context.configPath))
+    ) {
+      module.exports.initModel(context.configPath, context.filePath);
+    }
+    // Trigger model updates for:
+    // - Changed 'model' files
+    // - Any 'outsider' files
+    if (
+      isValidFile(context.filePath, "model") &&
+      module.exports.hasFileChanged(context)
+    ) {
+      module.exports.updateModel(context);
+    }
+
+    // Get cds environment (for internal ruleTester)
+    if (isValidEnv(context)) {
+      module.exports.Cache.set("environment", context.options[0].environment);
+    }
+  },
+
+  /**
+   * Checks whether a file is new or has already been
+   * part of an existing cds model
+   * @param {*} filePath
+   * @returns boolean
+   */
+  isNewFile: function (filePath) {
+    if (!module.exports.Cache.has(`model:${filePath}`)) {
+      return true;
+    } else {
+      return false;
+    }
+  },
+
+  /**
+   * Checks whether the path where the nearest ESLint configuration
+   * file has changed
+   * @param {*} configPath
+   * @returns boolean
+   */
+  isNewConfigPath: function (configPath) {
+    let update = false;
+    if (
+      !module.exports.Cache.has("pluginpath") &&
+      !module.exports.Cache.has("configpath") ||
+      configPath !== module.exports.Cache.get("configpath")
+    ) {
+      update = true;
+    }
+    return update;
+  },
+
+  /**
+   * Gets directory of the nearest ESLint config files associated
+   * Within this plugin, this is equivalent to the cds project's directory
+   * @param filePath
+   * @returns Directory of ESLint config file
+   */
+  loadConfigPath: function (filePath) {
+    let configPath = path.dirname(module.exports.getConfigPath(filePath));
+    if (configPath) {
+      module.exports.Cache.set("projectpath", configPath);
+    } else {
+      throw new Error("Failed to find an ESLint configuration file!");
+    }
+    return configPath;
+  },
+
   /**
    * Generates dummy AST with just single Program node
-   * @param code source code
+   * @param code Parse file contents
    * @returns AST
    */
-  // Types:
   getAST: function (code) {
     return {
       type: "Program",
@@ -81,22 +200,18 @@ module.exports = {
     };
   },
 
-  getSourcecode: function (code) {
-    return new SourceCode(code, module.exports.getAST(code));
-  },
-
   /**
    * Generates proxy for cds object which adds caching
    * @param obj cds object
    * @returns Proxy for cds
    */
-  getProxy: function (obj) {
+  getCDSProxy: function (obj) {
     const handler = {
       get(target, prop, receiver) {
         const value = Reflect.get(target, prop, receiver);
         if (["model", "environment"].includes(prop)) {
           if (prop === "model") {
-            prop = `model:${module.exports.Cache.get("configpath")}`;
+            prop = `model:${module.exports.Cache.get("filepath")}`;
           }
           return module.exports.Cache.get(prop);
         }
@@ -151,10 +266,11 @@ module.exports = {
   },
 
   /**
-   * Uses ESLint's static function splitLines() to split the source code text into an array of lines:
+   * Uses ESLint's static function splitLines() to split the source code text
+   * into an array of lines:
    * https://eslint.org/docs/developer-guide/nodejs-api#sourcecodesplitlines
    * Returns the index of the last line
-   * @param {*} code
+   * @param code
    * @returns Last line index
    */
   getLastLine: function (code) {
@@ -167,24 +283,13 @@ module.exports = {
     return lines.length - 1;
   },
 
-  getLastColumn: function (code, line) {
-    let lines;
-    if (typeof code === "string") {
-      lines = SourceCode.splitLines(code);
-    } else {
-      lines = code;
-    }
-    return lines[line].length - 1;
-  },
-
   /**
    * Generates ESlint's 'loc' from artifact string and cds $location property:
    * https://eslint.org/docs/developer-guide/working-with-rules-deprecated#contextreport
    * @param name
-   * @param obj
+   * @param {SoureLocation} obj
    * @returns ESLint's 'loc' object
    */
-  // Types: AST.SourceLocation
   getLocation: function (name, obj) {
     const loc = {
       start: { line: 0, column: 0 },
@@ -210,8 +315,8 @@ module.exports = {
    * 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 currentDir start here and search until root dir
-   * @returns dir containing ESLint config file
+   * @param {string} currentDir start here and search until root dir
+   * @returns {string} dir containing ESLint config file (empty if not exists)
    */
   getConfigPath: function (currentDir = ".") {
     const configFiles = [
@@ -233,174 +338,211 @@ module.exports = {
       }
       configDir = path.join(configDir, "..");
     }
-    throw new Error("Failed to find an ESLint configuration file!");
+    return "";
   },
 
   /**
-   * Loads LinkedCSN by:
-   * (1) Determining config path if does not exist
-   * (2) Running cds.load('*') to resolve full model
-   * (3) If 2. also fails, pass on error object
-   * @param code
-   * @returns
+   * Compiles reflected model for a given project directory
+   * Note, that to support monorepos, the cache (in @sap/cds) must be cleared
+   * to also change the roots with every changed configPath.
+   * @param configPath
+   * @returns reflected model
    */
-  loadModel: function (code = "", configPath, filePath) {
+  compileModelFromPath: function (configPath) {
     let compiledModel;
     let reflectedModel;
-    if (isTest()) {
-      if (code) {
-        try {
-          if (isTest()) {
-            compiledModel = cds.compile.to.csn(code);
-          } else {
-            compiledModel = cds.compile.to.csn([filePath]);
-          }
-          if (compiledModel) {
-            reflectedModel = cds.linked(compiledModel);
-          }
-        } catch (err) {
-          reflectedModel = { err };
-        }
-      }
-    } else {
-      // Loads new model (must clear cache in order to be able to change root with every configPath)
-      cds.resolve.cache = {};
-      const roots = cds.resolve("*", { root: configPath });
-      if (
-        !module.exports.Cache.has(`model:${configPath}`) &&
-        configPath !== filePath
-      ) {
-        if (roots) {
-          try {
-            compiledModel = cds.load(roots, {
-              cwd: configPath,
-              sync: true,
-              locations: true,
-            });
-            if (compiledModel) {
-              reflectedModel = cds.linked(compiledModel);
-            }
-          } catch (err) {
-            reflectedModel = { err };
-          }
+    cds.resolve.cache = {};
+    const roots = cds.resolve("*", { root: configPath });
+    if (roots) {
+      try {
+        compiledModel = cds.load(roots, {
+          cwd: configPath,
+          sync: true,
+          locations: true,
+        });
+        if (compiledModel) {
+          reflectedModel = cds.linked(compiledModel);
         }
-      } else {
-        reflectedModel = module.exports.Cache.get(`model:${configPath}`);
+      } catch (err) {
+        reflectedModel = { err };
       }
     }
-    // Cache model files
-    if (
-      reflectedModel &&
-      reflectedModel.$sources &&
-      !module.exports.Cache.has(`modelfiles:${configPath}`)
-    ) {
-      const files = reflectedModel.$sources;
-      if (files && files.length > 0) {
-        module.exports.Cache.set(`modelfiles:${configPath}`, files);
-        if (!isTest()) {
-          files.forEach((file) => {
-            if (!module.exports.Cache.has(`file:${file}`)) {
-              module.exports.Cache.set(
-                `file:${file}`,
-                fs.readFileSync(file, "utf8")
-              );
-            }
-          });
-        }
+    return reflectedModel;
+  },
+
+  /**
+   * Compiles reflected model for a dictionary of files/file contents
+   * Note, that this method is used to account for editor type events
+   * and hence, model updates.
+   * WARNING: Only use if cds roots are defined prior to this step
+   * and the dictionary is complete (the compiler will not resolve
+   * any missing files)!
+   * @param dictFiles
+   * @returns reflected model
+   */
+  compileModelFromDict: function (dictFiles, options) {
+    let reflectedModel;
+    try {
+      const compiledModel = cds.compile(dictFiles, {
+        sync: true,
+        locations: true,
+        ...options,
+      });
+      if (compiledModel) {
+        reflectedModel = cds.linked(compiledModel);
       }
+    } catch (err) {
+      reflectedModel = { err };
     }
-    module.exports.Cache.set(`model:${configPath}`, reflectedModel);
-    return;
+    return reflectedModel;
   },
 
   /**
-   * Updates configPath (usually ESLint's configPath) for a given project if:
-   * - File is not part of the compiled project model
-   * It then defaults to filePath and compiles the file stand-alone
-   * @param code
+   * Initiates and stores new reflected model, it's corresponding project path,
+   * as well as a list and dictionary of files comprising the model.
    * @param configPath
    * @param filePath
    */
-  updateConfigPath: function (code, configPath, filePath) {
-    let compiledModel;
-    let reflectedModel;
-    const files = module.exports.Cache.has(`modelfiles:${configPath}`)
-      ? module.exports.Cache.get(`modelfiles:${configPath}`)
-      : [];
-    // If file is not part of cds model for this dir, it is compiled individually
-    if (!files || !files.includes(filePath)) {
-      module.exports.Cache.set(`configpath`, filePath);
-      module.exports.Cache.set(`modelfiles:${filePath}`, [filePath]);
-      module.exports.Cache.set(
-        `file:${filePath}`,
-        fs.readFileSync(filePath, "utf8")
-      );
-      if (!module.exports.Cache.has(`model:${filePath}`)) {
-        try {
-          if (isTest()) {
-            compiledModel = cds.compile.to.csn(code);
-          } else {
-            compiledModel = cds.compile.to.csn([filePath]);
-          }
-          if (compiledModel) {
-            reflectedModel = cds.linked(compiledModel);
-          }
-        } catch (err) {
-          reflectedModel = { err };
-        }
+  initModel: function (configPath, filePath) {
+    module.exports.Cache.set("configpath", configPath);
+    const reflectedModel = module.exports.compileModelFromPath(configPath);
+    let files;
+    if (reflectedModel && !reflectedModel.err && reflectedModel.$sources) {
+      module.exports.Cache.set(`model:${filePath}`, reflectedModel);
+      files = reflectedModel.$sources;
+      if (files) {
+        module.exports.Cache.set(`modelfiles:${configPath}`, files);
+        files.forEach(file => {
+          module.exports.Cache.set(`model:${file}`, reflectedModel);
+        })
       } else {
-        reflectedModel = module.exports.Cache.get(`model:${filePath}`);
+        files = [];
+      }
+      const dictFiles = module.exports.getDictFiles(configPath, files);
+      module.exports.Cache.set(`dictfiles:${configPath}`, dictFiles);
+    }
+  },
+
+  initModelRuleTester: function (filePath) {
+    const configPath = path.dirname(filePath);
+    module.exports.Cache.set("configpath", configPath);
+    let files = fs.readdirSync(configPath);
+    const modelfiles = [];
+    files.forEach((file) => {
+      const filePath = path.join(configPath, file);
+      if (isValidFile(filePath, "model")) {
+        modelfiles.push(filePath);
       }
+    });
+    module.exports.Cache.set(`modelfiles:${configPath}`, files);
+    const dictFiles = module.exports.getDictFiles(configPath, modelfiles);
+    module.exports.Cache.set(`dictfiles:${configPath}`, dictFiles);
+    const compiledModel = module.exports.compileModelFromDict(dictFiles);
+    let reflectedModel;
+    if (compiledModel) {
+      reflectedModel = cds.linked(compiledModel);
+    }
+    if (reflectedModel) {
+      module.exports.Cache.set(`model:${filePath}`, reflectedModel);
     }
-    module.exports.Cache.set(`model:${filePath}`, reflectedModel);
   },
 
   /**
-   * Updates compiled model (CSN) by:
-   * (1) Getting model files from CSN.$sources (cached)
-   * (2) Running compile.to.csn with updated sources dictionary
-   * @param code
+   * Creates or updates a dictionary of files/file contents for a given
+   * project path.
+   * @param configPath
+   * @param files
+   * @returns dictFiles
    */
-  updateModel: function (code, configPath) {
-    let compiledModel;
-    let reflectedModel;
-    let files = [];
-    const dictFiles = {};
-    if (module.exports.Cache.has(`modelfiles:${configPath}`)) {
-      files = module.exports.Cache.get(`modelfiles:${configPath}`);
-      if (files.length > 1) {
-        files.forEach((file) => {
-          if (module.exports.Cache.has(`file:${file}`)) {
-            dictFiles[file] = module.exports.Cache.get(`file:${file}`);
-          } else {
-            dictFiles[file] = fs.readFileSync(file, "utf8");
-          }
-        });
-        try {
-          /** Ignore typings here as the options 'sync' and 'cwd'
-           *  should not be visible in the public api! */
-          compiledModel = cds.compile.to.csn(dictFiles, {
-            sync: true,
-            locations: true,
-          });
-          if (compiledModel) {
-            reflectedModel = cds.linked(compiledModel);
-          }
-        } catch (err) {
-          reflectedModel = { err };
-        }
-      } else if (files.length === 1) {
-        try {
-          compiledModel = cds.compile.to.csn(code);
-          if (compiledModel) {
-            reflectedModel = cds.linked(compiledModel);
-          }
-        } catch (err) {
-          reflectedModel = { err };
+  getDictFiles: function (configPath, files=[]) {
+    let dictFiles = {};
+    if (module.exports.Cache.has(`dictfiles:${configPath}`)) {
+      dictFiles = module.exports.Cache.get(`dictfiles:${configPath}`);
+    } else {
+      files.forEach((file) => {
+        if (module.exports.Cache.has(`file:${file}`)) {
+          dictFiles[file] = module.exports.Cache.get(`file:${file}`);
+        } else {
+          dictFiles[file] = fs.readFileSync(file, "utf8");
         }
+      });
+    }
+    return dictFiles;
+  },
+
+  /**
+   * Determines whether an incoming file has changed contents
+   * @param context cds context object
+   * @returns boolean
+   */
+  hasFileChanged: function (context) {
+    const files = module.exports.Cache.get(`modelfiles:${context.configPath}`);
+    const dictFiles = module.exports.getDictFiles(context.configPath, files);
+    // If incoming file is a 'model' file
+    if (module.exports.isFileInModel(context, files)) {
+      // Only update on detected changes
+      if (dictFiles[context.filePath] !== context.code) {
+        dictFiles[context.filePath] = context.code;
+        module.exports.Cache.set(`dictfiles:${context.configPath}`, dictFiles);
+        return true;
+      }
+    } else {
+      if (dictFiles[context.filePath] !== context.code) {
+        return true;
       }
-      module.exports.Cache.set(`model:${configPath}`, reflectedModel);
     }
-    return;
+    return false;
+  },
+
+  /**
+   * Checks whether a file is part of the model for a given project
+   * @param context
+   * @param files
+   * @returns boolean
+   */
+  isFileInModel(filePath, files) {
+    if (files && files.length > 0 && files.includes(filePath)) {
+      return true;
+    }
+    return false;
+  },
+
+  /**
+   * Updates and stores reflected model on file changes. Model compilation
+   * us handled separately for 'model' files (part of model) and 'outsider'
+   * files.
+   * @param context cds context object
+   */
+  updateModel: function (context) {
+    let reflectedModel;
+    let files = module.exports.Cache.get(`modelfiles:${context.configPath}`);
+    if (!files) {
+      files = [];
+    }
+    // If incoming file is a 'model' file
+    if (
+      !process.env["LINT_FLAVOR"] === "parsed" ||
+      module.exports.isFileInModel(context, files)
+    ) {
+      const dictFiles = module.exports.Cache.get(
+        `dictfiles:${context.configPath}`
+      );
+      dictFiles[context.filePath] = context.code;
+      reflectedModel = module.exports.compileModelFromDict(dictFiles, {
+        flavor: "inferred",
+      });
+      files.forEach((file) => {
+        module.exports.Cache.set(`model:${file}`, reflectedModel);
+      });
+    } else {
+      // If incoming file is an 'outsider' file
+      const dictFiles = {};
+      dictFiles[context.filePath] = context.code;
+      let flavor = "parsed";
+      reflectedModel = module.exports.compileModelFromDict(dictFiles, {
+        flavor,
+      });
+      module.exports.Cache.set(`model:${context.filePath}`, reflectedModel);
+    }
   },
 };