Incompatible with NestJS cache store #53

consult-kk · 2022-11-03T16:34:04Z

V3.0.1 is incompatible with NestJS . Unable to register CacheModule using the RedisStore.

"message": "Type 'typeof import(\"cache-test/node_modules/cache-manager-redis-store/dist/index\")' is not assignable to type '(string | CacheStoreFactory | CacheStore) & typeof import(\"/Users/kk/dev/nodejs/cache-test/node_modules/cache-manager-redis-store/dist/index\")'.\n  ...

Here is the code I am using in the module.ts :
`
import * as redisStore from "cache-manager-redis-store";
import { ConfigModule } from '@nestjs/config';

@module({
imports: [
ConfigModule.forRoot(),
CacheModule.register({
isGlobal: true,
store: redisStore,
url: "redis://localhost:6379",
}),
HttpModule,
],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
`

The text was updated successfully, but these errors were encountered:

dimaqw · 2022-11-06T00:23:26Z

The same issue

Alfagun74 · 2022-11-08T20:23:49Z

Same Issue

belyaev-dev · 2022-11-12T22:05:52Z

Same issue

dougrocha · 2022-11-14T22:09:42Z

I found a way to fix this issue although it may not be nice.

import { redisStore } from 'cache-manager-redis-store'

CacheModule.registerAsync({
      isGlobal: true,
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        ttl: configService.get('CACHE_TTL'),
        store: (await redisStore({
          url: configService.get('REDIS_URL'),
        })) as unknown as CacheStore,
      }),
      inject: [ConfigService],
    }),

I'm not exactly sure what's going on outside of the fact the types don't match.

Alfagun74 · 2022-11-15T06:02:26Z

I found a way to fix this issue although it may not be nice.

import { redisStore } from 'cache-manager-redis-store'

CacheModule.registerAsync({
      isGlobal: true,
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        ttl: configService.get('CACHE_TTL'),
        store: (await redisStore({
          url: configService.get('REDIS_URL'),
        })) as unknown as CacheStore,
      }),
      inject: [ConfigService],
    }),

I'm not exactly sure what's going on outside of the fact the types don't match.

Nah thanks imma stay on the old version until something proper gets released

MikeRossXYZ · 2022-11-16T19:01:11Z

@dougrocha You are effectively bypassing the Typescript type checks, which I would not recommend

I'm just stepping back into the Typescript and Node world again after a few years working in Go and Python, but I believe my #54 ⬆️ should get things working in NestJS by narrowing the type definitions provided by this package.

If @dabroek approves of the changes, then you should be unblocked.

iangregsondev · 2022-11-23T13:58:17Z

Also there is another issue. Here is my solution. The in memory provider supports milliseconds by default but the redis provider (this one) supports seconds.

And as others have mentioned, the 3rd argument on the standard in-memory provider takes a number but this provider needs an object with key "ttl" and a number.

More info here..

    // It supports seconds and NOT milliseconds
    if (this.configService.cacheProvider == CacheProvider.redis) {
      // support seconds!!
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      await this.cacheManager.set(apiKey, key, { ttl: this.configService.cacheTtl / 1000 } as any);
    } else {
      // rest of providers should support milliseconds
      await this.cacheManager.set(apiKey, key, this.configService.cacheTtl);
    }

iangregsondev · 2022-11-23T13:59:42Z

My solution above is a bit messy, first I had to use "as any" to bypass type issue but should not all providers support milliseconds? Otherwise you need to add some logic as my reply above ^^^

luluhoc · 2022-12-07T14:35:03Z

@dabroek

GabSnow24 · 2022-12-07T16:38:01Z

I managed to go through this error using require

When i used import and bypass using some weird thing in typescript i cant get anything in Redis container and was receiveng some errors in cache service. by using the code above, i managed to do things work.
const redisStore = require('cache-manager-redis-store').redisStore;

cgat · 2022-12-11T06:50:53Z

For NestJs 8, I wasn't able to get any of the solutions to work.

One solution shown in the NestJs does work

CacheModule.register<ClientOpts>({
      store: redisStore,

      // Store-specific configuration:
      host: process.env.REDIS_HOST,
      port: parseInt(process.env.REDIS_PORT),
      password: process.env.REDIS_PASSWORD,
    }),

But you need to ensure that this is using cache-manager-redis-store 2.0.

marianolinares · 2023-01-05T23:57:04Z

The problem is redisStore is of type Store, and CacheStore is required. My solution is casting redisStore as CacheStore to fix it.

CacheModule.register({ store: redisStore as unknown as CacheStore, host: 'localhost', port: 6379, }),

Pangeran29 · 2023-02-07T08:44:05Z

Hello i solve this problem with down grade version of some packages, go check here
https://github.com/Pangeran29/testing-nestjs/blob/master/src/testing-cache-redis/testing-cahce-redis.MD

yusuftaufiq · 2023-02-14T06:25:00Z

Referring to this comment, I think this issue can be solved if you use node-cache-manager-redis-yet instead.

import { CacheModule, Module } from '@nestjs/common';
import { redisStore } from 'cache-manager-redis-yet';

@Module({
  imports: [
    CacheModule.register({
      store: redisStore,
      url: 'redis://localhost:6379',
    }),
  ],
})

puckj · 2023-02-16T03:56:04Z

Hello i solve this problem with down grade version of some packages, go check here https://github.com/Pangeran29/testing-nestjs/blob/master/src/testing-cache-redis/testing-cahce-redis.MD

Thank you king

AhmedHdeawy · 2023-02-16T12:38:18Z

Hello i solve this problem with down grade version of some packages, go check here https://github.com/Pangeran29/testing-nestjs/blob/master/src/testing-cache-redis/testing-cahce-redis.MD

Thanks

Exilz · 2023-02-17T17:13:09Z

This package is riddled with issues, bad typing, missing methods that are not exposed and so on. I appreciate it for bridging nest's cache manager and redis but at this point I think it's easier to use something like ioredis with very basic abstractions for the set and get methods, and just be done with it.

This issue prevents me from properly closing the connection after running my end to end tests. Previously I couldn't set redis clusters properly because of the way the client is set up and exposed through this additional layer. It works great for simpler projects anyway.

pratyush-prateek · 2023-02-19T06:45:32Z

The solution mentioned by @cgat is working. If we use cache-manager-redis-store 2.0. It fixes the problem

dev-whoan · 2023-02-28T02:18:23Z

Hello i solve this problem with down grade version of some packages, go check here
https://github.com/Pangeran29/testing-nestjs/blob/master/src/testing-cache-redis/testing-cahce-redis.MD

Thanks It works.

ram95krishh · 2023-02-28T22:53:02Z

My solution with a dummy store fallback

import {
  CacheModule,
  CacheModuleOptions,
  CacheStore,
  Module
} from '@nestjs/common'
import { redisStore } from 'cache-manager-redis-store'

class DummyFallBackStore implements CacheStore {
  get(key: string) {
    console.debug(`Dummy Cache :: gets nothing for key - ${key}`)
    return Promise.resolve(undefined)
  }
  set(key: string) {
    console.debug(`Dummy Cache :: sets nothing for key - ${key}`)
    return Promise.resolve(undefined)
  }
  del(key: string) {
    logger.debug(`Dummy Cache :: deletes nothing for key - ${key}`)
    return Promise.resolve(undefined)
  }
}

@Module({
  imports: [
    CacheModule.registerAsync({
      useFactory: async () : Promise<CacheModuleOptions> => {
        try {
          const store = await redisStore({
            url: '<ConnectionString>'
          })
          return { store }
        } catch (error) {
          console.error(error)
          return { store: new DummyFallBackStore() }
        }
      }
    })
  ],
  controllers: [<MyController>]
})
export class MyModule {}

CarsonRoscoe · 2023-03-02T20:41:53Z

Can't take credit, but chiming in, this solution worked for me in app.module.

import { redisStore } from 'cache-manager-redis-store';
...
CacheModule.registerAsync < any > ({
    isGlobal: true,
    imports: [ConfigModule],
    useFactory: async (configService: ConfigService) => {
        const store = await redisStore({
            url: configService.get('REDIS_URL'),
            ttl: 60,
        });
        return {
            store: () => store,
        };
    },
    inject: [ConfigService],
}),

Do note, for some reason ttl changed from milliseconds to seconds with this change, despite the in-memory caching being in milliseconds with my environment

MaksimKiselev · 2023-03-17T11:35:31Z

Problem

Example from official docs works only for cache-manager-redis-store@^2.0.0

cache-manager-redis-store@^2.0.0 incorrectly implement CacheManager interface and accepts TTL as object where ttl property should be in seconds { ttl: TTL_IN_SECONDS } see: #53 (comment)

Solution

The node-cache-manager have now official redis/ioredis cache stores.

npm i --save cache-manager-redis-yet

import { CacheModule, Module } from '@nestjs/common';
import { redisStore } from 'cache-manager-redis-yet';

@Module({
  imports: [
    CacheModule.registerAsync({
      isGlobal: true,
      useFactory: async () => ({
        store: await redisStore({
          host: process.env.REDIS_HOST,
          port: parseInt(process.env.REDIS_PORT!),
        }),
      }),
    }),
  ],
})
export class AppModule {}

alexphamhp · 2023-04-03T09:37:38Z

Thanks @MaksimKiselev
I tried your solution and it works
But, I just want to note that
the TTL when I set, it is miliseconds not seconds

MaksimKiselev · 2023-04-03T10:11:49Z

@alexphamhp I meant that cache-manager-redis-store@^2.0.0 incorrectly implement CacheManager interface and accept ttl parameter as object with ttl property where ttl in seconds.

CacheManager interface define ttl parameter as number where ttl must be in microseconds.

I've update original comment. Thx. 🍻

diariowebsquad · 2023-04-13T21:03:21Z

this correct solution:

CacheModule.registerAsync<any>({
      isGlobal: true,
      imports: [ConfigModule],
      useFactory: async () => {
        const store = await redisStore({
          url: 'redis://redis_listings_service:6379',
          ttl: 0,
        });
        return {
          store: () => store,
        };
      },
    }),

suoncha · 2023-04-23T18:42:14Z

My solution for cache-manager v5 + cache-manager-redis-yet:
jaredwray/cacheable#210 (comment)

tushermahmud · 2023-05-15T17:06:17Z

Here is my solution. Node v:16.18.0 npm v:8.19.2

"@nestjs/cache-manager": "^1.0.0", "@nestjs/common": "^9.0.0", "@nestjs/core": "^9.0.0", "@nestjs/jwt": "^10.0.3", "@nestjs/platform-express": "^9.0.0", "@nestjs/typeorm": "^9.0.1", "bcrypt": "^5.1.0", "bcryptjs": "^2.4.3", "cache-manager": "^5.2.1", "cache-manager-redis-store": "^2.0.0", "cache-manager-redis-yet": "^4.1.1",

import {  Module } from '@nestjs/common';
import { CacheModule } from '@nestjs/cache-manager';
import { JwtModule } from '@nestjs/jwt';
import * as redisStore from 'cache-manager-redis-store';
@Module({
    imports:[JwtModule.register({ secret: 'secret', signOptions:{expiresIn:'1d'} }), CacheModule.register({
        store: redisStore as any,
        host: 'redis',
        port: 6379,
    })],
    exports:[JwtModule, CacheModule]
})
export class SharedModule {}

import { Body, Controller, Get, Post, Param, ParseIntPipe, Put, Delete, UseGuards, UseInterceptors, Inject } from '@nestjs/common';
import { AuthGuard } from 'src/auth/auth.guard';
import { ProductCreateDto } from './dtos/product-create.dto';
import { ProductService } from './product.service';
import { CacheKey,CacheInterceptor,CacheTTL, CACHE_MANAGER } from '@nestjs/cache-manager';
import {Cache} from 'cache-manager'

@controller()
export class ProductController {
constructor(private productService:ProductService, @Inject(CACHE_MANAGER) private cacheManager:Cache){
}

@UseGuards(AuthGuard)
@Get('admin/products')
async getAllProducts(){
    return await this.productService.findAll({});
}

@UseGuards(AuthGuard)
@Post('admin/products')
async create(@Body() body:ProductCreateDto){
    return await this.productService.save(body)
}

@UseGuards(AuthGuard)
@Get('admin/products/:id')
async getProduct(@Param('id', ParseIntPipe) id:number){
    return await this.productService.findById(id)
}

@UseGuards(AuthGuard)
@Put('admin/products/:id')
async update(@Param('id',ParseIntPipe) id:number, @Body() body:ProductCreateDto){
    await this.productService.update(id, body);
    return await this.productService.findById(id);
}

@UseGuards(AuthGuard)
@Delete('admin/products/:id')
async delete(@Param('id') id:number){
    await this.productService.delete(id);
}

@CacheKey('products_frontend')
@CacheTTL(30*60)
@UseInterceptors(CacheInterceptor)
@Get('ambassador/products/frontend')
async frontend(){
    return await this.productService.findAll({})
}

@Get('ambassador/products/backend')
async backend(){
    let products = await this.cacheManager.get('products_backend');
    if(!products) {
        products = await this.productService.findAll({})
        await this.cacheManager.set('products_backend',products, 1800)
    }
    return products;
}

}

jongomes · 2023-07-20T18:29:00Z

CacheModule.registerAsync({
  isGlobal: true,
  useFactory: async () => {

    try {
      const store = await redisStore({
        url: process.env.REDIS,
        ttl: 60000,
        fallback: 'memory' -- it would be interesting to fall back
      });
      return {store};
    } catch (error) {
      return {
        store: 'memory',
      };
    }
  },

alhajee · 2023-07-27T14:15:47Z

cache.module.ts

I personally don't like having my configs directly in my App Module. I separate my configs into different modules and import them into App module.

You'd also notice that I prefer to read my environment variables from the ConfigService instead of reading directly from process.env (This way you have more control for where env files are being read from)

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { CacheModule, CacheModuleAsyncOptions } from '@nestjs/cache-manager';
import { redisStore } from 'cache-manager-redis-store';

@Module({
  imports: [
    CacheModule.registerAsync({
      isGlobal: true,
      imports: [ConfigModule], // No need to call ConfigModule.forRoot again
      inject: [ConfigService],
      useFactory: async (configService: ConfigService) => {
        const isActive = ['true', '1', 'yes'].includes(
          configService.get<string>('API_REDIS_STORE_IS_ACTIVE'),
        );
        return {
          store:
            isActive &&
            (await redisStore({
              // Store-specific configuration:
              socket: {
                host: configService.get<string>('API_REDIS_HOST'),
                port: +configService.get<number>('API_REDIS_PORT'),
              },
            })), // use redis when available or default to cache store
          ttl: 5000, // milliseconds
          max: 10, // maximum number of items in cache
        } as CacheModuleAsyncOptions;
      },
    }),
  ],
})
export class CacheConfigModule {}

arlan85 · 2023-07-31T18:02:47Z

none of this works for me, I'm trying to get information from redis but I. don't get anything from the Redis database

LebranD · 2023-09-21T10:22:21Z

here is my solution

CacheModule.registerAsync<RedisClientOptions>({
           isGlobal: true,
           imports: [ConfigModule],
           inject: [ConfigService],
           useFactory: async (configService: ConfigService) => {
               const redis = configService.get('redis');
               return {
                   store: redisStore,
                   host: redis.host,
                   port: redis.port,
               } as StoreConfig;
           },
       }),

cristian-moreno-ruiz · 2023-11-13T12:01:08Z

It looks like this package is not maintained any more, and, although I'm facing the same issue at the moment, I moved to this other (which is a fork from this one but actively maintained):

https://github.com/node-cache-manager/node-cache-manager-redis-yet

Also, created this issue to be properly tracked:

https://github.com/node-cache-manager/node-cache-manager-redis-yet/issues/394

janardhan5031 · 2024-02-03T12:51:03Z

I found a thing , when i save key value with TTL in redis from nestjs server after ttl expired, the key value not deleting.
Below is my code, let me know if anything went wrong.
Thank you.
`import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { CacheModule, CacheStore } from '@nestjs/cache-manager';
import { redisStore } from 'cache-manager-redis-store';

@module({
imports: [
CacheModule.registerAsync({
useFactory: async () => {
const store = await redisStore({
socket: {
host: 'localhost',
port: 6379,
},
password: '1234',
});

    return {
      store: store as unknown as CacheStore,
    };
  },
}),

],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}

import { Controller, Get, Inject } from '@nestjs/common';
import { AppService } from './app.service';
import { Cache } from 'cache-manager';
import { CACHE_MANAGER } from '@nestjs/cache-manager';

@controller()
export class AppController {
constructor(
private readonly appService: AppService,
@Inject(CACHE_MANAGER) private cacheModule: Cache,
) {}

@get('health-check')
async getHello() {
const data = await this.cacheModule.get('HELLO');
if (data) {
return data;
}

await this.cacheModule.set('HELLO', 'Hello from store', 10);
return 'Hello from server';

}
}`

NathBabs · 2024-02-05T11:09:05Z

none of this works for me, I'm trying to get information from redis but I. don't get anything from the Redis database

I am currently facing this issue, seems it is not using my redis but rather memory.

phankieuphu · 2024-04-24T09:25:15Z

I found solution

  import * as redisStore from 'cache-manager-redis-yet';
 
  @Module({
    imports: [
      CacheModule.register({
        isGlobal: true,
        useFactory: () => ({
          store: redisStore,
        }),
        host: config.REDIS.HOST,
        port: config.REDIS.PORT,
      }),

mariem2189 · 2024-07-15T10:49:48Z

I found a way to fix this issue, casting redisStore to 'any' to bypass the TypeScript error:

import * as redisStore from 'cache-manager-redis-store';

@Module({
  imports: [
    CacheModule.register({
      store: redisStore as any,
      url: 'redis://localhost:6379',
    }),
  ],
})

buidaoanhvan · 2024-10-15T01:53:58Z

import { Module } from '@nestjs/common';
import { CacheModule } from '@nestjs/cache-manager';
import { redisStore } from 'cache-manager-redis-yet';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    CacheModule.registerAsync({
      isGlobal: true,
      useFactory: async () => ({
        store: await redisStore({
          socket: {
            host: 'localhost',
            port: 6379
          }
        })
      })
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule { }

kgkg · 2024-10-26T10:15:38Z

None of above solution works for me. It seems to work because in-memory cache is used silently instead of Redis.

Try turning off Redis (image or service) and try to check if it even connects to it.

Working solution as of Nov 2024 with getting values from ConfigModule:

  imports: [
    CacheModule.registerAsync({
      isGlobal: true,
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: async (configService: ConfigService): Promise<CacheModuleOptions> => {
        try {
          const host = configService.get<string>('REDIS_HOST');
          const port = configService.get<number>('REDIS_PORT');
          const store = await redisStore({
            url: `redis://${host}:${port}`,
          });
          return { store };
        } catch (error) {
          console.error(error);
        }
      },
    }),
  ],

MikeRossXYZ mentioned this issue Nov 16, 2022

Update Typescript definitions to be more specific #54

Open

beeman mentioned this issue Dec 15, 2022

feat: implement api-cache-data-access module for api caching kin-labs/kinetic#523

Merged

MaksimKiselev mentioned this issue Apr 3, 2023

Cache documentation nestjs/docs.nestjs.com#2689

Closed

nfesta2023 mentioned this issue Dec 21, 2023

FES-3 Fix Redis config n-festa/authorization-service#2

Merged

Incompatible with NestJS cache store #53

Incompatible with NestJS cache store #53

Comments

consult-kk commented Nov 3, 2022

dimaqw commented Nov 6, 2022

Alfagun74 commented Nov 8, 2022

belyaev-dev commented Nov 12, 2022

dougrocha commented Nov 14, 2022

Alfagun74 commented Nov 15, 2022

MikeRossXYZ commented Nov 16, 2022

iangregsondev commented Nov 23, 2022

iangregsondev commented Nov 23, 2022

luluhoc commented Dec 7, 2022

GabSnow24 commented Dec 7, 2022

cgat commented Dec 11, 2022

marianolinares commented Jan 5, 2023

Pangeran29 commented Feb 7, 2023

yusuftaufiq commented Feb 14, 2023

puckj commented Feb 16, 2023

AhmedHdeawy commented Feb 16, 2023

Exilz commented Feb 17, 2023

pratyush-prateek commented Feb 19, 2023

dev-whoan commented Feb 28, 2023

ram95krishh commented Feb 28, 2023 • edited Loading

CarsonRoscoe commented Mar 2, 2023 • edited Loading

MaksimKiselev commented Mar 17, 2023 • edited Loading

Problem

Solution

alexphamhp commented Apr 3, 2023

MaksimKiselev commented Apr 3, 2023

diariowebsquad commented Apr 13, 2023

suoncha commented Apr 23, 2023 • edited Loading

tushermahmud commented May 15, 2023

jongomes commented Jul 20, 2023 • edited Loading

alhajee commented Jul 27, 2023

cache.module.ts

arlan85 commented Jul 31, 2023

LebranD commented Sep 21, 2023

cristian-moreno-ruiz commented Nov 13, 2023

janardhan5031 commented Feb 3, 2024 • edited Loading

NathBabs commented Feb 5, 2024

phankieuphu commented Apr 24, 2024

mariem2189 commented Jul 15, 2024

buidaoanhvan commented Oct 15, 2024 • edited Loading

kgkg commented Oct 26, 2024 • edited Loading

ram95krishh commented Feb 28, 2023 •

edited

Loading

CarsonRoscoe commented Mar 2, 2023 •

edited

Loading

MaksimKiselev commented Mar 17, 2023 •

edited

Loading

suoncha commented Apr 23, 2023 •

edited

Loading

jongomes commented Jul 20, 2023 •

edited

Loading

janardhan5031 commented Feb 3, 2024 •

edited

Loading

buidaoanhvan commented Oct 15, 2024 •

edited

Loading

kgkg commented Oct 26, 2024 •

edited

Loading