lint: lib/realtime

- add JobWorker type
- add typing annotate in:
  - realtimeUpdateDirtyNoteJob
  - realtimeSaveRevisionJob
  - realtimeClientConnection
  - processQueue

Author: a60814billy

lib/realtime/jobWorker.ts

@@ -0,0 +1,5 @@
+export interface JobWorker {
+    start(): void
+
+    stop(): void
+}

lib/realtime/processQueue.ts

@@ -1,4 +1,5 @@
 import {EventEmitter} from "events";
+import {JobWorker} from "./jobWorker";
 
 /**
  * Queuing Class for connection queuing
@@ -10,22 +11,48 @@ const QueueEvent = {
   Finish: 'Finish'
 }
 
-export class ProcessQueue extends EventEmitter {
-  private max: number;
-  private triggerTime: number;
+type AsyncFunc = () => Promise<void>
+type SyncFun = () => void
+type TaskFunc = AsyncFunc | SyncFun
+
+interface Task {
+  id: string
+  processingFunc: TaskFunc
+}
+
+
+export interface ProcessQueueOptions {
+  maximumLength?: number
+  triggerTimeInterval?: number
+  proactiveMode?: boolean
+  continuousMode?: boolean
+}
+
+const defaultOptions: ProcessQueueOptions = {
+  maximumLength: 500,
+  triggerTimeInterval: 5000,
+  // execute on push
+  proactiveMode: true,
+  // execute next work on finish
+  continuousMode: true
+}
+
+export class ProcessQueue extends EventEmitter implements JobWorker {
+  private readonly max: number;
+  private readonly triggerTime: number;
   private taskMap: Map<string, boolean>;
-  public queue: any[];
+  public queue: Task[];
   public lock: boolean;
   private eventTrigger: NodeJS.Timeout;
 
   constructor({
-                maximumLength = 500,
-                triggerTimeInterval = 5000,
+                maximumLength,
+                triggerTimeInterval,
                 // execute on push
-                proactiveMode = true,
+                proactiveMode,
                 // execute next work on finish
-                continuousMode = true
-              }) {
+                continuousMode
+              } = defaultOptions) {
     super()
     this.max = maximumLength
     this.triggerTime = triggerTimeInterval
@@ -42,29 +69,29 @@ export class ProcessQueue extends EventEmitter {
     }
   }
 
-  onEventProcessFunc() {
+  onEventProcessFunc(): void {
     if (this.lock) return
     this.lock = true
     setImmediate(() => {
       this.process()
     })
   }
 
-  start() {
+  start(): void {
     if (this.eventTrigger) return
     this.eventTrigger = setInterval(() => {
       this.emit(QueueEvent.Tick)
     }, this.triggerTime)
   }
 
-  stop() {
+  stop(): void {
     if (this.eventTrigger) {
       clearInterval(this.eventTrigger)
       this.eventTrigger = null
     }
   }
 
-  checkTaskIsInQueue(id) {
+  checkTaskIsInQueue(id: string): boolean {
     return this.taskMap.has(id)
   }
 
@@ -74,7 +101,7 @@ export class ProcessQueue extends EventEmitter {
    * @param processingFunc {Function<Promise>}
    * @returns {boolean} if success return true, otherwise false
    */
-  push(id: string, processingFunc) {
+  push(id: string, processingFunc: TaskFunc): boolean {
     if (this.queue.length >= this.max) return false
     if (this.checkTaskIsInQueue(id)) return false
     const task = {
@@ -88,7 +115,7 @@ export class ProcessQueue extends EventEmitter {
     return true
   }
 
-  process() {
+  process(): void {
     if (this.queue.length <= 0) {
       this.stop()
       this.lock = false
@@ -104,7 +131,13 @@ export class ProcessQueue extends EventEmitter {
         this.emit(QueueEvent.Finish)
       })
     }
-    task.processingFunc().then(finishTask).catch(finishTask)
+    const runFunc = task.processingFunc() as Promise<void>;
+    // Wait until the promise fulfilled if processing function is a promise
+    if (typeof runFunc.then === 'function') {
+      runFunc.then(finishTask).catch(finishTask)
+    } else {
+      finishTask()
+    }
   }
 }
 

lib/realtime/realtimeClientConnection.ts

@@ -15,7 +15,7 @@ export class RealtimeClientConnection {
     this.realtime = require('./realtime')
   }
 
-  registerEventHandler() {
+  registerEventHandler(): void {
     // received client refresh request
     this.socket.on('refresh', this.refreshEventHandler.bind(this))
     // received user status
@@ -40,27 +40,27 @@ export class RealtimeClientConnection {
     this.socket.on('permission', this.permissionChangeEventHandler.bind(this))
   }
 
-  isUserLoggedIn() {
+  isUserLoggedIn(): boolean {
     return this.socket.request.user && this.socket.request.user.logged_in
   }
 
-  isNoteAndUserExists() {
+  isNoteAndUserExists(): boolean {
     const note = this.realtime.getNoteFromNotePool(this.socket.noteId)
     const user = this.realtime.getUserFromUserPool(this.socket.id)
     return note && user
   }
 
-  isNoteOwner() {
+  isNoteOwner(): boolean {
     const note = this.getCurrentNote()
     return get(note, 'owner') === this.getCurrentLoggedInUserId()
   }
 
-  isAnonymousEnable() {
+  isAnonymousEnable(): boolean {
     // TODO: move this method to config module
     return config.allowAnonymous || config.allowAnonymousEdits
   }
 
-  getAvailablePermissions() {
+  getAvailablePermissions(): string[] {
     // TODO: move this method to config module
     const availablePermission = Object.assign({}, config.permission)
     if (!config.allowAnonymous && !config.allowAnonymousViews) {
@@ -78,7 +78,7 @@ export class RealtimeClientConnection {
     return this.realtime.getUserFromUserPool(this.socket.id)
   }
 
-  getCurrentLoggedInUserId() {
+  getCurrentLoggedInUserId(): string {
     return get(this.socket, 'request.user.id')
   }
 
@@ -91,13 +91,13 @@ export class RealtimeClientConnection {
     return this.socket.broadcast.to(this.socket.noteId)
   }
 
-  async destroyNote(id) {
+  async destroyNote(id: string): Promise<number> {
     return Note.destroy({
       where: {id: id}
     })
   }
 
-  async changeNotePermission(newPermission) {
+  async changeNotePermission(newPermission: string): Promise<void> {
     const [changedRows] = await Note.update({
       permission: newPermission
     }, {
@@ -110,7 +110,7 @@ export class RealtimeClientConnection {
     }
   }
 
-  notifyPermissionChanged() {
+  notifyPermissionChanged(): void {
     this.realtime.io.to(this.getCurrentNote().id).emit('permission', {
       permission: this.getCurrentNote().permission
     })
@@ -128,11 +128,11 @@ export class RealtimeClientConnection {
     })
   }
 
-  refreshEventHandler() {
+  refreshEventHandler(): void {
     this.realtime.emitRefresh(this.socket)
   }
 
-  checkVersionEventHandler() {
+  checkVersionEventHandler(): void {
     this.socket.emit('version', {
       version: config.fullversion,
       minimumCompatibleVersion: config.minimumCompatibleVersion
@@ -152,7 +152,7 @@ export class RealtimeClientConnection {
     this.realtime.emitUserStatus(this.socket)
   }
 
-  userChangedEventHandler() {
+  userChangedEventHandler(): void {
     logger.info('user changed')
 
     const note = this.getCurrentNote()
@@ -164,7 +164,7 @@ export class RealtimeClientConnection {
     this.realtime.emitOnlineUsers(this.socket)
   }
 
-  onlineUsersEventHandler() {
+  onlineUsersEventHandler(): void {
     if (!this.isNoteAndUserExists()) return
 
     const currentNote = this.getCurrentNote()
@@ -193,7 +193,7 @@ export class RealtimeClientConnection {
     this.getNoteChannel().emit('cursor activity', out)
   }
 
-  cursorBlurEventHandler() {
+  cursorBlurEventHandler(): void {
     if (!this.isNoteAndUserExists()) return
     const user = this.getCurrentUser()
     user.cursor = null
@@ -202,7 +202,7 @@ export class RealtimeClientConnection {
     })
   }
 
-  deleteNoteEventHandler() {
+  deleteNoteEventHandler(): void {
     // need login to do more actions
     if (this.isUserLoggedIn() && this.isNoteAndUserExists()) {
       const note = this.getCurrentNote()
@@ -220,7 +220,7 @@ export class RealtimeClientConnection {
     }
   }
 
-  permissionChangeEventHandler(permission) {
+  permissionChangeEventHandler(permission: string): void {
     if (!this.isUserLoggedIn()) return
     if (!this.isNoteAndUserExists()) return
 
@@ -237,7 +237,7 @@ export class RealtimeClientConnection {
       .catch(err => logger.error('update note permission failed: ' + err))
   }
 
-  disconnectEventHandler() {
+  disconnectEventHandler(): void {
     if (this.realtime.disconnectProcessQueue.checkTaskIsInQueue(this.socket.id)) {
       return
     }

lib/realtime/realtimeSaveRevisionJob.ts

@@ -2,32 +2,33 @@
 
 import {logger} from "../logger";
 import {saveAllNotesRevision} from "../services/note";
+import {JobWorker} from "./jobWorker";
 
 /**
  * clean when user not in any rooms or user not in connected list
  */
-export class SaveRevisionJob {
+export class SaveRevisionJob implements JobWorker {
   private realtime: any;
   private saverSleep: boolean;
   private timer: NodeJS.Timeout;
 
-  constructor(realtime) {
+  constructor(realtime: any) {
     this.realtime = realtime
     this.saverSleep = false
   }
 
-  start() {
+  start(): void {
     if (this.timer) return
     this.timer = setInterval(this.saveRevision.bind(this), 5 * 60 * 1000)
   }
 
-  stop() {
+  stop(): void {
     if (!this.timer) return
     clearInterval(this.timer)
     this.timer = undefined
   }
 
-  saveRevision() {
+  saveRevision(): void {
     if (this.getSaverSleep()) return
     saveAllNotesRevision((err, notes) => {
       if (err) {
@@ -39,11 +40,11 @@ export class SaveRevisionJob {
     })
   }
 
-  getSaverSleep() {
+  getSaverSleep(): boolean {
     return this.saverSleep
   }
 
-  setSaverSleep(val) {
+  setSaverSleep(val: boolean): void {
     this.saverSleep = val
   }
 }

lib/realtime/realtimeUpdateDirtyNoteJob.ts

@@ -2,27 +2,28 @@ import moment from "moment";
 
 import config from "../config";
 import {logger} from "../logger";
+import {JobWorker} from "./jobWorker";
 
-export class UpdateDirtyNoteJob {
+export class UpdateDirtyNoteJob implements JobWorker {
   private realtime: any;
   private timer: NodeJS.Timeout;
 
-  constructor(realtime) {
+  constructor(realtime: any) {
     this.realtime = realtime
   }
 
-  start() {
+  start(): void {
     if (this.timer) return
     this.timer = setInterval(this.updateDirtyNotes.bind(this), 1000)
   }
 
-  stop() {
+  stop(): void {
     if (!this.timer) return
     clearInterval(this.timer)
     this.timer = undefined
   }
 
-  updateDirtyNotes() {
+  updateDirtyNotes(): void {
     const notes = this.realtime.getNotePool()
     Object.keys(notes).forEach((key) => {
       const note = notes[key]