545563e776
- Complete NestJS TypeScript implementation with WebSocket support - Direct messaging (DM) and group chat functionality - End-to-end encryption with AES encryption and key pairs - Media file support (images, videos, audio, documents) up to 100MB - Push notifications with Firebase Cloud Messaging integration - Mention alerts and real-time typing indicators - User authentication with JWT and Passport - SQLite database with TypeORM entities and relationships - Comprehensive API documentation with Swagger/OpenAPI - File upload handling with secure access control - Online/offline status tracking and presence management - Message editing, deletion, and reply functionality - Notification management with automatic cleanup - Health check endpoint for monitoring - CORS configuration for cross-origin requests - Environment-based configuration management - Structured for Flutter SDK integration Features implemented: ✅ Real-time messaging with Socket.IO ✅ User registration and authentication ✅ Direct messages and group chats ✅ Media file uploads and management ✅ End-to-end encryption ✅ Push notifications ✅ Mention alerts ✅ Typing indicators ✅ Message read receipts ✅ Online status tracking ✅ File access control ✅ Comprehensive API documentation Ready for Flutter SDK development and production deployment.
duplexify
Turn a writeable and readable stream into a single streams2 duplex stream.
Similar to duplexer2 except it supports both streams2 and streams1 as input
and it allows you to set the readable and writable part asynchronously using setReadable(stream) and setWritable(stream)
npm install duplexify
Usage
Use duplexify(writable, readable, streamOptions) (or duplexify.obj(writable, readable) to create an object stream)
var duplexify = require('duplexify')
// turn writableStream and readableStream into a single duplex stream
var dup = duplexify(writableStream, readableStream)
dup.write('hello world') // will write to writableStream
dup.on('data', function(data) {
// will read from readableStream
})
You can also set the readable and writable parts asynchronously
var dup = duplexify()
dup.write('hello world') // write will buffer until the writable
// part has been set
// wait a bit ...
dup.setReadable(readableStream)
// maybe wait some more?
dup.setWritable(writableStream)
If you call setReadable or setWritable multiple times it will unregister the previous readable/writable stream.
To disable the readable or writable part call setReadable or setWritable with null.
If the readable or writable streams emits an error or close it will destroy both streams and bubble up the event.
You can also explicitly destroy the streams by calling dup.destroy(). The destroy method optionally takes an
error object as argument, in which case the error is emitted as part of the error event.
dup.on('error', function(err) {
console.log('readable or writable emitted an error - close will follow')
})
dup.on('close', function() {
console.log('the duplex stream is destroyed')
})
dup.destroy() // calls destroy on the readable and writable part (if present)
HTTP request example
Turn a node core http request into a duplex stream is as easy as
var duplexify = require('duplexify')
var http = require('http')
var request = function(opts) {
var req = http.request(opts)
var dup = duplexify(req)
req.on('response', function(res) {
dup.setReadable(res)
})
return dup
}
var req = request({
method: 'GET',
host: 'www.google.com',
port: 80
})
req.end()
req.pipe(process.stdout)
License
MIT
Related
duplexify is part of the mississippi stream utility collection which includes more useful stream modules similar to this one.