wspromisify 2.4.4 → 2.6.0

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/types.ts

@@ -4,7 +4,7 @@ declare namespace wsc {
     [key: string]: any
   }
 
-  export type WSEvent = 'open' | 'message' | 'close' | 'error'
+  export type WSEvent = 'open' | 'message' | 'close' | 'error' | 'timeout'
 
   /** Minimal socket-like interface. */
   interface Socket {

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('.')

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