added / fixed some types

src/utils/workerPool.ts

@@ -4,19 +4,52 @@ import { EventEmitter } from 'events'
 import os from 'os'
 
 import logger from './logger'
+import { Result } from './actions'
+import type { Question, QuestionDb, QuestionData } from '../types/basicTypes'
+import type { WorkerResult } from './classes'
 
 interface WorkerObj {
-  worker: any
+  worker: Worker
   index: number
   free: Boolean
 }
 
+interface TaskObject {
+  type: 'work' | 'dbEdit' | 'newQuestions' | 'newdb'
+  data:
+    | {
+        searchIn: number[]
+        question: Question
+        subjName: string
+        testUrl?: string
+        questionData?: QuestionData
+        searchInAllIfNoResult?: boolean
+        searchTillMatchPercent?: number
+        [key: string]: any
+      }
+    | { dbIndex: number; edits: any }
+    | QuestionDb
+    | Result
+}
+
 interface PendingJob {
-  workData: any
-  doneEvent: any
+  workData: TaskObject
+  doneEvent: DoneEvent
   targetWorkerIndex?: number
 }
 
+interface JobEvent extends EventEmitter {
+  on(event: 'jobDone', listener: () => void): this
+  on(event: 'newJob', listener: () => void): this
+  emit(event: 'newJob'): boolean
+  emit(event: 'jobDone'): boolean
+}
+
+interface DoneEvent extends EventEmitter {
+  once(event: 'done', listener: (result: WorkerResult) => void): this
+  emit(event: 'done', res: WorkerResult): boolean
+}
+
 const alertOnPendingCount = 50
 const workerFile = './src/utils/classes.ts'
 let workers: Array<WorkerObj>
@@ -24,7 +57,7 @@ const pendingJobs: {
   [id: string]: PendingJob
 } = {}
 
-const jobEvents = new EventEmitter()
+const jobEvents: JobEvent = new EventEmitter()
 
 jobEvents.on('jobDone', () => {
   processJob()
@@ -36,17 +69,17 @@ jobEvents.on('newJob', () => {
 
 // ---------------------------------------------------------------------------
 
-function handleWorkerError(worker: WorkerObj, err) {
+function handleWorkerError(worker: WorkerObj, err: Error) {
   // TODO: restart worker if exited or things like that
   logger.Log('resourcePromise error', logger.GetColor('redbg'))
-  console.error(err)
+  console.error(err, worker)
 }
 
 // TODO: accuire all workers here, and handle errors so they can be removed if threads exit
-export function msgAllWorker(data: any): Promise<any> {
+export function msgAllWorker(data: TaskObject): Promise<any> {
   logger.DebugLog('MSGING ALL WORKER', 'job', 1)
   return new Promise((resolve) => {
-    const promises = []
+    const promises: Promise<WorkerResult>[] = []
     workers.forEach((worker) => {
       promises.push(doALongTask(data, worker.index))
     })
@@ -58,7 +91,7 @@ export function msgAllWorker(data: any): Promise<any> {
 }
 
 export function doALongTask(
-  obj: any,
+  obj: TaskObject,
   targetWorkerIndex?: number
 ): Promise<any> {
   if (Object.keys(pendingJobs).length > alertOnPendingCount) {
@@ -72,7 +105,7 @@ export function doALongTask(
 
   const jobId = uuidv4()
   // FIXME: delete doneEvent?
-  const doneEvent = new EventEmitter()
+  const doneEvent: DoneEvent = new EventEmitter()
   pendingJobs[jobId] = {
     workData: obj,
     targetWorkerIndex: targetWorkerIndex,
@@ -80,7 +113,7 @@ export function doALongTask(
   }
   jobEvents.emit('newJob')
   return new Promise((resolve) => {
-    doneEvent.once('done', (result) => {
+    doneEvent.once('done', (result: WorkerResult) => {
       jobEvents.emit('jobDone')
       resolve(result)
     })
@@ -90,7 +123,7 @@ export function doALongTask(
 export function initWorkerPool(initData: any): Array<WorkerObj> {
   if (workers) {
     logger.Log('WORKERS ALREADY EXISTS', logger.GetColor('redbg'))
-    return
+    return null
   }
   workers = []
 
@@ -119,7 +152,7 @@ function processJob() {
   if (Object.keys(pendingJobs).length > 0) {
     // FIXME: FIFO OR ANYTHING ELSE (JOB PROCESSING ORDER)
     const keys = Object.keys(pendingJobs)
-    let jobKey, freeWorker
+    let jobKey: string, freeWorker: WorkerObj
     let i = 0
     while (!freeWorker && i < keys.length) {
       jobKey = keys[i]
@@ -159,7 +192,7 @@ function processJob() {
     delete pendingJobs[jobKey]
 
     doSomething(freeWorker, job.workData)
-      .then((res) => {
+      .then((res: WorkerResult) => {
         freeWorker.free = true
         job.doneEvent.emit('done', res)
       })
@@ -169,7 +202,7 @@ function processJob() {
   }
 }
 
-function getAWorker(i, initData) {
+function getAWorker(i: number, initData: Array<QuestionDb>) {
   const worker = workerTs(workerFile, {
     workerData: {
       workerIndex: i,
@@ -196,11 +229,11 @@ function getAWorker(i, initData) {
 
 // ---------------------------------------------------------------------------
 
-function doSomething(currWorker, obj) {
+function doSomething(currWorker: WorkerObj, obj: TaskObject) {
   const { /* index, */ worker } = currWorker
   return new Promise((resolve) => {
     worker.postMessage(obj)
-    worker.once('message', (msg) => {
+    worker.once('message', (msg: WorkerResult) => {
       resolve(msg)
     })
   })