@sap/eslint-plugin-cds 2.2.1 → 2.2.2

package/lib/impl/utils/model.js

@@ -1,485 +1,528 @@
-
 /**
  * @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 cache = new Map();
- 
- module.exports = {
-   /**
-    * Simple cache to store model and any cds calls made in the rule creation 
-    * api to modify the model
-    */
-   Cache: {
-     has(key) {
-       return cache.has(key);
-     },
-     set(key, value) {
-       return cache.set(key, [value, Date.now()]);
-     },
-     get(key) {
-       if (cache.get(key)) {
-         return cache.get(key)[0];
-       } else {
-         return;
-       }
-     },
-     dump() {
-       const dump = {};
-       for (const [key, value] of cache.entries()) {
-         const timestamp = new Date(value[1]);
-         dump[key] = { key, value: JSON.stringify(value[0]), timestamp };
-       }
-       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);
-       }
-       return;
-     },
-     clear() {
-       cache.clear();
-       return;
-     },
-   },
- 
-   /**
-    * 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 
-    */
-   updateCache: function (context) {
-     const filePath = context.filePath;
-     const code = context.code;
-     const cds = context.cds;
-     // Set configPath according to filePath
-     let configPath = path.dirname(module.exports.getConfigPath(filePath));
-     if (configPath) {
-       module.exports.Cache.set("projectpath", configPath);
-       module.exports.Cache.set("configpath", configPath);
-     } else {
-       throw new Error("Failed to find an ESLint configuration file!");
-     }
- 
-     // Get cds model for current project
-     module.exports.loadModel(code, configPath, filePath);
- 
-     // Update config path (any files not part of the above model)
-     // Can only do this if model.$sources are known, otherwise no
-     // way to distinguish between 'model' vs 'outsider' files
-     if (cds && cds.model && !cds.model.err) {
-       module.exports.updateConfigPath(code, configPath, filePath);
-       configPath = module.exports.Cache.get("configpath");
-     }
- 
-     // Update cds model on every 'type' event (from the editor)
-     if (
-       module.exports.Cache.has(`file:${filePath}`) &&
-       code !== module.exports.Cache.get(`file:${filePath}`)
-     ) {
-       // Update file contents in Cache
-       module.exports.Cache.set(`file:${filePath}`, code);
-       module.exports.Cache.remove(`done:${configPath}:${context.ruleID}`);
-       context.code = code;
-       context.sourcecode = new SourceCode(code, module.exports.getAST(code));
-       module.exports.updateModel(context);
-     }
- 
-     // Get cds environment (when called from ESLint's ruleTester)
-     if (
-       context.options &&
-       context.options[0] &&
-       context.options[0].environment
-     ) {
-       module.exports.Cache.set(`environment`, context.options[0].environment);
-     }
- 
-     context.configPath = configPath;
-     return context;
-   },
- 
-   /**
-    * Generates dummy AST with just single Program node
-    * @param code Parse file contents
-    * @returns AST
-    */
-   getAST: function (code) {
-     return {
-       type: "Program",
-       body: [],
-       sourceType: "module",
-       tokens: [],
-       comments: [],
-       range: [0, code.length],
-       loc: {
-         start: {
-           line: 1,
-           column: 0,
-         },
-         end: {
-           line: 1,
-           column: 0,
-         },
-       },
-     };
-   },
- 
-   /**
-    * Generates proxy for cds object which adds caching
-    * @param obj cds object
-    * @returns Proxy for cds
-    */
-   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")}`;
-           }
-           return module.exports.Cache.get(prop);
-         }
-         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) {
-         const result = Reflect.apply(target, this, argumentsList);
-         return result;
-       },
-     };
-     return new Proxy(obj, handler);
-   },
- 
-   /**
-    * Converts code with {line, column} to ESLint's 'range' property:
-    * https://eslint.org/docs/developer-guide/working-with-custom-parsers#all-nodes
-    * code.slice(node.range[0], node.range[1]) must be the text of the node!
-    * @param code source code
-    * @param line line number
-    * @param column column number
-    * @returns ESLint range
-    */
-   getRange: function (code, line, column) {
-     let lines;
-     if (typeof code === "string") {
-       lines = SourceCode.splitLines(code);
-     } else {
-       lines = code;
-     }
-     const ranges = [0];
-     lines.forEach((line, i) => {
-       if (i === 0) {
-         ranges[i + 1] = line.length + 1;
-       } else {
-         ranges[i + 1] = ranges[i] + line.length + 1;
-       }
-     });
-     if (line > 1) {
-       return ranges[line - 1] + column;
-     } else {
-       return column;
-     }
-   },
- 
-   /**
-    * 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
-    * @returns Last line index
-    */
-   getLastLine: function (code) {
-     let lines;
-     if (typeof code === "string") {
-       lines = SourceCode.splitLines(code);
-     } else {
-       lines = code;
-     }
-     return lines.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 {SoureLocation} obj
-    * @returns ESLint's 'loc' object
-    */
-   getLocation: function (name, obj) {
-     const loc = {
-       start: { line: 0, column: 0 },
-       end: { line: 1, column: 0 },
-     };
-     if (obj.$location) {
-       const nameloc = obj.$location;
-       // CSN entry with column 0 is equivalent to 'undefined'
-       // It means that the column in that line cannot be determined,
-       // so we assign a value 1 so as not to get a negative value
-       if (nameloc.col === 0) {
-         nameloc.col = 1;
-       }
-       loc.start.column = nameloc.col - 1;
-       loc.start.line = nameloc.line;
-       loc.end.column = nameloc.col - 1 + name.length;
-       loc.end.line = nameloc.line;
-     }
-     return loc;
-   },
- 
-   /**
-    * 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)
-    */
-   getConfigPath: function (currentDir = ".") {
-     const configFiles = [
-       ".eslintrc.js",
-       ".eslintrc.cjs",
-       ".eslintrc.yaml",
-       ".eslintrc.yml",
-       ".eslintrc.json",
-       ".eslintrc",
-       "package.json",
-     ];
-     let configDir = path.resolve(currentDir);
-     while (configDir !== path.resolve(configDir, "..")) {
-       for (let i = 0; i < configFiles.length; i++) {
-         const configPath = path.join(configDir, configFiles[i]);
-         if (fs.existsSync(configPath) && fs.statSync(configPath).isFile()) {
-           return configPath;
-         }
-       }
-       configDir = path.join(configDir, "..");
-     }
-     return "";
-   },
- 
-   /**
-    * Loads LinkedCSN cds model by:
-    * (1) Determining config path if does not exist
-    * (2) Running cds.load('*') to resolve full model
-    * (3) If 2. also fails, passing on the error object
-    * @param code
-    * @returns
-    */
-   loadModel: function (code = "", configPath, filePath) {
-     let compiledModel;
-     let reflectedModel;
-     if (isTest()) {
-       if (code) {
-         try {
-           if (isTest()) {
-             compiledModel = cds.compile.to.csn(code, {
-               sync: true,
-               locations: true,
-             });
-           } else {
-             compiledModel = cds.compile.to.csn([filePath], {
-               sync: true,
-               locations: true,
-             });
-           }
-           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 };
-           }
-         } else {
-           try {
-             compiledModel = cds.compile.to.csn([filePath], {
-               sync: true,
-               locations: true,
-             });
-             if (compiledModel) {
-               reflectedModel = cds.linked(compiledModel);
-             }
-           } catch (err) {
-             reflectedModel = { err };
-           }
-         }
-       } else {
-         reflectedModel = module.exports.Cache.get(`model:${configPath}`);
-       }
-     }
-     // 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")
-               );
-             }
-           });
-         }
-       }
-     }
-     module.exports.Cache.set(`model:${configPath}`, reflectedModel);
-     return;
-   },
- 
-   /**
-    * 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
-    * @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}`)
-       : [];
-     // 'Ousider' files: If a 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, {
-               sync: true,
-               locations: true,
-             });
-           } else {
-             compiledModel = cds.compile.to.csn([filePath], {
-               sync: true,
-               locations: true,
-             });
-           }
-           if (compiledModel) {
-             reflectedModel = cds.linked(compiledModel);
-           }
-         } catch (err) {
-           reflectedModel = { err };
-         }
-       } else {
-         reflectedModel = module.exports.Cache.get(`model:${filePath}`);
-       }
-     }
-     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
-    */
-   updateModel: function (context) {
-     const configPath = context.configPath;
-     const code = context.code;
-     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, {
-             sync: true,
-             locations: true,
-           });
-           if (compiledModel) {
-             reflectedModel = cds.linked(compiledModel);
-           }
-         } catch (err) {
-           reflectedModel = { err };
-         }
-       }
-       module.exports.Cache.set(`model:${configPath}`, reflectedModel);
-     }
-   },
- };
- 
+const fs = require("fs");
+const path = require("path");
+const cds = require("@sap/cds");
+const { SourceCode } = require("eslint");
+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
+   */
+  Cache: {
+    has(key) {
+      return cache.has(key);
+    },
+    set(key, value) {
+      return cache.set(key, [value, Date.now()]);
+    },
+    get(key) {
+      if (cache.get(key)) {
+        return cache.get(key)[0];
+      } else {
+        return;
+      }
+    },
+    dump() {
+      const dump = {};
+      for (const [key, value] of cache.entries()) {
+        const timestamp = new Date(value[1]);
+        dump[key] = { key, value: JSON.stringify(value[0]), timestamp };
+      }
+      return dump;
+    },
+    remove(key) {
+      if (cache.has(key)) {
+        cache.delete(key);
+      }
+      return;
+    },
+    clear() {
+      cache.clear();
+      return;
+    },
+  },
+
+  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 (isValidFile(context.filePath, "model")) {
+      if (
+        process.env["LINT_FLAVOR"] !== "parsed" &&
+        (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 (module.exports.hasFileChanged(context) || process.env["LINT_FLAVOR"] === "parsed") {
+        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("configpath") ||
+      configPath !== module.exports.Cache.get("configpath")
+    ) {
+      update = true;
+    }
+    // Keep track of all config paths visited
+    // - Used in formatter to group lint reports
+    // - Dirnames are used to assign any 'env' lints
+    if (!module.exports.Cache.has("configpaths")) {
+      module.exports.Cache.set("configpaths", [configPath]);
+    } else {
+      const configPaths = module.exports.Cache.get("configpaths");
+      configPaths.push(configPath);
+      module.exports.Cache.set("configpaths", configPaths);
+    }
+    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 Parse file contents
+   * @returns AST
+   */
+  getAST: function (code) {
+    return {
+      type: "Program",
+      body: [],
+      sourceType: "module",
+      tokens: [],
+      comments: [],
+      range: [0, code.length],
+      loc: {
+        start: {
+          line: 1,
+          column: 0,
+        },
+        end: {
+          line: 1,
+          column: 0,
+        },
+      },
+    };
+  },
+
+  /**
+   * Generates proxy for cds object which adds caching
+   * @param obj cds object
+   * @returns Proxy for cds
+   */
+  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("filepath")}`;
+          }
+          return module.exports.Cache.get(prop);
+        }
+        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) {
+        const result = Reflect.apply(target, this, argumentsList);
+        return result;
+      },
+    };
+    return new Proxy(obj, handler);
+  },
+
+  /**
+   * Converts code with {line, column} to ESLint's 'range' property:
+   * https://eslint.org/docs/developer-guide/working-with-custom-parsers#all-nodes
+   * code.slice(node.range[0], node.range[1]) must be the text of the node!
+   * @param code source code
+   * @param line line number
+   * @param column column number
+   * @returns ESLint range
+   */
+  getRange: function (code, line, column) {
+    let lines;
+    if (typeof code === "string") {
+      lines = SourceCode.splitLines(code);
+    } else {
+      lines = code;
+    }
+    const ranges = [0];
+    lines.forEach((line, i) => {
+      if (i === 0) {
+        ranges[i + 1] = line.length + 1;
+      } else {
+        ranges[i + 1] = ranges[i] + line.length + 1;
+      }
+    });
+    if (line > 1) {
+      return ranges[line - 1] + column;
+    } else {
+      return column;
+    }
+  },
+
+  /**
+   * 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
+   * @returns Last line index
+   */
+  getLastLine: function (code) {
+    let lines;
+    if (typeof code === "string") {
+      lines = SourceCode.splitLines(code);
+    } else {
+      lines = code;
+    }
+    return lines.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 {SoureLocation} obj
+   * @returns ESLint's 'loc' object
+   */
+  getLocation: function (name, obj) {
+    const loc = {
+      start: { line: 0, column: 0 },
+      end: { line: 1, column: 0 },
+    };
+    if (obj.$location) {
+      const nameloc = obj.$location;
+      // CSN entry with column 0 is equivalent to 'undefined'
+      // It means that the column in that line cannot be determined,
+      // so we assign a value 1 so as not to get a negative value
+      if (nameloc.col === 0) {
+        nameloc.col = 1;
+      }
+      loc.start.column = nameloc.col - 1;
+      loc.start.line = nameloc.line;
+      loc.end.column = nameloc.col - 1 + name.length;
+      loc.end.line = nameloc.line;
+    }
+    return loc;
+  },
+
+  /**
+   * 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)
+   */
+  getConfigPath: function (currentDir = ".") {
+    const configFiles = [
+      ".eslintrc.js",
+      ".eslintrc.cjs",
+      ".eslintrc.yaml",
+      ".eslintrc.yml",
+      ".eslintrc.json",
+      ".eslintrc",
+      "package.json",
+    ];
+    let configDir = path.resolve(currentDir);
+    while (configDir !== path.resolve(configDir, "..")) {
+      for (let i = 0; i < configFiles.length; i++) {
+        const configPath = path.join(configDir, configFiles[i]);
+        if (fs.existsSync(configPath) && fs.statSync(configPath).isFile()) {
+          return configPath;
+        }
+      }
+      configDir = path.join(configDir, "..");
+    }
+    return "";
+  },
+
+  /**
+   * 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
+   */
+  compileModelFromPath: function (configPath) {
+    let compiledModel;
+    let reflectedModel;
+    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);
+        }
+      } catch (err) {
+        reflectedModel = { err };
+      }
+    }
+    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 };
+    }
+    return reflectedModel;
+  },
+
+  /**
+   * 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
+   */
+  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);
+      } else {
+        files = [];
+      }
+      const dictFiles = module.exports.getDictFiles(configPath, files);
+      module.exports.Cache.set(`dictfiles:${configPath}`, dictFiles);
+    }
+  },
+
+  /**
+   * Creates or updates a dictionary of files/file contents for a given
+   * project path.
+   * @param configPath
+   * @param files
+   * @returns dictFiles
+   */
+  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) {
+    let dictFiles = {};
+    const files = module.exports.Cache.get(`modelfiles:${context.configPath}`);
+    // If incoming file is a 'model' file
+    if (module.exports.isFileInModel(context, files)) {
+      dictFiles = module.exports.getDictFiles(context.configPath, 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 {
+      return true;
+    }
+    return false;
+  },
+
+  /**
+   * Checks whether a file is part of the model for a given project
+   * @param context
+   * @param files
+   * @returns boolean
+   */
+  isFileInModel(context, files) {
+    if (files && files.length > 0 && files.includes(context.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";
+      // Fully resolve model for ESLint's ruleTester
+      if (process.env["RULE_TESTER"]) {
+        flavor = "inferred"
+      }
+      reflectedModel = module.exports.compileModelFromDict(dictFiles, {
+        flavor
+      });
+      module.exports.Cache.set(`model:${context.filePath}`, reflectedModel);
+    }
+  },
+
+};