@nmtjs/client 0.15.2 → 0.16.0-beta.1

package/src/layers/streams.ts

@@ -0,0 +1,277 @@
+import type { ProtocolBlob, ProtocolBlobMetadata } from '@nmtjs/protocol'
+import type {
+  ProtocolClientBlobStream,
+  ProtocolServerBlobConsumer,
+} from '@nmtjs/protocol/client'
+import { MAX_UINT32, noopFn } from '@nmtjs/common'
+import { ClientMessageType, kBlobKey, ServerMessageType } from '@nmtjs/protocol'
+import { ProtocolServerBlobStream } from '@nmtjs/protocol/client'
+
+import type { ClientCore } from '../core.ts'
+import { ClientStreams, ServerStreams } from '../streams.ts'
+
+const DEFAULT_PULL_SIZE = 65535
+
+const toReasonString = (reason: unknown) => {
+  if (typeof reason === 'string') return reason
+  if (reason === undefined || reason === null) return undefined
+  return String(reason)
+}
+
+export interface StreamLayerApi {
+  readonly clientStreams: ClientStreams
+  readonly serverStreams: ServerStreams
+  getStreamId: () => number
+  addClientStream: (blob: ProtocolBlob) => ProtocolClientBlobStream
+  createServerBlobStream: (
+    streamId: number,
+    metadata: ProtocolBlobMetadata,
+  ) => ProtocolServerBlobConsumer
+  addServerBlobStream: (metadata: ProtocolBlobMetadata) => {
+    streamId: number
+    stream: ProtocolServerBlobStream
+  }
+}
+
+export const createServerBlobConsumer = (
+  metadata: ProtocolBlobMetadata,
+  subscribe: (options?: { signal?: AbortSignal }) => ProtocolServerBlobStream,
+): ProtocolServerBlobConsumer => {
+  const consumer = ((options?: { signal?: AbortSignal }) =>
+    subscribe(options)) as ProtocolServerBlobConsumer
+
+  Object.defineProperties(consumer, {
+    metadata: {
+      configurable: false,
+      enumerable: true,
+      writable: false,
+      value: metadata,
+    },
+    [kBlobKey]: {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: true,
+    },
+  })
+
+  return consumer
+}
+
+export const createStreamLayer = (core: ClientCore): StreamLayerApi => {
+  const clientStreams = new ClientStreams()
+  const serverStreams = new ServerStreams()
+
+  let streamId = 0
+
+  const getStreamId = () => {
+    if (streamId >= MAX_UINT32) {
+      streamId = 0
+    }
+
+    return streamId++
+  }
+
+  const addClientStream = (blob: ProtocolBlob) => {
+    const id = getStreamId()
+    return clientStreams.add(blob.source, id, blob.metadata)
+  }
+
+  const createServerBlobStream = (
+    id: number,
+    metadata: ProtocolBlobMetadata,
+  ) => {
+    const stream = new ProtocolServerBlobStream(metadata, {
+      pull: () => {
+        if (!core.messageContext) return
+
+        core.emitStreamEvent({
+          direction: 'outgoing',
+          streamType: 'server_blob',
+          action: 'pull',
+          streamId: id,
+          byteLength: DEFAULT_PULL_SIZE,
+        })
+
+        const buffer = core.protocol.encodeMessage(
+          core.messageContext,
+          ClientMessageType.ServerStreamPull,
+          { streamId: id, size: DEFAULT_PULL_SIZE },
+        )
+
+        core.send(buffer).catch(noopFn)
+      },
+      close: () => {
+        serverStreams.remove(id)
+      },
+      readableStrategy: { highWaterMark: 0 },
+    })
+
+    serverStreams.add(id, stream)
+
+    return createServerBlobConsumer(metadata, ({ signal } = {}) => {
+      if (signal) {
+        signal.addEventListener(
+          'abort',
+          () => {
+            if (!core.messageContext) return
+
+            core.emitStreamEvent({
+              direction: 'outgoing',
+              streamType: 'server_blob',
+              action: 'abort',
+              streamId: id,
+              reason: toReasonString(signal.reason),
+            })
+
+            const buffer = core.protocol.encodeMessage(
+              core.messageContext,
+              ClientMessageType.ServerStreamAbort,
+              { streamId: id, reason: toReasonString(signal.reason) },
+            )
+
+            core.send(buffer).catch(noopFn)
+            void serverStreams.abort(id).catch(noopFn)
+          },
+          { once: true },
+        )
+      }
+
+      return stream
+    })
+  }
+
+  const addServerBlobStream = (metadata: ProtocolBlobMetadata) => {
+    const id = getStreamId()
+    const stream = new ProtocolServerBlobStream(metadata)
+    serverStreams.add(id, stream)
+    return { streamId: id, stream }
+  }
+
+  core.on('message', (message: any) => {
+    switch (message.type) {
+      case ServerMessageType.ServerStreamPush:
+        core.emitStreamEvent({
+          direction: 'incoming',
+          streamType: 'server_blob',
+          action: 'push',
+          streamId: message.streamId,
+          byteLength: message.chunk.byteLength,
+        })
+        void serverStreams.push(message.streamId, message.chunk)
+        break
+      case ServerMessageType.ServerStreamEnd:
+        core.emitStreamEvent({
+          direction: 'incoming',
+          streamType: 'server_blob',
+          action: 'end',
+          streamId: message.streamId,
+        })
+        void serverStreams.end(message.streamId)
+        break
+      case ServerMessageType.ServerStreamAbort:
+        core.emitStreamEvent({
+          direction: 'incoming',
+          streamType: 'server_blob',
+          action: 'abort',
+          streamId: message.streamId,
+          reason: message.reason,
+        })
+        void serverStreams.abort(message.streamId)
+        break
+      case ServerMessageType.ClientStreamPull:
+        core.emitStreamEvent({
+          direction: 'incoming',
+          streamType: 'client_blob',
+          action: 'pull',
+          streamId: message.streamId,
+          byteLength: message.size,
+        })
+
+        void clientStreams.pull(message.streamId, message.size).then(
+          (chunk) => {
+            if (!core.messageContext) return
+
+            if (chunk) {
+              core.emitStreamEvent({
+                direction: 'outgoing',
+                streamType: 'client_blob',
+                action: 'push',
+                streamId: message.streamId,
+                byteLength: chunk.byteLength,
+              })
+
+              const buffer = core.protocol.encodeMessage(
+                core.messageContext,
+                ClientMessageType.ClientStreamPush,
+                { streamId: message.streamId, chunk },
+              )
+
+              core.send(buffer).catch(noopFn)
+              return
+            }
+
+            core.emitStreamEvent({
+              direction: 'outgoing',
+              streamType: 'client_blob',
+              action: 'end',
+              streamId: message.streamId,
+            })
+
+            const buffer = core.protocol.encodeMessage(
+              core.messageContext,
+              ClientMessageType.ClientStreamEnd,
+              { streamId: message.streamId },
+            )
+
+            core.send(buffer).catch(noopFn)
+            void clientStreams.end(message.streamId).catch(noopFn)
+          },
+          () => {
+            if (!core.messageContext) return
+
+            core.emitStreamEvent({
+              direction: 'outgoing',
+              streamType: 'client_blob',
+              action: 'abort',
+              streamId: message.streamId,
+            })
+
+            const buffer = core.protocol.encodeMessage(
+              core.messageContext,
+              ClientMessageType.ClientStreamAbort,
+              { streamId: message.streamId },
+            )
+
+            core.send(buffer).catch(noopFn)
+            clientStreams.remove(message.streamId)
+          },
+        )
+        break
+      case ServerMessageType.ClientStreamAbort:
+        core.emitStreamEvent({
+          direction: 'incoming',
+          streamType: 'client_blob',
+          action: 'abort',
+          streamId: message.streamId,
+          reason: message.reason,
+        })
+        void clientStreams.abort(message.streamId, message.reason).catch(noopFn)
+        break
+    }
+  })
+
+  core.on('disconnected', (reason) => {
+    void clientStreams.clear(reason).catch(noopFn)
+    void serverStreams.clear(reason).catch(noopFn)
+  })
+
+  return {
+    clientStreams,
+    serverStreams,
+    getStreamId,
+    addClientStream,
+    createServerBlobStream,
+    addServerBlobStream,
+  }
+}

package/src/plugins/browser.ts

@@ -1,32 +1,60 @@
 import type { ClientPlugin } from './types.ts'
 
+const syncPauseReasons = (
+  setPauseReason: (reason: string, active: boolean) => void,
+) => {
+  if (globalThis.window && 'navigator' in globalThis.window) {
+    setPauseReason('offline', globalThis.window.navigator?.onLine === false)
+  }
+
+  if (globalThis.document) {
+    setPauseReason(
+      'tab_hidden',
+      globalThis.document.visibilityState === 'hidden',
+    )
+  }
+}
+
 export const browserConnectivityPlugin = (): ClientPlugin => {
-  return (client) => {
+  return ({ core }) => {
     const cleanup: Array<() => void> = []
 
-    const maybeConnect = () => {
-      if (client.state === 'disconnected' && !client.isDisposed()) {
-        client.connect().catch(() => void 0)
+    const triggerReconnect = () => {
+      if (!core.isDisposed()) {
+        core.triggerReconnect()
       }
     }
 
     return {
       name: 'browser-connectivity',
       onInit: () => {
+        syncPauseReasons(core.setReconnectPauseReason.bind(core))
+
         if (globalThis.window) {
-          const onPageShow = () => maybeConnect()
+          const onPageShow = () => triggerReconnect()
           globalThis.window.addEventListener('pageshow', onPageShow)
           cleanup.push(() =>
             globalThis.window?.removeEventListener('pageshow', onPageShow),
           )
 
-          const onOnline = () => maybeConnect()
+          const onOnline = () => {
+            core.setReconnectPauseReason('offline', false)
+            triggerReconnect()
+          }
           globalThis.window.addEventListener('online', onOnline)
           cleanup.push(() =>
             globalThis.window?.removeEventListener('online', onOnline),
           )
 
-          const onFocus = () => maybeConnect()
+          const onOffline = () => {
+            core.setReconnectPauseReason('offline', true)
+          }
+          globalThis.window.addEventListener('offline', onOffline)
+          cleanup.push(() =>
+            globalThis.window?.removeEventListener('offline', onOffline),
+          )
+
+          const onFocus = () => triggerReconnect()
           globalThis.window.addEventListener('focus', onFocus)
           cleanup.push(() =>
             globalThis.window?.removeEventListener('focus', onFocus),
@@ -35,8 +63,10 @@ export const browserConnectivityPlugin = (): ClientPlugin => {
 
         if (globalThis.document) {
           const onVisibilityChange = () => {
-            if (globalThis.document?.visibilityState === 'visible') {
-              maybeConnect()
+            const hidden = globalThis.document?.visibilityState === 'hidden'
+            core.setReconnectPauseReason('tab_hidden', hidden)
+            if (!hidden) {
+              triggerReconnect()
             }
           }
 

package/src/plugins/heartbeat.ts

@@ -40,7 +40,7 @@ export interface HeartbeatPluginOptions {
 export const heartbeatPlugin = (
   options: HeartbeatPluginOptions = {},
 ): ClientPlugin => {
-  return (client) => {
+  return ({ core, ping }) => {
     const interval = options.interval ?? DEFAULT_HEARTBEAT_INTERVAL
     const timeout = options.timeout ?? DEFAULT_HEARTBEAT_TIMEOUT
 
@@ -55,7 +55,7 @@ export const heartbeatPlugin = (
 
     const startHeartbeat = () => {
       if (heartbeatTask) return
-      if (client.transportType !== ConnectionType.Bidirectional) return
+      if (core.transportType !== ConnectionType.Bidirectional) return
 
       heartbeatAbortController = new AbortController()
       const signal = heartbeatAbortController.signal
@@ -63,8 +63,8 @@ export const heartbeatPlugin = (
       heartbeatTask = (async () => {
         while (
           !signal.aborted &&
-          !client.isDisposed() &&
-          client.state === 'connected'
+          !core.isDisposed() &&
+          core.state === 'connected'
         ) {
           if (isPaused()) {
             await sleep(1000, signal)
@@ -75,21 +75,21 @@ export const heartbeatPlugin = (
 
           if (
             signal.aborted ||
-            client.isDisposed() ||
-            client.state !== 'connected'
+            core.isDisposed() ||
+            core.state !== 'connected'
           ) {
             continue
           }
 
           try {
-            await client.ping(timeout, signal)
+            await ping.ping(timeout, signal)
           } catch {
             if (
               !signal.aborted &&
-              !client.isDisposed() &&
-              client.state === 'connected'
+              !core.isDisposed() &&
+              core.state === 'connected'
             ) {
-              await client
+              await core
                 .requestReconnect('heartbeat_timeout')
                 .catch(() => void 0)
             }

package/src/plugins/index.ts

@@ -1,5 +1,12 @@
+export type {
+  ClientPlugin,
+  ClientPluginContext,
+  ClientPluginEvent,
+  ClientPluginInstance,
+  ReconnectConfig,
+  StreamEvent,
+} from './types.ts'
 export * from './browser.ts'
 export * from './heartbeat.ts'
 export * from './logging.ts'
 export * from './reconnect.ts'
-export * from './types.ts'

package/src/plugins/reconnect.ts

@@ -1,44 +1,4 @@
-import { ConnectionType } from '@nmtjs/protocol'
-
-import type { ClientDisconnectReason, ClientPlugin } from './types.ts'
-
-const DEFAULT_RECONNECT_TIMEOUT = 1000
-const DEFAULT_MAX_RECONNECT_TIMEOUT = 60000
-
-const sleep = (ms: number, signal?: AbortSignal) => {
-  return new Promise<void>((resolve) => {
-    if (signal?.aborted) return resolve()
-    const timer = setTimeout(resolve, ms)
-    if (signal) {
-      signal.addEventListener(
-        'abort',
-        () => {
-          clearTimeout(timer)
-          resolve()
-        },
-        { once: true },
-      )
-    }
-  })
-}
-
-const computeReconnectDelay = (ms: number) => {
-  if (globalThis.window) {
-    const jitter = Math.floor(ms * 0.2 * Math.random())
-    return ms + jitter
-  }
-  return ms
-}
-
-const isReconnectPaused = () => {
-  if (globalThis.window && 'navigator' in globalThis.window) {
-    if (globalThis.window.navigator?.onLine === false) return true
-  }
-  if (globalThis.document) {
-    if (globalThis.document.visibilityState === 'hidden') return true
-  }
-  return false
-}
+import type { ClientPlugin } from './types.ts'
 
 export interface ReconnectPluginOptions {
   initialTimeout?: number
@@ -48,83 +8,16 @@ export interface ReconnectPluginOptions {
 export const reconnectPlugin = (
   options: ReconnectPluginOptions = {},
 ): ClientPlugin => {
-  return (client) => {
-    let reconnecting: Promise<void> | null = null
-    let reconnectAbortController: AbortController | null = null
-    let reconnectTimeout = options.initialTimeout ?? DEFAULT_RECONNECT_TIMEOUT
-
-    const cancelReconnect = () => {
-      reconnectAbortController?.abort()
-      reconnectAbortController = null
-      reconnecting = null
-    }
-
-    const ensureReconnectLoop = () => {
-      if (reconnecting) return
-
-      reconnectAbortController = new AbortController()
-      const signal = reconnectAbortController.signal
-
-      reconnecting = (async () => {
-        while (
-          !signal.aborted &&
-          !client.isDisposed() &&
-          client.state === 'disconnected' &&
-          client.lastDisconnectReason !== 'client'
-        ) {
-          if (isReconnectPaused()) {
-            await sleep(1000, signal)
-            continue
-          }
-
-          const delay = computeReconnectDelay(reconnectTimeout)
-          await sleep(delay, signal)
-
-          if (
-            signal.aborted ||
-            client.isDisposed() ||
-            client.state !== 'disconnected' ||
-            client.lastDisconnectReason === 'client'
-          ) {
-            break
-          }
-
-          const previousTimeout = reconnectTimeout
-          await client.connect().catch(() => void 0)
-
-          if (client.state === 'disconnected') {
-            reconnectTimeout = Math.min(
-              previousTimeout * 2,
-              options.maxTimeout ?? DEFAULT_MAX_RECONNECT_TIMEOUT,
-            )
-          }
-        }
-      })().finally(() => {
-        reconnecting = null
-        reconnectAbortController = null
+  return ({ core }) => ({
+    name: 'reconnect',
+    onInit: () => {
+      core.configureReconnect({
+        initialTimeout: options.initialTimeout,
+        maxTimeout: options.maxTimeout,
       })
-    }
-
-    const onDisconnect = (reason: ClientDisconnectReason) => {
-      if (
-        client.transportType !== ConnectionType.Bidirectional ||
-        reason === 'client' ||
-        client.isDisposed()
-      ) {
-        cancelReconnect()
-        return
-      }
-      ensureReconnectLoop()
-    }
-
-    return {
-      name: 'reconnect',
-      onConnect: () => {
-        reconnectTimeout = options.initialTimeout ?? DEFAULT_RECONNECT_TIMEOUT
-        cancelReconnect()
-      },
-      onDisconnect,
-      dispose: cancelReconnect,
-    }
-  }
+    },
+    dispose: () => {
+      core.configureReconnect(null)
+    },
+  })
 }

package/src/plugins/types.ts

@@ -1,8 +1,30 @@
-import type { BaseClient } from '../core.ts'
+import type { ClientCore, ConnectionState } from '../core.ts'
+import type { PingLayerApi } from '../layers/ping.ts'
 
 export type ClientDisconnectReason = 'client' | 'server' | (string & {})
 
+export interface ReconnectConfig {
+  initialTimeout?: number
+  maxTimeout?: number
+}
+
+export type StreamEvent = {
+  direction: 'incoming' | 'outgoing'
+  streamType: 'rpc' | 'client_blob' | 'server_blob'
+  action: 'response' | 'pull' | 'push' | 'end' | 'abort'
+  callId?: number
+  streamId?: number
+  byteLength?: number
+  reason?: string
+}
+
 export type ClientPluginEvent =
+  | {
+      kind: 'state_changed'
+      timestamp: number
+      state: ConnectionState
+      previous: ConnectionState
+    }
   | {
       kind: 'connected'
       timestamp: number
@@ -38,17 +60,7 @@ export type ClientPluginEvent =
       procedure: string
       error: unknown
     }
-  | {
-      kind: 'stream_event'
-      timestamp: number
-      direction: 'incoming' | 'outgoing'
-      streamType: 'rpc' | 'client_blob' | 'server_blob'
-      action: 'response' | 'pull' | 'push' | 'end' | 'abort'
-      callId?: number
-      streamId?: number
-      byteLength?: number
-      reason?: string
-    }
+  | ({ kind: 'stream_event'; timestamp: number } & StreamEvent)
 
 /**
  * Client plugin lifecycle contract.
@@ -67,6 +79,11 @@ export interface ClientPluginInstance {
   dispose?(): void
 }
 
+export interface ClientPluginContext {
+  core: ClientCore
+  ping: PingLayerApi
+}
+
 export type ClientPlugin = (
-  client: BaseClient<any, any, any, any, any>,
+  context: ClientPluginContext,
 ) => ClientPluginInstance