Local fetches from imported local modules are not detected as file attachments

[mbostock]

Currently we only detect and rewrite local fetches from within Markdown, not within imported ES modules. For example, if I have a JavaScript cell in a Markdown file, docs/index.md:

```js
import {foo}  from "./foo.js";
```

And then in foo.js:

export const foo = await fetch("./foo.json").then((response) => response.json());

Then we would want foo.json to be identified as a file attachment.

Furthermore, if foo.js uses an absolute path (starting with a /):

export const foo = await fetch("/foo.json").then((response) => response.json());

Then foo.js would need to be rewritten to append /_file as per #78.

One of the challenges is whether fetch, like import, should be considered relative to the calling JavaScript source file (here foo.js) or relative to the serving page (index.md) which could be in a different directory. But I think since we’re already doing static analysis to find the fetches, it makes sense for fetch to be relative to the calling JavaScript source file for consistency; we think that’s “what people want”.

[cinxmo]

Relates to #203

[trebor]

@mbostock i've been working on this, but the code in question has been changing a bunch and my prior approach is out of date and likely wrong-headed with the new code in imports.ts. i wanted to check with you on a general approach.

i believe that the fetches are identified in findFeatures: https://github.com/observablehq/cli/blob/100954bb60f79bf4f384120cc569190687d55b75/src/javascript/features.ts#L25-L29

but will need to be found recursively, in the same way that imports are handled: https://github.com/observablehq/cli/blob/100954bb60f79bf4f384120cc569190687d55b75/src/javascript/imports.ts#L32-L37

if this is true, then i can think of a few ways to do this:

• add recursive parsing in findFeatures - which seems redundant
• call findFeatures from findImports, which would then return imports AND features - which feels a bit over-coupled
• extract out recursive parsing code and call findFeatures, findImports from there - a rather large structural change

am i thinking about this the right sort of way?

is there some much simpler thing i could be doing?

[mbostock]

Calling findFeatures from findImports sounds easiest to me, though my further intuition is that we want to decouple findFetches from findFeatures.fetch works in an imported module, but FileAttachment, Secret, and DatabaseClient currently don’t — and if they were to work, you’d still have to import them explicitly from the standard library somehow; see #15.

The findFetches approach means:

• Move the local fetch detection logic out of findFeatures and into a new findFetches in fetches.ts
• Call findFetches from findImports to collect fetches recursively at the same time as imports
• Have findImports return both imports: ImportReference[] and fetches: Feature[] (?)
• Combine the found fetches back into features in parseJavaScript
• Have rewriteModule also rewrite local fetches

You might also be tempted to have rewriteModule call rewriteFetches, but one of the wrinkles there is that the path to a fetched file will be different between Markdown and JavaScript modules; the later are under _import. (Which is one reason we have both rewriteModule and rewriteImports.)

So yeah, I think coupling imports and fetches seems easiest to me. I could also see us collecting features in general across transitive imports, but like I said, you can’t use those other features in imported modules currently so that feels premature.