@sap/eslint-plugin-cds 3.1.2 → 4.0.2

package/lib/rules/sql-cast-suggestion.js

@@ -1,40 +1,64 @@
 'use strict'
 
+const { RULE_CATEGORIES } = require('../constants')
+
 module.exports = {
   meta: {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
+      category: RULE_CATEGORIES.model,
       description: 'Should make suggestions for possible missing SQL casts.',
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/sql-cast-suggestion',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/sql-cast-suggestion',
     },
     type: 'suggestion',
     messages: {
-      missingSQLCast: 'Potential issue - Missing SQL cast for column expression?'
-    }
+      missingSqlCast: 'Potential issue - Missing SQL cast for column expression?'
+    },
+    model: 'parsed',
   },
   create: function (context) {
-    return { view: checkSqlCast }
+    const model = context.getModel()
+    if (!model?.definitions)
+      return
+
+    return function checkAllElementsStartWithLowercase() {
+      for (const defName in model.definitions) {
+        const def = model.definitions[defName]
+        checkSqlCastsInView(defName, def)
+      }
+    }
 
-    function checkSqlCast (v) {
+    function checkSqlCastsInView(defName, def) {
       // TODO: restructure and make more robust (#507)
-      if (v?.query?.SET?.args) {
-        for (const arg of v.query.SET.args) {
-          if (arg?.SELECT) {
-            // Only in UNION cases?
-            for (const each of arg.SELECT.columns || []) {
-              if (each) {
-                const { xpr, cast } = each
-                if (cast && xpr) {
-                  if (!(xpr[0]?.xpr && xpr[0]?.cast)) {
-                    context.report({
-                      messageId: 'missingSQLCast',
-                      node: context.getNode(v)
-                    })
-                  }
-                }
-              }
-            }
+      if (!def?.query?.SET?.args?.length)
+        return
+
+      for (const arg of def.query.SET.args) {
+        if (arg?.SELECT?.columns?.length) {
+          // Only in UNION cases?
+          for (const col of arg.SELECT.columns) {
+            if (col)
+              checkColumn(col)
+          }
+        }
+      }
+
+      function checkColumn(col) {
+        const { xpr, cast } = col
+        if (cast && xpr) {
+          if (!(xpr[0]?.xpr && xpr[0]?.cast)) {
+            // we don't pass a name for the column's location, as it would be used to calculate
+            // endColumn, which is not correct for this expression
+            const loc = col.$location ?
+              context.getLocation('', col, model) :
+              context.getLocation(defName, def, model)
+
+            context.report({
+              messageId: 'missingSqlCast',
+              loc,
+              file: def.$location.file,
+            })
           }
         }
       }

package/lib/rules/sql-null-comparison.js

@@ -2,7 +2,7 @@
 
 const { forEachXprInDefinition } = require('../utils/csnTraversal')
 
-const invalidComparisonOperators = [ '=', '!=', '<>' ]
+const invalidComparisonOperators = [ '=', '<>' ]
 
 module.exports = {
   meta: {
@@ -11,50 +11,54 @@ module.exports = {
       description: 'Ensure SQL comparisons with \'null\' are valid',
       category: 'Model Validation',
       recommended: false,
-      // TODO: Add documentation
-      // url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/sql-null-comparison',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/sql-null-comparison',
     },
     type: 'problem',
     model: 'parsed',
     messages: {
-      nullComparison: `Comparisons against 'null' are always null. Did you mean 'is not null'?`,
+      nullComparison: `Comparisons against 'null' using '=' and '<>' are always null. Did you mean 'is null'/'is not null'?`,
     }
   },
   create(context) {
-    return {
-      view(v) {
-        forEachXprInDefinition(v, checkExpression)
-
-        function checkExpression(xpr, ctx) {
-          if (!xpr || !Array.isArray(xpr))
-            return
-
-          for (let i = 0; i < xpr.length; i++) {
-            if (typeof xpr[i] !== 'object')
-              continue // scalar value, etc.
-
-            if (xpr[i]?.val === null) {
-              const prev = i > 0 && typeof xpr[i-1] === 'string' ? xpr[i-1] : null
-              if (prev && invalidComparisonOperators.includes(prev)) {
-                reportComparison(xpr, ctx)
-                continue
-              }
-              const next = i+1 < xpr.length && typeof xpr[i+1] === 'string' ? xpr[i+1] : null
-              if (next && invalidComparisonOperators.includes(next))
-                reportComparison(xpr, ctx)
-            }
-          }
-        }
+    const model = context.getModel()
+    if (!model?.definitions)
+      return
 
-        function reportComparison(xpr, ctx) {
-          context.report({
-            messageId: 'nullComparison',
-            loc: context.getLocation(null, ctx),
-            file: ctx.$location?.file,
-          })
-        }
+    return function checkSqlNullComparisonsInModel() {
+      for (const defName in model.definitions) {
+        const def = model.definitions[defName]
+        if (def.query || def.projection)
+          forEachXprInDefinition(def, checkExpression)
+      }
+    }
+
+    function checkExpression(xpr, ctx) {
+      if (!xpr || !Array.isArray(xpr))
+        return
 
+      for (let i = 0; i < xpr.length; i++) {
+        if (typeof xpr[i] !== 'object')
+          continue // scalar value, etc.
+
+        if (xpr[i]?.val === null) {
+          const prev = i > 0 && typeof xpr[i-1] === 'string' ? xpr[i-1] : null
+          if (prev && invalidComparisonOperators.includes(prev)) {
+            reportComparison(xpr, ctx)
+            continue
+          }
+          const next = i+1 < xpr.length && typeof xpr[i+1] === 'string' ? xpr[i+1] : null
+          if (next && invalidComparisonOperators.includes(next))
+            reportComparison(xpr, ctx)
+        }
       }
     }
+
+    function reportComparison(xpr, ctx) {
+      context.report({
+        messageId: 'nullComparison',
+        loc: context.getLocation('', ctx),
+        file: ctx.$location?.file,
+      })
+    }
   }
 }

package/lib/rules/start-elements-lowercase.js

@@ -1,63 +1,67 @@
 'use strict'
 
+const { RULE_CATEGORIES } = require('../constants')
+
+const allowedUpperCaseElements = ['ID']
+
 module.exports = {
   meta: {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
+      category: RULE_CATEGORIES.model,
       description: 'Regular element names should start with lowercase letters.',
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/start-elements-lowercase',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/start-elements-lowercase',
     },
     type: 'suggestion',
-    hasSuggestions: true,
     messages: {
-      startLowercase: "Element name '{{entityName}}.{{elementName}}' should start with a lowercase letter.",
-      fixLowercase: 'Start element name with a lowercase letter.'
+      startLowercase: "Element name '{{defName}}:{{elementName}}' should start with a lowercase letter.",
     },
     fixable: 'code',
     model: 'parsed',
   },
   create: function (context) {
-    const sourcecode = context.getSourceCode()
+    const model = context.getModel()
+    if (!model?.definitions)
+      return
 
-    return {
-      element: checkStartLowercase
+    return function checkAllElementsStartWithLowercase() {
+      for (const defName in model.definitions)
+        checkDefinition(defName, model.definitions[defName])
     }
 
-    function checkStartLowercase (e) {
-      const elementName = e.name
-      const entityName = e.parent.name
-      if (elementName && !(entityName.startsWith('localized') || entityName.endsWith('texts'))) {
-        if (elementName.charAt(0) !== elementName.charAt(0).toLowerCase() && !['ID'].includes(elementName)) {
-          if (e.$location && e.$location.file) {
-            const file = e.$location.file
-            const loc = context.getLocation(elementName, e)
-            const fix = (fixer, source = sourcecode) => {
-              const elementNameSanitized = elementName.charAt(0).toLowerCase() + elementName.slice(1)
-              const rangeEnd = source.getIndexFromLoc({
-                line: loc.end.line,
-                column: loc.end.column
-              })
-              const rangeBeg = rangeEnd ? rangeEnd - elementNameSanitized.length : 0
-              return fixer.replaceTextRange([rangeBeg, rangeEnd], elementNameSanitized)
-            }
-            context.report({
-              messageId: 'startLowercase',
-              loc,
-              file,
-              data: {
-                entityName,
-                elementName
-              },
-              suggest: [
-                {
-                  messageId: 'fixLowercase',
-                  fix
-                }
-              ]
-            })
+    function checkDefinition(defName, def) {
+      if (defName.startsWith('localized') || defName.endsWith('texts'))
+        return
+
+      checkElements(def)
+
+      function checkElements(art) {
+        if (art.elements) {
+          for (const elementName in art.elements) {
+            const element = art.elements[elementName]
+            checkStartLowercase(element, elementName)
+            checkElements(element)
           }
         }
       }
+
+      function checkStartLowercase (element, elementName) {
+        if (!element.$location?.file)
+          return // without location, we can't report anything properly
+
+        if (elementName.charAt(0) !== elementName.charAt(0).toLowerCase()
+            && !allowedUpperCaseElements.includes(elementName)) {
+          context.report({
+            messageId: 'startLowercase',
+            loc: context.getLocation(elementName, element),
+            file: element.$location.file,
+            data: {
+              defName,
+              elementName
+            }
+          })
+        }
+      }
     }
   }
 }

package/lib/rules/start-entities-uppercase.js

@@ -1,59 +1,49 @@
 'use strict'
 
+const { RULE_CATEGORIES } = require('../constants')
 const { splitDefName } = require('../utils/rules')
 
 module.exports = {
   meta: {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
+      category: RULE_CATEGORIES.model,
       description: 'Regular entity names should start with uppercase letters.',
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/start-entities-uppercase',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/start-entities-uppercase',
     },
     type: 'suggestion',
-    hasSuggestions: true,
     messages: {
       startUppercase: "Entity name '{{entityName}}' should start with an uppercase letter.",
-      fixUppercase: 'Start entity name with an uppercase letter.'
     },
     fixable: 'code',
     model: 'parsed',
   },
   create(context) {
-    const sourcecode = context.getSourceCode()
+    const model = context.getModel()
+    if (!model?.definitions)
+      return
 
-    return { entity: checkStartsUppercase }
+    return function checkAllEntitiesStartWithUppercase() {
+      for (const defName in model.definitions) {
+        const def = model.definitions[defName]
+        if (def.kind === 'entity') {
+          checkEntityStartsUppercase(defName, def)
+        }
+      }
+    }
 
-    function checkStartsUppercase (e) {
-      if (e.kind !== 'entity')
-        return // workaround for #424
+    function checkEntityStartsUppercase(name, entity) {
+      if (!entity.$location?.file)
+        return // without location, we can't report anything properly
 
-      const entityName = splitDefName(e).name
+      const entityName = splitDefName(entity, name).name
       if (entityName.charAt(0) !== entityName.charAt(0).toUpperCase()) {
-        if (e.$location?.file) {
-          const file = e.$location.file
-          const loc = context.getLocation(entityName, e)
-          const fix = fixer => {
-            const entityNameSanitized = entityName.charAt(0).toUpperCase() + entityName.slice(1)
-            const rangeEnd = sourcecode.getIndexFromLoc({
-              line: loc.end.line,
-              column: loc.end.column
-            })
-            const rangeBeg = rangeEnd ? rangeEnd - entityNameSanitized.length : 0
-            return fixer.replaceTextRange([rangeBeg, rangeEnd], entityNameSanitized)
-          }
-          context.report({
-            messageId: 'startUppercase',
-            loc,
-            file,
-            data: { entityName },
-            suggest: [
-              {
-                messageId: 'fixUppercase',
-                fix
-              }
-            ]
-          })
-        }
+        context.report({
+          messageId: 'startUppercase',
+          loc: context.getLocation(entityName, entity),
+          file: entity.$location.file,
+          data: { entityName },
+        })
       }
     }
   }

package/lib/rules/valid-csv-header.js

@@ -3,6 +3,7 @@
 const cds = require('@sap/cds')
 const { basename, extname } = require('node:path')
 const findFuzzy = require('../utils/findFuzzy')
+const { RULE_CATEGORIES } = require('../constants')
 const SEP = '[,;\t]'
 const EOL = '\\r?\\n'
 
@@ -11,9 +12,9 @@ module.exports = {
     schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
       description: 'CSV files for entities must refer to valid element names.',
-      category: 'Model Validation',
+      category: RULE_CATEGORIES.csv,
       recommended: true,
-      url: 'https://cap.cloud.sap/docs/tools/cds-lint/meta/valid-csv-header',
+      url: 'https://cap.cloud.sap/docs/tools/cds-lint/rules/valid-csv-header',
     },
     severity: 'warn',
     type: 'problem',

package/lib/utils/Cache.js

@@ -1,35 +1,38 @@
 'use strict'
 
-/**
- * Simple cache to store model and any cds calls made in the rule creation
- * api to modify the model
- */
-const cache = new Map()
 
-module.exports = {
+class Cache {
+  #entries = new Map()
+
   has (key) {
-    return cache.has(key)
-  },
+    return this.#entries.has(key)
+  }
   set (key, value) {
-    return cache.set(key, [value, Date.now()])
-  },
+    return this.#entries.set(key, [value, Date.now()])
+  }
   get (key) {
-    return cache.get(key) ? cache.get(key)[0] : undefined
-  },
+    return this.#entries.has(key) ? this.#entries.get(key)[0] : undefined
+  }
   dump () {
     const dump = {}
-    for (const [key, value] of cache.entries()) {
+    for (const [key, value] of this.#entries.entries()) {
       const timestamp = new Date(value[1])
       dump[key] = { key, value: value[0], timestamp }
     }
     return JSON.stringify(dump, null, 2)
-  },
+  }
   remove (key) {
-    if (cache.has(key)) {
-      cache.delete(key)
+    if (this.#entries.has(key)) {
+      this.#entries.delete(key)
     }
-  },
+  }
   clear () {
-    cache.clear()
+    this.#entries.clear()
   }
 }
+
+
+module.exports = {
+  Cache,
+  globalCache: new Cache(),
+}

package/lib/utils/createRule.js

@@ -17,10 +17,10 @@ const fs = require('fs')
 const path = require('path')
 const cds = require('@sap/cds')
 
-const Cache = require('./Cache')
+const { globalCache } = require('./Cache')
 const constants = require('../constants')
 const isConfiguredFileType = require('./isConfiguredFileType')
-const getProjectRootPath = require('./getProjectRootPath')
+const { getProjectRootPath, hasProjectRoots } = require('./projectRootPath')
 const { CdsLintAssertionError } = require('./LintError')
 
 const LOG = cds.debug('lint:plugin')
@@ -48,18 +48,18 @@ module.exports = function createRule(spec) {
         Program: node => {
           const file = context.getFilename()
           if (file !== filePrev) {
-            LOG && LOG(`File: ${context.getFilename()}`)
+            LOG?.(`File: ${context.getFilename()}`)
           }
-          const cdscontext = extendContext(node, context, meta)
-          Cache.set('context', cdscontext)
-          const { isTest, isValidFile, doEnvironmentChecks, doRootModelChecks, showInEditor } = checkEntryCriteria(meta, cdscontext)
+          const cdsContext = extendContext(node, context, meta)
+          globalCache.set('context', cdsContext)
+          const { isTest, isValidFile, doEnvironmentChecks, doRootModelChecks, showInEditor } = checkEntryCriteria(meta, cdsContext)
           switch (meta.model) {
           case 'none':
             if (doEnvironmentChecks) {
-              if (isTest || !Cache.has(`rule:${cdscontext.id}`)) {
-                LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
-                Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
-                createReport(node, cdscontext, meta, create)
+              if (isTest || !globalCache.has(`rule:${cdsContext.id}`)) {
+                LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
+                globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
+                createReport(node, cdsContext, meta, create)
               }
             }
             break
@@ -67,24 +67,24 @@ module.exports = function createRule(spec) {
           case 'inferred':
             if (isValidFile && doRootModelChecks) {
               if (showInEditor) {
-                Cache.remove(`model:${Cache.get('rootpath')}`)
-                Cache.remove(`rule:${cdscontext.id}:${Cache.get('rootpath')}`)
-                Cache.remove(`report:${context.getFilename()}:${context.id}`)
+                globalCache.remove(`model:${globalCache.get('rootpath')}`)
+                globalCache.remove(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`)
+                globalCache.remove(`report:${context.getFilename()}:${context.id}`)
               }
-              if (isTest || showInEditor || !Cache.has(`rule:${cdscontext.id}:${Cache.get('rootpath')}`)) {
-                LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
+              if (isTest || showInEditor || !globalCache.has(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`)) {
+                LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
                 if (!showInEditor) {
-                  Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
+                  globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
                 }
-                createReport(node, cdscontext, meta, create)
+                createReport(node, cdsContext, meta, create)
               } else {
-                if (Cache.has(`report:${context.getFilename()}:${context.id}`)) {
-                  const reports = Cache.get(`report:${context.getFilename()}:${context.id}`)
+                if (globalCache.has(`report:${context.getFilename()}:${context.id}`)) {
+                  const reports = globalCache.get(`report:${context.getFilename()}:${context.id}`)
                   for (const r of Array.from(reports)) {
                     context.report(JSON.parse(r))
                   }
-                  Cache.remove(`report:${context.getFilename()}:${context.id}`)
-                  Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
+                  globalCache.remove(`report:${context.getFilename()}:${context.id}`)
+                  globalCache.set(`rule:${cdsContext.id}:${globalCache.get('rootpath')}`, 'done')
                 }
               }
             }
@@ -92,8 +92,8 @@ module.exports = function createRule(spec) {
 
           default:
             if (isValidFile) {
-              LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
-              createReport(node, cdscontext, meta, create)
+              LOG?.(`  Model: "${meta.model}" Rule: ${context.id}`)
+              createReport(node, cdsContext, meta, create)
             }
             break
           }
@@ -112,15 +112,14 @@ function isRunningWithESLint () {
   return process.argv[1].match(/eslint(\.js)?$/)
 }
 
-function checkEntryCriteria (meta, cdscontext) {
-  const isTest = Cache.has('test')
-  const showInEditor = cdscontext.options.includes('show')
-  const hasProjectRoots = Cache.has(`roots:${Cache.get('rootpath')}`)
-  const isValidFile = isConfiguredFileType(cdscontext.getFilename(), 'FILES')
-  const doRootModelChecks = isTest || (hasProjectRoots && (isRunningWithCDSLint() || isRunningWithESLint()) || showInEditor)
+function checkEntryCriteria (meta, cdsContext) {
+  const isTest = globalCache.has('test')
+  const showInEditor = cdsContext.options.includes('show')
+  const isValidFile = isConfiguredFileType(cdsContext.getFilename(), 'FILES')
+  const doRootModelChecks = isTest || (hasProjectRoots() && (isRunningWithCDSLint() || isRunningWithESLint()) || showInEditor)
   // Lint all env rules independent of any parsed file (i.e. 'cds lint' uses the lintText "" API)
   const doEnvironmentChecks =
-    isTest || (isRunningWithCDSLint() && cdscontext.getFilename() === '<text>')
+    isTest || (isRunningWithCDSLint() && cdsContext.getFilename() === '<text>')
   return { isTest, isValidFile, doRootModelChecks, doEnvironmentChecks, showInEditor }
 }
 
@@ -128,7 +127,6 @@ function setMetaDefaults (meta) {
   meta ??= {}
   meta.severity ??= constants.DEFAULT_RULE_SEVERITY
   meta.docs ??= {}
-  meta.docs.category ??= constants.DEFAULT_RULE_CATEGORY
   meta.model ??= 'parsed'
   return meta
 }
@@ -185,8 +183,10 @@ function createReport (node, cdsContext, meta, create) {
 
 function sanitizeFileLocation (d) {
   let parent = d
-  while (!parent.$location && parent.parent && !parent.parent.definitions) parent = d.parent
-  if (parent.$location) d.$location = parent.$location
+  while (!parent.$location && parent.parent && !parent.parent.definitions)
+    parent = d.parent
+  if (parent.$location)
+    d.$location = parent.$location
   return d
 }
 
@@ -196,11 +196,11 @@ function sanitizeFileLocation (d) {
  * @param meta
  */
 function extendContext (node, context, meta) {
-  if (!Cache.has('test')) {
+  if (!globalCache.has('test')) {
     const filePath = context.getFilename()
     const rootPath = filePath && fs.existsSync(filePath) ? getProjectRootPath(filePath) : ''
     if (rootPath) {
-      Cache.set('rootpath', rootPath)
+      globalCache.set('rootpath', rootPath)
     }
   }
 
@@ -214,15 +214,18 @@ function extendContext (node, context, meta) {
 
   const cdscontext = Object.create(Object.getPrototypeOf(context), descriptors)
   const { parserServices } = context.sourceCode || context
-  cdscontext.getModel =
-    meta.model === 'inferred' ? parserServices.getInferredCsn : parserServices.getParsedCsn
+
+  cdscontext.getModel = meta.model === 'inferred'
+    ? parserServices.getInferredCsn
+    : parserServices.getParsedCsn
+
   cdscontext.getEnvironment = () => {
     const options = context.options
     return options && options[0] && options[0].environment ? options[0].environment : undefined
   }
   cdscontext.getLocation = parserServices.getLocation
   cdscontext.getNode = Object.keys(parserServices).length > 0 ? parserServices.getNode : () => node
-  cdscontext.getRootPath = () => Cache.get('rootpath')
+  cdscontext.getRootPath = () => globalCache.get('rootpath')
   return cdscontext
 
   function reportWrapper(r) {
@@ -232,7 +235,7 @@ function extendContext (node, context, meta) {
         if (!r.file) {
           throw new CdsLintAssertionError(`Rule ${context.id} must return a "file" property in the rule report!`)
         }
-        const file = Cache.get('rootpath') ? resolveFilePath(r.file) : r.file
+        const file = globalCache.get('rootpath') ? resolveFilePath(r.file) : r.file
         if (cdscontext.getFilename() === file) {
           delete r.file
           context.report(r)
@@ -280,11 +283,11 @@ function cacheReport (r, filepath, context, meta) {
   }
   if (r) {
     let reports = new Set()
-    if (Cache.has(`report:${filepath}:${context.id}`)) {
-      reports = Cache.get(`report:${filepath}:${context.id}`)
+    if (globalCache.has(`report:${filepath}:${context.id}`)) {
+      reports = globalCache.get(`report:${filepath}:${context.id}`)
     }
     reports.add(JSON.stringify(r))
-    Cache.set(`report:${filepath}:${context.id}`, reports)
+    globalCache.set(`report:${filepath}:${context.id}`, reports)
   }
 }
 
@@ -295,7 +298,7 @@ function cacheReport (r, filepath, context, meta) {
  */
 function getDisabled (code, sourcecode, line) {
   const listDisabled = []
-  const rules = Cache.get('rules')
+  const rules = globalCache.get('rules')
   const rulesDisabled = Object.keys(rules).reduce((o, key) => ({ ...o, [key]: 'on' }), {})
   if (code) {
     const matches = [...code.matchAll(REGEX_COMMENTS)]
@@ -375,5 +378,5 @@ function getLastLine (code) {
  * @param {string} file
  */
 function resolveFilePath (file) {
-  return path.isAbsolute(file) ? file : path.join(Cache.get('rootpath'), file)
+  return path.isAbsolute(file) ? file : path.join(globalCache.get('rootpath'), file)
 }