or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

configuration.mdindex.mdredis-service.mdservice-factory.md
tile.json

tessl/npm-midwayjs--redis

Redis component for Midway.js framework providing comprehensive Redis database integration with support for single instances, clusters, and sentinel configurations

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@midwayjs/redis@3.20.x

To install, run

npx @tessl/cli install tessl/npm-midwayjs--redis@3.20.0

index.mddocs/

@midwayjs/redis

@midwayjs/redis is a Redis component for the Midway.js Node.js framework that provides comprehensive Redis database integration capabilities. It serves as a service factory wrapper around the ioredis library, offering support for single Redis instances, Redis Sentinel high-availability setups, and Redis Cluster configurations with automatic client lifecycle management.

Package Information

  • Package Name: @midwayjs/redis
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install @midwayjs/redis
  • Dependencies: ioredis@5.4.2

Core Imports

import { RedisService, RedisServiceFactory, Configuration } from "@midwayjs/redis";

For accessing the original ioredis class:

import { Redis } from "@midwayjs/redis";

Basic Usage

import { RedisService } from "@midwayjs/redis";
import { Inject } from "@midwayjs/core";

// In a Midway.js service or controller
export class UserService {
  @Inject()
  redisService: RedisService;

  async cacheUser(id: string, userData: any) {
    // Use like standard ioredis - all Redis methods available
    await this.redisService.set(`user:${id}`, JSON.stringify(userData));
    await this.redisService.expire(`user:${id}`, 3600);
  }

  async getUser(id: string) {
    const cached = await this.redisService.get(`user:${id}`);
    return cached ? JSON.parse(cached) : null;
  }
}

Architecture

@midwayjs/redis is built around several key components:

  • Service Factory Pattern: RedisServiceFactory manages multiple Redis client instances with configuration-driven setup
  • Service Wrapper: RedisService provides the default Redis client with full ioredis API delegation
  • Lifecycle Management: RedisConfiguration handles application startup, shutdown, and health checks
  • Multi-Client Support: Support for multiple named Redis connections (single, cluster, sentinel)
  • Health Monitoring: Built-in health checks for monitoring Redis connection status

Capabilities

Service Factory

Core service factory for creating and managing Redis client instances with support for single, cluster, and sentinel configurations.

class RedisServiceFactory extends ServiceFactory<Redis> {
  protected redisConfig: ServiceFactoryConfigOption<RedisConfigOptions>;
  protected logger: ILogger;
  
  protected async createClient(config: RedisConfigOptions): Promise<Redis>;
  getName(): string;
  protected async destroyClient(redisInstance: Redis): Promise<void>;
}

Service Factory

Redis Service

Main service wrapper that provides access to Redis operations through dependency injection, delegating all ioredis methods.

class RedisService implements Redis {
  private serviceFactory: RedisServiceFactory;
  private instance: Redis;
  
  defineCommand(
    name: string,
    definition: {
      lua: string;
      numberOfKeys?: number;
      readOnly?: boolean;
    }
  ): void;
}

interface RedisService extends Redis {}

Redis Service

Configuration Management

Lifecycle and health check management for Redis components within the Midway.js framework.

class RedisConfiguration implements ILifeCycle {
  async onReady(container: IMidwayContainer): Promise<void>;
  async onStop(container: IMidwayContainer): Promise<void>;
  async onHealthCheck(container: IMidwayContainer): Promise<HealthResult>;
}

Configuration

Types

import { ServiceFactoryConfigOption } from '@midwayjs/core';
import { ClusterNode, ClusterOptions } from 'ioredis';

type RedisConfigOptions = 
  | Redis.RedisOptions
  | ({
      cluster?: boolean;
      nodes?: ClusterNode[];
    } & ClusterOptions);

interface HealthResult {
  status: boolean;
  reason: string;
}

interface MidwayCommonError extends Error {
  name: 'MidwayCommonError';
}