Prerequisites

I am trying to verify the presence of an active Redis connection by using Redis.activeConnectionsCount, however, it always returns a value of 0 despite having correct credentials. Upon checking the list of connections in redis-cli, I noticed that there are no active connections except for the one established by redis-cli. The status of the connection also appears as "connecting" when checked using Redis.connection().status.

As a temporary solution, I have implemented a workaround by checking the connection in the boot method of the AppProvider. This establishes the connection once the application is up and running.

Image 1. Status is "connecting".

Image 2. Checking for status. Then wait 5 seconds and then checking for status again. Status is "ready".

Package version

7.3.1

Node.js and npm version

16.17.0 & 8.15.0

Sample Code (to reproduce the issue)

AppProvider.ts

import { ApplicationContract } from '@ioc:Adonis/Core/Application'

export default class AppProvider {
  constructor(protected app: ApplicationContract) {}

  public register() {
    // Register your own bindings
  }

  public async boot() {
    const Redis = (await import('@ioc:Adonis/Addons/Redis')).default;

    // console.log(Redis.activeConnectionsCount)
    // console.log(Redis.connection().status)

    await new Promise((resolve) => {
      setTimeout(() => resolve(true), 5000)
    })

    console.log(Redis.activeConnectionsCount) // always 0 if lines 13 and 14 are commented out
    console.log(Redis.connection().status) // always "connecting" if lines 13 and 14 are commented out
  }

  public async ready() {
    // App is ready
  }

  public async shutdown() {
    // Cleanup, since app is going down
  }
}

Package version

9.1

Describe the bug

I get the following error in my code while am following the documentation.

With IORedis

redis.on('message', (channel, messages) => {
  console.log(message)
})

redis.subscribe('user:add', (error, count) => {
  if (error) {
    console.log(error)
  }
})

With AdonisJS

redis.subscribe('user:add', (message) => {
  console.log(message)
},
{
  onError(error) {
    console.log(error)
  },
  onSubscription(count) {
    console.log(count)
  },
})

Expected 2 arguments, but got 3.ts(2554)

        redis.subscribe(`job-application:${entityId}`, (message) => {
            console.log('send message:', message)
        }, {
            onError(error) {
                console.error('Failed to subscribe:', error)
            },
            onSubscription(count) {
                console.log(`Subscribed to ${count} channels.`)
            },
        })

Reproduction repo

No response

Package version

7.3.4

Describe the bug

I am running the redis' geo functions like georadius() in my code but it is giving me error:

This is my controller code:

import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
import Redis from '@ioc:Adonis/Addons/Redis'

export default class RedisController {
    public async makeConnection({ request }: HttpContextContract) {

        
        const radius = 50  // Specify your radius in meters
      const options = ['WITHDIST', 'WITHCOORD', 'ASC', 'COUNT', '1']

      // Use GEORADIUS command to find the nearest point
      const results = await Redis.georadius('track_wr', 72.8273470257908, 18.9345157490157, radius, 'm', ...options)

      console.log(results);
    }

Error: "message": "Redis_1.default.georadius is not a function",

upon investigating, I found my ioMethods.ts file do not have following array elements:

'geoadd',
'geodist',
'geodistBuffer',
'geohash',
'geohashBuffer',
'geopos',
'georadius',
'georadius_ro',
'georadiusbymember',
'georadiusbymember_ro',
'geosearch',
'geosearchstore',

I

Reproduction repo

No response

What happens

The adonisjs server is running.
Redis-server goes down.
client sends a request to /key
client will never receive a response (client browser waits for the response indefinitely)

Package version

Adonis 4.1 (api only)
the version adonisjs installed: adonis install @adonisjs/redis : "@adonisjs/redis": "^2.0.7"

Node.js and npm version

Node v12.18.1
yarn 1.22.4 (project setup with --yarn)
npm 6.14.5

Sample Code (to reproduce the issue)

Every config is on its default
app/Http/KeyController.js:

class KeyController {
	async index({ request, response }) {
		try {
			const value = await Redis.get("mykey");
			if (value) {
				return response.send({ value });
			}
			return response.notFound();
		} catch (err) {
			return response.status(500).send({ error: err.toString() });
		}
	}
}

Add Route.get("key", "KeyController.index"); to start/routes.js

What is also annoying is that there will be many tries to connect and therefore many error lines in console about
[ioredis] Unhandled error event: Error: connect ETIMEDOUT
But there is no way to handle it [Redis.on("error", (err) => {//handling... }) does not work ]

So is there any workaround on how to send a response to the client when this condition happens?

Package version

8.0.0

Describe the bug

Error: Package subpath './package.json' is not defined by
"exports" in
/Users/abiliocoelho/www/projects/smileCare/api/node_modules/@adonisjs/redis/package.json

Reproduction repo

No response

Hello,
A very small and practical feature.
Would it be possible to add a way to remove the MessageBuilder from the publish (by an argument for example)?
Thanks in advance!

Package version

8.0.1

Describe the bug

When i use ioredis or redis-cli, I can connect to upstash with tls enabled

import { Redis } from "ioredis"

const  redis = new Redis({
    host: 'usw2-renewed-cat-30994.upstash.io',
    port: 30994,
    username: 'default',
    password: '',
    db: 0,
    keyPrefix: '',
    tls: {}
})
console.log(await redis.set('o', 'k'))
redis.disconnect()

But if i configure it in adonis like this, it timed out

        main: {
            host: env.get('REDIS_HOST'),
            port: env.get('REDIS_PORT'),
            username: 'default',
            password: env.get('REDIS_PASSWORD', ''),
            db: 0,
            keyPrefix: '',
            retryStrategy(times) {
                return times > 10 ? null : times * 50
            },
            // enable tls here: https://github.com/redis/ioredis?tab=readme-ov-file#tls-options
            tls: {}
        }

Reproduction repo

No response

I seem to have installed and configured Redis correctly as specified, but whenever I try to use some redis command I get this error message: "NOAUTH Authentication required.".
I'm using --requirepass and even setting the 'password' property on the local connection in config redis I'm still "NOAUTH". What to do?

redis.ts

...
connection: Env.get('REDIS_CONNECTION'),
connections: {
   local: {
      host: Env.get('REDIS_HOST'),
      port: Env.get('REDIS_PORT'),
      password: Env.get('REDIS_PASSWORD', ''),
      db: 0,
      keyPrefix: 'cache:',
   },
}

.env

REDIS_CONNECTION=local
REDIS_HOST=127.0.0.1
REDIS_PORT=6379
REDIS_PASSWORD=123

docker-compose.yml

services:
   redis:
       image: redis:latest
       restart: always
       command: redis-server --save 60 1 --loglevel warning --requirepass 123
       ports:
         - '6379:6379'

https://oss.redis.com/redisjson/

In my use case I am creating new clients in AWS and need to update the application redis configuration to add them during run time.

We can do this with Database.patch() for Lucid in adonis for multi tenant databases, but I think it would be nice to do this with Redis, but I cannot find documentation on how to accomplish this.

This would be a nice to have so I don't have to reset my app to connect to my new tenant's redis client.

Package version

@adonisjs/redis version "^7.3.2"

Node.js and npm version

node : v18.12.1
npm : 8.19.2

Sample Code (to reproduce the issue)

.env file

config/session.ts

config/redis.ts

package.json

BONUS (a sample repo to reproduce the issue)

I got error like this

I followed redis setup on https://docs.adonisjs.com/guides/redis. I can get and set data from redis, but I'm not able to use getdel:

const value= await Redis.get('key'); // works

const value= await Redis.getdel('key'); // error

Error:
Redis_1.default.getdel is not a function

The getdel is offered by IDE autocomplete and also has a definition in RedisCommander.ts (ioredis):

/**
  * Get the value of a key and delete the key
  * - _group_: string
  * - _complexity_: O(1)
  * - _since_: 6.2.0
  */
 getdel(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;

Package version

2.0.7

Node.js and npm version

v10.12.0 (current LTS)

Sample Code

'use strict'

const { Command } = require('@adonisjs/ace')

const Redis = use('Redis')
const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms))

class TestRedisIssue extends Command {
  static get signature () {
    return 'test:redis:issue'
  }

  static get description () {
    return 'Tell something helpful about this command'
  }

  async handle (args, options) {
    this.info('Dummy implementation for test:redis:issue command')

    // Note: the adonis 4.1 docs (wrongly) says "message, channel, pattern"
    Redis.psubscribe('my-pattern-event:*', (pattern, message, channel) => { 
      console.log('redis:pmessage', pattern, message, channel)
    })

    Redis.subscribe('some-temp-channel', message => {
      console.log('redis:message:some-temp-channel', message)
    })

    await sleep(100)
    Redis.publish('my-pattern-event:test', 'test') // received
    await sleep(100)
    Redis.publish('some-temp-channel', 'some-message') // received
    await sleep(100)
    Redis.unsubscribe('some-temp-channel') // triggers the issue
    await sleep(100)
    Redis.publish('my-pattern-event:test2', 'test2') // not received! (this is bad since we did not unsubscribed from this pattern)
    await sleep(100)
    Redis.subscribe('some-other-queue', () => {}) // error:
    /*
      2018-10-26T12:01:37.961Z - warning:
        WARNING: Adonis has detected an unhandled promise rejection, which may
        cause undesired behavior in production.
        To stop this warning, use catch() on promises or wrap await
        calls inside try/catch.

      Error: Connection is closed.
          at Redis.sendCommand (/home/richie/dev/(redacted)/node_modules/ioredis/lib/redis.js:558:20)
          at Redis.subscribe (/home/richie/dev/(redacted)/node_modules/ioredis/lib/commander.js:131:17)
      From previous event:
          at Command.initPromise (/home/richie/dev/(redacted)/node_modules/ioredis/lib/command.js:63:18)
          at new Command (/home/richie/dev/(redacted)/node_modules/ioredis/lib/command.js:51:8)
          at Redis.subscribe (/home/richie/dev/(redacted)/node_modules/ioredis/lib/commander.js:131:29)
          at Promise (/home/richie/dev/(redacted)/node_modules/@adonisjs/redis/src/RedisFactory/index.js:218:33)
          at new Promise (<anonymous>)
          at Proxy.subscribe (/home/richie/dev/(redacted)/node_modules/@adonisjs/redis/src/RedisFactory/index.js:196:12)
          at TestRedisIssue.handle (/home/richie/dev/(redacted)/app/Commands/TestRedisIssue.js:37:11)
    */
  }
}

module.exports = TestRedisIssue

Heart of the issue

Here:
https://github.com/adonisjs/adonis-redis/blob/03b45cfd379130fce981c2ab16b7f6a0504e7185/src/RedisFactory/index.js#L303

It checks if there is any other registered channel sub, but it doesn't check for any pchannel (different variable), so it disconnects the redis-sub connection.

And the reason of the triggered error is: the disconnect process doesn't clear the this.subscriberConnection variable ; auto-connect is consequently not called :
https://github.com/adonisjs/adonis-redis/blob/03b45cfd379130fce981c2ab16b7f6a0504e7185/src/RedisFactory/index.js#L165

My advice: do not close the connection, redis is capable of handling many many ones (https://redis.io/topics/clients#maximum-number-of-clients), a double connection from each instance would not matter that much (plus it was a needed slot just before closing it). If an adonis instance is based on a sub/unsub workflow, it will uselessly connects and disconnects to the redis server each time there is 0 listened channels, not a stable behavior.

Hello,
I have a problem that I did not encounter in the past.
It seems that the subscribe to a channel returns me all the time null.
The connection to Redis works, especially since null is only sent when new content is sent through the channel.

Package version

7.0.2

Node.js and npm version

NodeJS: 6.14.13
NPM: 14.17.0

Sample Code (to reproduce the issue)

Redis.subscribe('test', (message: string) => {
    console.log(message)
})

yield Redis.set('users', JSON.parse(users))

How to set ttl for key 'users' ?

Versions

@adonisjs/cli version: 4.0.12
Node.js version: 14.16.0
NPM version: 6.14.11

Steps to reproduce

1. Start with fresh environment;
2. Install AdonisJS CLI;
   npm install -g @adonisjs/cli
3. Init new project via CLI;
   adonis new project
4. Enter new project directory;
   cd project
5. Install Redis package via CLI;
   adonis install @adonisjs/redis
6. Put "@adonisjs/redis/providers/RedisProvider" to "start/app.js" providers;
7. Check out problems that listed below.

Problem 1

After installation Redis config doesn't appear inside "config" directory.

Problem 2

After run:
adonis serve --dev
Got error:

NOTE

Version 7 is installed by CLI, not manually. Probably TypeScript causes this issue.

Prerequisites

Package version

v2.0.7

Node.js and npm version

node v11.2.0
yarn v1.13.0

Sample Code (to reproduce the issue)

const Redis = use('Redis')
console.log(Redis)

returns

[Function RedisProvider]

and of course fails to execute any redis commands as described in the docs. :(

Package version

7.1.0

Node.js and npm version

16.x and 8.x

External Dependencies

https://github.com/socketio/socket.io 4.4.0
https://github.com/socketio/socket.io-redis-adapter 7.1.0
https://github.com/socketio/socket.io-redis-emitter 4.1.1

Issue description

To bring realtime in my application, I want to use Socket.IO as my websocket provider.
To do so, I create an instance of SocketIO "Server" and put AdonisServer.instance as first argument.
All is working correctly. I can connect to the websocket from my VueJS client.

To be able to work with multiple instance of adonis (like for example, 3 instances in heroku), I'm using the pkg "socket.io-redis-adapter". This pkg, will use the Redis pub/sub mechanism. Each instance of SocketIO.Server listening in each AdonisServer will connect to the my Redis instance and pub/sub to a channel named "socket.io" (default name). I configured 3 connections in adonis - redis.conf (publisher, subscriber, emitter).

Then, for cron jobs, I decided to make a command in adonis. This one will use the pkg "socket.io-redis-emitter". This pkg, help to communicate to each SocketIO.Server connected to the redis instance by publishing a message to the socket.io channel. Then each SocketIO adapters, will receive the message and broadcast this last to each socket connected.

The problem seems to be located in the subscriber client in the adapter and linked to your abstracted subscribe implementation. The subscriber does not seems to receive the published message.

Pls add to package function ioredis 'call'

Redis.call("JSON.GET", id)
TypeError: Redis_1.default.call is not a function

Link to ioredis example: https://github.com/luin/ioredis/blob/main/examples/module.js

Dear,

How can I upgrade to ioredis 5.0.2 version as there is a bug fix(redis/ioredis#1536) in typescript declaration for hmset command which is required for my adonisjs application .

Please help me on this.

Thanks
Suman

Package version

2.0.7

Node.js and npm version

Node: 12.13.1
NPM: 6.12.1

Sample Code (to reproduce the issue)

In RedisFactory:, when we initialize an IoRedis.Cluster the other parameters such as scaleReads is not passed as second parameter. Instead, only redisOptions is passed as stated in the IORedis documentation.

  _newConnection () {
    if (this._useCluster) {
      debug('creating new redis cluster using config: %j', this._config)
      return new IoRedis.Cluster(this._config.clusters, { redisOptions: this._config.redisOptions })
    }
    debug('creating new redis connection using config: %j', this._config)
    return new IoRedis(this._config)
  }

I have directly modified it on my node_modules as a quick test and it worked for me.

  _newConnection () {
    if (this._useCluster) {
      debug('creating new redis cluster using config: %j', this._config)
      return new IoRedis.Cluster(this._config.clusters, { scaleReads: "all", redisOptions: this._config.redisOptions })
    }
    debug('creating new redis connection using config: %j', this._config)
    return new IoRedis(this._config)
  }

As seen on this metric, all replicas are receiving traffic after I added the scaleReads option.

As a side note, any chance we can jump to a newer version of IORedis?

Package version

v5.0.9

Node.js and npm version

• node: v14.15.1
• npm: v6.14.8

Issue

tslib has become an indirect dependency due to the ts compiler option "importHelpers": true used here: 5e73968#diff-b55cdbef4907b7045f32cc5360d48d262cca5f94062e353089f189f4460039e0R6

Importing the transpiled code requires for the "importer" to have installed tslib (dependency)

Example: node_modules/@adonisjs/redis/build/src/RedisConnection/index.js

"use strict";
/*
 * @adonisjs/redis
 *
 * (c) Harminder Virk <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.RedisConnection = void 0;
const tslib_1 = require("tslib");

Users now get the following exception when starting the production server:

Error: Cannot find module 'tslib'
Require stack:
- /app/node_modules/@adonisjs/redis/build/src/RedisConnection/index.js
- /app/node_modules/@adonisjs/redis/build/src/RedisManager/index.js
- /app/node_modules/@adonisjs/redis/build/providers/RedisProvider.js
- /app/node_modules/@poppinss/utils/build/src/esmRequire.js
- /app/node_modules/@poppinss/utils/build/index.js
- /app/node_modules/@adonisjs/fold/build/src/Ioc/index.js
- /app/node_modules/@adonisjs/fold/build/index.js
- /app/node_modules/@adonisjs/application/build/index.js
- /app/node_modules/@adonisjs/core/build/standalone.js
- /app/server.js
at Function.Module._resolveFilename (internal/modules/cjs/loader.js:880:15)
at Function.Module._load (internal/modules/cjs/loader.js:725:27)
at Module.require (internal/modules/cjs/loader.js:952:19)
at require (internal/modules/cjs/helpers.js:88:18)
at Object.<anonymous> (/app/node_modules/@adonisjs/redis/build/src/RedisConnection/index.js:12:17)
at Module._compile (internal/modules/cjs/loader.js:1063:30)
at Object.Module._extensions..js (internal/modules/cjs/loader.js:1092:10)
at Module.load (internal/modules/cjs/loader.js:928:32)
at Function.Module._load (internal/modules/cjs/loader.js:769:14)
at Module.require (internal/modules/cjs/loader.js:952:19)

Reproducing

Create a hello-world template project and add redis following the redis guide
Then:

• npm run build
• cp -r ./build ../../somewhere/soThatParentNodeModulesIsNotUsed
• cd
• npm ci --production
• node server.js

Sample Repository

https://github.com/kidroca/adonis-redis-tslib-error-sample

Package version

"@adonisjs/redis": "^2.0.7"

Node.js and npm version

Node: v10.8.0
Npm:6.4.1

Sample Code (to reproduce the issue)

Redis.subscribe('news',async (msg) => {
  console.log(msg)
});

The start/redis.js file which copied from https://github.com/adonisjs/adonis-redis/blob/develop/examples/listener.js seems not booted by default. Because for example if I uncomment

Redis.subscribe('news',async (msg) => {
  console.log(msg)
});

this piece of code, and publish a message from redis-cli to news channel, nothing happens and redis returns 0 which means channel has no subscriber.
If I copy the code above to event.js, It works as expected. Do I have to register/boot manually the redis.js (listener) file ? I think It should be registered/booted by default. Or am I missing something else?
Thanks!

Use adonis-cli create new scaffold, follow the docs of Redis chapter settings.

When I change sessions driver to redis. then refresh the page, it was hangs

But , in booystrap/events.js:

const Redis = use('Redis')
Redis.on('connect', function () {
  console.log('connected')
})

Redis.on('error', function (error) {
  console.log(error)
})

the code output connected, no error outputs, how could i debug with it?

In @adonisjs/redis, trying to do redis.subscribe() when the specified channel already has an active subscription will throw an error.

It would be nice if instead of throwing, @adonisjs/redis was able to intelligently group duplicate subscriptions together.

redis.subscribe('users/123', callback); // opens connection

// later...
redis.subscribe('users/123', callback); // reuses existing subscription

@adonisjs/redis is described as "The package is a thin wrapper on top of ioredis with better DX around Pub/Sub and automatic management of multiple redis connections", so this feature seems very inline with the package's goals.

Originally posted as a discussion here

Summary

When adding strict mode to tsconfig.json we encounter errors in typechecking as the redis config types cannot be found

Package version

7.3.0

Node.js and npm version

Node: 16.15.1
NPM: 8.11.0

Sample Code (to reproduce the issue)

npx create-adonis-ts-app hello-world
cd hello-world
npm i @adonisjs/redis
node ace configure @adonisjs/redis

---- add strict to tsconfig.json
----- run a tsc typecheck

BONUS (a sample repo to reproduce the issue)

Hello,

For some reason, if I use a connection string to connect it attempts to connect to 127.0.0.1:6379:

config:

..
docker: 'redis://redis:6379',
..

error:

server_1    | [ioredis] Unhandled error event: Error: connect ECONNREFUSED 127.0.0.1:6379
server_1    |     at Object._errnoException (util.js:999:13)
server_1    |     at _exceptionWithHostPort (util.js:1020:20)

In order for the provider to connect correctly I need to use:

config:

...
  docker: {
    host: 'redis',
    port: 6379,
    password: null,
    db: 0,
    keyPrefix: ''
  },
...

But ioredis does allow connecting via connection string:

https://github.com/luin/ioredis#connect-to-redis

I'm having some issues with an Adonis application that is using Redis (3.0) for both sessions and caching. The application recently produced an error from Redis: ERR max number of clients reached.

Upon looking into the issue I noticed that any new connection to Redis from the Adonis Application (which appears to be every HTTP Request) doesn't appear to be getting disconnected. This resulted in an ever increasing number of clients+connections eventually hitting my configured limit of 1024. I was able to increase the maxclients setting to temporarily restore the application.

I'm curious if there is something that I'm missing here or if this is the expected behavior? It could very well be a Redis configuration issue on my part but Redis documentation seems to lay the blame for too many connections on the application-side not properly disconnecting old clients.

Any insight would be much appreciated. Thanks.

Add feedback when connection config is invalid. Currently, it just hangs indefinitely without feedback which makes it hard to debug.

Possibly add a timeout to the connection and fail with an error?