feat: relative cache support

[cs6cs6]

…velopers or into ci machines.

Summary

Related Issues

[linux-foundation-easycla]

The committers listed above are authorized under a signed CLA.

• ✅ login: cs6cs6 (5f1c068, 1594416, 4b483a9, bf15419, a09bbcf, 0b7542c, 0b5795c, 9ff6720, c4597a7, 88af1e7, 1da9c6b)

[eslint-github-bot]

Hi @cs6cs6!, thanks for the Pull Request

The pull request title isn't properly formatted. We ask that you update the pull request title to match this format, as we use it to generate changelogs and automate releases.

• The commit message tag wasn't recognized. Did you mean "docs", "fix", or "feat"?
• There should be a space following the initial tag and colon, for example 'feat: Message'.
• The first letter of the tag should be in lowercase

To Fix: You can fix this problem by clicking 'Edit' next to the pull request title at the top of this page.

Read more about contributing to ESLint here

[cs6cs6]

Hello. How do I draw attention to this PR? I believe I am only awaiting feedback.

[nzakas]

Thanks for putting this together and sorry for the delay -- we are a small team and have a lot to do.

Overall I think this looks good. I left some feedback throughout.

[nzakas]

This is looking good. Left comments throughout on areas we can clarify and clean up.

[nzakas]

How is this changing the ConfigArray? This setting is at the CLI level, not at the config level, so there shouldn't be any changes to the ConfigArray.

[cs6cs6]

The object itself, along with all of its properties (set or not) is rolled into the computed hash code that goes into the file. So, simply by adding a new property, the hash computed of the object changes, even if that property is deliberately set to create no change in behavior.

[mdjermanovic]

I think we should clarify what we mean by the current working directory that will be passed to the LintResultCache class. Is it process.cwd(), or cwd that was passed to ESLint/FlatESLint constructor? In the latter case, is there a way to pass cwd to file-entry-cache or we could end up calculating paths differently?

[mdjermanovic]

Another question is does file-entry-cache support relative paths? All tests seem to be with absolute paths:

https://github.com/jaredwray/file-entry-cache/blob/master/test/specs/cache.js

[cs6cs6]

It will. I am just going to push up the code review sometime today. I have a complete and working branch on this task, and most of your questions wuold be resolved by the code review/better answered looking at the code changes.

[nzakas]

Don't forget to answer the question regarding what cwd is from the previous comment.

[cs6cs6]

Is it process.cwd(), or cwd that was passed to ESLint/FlatESLint constructor?

When created in cli-engine.js, it's options.cwd. It is also referred to as 'cwd' in the code.
When created in flat-eslint.js, it's processedOptions.cwd.

[fasttime]

Do you think that cwd would be a better base location to store relative paths?

Do you mean in all cases? If so, the answer is no. I think it makes the most sense to have it relative to the cache file when --cache-location is not used.

I'm asking because when --cache-location is not set, the cache file location should be already cwd. I think the advantage of keeping the paths relative to the cache file directory is that they don't change if the current directory changes, for example in a monorepo. Do you have a particular scenario in mind where storing paths relative to cwd would be advantageous?

[mdjermanovic]

Yeah, as @fasttime noticed, when --cache-location is not used, the cache file defaults to .eslintcache in cwd. So if the logic would be to use the location of the cache file when --cache-location is not used, and cwd when --cache-location is used, then it's basically the same as - always use cwd.

[mdjermanovic]

For a use case where a monorepo has a single eslint cache file that's checked-in and shared between developers, and developers work and run eslint in project subdirectories (using --cache-location with a path to the single cache file somewhere in the root), I believe the only solution would be that the paths are relative to the cache file directory.

For other use cases, e.g., when the cache file is generated in CI and shared between CI runs (I believe that was the original use case in eslint/eslint#16493?), I'm not sure, it depends on where and how the cache file will be stored and used. It might be good to get more input from people requesting this feature.

[nzakas]

I think we should just make a decision and see what happens when people test with it. This PR has been open since October of last year, and it seems like this is the last thing to decide on, so I don't think there's value in drawing this out further when we have a binary decision to make.

So I'd like to propose that we say the paths are always relative to location of the .eslintcache file.

[mdjermanovic]

So I'd like to propose that we say the paths are always relative to location of the .eslintcache file.

I agree.

[nzakas]

@cs6cs6 there were still some outstanding requests for you to consider here. Are you still working on this?

[nzakas]

@cs6cs6 just checking back to see if you intend on finishing this up?

[cs6cs6]

Hello, I apologize for the delay. I am working on this today.

[jaredwray]

@nzakas and @mdjermanovic - I released v9.1.0 of file-entry-cache it does what you are thinking but with one minor change. You need to specify the currentWorkingDir instead of just setting relativePath = true. The reason for this is that we are now using that path to handle the file keys correctly. You can see it working here with the example @mdjermanovic put together. https://stackblitz.com/edit/stackblitz-starters-npqlt7?file=package.json,test.js

const path = require('node:path');
const fileEntryCache = require('file-entry-cache');

const cacheFileLocation = path.resolve(__dirname, '.eslintcache');
const useChecksum = true;
const currentWorkingDirectory = __dirname;

const cache = fileEntryCache.create(
  cacheFileLocation,
  undefined,
  useChecksum,
  currentWorkingDirectory
);

Thanks for the patience on this and I believe this should un-block you with this where you want to rename the working folder and still use the cache.

[mdjermanovic]

@jaredwray thanks for the new versions!

Question: how to store file locations relative to the cache file?

I tried the following:

const fileEntryCache = require("file-entry-cache");
const path = require("node:path");

const cacheFileDir = path.resolve(__dirname, "cache");

const cacheFileLocation = path.resolve(cacheFileDir, ".eslintcache");
const useChecksum = true;
const currentWorkingDirectory = cacheFileDir;

const cache = fileEntryCache.create(
    cacheFileLocation,
    undefined,
    useChecksum,
    currentWorkingDirectory
);

const filePath = path.resolve(__dirname, "src", "my-file.js"); // exists
const fileDescriptor = cache.getFileDescriptor(filePath);
fileDescriptor.meta.results = { foo: "bar" };

cache.reconcile();

cache/.eslintcache cache file is successfully created, but it seems empty:

[{}]

[jaredwray]

@jaredwray thanks for the new versions!

Question: how to store file locations relative to the cache file?

I tried the following:

const fileEntryCache = require("file-entry-cache");
const path = require("node:path");

const cacheFileDir = path.resolve(__dirname, "cache");

const cacheFileLocation = path.resolve(cacheFileDir, ".eslintcache");
const useChecksum = true;
const currentWorkingDirectory = cacheFileDir;

const cache = fileEntryCache.create(
    cacheFileLocation,
    undefined,
    useChecksum,
    currentWorkingDirectory
);

const filePath = path.resolve(__dirname, "src", "my-file.js"); // exists
const fileDescriptor = cache.getFileDescriptor(filePath);
fileDescriptor.meta.results = { foo: "bar" };

cache.reconcile();

cache/.eslintcache cache file is successfully created, but it seems empty:

[{}]

Do you have a project that I can see with this? I believe the paths are causing issues on this and one thing to look at is that with using the currentWorkingDirectory you need to do relative path to the files. An example of this is the unit test here:

https://github.com/jaredwray/file-entry-cache/blob/0be8ea67cd55cafa277ac199a62c3f087396d517/test/relative.js#L71

[mdjermanovic]

I believe the paths are causing issues on this and one thing to look at is that with using the currentWorkingDirectory you need to do relative path to the files. An example of this is the unit test here:

https://github.com/jaredwray/file-entry-cache/blob/0be8ea67cd55cafa277ac199a62c3f087396d517/test/relative.js#L71

In the unit test, all paths are absolute, as they're produced by path.resolve()?

[mdjermanovic]

Here a stackblitz repro:

https://stackblitz.com/edit/stackblitz-starters-eh4ubs?file=test.js

[jaredwray]

Here a stackblitz repro:

https://stackblitz.com/edit/stackblitz-starters-eh4ubs?file=test.js

The fix for this is to point at the current working directory of where the file is instead of the cache directory:

https://stackblitz.com/edit/stackblitz-starters-ikrcmu?file=test.js,cache%2F.eslintcache

const currentWorkingDirectory = path.resolve(__dirname, 'src');

The currentWorkingDirectory needs to point where the files are that we have the description on as it is using relative paths.

[jaredwray]

@mdjermanovic, @nzakas - I wanted to update you that we have released a new major version of file-entry-cache. This has some significant updates but should work better for you. I have been looking through your code and it looks like the big thing you need to handle is when a folder gets renamed you want to track files in it without resetting them.

Read the new docs here: https://www.npmjs.com/package/file-entry-cache

I would recommend that you continue to do absolute paths like you have done before. We do support relative paths but I think the goal here is to make it as easy as possible.

When a folder changes you can now call renameAbsolutePathKeys(oldPath: string, newPath: string): void which will do the rename in the memory cache and then just call reconcile() which will save the updated to cache.

const fileEntryCache = require('file-entry-cache');
const cache = fileEntryCache.create('.eslintcache', undefined, true);
const fileEntry = cache.getFileDescriptor(path.resolve(__dirname, './src/test-file.js');
console.log(fileEntry.changed); // true, first time run
cache.reconcile(); // save to the file cache
// rename the `src` folder as an example
const oldPath = path.resolve(__dirname, './src');
const newPath = path.resolve(__dirname, './src2');
fs.renameSync(oldPath, newPath);
// update all the keys
cache.renameAbsolutePathKeys(oldPath, newPath);
// they are now updated in memory, update the disk cache
cache.reconcile();

There are more updates around this with a faster caching layer and more robust features that you can read about at the README: https://github.com/jaredwray/cacheable/blob/main/packages/file-entry-cache/README.md

Please let me know how I can help to make this happen. If you want to do a video conference just let me know. https://fantastical.app/jaredwray/30-minute-sync

[mdjermanovic]

When a folder changes you can now call renameAbsolutePathKeys(oldPath: string, newPath: string): void which will do the rename in the memory cache and then just call reconcile() which will save the updated to cache.

A problem with this is that we don't know oldPath. The cache file was created/updated in a previous run, possibly on a different machine, and new run doesn't have the context of the previous run. Also, in a use case where the cache file is checked into source control and shared between developers, there could be multiple old paths.

[mdjermanovic]

To clarify, the example with renaming the directory was made to simplify the repro. The use case this RFC targets is when the cache file is created/updated on one machine, and then should be used on another machine where the project is possibly cloned into a different path so the absolute paths of files are different.

https://github.com/cs6cs6/eslint_rfc/blob/feat/16493_relative_cache/designs/2023-relative-cache/README.md

We think the only way to achieve this is by storing relative instead of absolute paths in the cache file.

[mdjermanovic]

The fix for this is to point at the current working directory of where the file is instead of the cache directory:

https://stackblitz.com/edit/stackblitz-starters-ikrcmu?file=test.js,cache%2F.eslintcache

const currentWorkingDirectory = path.resolve(__dirname, 'src');

The currentWorkingDirectory needs to point where the files are that we have the description on as it is using relative paths.

In this example, the cache key for the file is "/my-file.js". But, if we do this for every file, then all files with the same filename would have the same cache key? For example, src/my-file.js and test/my-file.js would both have "/my-file.js" as the cache key and therefore have the same cache entry?

[nzakas]

@mdjermanovic @jaredwray at this point it seems better to open an issue to contain this back-and-forth instead of continuing on in this RFC. What do you think?

[jaredwray]

@mdjermanovic @jaredwray at this point it seems better to open an issue to contain this back-and-forth instead of continuing on in this RFC. What do you think?

Who can I work with on this to get it completed? More than happy to schedule a time as with the new file-entry-cache this should be really easy and less work.

[nzakas]

I think @mdjermanovic is the best person to work with.

[mdjermanovic]

Here's an issue on the file-entry-cache repo for further discussion: jaredwray/cacheable#914

[jaredwray]

@cs6cs6 @nzakas - Just FYI that we will have this released in September. jaredwray/cacheable#914

[nzakas]

@jaredwray thanks! @mdjermanovic can you take a look and make sure it's doing what you expect?

[mdjermanovic]

@mdjermanovic can you take a look and make sure it's doing what you expect?

Yes, I left a comment in the related issue: jaredwray/cacheable#914

[jaredwray]

@nzakas and @mdjermanovic - we are really close on this. jaredwray/cacheable#914 (comment)

[mdjermanovic]

A couple of differences I noticed while testing file-entry-cache v11 (v11.0.0-beta.3, but I assume this behavior will stay the same in v11.0.0 final) that we'll need to address when upgrading from file-entry-cache v8:

1. Passing the full absolute path of the cache file as the first argument (cacheId parameter) and undefined as the second argument (cacheDirectory parameter) to fileEntryCache.create() doesn't work in v11. We'll need to split it into the file name and directory path, and pass them separately as the first and the second argument.
2. Custom data in file descriptors must be stored in meta.data property. Other properties are not persisted in the cache file. ESLint currently stores custom data in meta.results and meta.hashOfConfig properties, so we'll need to change this.

None of these differences seem problematic, but we'll need to make a few small changes in the code.

[mdjermanovic]

I'm assuming this will also be a new ESLint constructor option, so we should mention that as well.

[jaredwray]

@mdjermanovic - I can make this work in v11.

Custom data in file descriptors must be stored in meta.data property. Other properties are not persisted in the cache file. ESLint currently stores custom data in meta.results and meta.hashOfConfig properties, so we'll need to change this.

[jaredwray]

@mdjermanovic - on fileEntryCache.create() have you tried using fileEntryCache.createFromFile() as I think that would work with a single param.

[mdjermanovic]

@mdjermanovic - I can make this work in v11.

Custom data in file descriptors must be stored in meta.data property. Other properties are not persisted in the cache file. ESLint currently stores custom data in meta.results and meta.hashOfConfig properties, so we'll need to change this.

I think it isn't necessary. We can update ESLint to store custom data in the property that the file-entry-cache API provides for it (meta.data), thus avoiding the risk of collision with meta properties that you might want to add in the future for different purposes.

None of differences described in #114 (comment) seem problematic, I just wanted to mention them as a reminder for when we update the file-entry-cache dependency to v11.

[mdjermanovic]

on fileEntryCache.create() have you tried using fileEntryCache.createFromFile() as I think that would work with a single param.

I got fileEntryCache.create() working as we need in file-entry-cache v11.0.0-beta.5. Once the final v11.0.0 is released, I'll post here an example of how to use it to make cache files portable.

[mdjermanovic]

file-entry-cache v11.0.0 has been released.

Here's an example of how to achieve portable cache files with paths relative to the cache file location.

my-project/
├── cache/
│   └── .eslintcache      <-- cache file
└── src/
    └── a.js              <-- file we want to track in the cache file

// write.js

const path = require('node:path');
const fileEntryCache = require('file-entry-cache'); // v11.0.0

// cache file is cache/.eslintcache
const cacheDirectory = path.resolve(__dirname, 'cache');
const cacheFilename = '.eslintcache';

const cache = fileEntryCache.create(
  cacheFilename,
  cacheDirectory,
  {
    useCheckSum: true, // --cache-strategy content
    cwd: cacheDirectory, // this means relative file paths should be treated as relative to the cache file location
  }
);

const fullFilePath = path.resolve(__dirname, "src/a.js");

// path relative to the cache file location, normalized to posix
const filePath = path.relative(cacheDirectory, fullFilePath).replace(/\\/gu, "/");

const fileDescriptor = cache.getFileDescriptor(filePath);

// store custom data in the cache entry
fileDescriptor.meta.data = { foo: "bar" };

// save cache
cache.reconcile();

// read.js

const path = require('node:path');
const fileEntryCache = require('file-entry-cache'); // v11.0.0

// cache file is cache/.eslintcache
const cacheDirectory = path.resolve(__dirname, 'cache');
const cacheFilename = '.eslintcache';

const cache = fileEntryCache.create(
  cacheFilename,
  cacheDirectory,
  {
    useCheckSum: true, // --cache-strategy content
    cwd: cacheDirectory, // this means relative file paths should be treated as relative to the cache file location
  }
);

const fullFilePath = path.resolve(__dirname, "src/a.js");

// path relative to the cache file location, normalized to posix
const filePath = path.relative(cacheDirectory, fullFilePath).replace(/\\/gu, "/");

const fileDescriptor = cache.getFileDescriptor(filePath);

console.log(fileDescriptor);

/*

{
  key: '../src/a.js',
  changed: false, // <-- cache hit 👍
  meta: {
    size: 3,
    mtime: 1760181555466,
    hash: 'acbd18db4cc2f85cedef654fccc4a4d8',
    data: { foo: 'bar' }
  }
}

*/

[mdjermanovic]

@cs6cs6 now that this is unblocked, would you like to continue working on this RFC?

[mdjermanovic]

Closing due to inactivity. Thanks for your work on this RFC, I'll continue in a new PR.