|
"use strict";
|
|
const http = require( 'http' )
|
const socketIO = require( 'socket.io' )
|
const compose = require( 'koa-compose' )
|
|
const Socket = require( './lib/socket' )
|
|
|
/**
|
* Main IO class that handles the socket.io connections
|
* @class
|
*/
|
module.exports = class IO {
|
/**
|
* @constructs
|
* @param namespace <String> namespace identifier
|
*/
|
constructor( opts ) {
|
if ( opts && !(typeof opts !== 'string' || opts && typeof opts !== 'object' ) ) {
|
throw new Error( 'Incorrect argument passed to koaSocket constructor' )
|
}
|
|
/**
|
* List of middlewares, these are composed into an execution chain and
|
* evaluated with each event
|
* @type <Array:Function>
|
*/
|
this.middleware = []
|
|
/**
|
* Composed middleware stack
|
* @type <Function>
|
*/
|
this.composed = null
|
|
/**
|
* All of the listeners currently added to the IO instance
|
* event:callback
|
* @type <Map>
|
*/
|
this.listeners = new Map()
|
|
/**
|
* All active connections
|
* id:Socket
|
* @type <Map>
|
*/
|
this.connections = new Map()
|
|
/**
|
* Configuration options
|
* @type <Object>
|
*/
|
if ( typeof opts === 'string' ) {
|
opts = {
|
namespace: opts
|
}
|
}
|
this.opts = Object.assign({
|
/**
|
* Namespace id
|
* @type <String>
|
* @default null
|
*/
|
namespace: null,
|
|
/**
|
* Hidden instances do not append to the koa app, but still require attachment
|
* @type <Boolean>
|
* @default false
|
*/
|
hidden: false,
|
|
/**
|
* Options to pass when instantiating socket.io
|
* @type <Object>
|
* @default {}
|
*/
|
ioOptions: {}
|
}, opts )
|
|
/**
|
* Holds the socketIO connection
|
* @type <Socket.IO>
|
*/
|
this.socket = null
|
|
// Bind handlers
|
this.onConnection = this.onConnection.bind( this )
|
this.onDisconnect = this.onDisconnect.bind( this )
|
}
|
|
/**
|
* Attach to a koa application
|
* @param app <Koa app> the koa app to use
|
*/
|
attach( app ) {
|
|
if ( app.server && app.server.constructor.name != 'Server' ) {
|
throw new Error( 'app.server already exists but it\'s not an http server' );
|
}
|
|
if ( !app.server ) {
|
// Create a server if it doesn't already exists
|
app.server = http.createServer( app.callback() )
|
|
// Patch `app.listen()` to call `app.server.listen()`
|
app.listen = function listen(){
|
app.server.listen.apply( app.server, arguments )
|
return app.server
|
}
|
}
|
|
if ( app._io ) {
|
// Without a namespace we’ll use the default, but .io already exists meaning
|
// the default is taken already
|
if ( !this.opts.namespace ) {
|
throw new Error( 'Socket failed to initialise::Instance may already exist' )
|
}
|
|
this.attachNamespace( app, this.opts.namespace )
|
return
|
}
|
|
if ( this.opts.hidden && !this.opts.namespace ) {
|
throw new Error( 'Default namespace can not be hidden' )
|
}
|
|
app._io = new socketIO( app.server, this.opts.ioOptions )
|
|
if ( this.opts.namespace ) {
|
this.attachNamespace( app, this.opts.namespace )
|
return
|
}
|
|
// Attach default namespace
|
app.io = this
|
|
// If there is no namespace then connect using the default
|
this.socket = app._io
|
this.socket.on( 'connection', this.onConnection )
|
}
|
|
/**
|
* Attaches the namespace to the server
|
* @param app <Koa app> the koa app to use
|
* @param id <String> namespace identifier
|
*/
|
attachNamespace( app, id ) {
|
if ( !app._io ) {
|
throw new Error( 'Namespaces can only be attached once a socketIO instance has been attached' )
|
}
|
|
this.socket = app._io.of( id )
|
this.socket.on( 'connection', this.onConnection )
|
|
if ( this.opts.hidden ) {
|
return
|
}
|
|
if ( app[ id ] ) {
|
throw new Error( 'Namespace ' + id + ' already attached to koa instance' )
|
}
|
|
app[ id ] = this
|
}
|
|
/**
|
* Pushes a middleware on to the stack
|
* @param fn <Function> the middleware function to execute
|
*/
|
use( fn ) {
|
this.middleware.push( fn )
|
this.composed = compose( this.middleware )
|
|
this.updateConnections()
|
|
return this
|
}
|
|
/**
|
* Adds a new listeners to the stack
|
* @param event <String> the event id
|
* @param handler <Function> the callback to execute
|
* @return this
|
*/
|
on( event, handler ) {
|
let listeners = this.listeners.get( event )
|
|
// If this is a new event then just set it
|
if ( !listeners ) {
|
this.listeners.set( event, [ handler ] )
|
this.updateConnections()
|
return this
|
}
|
|
listeners.push( handler )
|
this.listeners.set( event, listeners )
|
this.updateConnections()
|
return this
|
}
|
|
/**
|
* Removes a listener from the event
|
* @param event <String> if omitted will remove all listeners
|
* @param handler <Function> if omitted will remove all from the event
|
* @return this
|
*/
|
off( event, handler ) {
|
if ( !event ) {
|
this.listeners = new Map()
|
this.updateConnections()
|
return this
|
}
|
|
if ( !handler ) {
|
this.listeners.delete( event )
|
this.updateConnections()
|
return this
|
}
|
|
let listeners = this.listeners.get( event )
|
let i = listeners.length - 1
|
while( i ) {
|
if ( listeners[ i ] === handler ) {
|
break
|
}
|
i--
|
}
|
listeners.splice( i, 1 )
|
|
this.updateConnections()
|
return this
|
}
|
|
/**
|
* Broadcasts an event to all connections
|
* @param event <String>
|
* @param data <?>
|
*/
|
broadcast( event, data ) {
|
this.connections.forEach( ( socket, id ) => {
|
socket.emit( event, data )
|
})
|
}
|
|
/**
|
* Triggered for each new connection
|
* Creates a new Socket instance and adds that to the stack and sets up the
|
* disconnect event
|
* @param sock <Socket.io Socket>
|
* @private
|
*/
|
onConnection( sock ) {
|
// let instance = new Socket( sock, this.listeners, this.middleware )
|
let instance = new Socket( sock, this.listeners, this.composed )
|
this.connections.set( sock.id, instance )
|
sock.on( 'disconnect', () => {
|
this.onDisconnect( sock )
|
})
|
|
// Trigger the connection event if attached to the socket listener map
|
let handlers = this.listeners.get( 'connection' )
|
if ( handlers ) {
|
handlers.forEach( handler => {
|
handler({
|
event: 'connection',
|
data: instance,
|
socket: instance.socket
|
}, instance.id )
|
})
|
}
|
}
|
|
/**
|
* Fired when the socket disconnects, simply reflects stack in the connections
|
* stack
|
* @param sock <Socket.io Socket>
|
* @private
|
*/
|
onDisconnect( sock ) {
|
this.connections.delete( sock.id )
|
}
|
|
/**
|
* Updates all existing connections with current listeners and middleware
|
* @private
|
*/
|
updateConnections() {
|
this.connections.forEach( connection => {
|
connection.update( this.listeners, this.composed )
|
})
|
}
|
}
|
