"My Types Are Missing" when "types" and "typeRoots" are both provided.

[pelepelin]

Expected Behavior

Same as tsc or documented in "My Types Are Missing"
According to https://www.typescriptlang.org/tsconfig#types :

This option does not affect how @types/* are included in your application code

Actual Behavior

When both types and typeRoots are specified, tsc resolves imported types from typeRoots, but ts-node does not. It is not documented.
ts-node --files src/index.ts resolves the types, but it's not clear why, as neither include nor files are used.
Without types ts-node src/index.ts resolves types in typeRoots as well as tsc does.

Steps to reproduce the problem

Run ts-node src/index.ts in the reproduction below

Minimal reproduction

TypeStrong/ts-node-repros#6

Specifications

• ts-node version: 9.0.0
• node version: 12.14.0
• TypeScript version: 4.0.3
• tsconfig.json, if you're using one:

{
  "compilerOptions": {
    "strict": true,
    "esModuleInterop": true,
    "outDir": "dist",
    "types": ["node"],
    "typeRoots": ["node_modules/@types", "src/typings"]
  }
}

• Operating system and version: Ubuntu 18.04.5 LTS

[pelepelin]

Side note: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html#types-typeroots-and-types section referenced from README is now missing in the Handbook. I was unable to google it even though I know it's still somewhere in git history.

[pelepelin]

Archived link is
https://github.com/microsoft/TypeScript-Handbook/blob/master/pages/tutorials/tsconfig.json.md#types-typeroots-and-types

Keep in mind that automatic inclusion is only important if you're using files with global declarations (as opposed to files declared as modules). If you use an import "foo" statement, for instance, TypeScript may still look through node_modules & node_modules/@types folders to find the foo package.

I read this as normal imports should be resolved even with types specified.

---

Also I think it worth quoting relevant sentence from that file into ts-node README. https://github.com/microsoft/TypeScript-Handbook/blob/master/pages/tutorials/tsconfig.json.md#details

If the "files" and "include" are both left unspecified, the compiler defaults to including all TypeScript (.ts, .d.ts and .tsx) files in the containing directory and subdirectories

That would clarify that tsc uses implicit include by default, as it's not obvious and seems missing in current tsconfig docs.

---

If I try to specify files or include with only a single source file, the behavior of tsc seems the same as ts-node, as it does not resolve typeRoots despite the quoted "automatic inclusion is only important if you're using files with global declarations". So it looks like TS docs are a bit misleading or it's a bug in TS itself, as when types are specified, it still imports types from node_modules/@types but not from my typeRoots. If types are not specified, typeRoots are examined.

[cspotcode]

I can clarify the behavior of ts-node's --files flag.

Without specifying --files, we set/overwrite your config to be "include": [], "files": ["path to entrypoint file"]

When you specify --files we do not do this, so we allow tsc's default behavior or your explicitly specified "files", "include", and "exclude" to take effect.

When --files fixes a types problem, it means that the "files" array (in this case, tsc's default behavior) is pulling in a file containing the necessary types. This indicates to me that your problem is not related to types/typeRoots.

You can use tsc --showConfig to list all files being matched by the default "files" array. My guess is that one of those files is importing, requiring, or /// <referenceing the necessary types. This can happen independently of types/typeRoots.

[cspotcode]

Caveat being that I haven't had time to look at your reproduction yet. So it's certainly possible that I'm wrong about the source of your problem, but I wanted to share some useful information in the meantime.

[pelepelin]

I think it's an issue in compiler, I've created microsoft/TypeScript#41198

This indicates to me that your problem is not related to types/typeRoots.

I think in my case:

• When types are not set and there is only one file in files, local typings are successfully resolved through typeRoots.
• When types are set, but files are unset and populated by the default tsc behavior (by tsc or with --files), local typings are discovered because they appear in implicit files.
• When types are set and there is only one file in files, local typings are not discovered. That is what happens in my repro or with explicit files like in the issue I've posted to MS/TS.

So if you will verify my conclusion I think the only thing you can do here is adding clarification as per above quotes like these:

Without specifying --files, ts-node overwrites config file with "include": [], "files": ["path to entrypoint file"]
When you specify --files, ts-node does not do this, so it allows tsc's default behavior or your explicitly specified "files", "include", and "exclude" to take effect. When the "files" and "include" are both left unspecified, tsc defaults to including all TypeScript (.ts, .d.ts and .tsx) files in the containing directory and subdirectories.
Note that when types are set, compiler ignores typeRoots, so if --files options is not used, typings in custom locations won't be found.

Actually, you could fix that problem on ts-node side by adding typeRoots into initial files in such conditions, but I don't think you should.

[cspotcode]

Thanks for the detailed analysis.

Looking at your reproduction, I think I found a straightforward workaround:

/// <reference types="dnscache" />
import dnscache from 'dnscache';

It seems like import from 'dnscache' uses the "NodeJS" module resolver, which looks at relative node_modules directories but ignores typeRoots. However, <reference types=""> uses typeRoots.

Another option: you can specify files in your tsconfig.

{
  "ts-node": {
    "files": true
  },
  "compilerOptions": ...
}

[cspotcode]

I forgot to mention:

I used tsc --traceResolution to see a detailed log of every location the compiler looks when trying to find module declarations.

[cspotcode]

We discussed this briefly on the TypeScript Discord server. The Discord server is a great place to talk with TypeScript experts; I definitely recommend it.

https://discord.com/channels/508357248330760243/745636133219598416/770058905869877259

As far as I can tell, this is normal, expected behavior.

The goal of types and typeRoots is to eagerly pull in types that are not matched by the files/include/exclude arrays
this exposes globals, other modules (pulling in node exposes the fs module), and export as namespace
types and typeRoots is not part of module resolution, so if you import "foo" the resolver will not look at types/typeRoots
/// <reference types="" /> will look at types/typeRoots

Though surprising, it looks like TypeScript is behaving as intended.

You can do one of the following to fix your problem:

a) enable ts-node's "files": true in your tsconfig file
b) add a /// <reference types="dnscache" /> to trigger a typeRoots/types lookup for dnscache
c) add a /// <reference path="../types/dnscache.d.ts" /> to trigger inclusion of the dnscache declaration (I'm sure the path in my example is wrong, but you get the idea. It's a relative path to a local file which will be included as if it were in your "files" array)
d) add "dnscache" to your "types" array: "types": ["node", "dnscache"]

I'm going to close this issue since it seems like it's not a ts-node issue. Feel free to reopen it, or file a new issue, if you think you've found a ts-node bug.

[pelepelin]

The goal of types and typeRoots is to eagerly pull in types
types and typeRoots is not part of module resolution

That's very interesting point, thank you.

[wvhulle]

I can clarify the behavior of ts-node's --files flag.

Without specifying --files, we set/overwrite your config to be "include": [], "files": ["path to entrypoint file"]

When you specify --files we do not do this, so we allow tsc's default behavior or your explicitly specified "files", "include", and "exclude" to take effect.

When --files fixes a types problem, it means that the "files" array (in this case, tsc's default behavior) is pulling in a file containing the necessary types. This indicates to me that your problem is not related to types/typeRoots.

You can use tsc --showConfig to list all files being matched by the default "files" array. My guess is that one of those files is importing, requiring, or /// <referenceing the necessary types. This can happen independently of types/typeRoots.

This was not easy to find. It took me 2 hours. This post was helpful:

https://stackoverflow.com/questions/51610583/ts-node-ignores-d-ts-files-while-tsc-successfully-compiles-the-project

You can look at how many people had the same problem in that question and voted. Overriding particular fields in tsconfig.json is impossible to debug. Trace resolution didn't show anything, and documentation was nowhere to be found. Is there a good reason to override the include and files section? Why not just augment it? Please follow the tsc behavior or give a warning on execution to stop others from having to find it out like this.