@nmtjs/client 0.15.3 → 0.16.0-beta.1

package/src/transport.ts

@@ -5,59 +5,84 @@ import type {
 } from '@nmtjs/protocol'
 import type { BaseClientFormat } from '@nmtjs/protocol/client'
 
-export type ClientTransportMessageOptions = {
-  signal?: AbortSignal
-  _stream_response?: boolean
-}
+export type ClientDisconnectReason = 'client' | 'server' | (string & {})
 
-export interface ClientTransportStartParams {
+export interface TransportConnectParams {
   auth?: string
   application?: string
-  onMessage: (message: ArrayBufferView) => any
-  onConnect: () => any
-  onDisconnect: (reason: 'client' | 'server' | (string & {})) => any
+  onMessage: (message: ArrayBufferView) => void
+  onConnect: () => void
+  onDisconnect: (reason: ClientDisconnectReason) => void
 }
 
-export interface ClientTransportRpcParams {
-  format: BaseClientFormat
+export interface TransportSendOptions {
+  signal?: AbortSignal
+}
+
+export interface TransportCallContext {
+  contentType: string
   auth?: string
   application?: string
 }
 
-export type ClientCallResponse =
-  | { type: 'rpc'; result: ArrayBufferView }
-  | { type: 'rpc_stream'; stream: ReadableStream<ArrayBufferView> }
-  | {
-      type: 'blob'
-      metadata: ProtocolBlobMetadata
-      source: ReadableStream<ArrayBufferView>
-    }
-
-export type ClientTransport<T extends ConnectionType = ConnectionType> =
-  T extends ConnectionType.Bidirectional
-    ? {
-        type: ConnectionType.Bidirectional
-        connect(params: ClientTransportStartParams): Promise<void>
-        disconnect(): Promise<void>
-        send(
-          message: ArrayBufferView,
-          options: ClientTransportMessageOptions,
-        ): Promise<void>
-      }
-    : {
-        type: ConnectionType.Unidirectional
-        connect?(params: ClientTransportStartParams): Promise<void>
-        disconnect?(): Promise<void>
-        call(
-          client: {
-            format: BaseClientFormat
-            auth?: string
-            application?: string
-          },
-          rpc: { callId: number; procedure: string; payload: any },
-          options: ClientTransportMessageOptions,
-        ): Promise<ClientCallResponse>
-      }
+export interface TransportRpcParams {
+  callId: number
+  procedure: string
+  payload: ArrayBufferView
+  blob?: { source: ReadableStream; metadata: ProtocolBlobMetadata }
+}
+
+export interface TransportCallOptions {
+  signal?: AbortSignal
+  streamResponse?: boolean
+}
+
+export interface TransportRpcResponse {
+  type: 'rpc'
+  result: ArrayBufferView
+}
+
+export interface TransportRpcStreamResponse {
+  type: 'rpc_stream'
+  stream: ReadableStream<ArrayBufferView>
+}
+
+export interface TransportBlobResponse {
+  type: 'blob'
+  metadata: ProtocolBlobMetadata
+  source: ReadableStream<ArrayBufferView>
+}
+
+export interface TransportErrorResponse {
+  type: 'error'
+  error: ArrayBufferView
+  status?: number
+  statusText?: string
+}
+
+export type TransportCallResponse =
+  | TransportRpcResponse
+  | TransportRpcStreamResponse
+  | TransportBlobResponse
+  | TransportErrorResponse
+
+export interface BidirectionalTransport {
+  type: ConnectionType.Bidirectional
+  connect(params: TransportConnectParams): Promise<void>
+  disconnect(): Promise<void>
+  send(message: ArrayBufferView, options: TransportSendOptions): Promise<void>
+}
+
+export interface UnidirectionalTransport {
+  type: ConnectionType.Unidirectional
+  call(
+    context: TransportCallContext,
+    rpc: TransportRpcParams,
+    options: TransportCallOptions,
+  ): Promise<TransportCallResponse>
+}
+
+export type ClientTransport = BidirectionalTransport | UnidirectionalTransport
 
 export interface ClientTransportParams {
   protocol: ProtocolVersion
@@ -65,7 +90,11 @@ export interface ClientTransportParams {
 }
 
 export type ClientTransportFactory<
-  Type extends ConnectionType,
+  Transport extends ClientTransport = ClientTransport,
   Options = unknown,
-  Transport extends ClientTransport<Type> = ClientTransport<Type>,
 > = (params: ClientTransportParams, options: Options) => Transport
+
+export type ClientTransportMessageOptions = TransportSendOptions
+export type ClientTransportStartParams = TransportConnectParams
+export type ClientTransportRpcParams = TransportCallContext
+export type ClientCallResponse = TransportCallResponse

package/src/types.ts

@@ -3,24 +3,30 @@ import type { TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract'
 import type { ProtocolBlobInterface } from '@nmtjs/protocol'
 import type {
   ProtocolError,
-  ProtocolServerBlobStream,
+  ProtocolServerBlobConsumer,
 } from '@nmtjs/protocol/client'
 import type { BaseTypeAny, PlainType, t } from '@nmtjs/type'
 
 export const ResolvedType: unique symbol = Symbol('ResolvedType')
 export type ResolvedType = typeof ResolvedType
 
-export type ClientCallOptions = {
-  timeout?: number
-  signal?: AbortSignal
+export type RpcCallOptions = { timeout?: number; signal?: AbortSignal }
+
+export type StreamCallOptions = RpcCallOptions & { autoReconnect?: boolean }
+
+export type ClientCallOptions = StreamCallOptions & {
   /**
    * @internal
    */
   _stream_response?: boolean
 }
 
+export type BlobSubscriptionOptions = { signal?: AbortSignal }
+
+export type StreamSubscriptionOptions = Partial<StreamCallOptions>
+
 export type ClientOutputType<T> = T extends ProtocolBlobInterface
-  ? (options?: { signal?: AbortSignal }) => ProtocolServerBlobStream
+  ? ProtocolServerBlobConsumer
   : T extends { [PlainType]?: true }
     ? { [K in keyof Omit<T, PlainType>]: ClientOutputType<T[K]> }
     : T
@@ -99,10 +105,29 @@ export type ClientCaller<
   SafeCall extends boolean,
 > = (
   ...args: Procedure['input'] extends t.NeverType
-    ? [data?: undefined, options?: Partial<ClientCallOptions>]
+    ? [
+        data?: undefined,
+        options?: Partial<
+          Procedure['stream'] extends true ? StreamCallOptions : RpcCallOptions
+        >,
+      ]
     : undefined extends t.infer.encode.input<Procedure['contract']['input']>
-      ? [data?: Procedure['input'], options?: Partial<ClientCallOptions>]
-      : [data: Procedure['input'], options?: Partial<ClientCallOptions>]
+      ? [
+          data?: Procedure['input'],
+          options?: Partial<
+            Procedure['stream'] extends true
+              ? StreamCallOptions
+              : RpcCallOptions
+          >,
+        ]
+      : [
+          data: Procedure['input'],
+          options?: Partial<
+            Procedure['stream'] extends true
+              ? StreamCallOptions
+              : RpcCallOptions
+          >,
+        ]
 ) => SafeCall extends true
   ? Promise<OneOf<[{ result: Procedure['output'] }, { error: ProtocolError }]>>
   : Promise<Procedure['output']>