@owlmeans/socket 0.1.18-rc.8 → 0.1.18

package/src/model.ts

@@ -1,12 +1,15 @@
 import { ResilientError } from '@owlmeans/error'
 import { CALL_TIMEOUT, MessageType } from './consts.js'
-import { SocketMessageMalformed, SocketTimeout } from './errors.js'
+import { SocketMessageMalformed, SocketTimeout, SocketUnauthorized, SocketUnsupported } from './errors.js'
 import type {
   AuthMessage, CallHendler, CallMessage, CallResolver, Connection, ConnectionListener,
   EventMessage, Message, RequestHandler
 } from './types.js'
-import { uuid } from '@owlmeans/basic-ids'
 import { AuthenticationStage, AuthError } from '@owlmeans/auth'
+import { logger } from '@owlmeans/log'
+import { idHelper } from '@owlmeans/basic-ids'
+
+const log = logger('socket')
 
 export const createBasicConnection = (): Connection => {
   const listeners: ConnectionListener[] = []
@@ -52,7 +55,7 @@ export const createBasicConnection = (): Connection => {
 
     call: async (method, ...payload) => {
       const msg: CallMessage<any> = {
-        method, payload, type: MessageType.Call, id: uuid()
+        method, payload, type: MessageType.Call, id: idHelper.uuid()
       }
       conn.prepare?.(msg)
       return new Promise(async (resolve, reject) => {
@@ -86,7 +89,7 @@ export const createBasicConnection = (): Connection => {
 
     request: async (payload, observer) => {
       const msg: Message<any> = {
-        type: MessageType.Request, payload, id: uuid()
+        type: MessageType.Request, payload, id: idHelper.uuid()
       }
       if (observer != null) {
         observers[msg.id!] = observer
@@ -175,116 +178,148 @@ export const createBasicConnection = (): Connection => {
     },
 
     receive: async message => {
-      if (message.startsWith('{') || message.startsWith('[')) {
-        let msg: Message<any> | string = message
-        try {
-          msg = JSON.parse(message)
-        } catch {
-        }
-        if (typeof msg === 'object') {
-          if (msg.payload == null) {
-            msg.payload = msg
-          }
-          if (msg.type == null) {
-            msg.type = MessageType.Message
-          }
-          msg.rawData = message
-          if (conn.prepare != null) {
-            conn.prepare(msg, true)
-          }
-          try {
-            switch (msg.type) {
-              case MessageType.Call: {
-                await conn._receiveCall(msg as CallMessage<any>)
-                break
-              }
-              case MessageType.Result: {
-                await conn._receiveResult(msg)
-                break
-              }
-              case MessageType.Error: {
-                await conn._receiveError(msg)
-                break
-              }
-              case MessageType.Request: {
-                await conn._receiveRequest(msg)
-                break
-              }
-              case MessageType.Response: {
-                await conn._receiveResponse(msg)
-                break
-              }
-              case MessageType.Event: {
-                await conn._receiveEvent(msg as EventMessage<any>)
-                break
-              }
-              case MessageType.Message: {
-                await conn._receiveMessage(msg)
-                break
+      if (!message.startsWith('{') && !message.startsWith('[')) {
+        return
+      }
+
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(message)
+      } catch {
+        throw new SocketMessageMalformed('json')
+      }
+      if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new SocketMessageMalformed('shape')
+      }
+
+      const msg = parsed as Message<any>
+      if (msg.payload == null) {
+        msg.payload = parsed
+      }
+      if (msg.type == null) {
+        msg.type = MessageType.Message
+      }
+      if (!Object.values(MessageType).includes(msg.type)) {
+        throw new SocketMessageMalformed('type')
+      }
+      // System frames belong to the carrier lifecycle and are never accepted from the wire.
+      if (msg.type === MessageType.System) {
+        throw new SocketMessageMalformed('system')
+      }
+      if (conn.requiresAuthentication === true
+        && conn.stage !== AuthenticationStage.Authenticated
+        && msg.type !== MessageType.Auth) {
+        throw new SocketUnauthorized('stage')
+      }
+
+      msg.rawData = message
+      conn.prepare?.(msg, true)
+
+      try {
+        switch (msg.type) {
+          case MessageType.Call:
+            await conn._receiveCall(msg as CallMessage<any>)
+            break
+          case MessageType.Result:
+            await conn._receiveResult(msg)
+            break
+          case MessageType.Error:
+            await conn._receiveError(msg)
+            break
+          case MessageType.Request:
+            await conn._receiveRequest(msg)
+            break
+          case MessageType.Response:
+            await conn._receiveResponse(msg)
+            break
+          case MessageType.Event:
+            await conn._receiveEvent(msg as EventMessage<any>)
+            break
+          case MessageType.Message:
+            await conn._receiveMessage(msg)
+            break
+          case MessageType.Auth: {
+            const authMessage = msg as AuthMessage<any>
+            if (conn._authSequence != null) {
+              if (authMessage.stage == null) {
+                conn._authSequence.reject(ResilientError.ensure(
+                  authMessage.payload ?? new AuthError('socket:unknown')
+                ))
+              } else {
+                conn.stage = authMessage.stage
+                conn._authSequence.resolve(authMessage.payload)
               }
-              case MessageType.Auth: {
-                const _msg: AuthMessage<any> = msg as AuthMessage<any>
-                if (conn._authSequence != null) {
-                  if (_msg.stage == null) {
-                    conn._authSequence.reject(ResilientError.ensure(_msg.payload ?? new AuthError('socket:unknown')))
-                  } else {
-                    conn.stage = _msg.stage
-                    conn._authSequence.resolve(_msg.payload)
-                  }
-                  conn._authSequence = undefined
-                } else {
-                  try {
-                    const [stage, response] = await conn.authenticate(_msg.stage, _msg.payload)
-                    if (stage != null) {
-                      conn.auth(stage, response).finally(() => void 0)
-                    }
-                  } catch (e) {
-                    conn.auth(null as any, ResilientError.marshal(ResilientError.ensure(e as Error))).finally(() => void 0)
-                  } finally {
-                    conn._authSequence = undefined
-                  }
+              conn._authSequence = undefined
+            } else {
+              try {
+                const [stage, response] = await conn.authenticate(authMessage.stage, authMessage.payload)
+                if (stage != null) {
+                  void conn.auth(stage, response).catch(error => {
+                    log.warn('Socket authentication response not sent', { error })
+                  })
                 }
-                break
+              } catch (error) {
+                void conn.auth(
+                  null as any,
+                  ResilientError.marshal(ResilientError.ensure(error as Error))
+                ).catch(sendError => {
+                  log.warn('Socket authentication error not sent', { error: sendError })
+                })
+              } finally {
+                conn._authSequence = undefined
               }
             }
-          } catch (e) {
-            console.error('Error on message processing:', e)
-            throw ResilientError.ensure(e as Error)
+            break
           }
         }
-        await Promise.all(listeners.map(async listener => listener(msg)))
+      } catch (error) {
+        throw ResilientError.ensure(error as Error)
       }
+
+      // A consumer listener is an observation hook, not part of dispatch. One rejecting listener
+      // must neither skip its peers nor reject the transport event callback.
+      await Promise.all(listeners.map(async listener => {
+        try {
+          await listener(msg)
+        } catch (error) {
+          log.error('Socket listener failed', { error })
+        }
+      }))
     },
 
     _receiveCall: async msg => {
+      if (msg.id == null) {
+        throw new SocketMessageMalformed('call:id')
+      }
+      if (typeof msg.method !== 'string' || msg.method.length === 0 || !Array.isArray(msg.payload)) {
+        throw new SocketMessageMalformed('call')
+      }
+
       let cancel = false
-      callPerformers[msg.method](...msg.payload)
-        .then(async result => {
-          if (cancel) {
-            return
-          }
-          clearTimeout(timeout)
-          const resultMsg: Message<any> = {
-            id: msg.id,
-            type: MessageType.Result,
-            payload: result
-          }
-          await conn.send(resultMsg)
-        }).catch(async error => {
-          console.error('Error during the call:', error)
-          if (cancel) {
-            return
-          }
-          clearTimeout(timeout)
-          const response: Message<any> = {
-            id: msg.id,
-            type: MessageType.Error,
-            payload: ResilientError.ensure(error).marshal().message
-          }
-          await conn.send(response)
-        })
       msg.timeout = msg.timeout ?? conn.defaultCallTimeout ?? CALL_TIMEOUT
       const timeout = setTimeout(() => { if (msg.timeout !== 0) cancel = true }, msg.timeout)
+
+      try {
+        const performer = callPerformers[msg.method]
+        if (performer == null) {
+          throw new SocketUnsupported(`call:${msg.method}`)
+        }
+        const result = await performer(...msg.payload)
+        if (!cancel) {
+          await conn.send({ id: msg.id, type: MessageType.Result, payload: result })
+        }
+      } catch (error) {
+        if (!cancel) {
+          const resilient = ResilientError.ensure(error as Error)
+          await conn.send({
+            id: msg.id,
+            type: MessageType.Error,
+            payload: resilient.marshal().message
+          })
+        }
+      } finally {
+        clearTimeout(timeout)
+      }
     },
 
     _receiveResult: async msg => {

package/src/types.ts

@@ -9,6 +9,12 @@ export interface Connection {
 
   stage: AuthenticationStage
 
+  /**
+   * When enabled by a server carrier, only authentication frames are accepted until the
+   * connection reaches `AuthenticationStage.Authenticated`.
+   */
+  requiresAuthentication?: boolean
+
   notify: <T>(event: string, payload: T) => Promise<void>
   observe: <T>(event: string, handler: (event: EventMessage<T>) => Promise<void>) => () => void
 

package/tests/model.spec.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from 'bun:test'
+import { AuthenticationStage } from '@owlmeans/auth'
+import { ResilientError } from '@owlmeans/error'
+import {
+  createBasicConnection, MessageType, SocketMessageMalformed, SocketUnauthorized, SocketUnsupported
+} from '../src/index.js'
+import type { Message } from '../src/index.js'
+
+describe('@owlmeans/socket — inbound frame boundary', () => {
+  test('rejects malformed JSON, non-object frames, and wire System frames', async () => {
+    const connection = createBasicConnection()
+
+    await expect(connection.receive('{')).rejects.toBeInstanceOf(SocketMessageMalformed)
+    await expect(connection.receive('[]')).rejects.toBeInstanceOf(SocketMessageMalformed)
+    await expect(connection.receive(JSON.stringify({
+      type: MessageType.System, event: 'close', payload: {}
+    }))).rejects.toBeInstanceOf(SocketMessageMalformed)
+  })
+
+  test('permits only authentication frames before a server carrier authenticates the connection', async () => {
+    const connection = createBasicConnection()
+    connection.requiresAuthentication = true
+
+    await expect(connection.receive(JSON.stringify({
+      type: MessageType.Message, payload: 'before-auth'
+    }))).rejects.toBeInstanceOf(SocketUnauthorized)
+
+    connection.stage = AuthenticationStage.Authenticated
+    await connection.receive(JSON.stringify({ type: MessageType.Message, payload: 'after-auth' }))
+    expect(connection.consume()).toEqual(['after-auth', undefined, 0])
+  })
+
+  test('answers an unknown call with a typed error instead of rejecting dispatch', async () => {
+    const connection = createBasicConnection()
+    const sent: Message<unknown>[] = []
+    connection.send = async message => {
+      if (typeof message !== 'string') sent.push(message)
+    }
+
+    await connection.receive(JSON.stringify({
+      type: MessageType.Call, id: 'call-1', method: 'missing', payload: []
+    }))
+
+    expect(sent).toHaveLength(1)
+    expect(sent[0]?.type).toBe(MessageType.Error)
+    expect(ResilientError.ensure(sent[0]?.payload as string)).toBeInstanceOf(SocketUnsupported)
+  })
+
+  test('isolates rejecting listeners and still runs their peers', async () => {
+    const connection = createBasicConnection()
+    let observed = false
+    connection.listen(async () => { throw new Error('listener failed') })
+    connection.listen(async () => { observed = true })
+
+    await connection.receive(JSON.stringify({ type: MessageType.Message, payload: 'event' }))
+
+    expect(observed).toBe(true)
+  })
+})

package/tsconfig.json

@@ -7,5 +7,5 @@
     "rootDir": "./src/",
     "outDir": "./build/"
   },
-  "exclude": ["./dist/**/*", "./build/**/*", "./*.ts"]
+  "exclude": ["./dist/**/*", "./build/**/*", "./tests/**/*", "./*.ts"]
 }