@nmtjs/client 0.14.4 → 0.15.0-beta.1

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Denis Ilchyshyn
+Copyright (c) 2025 Denys Ilchyshyn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -6,4 +6,4 @@
 - binary data streaming and event subscriptions
 - contract-based API
 - end-to-end type safety
-- CPU-intensive task execution on separate workers
+- CPU-intensive task execution on separate workers

package/package.json

@@ -2,42 +2,33 @@
   "name": "@nmtjs/client",
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/common.d.ts",
-      "import": "./dist/common.js",
-      "module-sync": "./dist/common.js"
-    },
-    "./runtime": {
-      "types": "./dist/runtime.d.ts",
-      "import": "./dist/runtime.js",
-      "module-sync": "./dist/runtime.js"
-    },
-    "./static": {
-      "types": "./dist/static.d.ts",
-      "import": "./dist/static.js",
-      "module-sync": "./dist/static.js"
-    }
+    ".": "./dist/index.js",
+    "./runtime": "./dist/clients/runtime.js",
+    "./static": "./dist/clients/static.js"
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.14.4",
-    "@nmtjs/common": "0.14.4",
-    "@nmtjs/contract": "0.14.4",
-    "@nmtjs/protocol": "0.14.4"
+    "@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"
   },
   "devDependencies": {
-    "@nmtjs/common": "0.14.4",
-    "@nmtjs/type": "0.14.4",
-    "@nmtjs/protocol": "0.14.4",
-    "@nmtjs/contract": "0.14.4"
+    "@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"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.14.4",
+  "version": "0.15.0-beta.1",
   "scripts": {
+    "clean-build": "rm -rf ./dist",
     "build": "tsc",
+    "dev": "tsc --watch",
     "type-check": "tsc --noEmit"
   }
 }

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;
-}

package/dist/static.js

@@ -1,27 +0,0 @@
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
-import { BaseClient } from "./common.js";
-export class StaticClient extends BaseClient {
-    transformer;
-    constructor(...args) {
-        super(...args);
-        this.transformer = new ProtocolBaseTransformer();
-        this.callers = this.createProxy(Object.create(null));
-    }
-    createProxy(target, path = []) {
-        return new Proxy(target, {
-            get: (obj, prop) => {
-                // `await client.call.something` or `await client.call.something.nested`
-                // without explicitly calling a function implicitly calls .then() on a target
-                // FIXME: this basically makes "then" a reserved word for static Client
-                if (prop === 'then')
-                    return obj;
-                const newPath = [...path, String(prop)];
-                const caller = (payload, options) => this._call(newPath.join('/'), payload, {
-                    ...options,
-                    timeout: options?.timeout ?? this.options.timeout,
-                });
-                return this.createProxy(caller, newPath);
-            },
-        });
-    }
-}

package/dist/types.d.ts

@@ -1,54 +0,0 @@
-import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common';
-import type { TAnyAPIContract, TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract';
-import type { ProtocolBaseClientCallOptions, ProtocolError, ProtocolServerStreamInterface } from '@nmtjs/protocol/client';
-import type { BaseTypeAny, t } from '@nmtjs/type';
-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 ? t.infer.encode.output<this['input']> : never;
-}
-export interface RuntimeOutputContractTypeProvider extends TypeProvider {
-    output: this['input'] extends BaseTypeAny ? t.infer.decode.output<this['input']> : never;
-}
-export type AnyResolvedAPIContractProcedure = {
-    contract: TAnyProcedureContract;
-    input: any;
-    output: any;
-};
-export type AnyResolvedAPIContractRouter = {
-    contract: TAnyRouterContract;
-    routes: Record<string, AnyResolvedAPIContractRouter | AnyResolvedAPIContractProcedure>;
-};
-export type AnyResolvedAPIContract = Record<string, Record<string, AnyResolvedAPIContractProcedure | AnyResolvedAPIContractRouter>>;
-export type ResolveAPIRouterRoutes<T extends TAnyRouterContract, InputTypeProvider extends TypeProvider = TypeProvider, OutputTypeProvider extends TypeProvider = TypeProvider> = {
-    [K in keyof T['routes']]: T['routes'][K] extends TAnyRouterContract ? {
-        contract: T['routes'][K];
-        routes: ResolveAPIRouterRoutes<T['routes'][K], InputTypeProvider, OutputTypeProvider>;
-    } : T['routes'][K] extends TAnyProcedureContract ? {
-        contract: T['routes'][K];
-        input: CallTypeProvider<InputTypeProvider, T['routes'][K]['input']>;
-        output: T['routes'][K]['stream'] extends undefined | t.NeverType ? CallTypeProvider<OutputTypeProvider, T['routes'][K]['output']> : {
-            result: CallTypeProvider<OutputTypeProvider, T['routes'][K]['output']>;
-            stream: ProtocolServerStreamInterface<CallTypeProvider<OutputTypeProvider, T['routes'][K]['stream']>>;
-        };
-    } : never;
-};
-export type ResolveAPIContract<C extends TAnyAPIContract = TAnyAPIContract, InputTypeProvider extends TypeProvider = TypeProvider, OutputTypeProvider extends TypeProvider = TypeProvider> = ResolveAPIRouterRoutes<C['router'], InputTypeProvider, OutputTypeProvider>;
-export type ClientCaller<Procedure extends AnyResolvedAPIContractProcedure, SafeCall extends boolean> = (...args: Procedure['input'] extends t.NeverType ? [data?: undefined, options?: Partial<ProtocolBaseClientCallOptions>] : undefined extends t.infer.encode.input<Procedure['contract']['input']> ? [
-    data?: Procedure['input'],
-    options?: Partial<ProtocolBaseClientCallOptions>
-] : [
-    data: Procedure['input'],
-    options?: Partial<ProtocolBaseClientCallOptions>
-]) => SafeCall extends true ? Promise<OneOf<[{
-    output: Procedure['output'];
-}, {
-    error: ProtocolError;
-}]>> : Promise<Procedure['output']>;
-export type ClientCallers<Resolved extends AnyResolvedAPIContractRouter, SafeCall extends boolean> = {
-    [K in keyof Resolved['routes']]: Resolved['routes'][K] extends AnyResolvedAPIContractProcedure ? ClientCaller<Resolved['routes'][K], SafeCall> : Resolved['routes'][K] extends AnyResolvedAPIContractRouter ? ClientCallers<Resolved['routes'][K], SafeCall> : never;
-};

package/dist/types.js

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