synt_backend/controllers/websocket.js

Synt light-weight node backend service

const express = require("express");
const router = express.Router();
const userHelper = require("./../helpers/user");
const db = require("./../mysql/models/index");

// routes
router.post("/connect", connect);
router.post("/validate", validate);
router.post("/subscribe", subscribe);
router.post("/disconnect", disconnect);
router.post("/default", getDefault);
router.post("/subscriptions", getSubscriptions);

module.exports = router;

async function connect(req, res) {
  try {
    const { connectionId } = req.body;

    if (!connectionId) {
      return res.status(404).send("Not Found");
    }

    db.WebSocketConnection.create({
      connectionId,
    });

    return res.json({ success: true, message: "Connected." });
  } catch (error) {
    console.log(error);
  }
}

async function validate(req, res) {
  try {
    const { connectionId } = req.body;

    if (!connectionId) {
      return res.status(404).send("Not Found");
    }

    let User = await userHelper.getAuthUser(req); // needs to have Authorization header
    if (User) {
      db.WebSocketConnection.findOne({
        where: {
          connectionId,
        },
      }).then((Connection) => {
        Connection.UserId = User.id;
        Connection.is_validated = true;
        Connection.save();
        return res.json({ success: true, message: "Validated." });
      });
    } else {
      return res.status(404).send("User Not Found");
    }
  } catch (error) {
    console.log(error);
  }
}

function subscribe(req, res) {
  const { connectionId, channel, type } = req.body;

  // add channel to subscribed channel for connectionId
  if (!connectionId) {
    return res.json({
      success: false,
      errors: {
        connectionId: "Your connection id needs to be valid.",
      },
    });
  }

  if (!channel) {
    return res.json({
      success: false,
      errors: {
        channel: "Channel name is required.",
      },
    });
  }

  if (!type) {
    return res.json({
      success: false,
      errors: {
        channel: "Channel type is required.",
      },
    });
  }

  db.WebSocketConnection.findOne({
    where: {
      connectionId,
    },
  })
    .then((Connection) => {
      db.WebSocketSubscription.create({
        WebSocketConnectionId: Connection.id,
        type,
        channel,
      });
    })
    .catch((err) => console.log(err));

  return res.json({ success: true, message: "Subscribed." });
}

function disconnect(req, res) {
  const { connectionId } = req.body;

  db.WebSocketConnection.update(
    { is_active: false },
    {
      where: {
        connectionId,
      },
    }
  );

  return res.json({ success: true, message: "Deactivated." });
}

function getDefault(req, res) {
  res.status(404).send("Not Found");
}

function getSubscriptions(req, res) {
  const { channel } = req.body;

  if (!channel) {
    return res.json({
      success: false,
      errors: {
        channel: "Channel name is required.",
      },
    });
  }

  db.WebSocketSubscription.findAll({
    where: {
      channel,
    },
    include: [{ model: db.WebSocketConnection, where: { is_active: 1 } }],
  })
    .then((Subscriptions) => {
      return res.json({
        success: true,
        Subscriptions,
      });
    })
    .catch((error) => {
      return res.json({
        success: false,
        error,
      });
    });
}