sockjs-client vs @stomp/stompjs vs stompjs
WebSocket and STOMP Protocol Libraries
Search packages..
sockjs-client@stomp/stompjsstompjsSimilar Packages:
WebSocket and STOMP Protocol Libraries

WebSocket and STOMP Protocol Libraries are essential tools for enabling real-time communication between clients and servers in web applications. WebSockets provide a full-duplex communication channel over a single TCP connection, allowing for low-latency data exchange. STOMP (Simple Text Oriented Messaging Protocol) is a messaging protocol that runs on top of WebSockets, providing a simple and text-based way to send messages between clients and servers. These libraries implement the WebSocket and STOMP protocols, allowing developers to build interactive applications such as chat systems, live notifications, and collaborative tools. They handle the complexities of establishing connections, sending and receiving messages, and managing topics and queues, making it easier for developers to integrate real-time features into their applications.

Npm Package Weekly Downloads Trend
3 Years
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
sockjs-client2,614,5018,523700 kB30-MIT
@stomp/stompjs351,707869473 kB2516 days agoApache-2.0
stompjs01,447-8812 years agoApache-2.0
Feature Comparison: sockjs-client vs @stomp/stompjs vs stompjs

Protocol Support

  • sockjs-client:

    sockjs-client is primarily focused on providing a reliable WebSocket-like API with fallback mechanisms for environments where WebSocket connections may fail. It does not implement the STOMP protocol itself but can be used in conjunction with STOMP clients to provide a more robust connection layer.

  • @stomp/stompjs:

    @stomp/stompjs supports STOMP over WebSocket and provides a flexible architecture that allows for easy integration with different transport protocols. It is designed to work seamlessly with both standard WebSocket connections and fallback transports like SockJS, making it versatile for various environments.

  • stompjs:

    stompjs supports STOMP over WebSocket and SockJS, providing a simple interface for sending and receiving messages. It is a lightweight implementation that adheres to the STOMP protocol specifications, making it compatible with any STOMP-compliant server.

Advanced Features

  • sockjs-client:

    sockjs-client focuses on providing reliable connections with automatic fallback to various transport methods (e.g., XHR, iframe) when WebSockets are not available. It does not provide any STOMP-specific features, as it is primarily a transport layer library.

  • @stomp/stompjs:

    @stomp/stompjs offers a rich set of features, including support for message acknowledgments, transactions, and headers. It also provides a more modern and flexible API compared to older STOMP clients, making it easier to work with asynchronous messaging patterns.

  • stompjs:

    stompjs provides basic STOMP features such as message sending, subscribing to topics, and handling incoming messages. However, it lacks some of the more advanced features found in newer libraries, such as built-in support for message acknowledgments and transactions.

Bundle Size

  • sockjs-client:

    sockjs-client is also lightweight, especially considering the functionality it provides. The library is designed to be efficient and has a small footprint, making it suitable for applications where load time and bandwidth usage are concerns.

  • @stomp/stompjs:

    @stomp/stompjs is relatively lightweight compared to other feature-rich STOMP clients, making it a good choice for performance-sensitive applications. Its modular design allows developers to include only the parts of the library they need, further reducing the overall bundle size.

  • stompjs:

    stompjs is a minimalistic library with a small bundle size, making it ideal for projects that require basic STOMP functionality without adding significant overhead. Its simplicity and focus on core STOMP features make it a good choice for lightweight applications.

Ease of Use: Code Examples

  • sockjs-client:

    WebSocket Fallback Example with sockjs-client

    import SockJS from 'sockjs-client';

const socket = new SockJS('http://localhost:8080/sockjs');

socket.onopen = () => {
  console.log('Connection opened');
  socket.send('Hello, SockJS!');
};

socket.onmessage = (event) => {
  console.log('Message received:', event.data);
};

socket.onclose = () => {
  console.log('Connection closed');
};
  • @stomp/stompjs:

    STOMP over WebSocket Example with @stomp/stompjs

    import { Client } from '@stomp/stompjs';

const client = new Client({
  brokerURL: 'ws://localhost:8080/stomp',
  onConnect: () => {
    console.log('Connected');
    client.subscribe('/topic/messages', (message) => {
      console.log('Received:', message.body);
    });
    client.publish({ destination: '/topic/messages', body: 'Hello, STOMP!' });
  },
});

client.activate();
  • stompjs:

    Basic STOMP Example with stompjs

    import Stomp from 'stompjs';

const socket = new WebSocket('ws://localhost:8080/stomp');
const client = Stomp.over(socket);

client.connect({}, (frame) => {
  console.log('Connected:', frame);
  client.subscribe('/topic/messages', (message) => {
    console.log('Received:', message.body);
  });
  client.send('/topic/messages', {}, 'Hello, STOMP!');
});
How to Choose: sockjs-client vs @stomp/stompjs vs stompjs
  • sockjs-client:

    Choose sockjs-client if you need a library that provides a WebSocket-like API with fallback options for environments where WebSockets are not supported. It is particularly useful for applications that require reliable communication in diverse network conditions and need to handle connection failures gracefully.

  • @stomp/stompjs:

    Choose @stomp/stompjs if you need a modern, feature-rich STOMP client that supports WebSocket, SockJS, and other transport protocols. It is ideal for applications that require advanced features like message acknowledgments, transactions, and support for multiple WebSocket connections.

  • stompjs:

    Choose stompjs if you are looking for a lightweight STOMP client that works well with WebSocket and SockJS. It is suitable for projects that need basic STOMP functionality without the overhead of a larger library. However, it may lack some advanced features found in more modern clients.

Similar Npm Packages to sockjs-client

sockjs-client is a JavaScript library that provides a WebSocket-like object for browsers, allowing for real-time communication between clients and servers. It is designed to work seamlessly across various browsers, even those that do not support WebSockets. By falling back to alternative transport methods like XHR streaming or long polling, sockjs-client ensures reliable communication in diverse environments. This makes it an excellent choice for applications that require real-time features but need to maintain compatibility across different platforms.

While sockjs-client is a robust option for real-time communication, there are several alternatives worth considering:

  • socket.io-client is a popular library that enables real-time, bidirectional communication between web clients and servers. It builds on WebSocket technology and provides additional features such as automatic reconnection, multiplexing, and support for fallback options. socket.io-client is widely used in applications that require real-time updates, such as chat applications or live notifications, due to its ease of use and extensive feature set.

  • stompjs is a JavaScript client for the STOMP (Simple Text Oriented Messaging Protocol) messaging protocol. It is particularly useful for applications that require message-oriented middleware and works well with WebSocket connections. stompjs allows for publish/subscribe messaging patterns, making it suitable for applications that need to handle complex messaging scenarios, such as chat applications or event-driven architectures.

  • websocket is a native JavaScript API that provides a way to open a persistent connection between the client and server. Unlike sockjs-client, which provides fallbacks for unsupported browsers, the WebSocket API requires that the browser supports WebSockets. It is ideal for applications that can guarantee a modern browser environment and need low-latency communication, such as online gaming or real-time collaboration tools.

To see how sockjs-client compares with socket.io-client, stompjs, and websocket, check out the comparison: Comparing socket.io-client vs sockjs-client vs stompjs vs websocket.

Similar Npm Packages to @stomp/stompjs

@stomp/stompjs is a JavaScript library that provides a client for the STOMP (Simple Text Oriented Messaging Protocol) protocol, enabling real-time messaging in web applications. It is commonly used in conjunction with WebSocket connections to facilitate communication between clients and servers. With its straightforward API, @stomp/stompjs makes it easy to implement publish-subscribe messaging patterns in applications, allowing developers to build interactive and responsive user experiences.

While @stomp/stompjs is a robust option for STOMP-based messaging, there are several alternatives that cater to different use cases and protocols:

  • mqtt is a lightweight messaging protocol designed for low-bandwidth, high-latency networks. It is often used in IoT (Internet of Things) applications where devices need to communicate with each other or with a central server. The mqtt library provides a client for connecting to MQTT brokers, making it ideal for scenarios where efficient message delivery and low overhead are critical.

  • socket.io-client is the client-side library for Socket.IO, a popular library that enables real-time, bidirectional communication between web clients and servers. It abstracts WebSocket connections and provides fallbacks for older browsers, making it a versatile choice for real-time applications. If you need a reliable solution for real-time communication with support for various transport methods, socket.io-client is a strong contender.

  • sockjs-client is a JavaScript library that provides a WebSocket-like object in environments that do not support WebSockets. It offers a fallback mechanism to ensure that applications can still communicate in real-time, even in restrictive network conditions. If you require a solution that guarantees connectivity across different environments, sockjs-client is a suitable option.

  • webstomp-client is a client library for STOMP over WebSocket. It provides a simple way to connect to STOMP servers using WebSocket connections, similar to @stomp/stompjs. If you are looking for a lightweight alternative specifically for STOMP messaging, webstomp-client might be a good fit.

To see how @stomp/stompjs compares with mqtt, socket.io-client, sockjs-client, and webstomp-client, check out the comparison: Comparing @stomp/stompjs vs mqtt vs socket.io-client vs sockjs-client vs webstomp-client.

Similar Npm Packages to stompjs

stompjs is a JavaScript library that implements the STOMP (Simple Text Oriented Messaging Protocol) protocol, allowing for easy communication between clients and message brokers. It is particularly useful in applications that require real-time messaging capabilities, such as chat applications or live notifications. While stompjs provides a robust solution for STOMP messaging, there are other libraries in the ecosystem that offer similar functionalities. Here are a few alternatives:

  • @stomp/stompjs is a modern implementation of the STOMP protocol that is actively maintained and designed to work seamlessly with WebSocket connections. It provides a more modular and flexible API compared to the original stompjs library, making it easier to integrate into various applications. If you are looking for an up-to-date STOMP client that supports the latest features and best practices, @stomp/stompjs is an excellent choice. It is particularly well-suited for applications that require robust error handling and connection management.
  • sockjs-client is a JavaScript library that provides a WebSocket-like object in environments that do not support WebSockets. While it is not a STOMP client by itself, it can be used in conjunction with STOMP libraries to provide a fallback mechanism for real-time communication. If your application needs to support a wide range of browsers and environments, including those that do not support WebSockets, sockjs-client can be a valuable addition to your stack.

To see how stompjs compares with @stomp/stompjs and sockjs-client, check out the comparison: Comparing @stomp/stompjs vs sockjs-client vs stompjs.

README for sockjs-client

SockJS-client

npm versionDependenciesChatContributor Covenant BrowserStack Status

SockJS for enterprise

Available as part of the Tidelift Subscription.

The maintainers of SockJS and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.

Summary

SockJS is a browser JavaScript library that provides a WebSocket-like object. SockJS gives you a coherent, cross-browser, Javascript API which creates a low latency, full duplex, cross-domain communication channel between the browser and the web server.

Under the hood SockJS tries to use native WebSockets first. If that fails it can use a variety of browser-specific transport protocols and presents them through WebSocket-like abstractions.

SockJS is intended to work for all modern browsers and in environments which don't support the WebSocket protocol -- for example, behind restrictive corporate proxies.

SockJS-client does require a server counterpart:

Philosophy:

  • The API should follow HTML5 Websockets API as closely as possible.
  • All the transports must support cross domain connections out of the box. It's possible and recommended to host a SockJS server on a different server than your main web site.
  • There is support for at least one streaming protocol for every major browser.
  • Streaming transports should work cross-domain and should support cookies (for cookie-based sticky sessions).
  • Polling transports are used as a fallback for old browsers and hosts behind restrictive proxies.
  • Connection establishment should be fast and lightweight.
  • No Flash inside (no need to open port 843 - which doesn't work through proxies, no need to host 'crossdomain.xml', no need to wait for 3 seconds in order to detect problems)

Subscribe to SockJS mailing list for discussions and support.

SockJS family

Work in progress:

Getting Started

SockJS mimics the WebSockets API, but instead of WebSocket there is a SockJS Javascript object.

First, you need to load the SockJS JavaScript library. For example, you can put that in your HTML head:

<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>

After the script is loaded you can establish a connection with the SockJS server. Here's a simple example:

 var sock = new SockJS('https://mydomain.com/my_prefix');
 sock.onopen = function() {
     console.log('open');
     sock.send('test');
 };

 sock.onmessage = function(e) {
     console.log('message', e.data);
     sock.close();
 };

 sock.onclose = function() {
     console.log('close');
 };

SockJS-client API

SockJS class

Similar to the 'WebSocket' API, the 'SockJS' constructor takes one, or more arguments:

var sockjs = new SockJS(url, _reserved, options);

url may contain a query string, if one is desired.

Where options is a hash which can contain:

  • server (string)

    String to append to url for actual data connection. Defaults to a random 4 digit number.

  • transports (string OR array of strings)

    Sometimes it is useful to disable some fallback transports. This option allows you to supply a list transports that may be used by SockJS. By default all available transports will be used.

  • sessionId (number OR function)

    Both client and server use session identifiers to distinguish connections. If you specify this option as a number, SockJS will use its random string generator function to generate session ids that are N-character long (where N corresponds to the number specified by sessionId). When you specify this option as a function, the function must return a randomly generated string. Every time SockJS needs to generate a session id it will call this function and use the returned string directly. If you don't specify this option, the default is to use the default random string generator to generate 8-character long session ids.

  • timeout (number)

    Specify a minimum timeout in milliseconds to use for the transport connections. By default this is dynamically calculated based on the measured RTT and the number of expected round trips. This setting will establish a minimum, but if the calculated timeout is higher, that will be used.

Although the 'SockJS' object tries to emulate the 'WebSocket' behaviour, it's impossible to support all of its features. An important SockJS limitation is the fact that you're not allowed to open more than one SockJS connection to a single domain at a time. This limitation is caused by an in-browser limit of outgoing connections - usually browsers don't allow opening more than two outgoing connections to a single domain. A single SockJS session requires those two connections - one for downloading data, the other for sending messages. Opening a second SockJS session at the same time would most likely block, and can result in both sessions timing out.

Opening more than one SockJS connection at a time is generally a bad practice. If you absolutely must do it, you can use multiple subdomains, using a different subdomain for every SockJS connection.

Supported transports, by browser (html served from http:// or https://)

BrowserWebsocketsStreamingPolling
IE 6, 7nonojsonp-polling
IE 8, 9 (cookies=no)noxdr-streaming †xdr-polling †
IE 8, 9 (cookies=yes)noiframe-htmlfileiframe-xhr-polling
IE 10rfc6455xhr-streamingxhr-polling
Chrome 6-13hixie-76xhr-streamingxhr-polling
Chrome 14+hybi-10 / rfc6455xhr-streamingxhr-polling
Firefox <10no ‡xhr-streamingxhr-polling
Firefox 10+hybi-10 / rfc6455xhr-streamingxhr-polling
Safari 5.xhixie-76xhr-streamingxhr-polling
Safari 6+rfc6455xhr-streamingxhr-polling
Opera 10.70+no ‡iframe-eventsourceiframe-xhr-polling
Opera 12.10+rfc6455xhr-streamingxhr-polling
Konquerornonojsonp-polling

  • †: IE 8+ supports [XDomainRequest]1, which is essentially a modified AJAX/XHR that can do requests across domains. But unfortunately it doesn't send any cookies, which makes it inappropriate for deployments when the load balancer uses JSESSIONID cookie to do sticky sessions.

  • ‡: Firefox 4.0 and Opera 11.00 and shipped with disabled Websockets "hixie-76". They can still be enabled by manually changing a browser setting.

Supported transports, by browser (html served from file://)

Sometimes you may want to serve your html from "file://" address - for development or if you're using PhoneGap or similar technologies. But due to the Cross Origin Policy files served from "file://" have no Origin, and that means some of SockJS transports won't work. For this reason the SockJS transport table is different than usually, major differences are:

BrowserWebsocketsStreamingPolling
IE 8, 9same as aboveiframe-htmlfileiframe-xhr-polling
Othersame as aboveiframe-eventsourceiframe-xhr-polling

Supported transports, by name

TransportReferences
websocket (rfc6455)[rfc 6455]2
websocket (hixie-76)[draft-hixie-thewebsocketprotocol-76]3
websocket (hybi-10)[draft-ietf-hybi-thewebsocketprotocol-10]4
xhr-streamingTransport using [Cross domain XHR]5 [streaming]6 capability (readyState=3).
xdr-streamingTransport using [XDomainRequest]1 [streaming]6 capability (readyState=3).
eventsource[EventSource/Server-sent events]7.
iframe-eventsource[EventSource/Server-sent events]7 used from an [iframe via postMessage]8.
htmlfile[HtmlFile]9.
iframe-htmlfile[HtmlFile]9 used from an [iframe via postMessage]8.
xhr-pollingLong-polling using [cross domain XHR]5.
xdr-pollingLong-polling using [XDomainRequest]1.
iframe-xhr-pollingLong-polling using normal AJAX from an [iframe via postMessage]8.
jsonp-pollingSlow and old fashioned [JSONP polling]10. This transport will show "busy indicator" (aka: "spinning wheel") when sending data.

Connecting to SockJS without the client

Although the main point of SockJS is to enable browser-to-server connectivity, it is possible to connect to SockJS from an external application. Any SockJS server complying with 0.3 protocol does support a raw WebSocket url. The raw WebSocket url for the test server looks like:

  • ws://localhost:8081/echo/websocket

You can connect any WebSocket RFC 6455 compliant WebSocket client to this url. This can be a command line client, external application, third party code or even a browser (though I don't know why you would want to do so).

Deployment

You should use a version of sockjs-client that supports the protocol used by your server. For example:

<script src="https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js"></script>

For server-side deployment tricks, especially about load balancing and session stickiness, take a look at the SockJS-node readme.

Development and testing

SockJS-client needs node.js for running a test server and JavaScript minification. If you want to work on SockJS-client source code, checkout the git repo and follow these steps:

cd sockjs-client
npm install

To generate JavaScript, run:

gulp browserify

To generate minified JavaScript, run:

gulp browserify:min

Both commands output into the build directory.

Testing

Automated testing provided by:

Once you've compiled the SockJS-client you may want to check if your changes pass all the tests.

npm run test:browser_local

This will start karma and a test support server.

Browser Quirks

There are various browser quirks which we don't intend to address:

  • Pressing ESC in Firefox, before Firefox 20, closes the SockJS connection. For a workaround and discussion see #18.
  • jsonp-polling transport will show a "spinning wheel" (aka. "busy indicator") when sending data.
  • You can't open more than one SockJS connection to one domain at the same time due to the browser's limit of concurrent connections (this limit is not counting native WebSocket connections).
  • Although SockJS is trying to escape any strange Unicode characters (even invalid ones - like surrogates \xD800-\xDBFF or \xFFFE and \xFFFF) it's advisable to use only valid characters. Using invalid characters is a bit slower, and may not work with SockJS servers that have proper Unicode support.
  • Having a global function called onmessage or such is probably a bad idea, as it could be called by the built-in postMessage API.
  • From SockJS' point of view there is nothing special about SSL/HTTPS. Connecting between unencrypted and encrypted sites should work just fine.
  • Although SockJS does its best to support both prefix and cookie based sticky sessions, the latter may not work well cross-domain with browsers that don't accept third-party cookies by default (Safari). In order to get around this make sure you're connecting to SockJS from the same parent domain as the main site. For example 'sockjs.a.com' is able to set cookies if you're connecting from 'www.a.com' or 'a.com'.
  • Trying to connect from secure "https://" to insecure "http://" is not a good idea. The other way around should be fine.
  • Long polling is known to cause problems on Heroku, but a workaround for SockJS is available.
  • SockJS websocket transport is more stable over SSL. If you're a serious SockJS user then consider using SSL (more info).

Footnotes

  1. https://blogs.msdn.microsoft.com/ieinternals/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds/ ↩ ↩2 ↩3

  2. https://www.rfc-editor.org/rfc/rfc6455.txt ↩

  3. https://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 ↩

  4. https://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10 ↩

  5. https://secure.wikimedia.org/wikipedia/en/wiki/XMLHttpRequest#Cross-domain_requests ↩ ↩2

  6. http://www.debugtheweb.com/test/teststreaming.aspx ↩ ↩2

  7. https://html.spec.whatwg.org/multipage/comms.html#server-sent-events ↩ ↩2

  8. https://developer.mozilla.org/en/DOM/window.postMessage ↩ ↩2 ↩3

  9. http://cometdaily.com/2007/11/18/ie-activexhtmlfile-transport-part-ii/ ↩ ↩2

  10. https://secure.wikimedia.org/wikipedia/en/wiki/JSONP ↩

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.