Wsrtjtyk

Here is my program:

import * as child_process from 'child_process'



let global_npm_modules = ''



const initial_command = 'npm ls -g --depth=0 --json'

const shell = 'powershell'

const callback = (err: Error, stdout: string | Buffer, stderr: string | Buffer) => {

    if (err) {

        console.log('There was an errornn', err)

        return

    }



    console.log(stdout)

}



child_process.exec(initial_command, {shell: shell}, callback)

And tslint is complaining about callback in the last line giving the error:

[ts]

Argument of type '(err: Error, stdout: string | Buffer, stderr: string | Buffer) => void' is not assignable to parameter of type '(error: ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => void'.

  Types of parameters 'err' and 'error' are incompatible.

    Type 'ExecException | null' is not assignable to type 'Error'.

      Type 'null' is not assignable to type 'Error'.

const callback: (err: Error, stdout: string | Buffer, stderr: string | Buffer) => void

And I was just using the types provided in this section:

callback <Function> called with the output when process terminates.



error <Error>

stdout <string> | <Buffer>

stderr <string> | <Buffer>

{

  "compilerOptions": {

    "target": "es5",

    "module": "commonjs",

    "rootDir": "src",

    "outDir": "dist",

    "lib": [

      "esnext",

      "dom"

    ],

    "strict": true,

    "esModuleInterop": true,

    "sourceMap": true,

    "declaration": true

  },

  "exclude": [

    "node_modules",

    "dist"

  ]

}

I also have @types/node installed.

EDIT

With Node, the documentation says this about child_process.exec(): "If a callback function is provided, it is called with the arguments (error, stdout, stderr). On success, error will be null."

But with TypeScript, the Error type is defined as

interface Error {

    stack?: string;

}

Should I just add | null to the possible type that the error parameter can be? Or is this a bug with the @types/node package?

The type of the first argument of callback is defined as ExecException | null and ExecException extends Error. And since a callback function is provided by the programmer to the library and would be called by the library, it should cover all the possibilities of the arguments that might be passed to it.

Your callback: (error: Error, /* code omitted */) => ChildProcess can only handles, regarding to its type declaration, the case where error is of type Error and can not handle the case where error is null. So tsc is emitting a type error.

I can think of two solutions to this for now:

1. Add | null to the type declaration of error
   

    const callback = (err: Error | null, stdout: string | Buffer, stderr: string | Buffer) => {

        if (err) {

            console.log('There was an errornn', err)

            return

        }



        console.log(stdout)

    }

2. Infer the expected type of the callback from existing declaration and then declare the callback with that inferred type.

    type CallbackType = typeof child_process.exec extends (cmd: string, options: any, callback: infer P) => ChildProcess ? P : any 



    const callback: CallbackType  = (err, stdout, stderr) => {

        if (err) {

            console.log('There was an errornn', err)

            return

        }



        console.log(stdout)

    }

Check it in online repl

A possible solution to this problem is to add

"compilerOptions": {

    "strictNullChecks": false

}

to the tsconfig.json.

But hopefully, in the future, I can figure out a solution that doesn't require this.

EDIT

Or | null can be added as a type annotation for err. I opted to choose this more specific solution.