@types/socket.io-redis/index.d.ts

// Type definitions for socket.io-redis 1.0.0
// Project: https://github.com/socketio/socket.io-redis
// Definitions by: Philipp Holzer <https://github.com/nupplaphil>
//                 seeLuck <https://github.com/seeLuck>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

import SocketIO = require("socket.io");

declare const SocketIORedis: SocketIORedisStatic;
export = SocketIORedis;

interface SocketIORedisStatic {
    /**
     * Default Redis Adapter constructor
     */
    (): SocketIORedis.RedisAdapter;

    /**
     * Creates a new Redis Adapter
     * @param uri Is a string like localhost:6379 where your redis server is located.
     * @param opts An optional parameters object
     */
    (uri: string, opts?: SocketIORedis.SocketIORedisOptions): SocketIORedis.RedisAdapter;

    /**
     * Creates a new Redis Adapter
     * @param opts A parameters object
     */
    (opts: SocketIORedis.SocketIORedisOptions): SocketIORedis.RedisAdapter;
}

/**
 * TODO: return Value for pubClient and subClient is RedisClient, but the im port throws errors because of "invalid module name in augmenatition"
 *
 */
declare namespace SocketIORedis {
    /**
     * Options to pass to the redis server when creating it
     */
    interface SocketIORedisOptions {

        /**
         * The optional name of the key to pub/sub events on as prefix
         * @default socket.io
         */
        key?: string;

        /**
         * The optional host to connect to redis on
         * @default localhost
         */
        host?: string;

        /**
         * The optional port to connect to redis on
         * @default 6379
         */
        port?: number;

        /**
         * The optional password to connect to redis on
         */
        auth_pass?: number | string;

        /**
         * The optional redis client to publish events on
         */
        pubClient?: any;

        /**
         * The optional redis client to subscribe to events on
         */
        subClient?: any;
    }

    interface RedisAdapter extends SocketIO.Adapter {

        /**
         * This servers key
         */
        uid: string;

        /**
         * The prefix of pub/sub events
         */
        prefix: string;

        /**
         * Optional, the redis client to publish events on
         */
        pubClient?: any;

        /**
         * Optional, the redis client to subscribe to events on
         */
        subClient?: any;

        /**
         * Broadcasts a packet
         * @param packet The packet to broadcast
         * @param opts Any options to send along:
         *    - rooms: An optional list of rooms to broadcast to. If empty, the packet is broadcast to all sockets
         *    - except: A list of Socket IDs to exclude
         *    - flags: Any flags that we want to send along ('json', 'volatile', 'broadcast')
         * @param remote The optional flag, whether the packet came from another node
         */
        broadcast: {
            (packet: any, opts: { rooms?: string[]; except?: string[]; flags?: {[flag: string]: boolean} }): void;
            (packet: any, opts: { rooms?: string[]; except?: string[]; flags?: {[flag: string]: boolean} }, remote?: boolean): void;
        };

        /**
         * Removes a socket from all the rooms that it's joined
         * @param id The ID of the socket that we're removing
         * @param callback An optional callback to call when the socket has been
         */
        delAll: {
            (id: string): void;
            (id: string, callback?: (err?: any) => void): void;
        };

        /**
         * clients returns the list of client IDs connected to rooms across all nodes.
         * @param {string[]} rooms
         * @param {(err?: any, clients: string[]) => void} callback
         */
        clients(rooms: string[], callback: (err: any, clients: string[]) => void) : void;

        /**
         * clients returns the list of client IDs connected to rooms across all nodes.
         * @param {(err?: any, clients: string[]) => void} callback
         */
        clients(callback: (err: any, clients: string[]) => void) : void;

        /**
         * clientRooms returns the list of rooms the client with the given ID has joined
         * (even on another node).
         * @param {string} id
         * @param {(err: any, rooms: string[]) => void} callback
         */
        clientRooms(id: string, callback: (err: any, rooms: string[]) => void) : void;

        /**
         * allRooms returns the list of all rooms.
         * @param {(err: any, rooms: string[]) => void} callback
         */
        allRooms(callback: (err: any, rooms: string[]) => void) : void;

        /**
         * remoteJoin rakes the socket with the given id join the room.
         * The callback will be called once the socket has joined the room, or with an
         * err argument if the socket was not found.
         * @param {string} id the socket Id.
         * @param {string} room the room Id.
         * @param {(err: any) => void} callback
         */
        remoteJoin(id: string, room: string, callback: (err: any) => void) : void;

        /**
         * remoteLeave makes the socket with the given id leave the room.
         * The callback will be called once the socket has left the room, or with an
         * err argument if the socket was not found.
         * @param {string} id the socket Id.
         * @param {string} room the room Id.
         * @param {(err: any) => void} callback
         */
        remoteLeave(id: string, room: string, callback: (err: any) => void) : void;

        /**
         * remoteDisconnect makes the socket with the given id to get disconnected.
         * If close is set to true, it also closes the underlying socket.
         * The callback will be called once the socket was disconnected, or with an
         * err argument if the socket was not found.
         * @param {string} id the socket Id.
         * @param {boolean} close close the underlying socket
         * @param {(err: any) => void} callback
         */
        remoteDisconnect(id: string, close: boolean, callback: (err: any) => void) : void;

        /**
         * customRequest sends a request to every nodes, that will respond through the
         * customHook method.
         * @param {any} data
         * @param {(err: any, replies: any[]) => void} callback
         */
        customRequest(data: any, callback: (err: any, replies: any[]) => void) : void;
    }
}