@types/connect-redis

What is @types/connect-redis?

@types/connect-redis provides TypeScript type definitions for the connect-redis package, which is a Redis session store for Express. This package allows developers to use Redis as a session store in their Express applications with type safety provided by TypeScript.

What are @types/connect-redis's main functionalities?

Setting up Redis session store

This code demonstrates how to set up a Redis session store in an Express application using the connect-redis package. The RedisStore is created with a Redis client and used as the session store in the Express app.

const session = require('express-session');
const RedisStore = require('connect-redis')(session);
const redisClient = require('redis').createClient();

const app = require('express')();

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: 'your-secret-key',
  resave: false,
  saveUninitialized: false
}));

Configuring Redis store options

This code sample shows how to configure various options for the Redis store, such as host, port, TTL (time to live), database index, password, and key prefix. These options allow for more fine-grained control over the Redis session store.

const session = require('express-session');
const RedisStore = require('connect-redis')(session);
const redisClient = require('redis').createClient();

const app = require('express')();

app.use(session({
  store: new RedisStore({
    client: redisClient,
    host: 'localhost',
    port: 6379,
    ttl: 260,
    disableTTL: false,
    db: 0,
    pass: 'your-password',
    prefix: 'sess:'
  }),
  secret: 'your-secret-key',
  resave: false,
  saveUninitialized: false
}));

Other packages similar to @types/connect-redis

@types/express-session

@types/express-session provides TypeScript type definitions for the express-session package, which is a general session middleware for Express. While it does not specifically target Redis, it is a core dependency for connect-redis and can be used with various session stores.

@types/ioredis

@types/ioredis provides TypeScript type definitions for the ioredis package, which is a robust, full-featured Redis client for Node.js. While it does not provide session store functionality, it can be used to interact with Redis in a more general sense and can be combined with other packages to achieve similar results.

@types/redis

@types/redis provides TypeScript type definitions for the redis package, which is a popular Redis client for Node.js. Similar to @types/ioredis, it does not provide session store functionality but can be used to interact with Redis and can be combined with other packages for session management.

README

Installation

npm install --save @types/connect-redis

Summary

This package contains type definitions for connect-redis (https://npmjs.com/package/connect-redis).

Details

Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect-redis.

index.d.ts

// Type definitions for connect-redis
// Project: https://npmjs.com/package/connect-redis
// Definitions by: Xavier Stouder <https://github.com/xstoudi>
//                   Seth Butler <https://github.com/sbutler2901>
//                 Jip Sterk <https://github.com/JipSterk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3

/// <reference types="express" />
/// <reference types="express-session" />
/// <reference types="redis" />

declare module "connect-redis" {
    import * as express from "express";
    import * as session from "express-session";
    import * as ioRedis from "ioredis";
    import * as redis from "redis";

    function s(options: (options?: session.SessionOptions) => express.RequestHandler): s.RedisStore;

    namespace s {
        type Client = redis.RedisClient | ioRedis.Redis | ioRedis.Cluster;
        interface RedisStore extends session.Store {
            new(options: RedisStoreOptions): RedisStore;
            client: Client;
        }
        interface RedisStoreOptions {
            client?: Client | undefined;
            host?: string | undefined;
            port?: number | undefined;
            socket?: string | undefined;
            url?: string | undefined;
            ttl?: number | string | ((store: RedisStore, sess: session.SessionData, sid: string) => number) | undefined;
            disableTTL?: boolean | undefined;
            disableTouch?: boolean | undefined;
            db?: number | undefined;
            pass?: string | undefined;
            prefix?: string | undefined;
            unref?: boolean | undefined;
            serializer?: Serializer | JSON | undefined;
            logErrors?: boolean | ((error: string) => void) | undefined;
            scanCount?: number | undefined;
        }
        interface Serializer {
            stringify: Function;
            parse: Function;
        }
    }

    export = s;
}

Additional Details

• Last updated: Mon, 04 Sep 2023 15:41:08 GMT
• Dependencies: @types/express, @types/express-session, @types/ioredis, @types/redis
• Global values: none

Credits

These definitions were written by Xavier Stouder, Seth Butler, and Jip Sterk.