sleepy-socket 0.6.2 → 0.7.0

package/dist/utils.js

@@ -0,0 +1,16 @@
+export const defaultIdGenerator = () => crypto.randomUUID();
+let _uuidFn = defaultIdGenerator;
+export function joinRoute(...segments) {
+    const joined = segments
+        .filter(Boolean)
+        .join('/')
+        .replace(/\/{2,}/g, '/');
+    return joined.startsWith('/') ? joined : `/${joined}`;
+}
+export function id() {
+    return _uuidFn();
+}
+export function setIdGenerator(fn) {
+    _uuidFn = fn;
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,kBAAkB,GAAgB,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,CAAA;AAExE,IAAI,OAAO,GAAgB,kBAAkB,CAAA;AAE7C,MAAM,UAAU,SAAS,CAAE,GAAG,QAAkB;IAC9C,MAAM,MAAM,GAAG,QAAQ;SACpB,MAAM,CAAC,OAAO,CAAC;SACf,IAAI,CAAC,GAAG,CAAC;SACT,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAA;IAE1B,OAAO,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAA;AACvD,CAAC;AAED,MAAM,UAAU,EAAE;IAChB,OAAO,OAAO,EAAE,CAAA;AAClB,CAAC;AAED,MAAM,UAAU,cAAc,CAAE,EAAe;IAC7C,OAAO,GAAG,EAAE,CAAA;AACd,CAAC"}

package/package.json

@@ -3,9 +3,20 @@
   "description": "A dependency-free WebSocket client for sleepy-serv",
   "author": "Travis J True",
   "license": "MIT",
-  "version": "0.6.2",
-  "exports": "./src/index.js",
+  "version": "0.7.0",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "type": "module",
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.*"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/travistrue2008/sleepy-serv.git",
@@ -19,6 +30,12 @@
     "websocket",
     "www"
   ],
-  "scripts": {},
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.portable.json"
+  },
   "dependencies": {}
 }

package/src/{index.js → index.ts}

@@ -1,21 +1,97 @@
-import { TYPES, createMessage } from './messages'
-import { joinRoute } from './utils'
+import { MessageType, createMessage } from './messages.js'
+import { joinRoute } from './utils.js'
 
-export * from './messages'
-export * from './utils'
+export * from './messages.js'
+export * from './utils.js'
 
-export const QUEUE = {
-  NONE: 'none',
-  FIFO: 'fifo',
-  LIFO: 'lifo',
+export type TimeoutHandle = ReturnType<typeof setTimeout>
+export type IntervalHandle = ReturnType<typeof setInterval>
+
+export const Queue = {
+  None: 'none',
+  Fifo: 'fifo',
+  Lifo: 'lifo',
+} as const
+
+export type Queue = typeof Queue[keyof typeof Queue]
+
+export type ReconnectOptions = {
+  minDelay?: number
+  maxDelay?: number
+  factor?: number
+  random?: () => number
+}
+
+export type ConnectOptions = {
+  queue?: Queue
+  secure?: boolean
+  timeout?: number
+  serverTimeout?: number
+  mountPath?: string
+  reconnect?: ReconnectOptions | false
+}
+
+export type RequestOptions = {
+  headers?: Headers
+  query?: Record<string, unknown>
+  body?: unknown
+}
+
+export type ResponseMessage = {
+  id: string
+  clientId: string
+  type: typeof MessageType.Response
+  timestamp: string
+  status: number
+  headers: Record<string, string>
+  body: unknown
+}
+
+export type NotificationMessage = {
+  id: string
+  clientId: string
+  type: typeof MessageType.Notification
+  timestamp: string
+  event: string
+  headers: Record<string, string>
+  body: unknown
+}
+
+export type EventHandler = (payload: NotificationMessage) => void
+
+export type TicketData = {
+  clientId: string
+  ticket: string
+  data: unknown
+}
+
+type ReconnectConfig = {
+  minDelay: number
+  maxDelay: number
+  factor: number
+}
+
+type DispatchedMessage = {
+  id: string
+  ready: boolean
+  timer: ReturnType<typeof setTimeout>
+  response: ResponseMessage | null
+  resolve: (value: ResponseMessage) => void
+  reject: (reason: Error) => void
+}
+
+type NormalizedRequestOpts = {
+  headers: Headers
+  query: Record<string, unknown>
+  body: unknown
 }
 
 const RECONNECT_JITTER = 0.5
 const JSON_CONTENT_TYPE = 'application/json;charset=utf-8'
 
 export default class SleepySocketClient {
-  #id = null
-  #queueType = QUEUE.NONE
+  #id: string | null = null
+  #queueType: Queue = Queue.None
   #ready = false
   #closing = false
   #secure = false
@@ -23,75 +99,82 @@ export default class SleepySocketClient {
   #serverTimeout = 120_000
   #heartbeatInterval = 30_000
   #mountPath = ''
-  #host = null
-  #port = null
-  #token = null
-  #socket = null
-  #random = Math.random
-  #livenessTimer = null
-  #heartbeatTimer = null
-  #reconnectTimer = null
-  #reconnectConfig = null
-  #connectionData = null
-  #listeners = new Map()
-  #dispatchedMessages = []
-
-  get id () {
+  #host: string | null = null
+  #port: number | null = null
+  #token: string | null = null
+  #socket: WebSocket | null = null
+  #random: () => number = Math.random
+  #livenessTimer: ReturnType<typeof setTimeout> | null = null
+  #heartbeatTimer: ReturnType<typeof setInterval> | null = null
+  #reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  #reconnectConfig: ReconnectConfig | null = null
+  #connectionData: unknown = null
+  #listeners = new Map<string, Set<EventHandler>>()
+  #dispatchedMessages: DispatchedMessage[] = []
+
+  get id (): string | null {
     return this.#id
   }
 
-  get isConnected () {
+  get isConnected (): boolean {
     return this.#ready
   }
 
-  get queueType () {
-    return this.#queueType
+  get isSecure (): boolean {
+    return this.#secure
   }
 
-  get secure () {
-    return this.#secure
+  get queueType (): Queue {
+    return this.#queueType
   }
 
-  get timeout () {
+  get timeout (): number {
     return this.#timeout
   }
 
-  get heartbeatInterval () {
+  get heartbeatInterval (): number {
     return this.#heartbeatInterval
   }
 
-  get serverTimeout () {
+  get serverTimeout (): number {
     return this.#serverTimeout
   }
 
-  get token () {
+  get token (): string | null {
     return this.#token
   }
 
-  get mountPath () {
+  get mountPath (): string {
     return this.#mountPath
   }
 
-  get socket () {
+  get socket (): WebSocket | null {
     return this.#socket
   }
 
-  get connectionData () {
+  get connectionData (): unknown {
     return this.#connectionData
   }
 
-  static async connect (host, port, opts = {}) {
-    if (opts.queue && !Object.values(QUEUE).includes(opts.queue)) {
+  static async connect (
+    host: string,
+    port: number,
+    opts: ConnectOptions = {},
+  ): Promise<SleepySocketClient> {
+    if (opts.queue && !Object.values(Queue).includes(opts.queue)) {
       throw new RangeError(`Invalid queue type: ${opts.queue}`)
     }
 
     const client = new this()
-    const hasReconnect = opts.reconnect && typeof opts.reconnect === 'object'
-    const reconnect = hasReconnect ? opts.reconnect : {}
+
+    const reconnect: ReconnectOptions =
+      opts.reconnect && typeof opts.reconnect === 'object'
+        ? opts.reconnect
+        : {}
 
     client.#host = host
     client.#port = port
-    client.#queueType = opts.queue ?? QUEUE.NONE
+    client.#queueType = opts.queue ?? Queue.None
     client.#secure = opts.secure ?? false
     client.#timeout = opts.timeout ?? 30_000
     client.#serverTimeout = opts.serverTimeout ?? 120_000
@@ -112,21 +195,21 @@ export default class SleepySocketClient {
     return client
   }
 
-  #baseUrl () {
+  #baseUrl (): string {
     const protocol = this.#secure ? 'https' : 'http'
 
     return `${protocol}://${this.#host}:${this.#port}${this.#mountPath}`
   }
 
-  async #createTicket () {
+  async #createTicket (): Promise<TicketData> {
     const response = await fetch(`${this.#baseUrl()}/ws`, {
       method: 'POST',
     })
 
-    return response.json()
+    return await response.json() as TicketData
   }
 
-  async #reclaimTicket () {
+  async #reclaimTicket (): Promise<TicketData | null> {
     const url = `${this.#baseUrl()}/ws/${this.#id}`
 
     const response = await fetch(url, {
@@ -140,10 +223,10 @@ export default class SleepySocketClient {
       return null
     }
 
-    return response.json()
+    return await response.json() as TicketData
   }
 
-  async #requestTicket () {
+  async #requestTicket (): Promise<TicketData> {
     if (this.#id && this.#token) {
       const reclaimed = await this.#reclaimTicket()
 
@@ -155,25 +238,31 @@ export default class SleepySocketClient {
     return this.#createTicket()
   }
 
-  #socketUrl (ticket) {
+  #socketUrl (ticket: string): string {
     const protocol = this.#secure ? 'wss' : 'ws'
     const authority = `${this.#host}:${this.#port}${this.#mountPath}`
 
     return `${protocol}://${authority}/ws?ticket=${ticket}`
   }
 
-  #openSocket (res, succeed, fail) {
-    this.#socket = new WebSocket(this.#socketUrl(res.ticket))
+  #openSocket (
+    res: TicketData,
+    succeed: () => void,
+    fail: (message: string) => void,
+  ): void {
+    const socket = new WebSocket(this.#socketUrl(res.ticket))
+
+    this.#socket = socket
     this.#connectionData = res.data
 
-    const onError = () => fail('Connection failed.')
+    const onError = (): void => fail('Connection failed.')
 
-    const onWelcome = event => {
+    const onWelcome = (event: MessageEvent): void => {
       const message = JSON.parse(event.data)
 
-      this.#socket.removeEventListener('message', onWelcome)
+      socket.removeEventListener('message', onWelcome)
 
-      if (message.type !== TYPES.WELCOME) {
+      if (message.type !== MessageType.Welcome) {
         fail('Expected a welcome message.')
 
         return
@@ -183,8 +272,8 @@ export default class SleepySocketClient {
       this.#token = message.body.token
       this.#heartbeatInterval = message.body.heartbeatInterval
 
-      this.#socket.addEventListener('message', ev => this.#handleMessage(ev))
-      this.#socket.addEventListener('close', ev => this.#handleClose(ev))
+      socket.addEventListener('message', ev => this.#handleMessage(ev))
+      socket.addEventListener('close', ev => this.#handleClose(ev))
 
       this.#startHeartbeat()
       this.#armLiveness()
@@ -194,15 +283,15 @@ export default class SleepySocketClient {
       succeed()
     }
 
-    this.#socket.addEventListener('open', () => {
-      this.#socket.removeEventListener('error', onError)
-      this.#socket.addEventListener('message', onWelcome)
+    socket.addEventListener('open', () => {
+      socket.removeEventListener('error', onError)
+      socket.addEventListener('message', onWelcome)
     }, { once: true })
 
-    this.#socket.addEventListener('error', onError)
+    socket.addEventListener('error', onError)
   }
 
-  #establish () {
+  #establish (): Promise<void> {
     return new Promise((resolve, reject) => {
       let settled = false
 
@@ -217,7 +306,7 @@ export default class SleepySocketClient {
         reject(new Error('Connection timed out.'))
       }, this.#timeout)
 
-      const fail = message => {
+      const fail = (message: string): void => {
         if (settled) {
           return
         }
@@ -228,7 +317,7 @@ export default class SleepySocketClient {
         reject(new Error(message))
       }
 
-      const succeed = () => {
+      const succeed = (): void => {
         if (settled) {
           return
         }
@@ -245,16 +334,18 @@ export default class SleepySocketClient {
     })
   }
 
-  #armLiveness () {
-    clearTimeout(this.#livenessTimer)
+  #armLiveness (): void {
+    if (this.#livenessTimer) {
+      clearTimeout(this.#livenessTimer)
+    }
 
     this.#livenessTimer = setTimeout(() => {
       this.#socket?.close()
     }, this.serverTimeout)
   }
 
-  #scheduleReconnect (attempt) {
-    const { minDelay, maxDelay, factor } = this.#reconnectConfig
+  #scheduleReconnect (attempt: number, config: ReconnectConfig): void {
+    const { minDelay, maxDelay, factor } = config
     const base = Math.min(minDelay * factor ** attempt, maxDelay)
     const delay = base * (1 + this.#random() * RECONNECT_JITTER)
 
@@ -272,26 +363,28 @@ export default class SleepySocketClient {
           return
         }
 
-        this.#scheduleReconnect(attempt + 1)
+        this.#scheduleReconnect(attempt + 1, config)
       }
     }, delay)
   }
 
-  #startHeartbeat () {
+  #startHeartbeat (): void {
     this.#heartbeatTimer = setInterval(() => {
-      const message = createMessage(this.#id, TYPES.HEARTBEAT)
+      const message = createMessage(this.#id!, MessageType.Heartbeat)
 
-      this.#socket.send(JSON.stringify(message))
+      this.#socket!.send(JSON.stringify(message))
     }, this.#heartbeatInterval)
   }
 
-  #stopHeartbeat () {
-    clearInterval(this.#heartbeatTimer)
+  #stopHeartbeat (): void {
+    if (this.#heartbeatTimer) {
+      clearInterval(this.#heartbeatTimer)
+    }
 
     this.#heartbeatTimer = null
   }
 
-  #normalizeRequestOpts (opts) {
+  #normalizeRequestOpts (opts: RequestOptions): NormalizedRequestOpts {
     if (opts.headers !== undefined && !(opts.headers instanceof Headers)) {
       throw new TypeError('opts.headers must be a Headers instance')
     }
@@ -313,7 +406,11 @@ export default class SleepySocketClient {
     }
   }
 
-  #sendRequest (method, route, opts = {}) {
+  #sendRequest (
+    method: string,
+    route: string,
+    opts: RequestOptions = {},
+  ): Promise<ResponseMessage> {
     if (!this.#ready) {
       throw new Error('Socket is closed')
     }
@@ -321,7 +418,7 @@ export default class SleepySocketClient {
     const { headers, query, body } = this.#normalizeRequestOpts(opts)
     const fullRoute = joinRoute(this.#mountPath, route)
 
-    const message = createMessage(this.#id, TYPES.REQUEST, {
+    const message = createMessage(this.#id!, MessageType.Request, {
       method,
       query,
       body,
@@ -351,15 +448,18 @@ export default class SleepySocketClient {
         response: null,
       })
 
-      this.#socket.send(JSON.stringify(message))
+      this.#socket!.send(JSON.stringify(message))
     })
   }
 
-  #handleClose (event) {
+  #handleClose (event: CloseEvent): void {
     this.#ready = false
 
     this.#stopHeartbeat()
-    clearTimeout(this.#livenessTimer)
+
+    if (this.#livenessTimer) {
+      clearTimeout(this.#livenessTimer)
+    }
 
     for (const entry of this.#dispatchedMessages) {
       clearTimeout(entry.timer)
@@ -381,10 +481,10 @@ export default class SleepySocketClient {
       return
     }
 
-    this.#scheduleReconnect(0)
+    this.#scheduleReconnect(0, this.#reconnectConfig)
   }
 
-  #handleRequest (data) {
+  #handleRequest (data: ResponseMessage): void {
     const entry = this.#dispatchedMessages.find(item => item.id === data.id)
 
     if (!entry) {
@@ -399,23 +499,23 @@ export default class SleepySocketClient {
     this.#drain()
   }
 
-  #handleNotification (data) {
+  #handleNotification (data: NotificationMessage): void {
     this.#emit('notification', data)
   }
 
-  #handleMessage (event) {
+  #handleMessage (event: MessageEvent): void {
     this.#armLiveness()
 
     const data = JSON.parse(event.data)
 
     switch (data.type) {
-      case TYPES.HEARTBEAT:
+      case MessageType.Heartbeat:
         return
 
-      case TYPES.RESPONSE:
+      case MessageType.Response:
         return this.#handleRequest(data)
 
-      case TYPES.NOTIFICATION:
+      case MessageType.Notification:
         return this.#handleNotification(data)
 
       default:
@@ -423,46 +523,46 @@ export default class SleepySocketClient {
     }
   }
 
-  #processNone () {
+  #processNone (): void {
     this.#dispatchedMessages = this.#dispatchedMessages.filter(entry => {
       if (entry.ready) {
-        entry.resolve(entry.response)
+        entry.resolve(entry.response!)
       }
 
       return !entry.ready
     })
   }
 
-  #processFifo () {
+  #processFifo (): void {
     while (this.#dispatchedMessages[0]?.ready) {
       const [entry] = this.#dispatchedMessages.splice(0, 1)
 
-      entry.resolve(entry.response)
+      entry.resolve(entry.response!)
     }
   }
 
-  #processLifo () {
+  #processLifo (): void {
     while (this.#dispatchedMessages.at(-1)?.ready) {
       const entry = this.#dispatchedMessages.pop()
 
-      entry.resolve(entry.response)
+      entry!.resolve(entry!.response!)
     }
   }
 
-  #drain () {
+  #drain (): void {
     switch (this.#queueType) {
-      case QUEUE.NONE:
+      case Queue.None:
         return this.#processNone()
 
-      case QUEUE.FIFO:
+      case Queue.Fifo:
         return this.#processFifo()
 
-      case QUEUE.LIFO:
+      case Queue.Lifo:
         return this.#processLifo()
     }
   }
 
-  #emit (event, payload) {
+  #emit (event: string, payload: NotificationMessage): void {
     const handlers = this.#listeners.get(event)
 
     if (!handlers) {
@@ -478,19 +578,19 @@ export default class SleepySocketClient {
     }
   }
 
-  on (event, handler) {
+  on (event: string, handler: EventHandler): void {
     if (!this.#listeners.has(event)) {
       this.#listeners.set(event, new Set())
     }
 
-    this.#listeners.get(event).add(handler)
+    this.#listeners.get(event)!.add(handler)
   }
 
-  off (event, handler) {
+  off (event: string, handler: EventHandler): void {
     this.#listeners.get(event)?.delete(handler)
   }
 
-  async close () {
+  async close (): Promise<void> {
     if (this.#closing) {
       throw new Error('Socket is closed')
     }
@@ -499,8 +599,14 @@ export default class SleepySocketClient {
     this.#ready = false
 
     this.#stopHeartbeat()
-    clearTimeout(this.#livenessTimer)
-    clearTimeout(this.#reconnectTimer)
+
+    if (this.#livenessTimer) {
+      clearTimeout(this.#livenessTimer)
+    }
+
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer)
+    }
 
     this.#reconnectTimer = null
 
@@ -511,27 +617,27 @@ export default class SleepySocketClient {
     }
   }
 
-  head (route, opts = {}) {
+  head (route: string, opts: RequestOptions = {}): Promise<ResponseMessage> {
     return this.#sendRequest('HEAD', route, opts)
   }
 
-  get (route, opts = {}) {
+  get (route: string, opts: RequestOptions = {}): Promise<ResponseMessage> {
     return this.#sendRequest('GET', route, opts)
   }
 
-  post (route, opts = {}) {
+  post (route: string, opts: RequestOptions = {}): Promise<ResponseMessage> {
     return this.#sendRequest('POST', route, opts)
   }
 
-  put (route, opts = {}) {
+  put (route: string, opts: RequestOptions = {}): Promise<ResponseMessage> {
     return this.#sendRequest('PUT', route, opts)
   }
 
-  patch (route, opts = {}) {
+  patch (route: string, opts: RequestOptions = {}): Promise<ResponseMessage> {
     return this.#sendRequest('PATCH', route, opts)
   }
 
-  delete (route, opts = {}) {
+  delete (route: string, opts: RequestOptions = {}): Promise<ResponseMessage> {
     return this.#sendRequest('DELETE', route, opts)
   }
 }