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

package/dist/clients/runtime.js

@@ -0,0 +1,80 @@
+import { IsProcedureContract, IsRouterContract } from '@nmtjs/contract';
+import { BaseClient } from "../core.js";
+export class RuntimeContractTransformer {
+    #procedures = new Map();
+    constructor(router) {
+        const registerProcedures = (r, path = []) => {
+            if (IsRouterContract(r)) {
+                for (const [key, route] of Object.entries(r.routes)) {
+                    registerProcedures(route, [...path, key]);
+                }
+            }
+            else if (IsProcedureContract(r)) {
+                const fullName = [...path].join('/');
+                this.#procedures.set(fullName, r);
+            }
+        };
+        registerProcedures(router);
+    }
+    encode(_procedure, payload) {
+        const procedure = this.#procedures.get(_procedure);
+        if (!procedure)
+            throw new Error(`Procedure not found: ${_procedure}`);
+        return procedure.input.encode(payload);
+    }
+    decode(_procedure, payload) {
+        const procedure = this.#procedures.get(_procedure);
+        if (!procedure)
+            throw new Error(`Procedure not found: ${_procedure}`);
+        return procedure.output.decode(payload);
+    }
+}
+export class RuntimeClient extends BaseClient {
+    transformer;
+    #procedures = new Map();
+    #callers;
+    constructor(options, transport, transportOptions) {
+        super(options, transport, transportOptions);
+        this.resolveProcedures(this.options.contract);
+        this.transformer = new RuntimeContractTransformer(this.options.contract);
+        this.#callers = this.buildCallers();
+    }
+    get call() {
+        return this.#callers;
+    }
+    get stream() {
+        return this.#callers;
+    }
+    resolveProcedures(router, path = []) {
+        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);
+            }
+        }
+    }
+    buildCallers() {
+        const callers = 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, options) => this._call(name, payload, {
+                        ...options,
+                        _stream_response: !!stream,
+                    });
+                }
+                else {
+                    current[part] = current[part] ?? Object.create(null);
+                    current = current[part];
+                }
+            }
+        }
+        return callers;
+    }
+}

package/dist/clients/static.js

@@ -0,0 +1,26 @@
+import { BaseClient } from "../core.js";
+import { BaseClientTransformer } from "../transformers.js";
+export class StaticClient extends BaseClient {
+    transformer;
+    constructor(options, transport, transportOptions) {
+        super(options, transport, transportOptions);
+        this.transformer = new BaseClientTransformer();
+    }
+    get call() {
+        return this.createProxy(Object.create(null), false);
+    }
+    get stream() {
+        return this.createProxy(Object.create(null), true);
+    }
+    createProxy(target, isStream, path = []) {
+        return new Proxy(target, {
+            get: (obj, prop) => {
+                if (prop === 'then')
+                    return obj;
+                const newPath = [...path, String(prop)];
+                const caller = (payload, options) => this._call(newPath.join('/'), payload, options);
+                return this.createProxy(caller, isStream, newPath);
+            },
+        });
+    }
+}

package/dist/core.js

@@ -0,0 +1,410 @@
+import { anyAbortSignal, createFuture, MAX_UINT32, noopFn } from '@nmtjs/common';
+import { ClientMessageType, ConnectionType, ErrorCode, ProtocolBlob, ServerMessageType, } from '@nmtjs/protocol';
+import { ProtocolError, ProtocolServerBlobStream, ProtocolServerRPCStream, ProtocolServerStream, versions, } from '@nmtjs/protocol/client';
+import { EventEmitter } from "./events.js";
+import { ClientStreams, ServerStreams } from "./streams.js";
+export { ErrorCode, ProtocolBlob, } from '@nmtjs/protocol';
+export * from "./types.js";
+export class ClientError extends ProtocolError {
+}
+const DEFAULT_RECONNECT_TIMEOUT = 1000;
+const DEFAULT_MAX_RECONNECT_TIMEOUT = 60000;
+/**
+ * @todo Add error logging in ClientStreamPull rejection handler for easier debugging
+ * @todo Consider edge case where callId/streamId overflow at MAX_UINT32 with existing entries
+ */
+export class BaseClient extends EventEmitter {
+    options;
+    transportFactory;
+    transportOptions;
+    _;
+    calls = new Map();
+    transport;
+    protocol;
+    messageContext;
+    clientStreams = new ClientStreams();
+    serverStreams = new ServerStreams();
+    rpcStreams = new ServerStreams();
+    callId = 0;
+    streamId = 0;
+    cab = null;
+    reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
+    #auth;
+    constructor(options, transportFactory, transportOptions) {
+        super();
+        this.options = options;
+        this.transportFactory = transportFactory;
+        this.transportOptions = transportOptions;
+        this.protocol = versions[options.protocol];
+        const { format, protocol } = this.options;
+        this.transport = this.transportFactory({ protocol, format }, this.transportOptions);
+        if (this.transport.type === ConnectionType.Bidirectional &&
+            this.options.autoreconnect) {
+            this.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.once('connected', reject));
+                    this.reconnectTimeout = Math.min(this.reconnectTimeout * 2, DEFAULT_MAX_RECONNECT_TIMEOUT);
+                    await Promise.race([timeout, connected]).then(this.connect.bind(this), noopFn);
+                }
+            });
+            this.on('connected', () => {
+                this.reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
+            });
+            if (globalThis.window) {
+                globalThis.window.addEventListener('pageshow', () => {
+                    if (!this.cab)
+                        this.connect();
+                });
+            }
+        }
+    }
+    get auth() {
+        return this.#auth;
+    }
+    set auth(value) {
+        this.#auth = value;
+    }
+    async connect() {
+        if (this.transport.type === ConnectionType.Bidirectional) {
+            this.cab = new AbortController();
+            const protocol = this.protocol;
+            const serverStreams = this.serverStreams;
+            const transport = {
+                send: (buffer) => {
+                    this.#send(buffer).catch(noopFn);
+                },
+            };
+            this.messageContext = {
+                transport,
+                encoder: this.options.format,
+                decoder: this.options.format,
+                addClientStream: (blob) => {
+                    const streamId = this.#getStreamId();
+                    return this.clientStreams.add(blob.source, streamId, blob.metadata);
+                },
+                addServerStream(streamId, metadata) {
+                    const stream = new ProtocolServerBlobStream(metadata, {
+                        pull: (controller) => {
+                            transport.send(protocol.encodeMessage(this, ClientMessageType.ServerStreamPull, { streamId, size: 65535 /* 64kb by default */ }));
+                        },
+                        close: () => {
+                            serverStreams.remove(streamId);
+                        },
+                        readableStrategy: { highWaterMark: 0 },
+                    });
+                    serverStreams.add(streamId, stream);
+                    return ({ signal } = {}) => {
+                        if (signal)
+                            signal.addEventListener('abort', () => {
+                                transport.send(protocol.encodeMessage(this, ClientMessageType.ServerStreamAbort, { streamId }));
+                                serverStreams.abort(streamId);
+                            }, { once: true });
+                        return stream;
+                    };
+                },
+                streamId: this.#getStreamId.bind(this),
+            };
+            return this.transport.connect({
+                auth: this.auth,
+                application: this.options.application,
+                onMessage: this.onMessage.bind(this),
+                onConnect: this.onConnect.bind(this),
+                onDisconnect: this.onDisconnect.bind(this),
+            });
+        }
+    }
+    async disconnect() {
+        if (this.transport.type === ConnectionType.Bidirectional) {
+            this.cab.abort();
+            await this.transport.disconnect();
+            this.messageContext = null;
+            this.cab = null;
+        }
+    }
+    blob(source, metadata) {
+        return ProtocolBlob.from(source, metadata);
+    }
+    async _call(procedure, payload, options = {}) {
+        const timeout = options.timeout ?? this.options.timeout;
+        const controller = new AbortController();
+        // attach all abort signals
+        const signals = [controller.signal];
+        if (timeout)
+            signals.push(AbortSignal.timeout(timeout));
+        if (options.signal)
+            signals.push(options.signal);
+        if (this.cab?.signal)
+            signals.push(this.cab.signal);
+        const signal = signals.length ? anyAbortSignal(...signals) : undefined;
+        const callId = this.#getCallId();
+        const call = createFuture();
+        call.procedure = procedure;
+        call.signal = signal;
+        this.calls.set(callId, call);
+        // Check if signal is already aborted before proceeding
+        if (signal?.aborted) {
+            this.calls.delete(callId);
+            const error = new ProtocolError(ErrorCode.ClientRequestError, signal.reason);
+            call.reject(error);
+        }
+        else {
+            if (signal) {
+                signal.addEventListener('abort', () => {
+                    call.reject(new ProtocolError(ErrorCode.ClientRequestError, signal.reason));
+                    if (this.transport.type === ConnectionType.Bidirectional &&
+                        this.messageContext) {
+                        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcAbort, { callId });
+                        this.#send(buffer).catch(noopFn);
+                    }
+                }, { once: true });
+            }
+            try {
+                const transformedPayload = this.transformer.encode(procedure, payload);
+                if (this.transport.type === ConnectionType.Bidirectional) {
+                    const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.Rpc, { callId, procedure, payload: transformedPayload });
+                    await this.#send(buffer, signal);
+                }
+                else {
+                    const response = await this.transport.call({
+                        application: this.options.application,
+                        format: this.options.format,
+                        auth: this.auth,
+                    }, { callId, procedure, payload: transformedPayload }, { signal, _stream_response: options._stream_response });
+                    this.#handleCallResponse(callId, response);
+                }
+            }
+            catch (error) {
+                call.reject(error);
+            }
+        }
+        const result = call.promise.then((value) => {
+            if (value instanceof ProtocolServerRPCStream) {
+                return value.createAsyncIterable(() => {
+                    controller.abort();
+                });
+            }
+            controller.abort();
+            return value;
+        }, (err) => {
+            controller.abort();
+            throw err;
+        });
+        if (this.options.safe) {
+            return await result
+                .then((result) => ({ result }))
+                .catch((error) => ({ error }))
+                .finally(() => {
+                this.calls.delete(callId);
+            });
+        }
+        else {
+            return await result.finally(() => {
+                this.calls.delete(callId);
+            });
+        }
+    }
+    async onConnect() {
+        this.emit('connected');
+    }
+    async onDisconnect(reason) {
+        this.emit('disconnected', reason);
+        this.clientStreams.clear(reason);
+        this.serverStreams.clear(reason);
+        this.rpcStreams.clear(reason);
+    }
+    async onMessage(buffer) {
+        if (!this.messageContext)
+            return;
+        const message = this.protocol.decodeMessage(this.messageContext, buffer);
+        switch (message.type) {
+            case ServerMessageType.RpcResponse:
+                this.#handleRPCResponseMessage(message);
+                break;
+            case ServerMessageType.RpcStreamResponse:
+                this.#handleRPCStreamResponseMessage(message);
+                break;
+            case ServerMessageType.RpcStreamChunk:
+                this.rpcStreams.push(message.callId, message.chunk);
+                break;
+            case ServerMessageType.RpcStreamEnd:
+                this.rpcStreams.end(message.callId);
+                this.calls.delete(message.callId);
+                break;
+            case ServerMessageType.RpcStreamAbort:
+                this.rpcStreams.abort(message.callId);
+                this.calls.delete(message.callId);
+                break;
+            case ServerMessageType.ServerStreamPush:
+                this.serverStreams.push(message.streamId, message.chunk);
+                break;
+            case ServerMessageType.ServerStreamEnd:
+                this.serverStreams.end(message.streamId);
+                break;
+            case ServerMessageType.ServerStreamAbort:
+                this.serverStreams.abort(message.streamId);
+                break;
+            case ServerMessageType.ClientStreamPull:
+                this.clientStreams.pull(message.streamId, message.size).then((chunk) => {
+                    if (chunk) {
+                        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamPush, { streamId: message.streamId, chunk });
+                        this.#send(buffer).catch(noopFn);
+                    }
+                    else {
+                        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamEnd, { streamId: message.streamId });
+                        this.#send(buffer).catch(noopFn);
+                        this.clientStreams.end(message.streamId);
+                    }
+                }, () => {
+                    const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.ClientStreamAbort, { streamId: message.streamId });
+                    this.#send(buffer).catch(noopFn);
+                    this.clientStreams.remove(message.streamId);
+                });
+                break;
+            case ServerMessageType.ClientStreamAbort:
+                this.clientStreams.abort(message.streamId);
+                break;
+        }
+    }
+    #handleRPCResponseMessage(message) {
+        const { callId, result, error } = message;
+        const call = this.calls.get(callId);
+        if (!call)
+            return;
+        if (error) {
+            call.reject(new ProtocolError(error.code, error.message, error.data));
+        }
+        else {
+            try {
+                const transformed = this.transformer.decode(call.procedure, result);
+                call.resolve(transformed);
+            }
+            catch (error) {
+                call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
+            }
+        }
+    }
+    #handleRPCStreamResponseMessage(message) {
+        const call = this.calls.get(message.callId);
+        if (message.error) {
+            if (!call)
+                return;
+            call.reject(new ProtocolError(message.error.code, message.error.message, message.error.data));
+        }
+        else {
+            if (call) {
+                const { procedure, signal } = call;
+                const stream = new ProtocolServerRPCStream({
+                    start: (controller) => {
+                        if (signal) {
+                            if (signal.aborted)
+                                controller.error(signal.reason);
+                            else
+                                signal.addEventListener('abort', () => {
+                                    controller.error(signal.reason);
+                                    if (this.rpcStreams.has(message.callId)) {
+                                        this.rpcStreams.remove(message.callId);
+                                        this.calls.delete(message.callId);
+                                        if (this.messageContext) {
+                                            const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcAbort, { callId: message.callId, reason: signal.reason });
+                                            this.#send(buffer).catch(noopFn);
+                                        }
+                                    }
+                                }, { once: true });
+                        }
+                    },
+                    transform: (chunk) => {
+                        return this.transformer.decode(procedure, this.options.format.decode(chunk));
+                    },
+                    pull: () => {
+                        const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcPull, { callId: message.callId });
+                        this.#send(buffer).catch(noopFn);
+                    },
+                    readableStrategy: { highWaterMark: 0 },
+                });
+                this.rpcStreams.add(message.callId, stream);
+                call.resolve(stream);
+            }
+            else {
+                // Call not found, but stream response received
+                // This can happen if the call was aborted or timed out
+                // Need to send an abort for the stream to avoid resource leaks from server side
+                if (this.messageContext) {
+                    const buffer = this.protocol.encodeMessage(this.messageContext, ClientMessageType.RpcAbort, { callId: message.callId });
+                    this.#send(buffer).catch(noopFn);
+                }
+            }
+        }
+    }
+    #handleCallResponse(callId, response) {
+        const call = this.calls.get(callId);
+        if (response.type === 'rpc_stream') {
+            if (call) {
+                const stream = new ProtocolServerStream({
+                    transform: (chunk) => {
+                        return this.transformer.decode(call.procedure, this.options.format.decode(chunk));
+                    },
+                });
+                this.rpcStreams.add(callId, stream);
+                call.resolve(({ signal }) => {
+                    response.stream.pipeTo(stream.writable, { signal }).catch(noopFn);
+                    return stream;
+                });
+            }
+            else {
+                // Call not found, but stream response received
+                // This can happen if the call was aborted or timed out
+                // Need to cancel the stream to avoid resource leaks from server side
+                response.stream.cancel().catch(noopFn);
+            }
+        }
+        else if (response.type === 'blob') {
+            if (call) {
+                const { metadata, source } = response;
+                const stream = new ProtocolServerBlobStream(metadata);
+                this.serverStreams.add(this.#getStreamId(), stream);
+                call.resolve(({ signal }) => {
+                    source.pipeTo(stream.writable, { signal }).catch(noopFn);
+                    return stream;
+                });
+            }
+            else {
+                // Call not found, but blob response received
+                // This can happen if the call was aborted or timed out
+                // Need to cancel the stream to avoid resource leaks from server side
+                response.source.cancel().catch(noopFn);
+            }
+        }
+        else if (response.type === 'rpc') {
+            if (!call)
+                return;
+            try {
+                const transformed = this.transformer.decode(call.procedure, response.result);
+                call.resolve(transformed);
+            }
+            catch (error) {
+                call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
+            }
+        }
+    }
+    #send(buffer, signal) {
+        if (this.transport.type === ConnectionType.Unidirectional)
+            throw new Error('Invalid transport type for send');
+        return this.transport.send(buffer, { signal });
+    }
+    #getStreamId() {
+        if (this.streamId >= MAX_UINT32) {
+            this.streamId = 0;
+        }
+        return this.streamId++;
+    }
+    #getCallId() {
+        if (this.callId >= MAX_UINT32) {
+            this.callId = 0;
+        }
+        return this.callId++;
+    }
+}

package/dist/events.js

@@ -0,0 +1,33 @@
+// TODO: add errors and promise rejections handling
+/**
+ * Thin node-like event emitter wrapper around EventTarget
+ */
+export class EventEmitter {
+    static once(ee, event) {
+        return new Promise((resolve) => ee.once(event, resolve));
+    }
+    #target = new EventTarget();
+    #listeners = new Map();
+    on(event, listener, options) {
+        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(event, listener, options) {
+        return this.on(event, listener, { ...options, once: true });
+    }
+    off(event, listener) {
+        const wrapper = this.#listeners.get(listener);
+        if (wrapper)
+            this.#target.removeEventListener(event, wrapper);
+    }
+    emit(event, ...args) {
+        return this.#target.dispatchEvent(new CustomEvent(event, { detail: args }));
+    }
+}
+export const once = (ee, event, signal) => {
+    return new Promise((resolve) => {
+        ee.once(event, resolve, { signal });
+    });
+};

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./core.js";
+export * from "./events.js";
+export * from "./transformers.js";
+export * from "./transport.js";
+export * from "./types.js";

package/dist/streams.js

@@ -0,0 +1,100 @@
+import { ProtocolClientBlobStream } from '@nmtjs/protocol/client';
+export class ClientStreams {
+    #collection = new Map();
+    get size() {
+        return this.#collection.size;
+    }
+    get(streamId) {
+        const stream = this.#collection.get(streamId);
+        if (!stream)
+            throw new Error('Stream not found');
+        return stream;
+    }
+    add(source, streamId, metadata) {
+        const stream = new ProtocolClientBlobStream(source, streamId, metadata);
+        this.#collection.set(streamId, stream);
+        return stream;
+    }
+    remove(streamId) {
+        this.#collection.delete(streamId);
+    }
+    async abort(streamId, reason) {
+        const stream = this.#collection.get(streamId);
+        if (!stream)
+            return; // Stream already cleaned up
+        await stream.abort(reason);
+        this.remove(streamId);
+    }
+    pull(streamId, size) {
+        const stream = this.get(streamId);
+        return stream.read(size);
+    }
+    async end(streamId) {
+        await this.get(streamId).end();
+        this.remove(streamId);
+    }
+    async clear(reason) {
+        if (reason) {
+            const abortPromises = [...this.#collection.values()].map((stream) => stream.abort(reason));
+            await Promise.all(abortPromises);
+        }
+        this.#collection.clear();
+    }
+}
+export class ServerStreams {
+    #collection = new Map();
+    #writers = new Map();
+    get size() {
+        return this.#collection.size;
+    }
+    has(streamId) {
+        return this.#collection.has(streamId);
+    }
+    get(streamId) {
+        const stream = this.#collection.get(streamId);
+        if (!stream)
+            throw new Error('Stream not found');
+        return stream;
+    }
+    add(streamId, stream) {
+        this.#collection.set(streamId, stream);
+        this.#writers.set(streamId, stream.writable.getWriter());
+        return stream;
+    }
+    remove(streamId) {
+        this.#collection.delete(streamId);
+        this.#writers.delete(streamId);
+    }
+    async abort(streamId) {
+        if (this.has(streamId)) {
+            const writer = this.#writers.get(streamId);
+            if (writer) {
+                await writer.abort();
+                writer.releaseLock();
+            }
+            this.remove(streamId);
+        }
+    }
+    async push(streamId, chunk) {
+        const writer = this.#writers.get(streamId);
+        if (writer) {
+            return await writer.write(chunk);
+        }
+    }
+    async end(streamId) {
+        const writer = this.#writers.get(streamId);
+        if (writer) {
+            await writer.close();
+            writer.releaseLock();
+        }
+        this.remove(streamId);
+    }
+    async clear(reason) {
+        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/dist/transformers.js

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

package/dist/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export const ResolvedType = Symbol('ResolvedType');

package/package.json

@@ -7,24 +7,24 @@
     "./static": "./dist/clients/static.js"
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.15.0-beta.1",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/contract": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1"
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/contract": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2"
   },
   "devDependencies": {
-    "@nmtjs/_tests": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1",
-    "@nmtjs/contract": "0.15.0-beta.1",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1"
+    "@nmtjs/_tests": "0.15.0-beta.2",
+    "@nmtjs/contract": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc",