gamesocket.io/lib/Behavior/Behavior.js

Simple event-oriented API for uWebSocket.js

'use strict'
var __importDefault =
  (this && this.__importDefault) ||
  function (mod) {
    return mod && mod.__esModule ? mod : { default: mod }
  }
Object.defineProperty(exports, '__esModule', { value: true })
exports.Behavior = void 0
const uuid_1 = require('uuid')
const DataManager_js_1 = require('../DataManager/DataManager.js')
const ServerProxy_js_1 = require('../ServerProxy/ServerProxy.js')
const Logger_js_1 = __importDefault(require('../Logger/Logger.js'))
const Manager_js_1 = require('../Namespace/Manager.js')
class Behavior {
  _manager
  constructor(_manager) {
    this._manager = _manager
  }
  get open() {
    return async function (socket) {
      if (isNot(socket.id, 'uuid')) socket.id = (0, uuid_1.v4)()
      Manager_js_1.NmspManager.get(this.namespace).Sockets.addOne(socket.id)
      ServerProxy_js_1.ServerProxy.pool.set(socket.id, socket)
      socket.subscribe(`${this.namespace}/broadcast`)
      if (Logger_js_1.default.flags.info)
        Logger_js_1.default.info(`${this.namespace}: open connection with socket#${socket.id}`)
      const openHandler = this.get('open')
      if (openHandler) {
        let escort = DataManager_js_1.DataManager.spawn('open', { namespace: this.namespace, id: socket.id })
        await openHandler.execute(escort)
        DataManager_js_1.DataManager.drop(escort)
      }
    }.bind(this._manager)
  }
  get close() {
    return async function (socket, code, message) {
      ServerProxy_js_1.ServerProxy.pool.delete(socket.id)
      if (Logger_js_1.default.flags.info)
        Logger_js_1.default.info(`${this.namespace}: close connection with socket#${socket.id}`)
      const closeHandler = this.get('close')
      if (closeHandler) {
        const data = {
          namespace: this.namespace,
          socket: socket,
          code: code,
          message: DataManager_js_1.DataManager.decode(message),
        }
        let escort = DataManager_js_1.DataManager.spawn('close', data)
        await closeHandler.execute(escort)
        DataManager_js_1.DataManager.drop(escort)
      }
    }.bind(this._manager)
  }
  get message() {
    return async function (socket, message, isBinary) {
      if (Logger_js_1.default.flags.info)
        Logger_js_1.default.info(`${this.namespace}: execute 'message' event with socket#${socket.id}`)
      const parsedData = DataManager_js_1.DataManager.decode(message)
      let dataEscort
      if (isNot(parsedData, 'object')) {
        if (Logger_js_1.default.flags.warn)
          Logger_js_1.default.warn(`Got undefined data:${parsedData} from socket#${socket.id}`)
        const undefinedDataHandler = this.get('undefined data')
        if (undefinedDataHandler) {
          dataEscort = DataManager_js_1.DataManager.spawn('undefined data', {
            ...parsedData,
            socket_id: socket.id,
            namespace: this.namespace,
          })
          await undefinedDataHandler.execute(dataEscort)
        }
      } else {
        if (contains(parsedData, 'event')) {
          dataEscort = DataManager_js_1.DataManager.spawn(parsedData.event, {
            ...parsedData,
            socket_id: socket.id,
            namespace: this.namespace,
          })
          const eventHandler = this.get(parsedData.event)
          if (eventHandler) await eventHandler.execute(dataEscort)
          else {
            const undefinedEventHandler = this.get('undefined event')
            if (Logger_js_1.default.flags.warn)
              Logger_js_1.default.warn(`Got undefined event '${parsedData.event}' from socket#${socket.id}`)
            if (undefinedEventHandler) await undefinedEventHandler.execute(dataEscort)
          }
        } else {
          dataEscort = DataManager_js_1.DataManager.spawn('unknown structure', {
            ...parsedData,
            socket_id: socket.id,
            namespace: this.namespace,
          })
          const undefinedEventHandler = this.get('undefined event')
          if (Logger_js_1.default.flags.warn)
            Logger_js_1.default.warn(
              `Got undefined data object from socket#${socket.id}: ${JSON.stringify(parsedData)}`,
            )
          if (undefinedEventHandler) await undefinedEventHandler.execute(dataEscort)
        }
        DataManager_js_1.DataManager.drop(dataEscort)
      }
    }.bind(this._manager)
  }
  get drain() {
    return async function (socket) {
      if (Logger_js_1.default.flags.debug) Logger_js_1.default.debug(`Executing 'drain' event`)
      const drainHandler = this.get('drain')
      if (drainHandler) drainHandler.execute(DataManager_js_1.DataManager.spawn('drain', { socket: socket }))
    }.bind(this._manager)
  }
}
exports.Behavior = Behavior
function is(entity, type) {
  switch (type) {
    case 'uuid': {
      if (typeof entity != 'string') return false
      return (0, uuid_1.validate)(entity)
    }
    case 'object': {
      if (typeof entity == 'string') return false
      else return true
    }
  }
}
function isNot(entity, type) {
  return !is(entity, type)
}
function contains(object, param) {
  if (typeof object != 'object') return false
  return param in object
}