@nmtjs/client 0.15.0-beta.1 → 0.15.0-beta.10

package/src/events.ts

@@ -0,0 +1,70 @@
+import type { Callback } from '@nmtjs/common'
+
+export type EventMap = { [K: string]: any[] }
+
+// TODO: add errors and promise rejections handling
+/**
+ * Thin node-like event emitter wrapper around EventTarget
+ */
+export class EventEmitter<
+  Events extends EventMap = EventMap,
+  EventName extends Extract<keyof Events, string> = Extract<
+    keyof Events,
+    string
+  >,
+> {
+  static once<
+    T extends EventEmitter,
+    E extends T extends EventEmitter<any, infer Event> ? Event : never,
+  >(ee: T, event: E) {
+    return new Promise((resolve) => ee.once(event, resolve))
+  }
+
+  #target = new EventTarget()
+  #listeners = new Map<Callback, Callback>()
+
+  on<E extends EventName>(
+    event: E | (Object & string),
+    listener: (...args: Events[E]) => void,
+    options?: AddEventListenerOptions,
+  ) {
+    const wrapper = (event) => listener(...event.detail)
+    this.#listeners.set(listener, wrapper)
+    this.#target.addEventListener(event, wrapper, { ...options, once: false })
+    return () => this.#target.removeEventListener(event, wrapper)
+  }
+
+  once<E extends EventName>(
+    event: E | (Object & string),
+    listener: (...args: Events[E]) => void,
+    options?: AddEventListenerOptions,
+  ) {
+    return this.on(event, listener, { ...options, once: true })
+  }
+
+  off(event: EventName | (Object & string), listener: Callback) {
+    const wrapper = this.#listeners.get(listener)
+    if (wrapper) this.#target.removeEventListener(event, wrapper)
+  }
+
+  emit<E extends EventName | (Object & string)>(
+    event: E,
+    ...args: E extends EventName ? Events[E] : any[]
+  ) {
+    return this.#target.dispatchEvent(new CustomEvent(event, { detail: args }))
+  }
+}
+
+export const once = <
+  T extends EventEmitter,
+  EventMap extends T extends EventEmitter<infer E, any> ? E : never,
+  EventName extends T extends EventEmitter<any, infer N> ? N : never,
+>(
+  ee: T,
+  event: EventName,
+  signal?: AbortSignal,
+) => {
+  return new Promise<EventMap[EventName]>((resolve) => {
+    ee.once(event, resolve, { signal })
+  })
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './core.ts'
+export * from './events.ts'
+export * from './transformers.ts'
+export * from './transport.ts'
+export * from './types.ts'

package/src/streams.ts

@@ -0,0 +1,131 @@
+import type { ProtocolBlobMetadata } from '@nmtjs/protocol'
+import type { ProtocolServerStreamInterface } from '@nmtjs/protocol/client'
+import { ProtocolClientBlobStream } from '@nmtjs/protocol/client'
+
+export class ClientStreams {
+  readonly #collection = new Map<number, ProtocolClientBlobStream>()
+
+  get size() {
+    return this.#collection.size
+  }
+
+  get(streamId: number) {
+    const stream = this.#collection.get(streamId)
+    if (!stream) throw new Error('Stream not found')
+    return stream
+  }
+
+  add(
+    source: ReadableStream,
+    streamId: number,
+    metadata: ProtocolBlobMetadata,
+  ) {
+    const stream = new ProtocolClientBlobStream(source, streamId, metadata)
+    this.#collection.set(streamId, stream)
+    return stream
+  }
+
+  remove(streamId: number) {
+    this.#collection.delete(streamId)
+  }
+
+  async abort(streamId: number, reason?: string) {
+    const stream = this.#collection.get(streamId)
+    if (!stream) return // Stream already cleaned up
+    await stream.abort(reason)
+    this.remove(streamId)
+  }
+
+  pull(streamId: number, size: number) {
+    const stream = this.get(streamId)
+    return stream.read(size)
+  }
+
+  async end(streamId: number) {
+    await this.get(streamId).end()
+    this.remove(streamId)
+  }
+
+  async clear(reason?: string) {
+    if (reason) {
+      const abortPromises = [...this.#collection.values()].map((stream) =>
+        stream.abort(reason),
+      )
+      await Promise.all(abortPromises)
+    }
+    this.#collection.clear()
+  }
+}
+
+export class ServerStreams<
+  T extends ProtocolServerStreamInterface = ProtocolServerStreamInterface,
+> {
+  readonly #collection = new Map<number, T>()
+  readonly #writers = new Map<number, WritableStreamDefaultWriter>()
+
+  get size() {
+    return this.#collection.size
+  }
+
+  has(streamId: number) {
+    return this.#collection.has(streamId)
+  }
+
+  get(streamId: number) {
+    const stream = this.#collection.get(streamId)
+    if (!stream) throw new Error('Stream not found')
+    return stream
+  }
+
+  add(streamId: number, stream: T) {
+    this.#collection.set(streamId, stream)
+    this.#writers.set(
+      streamId,
+      stream.writable.getWriter() as WritableStreamDefaultWriter,
+    )
+    return stream
+  }
+
+  remove(streamId: number) {
+    this.#collection.delete(streamId)
+    this.#writers.delete(streamId)
+  }
+
+  async abort(streamId: number) {
+    if (this.has(streamId)) {
+      const writer = this.#writers.get(streamId)
+      if (writer) {
+        await writer.abort()
+        writer.releaseLock()
+      }
+      this.remove(streamId)
+    }
+  }
+
+  async push(streamId: number, chunk: ArrayBufferView) {
+    const writer = this.#writers.get(streamId)
+    if (writer) {
+      return await writer.write(chunk)
+    }
+  }
+
+  async end(streamId: number) {
+    const writer = this.#writers.get(streamId)
+    if (writer) {
+      await writer.close()
+      writer.releaseLock()
+    }
+    this.remove(streamId)
+  }
+
+  async clear(reason?: string) {
+    if (reason) {
+      const abortPromises = [...this.#writers.values()].map((writer) =>
+        writer.abort(reason).finally(() => writer.releaseLock()),
+      )
+      await Promise.allSettled(abortPromises)
+    }
+    this.#collection.clear()
+    this.#writers.clear()
+  }
+}

package/src/transformers.ts

@@ -0,0 +1,8 @@
+export class BaseClientTransformer {
+  encode(_procedure: string, payload: any) {
+    return payload
+  }
+  decode(_procedure: string, payload: any) {
+    return payload
+  }
+}

package/src/transport.ts

@@ -0,0 +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 {
+  auth?: string
+  application?: string
+  onMessage: (message: ArrayBufferView) => any
+  onConnect: () => any
+  onDisconnect: (reason: 'client' | 'server' | (string & {})) => any
+}
+
+export interface ClientTransportRpcParams {
+  format: BaseClientFormat
+  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 ClientTransportParams {
+  protocol: ProtocolVersion
+  format: BaseClientFormat
+}
+
+export type ClientTransportFactory<
+  Type extends ConnectionType,
+  Options = unknown,
+  Transport extends ClientTransport<Type> = ClientTransport<Type>,
+> = (params: ClientTransportParams, options: Options) => Transport

package/src/types.ts

@@ -0,0 +1,145 @@
+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,
+  ProtocolServerStreamInterface,
+} 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
+  /**
+   * @internal
+   */
+  _stream_response?: boolean
+}
+
+export type ClientOutputType<T> = T extends ProtocolBlobInterface
+  ? (options?: { signal?: AbortSignal }) => ProtocolServerBlobStream
+  : T extends { [PlainType]?: true }
+    ? { [K in keyof Omit<T, PlainType>]: ClientOutputType<T[K]> }
+    : T
+
+export interface StaticInputContractTypeProvider extends TypeProvider {
+  output: this['input'] extends BaseTypeAny
+    ? t.infer.decode.input<this['input']>
+    : never
+}
+
+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
+}
+
+export interface RuntimeOutputContractTypeProvider extends TypeProvider {
+  output: this['input'] extends BaseTypeAny
+    ? ClientOutputType<t.infer.decodeRaw.output<this['input']>>
+    : never
+}
+
+export type AnyResolvedContractProcedure = {
+  [ResolvedType]: 'procedure'
+  contract: TAnyProcedureContract
+  stream: boolean
+  input: any
+  output: any
+}
+
+export type AnyResolvedContractRouter = {
+  [ResolvedType]: 'router'
+  [key: string]:
+    | AnyResolvedContractProcedure
+    | { [ResolvedType]: 'router'; [key: string]: AnyResolvedContractProcedure }
+}
+
+export type ResolveAPIRouterRoutes<
+  T extends TAnyRouterContract,
+  InputTypeProvider extends TypeProvider = TypeProvider,
+  OutputTypeProvider extends TypeProvider = TypeProvider,
+> = { [ResolvedType]: 'router' } & {
+  [K in keyof T['routes']]: T['routes'][K] extends TAnyProcedureContract
+    ? {
+        [ResolvedType]: 'procedure'
+        contract: T['routes'][K]
+        stream: T['routes'][K]['stream'] extends true ? true : false
+        input: CallTypeProvider<InputTypeProvider, T['routes'][K]['input']>
+        output: T['routes'][K]['stream'] extends true
+          ? AsyncIterable<
+              CallTypeProvider<OutputTypeProvider, T['routes'][K]['output']>
+            >
+          : CallTypeProvider<OutputTypeProvider, T['routes'][K]['output']>
+      }
+    : 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<[{ result: Procedure['output'] }, { error: ProtocolError }]>>
+  : Promise<Procedure['output']>
+
+type OmitType<T extends object, E> = {
+  [K in keyof T as T[K] extends E ? never : K]: T[K]
+}
+
+// export type FilterResolvedContractRouter<
+//   Resolved extends AnyResolvedContractRouter,
+//   Stream extends boolean,
+// > = {
+//   [K in keyof Resolved]: Resolved[K] extends AnyResolvedContractProcedure
+//     ? Resolved[K]['stream'] extends Stream
+//       ? Resolved[K]
+//       : never
+//     : Resolved[K] extends AnyResolvedContractRouter
+//       ? FilterResolvedContractRouter<Resolved[K], Stream>
+//       : never
+// }
+
+export type ClientCallers<
+  Resolved extends AnyResolvedContractRouter,
+  SafeCall extends boolean,
+  Stream extends boolean,
+> = OmitType<
+  {
+    [K in keyof Resolved]: Resolved[K] extends AnyResolvedContractProcedure
+      ? Stream extends (Resolved[K]['stream'] extends true ? true : false)
+        ? ClientCaller<Resolved[K], SafeCall>
+        : never
+      : Resolved[K] extends AnyResolvedContractRouter
+        ? ClientCallers<Resolved[K], SafeCall, Stream>
+        : never
+  },
+  never
+>