Motivation

Websockets are way faster than http. This package seeks to provide a replacement for http when creating RESTful APIs.

To do

• Limit calls to WATCH handler so that it's only called when the matches of the query is changed. Now it is triggered for all changes within a resource.
• Move CHANGE-events away from strategy

Usage

Client

import {Frontend} from 'socketio-rest'
import socketio from 'socket.io-client'

const io = socketio('http://localhost')
const realtime = new Frontend(io)

// Meta data for all messages

realtime.options.token = 'some jwt token'

// Create

async function createUser(options) {
  return realtime.create('users', options)
}

// Read

async function getUser(id) {
  return realtime.getOne('users', { id })
}

async function getUserByEmail(email) {
  return realtime.getOne('users', { email })
}

async function getAllUsers() {
  return realtime.get('users')
}

async function getAdminUsers() {
  return realtime.get('users', { role: 'admin' })
}

// Watch/unwatch

async function watchAdminUsers() {
  const watchId = await realtime.watch('users')

  return function unwatch() {
    return realtime.unwatch(watchId)
  }
}

async function watchAdminUsers() {
  const watchId = realtime.watch('users', { role: 'admin' })

  return function unwatch() {
    return realtime.unwatch(watchId)
  }
}

// Update

async function updateRole(userId, newRole) {
  return realtime.update('users', { role: newRole })
}

// Delete

async function deleteUser(id) {
  return realtime.destroy('users', { id })
}

Server

import {Backend} from 'socketio-rest'
import EventEmitter from 'events'
import socketio from 'socket.io'
import http from 'http'

const server = http.createServer()
const io = socketio(server)
const events = new EventEmitter()
const resources = ['users']

const databaseAdapter = {
  async getOne(resource, query, metaData) {
    // Return one instance of the resource matching the query
    // ‹Your implementation›
  },
  async get(resource, query, metaData) {
    // Return an array of instances matching the query
    // ‹Your implementation›
  },
  async update(resource, updates, metaData) {
    // Update an instance of the query using updates = { id, ...updates }
    // ‹Your implementation›

    // Then notify socketio-rest that a change has occurred
    events.emit('CHANGE ' + resource)
  },
  async create(resource, data, metaData) {
    // Create an instance of the resource
    // ‹Your implementation›

    // Then notify socketio-rest that a change has occurred
    events.emit('CHANGE ' + resource)
  },
  async destroy(resource, query, metaData) {
    // Delete an instance of the resource
    // ‹Your implementation›

    // Then notify socketio-rest that a change has occurred
    events.emit('CHANGE ' + resource)
  }
}

// Initialize

const realtime = new Backend(io, resources)

// Specify a strategy

const strategy = {
  db,
  events,
}

realtime.useStrategy(strategy)

server.listen(1234, () => {
  console.log('Server listening on port 1234')
})

Testing

yarn test

npm test