Definitelytyped: La definición de bluebird 3.0 no se puede asignar a ES6 Promises

@Strate ¿Puede publicar la salida restante de tsc? Y por favor intente abrir su bluebird.d.ts local y agregue esta única línea de # 10831 . ¿Eso soluciona tu problema?

Todo el error:

error TS2322: Type '(entity: BaseEntity) => Bluebird<{ contentType: "ActivityDesktopWidget" | "AddressType" | "Approv...' is not assignable to type 'UpdateEntityFunction<BaseEntity>'.
  Type 'Bluebird<{ contentType: "ActivityDesktopWidget" | "AddressType" | "Approval" | "BaseIntegrationEn...' is not assignable to type 'Promise<BaseEntity>'.
    Types of property 'then' are incompatible.
      Type '{ <U>(onFulfill: (value: { contentType: "ActivityDesktopWidget" | "AddressType" | "Approval" | "B...' is not assignable to type '{ <TResult1, TResult2>(onfulfilled: (value: BaseEntity) => TResult1 | PromiseLike<TResult1>, onre...'.
        Type 'Bluebird<any>' is not assignable to type 'Promise<any>'.

Estoy usando [email protected] con lib.es2016.d.ts file. Agregar esa línea no ayuda.

Ah ya veo ... creo que es debido a esta falta de línea de aquí . Esto significa que, con las mecanografías actuales, debe devolver el mismo tipo U tanto de onFulfill como de onReject . Sería genial si alguien pudiera arreglar esto en el npm y este repositorio dt por cierto.

Mientras tanto, probablemente deberías dividir tus .then(success, failure) en .then(success).catch(failure) ya que eso es probablemente lo que hiciste bien. Aunque es parte de la sintaxis oficial, en realidad no es la "preferida" con bluebird de todos modos.

La alternativa es que podría especificar manualmente el parámetro genérico U así

.then<SomeType>(() => new SomeType(), (err) => 123); // This is an explicit error because SomeType != number

para asegurarse de que devuelve el mismo tipo de ambas devoluciones de llamada.

@lhecker pero ni siquiera uso then o catch . Tengo algo como eso:

// module 1. Note that bluebird is not imported
export default function<T>(promise: Promise<T>) {} // es6 promise used here

// module 2.
import Promise from "bluebird"
import handler from "./module1"
const promise: Promise<any>
handler(promise) // <-- error is here

Parece que podría solucionarse agregando otra declaración then , compatible con la de es6 a bluebird.d.ts

Ah, maldita sea ... lo siento. Supongo que finalmente debería tomarme un descanso. 😅

Así que ignore mis comentarios sobre qué hacer mientras tanto: ya que faltan de todos modos y ya que realmente no tengo o al menos "no debería" tener el tiempo para hacer nada más que soporte básico como este, sería muy apreciado si podría enviar PR para agregar esos mecanografiados a ambos proyectos. 😊

@lhecker hecho :)

Solo una nota al margen, pero siempre recomiendo usar PromiseLike para cuando aceptes promesas. Garantizará la interfaz de promesa mínima implementada para que pueda aceptar la mayoría de las promesas. Luego puede devolver el tipo de promesa de su elección, haciéndolo más estricto como Bluebird<T> que tiene muchos métodos adicionales. Durante mucho tiempo, ninguna de mis promesas fue asignable debido a que los símbolos ES6 se agregaron a los tipos de promesa ES6.

@blakeembrey usando PromiseLike en este caso no es la respuesta, porque PromiseLike también tiene una versión incompatible de entonces

Desafortunadamente, las tipificaciones de Promise han cambiado en la versión 2 de TS, por lo que estas tipificaciones ya no corresponden: https://github.com/Microsoft/TypeScript/blob/070aa83cc06b2974639bbefcde98e6e2fb5fe693/src/lib/es2015.promise.d.ts

¿Podemos reabrir este problema?

¿Alguna actualización sobre esto?

@OliverJAsh @ arg20, ¿ podrían proporcionar un caso de prueba auto-reproducible de su problema?

@Strate aquí tienes mi error. Usando mecanografiado 2.0.3 (lib.es6.d.ts) y @ types / bluebird v3.0.33

error TS2345: Argument of type 'Bluebird<Db>' is not assignable to parameter of type 'Promise
<Db>'.                                                                                                            
  Types of property 'then' are incompatible.                                                                      
    Type '{ <U1, U2>(onFulfill: (value: Db) => U1 | Thenable<U1>, onReject: (error: any) => U2 | Thenable<U...' is
 not assignable to type '{ <TResult1, TResult2>(onfulfilled: (value: Db) => TResult1 | PromiseLike<TResult1>, onre
jected: ...'.                                                                                                     
      Type 'Bluebird<any>' is not assignable to type 'Promise<any>'.                                              
        Types of property 'then' are incompatible.                                                                
          Type '{ <U1, U2>(onFulfill: (value: any) => U1 | Thenable<U1>, onReject: (error: any) => U2 | Thenable<.
..' is not assignable to type '{ <TResult1, TResult2>(onfulfilled: (value: any) => TResult1 | PromiseLike<TResult1
>, onrejected:...'.                                                                                               
            Type 'Bluebird<any>' is not assignable to type 'Promise<any>'.              

Intentar convertir Bluebird Promise en una promesa de ES6 arroja lo siguiente ( bluebirdPromise as Promise<Db> )

 error TS2352: Type 'Bluebird<Db>' cannot be converted to type 'Promise<Db>'.                 
  Types of property 'then' are incompatible.                                                                      
    Type '{ <U1, U2>(onFulfill: (value: Db) => U1 | Thenable<U1>, onReject: (error: any) => U2 | Thenable<U...' is  not comparable to type '{ <TResult1, TResult2>(onfulfilled: (value: Db) => TResult1 | PromiseLike<TResult1>, onrejected: ...'.                                                                                                     
      Type 'Bluebird<any>' is not comparable to type 'Promise<any>'.                                              
        Property '[Symbol.toStringTag]' is missing in type 'Bluebird<any>'.         

agregar esto como se propone en # 10831 funcionó para mí

readonly [Symbol.toStringTag]: 'Promise';

Además, la conversión a ES6 Promise funcionó

return new Promise.resolve(bluebirdPromise)

@jmendiara como se indica en # 10831, no hay readonly [Symbol.toStringTag] en bluebird en realidad, por lo que agregar esto a bluebird.d.ts es definitivamente incorrecto: las mecanografías deben representar el mundo real.
Si el estándar Promise requiere readonly [Symbol.toStringTag] , debe agregarse al mismo bluebird y también al bluebird.d.ts. Parece que definitivamente deberías usar la conversión entre bluebird y promesas nativas (lo cual es realmente molesto).
Para su información: puede usar Promise.resolve sin la palabra clave new .

Me encontré con un problema cuando la promesa de bluebird no se puede asignar a una estándar. Y en mi caso, es imposible convertir bluebird al estándar con Promise.resolve , porque está profundamente en un objeto de terceros. Por lo tanto, a veces es razonable que la promesa de bluebird se pueda asignar a uno estándar sin conversión.
Solicitud de función recién creada en el repositorio de bluebird, para agregar Symbol.toStringTag a las instancias de bluebird.

https://github.com/petkaantonov/bluebird/issues/1277

¿Alguna actualización sobre esto?

Me alegro de haber encontrado este hilo. Pensé que me estaba volviendo loco. Realmente me gustaría ver una solución para esto. Describí los detalles de mi problema en SO

Me encuentro con este problema con @ types / bluebird 3.5.3 y TypeScript 2.2.2.

@silentorb Tengo esto funcionando usando la definición de tipo @types/bluebird-global y luego anulando la definición de promesa global (que tendrá si está apuntando a una plataforma ES2015) agregando lo siguiente en la parte superior de mi código punto de entrada de ejecución:

import * as Promise from 'bluebird';
global.Promise = require('bluebird');

Lo anterior funciona para el entorno de nodo (estoy usando 6.10.x). Si está utilizando un paquete web , es posible que deba usar algo como _expose-loader_.

@ksnyde : anteriormente probé @types/bluebird-global y encontré varios detalles de Promise faltantes. Consideré parchear @types/bluebird-global pero sería mejor tener @types/bluebird funcionando.

@silentorb, la clave es anular la referencia global de Promise; funciona sin problema para mí. Dicho esto, ciertamente sería bueno si funcionara de fábrica, pero no hay necesidad de esperar con esta solución.

¿Algún progreso en esto?

También tengo este problema. Se reduce a errores como los siguientes:

type Promise<any> is not assignable to Bluebird<any>

Muy frustrante. Esto también está rompiendo los usos de otros paquetes de escritura, como sequelize .

export interface MissionModel extends Sequelize.Model<MissionInstance, MissionAttributes. {
    create(missionAttributes: MissionAttributes, opsions?: Sequelize.CreateOptions): Promise<MissionInstance>;
}

MissionModel tendrá el siguiente error a menos que Promise se importe como * from "bluebird" :

src\server\models\mission.ts(3,18): error TS2430: Interface 'MissionModel' incorrectly extends interface 'Model<MissionInstance, MissionAttributes>'.
  Types of property 'create' are incompatible.
    Type '(MissionAttributes: MissionAttributes, option?: CreateOptions | undefined) => Promise<MissionInst...' is not assignable to type '(values?: MissionAttributes | undefined, options?: CreateOptions | undefined) => Bluebird<Mission...'.
      Type 'Promise<MissionInstance>' is not assignable to type 'Bluebird<MissionInstance>'.
        Types of property 'then' are incompatible.
          Type '<TResult1 = MissionInstance, TResult2 = never>(onfulfilled?: ((value: MissionInstance) => TResult...' is not assignable to type '{ <U>(onFulfill?: ((value: MissionInstance) => U | PromiseLike<U>) | undefined, onReject?: ((erro...'.
            Type 'Promise<any>' is not assignable to type 'Bluebird<any>'.

@Strate, ¿ podrías volver a abrir el problema?
Pensándolo bien, presentaré uno nuevo y más específico.

Realmente odio perder el tiempo para solucionar este tipo de problema de mecanografía. Porque el código es muy claro, pero para pasar tsc tienes que hacer más trabajo extra. La forma más sencilla de solucionarlo es crear una variable temporal con el tipo any. Luego conviértalo en su Promesa de destino. Tal como:

'' '
const p: cualquiera = getPromise ();
regreso> p;
'' '

@flyingsky (et. al.) En primer lugar, me gustaría recordarles a todos nuevamente que nunca será posible asignar directamente promesas nativas a las de Bluebird, ya que las promesas de Bluebird proporcionan extensiones que no existen en la implementación nativa.

Por otro lado, asignar promesas de Bluebird a las nativas debería ser posible y con razón. Pero muchos aquí tienen la impresión de que esto debería funcionar ahora mismo, lo que definitivamente no es el caso.

La razón de esto es que mientras Bluebird expone todas las funciones comúnmente conocidas de una manera nativa compatible, _no_ expone un campo en particular: El campo [Symbol.toStringTag] tiene que ser "promise" . Vea aquí: https://github.com/petkaantonov/bluebird/issues/1277. Esto hace que Bluebird sea estrictamente incompatible con las promesas nativas. Así que ...

const p: any = getPromise();
return <Promise>p;

Este es un tipo técnicamente inseguro e incorrecto.

Consideré parchear @types/bluebird-global , pero sería mejor tener @types/bluebird funcionando.

bluebird-global sirve un caso de uso completamente diferente al de bluebird : existe en caso de que vaya por la ruta insegura de sobrescribir la variable global Promise con Bluebird . (No es seguro porque simplemente sobrescribirlo no significa que todos los paquetes de los que depende no continuarán usando promesas nativas).

Si alguien en este número quiere ver el progreso, le sugiero que abra un PR para el problema Bluebird ya mencionado: https://github.com/petkaantonov/bluebird/issues/1277

Si alguien en este número quiere ver progreso, le sugiero que abra un PR para el problema Bluebird ya mencionado: petkaantonov / bluebird # 1277

Parece que se ha creado este PR: https://github.com/petkaantonov/bluebird/pull/1421

@ksnyde - Tu @types/bluebird-global funciona para mí, ligeramente modificada:

import * as Promise from 'bluebird'
global.Promise = Promise

De lo contrario, obtengo error TS6133: 'Promise' is declared but its value is never read. que se espera para tsconfig.json con "noUnusedLocals": true .

Gracias.

Estoy usando bluebird-global pero sigo recibiendo este error:

Falta la propiedad '[Symbol.toStringTag]' en el tipo 'Bluebird'

Agregar esta línea soluciona el problema https://github.com/DefinitelyTyped/DefinitelyTyped/pull/10831/files

¿Hay alguna forma de solucionarlo localmente sin modificar los tipos de bluebird?

+1

@gdpaulmil ¡ Gracias por su comentario constructivo!

Me impulsó a echar un vistazo a la situación en Bluebird.
Resulta que https://github.com/petkaantonov/bluebird/pull/1421 se fusionó hace 11 días, lo que significa que finalmente agregaron soporte para Symbol.toStringTag . 🎉

Esto, a su vez, significa que este problema se puede solucionar de inmediato volviendo a enviar # 10831. Uno solo tendrá que intercambiar "Promise" con "Object" . Sinceramente, lo revisaría de inmediato. 🙂

@lhecker , creó # 35353 para aclarar todo esto.

Hola, me gustaría informarles a todos que este problema se ha solucionado en la versión 3.5.27 de @types/bluebird .
Ahora puede disfrutar de poder asignar todos estos Bluebirds a todas estas Promesas. 🎉
Sin embargo, tendrá que usar TypeScript 3.2 o más reciente para esto. (Ver # 34805)

PD: Gracias de nuevo @JoshuaKGoldberg por tratar con Bluebird PR. 🙂👍

Es:

import * as Promise from 'bluebird';
global.Promise = require('bluebird');

¿Sigue siendo aplicable para es2017?

Excepto por todos los otros paquetes que tienen la versión anterior como dependencia y no obtuvieron el memo ... request-promise, knex, ... acaba de romper una gran cantidad de código con esta actualización. El compilador de TypeScript está lanzando errores sin sentido por todas partes, Typecript 3.3, 3.4, 3.5 ... no parece importar.

Si ayuda a alguien, como se mencionó anteriormente, tuve el tiempo más fácil simplemente NO intercambiar mi objeto Promise global por BB. No he encontrado ningún problema en el que una cosa sea compatible con otra.

@jacklinton Estoy seguro de que ya sabe que existen pruebas unitarias para verificar que todos los paquetes afectados aún se compilan con la versión dada de TypeScript sin "arrojar errores sin sentido".
Por ejemplo, aquí hay un proyecto que muestra la promesa de solicitud trabajando con los tipos más nuevos de Bluebird: https://github.com/lhecker/request-promise-sample
Como no puedo reproducir su problema, sería fantástico si pudiera proporcionar un ejemplo mínimo que muestre los problemas que está viendo.

Es difícil saber por dónde empezar, pero con todos los demás paquetes actualizados
Error:(19, 3) TS2741: Property '[Symbol.toStringTag]' is missing in type 'Bluebird<string[]>' but required in type 'Bluebird<string[]>'.
Si elimino @ types / bluebird, estos errores desaparecen. La única conjetura que puedo hacer con el tiempo que tengo es que no todos los demás paquetes que necesitan estos tipos se han puesto al día todavía. Sospecho que Knex es probablemente el culpable, pero no lo sé. Toma su propia dependencia de la versión anterior de este paquete.

Este error suena como si tuviera dos versiones de @types/bluebird instaladas. Debería intentar ver si puede aplanar ese árbol para que solo tenga uno de ellos.

knex 0.17.3 depende de la versión más reciente 3.5.27 de las mecanografías @types/bluebird por cierto. Si tiene una versión actualizada de knex, supongo que debería funcionar.
Sin embargo, lo mismo ocurre con su segunda copia de @types/bluebird : también debería ser 3.5.27.

Gracias por ser receptivo @lhecker . No quise sonar crítico, me disculpo. Claramente ha estado trabajando duro en esto y es algo que todos hemos estado esperando durante mucho tiempo. Gracias por su arduo trabajo para publicar esta actualización tan rápido después de que Bluebird hizo el cambio. Haré que este monolito hinchado funcione de la manera que se supone que debe hacerlo de una forma u otra.

@lhecker , ¿puedes volver a publicar tu solicitud-promesa-muestra porque parece que ya no está? 😢

@VictorioBerra el truco con

import * as Promise from 'bluebird';
global.Promise = require('bluebird');

me da el siguiente error en Node.js 12:

global.Promise = Promise;
Al tipo 'typeof Bluebird' le faltan las siguientes propiedades del tipo 'Función': aplicar, llamar, enlazar, longitud y 4 más.

Estoy usando TypeScript v3.7.4, bluebird v3.7.2 y @ types / bluebird-global v3.5.12.

@bennyn Ya no tengo el código. Lo siento mucho. Lo eliminé después de que se solucionó el problema de la promesa de solicitud.
Asegúrese de utilizar la última versión de @types/bluebird en 3.5.29.

Tengo el mismo error que @bennyn , con las últimas versiones de todos los bluebird, @ types / bluebird-global y TypeScript

Parece que la única opción viable con la versión actual de Bluebird 3.7.2 y TypeScript 3.6 es no usar mecanografía Bluebird en absoluto.

En el punto de entrada de la aplicación, reemplazo el constructor nativo de Promise con Bluebird y uso Bluebird usando la API de promesa nativa después de eso:

import * as Bluebird from "bluebird";
global.Promise = Bluebird;

new Promise((resolve, reject) => {
  // this is actually a Bluebird object
});

Yo personalmente, francamente, creo que ustedes están haciendo algo mal por su parte. 😖
He reconstruido mi proyecto mínimo request-promise-sample que muestra cómo absolutamente 100% definitivamente puedes ...

• asignar el constructor Bluebird a global.Promise
• use request-promise sin errores de compilación
• Asignar Bluebird instancias de clase a la interfaz Promise (que es de lo que trata este problema)

_ Dicho esto, este problema se ha cerrado y no debe utilizarse para continuar las discusiones fuera del tema.
La discusión anterior está fuera de tema, ya que este ticket trata sobre las promesas de Bluebird que no se pueden asignar a ES6 / promesas nativas. Pero como se muestra arriba, este problema se ha solucionado durante mucho tiempo.
Si tiene problemas para usar @types/[email protected] con Bluebird, consulte https://github.com/DefinitelyTyped/DefinitelyTyped/issues/42084 en su lugar.

@lhecker
Gracias por la respuesta. Probé tu proyecto y tampoco funciona:

La instalación de @types/[email protected] tampoco ayuda:

El proyecto modificado se puede encontrar aquí:
https://github.com/chebum/request-promise-sample

@chebum Su comentario anterior no dejó en claro que está tratando de escribir funciones asíncronas como las que devuelven un Bluebird<T> . En ese caso, ya podría haberte dicho que, lamentablemente, esto no es posible. Como puede ver en la salida de su compilador, _debe_ devolver un tipo Promise<T> de una función asíncrona.

Sin embargo, si desea renunciar un poco a la seguridad de su tipo, puede hacer lo siguiente:

1. Agregar @types/bluebird-global como dependencia
2. Reemplazar el constructor Promise global: window.Promise = Bluebird as any;
3. Escribir: async function testFn(): Promise<void>
4. El tipo global Promise<T> ahora es casi idéntico a Bluebird<T> y debería poder utilizar todas las funciones importantes de Bluebird.

Si encuentra algún error de Symbol.species , etc., por favor _no_ use este boleto, sino el # 42084.