@nmtjs/client 0.5.3 → 0.6.0

package/lib/client.ts

@@ -1,140 +0,0 @@
-import { type BaseClientFormat, ErrorCode } from '@nmtjs/common'
-
-import type { TServiceContract } from '@nmtjs/contract'
-import { ClientError } from './common.ts'
-import type { ClientTransport } from './transport.ts'
-import type { ClientCallOptions } from './types.ts'
-import * as utils from './utils.ts'
-
-export type ClientOptions = {
-  defaultTimeout: number
-  debug?: boolean
-}
-
-export type ClientServices = Record<string, TServiceContract>
-
-export abstract class Client extends utils.EventEmitter {
-  protected transport!: ClientTransport
-  protected format!: BaseClientFormat
-
-  auth?: string
-
-  private ids = {
-    call: 0,
-    stream: 0,
-  }
-
-  constructor(
-    protected readonly options: ClientOptions,
-    protected services: string[],
-  ) {
-    super()
-    if (!options.defaultTimeout) options.defaultTimeout = 15000
-  }
-
-  useTransport<T extends new (...args: any[]) => ClientTransport>(
-    transportClass: T,
-    ...options: ConstructorParameters<T>
-  ) {
-    this.transport = new transportClass(...options)
-    this.transport.client = Object.freeze({
-      services: this.services,
-      format: this.format,
-      auth: this.auth,
-    })
-    this.checkTransport(this.transport)
-    return this as Omit<this, 'useTransport'>
-  }
-
-  useFormat(format: BaseClientFormat) {
-    this.format = format
-    return this as Omit<this, 'useFormat'>
-  }
-
-  async connect() {
-    await this.transport.connect()
-  }
-
-  async disconnect() {
-    await this.transport.disconnect()
-  }
-
-  async reconnect() {
-    await this.disconnect()
-    await this.connect()
-  }
-
-  protected checkTransport(transport: ClientTransport) {}
-
-  protected createCaller(
-    service: string,
-    procedure: string,
-    {
-      timeout = this.options.defaultTimeout,
-      transformInput,
-      transformOutput,
-    }: {
-      timeout?: number
-      transformInput?: (input: any) => any
-      transformOutput?: (output: any) => any
-    } = {},
-  ) {
-    return async (payload: any, options: ClientCallOptions = {}) => {
-      const { signal } = options
-
-      const abortSignal = signal
-        ? AbortSignal.any([signal, AbortSignal.timeout(timeout)])
-        : AbortSignal.timeout(timeout)
-
-      const callId = ++this.ids.call
-
-      if (this.options.debug) {
-        console.groupCollapsed(`RPC [${callId}] ${service}/${procedure}`)
-        console.log(payload)
-        console.groupEnd()
-      }
-
-      const callExecution = this.transport
-        .rpc({
-          callId,
-          service,
-          procedure,
-          payload: transformInput ? transformInput(payload) : payload,
-          signal: abortSignal,
-        })
-        .then((result) => {
-          if (result.success) return result.value
-          throw new ClientError(
-            result.error.code,
-            result.error.message,
-            result.error.data,
-          )
-        })
-
-      const callTimeout = utils.forAborted(abortSignal).catch(() => {
-        const error = new ClientError(ErrorCode.RequestTimeout)
-        return Promise.reject(error)
-      })
-
-      try {
-        const response = await Promise.race([callTimeout, callExecution])
-
-        if (this.options.debug) {
-          console.groupCollapsed(`RPC [${callId}] Success`)
-          console.log(response)
-          console.groupEnd()
-        }
-
-        return transformOutput ? transformOutput(response) : response
-      } catch (error) {
-        if (this.options.debug) {
-          console.groupCollapsed(`RPC [${callId}] Error`)
-          console.log(error)
-          console.groupEnd()
-        }
-
-        throw error
-      }
-    }
-  }
-}

package/lib/stream.ts

@@ -1,72 +0,0 @@
-import type { ApiBlob, ApiBlobMetadata } from '@nmtjs/common'
-import type { AnyFn } from './utils.ts'
-
-export class ClientUpStream {
-  readonly reader: ReadableStreamBYOBReader
-
-  constructor(
-    readonly id: number,
-    readonly blob: ApiBlob,
-  ) {
-    if (this.blob.source instanceof ReadableStream === false)
-      throw new Error('Blob source is not a ReadableStream')
-    this.reader = this.blob.source.getReader({ mode: 'byob' })
-  }
-}
-
-export type ClientDownStreamBlob = {
-  readonly metadata: ApiBlobMetadata
-  readonly stream: ReadableStream<Uint8Array>
-}
-
-export type ClientDownStreamWrapper = {
-  writer: WritableStreamDefaultWriter
-  blob: ClientDownStreamBlob
-}
-
-export const createClientDownStream = (
-  metadata: ApiBlobMetadata,
-  pull: AnyFn,
-): ClientDownStreamWrapper => {
-  let bytes = 0
-
-  const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>(
-    {
-      start: () => pull,
-      transform(chunk, controller) {
-        if (metadata.size !== -1) {
-          bytes += chunk.byteLength
-          if (bytes > metadata.size) {
-            const error = new Error('Stream size exceeded')
-            controller.error(error)
-          } else {
-            try {
-              controller.enqueue(chunk)
-            } catch (error) {
-              console.error(error)
-            }
-          }
-        } else {
-          controller.enqueue(chunk)
-        }
-      },
-    },
-    { highWaterMark: 1 },
-  )
-
-  const writer = writable.getWriter()
-
-  const blob: ClientDownStreamBlob = {
-    get metadata() {
-      return metadata
-    },
-    get stream() {
-      return readable
-    },
-  }
-
-  return {
-    blob,
-    writer,
-  }
-}

package/lib/subscription.ts

@@ -1,12 +0,0 @@
-import { EventEmitter, type EventMap } from './utils.ts'
-
-export class Subscription<
-  Events extends EventMap = EventMap,
-> extends EventEmitter<Events> {
-  constructor(
-    readonly key: string,
-    readonly unsubscribe: () => void,
-  ) {
-    super()
-  }
-}

package/lib/transport.ts

@@ -1,40 +0,0 @@
-import type { BaseClientFormat } from '@nmtjs/common'
-import { EventEmitter, type EventMap } from './utils.ts'
-
-export type ClientTransportRpcCall = {
-  service: string
-  procedure: string
-  callId: number
-  payload: any
-  signal: AbortSignal
-}
-
-export type ClientTransportRpcResult =
-  | {
-      success: false
-      error: { code: string; message?: string; data?: any }
-    }
-  | {
-      success: true
-      value: any
-    }
-
-export abstract class ClientTransport<
-  T extends EventMap = EventMap,
-> extends EventEmitter<
-  T & { event: [service: string, event: string, payload: any] }
-> {
-  abstract type: string
-
-  client!: {
-    readonly services: string[]
-    readonly format: BaseClientFormat
-    readonly auth?: string
-  }
-
-  abstract connect(): Promise<void>
-  abstract disconnect(): Promise<void>
-  abstract rpc(
-    params: ClientTransportRpcCall,
-  ): Promise<ClientTransportRpcResult>
-}

package/lib/utils.ts

@@ -1,65 +0,0 @@
-export type AnyFn = (...args: any[]) => any
-
-export type EventMap = { [K: string]: any[] }
-
-export function forAborted(signal: AbortSignal) {
-  return new Promise((_, reject) => {
-    const handler = () => reject(new Error('aborted'))
-    const options = { once: true }
-    signal.addEventListener('abort', handler, options)
-  })
-}
-
-export function onAbort(signal: AbortSignal, listener: () => void) {
-  signal.addEventListener('abort', listener, { once: true })
-  return () => signal.removeEventListener('abort', listener)
-}
-
-/**
- * Very simple node-like event emitter wrapper around EventTarget
- *
- * @todo add errors and promise rejections handling
- */
-export class EventEmitter<
-  Events extends EventMap = EventMap,
-  EventNames extends Extract<keyof Events, string> = Extract<
-    keyof Events,
-    string
-  >,
-> {
-  #target = new EventTarget()
-  #listeners = new Map<AnyFn, AnyFn>()
-
-  on<E extends EventNames>(
-    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)
-    return () => this.#target.removeEventListener(event, wrapper)
-  }
-
-  once<E extends EventNames>(
-    event: E | (Object & string),
-    listener: (...args: Events[E]) => void,
-  ) {
-    return this.on(event, listener, { once: true })
-  }
-
-  off(event: EventNames | (Object & string), listener: AnyFn) {
-    const wrapper = this.#listeners.get(listener)
-    if (wrapper) this.#target.removeEventListener(event, wrapper)
-  }
-
-  emit<E extends EventNames | (Object & string)>(
-    event: E,
-    ...args: E extends EventEmitter ? Events[E] : any[]
-  ) {
-    return this.#target.dispatchEvent(new CustomEvent(event, { detail: args }))
-  }
-}
-
-export const once = (ee: EventEmitter, event: string) =>
-  new Promise((resolve) => ee.once(event, resolve))