@qsocket/core is a powerful and versatile library for inter-process communication, enabling seamless data exchange both in the browser and in Node.js environments. Leveraging the @qsocket/protocol package to convert data into a byte-stream (buffer) format, @qsocket/core allows for diverse data types to be transmitted within a single message, preserving the integrity and structure of information. With built-in automatic packet compression, it minimizes network load and improves performance when handling large volumes of data.
The core strength of @qsocket/core lies in its flexibility and readiness to work with a wide range of transport options: WebSocket, LongPolling, TCP sockets, file sockets, Unix sockets, and Windows Pipes. Currently, the library supports engine.io for data transmission, but future updates will expand support for additional transport options.
Stay updated on the latest developments in the @qsocket/transport package—an essential tool for working with @qsocket/core. This package provides standardized, tested, and wrapped transports that easily integrate with @qsocket/core. This approach allows you to flexibly manage the transport layer without altering your core application code. @qsocket/transport guarantees stability, scalability, and growth potential for your application, allowing @qsocket/core to remain the reliable, trusted backbone of your communication layer.
With @qsocket/core, you gain reliability, scalability, and peak efficiency—everything you need for stable and fast inter-process communication, essential for applications where inter-process interaction is mission-critical.
- Multi-Transport Support: Currently supports
engine.io; future releases will add TCP sockets, file sockets, Unix sockets, and Windows Pipes. - Buffer-Based Data Transfer: All data is transmitted as buffers, enabling efficient handling of binary data.
- Flexible Interface: The library interacts with transports via a unified interface, making it easy to add support for new transport protocols.
- Namespace and Event Handling: Support for namespaces and events makes it easy to organize and manage data exchange logic between client and server.
- Configurable Data Compression: Option to enable data compression (GZIP and DEFLATE) with customizable thresholds and algorithms.
To install QSocket and the necessary transport package, use the following command:
```bash npm install @qsocket/core @qsocket/transport ```
Create a QSocket server with engine.io as the transport:
```typescript import { QSocketServer } from '@qsocket/core'; import { createEngineIOLatest } from '@qsocket/transport'; import { createServer } from 'http';
const httpServer = createServer(); httpServer.listen(3000);
const transport = createEngineIOLatest(httpServer); const server = new QSocketServer(transport, { compressor: { on: true, compressionFromSize: 1024 * 100, // Enable compression for messages larger than 100 KB }, debugConfig: { on: true, prefix: '[QSocket Server]', }, });
// Create a namespace const namespace = server.createNamespace('chat');
// Handle an event within the namespace namespace.on('connection', (connection) => { connection.on('event', (data) => { console.log('Message received:', data); return void 0; // must return a value }); connection.emit('event', 'Hello, Client'); }); ```
Set up a QSocket client using engine.io:
```typescript import { QSocketClient } from '@qsocket/core'; import { createEngineIOClientLatest } from '@qsocket/transport';
const transport = createEngineIOClientLatest('http://example.com'); const client = new QSocketClient(transport, { compressor: { on: true, }, debugConfig: { on: true, prefix: '[QSocket Client]', }, });
// Connect to a namespace client.createNamespace('chat'); ```
Creates a QSocket server instance with the ability to manage namespaces and events.
Constructor
```typescript new QSocketServer(transport: TQSocketServer, protocolConfig: IQSocketProtocolConfig, debugConfig?: IQSocketDebugConfig); ```
Creates a QSocket client instance for connecting to a server and exchanging data.
Constructor
```typescript new QSocketClient(socket: TQSocketClientSocket, protocolConfig?: IQSocketProtocolConfig, debugConfig?: IQSocketDebugConfig); ```
compressor: Data compression settings.on: Enable or disable compression.compressionFromSize: Threshold for enabling compression (in bytes).compressor: Custom compressor instance (optional).
Debug configuration:
on: Enable or disable debug mode.prefix: Prefix for debug messages.logger: Custom logger.
QSocket initially supports engine.io, but its architecture allows integration with other transport types, such as TCP or file sockets, in the future. Any transport simply needs to implement interfaces similar to those in engine.io.
This project is licensed under the MIT License.
If you have suggestions or ideas for improvement, please open an issue or submit a pull request in the project's GitHub repository.