Junction

Junction is an extensible XMPP middleware layer for Node. Highly scalable applications can be constructed by assembling sets of "plugins" known as middleware and filters. Middleware process incoming stanzas, while filters process outgoing stanzas.

This architecture has been proven effective by Connect, which provides HTTP middleware. Junction adopts this approach, repurposing it for use in XMPP, allowing XMPP applications to be built quickly and easily, while harnessing the powerful patterns familiar to Node.js developers.

Installation

$ npm install junction

Usage

Create an Application

To create a new application, simply invoke junction(). Use the built in message and presence parsing middleware to parse common stanzas.

var app = junction()
  .use(junction.messageParser())
  .use(junction.presenceParser());

Handle Stanzas

Use additional middleware to define your application's behavior. In this example, the built in message middleware is used to handle chat messages. Anytime a message is received, we send a greeting and echo the message body.

app.use(junction.message(function(handler) {
  handler.on('chat', function(stanza) {
    var msg = new Message(stanza.from);
    msg.c('body', {}).t('Hello ' + stanza.from + '!\n\n' +
                        'You said: ' + stanza.body);
    stanza.connection.send(msg);
  });
}));

Junction provides bundled middleware to handle core XMPP functionality. Additional middleware and higher-level frameworks are available as separate modules.

Trailing Middleware

Conclude the app by using the typical trailing middleware:

app.use(junction.serviceUnavailable())
   .use(junction.errorHandler());

serviceUnavailable middleware responds with a service-unavailable stanza error when other XMPP entities send the application a request that it doesn't support. This is recommended for well-behaved XMPP applications.

errorHandler middleware will respond with stanza errors when the application encounters an error condition.

These middleware should be used last in the stack, ensuring that other middleware take priority.

Connect to XMPP Network

With the app configured, connect to the XMPP network.

app.connect({ jid: '[email protected]', password: 's3cr3t' }).on('online', function() {
  console.log('connected as: ' + this.jid);
  this.send(new Presence());
});

Junction uses node-xmpp for the underlying connection, allowing apps to connect as clients, components, or any other supported connection type.

Frameworks

At its core, XMPP is a protocol that allows structured data to be exchanged in real-time between entities on the network. While typically used for instant messaging and presence, numerous XMPP extension protocols (known as XEPs) are available which make XMPP broadly applicable to non-IM applications.

These XEPs build on XMPP's core, while defining their own higher-level semantics. Junction-based frameworks implement support for these extensions, building on essential middleware and enhancing it with tooling designed to support development of applications making use of the XEP.

Middleware

Additional middleware is available to parse non-core extension elements commonly found in stanzas. Some middleware implement complete support for simple XEPs that don't justify the need for a full-fledged framework.

Tests

$ npm install --dev
$ make test

Credits

• Jared Hanson

License

The MIT License

Copyright (c) 2011-2017 Jared Hanson <http://jaredhanson.net/>