skott: process.chdir does not affect working directory used by skott for creating node id paths

That’s usually the type of small bug that can make you waste hours 😆

I just released 0.33.1 including the small patch for process.chdir, let me know how that goes for you on that side

Yes, that’s exactly right. Dang, I was looking around the repository for what you found in the config file, but missed it. Nice!

Thanks for providing these graphs @mattkindy. I am able to reproduce the behavior consistently so I should be able to land something confidently.

Let’s just recap on the situation to be sure it will fit your expectations.

Given an absolute path such as /var/folders/3v/some-project (basically a temp folder) and a skott’s process being run in the following folder /Users/johnskott/blabla/some-folder with that:

skott({ cwd: "/var/folders/3v/some-project" })

skott will have graph node paths written in a relative way from where it was initially executed (/Users/johnskott/blabla/some-folder) such as ../../../../../../../../../var/folders/3v/some-project/some-file.js.

So the graph is correctly computed but paths are ugly as the location of the folder is higher FS-wise to the location where skott was executed. Regarding that, we could achieve normalization (what you pasted there) by default and otherwise when using --includeBaseDir (which is currently disabled when using --cwd), paths would look exactly as it is now, because including the base directory in that case means that paths should contain the information where skott was run.

To come back a little bit on “process.chdir”, I found the problem with skott and I’ll land a fix (this is orthogonal to the subject just above)

It was indeed due to process.cwd() being eagerly executed there https://github.com/antoine-coulon/skott/blob/078096ec2cd394a4629a600beb7c7ee4d65d41da/packages/skott/src/config.ts#L55

so the following would work for you as expected and would provide the expected paths that is directly starting from the temp location:

process.chdir("/var/folders/3v/lr71j2ks5flgnjw2n82qf49w0000gn/T/skott_store/knex/knex@7363211");

skott().then(({ getStructure }) => {
  return getStructure();
})

Thanks for such a complete feedback @mattkindy!

This was only slightly confusing – in the docs, you mention this within the context of a monorepo, so this made sense. I originally tried to use cwd thinking it would behave differently, but ultimately, this is understood. (Side note, I do find it somewhat confusing given the lack of a “base directory” option).

I agree, as already stated I think it’s a bit misleading, cwd lets the user think that the working directory from a process perspective will be updated, but it’s not.

Consequently from an analysis standpoint, the behavior is strictly the same and the graph should end up being the same (if not then it’s a bug). So in the end it’s a matter of what type of node path you want, whether relative from the cwd or kind of absolute from skott script location.

It turns out that most of the time I found the DX to be better and the graph to be more visible when getting rid of all the relative path madness ../../module.js -> ../../../lib/whatever.js, but as you mentioned the solution might be to let the choice of what should be the base directory (so in the same spirit as when using an --entrypoint, you have the choice of keeping the base directory or to prune it) and it would kind of unify both behaviors (entrypoint vs root dir).

In addition to the option that should be available, there is also the fact of changing the current working directory outside of skott that you mentioned: using process.chdir. This one should normally work when not providing any cwd as the default runtime config takes process.cwd() as the default so it might be a bug indeed.

I won’t have the opportunity to dive in this week-end but I’ll be able to spend some serious time on this issue starting from the beginning of next week 😃 Also if you ever want to land PRs around these topics, feel free to do so!

For now I’m dealing with this with

    const normalizeId = (id: string) => path.relative(cwd, id);

    const { graph } = await api.getStructure();
    return Object.fromEntries(
      Object.entries(graph).map(([id, graph]) => {
        const basePath = normalizeId(id);
        return [
          basePath, 
          { 
            ...graph, 
            id: basePath, 
            adjacentTo: graph.adjacentTo.map(normalizeId) 
          }
        ];
      })
    );