@nmtjs/client 0.15.3 → 0.16.0-beta.2

package/dist/types.d.ts

@@ -1,21 +1,28 @@
 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 { ProtocolError, ProtocolServerBlobConsumer } from '@nmtjs/protocol/client';
 import type { BaseTypeAny, PlainType, 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 {
+};
+export type StreamSubscriptionOptions = Partial<StreamCallOptions>;
+export type ClientOutputType<T> = T extends ProtocolBlobInterface ? ProtocolServerBlobConsumer : T extends {
     [PlainType]?: true;
 } ? {
     [K in keyof Omit<T, PlainType>]: ClientOutputType<T[K]>;
@@ -55,7 +62,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/package.json

@@ -20,17 +20,17 @@
     }
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.15.3",
-    "@nmtjs/contract": "0.15.3",
-    "@nmtjs/protocol": "0.15.3",
-    "@nmtjs/common": "0.15.3"
+    "@nmtjs/contract": "0.16.0-beta.2",
+    "@nmtjs/type": "0.16.0-beta.2",
+    "@nmtjs/common": "0.16.0-beta.2",
+    "@nmtjs/protocol": "0.16.0-beta.2"
   },
   "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/tests-integration": "0.16.0-beta.2",
+    "@nmtjs/type": "0.16.0-beta.2",
+    "@nmtjs/contract": "0.16.0-beta.2",
+    "@nmtjs/common": "0.16.0-beta.2",
+    "@nmtjs/protocol": "0.16.0-beta.2"
   },
   "files": [
     "dist",
@@ -38,7 +38,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.3",
+  "version": "0.16.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist"
   }

package/src/client.ts

@@ -0,0 +1,218 @@
+import type { TypeProvider } from '@nmtjs/common'
+import type { TAnyRouterContract } from '@nmtjs/contract'
+import type { ProtocolBlobMetadata, ProtocolVersion } from '@nmtjs/protocol'
+import type { BaseClientFormat } 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.createServerBlobStream(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)
+  }
+
+  blob(
+    source: Blob | ReadableStream | string | AsyncIterable<Uint8Array>,
+    metadata?: ProtocolBlobMetadata,
+  ) {
+    return ProtocolBlob.from(source, metadata)
+  }
+
+  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),
+    )
   }
 }

package/src/clients/static.ts

@@ -1,16 +1,48 @@
 import type { TAnyRouterContract } 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,
   StaticInputContractTypeProvider,
   StaticOutputContractTypeProvider,
 } from '../types.ts'
-import { BaseClient } from '../core.ts'
+import { Client } from '../client.ts'
 import { BaseClientTransformer } from '../transformers.ts'
 
+const buildStaticCallers = (
+  rpc: RpcLayerApi,
+  isStream: boolean,
+  path: string[] = [],
+): Record<string, unknown> => {
+  const createProxy = <T>(
+    target: Record<string, unknown>,
+    current: string[],
+  ) => {
+    return new Proxy(target, {
+      get: (obj, prop) => {
+        if (prop === 'then') return obj
+
+        const nextPath = [...current, String(prop)]
+        const caller = (
+          payload?: unknown,
+          options?: Partial<ClientCallOptions>,
+        ) => {
+          return rpc.call(nextPath.join('/'), payload, {
+            ...options,
+            _stream_response: isStream || options?._stream_response,
+          })
+        }
+
+        return createProxy(caller as any, nextPath)
+      },
+    }) as T
+  }
+
+  return createProxy(Object.create(null), path)
+}
+
 export class StaticClient<
   Transport extends ClientTransportFactory<any, any> = ClientTransportFactory<
     any,
@@ -18,15 +50,13 @@ export class StaticClient<
   >,
   RouterContract extends TAnyRouterContract = TAnyRouterContract,
   SafeCall extends boolean = false,
-> extends BaseClient<
+> extends Client<
   Transport,
   RouterContract,
   SafeCall,
   StaticInputContractTypeProvider,
   StaticOutputContractTypeProvider
 > {
-  protected readonly transformer: BaseClientTransformer
-
   constructor(
     options: BaseClientOptions<RouterContract, SafeCall>,
     transport: Transport,
@@ -37,37 +67,15 @@ export class StaticClient<
       ? Options
       : never,
   ) {
-    super(options, transport, transportOptions)
-    this.transformer = new BaseClientTransformer()
-  }
-
-  override get call(): ClientCallers<this['_']['routes'], SafeCall, false> {
-    return this.createProxy(Object.create(null), false)
-  }
-
-  override get stream(): ClientCallers<this['_']['routes'], SafeCall, true> {
-    return this.createProxy(Object.create(null), true)
-  }
-
-  protected createProxy<T>(
-    target: Record<string, unknown>,
-    isStream: boolean,
-    path: string[] = [],
-  ) {
-    return new Proxy(target, {
-      get: (obj, prop) => {
-        if (prop === 'then') return obj
-        const newPath = [...path, String(prop)]
-        const caller = (
-          payload?: unknown,
-          options?: Partial<ClientCallOptions>,
-        ) =>
-          this._call(newPath.join('/'), payload, {
-            ...options,
-            _stream_response: isStream || options?._stream_response,
-          })
-        return this.createProxy(caller as any, isStream, newPath)
-      },
-    }) as T
+    super(
+      options,
+      transport,
+      transportOptions,
+      new BaseClientTransformer(),
+      (rpc) => ({
+        call: buildStaticCallers(rpc, false),
+        stream: buildStaticCallers(rpc, true),
+      }),
+    )
   }
 }