@nmtjs/client 0.15.3 → 0.16.0-beta.10

package/dist/transport.d.ts

@@ -1,53 +1,71 @@
 import type { ConnectionType, ProtocolBlobMetadata, ProtocolVersion } from '@nmtjs/protocol';
 import type { BaseClientFormat } from '@nmtjs/protocol/client';
-export type ClientTransportMessageOptions = {
-    signal?: AbortSignal;
-    _stream_response?: boolean;
-};
-export interface ClientTransportStartParams {
+export type ClientDisconnectReason = 'client' | 'server' | (string & {});
+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 = {
+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 type ClientTransport<T extends ConnectionType = ConnectionType> = T extends ConnectionType.Bidirectional ? {
+}
+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: ClientTransportStartParams): Promise<void>;
+    connect(params: TransportConnectParams): Promise<void>;
     disconnect(): Promise<void>;
-    send(message: ArrayBufferView, options: ClientTransportMessageOptions): Promise<void>;
-} : {
+    send(message: ArrayBufferView, options: TransportSendOptions): Promise<void>;
+}
+export interface UnidirectionalTransport {
     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>;
-};
+    call(context: TransportCallContext, rpc: TransportRpcParams, options: TransportCallOptions): Promise<TransportCallResponse>;
+}
+export type ClientTransport = BidirectionalTransport | UnidirectionalTransport;
 export interface ClientTransportParams {
     protocol: ProtocolVersion;
     format: BaseClientFormat;
 }
-export type ClientTransportFactory<Type extends ConnectionType, Options = unknown, Transport extends ClientTransport<Type> = ClientTransport<Type>> = (params: ClientTransportParams, options: Options) => Transport;
+export type ClientTransportFactory<Transport extends ClientTransport = ClientTransport, Options = unknown> = (params: ClientTransportParams, options: Options) => Transport;
+export type ClientTransportMessageOptions = TransportSendOptions;
+export type ClientTransportStartParams = TransportConnectParams;
+export type ClientTransportRpcParams = TransportCallContext;
+export type ClientCallResponse = TransportCallResponse;

package/dist/types.d.ts

@@ -1,25 +1,26 @@
 import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common';
 import type { TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract';
-import type { ProtocolBlobInterface } from '@nmtjs/protocol';
-import type { ProtocolError, ProtocolServerBlobStream } from '@nmtjs/protocol/client';
-import type { BaseTypeAny, PlainType, t } from '@nmtjs/type';
+import type { ProtocolError } from '@nmtjs/protocol/client';
+import type { BaseTypeAny, t } from '@nmtjs/type';
 export declare const ResolvedType: unique symbol;
 export type ResolvedType = typeof ResolvedType;
-export type ClientCallOptions = {
+export type RpcCallOptions = {
     timeout?: number;
     signal?: AbortSignal;
+};
+export type StreamCallOptions = RpcCallOptions & {
+    autoReconnect?: boolean;
+};
+export type ClientCallOptions = StreamCallOptions & {
     /**
      * @internal
      */
     _stream_response?: boolean;
 };
-export type ClientOutputType<T> = T extends ProtocolBlobInterface ? (options?: {
+export type BlobSubscriptionOptions = {
     signal?: AbortSignal;
-}) => ProtocolServerBlobStream : T extends {
-    [PlainType]?: true;
-} ? {
-    [K in keyof Omit<T, PlainType>]: ClientOutputType<T[K]>;
-} : T;
+};
+export type StreamSubscriptionOptions = Partial<StreamCallOptions>;
 export interface StaticInputContractTypeProvider extends TypeProvider {
     output: this['input'] extends BaseTypeAny ? t.infer.decode.input<this['input']> : never;
 }
@@ -27,10 +28,10 @@ export interface RuntimeInputContractTypeProvider extends TypeProvider {
     output: this['input'] extends BaseTypeAny ? t.infer.encode.input<this['input']> : never;
 }
 export interface StaticOutputContractTypeProvider extends TypeProvider {
-    output: this['input'] extends BaseTypeAny ? ClientOutputType<t.infer.encodeRaw.output<this['input']>> : never;
+    output: this['input'] extends BaseTypeAny ? t.infer.encode.output<this['input']> : never;
 }
 export interface RuntimeOutputContractTypeProvider extends TypeProvider {
-    output: this['input'] extends BaseTypeAny ? ClientOutputType<t.infer.decodeRaw.output<this['input']>> : never;
+    output: this['input'] extends BaseTypeAny ? t.infer.decode.output<this['input']> : never;
 }
 export type AnyResolvedContractProcedure = {
     [ResolvedType]: 'procedure';
@@ -55,7 +56,16 @@ export type ResolveAPIRouterRoutes<T extends TAnyRouterContract, InputTypeProvid
     } : T['routes'][K] extends TAnyRouterContract ? ResolveAPIRouterRoutes<T['routes'][K], InputTypeProvider, OutputTypeProvider> : never;
 };
 export type ResolveContract<C extends TAnyRouterContract = TAnyRouterContract, InputTypeProvider extends TypeProvider = TypeProvider, OutputTypeProvider extends TypeProvider = TypeProvider> = ResolveAPIRouterRoutes<C, InputTypeProvider, OutputTypeProvider>;
-export type ClientCaller<Procedure extends AnyResolvedContractProcedure, SafeCall extends boolean> = (...args: Procedure['input'] extends t.NeverType ? [data?: undefined, options?: Partial<ClientCallOptions>] : undefined extends t.infer.encode.input<Procedure['contract']['input']> ? [data?: Procedure['input'], options?: Partial<ClientCallOptions>] : [data: Procedure['input'], options?: Partial<ClientCallOptions>]) => SafeCall extends true ? Promise<OneOf<[{
+export type ClientCaller<Procedure extends AnyResolvedContractProcedure, SafeCall extends boolean> = (...args: Procedure['input'] extends t.NeverType ? [
+    data?: undefined,
+    options?: Partial<Procedure['stream'] extends true ? StreamCallOptions : RpcCallOptions>
+] : undefined extends t.infer.encode.input<Procedure['contract']['input']> ? [
+    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;

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AASA,MAAM,CAAC,MAAM,YAAY,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAA"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAKA,MAAM,CAAC,MAAM,YAAY,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAA"}

package/package.json

@@ -20,17 +20,16 @@
     }
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.15.3",
-    "@nmtjs/contract": "0.15.3",
-    "@nmtjs/protocol": "0.15.3",
-    "@nmtjs/common": "0.15.3"
+    "@nmtjs/type": "0.16.0-beta.10",
+    "@nmtjs/common": "0.16.0-beta.10",
+    "@nmtjs/contract": "0.16.0-beta.10",
+    "@nmtjs/protocol": "0.16.0-beta.10"
   },
   "devDependencies": {
-    "@nmtjs/tests-integration": "0.15.3",
-    "@nmtjs/type": "0.15.3",
-    "@nmtjs/contract": "0.15.3",
-    "@nmtjs/common": "0.15.3",
-    "@nmtjs/protocol": "0.15.3"
+    "@nmtjs/contract": "0.16.0-beta.10",
+    "@nmtjs/type": "0.16.0-beta.10",
+    "@nmtjs/protocol": "0.16.0-beta.10",
+    "@nmtjs/common": "0.16.0-beta.10"
   },
   "files": [
     "dist",
@@ -38,7 +37,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.3",
+  "version": "0.16.0-beta.10",
   "scripts": {
     "clean-build": "rm -rf ./dist"
   }

package/src/client.ts

@@ -0,0 +1,232 @@
+import type { TypeProvider } from '@nmtjs/common'
+import type { TAnyRouterContract } from '@nmtjs/contract'
+import type {
+  ProtocolBlobInterface,
+  ProtocolBlobMetadata,
+  ProtocolVersion,
+} from '@nmtjs/protocol'
+import type {
+  BaseClientFormat,
+  ProtocolServerBlobStream,
+} from '@nmtjs/protocol/client'
+import { noopFn } from '@nmtjs/common'
+import { ProtocolBlob } from '@nmtjs/protocol'
+
+import type { ClientCoreOptions, ConnectionState } from './core.ts'
+import type { PingLayerApi } from './layers/ping.ts'
+import type { RpcLayerApi } from './layers/rpc.ts'
+import type { StreamLayerApi } from './layers/streams.ts'
+import type { ClientPlugin } from './plugins/types.ts'
+import type { BaseClientTransformer } from './transformers.ts'
+import type { ClientTransportFactory } from './transport.ts'
+import type {
+  AnyResolvedContractRouter,
+  ClientCallers,
+  ResolveAPIRouterRoutes,
+} from './types.ts'
+import { ClientCore } from './core.ts'
+import { createPingLayer } from './layers/ping.ts'
+import { createRpcLayer } from './layers/rpc.ts'
+import { createStreamLayer } from './layers/streams.ts'
+
+export interface ClientOptions<
+  RouterContract extends TAnyRouterContract = TAnyRouterContract,
+  SafeCall extends boolean = false,
+> {
+  contract: RouterContract
+  protocol: ProtocolVersion
+  format: BaseClientFormat
+  application?: string
+  autoConnect?: boolean
+  timeout?: number
+  plugins?: ClientPlugin[]
+  safe?: SafeCall
+}
+
+export type BaseClientOptions<
+  RouterContract extends TAnyRouterContract = TAnyRouterContract,
+  SafeCall extends boolean = false,
+> = ClientOptions<RouterContract, SafeCall>
+
+export interface ClientCallersFactory<
+  Routes extends AnyResolvedContractRouter,
+  SafeCall extends boolean,
+> {
+  call: ClientCallers<Routes, SafeCall, false>
+  stream: ClientCallers<Routes, SafeCall, true>
+}
+
+type ClientRoutes<
+  RouterContract extends TAnyRouterContract,
+  InputTypeProvider extends TypeProvider,
+  OutputTypeProvider extends TypeProvider,
+> = ResolveAPIRouterRoutes<
+  RouterContract,
+  InputTypeProvider,
+  OutputTypeProvider
+>
+
+export class Client<
+  TransportFactory extends ClientTransportFactory<
+    any,
+    any
+  > = ClientTransportFactory<any, any>,
+  RouterContract extends TAnyRouterContract = TAnyRouterContract,
+  SafeCall extends boolean = false,
+  InputTypeProvider extends TypeProvider = TypeProvider,
+  OutputTypeProvider extends TypeProvider = TypeProvider,
+> {
+  _!: {
+    routes: ResolveAPIRouterRoutes<
+      RouterContract,
+      InputTypeProvider,
+      OutputTypeProvider
+    >
+    safe: SafeCall
+  }
+
+  readonly core: ClientCore
+  protected readonly rpcLayer: RpcLayerApi
+  protected readonly streamLayer: StreamLayerApi
+  protected readonly pingLayer: PingLayerApi
+  protected readonly transformer: BaseClientTransformer
+
+  readonly call: ClientCallers<
+    ClientRoutes<RouterContract, InputTypeProvider, OutputTypeProvider>,
+    SafeCall,
+    false
+  >
+  readonly stream: ClientCallers<
+    ClientRoutes<RouterContract, InputTypeProvider, OutputTypeProvider>,
+    SafeCall,
+    true
+  >
+
+  readonly on: ClientCore['on']
+  readonly once: ClientCore['once']
+  readonly off: ClientCore['off']
+
+  constructor(
+    readonly options: ClientOptions<RouterContract, SafeCall>,
+    readonly transportFactory: TransportFactory,
+    readonly transportOptions: TransportFactory extends ClientTransportFactory<
+      any,
+      infer Options
+    >
+      ? Options
+      : never,
+    transformer: BaseClientTransformer,
+    buildCallers: (rpc: RpcLayerApi) => { call: unknown; stream: unknown },
+  ) {
+    this.transformer = transformer
+
+    const transport = this.transportFactory(
+      { protocol: this.options.protocol, format: this.options.format },
+      this.transportOptions,
+    )
+
+    const coreOptions: ClientCoreOptions = {
+      protocol: this.options.protocol,
+      format: this.options.format,
+      application: this.options.application,
+      autoConnect: this.options.autoConnect,
+    }
+
+    this.core = new ClientCore(coreOptions, transport)
+    this.streamLayer = createStreamLayer(this.core)
+    this.rpcLayer = createRpcLayer(this.core, this.streamLayer, transformer, {
+      timeout: this.options.timeout,
+      safe: this.options.safe,
+    })
+    this.pingLayer = createPingLayer(this.core)
+
+    this.core.setMessageContextFactory(() => ({
+      encoder: this.core.format,
+      decoder: this.core.format,
+      transport: {
+        send: (buffer) => {
+          this.core.send(buffer).catch(noopFn)
+        },
+      },
+      streamId: () => this.streamLayer.getStreamId(),
+      addClientStream: (blob) => this.streamLayer.addClientStream(blob),
+      addServerStream: (streamId, metadata) =>
+        this.streamLayer.createServerBlob(streamId, metadata),
+    }))
+
+    this.core.initPlugins(this.options.plugins, {
+      core: this.core,
+      ping: this.pingLayer,
+    })
+
+    const callers = buildCallers(this.rpcLayer)
+    this.call = callers.call as ClientCallers<
+      ClientRoutes<RouterContract, InputTypeProvider, OutputTypeProvider>,
+      SafeCall,
+      false
+    >
+    this.stream = callers.stream as ClientCallers<
+      ClientRoutes<RouterContract, InputTypeProvider, OutputTypeProvider>,
+      SafeCall,
+      true
+    >
+
+    this.on = this.core.on.bind(this.core)
+    this.once = this.core.once.bind(this.core)
+    this.off = this.core.off.bind(this.core)
+  }
+
+  get state(): ConnectionState {
+    return this.core.state
+  }
+
+  get transportType() {
+    return this.core.transportType
+  }
+
+  get lastDisconnectReason() {
+    return this.core.lastDisconnectReason
+  }
+
+  get auth() {
+    return this.core.auth
+  }
+
+  set auth(value: any) {
+    this.core.auth = value
+  }
+
+  isDisposed() {
+    return this.core.isDisposed()
+  }
+
+  connect() {
+    return this.core.connect()
+  }
+
+  disconnect() {
+    return this.core.disconnect()
+  }
+
+  ping(timeout: number, signal?: AbortSignal) {
+    return this.pingLayer.ping(timeout, signal)
+  }
+
+  createBlob(
+    source: Blob | ReadableStream | string | AsyncIterable<Uint8Array>,
+    metadata?: ProtocolBlobMetadata,
+  ) {
+    return ProtocolBlob.from(source, metadata)
+  }
+
+  consumeBlob(
+    blob: ProtocolBlobInterface,
+    options?: { signal?: AbortSignal },
+  ): ProtocolServerBlobStream {
+    return this.streamLayer.consumeServerBlob(blob, options)
+  }
+
+  dispose() {
+    this.core.dispose()
+  }
+}

package/src/clients/runtime.ts

@@ -5,44 +5,111 @@ import type {
 } from '@nmtjs/contract'
 import { IsProcedureContract, IsRouterContract } from '@nmtjs/contract'
 
-import type { BaseClientOptions } from '../core.ts'
+import type { BaseClientOptions } from '../client.ts'
+import type { RpcLayerApi } from '../layers/rpc.ts'
 import type { ClientTransportFactory } from '../transport.ts'
 import type {
-  ClientCallers,
   ClientCallOptions,
   RuntimeInputContractTypeProvider,
   RuntimeOutputContractTypeProvider,
 } from '../types.ts'
-import { BaseClient } from '../core.ts'
+import { Client } from '../client.ts'
 
 export class RuntimeContractTransformer {
   #procedures = new Map<string, TAnyProcedureContract>()
 
   constructor(router: TAnyRouterContract) {
-    const registerProcedures = (r: TRouteContract, path: string[] = []) => {
-      if (IsRouterContract(r)) {
-        for (const [key, route] of Object.entries(r.routes)) {
-          registerProcedures(route, [...path, key])
+    const registerProcedures = (route: TRouteContract, path: string[] = []) => {
+      if (IsRouterContract(route)) {
+        for (const [key, child] of Object.entries(route.routes)) {
+          registerProcedures(child, [...path, key])
         }
-      } else if (IsProcedureContract(r)) {
-        const fullName = [...path].join('/')
-        this.#procedures.set(fullName, r)
+        return
+      }
+
+      if (IsProcedureContract(route)) {
+        this.#procedures.set(path.join('/'), route)
       }
     }
+
     registerProcedures(router)
   }
 
-  encode(_procedure: string, payload: any) {
-    const procedure = this.#procedures.get(_procedure)
-    if (!procedure) throw new Error(`Procedure not found: ${_procedure}`)
-    return procedure.input.encode(payload)
+  encode(procedure: string, payload: any) {
+    const contract = this.#procedures.get(procedure)
+    if (!contract) throw new Error(`Procedure not found: ${procedure}`)
+    return contract.input.encode(payload)
+  }
+
+  decode(procedure: string, payload: any) {
+    const contract = this.#procedures.get(procedure)
+    if (!contract) throw new Error(`Procedure not found: ${procedure}`)
+    return contract.output.decode(payload)
   }
+}
+
+const assignNested = (
+  root: Record<string, any>,
+  name: string,
+  value: unknown,
+) => {
+  const parts = name.split('/')
+  let current = root
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i]
+    if (i === parts.length - 1) {
+      current[part] = value
+    } else {
+      current[part] = current[part] ?? Object.create(null)
+      current = current[part]
+    }
+  }
+}
+
+const buildRuntimeCallers = (
+  rpc: RpcLayerApi,
+  contract: TAnyRouterContract,
+) => {
+  const procedures = new Map<string, TAnyProcedureContract>()
+
+  const resolveProcedures = (
+    router: TAnyRouterContract,
+    path: string[] = [],
+  ) => {
+    for (const [key, route] of Object.entries(router.routes)) {
+      if (IsRouterContract(route)) {
+        resolveProcedures(route, [...path, key])
+      } else if (IsProcedureContract(route)) {
+        procedures.set([...path, key].join('/'), route)
+      }
+    }
+  }
+
+  resolveProcedures(contract)
+
+  const callers: Record<string, any> = Object.create(null)
+  const streams: Record<string, any> = Object.create(null)
+
+  for (const [name, procedure] of procedures) {
+    const invoke = (
+      payload?: unknown,
+      options?: Partial<ClientCallOptions>,
+    ) => {
+      return rpc.call(name, payload, {
+        ...options,
+        _stream_response: !!procedure.stream,
+      })
+    }
 
-  decode(_procedure: string, payload: any) {
-    const procedure = this.#procedures.get(_procedure)
-    if (!procedure) throw new Error(`Procedure not found: ${_procedure}`)
-    return procedure.output.decode(payload)
+    if (procedure.stream) {
+      assignNested(streams, name, invoke)
+    } else {
+      assignNested(callers, name, invoke)
+    }
   }
+
+  return { call: callers, stream: streams }
 }
 
 export class RuntimeClient<
@@ -52,18 +119,13 @@ export class RuntimeClient<
   >,
   RouterContract extends TAnyRouterContract = TAnyRouterContract,
   SafeCall extends boolean = false,
-> extends BaseClient<
+> extends Client<
   Transport,
   RouterContract,
   SafeCall,
   RuntimeInputContractTypeProvider,
   RuntimeOutputContractTypeProvider
 > {
-  protected readonly transformer: RuntimeContractTransformer
-
-  readonly #procedures = new Map<string, TAnyProcedureContract>()
-  readonly #callers!: ClientCallers<this['_']['routes'], SafeCall, boolean>
-
   constructor(
     options: BaseClientOptions<RouterContract, SafeCall>,
     transport: Transport,
@@ -74,60 +136,12 @@ export class RuntimeClient<
       ? Options
       : never,
   ) {
-    super(options, transport, transportOptions)
-
-    this.resolveProcedures(this.options.contract)
-    this.transformer = new RuntimeContractTransformer(this.options.contract)
-    this.#callers = this.buildCallers()
-  }
-
-  override get call(): ClientCallers<this['_']['routes'], SafeCall, false> {
-    return this.#callers as any
-  }
-
-  override get stream(): ClientCallers<this['_']['routes'], SafeCall, true> {
-    return this.#callers as any
-  }
-
-  protected resolveProcedures(router: TAnyRouterContract, path: string[] = []) {
-    for (const [key, route] of Object.entries(router.routes)) {
-      if (IsRouterContract(route)) {
-        this.resolveProcedures(route, [...path, key])
-      } else if (IsProcedureContract(route)) {
-        const fullName = [...path, key].join('/')
-        this.#procedures.set(fullName, route)
-      }
-    }
-  }
-
-  protected buildCallers(): ClientCallers<
-    this['_']['routes'],
-    SafeCall,
-    boolean
-  > {
-    const callers: Record<string, any> = Object.create(null)
-
-    for (const [name, { stream }] of this.#procedures) {
-      const parts = name.split('/')
-      let current = callers
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i]
-        if (i === parts.length - 1) {
-          current[part] = (
-            payload?: unknown,
-            options?: Partial<ClientCallOptions>,
-          ) =>
-            this._call(name, payload, {
-              ...options,
-              _stream_response: !!stream,
-            })
-        } else {
-          current[part] = current[part] ?? Object.create(null)
-          current = current[part]
-        }
-      }
-    }
-
-    return callers as ClientCallers<this['_']['routes'], SafeCall, boolean>
+    super(
+      options,
+      transport,
+      transportOptions,
+      new RuntimeContractTransformer(options.contract),
+      (rpc) => buildRuntimeCallers(rpc, options.contract),
+    )
   }
 }