How to properly deal with promisifyAll in typescript?

Question

Consider the following code:

import redis = require('redis');  //Has ambient declaration from DT
import bluebird = require('bluebird');  //Has ambient declaration from DT

bluebird.promisifyAll((<any>redis).RedisClient.prototype);
bluebird.promisifyAll((<any>redis).Multi.prototype);

const client = redis.createClient();

client.getAsync('foo').then(function(res) {
    console.log(res);
});

getAsync will error out because it's created on the fly and not defined in any .d.ts file. So what is the proper way to handle this?

Also, even though I have the .d.ts files loaded for redis, I still need to cast redis to any to be used for promisifyAll. Otherwise, it will spill out error:

Property 'RedisClient' does not exist on type 'typeof "redis"'

Is typing it to any the only easy way to go?

Have you ever found a way to resolve this? I am running into same issue... — zam6ak, Apr 13 '16 at 13:31
@zam6ak Yes by using declaration merging. See my answer below. — Dave, Apr 14 '16 at 20:56

score 12 · Accepted Answer · answered Apr 14 '16 at 20:55

12

I'm solving this by declaration merging the setAsync & getAsync methods. I added the following code in my own custom .d.ts file.

declare module "redis" {

    export interface RedisClient extends NodeJS.EventEmitter {
        setAsync(key:string, value:string): Promise<void>;
        getAsync(key:string): Promise<string>;
    }

}

answered Apr 14 '16 at 20:55

Dave

12,117
10
46
52

2

is this maintainable for large libraries? What if you promifisy a lib that has a lots of method - would you have to re-declare all *Async() methods? Because that would be tedious... – zam6ak Apr 19 '16 at 19:28
1

I think explicitly declaring them is essentially the point of using Typescript. The alternative is to use `` which basically returns to the dynamic nature (of javascript). – Dave Apr 21 '16 at 01:46
1

One could implement some sort of offline script that would be a static counterpart of `Promise.promisifyAll`. It would take a reference to original typings and would produce an "appendfix" with `*Async` functions. – cubuspl42 May 09 '17 at 15:12
really hope typescript team can add some promisifyAll in the beautiful language – stanleyxu2005 Jan 27 '18 at 15:49

score 6 · Answer 2 · answered Dec 30 '19 at 06:52

Another way to do it which requires less code is to extend the Redis object like so:

import { promisify } from 'util';
import { ClientOpts, RedisClient } from 'redis';

class AsyncRedis extends RedisClient {
  public readonly getAsync = promisify(this.get).bind(this);
  public readonly setAsync = promisify(this.set).bind(this);
  public readonly quitAsync = promisify(this.quit).bind(this);
  public readonly rpushAsync: (list: string, item: string) => Promise<number> = promisify(
    this.rpush
  ).bind(this);
  public readonly blpopAsync: (
    list: string,
    timeout: number
  ) => Promise<[string, string]> = promisify(this.blpop).bind(this);
  public readonly flushdbAsync = promisify(this.flushdb).bind(this);
}

Notice that not all method signatures overwrite correctly, so you have to help typescript a little.

Now you can just use this enhanced class by creating it with your options, for example:

new AsyncRedis({
  host: process.env.REDIS_HOST || '127.0.0.1',
  password: process.env.REDIS_PASSWORD || 'whatever',
 });

score 1 · Answer 3 · answered Jul 31 '19 at 20:10

Just adding to Dave's answer, in my needs, I has to add in Multi for atomic operations.

declare module 'redis' {
    export interface RedisClient extends NodeJS.EventEmitter {
        execAsync(...args: any[]): Promise<any>;
        hgetallAsync(...args: any[]): Promise<any>;
        // add other methods here
    }
    export interface Multi extends Commands<Multi> {
        execAsync(...args: any[]): Promise<any>;
        // add other methods here
    }
}

score 0 · Answer 4 · answered Oct 25 '21 at 10:59

This solution works fine for me:

import { promisifyAll } from 'bluebird'; // import here works only if @types/bluebird is installed
import redis, { RedisClient, Multi } from 'redis'; // import here works only if @types/redis is installed

// Convert Redis client API to use promises, to make it usable with async/await syntax
const MultiAsync: any = promisifyAll(Multi.prototype);
const RedisClientAsync: any = promisifyAll(RedisClient.prototype);
const redisAsync = { ...redis, Multi: MultiAsync, RedisClient: RedisClientAsync };

const client: typeof RedisClientAsync = redisAsync.createClient();
// now you can use client async methods, i.e. client.getAsync, client.hgetAsync, client.hsetAsync, client.expireAsync...

How to properly deal with promisifyAll in typescript?

4 Answers4

Linked

Related