wspromisify 2.4.3 → 2.5.0

package/src/WSC.ts

@@ -0,0 +1,271 @@
+import './types'
+import { Zipnum } from 'zipnum'
+import { add_event, sett } from './utils'
+import { processConfig } from './config'
+import { AnyFunc, once, T } from 'pepka'
+
+const MAX_32 = 2**31 - 1
+const zipnum = new Zipnum()
+
+class WebSocketClient {
+  private open = false
+  private ws: wsc.Socket|null = null
+  private forcibly_closed = false
+  private reconnect_timeout: NodeJS.Timeout|null = null
+  private queue = {}
+  private messages: any[] = []
+  private onReadyQueue: AnyFunc[] = []
+  private onCloseQueue: AnyFunc[] = []
+  private handlers = <{[event in wsc.WSEvent]: ((e: any) => void)[]}>{
+    open: [], close: [], message: [], error: []
+  }
+  private config = <wsc.Config>{}
+
+  private init_flush(): void {
+    this.queue    = {}  // data queuse
+    this.messages = []  // send() queue
+  }
+
+  private log(event: string, message: any = null, time: number|null = null): void {
+    const config = this.config
+    if(time !== null) {
+      config.log(event, time, message)
+    } else {
+      if(config.timer) {
+        config.log(event, null, message)
+      } else {
+        config.log(event, message)
+      }
+    }
+  }
+
+  private initSocket(ws: wsc.Socket) {
+    const config = this.config
+    this.open = true
+    this.onReadyQueue.forEach((fn: Function) => fn())
+    this.onReadyQueue.splice(0)
+    const {id_key, data_key} = config.server
+    // Works also on previously opened sockets that do not fire 'open' event.
+    this.handlers.open.forEach((h) => h(ws))
+    // Send all pending messages.
+    this.messages.forEach((message: any) => message.send())
+    // It's reconnecting.
+    if(this.reconnect_timeout !== null) {
+      clearInterval(this.reconnect_timeout)
+      this.reconnect_timeout = null
+    }
+    if(config.ping) {
+      const ping_interval = setInterval(() => {
+        if(this.open) this.send(config.ping.content)
+        if(this.forcibly_closed) clearInterval(ping_interval)
+      }, config.ping.interval*1e3)
+    }
+    add_event(ws, 'close', async (...e) => {
+      this.log('close')
+      this.open = false
+      this.onCloseQueue.forEach((fn: Function) => fn())
+      this.onCloseQueue.splice(0)
+      this.handlers.close.forEach((h: any) => h(...e))
+      // Auto reconnect.
+      const reconnect = config.reconnect
+      if(
+        typeof reconnect === 'number' &&
+        !isNaN(reconnect) &&
+        !this.forcibly_closed
+      ) {
+        const reconnectFunc = async () => {
+          this.log('reconnect')
+          if(this.ws !== null) {
+            this.ws.close()
+            this.ws = null
+          }
+          // If some error occured, try again.
+          const status = await this.connect()
+          if(status !== null) {
+            this.reconnect_timeout = setTimeout(reconnectFunc, reconnect * 1000)
+          }
+        }
+        // No need for await.
+        reconnectFunc()
+      } else {
+        this.ws = null
+        this.open = false
+      }
+      // reset the flag to reuse.
+      this.forcibly_closed = false
+    })
+    add_event(ws, 'message', (e) => {
+      try {
+        const data = config.decode(e.data)
+        this.handlers.message.forEach((h: any) => h({...e, data}))
+        if(data[id_key]) {
+          const q = this.queue[data[id_key]]
+          if(q) {
+            // Debug, Log.
+            const time = q.sent_time ? (Date.now() - q.sent_time) : null
+            this.log('message', data[data_key], time)
+            // Play.
+            q.ff(data[data_key])
+            clearTimeout(q.timeout)
+            delete this.queue[data[id_key]]
+          }
+        }
+      } catch (err) {
+        console.error(err, `WSP: Decode error. Got: ${e.data}`)
+      }
+    })
+  }
+
+  private async connect() { // returns status if won't open or null if ok.
+    return new Promise((ff) => {
+      if(this.open === true) {
+        return ff(null)
+      }
+      const config = this.config
+      const ws = config.socket || config.adapter(config.url, config.protocols)
+      this.ws = ws
+      
+      if(!ws || ws.readyState > 1) {
+        this.ws = null
+        this.log('error', 'ready() on closing or closed state! status 2.')
+        return ff(2)
+      }
+    
+      add_event(ws, 'error', once((e) => {
+        this.log('error', 'status 3.')
+        this.handlers.error.forEach((h) => h(e))
+        this.ws = null
+        // Some network error: Connection refused or so.
+        return ff(3)
+      }))
+      // Because 'open' won't be envoked on opened socket.
+      if(ws.readyState) {
+        this.initSocket(ws)
+        ff(null)
+      } else {
+        add_event(ws, 'open', once(() => {
+          this.log('open')
+          this.initSocket(ws)
+          return ff(null)
+        }))
+      }
+    })
+  }
+
+  public get socket() {
+    return this.ws
+  }
+
+  public async ready() {
+    return new Promise<void>((ff) => {
+      if(this.open) {
+        ff()
+      } else {
+        this.onReadyQueue.push(ff)
+      }
+    })
+  }
+
+  public on(
+    event_name: wsc.WSEvent,
+    handler: (data: any) => any,
+    predicate: (data: any) => boolean = T,
+    raw = false
+  ) {
+    const _handler: wsc.EventHandler = (event) =>
+      predicate(event) && handler(event)
+    return raw
+      ? add_event(this.ws as wsc.Socket, event_name, _handler)
+      : this.handlers[event_name].push(_handler)
+  }
+
+  public async close(): wsc.AsyncErrCode {
+    return new Promise((ff, rj) => {
+      if(this.ws === null) {
+        rj('WSP: closing a non-inited socket!')
+      } else {
+        this.open = false
+        this.onCloseQueue.push(() => {
+          this.init_flush()
+          this.ws = null
+          this.forcibly_closed = true
+          ff(null)
+        })
+        this.ws.close()
+      }
+    })
+  }
+
+  /**  .send(your_data) wraps request to server with {id: `hash`, data: `actually your data`},
+    returns a Promise that will be rejected after a timeout or
+    resolved if server returns the same signature: {id: `same_hash`, data: `response data`}.
+  */
+  public async send<RequestDataType = any, ResponseDataType = any>(
+    message_data: RequestDataType,
+    opts = <wsc.SendOptions>{}
+  ): Promise<ResponseDataType> {
+    this.log('send', message_data)
+    const config   = this.config
+    const message  = {}
+    const data_key = config.server.data_key
+    const first_time_lazy = config.lazy && !this.open
+
+    const message_id = zipnum.zip((Math.random()*(MAX_32-10))|0)
+    if(typeof opts.top === 'object') {
+      if(opts.top[data_key]) {
+        throw new Error('Attempting to set data key/token via send() options!')
+      }
+      Object.assign(message, opts.top)
+    }
+
+    config.pipes.forEach(
+      (pipe) => message_data = pipe(message_data)
+    )
+
+    if(this.open === true) {
+      (this.ws as wsc.Socket).send(config.encode(message_id, message_data, config))
+    } else if(this.open === false || first_time_lazy) {
+      this.messages.push({
+        send: () => (this.ws as wsc.Socket).send(config.encode(message_id, message_data, config))
+      })
+      if(first_time_lazy) {
+        this.connect()
+      }
+    } else if(this.open === null) {
+      throw new Error('Attempting to send via closed WebSocket connection!')
+    }
+
+    return new Promise((ff, rj) => {
+      this.queue[message_id] = {
+        ff,
+        data_type: config.data_type,
+        sent_time: config.timer ? Date.now() : null,
+        timeout: sett(config.timeout, () => {
+          if(this.queue[message_id]) {
+            rj({
+              'Websocket timeout expired: ': config.timeout,
+              'for the message ': message_data
+            })
+            delete this.queue[message_id]
+          }
+        })
+      }
+    })
+  }
+
+  constructor(user_config: wsc.UserConfig = {}) {
+    this.config = processConfig(user_config)
+    // Init.
+    this.init_flush()
+    // Flags.
+    this.open = false
+    this.reconnect_timeout = null
+    this.forcibly_closed = false
+    if(!this.config.lazy) {
+      this.connect()
+    }
+  }
+}
+
+/* TODO: v3: @.deprecated. Use named import { WebSocketClient } instead. */
+export default WebSocketClient

package/src/config.ts

@@ -1,4 +1,5 @@
 import './types'
+import { native_ws } from './utils'
 
 const default_config = <wsc.Config>{
   data_type: 'json',  // ToDo some other stuff maybe.
@@ -29,13 +30,17 @@ const default_config = <wsc.Config>{
   }
 }
 
-const enrichConfig = (config: wsc.UserConfig) => {
+export const processConfig = (config: wsc.UserConfig) => {
+  if(native_ws===null && !('adapter' in config)) throw new Error(`
+    This platform has no native WebSocket implementation.
+    Please use 'ws' package as an adapter.
+    See https://github.com/houd1ni/WebsocketPromisify/issues/23
+  `)
   const full_config: wsc.Config = Object.assign(
     {},
     default_config,
     config
   )
-
   const url = full_config.url
   if(url[0] == '/') {
     try {
@@ -47,8 +52,4 @@ const enrichConfig = (config: wsc.UserConfig) => {
   }
 
   return full_config
-}
-
-export {
-  enrichConfig
 }

package/src/utils.ts

@@ -1,30 +1,12 @@
 import './types'
 
-const add_event = (o: wsc.Socket, e: string, handler: wsc.EventHandler) => {
-  return o.addEventListener(e, handler)
-}
+export const native_ws = (() => {try {return WebSocket||null}catch { return null }})()
 
-const once = (fn: Function) => {
-  let has_been_cached = false
-  let cached = null
-  return (...args: any) => {
-    if(has_been_cached) {
-      return cached
-    } else {
-      has_been_cached = true
-      return cached = fn(...args)
-    }
-  }
+export const add_event = (o: wsc.Socket, e: string, handler: wsc.EventHandler) => {
+  return o.addEventListener(e, handler)
 }
 
-const sett = (
+export const sett = (
   a: number,
   b: { (): void; (...args: any[]): void; }
-) => setTimeout(b, a)
-
-
-export {
-  add_event,
-  once,
-  sett
-}
+) => setTimeout(b, a)

package/test/index.ts

@@ -0,0 +1,21 @@
+import './specs/close'
+import './specs/drops'
+import './specs/echo'
+import './specs/existing_socket'
+import './specs/lazy'
+import './specs/ready'
+import './specs/reconnect'
+import './specs/lazySendBeforeOpen'
+import './specs/socket'
+import './specs/no-native-throws'
+import mockServer from './mock/server'
+import {test} from './suite'
+
+const {shutDown} = await mockServer()
+test.after(() => {
+  setTimeout(async () => {
+    await shutDown()
+    process.exit()
+  }, 100)
+})
+test.run()

package/test/mock/WS.ts

@@ -0,0 +1,43 @@
+
+import WebSocket, { WebSocketServer } from 'ws'
+import {noop} from 'pepka'
+
+let server: WebSocketServer|null = null
+
+const createServer = (port = 40510) => new Promise<WebSocketServer>((ff, rj) => {
+  if(server) return rj('The server is already running!')
+  server = new WebSocketServer({ port }, () => {
+    server!.on('connection', (socket: WebSocket&{isAlive: boolean}) => {
+      socket.on('message', (rawMessage: string) => {
+        const {id, data} = JSON.parse(rawMessage)
+        let response = ''
+        if(data.shut) {
+          socket.terminate()
+          socket.isAlive = false
+          socket.ping('', false, noop)
+          return null
+        } else if(data.echo) {
+          response = data
+        }
+        socket.send(JSON.stringify({ id, data: response }))
+        return null
+      })
+      return true
+    })
+    return ff(server!)
+  })
+  server.on('', console.log)
+})
+
+const killServer = async () => new Promise<void>((ff, rj) => {
+  if(server) {
+    for(const socket of server.clients) socket.terminate()
+    server.close(() => {
+      server = null
+      ff()
+    })
+  } else
+    rj('The server is already down!')
+  })
+
+export { createServer, killServer }

package/test/mock/server.ts

@@ -0,0 +1,17 @@
+
+import { WebSocketServer } from 'ws'
+import { createServer, killServer } from './WS.js'
+
+let port: number,
+    server: WebSocketServer|null
+
+export default async (new_port?: number) => {
+  if(!server) {
+    port = new_port || 8000 + Math.ceil(Math.random()*500)
+    server = await createServer(port)
+  }
+  return {
+    server, port,
+    shutDown: async () => { await killServer(); server=null }
+  }
+}

package/test/specs/close.ts

@@ -0,0 +1,18 @@
+import { test } from '../suite'
+import { createNew } from '../utils.js'
+import mockServer from '../mock/server'
+
+/** Closes the connenction. */
+test('close', () => new Promise<void>(async (ff, rj) => {
+  const {port} = await mockServer()
+  const ws = createNew({}, port)
+
+  setTimeout(async () => {
+    try {
+      await ws.close()
+      if(ws.socket === null) ff(); else rj()
+    } catch(e) {
+      rj()
+    }
+  }, 500)
+}))

package/test/specs/drops.ts

@@ -0,0 +1,30 @@
+import { createNew } from '../utils'
+import mockServer from '../mock/server'
+import { test } from '../suite'
+
+/** Rejects messages by timout */
+test('drops', () => new Promise(async (ff, rj) => {
+  const {port, shutDown} = await mockServer()
+  const ws = createNew({timeout: 500}, port)
+
+  await shutDown()
+  const lauchServ = async () => await mockServer(port)
+
+  setTimeout(async () => {
+    const msg = {echo: true, msg: 'hello!'}
+    let to: NodeJS.Timeout
+    try {
+      to = setTimeout(() => {
+        return rj()
+      }, 600)
+      await ws.send(msg)
+      if(to) clearTimeout(to)
+      await lauchServ()
+      return rj()
+    } catch(e) {
+      if(to!) clearTimeout(to)
+      await lauchServ()
+      return ff()
+    }
+  }, 200)
+}))

package/test/specs/echo.ts

@@ -0,0 +1,24 @@
+import { equals } from 'pepka'
+import { createNew, timeout } from '../utils'
+import mockServer from '../mock/server'
+import { test } from '../suite'
+
+/** Proof of work. */
+test('echo', timeout(5e3, () => new Promise<void>(async (ff, rj) => {
+    const {port} = await mockServer()
+    let to = setTimeout(() => rj('cannot create'), 2e2)
+    const ws = createNew({}, port)
+    clearTimeout(to)
+
+    to = setTimeout(() => rj('cannot ready'), 2e2)
+    await ws.ready()
+    clearTimeout(to)
+
+    const msg = {echo: true, msg: 'hello!'}
+    to = setTimeout(() => rj('cannot send'), 2e2)
+    const response = await ws.send(msg)
+    clearTimeout(to)
+
+    if(equals(response, msg)) ff(); else rj('echo msg is not equal.')
+  })
+))

package/test/specs/encode-decode.ts

@@ -0,0 +1 @@
+// TODO with mock server with specific port.

package/test/specs/existing_socket.ts

@@ -0,0 +1,55 @@
+import { createNew } from '../utils'
+import mockServer from '../mock/server'
+
+import WS from 'ws'
+import { test } from '../suite'
+import { equals } from 'pepka'
+
+
+const addr = (port: number) => 'ws://localhost:' + port
+
+/** If an existing socket connection is provided via config. */
+test('existing_socket', () => {
+  return new Promise(async (ff, rj) => {
+    const {port} = await mockServer()
+    const to = setTimeout(() => rj(), 4e4)
+    const existing_addr = addr(port)
+
+    // This one CANNOT connect as fast as we send to it,
+    // So readyState is 0.
+    const ws1 = createNew({socket: new WS(existing_addr)}, port)
+
+    if(ws1.socket?.readyState !== 0) return rj('not ready.')
+
+    const msg1 = {echo: true, msg: 'existing_socket!'}
+    const response1 = await ws1.send(msg1)
+
+    if(
+      ws1.socket?.readyState as number !== 1
+      || !equals(response1, msg1)
+    ) return rj('not ready.')
+    await ws1.close()
+
+    // This one DO CAN connect as fast as we send to it,
+    // So readyState should be 1.
+    const ws2_0 = new WS(existing_addr)
+
+    ws2_0.addEventListener('open', async () => {
+      const ws2 = await createNew({socket: ws2_0}, port)
+
+      if(ws2.socket?.readyState !== 1) return rj('not ready.')
+    
+      const msg2 = {echo: true, msg: 'existing_socket!'}
+      const response2 = await ws2.send(msg2)
+
+      if(
+        ws2.socket?.readyState as number !== 1
+        || !equals(response2, msg2)
+      ) return rj('not ready.')
+      await ws2.close()
+
+      clearTimeout(to)
+      ff()
+    })
+  })
+})

package/test/specs/lazy.ts

@@ -0,0 +1,22 @@
+import { createNew, timeout } from '../utils'
+import mockServer from '../mock/server'
+import { equals } from 'pepka'
+import { test } from '../suite'
+
+/** Lazy connect */
+test('lazy', timeout(2e3, () => {
+  return new Promise<void>(async (ff, rj) => {
+    const {port} = await mockServer()
+    const ws = createNew({ lazy: true }, port)
+
+    setTimeout(async () => {
+      if(ws.socket !== null) {
+        rj()
+      } else {
+        const msg = {echo: true, msg: 'hello!'}
+        const response = await ws.send(msg)
+        if(equals(response, msg)) ff(); else rj()
+      }
+    }, 500)
+  })
+}))

package/test/specs/lazySendBeforeOpen.ts

@@ -0,0 +1,19 @@
+import { createNew } from '../utils.js'
+import mockServer from '../mock/server'
+import { equals } from 'pepka'
+import { test } from '../suite'
+
+/** Sends massages if they were .send() before connection is estabilished. */
+test('lazy send before open queued.', () => new Promise(async (ff, rj) => {
+  const {port} = await mockServer()
+  let to = setTimeout(() => rj('cannot create'), 2e2)
+  const ws = createNew({lazy: true}, port)
+  clearTimeout(to)
+
+  const msg = {echo: true, msg: 'hello!'}
+  to = setTimeout(() => rj('cannot send'), 2e2)
+  const response = await ws.send(msg)
+  clearTimeout(to)
+
+  if(equals(response, msg)) ff(); else rj()
+}))

package/test/specs/no-native-throws.ts

@@ -0,0 +1,18 @@
+import mockServer from '../mock/server'
+import { test } from '../suite'
+import {WebSocketClient} from '../../src/WSC'
+
+/** Ready method. */
+test('No native throws without an adapter', async () => {
+  const {port} = await mockServer()
+  let pass = false
+  try {
+    new WebSocketClient({ url: 'ws://127.0.0.1:' + port })
+    try {
+      if(WebSocket) pass = true
+    } catch {}
+  } catch {
+    pass=true
+  }
+  if(!pass) throw new Error('Does not throw.')
+})

package/test/specs/ready.ts

@@ -0,0 +1,12 @@
+import { createNew, timeout } from '../utils'
+import mockServer from '../mock/server'
+import { test } from '../suite'
+
+/** Ready method. */
+test('ready', timeout(4e3, async () => {
+  const {port} = await mockServer()
+  const ws = createNew({}, port)
+
+  await ws.ready()
+  if(!ws.socket) throw new Error()
+}))

package/test/specs/reconnect.ts

@@ -0,0 +1,23 @@
+import { createNew, timeout } from '../utils'
+import mockServer from '../mock/server'
+import { equals } from 'pepka'
+import { test } from '../suite'
+
+/** Reconnects if connection is broken. */
+test('reconnect', timeout(1e4, () => new Promise<void>(async (ff, rj) => {
+    const {port, shutDown} = await mockServer()
+    const ws = createNew({ reconnect: 1 }, port)
+
+    setTimeout(async () => {
+      await shutDown()
+      setTimeout(async () => {
+        await mockServer(port)
+        setTimeout(async () => {
+          const msg = {echo: true, msg: 'hello!'}
+          const response = await ws.send(msg)
+          if(equals(response, msg)) ff(); else rj('not equals.')
+        }, 1500)
+      }, 1100)
+    }, 500)
+  })
+))

package/test/specs/socket.ts

@@ -0,0 +1,13 @@
+import { createNew, timeout } from '../utils'
+import mockServer from '../mock/server'
+import { test } from '../suite'
+
+/** Socket property check. */
+test('sockets', timeout(1e4, () => new Promise<void>(async (ff, rj) => {
+  const {port} = await mockServer()
+  const ws = createNew({}, port)
+
+  await ws.ready()
+
+  if(ws.socket && !isNaN(ws.socket.readyState)) ff(); else rj()
+})))

package/test/suite.ts

@@ -0,0 +1,3 @@
+import { suite as uvu_suite } from 'uvu'
+
+export const test = uvu_suite('.')