How to check types for the entire project via CLI?

[jaydenseric]

There is an issue about introducing a deno check CLI command, which presumably would allow TypeScript types to be checked for the entire project via CLI (for CI), but that could be weeks/months away from a resolution so how do we do it today?

[kitsonk]

deno cache

Deno currently does not have a concept of a "project". If you deno cache <somefile>, Deno will analyse its dependencies and type check them. If you have multiple entry points, you would do each.

Also, deno test is another option, where you have at least a file that Deno recognises at a test module that imports all the modules in your project. Then you don't have to specify anything other than deno test.

[jaydenseric]

@nayeemrmn you legend! Your suggestion unblocked me:

deno cache --import-map importMapDev.json **/*.{js,ts}

People will generally want to check for all issues in the project at once, it would be really neat if there was a single Deno command to check all project files for fmt, lint, type, and test errors grouping all problems in output under each file. Here is my GitHub Actions CI config now:

name: CI
on: [push, pull_request]
jobs:
  test:
    name: Test with ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest]
    steps:
      - name: Checkout repo
        uses: actions/checkout@v2
      - name: Setup Deno
        uses: denoland/setup-deno@v1
        with:
          deno-version: '^1.0.0'
      - name: Format check
        run: deno fmt --check
      - name: Lint
        run: deno lint
      - name: Type check
        run: deno cache --import-map importMapDev.json **/*.{js,ts}
      - name: Test
        run: deno test --import-map=importMapDev.json --allow-net

I don't use .jsx/.tsx files anymore, but anyone copying the config and glob should account for those file extensions too.

[jaydenseric]

I suppose the order matters too; do the deno cache based type check before other checks like deno test, that way caching isn't done twice and benefits following commands.

[jaydenseric]

Ok, So I've been having nightmares all afternoon figuring out 1980's bullshit technology to get the glob to work in all the different shells, and it looks like I'm getting close to a solution with this monstrosity:

find . \( -name  '*.js' -o  -iname '*.jsx' -o  -iname '*.ts' -o  -iname '*.tsx' \) -print0 | xargs -0 deno cache --import-map importMapDev.json

Some of the challenges are:

• You don't want the glob to resolve to the string of the glob itself if no files are found.
• If files for one of the possible file extensions isn't found (but others are) you don't want an error.

If ZSH were available everywhere, you could do things like this:

#!/bin/zsh
deno cache --import-map importMapDev.json -- **/*.(js|jsx|ts|tsx)

But it's not available in GitHub Actions and the bash shell in GitHub actions is only v3.2:

https://github.com/actions/virtual-environments/blob/main/images/macos/macos-11-Readme.md#language-and-runtime

So you can't use ** in globs, or any of the optional glob settings about what happens if no results are found.

While a full-blown Deno script to do the same thing as my final monstrosity shell script using std lib functions for globs, etc. would be more code and slower, it would be way more intuitive to understand. I've spent the whole afternoon on this and I'm still not happy with the result, and totally distracted from writing actual project JS code. This is not the developer experience Deno aspires to :(

[jaydenseric]

I've just discovered another problem with using deno cache to type check; it is unable to discover type errors in .js files that have the // @ts-check comment, even though the Deno LSP shows type errors in these files in your editor.

[jaydenseric]

I raised a bug issue for the above: #12143 .

[jaydenseric]

Here is what I came up with:

jaydenseric/ruck@ef8275b

#!/usr/bin/env -S deno run --allow-read --allow-write --allow-run

// @ts-check
// Type checks every JavaScript module in the project.

import { expandGlob } from "std/fs/mod.ts";

const typeCheckIndexModuleName = "type-check-index.mjs";

console.log("Creating a temporary index module to check…");

let rawModule = "";

for await (const { path } of expandGlob("**\/*.mjs")) {
  rawModule += `import "${path}";\n`;
}

await Deno.writeTextFile(typeCheckIndexModuleName, rawModule);

console.log("Checking the temporary index module…");

const process = Deno.run({
  cmd: ["deno", "check", typeCheckIndexModuleName],
  stdout: "piped",
  stderr: "piped",
});

const { code } = await process.status();
const rawOutput = await process.output();
const rawError = await process.stderrOutput();

if (code === 0) await Deno.stdout.write(rawOutput);
else await Deno.stderr.write(rawError);

console.log("Deleting the temporary index module…");

await Deno.remove(typeCheckIndexModuleName);

Deno.exit(code);

It can be run in the project directory by running this:

./scripts/type-check.mjs

[jollytoad]

I think the behaviour of least surprise would be for deno check and deno cache to operate on all files that deno fmt and deno lint do when given no specific files.

I find myself running the following quite often:

deno fmt && deno lint && deno check **/*.ts

And having to explain this to other devs, and hope their shell supports globs.

It's frustrating that can't be added as a task, as tasks don't yet support globs.

It would be far more intuitive to just be able to do:

deno fmt && deno lint && deno check

Which could also easily be added as a task too.

[jollytoad]

The default operation of check could also be configured in the same way as fmt/lint to allow a set of file includes/excludes.

Consistency is the key to a great user experience, and this current inconsistency doesn't benefit anyone.

[deer]

deno check **/*.ts is very useful -- thanks for posting this!

Since it's now almost seven months in the future, just thought I'd share the good news here for anyone else finding this. Deno now does support globs from tasks: https://deno.com/blog/v1.34#glob-support-in-denojson-and-cli-flags

So you could add something like this to your tasks:
"safe": "deno fmt --check && deno lint && deno check **/*.ts"

[lytedev]

Is this something that a PR would be welcome for? I also think deno check should work similarly to deno fmt, deno lint, and deno test. Especially since globbing does not yet work in deno tasks and I want to do something like this:

{
	"tasks": {
		"pre-commit": "deno lint && deno check --all *.ts && deno test"
		"setup-pre-commit": "echo '#!/bin/sh\ndeno task pre-commit' > .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit"
	}
}

[hrumhurum]

deno check **/*.ts does not work on Windows:

error: The filename, directory name, or volume label syntax is incorrect. (os error 123)

It would be useful if deno check could do this by default. Alternatively, deno check would benefit from a built-in glob support, as not all shell interpreters provide it.

[bartlomieju]

@hrumhurum this should work if you wrap **/*.ts in quotes like so: deno check "**/*.ts" - then Deno will expand the glob itself.

[hrumhurum]

deno check "**/*.ts" does not work and produces the same error message on Windows.

[greentore]

It does work if you define it as a task however.

  "tasks": {
    "check": "deno check **/*.ts"
  }

[silverwind]

On GitHub actions, I needed to use shopt -s globstar; deno check src/**/*.ts because the bash shell there does not have recursive globs enabled by default.

I think deno should support deno check (current directory) and deno check <dir> and just discover all .ts and .tsx files itself.