Ninguna sobrecarga coincide con esta llamada. El tipo ‘cadena’ no se puede asignar al tipo ‘Señales’

Estoy usando mecanografiado para construir un microservicio y manejar señales también. El código funcionaba bien hasta hace unos días, pero recientemente comenzó a arrojar errores. No se pudo encontrar una solución para el problema.

Código para el manejo de señales. Es solo una parte del archivo.
src/main.ts

  enum signals {
    SIGHUP = 1,
    SIGINT = 2,
    SIGTERM = 15
  }
  const shutdown = (signal, value) => {
    logger.warn("shutdown!")
    Db.closeAll()
    process.exit(value)
  }
  Object.values(signals).forEach(signal => {
    process.on(signal, () => {
      logger.warn(`process received a ${signal} signal`)
      shutdown(signal, signals[signal])
    })
  })

Cuando lo hago ts-node src/main.ts El siguiente error se lanza y sale.

/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:245
    return new TSError(diagnosticText, diagnosticCodes)
           ^
TSError: ⨯ Unable to compile TypeScript:
src/main.ts:35:16 - error TS2769: No overload matches this call.
  The last overload gave the following error.
    Argument of type 'string | signals' is not assignable to parameter of type 'Signals'.
      Type 'string' is not assignable to type 'Signals'.

35     process.on(signal, () => {
                  ~~~~~~

  node_modules/@types/node/base.d.ts:653:9
    653         on(event: Signals, listener: SignalsListener): this;
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The last overload is declared here.

    at createTSError (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:245:12)
    at reportTSError (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:249:19)
    at getOutput (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:362:34)
    at Object.compile (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:395:32)
    at Module.m._compile (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:473:43)
    at Module._extensions..js (module.js:663:10)
    at Object.require.extensions.(anonymous function) [as .ts] (/home/meraj/.nvm/versions/node/v8.10.0/lib/node_modules/ts-node/src/index.ts:476:12)
    at Module.load (module.js:565:32)
    at tryModuleLoad (module.js:505:12)
    at Function.Module._load (module.js:497:3)

Cualquier arreglo sería apreciado. O si puede decir por qué estaba funcionando antes hace solo 2 días y no ahora.

Esto sucede a veces cuando ha pasado un número incorrecto de argumentos a una función anónima:

    Object.keys(data).reduce((key: string) => {

    }, {}); 

generará error:

Ninguna sobrecarga coincide con esta llamada. Sobrecarga 1 de 3

Pásalo el número correcto de argumentos:

    Object.keys(data).reduce((acc: any, key: string) => {
    }, {});

También tuve este problema extraño, pero lo solucioné usando aserciones de tipo (en mi caso usando una enumeración de cadena):

(Object.values(someEnum) as string[]).concat(otherStringArray);

Solución 1: Mantener enumeración numérica signals

Object.values(signals)
  // numeric enum includes reverse mapping, filter numbers out and keep "SIGHUP" etc.
  .filter((s): s is NodeJS.Signals => typeof s !== "number") 
  .forEach(signal => {
    process.on(signal, ...) // works now
  })

Solución 2: use tipos literales de cadena de señal pura

// these string literal items are strongly typed by built-in NodeJS.Signals type
Object.values<NodeJS.Signals>(["SIGHUP", "SIGINT", "SIGTERM"])
  .forEach(signal => {
    process.on(signal, ...) // works now
  })

Solución 3: Cambiar a enumeración de cadena (sin mapeo inverso)

enum signals2 {
  SIGHUP = "SIGHUP",
  SIGINT = "SIGINT",
  SIGTERM = "SIGTERM"
}

Object.values(signals2)
  .forEach(signal => {
    process.on(signal, ...) // works now
  })

¿Por qué ocurre el error?

Enumeraciones numéricas como signals Incluir un mapeo inverso. Por ejemplo, puedes hacer lo siguiente:

const r1 = signals.SIGHUP // r1 value: 1
const r2 = signals[signals.SIGINT] // r2 value: "SIGINT"
const r3 = signals[15] // r3 value: "SIGTERM"

Es por eso que obtienes (string | signals)[] De vuelta por Object.values(signals)dónde string representa las claves de enumeración y signals para los valores de enumeración.

Ahora, parámetro signal en process.on(signal, ...) debe ser uno de los tipos de literales de cadena predefinidos de Node.JS. Sin embargo, pasamos string | signals tipo de elemento, por lo que TS grita en este punto.

Esto sucede cuando no asigna sus tipos correctamente.

Su tipo de datos variables DEBE coincidir con el tipo de datos de paso.

organizationList: { id: string; name: string;  }[] = [] //if you do this way it type error
organizationList: Organization[] = [] //correct defining method 

get Org() {
    return this.list.filter((org: Organization) => org.id == this.id) //this data type must defined data type
  }

Un caso raro que me ha pasado con respecto a este tipo de error podría ser por ejemplo

somePath = somePath.replace(/\//g, /\\\//g);

usar en su lugar

somePath= somePath.replace("/", "\/");
somePath= somePath.replace(/\//, "\/");

porque el segundo argumento en replace es de tipo cadena.

Recibí este tipo de error de mecanografiado cuando pasé una función no asíncrona a un método que esperaba una función asíncrona.