wspromisify 2.4.3 → 2.5.0

package/test/utils.ts

@@ -0,0 +1,27 @@
+
+import WebSocketClient from '../src/WSC'
+import {AnyFunc, AnyObject} from 'pepka'
+import { native_ws } from '../src/utils'
+import WS from 'ws'
+
+export const createNew = (config = {}, port: number) => new WebSocketClient(Object.assign({
+    url: 'ws://127.0.0.1:' + port,
+    // log: (...a) => console.log(...a),
+    adapter: (host: string, protocols?: string|string[]) => new (native_ws || WS)(host, protocols)
+  }, config)
+)
+
+// Inspired by tinchoz49 https://github.com/lukeed/uvu/issues/33#issuecomment-879870292
+export const timeout = (time: number, handler: AnyFunc) => async (context: AnyObject) => {
+  let timer: NodeJS.Timeout
+  try {
+    return await Promise.race([
+      handler(context),
+      new Promise((_resolve, reject) =>
+        timer = setTimeout(() => reject(new Error('timeout')), time)
+      )
+    ])
+  } finally {
+    if(timer!) clearTimeout(timer)
+  }
+}

package/tsconfig.json

@@ -11,9 +11,10 @@
     "experimentalDecorators": true,
     "noUnusedParameters": true,
     "noUnusedLocals": false,
-    "rootDir": "src",
+    "rootDir": ".",
     "baseUrl": ".",
+    "allowSyntheticDefaultImports": true,
     "outDir": "dist/ts"
   },
-  "include": [ "src/**/*" ]
+  "include": [ "src/**/*", "test/**/*" ]
 }

package/src/WS.ts

@@ -1,166 +0,0 @@
-import { zipnum } from 'zipnum'
-import connectLib from './connectLib'
-import { add_event, sett } from './utils'
-import { enrichConfig } from './config'
-import './types'
-import { AnyFunc, T } from 'pepka'
-
-const MAX_32 = 2**31 - 1
-
-/*  .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`}
-*/
-class WebSocketClient {
-
-  private open = false
-  private ws: wsc.Socket|null = null
-  // in use by side functions.
-  private forcibly_closed = false
-  private reconnect_timeout: NodeJS.Timer|null = null
-  private queue = {}
-  private messages: any[] = []
-  private onReadyQueue: AnyFunc[] = []
-  private onCloseQueue: AnyFunc[] = []
-  private handlers = <{[event: string]: ((e: any) => void)[]}>{
-    open: [], message: [], close: [], 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 async connect() { // returns status if won't open or null if ok.
-    return new Promise((ff) => {
-      connectLib.call(this, ff)
-    })
-  }
-
-  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()
-      }
-    })
-  }
-
-  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((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 = enrichConfig(user_config)
-    // Init.
-    this.init_flush()
-    // Flags.
-    this.open = false
-    this.reconnect_timeout = null
-    this.forcibly_closed = false
-    if(!this.config.lazy) {
-      this.connect()
-    }
-  }
-}
-
-export default WebSocketClient

package/src/connectLib.ts

@@ -1,120 +0,0 @@
-import './types'
-import { once, add_event } from './utils'
-
-
-const init = function(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
-  // Send all pending messages.
-  this.handlers.open.forEach((h) => h())
-  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 () => {
-    this.log('close')
-    this.open = false
-    this.onCloseQueue.forEach((fn: Function) => fn())
-    this.onCloseQueue = []
-    // 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 = null
-    }
-    // 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}`)
-    }
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-
-const connectLib = function(ff: Function) {
-  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) {
-    init.call(this, ws)
-    ff(null)
-  } else {
-    add_event(ws, 'open', once(() => {
-      this.log('open')
-      init.call(this, ws)
-      return ff(null)
-    }))
-  }
-}
-
-
-export default connectLib

package/test/mock/WS.js

@@ -1,51 +0,0 @@
-
-import { WebSocketServer  } from 'ws'
-
-let mockServer = {}
-
-const createServer = (port = 40510) => {
-  return new Promise((ff) => {
-    if(mockServer[port] === undefined) {
-      mockServer[port] = new WebSocketServer({ port }, () => {
-        mockServer[port].on('connection', (socket) => {
-          socket.on('message', (rawMessage) => {
-            const {id, data} = JSON.parse(rawMessage)
-            let response = ''
-            if(data.shut) {
-              socket.terminate()
-              socket.isAlive = false
-              socket.ping('', false, true)
-              return null
-            } else if(data.echo) {
-              response = data
-            }
-            socket.send(JSON.stringify({
-              id,
-              data: response
-            }))
-            return null
-          })
-          return true
-        })
-        return ff(true)
-      })
-    } else {
-      return ff(false)
-    }
-  })
-}
-
-const killServer = async (port = 40510) => {
-  return new Promise((ff) => {
-    if(mockServer[port]) {
-      mockServer[port].close(() => {
-        delete mockServer[port]
-        ff()
-      })
-    } else {
-      ff()
-    }
-  })
-}
-
-export { createServer, killServer }

package/test/mock/index.js

@@ -1,52 +0,0 @@
-
-import express from 'express'
-import { createServer, killServer } from './WS.js'
-import net from 'net';
-
-var portInUse = (port) => new Promise((ff) => {
-  var server = net.createServer(function(socket) {
-    socket.write('Echo server\r\n');
-    socket.pipe(socket);
-  });
-
-  server.on('error', function (e) {
-    ff(true);
-  });
-  server.on('listening', function (e) {
-    server.close();
-    ff(false);
-  });
-
-  server.listen(port, '127.0.0.1');
-});
-
-const ports = {}
-
-export default async () => {
-  const app = express()
-  const getPort = (req) => +req.originalUrl.split('/')[2] || 8095
-
-  app.get(/\/on\/.*/, async (req, res) => {
-    const port = getPort(req)
-    if(!ports[port]) {
-      await createServer(getPort(req))
-      ports[port] = true
-    } else {
-    }
-    res.send('on')
-  })
-
-  app.get(/\/off\/.*/, async (req, res) => {
-    const port = getPort(req)
-    if(ports[port]) {
-      await killServer(port)
-      delete ports[port]
-    } else {
-    }
-    res.send('off')
-  })
-
-  const port = 8000 + Math.ceil(Math.random()*500)
-  app.listen(port, () => {});
-  return port
-}

package/test/specs/close.js

@@ -1,25 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Closes the connenction. */
-test.serial('close', (t) => {
-  return new Promise(async (ff) => {
-    await mockServer()
-    const port = 40513
-    const ws = await createNew({}, port)
-
-    setTimeout(async () => {
-      await ws.close()
-
-      if(ws.socket === null) {
-        await shutDown(port)
-        t.pass()
-      } else {
-        await shutDown(port)
-        t.fail()
-      }
-      return ff()
-    }, 500)
-  })
-})

package/test/specs/drops.js

@@ -1,29 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Rejects messages by timout */
-test.serial('drops', (t) => {
-  return new Promise(async (ff) => {
-    await mockServer()
-    const ws = await createNew({
-      timeout: 500
-    }, 8110)
-
-    await shutDown(8110)
-
-    setTimeout(async () => {
-      const msg = {echo: true, msg: 'hello!'}
-      try {
-        setTimeout(() => {
-          return ff(t.fail())
-        }, 600)
-        await ws.send(msg)
-        return ff(t.fail())
-      } catch(e) {
-        t.pass()
-        return ff()
-      }
-    }, 200)
-  })
-})

package/test/specs/echo.js

@@ -1,26 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Proof of work */
-test.serial('echo', (t) => {
-  t.timeout(5000)
-  return new Promise(async (ff, rj) => {
-    await mockServer()
-    let to = setTimeout(() => rj(t.fail('cannot create')), 2e2)
-    const ws = await createNew()
-    clearTimeout(to)
-  
-    to = setTimeout(() => rj(t.fail('cannot ready')), 2e2)
-    await ws.ready()
-    clearTimeout(to)
-  
-    const msg = {echo: true, msg: 'hello!'}
-    to = setTimeout(() => rj(t.fail('cannot send')), 2e2)
-    const response = await ws.send(msg)
-    clearTimeout(to)
-
-    await shutDown()
-    ff(t.deepEqual(response, msg))
-  })
-})

package/test/specs/encode-decode.js

@@ -1,3 +0,0 @@
-import test from 'ava'
-
-test.todo('TODO with mock server with specific port.')

package/test/specs/existing_socket.js

@@ -1,55 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown, turnOn } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-import * as WS from 'ws'
-
-/** If an existing socket connection is provided via config. */
-test.serial('existing_socket', (t) => {
-  const existing_port = 8095
-  const existing_addr = 'ws://localhost:' + existing_port
-  return new Promise(async (ff) => {
-    await mockServer()
-    const to = setTimeout(() => ff(t.fail()), 4e4)
-
-    await turnOn(existing_port)
-
-    // This one CANNOT connect as fast as we send to it,
-    // So readyState is 0.
-    const ws1 = await createNew({
-      socket: new WS(existing_addr)
-    })
-
-    t.is(ws1.socket.readyState, 0)
-
-    const msg1 = {echo: true, msg: 'existing_socket!'}
-    const response1 = await ws1.send(msg1)
-
-    t.is(ws1.socket.readyState, 1)
-    t.deepEqual(response1, msg1)
-    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
-      })
-
-      t.is(ws2.socket.readyState, 1)
-    
-      const msg2 = {echo: true, msg: 'existing_socket!'}
-      const response2 = await ws2.send(msg2)
-    
-      t.is(ws2.socket.readyState, 1)
-      t.deepEqual(response2, msg2)
-      await ws2.close()
-
-      clearTimeout(to)
-      shutDown()
-      ff()
-    })
-  })
-})

package/test/specs/lazy.js

@@ -1,26 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Lazy connect */
-test.serial('lazy', (t) => {
-  t.timeout(2000)
-  return new Promise(async (ff) => {
-    await mockServer()
-    const ws = await createNew({
-      lazy: true
-    }, 8103)
-
-    setTimeout(async () => {
-      if(ws.socket !== null) {
-        shutDown()
-        ff(t.fail())
-      } else {
-        const msg = {echo: true, msg: 'hello!'}
-        const response = await ws.send(msg)
-        shutDown()
-        ff(t.deepEqual(response, msg))
-      }
-    }, 500)
-  })
-})

package/test/specs/ready.js

@@ -1,16 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Ready method. */
-test.serial('ready', async (t) => {
-  await mockServer()
-  t.timeout(4e3)
-
-  const ws = await createNew()
-  await ws.ready()
-  // t.fail('fuck!')
-
-  await shutDown()
-  return ws.socket ? t.pass() : t.fail()
-})

package/test/specs/reconnect.js

@@ -1,28 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown, turnOn } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Reconnects if connection is broken. */
-test.serial('reconnect', (t) => {
-  const port = 8116
-  return new Promise(async (ff) => {
-    await mockServer()
-    const to = setTimeout(() => ff(t.fail()), 4e4)
-    const ws = await createNew({
-      reconnect: 1
-    }, port)
-
-    setTimeout(async () => {
-      await shutDown(port)
-      setTimeout(async () => {
-        await turnOn(port)
-        setTimeout(async () => {
-          const msg = {echo: true, msg: 'hello!'}
-          const response = await ws.send(msg)
-          clearTimeout(to)
-          ff(t.deepEqual(response, msg))
-        }, 1500)
-      }, 1100)
-    }, 500)
-  })
-})

package/test/specs/sendBeforeOpen.js

@@ -1,23 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Sends massages if they were .send() before connection is estabilished. */
-test.serial('sendBeforeOpen', (t) => {
-  return new Promise(async (ff, rj) => {
-    await mockServer()
-    let to = setTimeout(() => rj(t.fail('cannot create')), 2e2)
-    const ws = await createNew({
-      lazy: true
-    }, 8101)
-    clearTimeout(to)
-
-    const msg = {echo: true, msg: 'hello!'}
-    to = setTimeout(() => rj(t.fail('cannot send')), 2e2)
-    const response = await ws.send(msg)
-    clearTimeout(to)
-
-    await shutDown()
-    ff(t.deepEqual(response, msg))
-  })
-})

package/test/specs/socket.js

@@ -1,22 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Socket property check. */
-test.serial('sockets', (t) => {
-  return new Promise(async ff => {
-    await mockServer()
-    const to = setTimeout(() => ff(t.fail()), 4e4)
-    const ws = await createNew()
-
-    await ws.ready()
-
-    clearTimeout(to)
-    shutDown()
-    if(ws.socket && !isNaN(ws.socket.readyState)) {
-      ff(t.pass())
-    } else {
-      ff(t.fail())
-    }
-  })
-})