@nmtjs/client 0.14.5 → 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
+>

package/dist/common.d.ts

@@ -1,38 +0,0 @@
-import type { TypeProvider } from '@nmtjs/common';
-import type { TAnyAPIContract } from '@nmtjs/contract';
-import type { ProtocolBaseClientCallOptions, ProtocolBaseTransformer, ProtocolTransport } from '@nmtjs/protocol/client';
-import { ProtocolError } from '@nmtjs/protocol/client';
-import type { ClientCallers, ResolveAPIRouterRoutes } from './types.ts';
-export { ErrorCode, ProtocolBlob, type ProtocolBlobMetadata, TransportType, } from '@nmtjs/protocol';
-export * from './types.ts';
-export declare class ClientError extends ProtocolError {
-}
-export interface BaseClientOptions<SafeCall extends boolean = false> {
-    timeout: number;
-    autoreconnect?: boolean;
-    safe?: SafeCall;
-}
-export declare abstract class BaseClient<APIContract extends TAnyAPIContract = TAnyAPIContract, SafeCall extends boolean = false, InputTypeProvider extends TypeProvider = TypeProvider, OutputTypeProvider extends TypeProvider = TypeProvider, Routes extends {
-    contract: APIContract['router'];
-    routes: ResolveAPIRouterRoutes<APIContract['router'], InputTypeProvider, OutputTypeProvider>;
-} = {
-    contract: APIContract['router'];
-    routes: ResolveAPIRouterRoutes<APIContract['router'], InputTypeProvider, OutputTypeProvider>;
-}> {
-    readonly transport: ProtocolTransport;
-    readonly options: BaseClientOptions<SafeCall>;
-    _: {
-        api: Routes;
-        safe: SafeCall;
-    };
-    protected abstract transformer: ProtocolBaseTransformer;
-    protected callers: ClientCallers<Routes, SafeCall>;
-    auth: any;
-    protected reconnectTimeout: number;
-    constructor(transport: ProtocolTransport, options: BaseClientOptions<SafeCall>);
-    protected _call(procedure: string, payload: any, options: ProtocolBaseClientCallOptions): Promise<any>;
-    get call(): ClientCallers<Routes, SafeCall>;
-    setAuth(auth: any): void;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-}

package/dist/common.js

@@ -1,60 +0,0 @@
-import { noopFn } from '@nmtjs/common';
-import { ProtocolError } from '@nmtjs/protocol/client';
-export { ErrorCode, ProtocolBlob, TransportType, } from '@nmtjs/protocol';
-export * from "./types.js";
-export class ClientError extends ProtocolError {
-}
-const DEFAULT_RECONNECT_TIMEOUT = 1000;
-export class BaseClient {
-    transport;
-    options;
-    _;
-    callers;
-    auth;
-    reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
-    constructor(transport, options) {
-        this.transport = transport;
-        this.options = options;
-        if (this.options.autoreconnect) {
-            this.transport.on('disconnected', async (reason) => {
-                if (reason === 'server') {
-                    this.connect();
-                }
-                else if (reason === 'error') {
-                    const timeout = new Promise((resolve) => setTimeout(resolve, this.reconnectTimeout));
-                    const connected = new Promise((_, reject) => this.transport.once('connected', reject));
-                    this.reconnectTimeout += DEFAULT_RECONNECT_TIMEOUT;
-                    await Promise.race([timeout, connected]).then(this.connect.bind(this), noopFn);
-                }
-            });
-            this.transport.on('connected', () => {
-                this.reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
-            });
-        }
-    }
-    async _call(procedure, payload, options) {
-        const call = await this.transport.call(procedure, payload, options, this.transformer);
-        if (this.options.safe) {
-            return await call.promise
-                .then((result) => ({ result }))
-                .catch((error) => ({ error }));
-        }
-        else {
-            return await call.promise.catch((error) => {
-                throw error;
-            });
-        }
-    }
-    get call() {
-        return this.callers;
-    }
-    setAuth(auth) {
-        this.auth = auth;
-    }
-    connect() {
-        return this.transport.connect(this.auth, this.transformer);
-    }
-    disconnect() {
-        return this.transport.disconnect();
-    }
-}

package/dist/runtime.d.ts

@@ -1,21 +0,0 @@
-import type { TAnyAPIContract, TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract';
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import type { RuntimeInputContractTypeProvider, RuntimeOutputContractTypeProvider } from './common.ts';
-import { BaseClient } from './common.ts';
-export declare class RuntimeContractTransformer extends ProtocolBaseTransformer {
-    protected procedures: Map<string, TAnyProcedureContract>;
-    constructor(procedures: Map<string, TAnyProcedureContract>);
-    decodeRPC(procedure: string, payload: any): any;
-    decodeRPCChunk(procedure: string, payload: any): unknown;
-    encodeRPC(procedure: string, payload: any): unknown;
-    protected getProcedureContract(procedure: string): TAnyProcedureContract;
-    protected build(router: TAnyRouterContract): void;
-}
-export declare class RuntimeClient<APIContract extends TAnyAPIContract, SafeCall extends boolean = false> extends BaseClient<APIContract, SafeCall, RuntimeInputContractTypeProvider, RuntimeOutputContractTypeProvider> {
-    contract: APIContract;
-    protected transformer: RuntimeContractTransformer;
-    protected procedures: Map<string, TAnyProcedureContract>;
-    constructor(contract: APIContract, ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>);
-    protected resolveProcedures(router: TAnyRouterContract): void;
-    protected buildCallers(): any;
-}

package/dist/runtime.js

@@ -1,105 +0,0 @@
-import { IsProcedureContract, IsRouterContract } from '@nmtjs/contract';
-import { ErrorCode } from '@nmtjs/protocol';
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import { NeemataTypeError, t } from '@nmtjs/type';
-import { BaseClient, ClientError } from "./common.js";
-export class RuntimeContractTransformer extends ProtocolBaseTransformer {
-    procedures;
-    constructor(procedures) {
-        super();
-        this.procedures = procedures;
-    }
-    decodeRPC(procedure, payload) {
-        const contract = this.getProcedureContract(procedure);
-        const type = contract.output;
-        if (type instanceof t.NeverType)
-            return undefined;
-        return payload;
-    }
-    decodeRPCChunk(procedure, payload) {
-        const contract = this.getProcedureContract(procedure);
-        const type = contract.stream;
-        if (!type || type instanceof t.NeverType)
-            return undefined;
-        return type.decode(payload);
-    }
-    encodeRPC(procedure, payload) {
-        const contract = this.getProcedureContract(procedure);
-        const type = contract.input;
-        if (type instanceof t.NeverType)
-            return undefined;
-        try {
-            return type.encode(payload);
-        }
-        catch (error) {
-            if (error instanceof NeemataTypeError) {
-                throw new ClientError(ErrorCode.ValidationError, `Invalid payload for ${procedure}: ${error.message}`, error.issues);
-            }
-            throw error;
-        }
-    }
-    getProcedureContract(procedure) {
-        const proc = this.procedures.get(procedure);
-        if (!proc) {
-            throw new ClientError(ErrorCode.NotFound, `Procedure contract not found for procedure: ${procedure}`);
-        }
-        return proc;
-    }
-    build(router) {
-        const routes = Object.values(router.routes);
-        for (const route of routes) {
-            if (IsRouterContract(route)) {
-                this.build(route);
-            }
-            else if (IsProcedureContract(route)) {
-                this.procedures.set(route.name, route);
-            }
-        }
-    }
-}
-export class RuntimeClient extends BaseClient {
-    contract;
-    transformer;
-    procedures = new Map();
-    constructor(contract, ...args) {
-        super(...args);
-        this.contract = contract;
-        this.resolveProcedures(this.contract.router);
-        this.transformer = new RuntimeContractTransformer(this.procedures);
-        this.callers = this.buildCallers();
-    }
-    resolveProcedures(router) {
-        const routes = Object.values(router.routes);
-        for (const route of routes) {
-            if (IsRouterContract(route)) {
-                this.resolveProcedures(route);
-            }
-            else if (IsProcedureContract(route)) {
-                this.procedures.set(route.name, route);
-            }
-        }
-    }
-    buildCallers() {
-        const callers = Object.create(null);
-        for (const [name, procedure] 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, options = {}) => this._call(name, payload, {
-                        timeout: procedure.timeout || options.timeout || this.options.timeout,
-                        ...options,
-                    });
-                }
-                else {
-                    if (!current[part]) {
-                        current[part] = {};
-                    }
-                    current = current[part];
-                }
-            }
-        }
-        return callers;
-    }
-}

package/dist/static.d.ts

@@ -1,9 +0,0 @@
-import type { TAnyAPIContract } from '@nmtjs/contract';
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import type { StaticInputContractTypeProvider, StaticOutputContractTypeProvider } from './common.ts';
-import { BaseClient } from './common.ts';
-export declare class StaticClient<APIContract extends TAnyAPIContract, SafeCall extends boolean = false> extends BaseClient<APIContract, SafeCall, StaticInputContractTypeProvider, StaticOutputContractTypeProvider> {
-    protected transformer: ProtocolBaseTransformer;
-    constructor(...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>);
-    protected createProxy(target: any, path?: string[]): any;
-}