RedisClientType hard to use with createClient

[tobiasdiez]

The RedisClientType has two generic parameters that make it hard to use to signify the return type of createClient. In particular, the first argument modules in the declaration of createClient is a local variable that is not exported and thus cannot be easily reused in one's own code.

Maybe it's already enough to provide sufficiently general defaults for the generic arguments. If I'm not mistaken these parameters control more the configuration of the client and don't really influence the typing of the "normal" methods; so they are not that important for an user of a factory method.

Below is a similar observation from #1673.

---

The RedisClientType exported since 4.0.1 still does not work for me. Could not figure out how to make the exported RedisClientType, RedisClientOptions and the type returned by createClient compatible. Here is an example that illustrates the issue.

The following does not compile unless someone knows how to type RedisClientOptions correctly (refer to the code sandbox link above).

import { createClient, RedisClientOptions, RedisClientType } from "redis";

const factory = (options: RedisClientOptions<any, any>): RedisClientType => {
  return createClient(options);
};

const client: RedisClientType = factory({...});

Instead, I am doing this for now:

import { createClient} from "redis";
type RedisClientType = ReturnType<typeof createClient>;
type RedisClientOptions = Parameters<typeof createClient>[0];

const factory = (options: RedisClientOptions): RedisClientType => {
  return createClient(options);
};

const client: RedisClientType = factory({...});

Originally posted by @tbinna in #1673 (comment)

[leibale]

RedisModules extends the client with the installed modules commands, RedisScripts extends it with the defined lua scripts (see here).

In case you want to ignore modules and scripts, Record<string, never> should do the trick:

RedisClientType<Record<string, never>, Record<string, never>>

I guess my comment should be added to the docs somewhere, I'll leave this issue open for now

[tobiasdiez]

Thanks! Would it then be an idea to set these generic parameters to Record<string, never> by default, i.e. RedisClientType without any generics specified is equivalent to what you wrote above?

[restfulhead]

@leibale Could you provide an example how to use a typed client with scripts?

What works for me without defining scripts:

export type RedisClientType = ReturnType<typeof createClient>

myCreateClient(port, host, pw): RedisClientType {
 const client: RedisClientType = createClient({
      socket: { port, host, tls: true },
      password: pw,
    })
  return client
}

However, once I add a script, I get a types are incompatible error.

myCreateClient(port, host, pw): RedisClientType {
 const client: RedisClientType = createClient({
      socket: { port, host, tls: true },
      password: pw,
      scripts: {
        add: defineScript({
          NUMBER_OF_KEYS: 1,
          SCRIPT: 'local val = redis.pcall("GET", KEYS[1]);' + 'return val + ARGV[1];',
          transformArguments(key: string, toAdd: number): string[] {
            return [key, toAdd.toString()]
          },
          transformReply(reply: number): number {
            return reply
          },
        }),
      },
    })
  return client
}

[leibale]

@restfulhead

import { createClient, defineScript, RedisModules, RedisScripts, RedisClientType } from '@node-redis/client';

interface ClientOptions<
    M extends RedisModules,
    S extends RedisScripts
> {
    port: number;
    host: string;
    pw: string;
    modules?: M;
    scripts?: S;
}

function clientFactory<
    M extends RedisModules,
    S extends RedisScripts
>(options: ClientOptions<M, S>): RedisClientType<M, S> {
    return createClient({
        socket: {
            port: options.port,
            host: options.host
        },
        password: options.pw,
        modules: options.modules,
        scripts: options.scripts
    });
}

const client = clientFactory({
    port: 6379,
    host: 'host',
    pw: 'pw',
    scripts: {
        add: defineScript({
          NUMBER_OF_KEYS: 1,
          SCRIPT: 'local val = redis.pcall("GET", KEYS[1]);' + 'return val + ARGV[1];',
          transformArguments(key: string, toAdd: number): Array<string> {
            return [key, toAdd.toString()]
          },
          transformReply(reply: number): number {
            return reply
          },
        })
    }
});

client.add('key', 1);
//     ^?

playground

[restfulhead]

Hm...thanks for the example, but what I really need is a factory that returns the type of the configured client; not the generic one. My application will use the same client everywhere, so I need a type to pass around the configured client.

For example say I'd like to pass my client to a function:

// how to best define the MyClient type here?
function doAdd(client: MyClient) {
   client.add('key', 1);
}

Now adding on to your example, the following works, but requires a lot of declaration:

export type MyClient = RedisClientType<RedisModules, {
    add: {
        NUMBER_OF_KEYS: number;
        SCRIPT: string;
        transformArguments(this: void, key: string, toAdd: number): Array<string>;
        transformReply(this: void, reply: number): number;
    } & 
    { 
        SHA1: string;
    }
}>

@leibale Would it be feasible to export the RedisScript and SHA1 types?

This would make the declaration (and therefore using) this library much easier:

export interface ConfiguredRedisScripts extends RedisScripts {
  add: RedisScript
}
export type MyClient = RedisClientType<RedisModules, ConfiguredRedisScripts>

function doAdd(client: MyClient) {
   client.add('key', 1);
}

[leibale]

@restfulhead

import { createClient } from '@node-redis/client';

export const client = createClient({
  modules: {
    // ...
  },
  scripts: {
    // ...
  }
});

export type CustomRedisClient = typeof client;

const duplicate = client.duplicate();

import { createClient } from '@node-redis/client';

const modules = {
  // ...
};

const scripts = {
  // ...
};

export type CustomRedisClient = RedisClientType<typeof modules, typeof scripts>;

export function clientFactory(): CustomRedisClient {
  return createClient({
    modules,
    scripts
  });
}

[tobiasdiez]

@leibale thanks for adding the defaults to the RedisClientType params. However, now the following code

import redis, { RedisClientType } from 'redis'
function createRedisClient(): Promise<RedisClientType> {
    const client = redis.createClient(...redisConfig...)
    await client.connect()
    return client
}

fails with an error of the type

error TS2322: Type 'RedisClientType<{ graph: { CONFIG_GET: typeof import("/home/runner/work/JabRefOnline/JabRefOnline/node_modules/@node-redis/graph/dist/commands/CONFIG_GET"); configGet: typeof import("/home/runner/work/JabRefOnline/JabRefOnline/node_modules/@node-redis/graph/dist/commands/CONFIG_GET"); ... 15 more ...; slowLog: typeo...' is not assignable to type 'RedisClientType<Record<string, never>, Record<string, never>>'.