Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Module

Hierarchy

Index

Constructors

constructor

  • new Module(app: Application, name?: string, autoInit?: boolean, wait?: boolean): Module
  • Object that describes a module of the Application

    Parameters

    • app: Application

      The Application

    • Optional name: string

      The name of the module

    • autoInit: boolean = true

      Should the Module run the async init method (default: true)

    • wait: boolean = true

      Should the Application wait for the module's init method to end (default: true)

      export class MyModule extends Module {
              constructor(app: Application) {
                  super(app, 'MyModuleName', true, true)
              }
      }
      

    Returns Module

Properties

Protected Readonly _app

Application instance

Private _endpoints

_endpoints: Endpoint[]

Module endpoints

Protected Readonly _id

_id: number

Module ID

Private _init

_init: Promise<any>

Module init promise

Protected Readonly _log

_log: Debugger

Module logger

Protected Readonly _name

_name: string

Module name

Protected _sockets

_sockets: Socket<DefaultEventsMap, DefaultEventsMap>[]

Connected sockets

Private _wait

_wait: boolean

Should the application wait for the init method

Static Private _counter

_counter: number = 0

ID counter

Accessors

endpoints

initPromise

  • get initPromise(): Promise<any>
  • Returns the init promise to know if the module init is done or not

    Returns Promise<any>

name

  • get name(): string

wait

  • get wait(): boolean

Methods

Protected addEndpoint

  • Add an endpoint to the module endpoints

    Parameters

    • endpoint: Endpoint

      Endpoint to add

      addEndpoint(myEndpoint)
      

    Returns void

Protected addEndpoints

  • addEndpoints(endpoints: Endpoint[]): void

Protected init

  • init(): Promise<any>
  • Init method that is made to be overwritten with any async initialization that the server has to wait to be over before starting

    Returns Promise<any>

    A promise of the async process

    await this.init()
    console.log('Module initialization done.')
    // Do stuff that has to wait the init
    

Protected initialize

  • initialize(autoInit: boolean): void
  • If autoInit is set on true, will run the init async method and put the result of the Promise in a variable that can be get by the application. This will allow the Application to be notified at the end of the init method of the Module If autoInit is set on false, will just put a Promise.resolve() in the init variable

    Parameters

    • autoInit: boolean

      Should the Application run the init method

      initialize(true/false)
      

    Returns void

onSocketJoin

  • onSocketJoin(socket: Socket<DefaultEventsMap, DefaultEventsMap>): any
  • Listener for new client socket connection

    Parameters

    • socket: Socket<DefaultEventsMap, DefaultEventsMap>

      Client socket

      // Application
      onSocketJoin((socket) => {
              this._modules.forEach((module) => {
                  module.onSocketJoin(socket)
              })
      })
      
      // MyModule
      public onSocketJoin(socket) {
              console.log(`Socket ${socket.id} joined`)
      }
      
      // index.ts
      const app = new Application({...})
      ...
      app.registerModule(MyModule)
      ...
      
      // When a socket joins the server
      // console: "Socket xZicnuePG5WehCSKAAAB joined"
      

    Returns any

onSocketLeave

  • onSocketLeave(socket: Socket<DefaultEventsMap, DefaultEventsMap>): any
  • Listener for disconnected client sockets

    Parameters

    • socket: Socket<DefaultEventsMap, DefaultEventsMap>

      Client socket

      // Application
      onSocketJoin((socket) => {
              ...
              socket.on('disconnected', (socket) => {
                  this.modules.forEach((module) => {
                      module.onSocketLeave(socket)
                  })
              })
      })
      
      // MyModule
      public onSocketLeave(socket) {
              console.log(`Socket ${socket.id} leaved`)
      }
      
      // index.ts
      const app = new Application({...})
      ...
      app.registerModule(MyModule)
      ...
      
      // When a socket leaves the server
      // console: "Socket xZicnuePG5WehCSKAAAB leaved"
      

    Returns any

Protected registerTask

  • Register a task

    Parameters

    • schedule: TaskSchedule

      Schedule of the task: Date, Moment or cron schedule

    • action: TaskAction

      Action the will be run on schedule

    • start: boolean = true

      Does auto start (default: true)

    Returns Task

    The task

    export class MyModule extends Module {
            constructor(app: Application) {
                ...
    
                // Perform task every day at 10h00
                this.registerTask('* * 10 * * *', this.performMyTask.bind(this), true)
            }
    
            public async performMyTask() {
                ...
            }
    }
    

setWait

  • setWait(wait: boolean): void
  • Set the wait flag to the given value

    Parameters

    • wait: boolean

      New wait flag value

      setWait(true/false)
      

    Returns void

Generated using TypeDoc