ShareDB with other websocket events

Question

I am trying to use Node.js WebSockets with sharedb. Here is what I have so far

var http = require('http');
var express = require('express');
var ShareDB = require('sharedb');
var WebSocket = require('ws');
var WebSocketJSONStream = require('websocket-json-stream');
var ShareDBLogger = require('sharedb-logger');

var backend = new ShareDB();
createDoc(startServer);

// Create initial document then fire callback
function createDoc(callback) {
  var connection = backend.connect();
  const sharedbLogger = new ShareDBLogger(backend);
  var doc = connection.get('examples', 'text');

  doc.fetch(function(err) {
    if (err) throw err;
    if (doc.type === null) {
      doc.create({content: 'Hello'}, 'text', callback);
      return;
    }
    callback();
  });
}

function startServer() {
  // Create a web server to serve files and listen to WebSocket connections
  var app = express();
  var server = http.createServer(app);

  // Connect any incoming WebSocket connection to ShareDB
  var wss = new WebSocket.Server({server: server});
  wss.on('connection', function(ws, req) {
    var stream = new WebSocketJSONStream(ws);
    backend.listen(stream);

    ws.on('message', function (data) {
      const json = JSON.parse(data);
      if(json.type === 'request-id') ws.send('some-id');
    })
  });

  server.listen(8080);
  console.log('Listening on http://localhost:8080');
}

However, since my client sends a WebSocket message {type: 'request-id'} that is not one of sharedb's standard operations. I keep getting this error-message:

Error: { type: 'request-id',
  error: { code: 4000, message: 'Invalid or unknown message' } }

How can tell sharedb to ignore certain websocket messages that are not operations when it listens on the websocket stream?

Answer 1

WebSocketJSONStream assumes every websocket event going through that is a sharedb one. Here is the library: https://github.com/avital/websocket-json-stream/blob/master/index.js

var util = require('util');
var Duplex = require('stream').Duplex;

function WebSocketJSONStream(ws) {
  // Make work with or without 'new'
  if (!(this instanceof WebSocketJSONStream)) return new WebSocketJSONStream(ws);
  Duplex.call(this, {objectMode: true});
  this.ws = ws;
  var self = this;

  ws.on('message', function(msg) {
    // You need to catch your own personal websocket events here that are NOT being used by sharedb - perhaps filter by its title/message?
    self.push(JSON.parse(msg)); 
  });
  ws.on('close', function() {
    self.push(null); // end readable stream
    self.end(); // end writable stream

    self.emit('close');
    self.emit('end');
  });

  this.on('error', function() { ws.close(); });
  this.on('end', function() { ws.close(); });
};
util.inherits(WebSocketJSONStream, Duplex);

WebSocketJSONStream.prototype._read = function() {};
WebSocketJSONStream.prototype._write = function(msg, encoding, next) {
  this.ws.send(JSON.stringify(msg));
  next();
};

module.exports = WebSocketJSONStream;