@nmtjs/client 0.13.0 → 0.14.0

package/dist/common.d.ts

@@ -1,11 +1,19 @@
+import type { TypeProvider } from '@nmtjs/common';
 import type { TAnyAPIContract } from '@nmtjs/contract';
-import { EventEmitter, type ProtocolBaseClientCallOptions, type ProtocolBaseTransformer, ProtocolError, type ProtocolTransport } from '@nmtjs/protocol/client';
-import type { ClientCallers, ResolveAPIContract, ResolveClientEvents, RuntimeInputContractTypeProvider, RuntimeOutputContractTypeProvider } from './types.ts';
+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 declare abstract class BaseClient<APIContract extends TAnyAPIContract = TAnyAPIContract, SafeCall extends boolean = false, API extends ResolveAPIContract<APIContract, RuntimeInputContractTypeProvider, RuntimeOutputContractTypeProvider> = ResolveAPIContract<APIContract, RuntimeInputContractTypeProvider, RuntimeOutputContractTypeProvider>> extends EventEmitter<ResolveClientEvents<API>> {
+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: {
         timeout: number;
@@ -13,20 +21,20 @@ export declare abstract class BaseClient<APIContract extends TAnyAPIContract = T
         safe?: SafeCall;
     };
     _: {
-        api: API;
+        api: Routes;
         safe: SafeCall;
     };
     protected abstract transformer: ProtocolBaseTransformer;
-    protected callers: ClientCallers<API, SafeCall>;
-    protected auth: any;
+    protected callers: ClientCallers<Routes, SafeCall>;
+    auth: any;
     protected reconnectTimeout: number;
     constructor(transport: ProtocolTransport, options: {
         timeout: number;
         autoreconnect?: boolean;
         safe?: SafeCall;
     });
-    protected _call(namespace: string, procedure: string, payload: any, options: ProtocolBaseClientCallOptions): Promise<any>;
-    get call(): ClientCallers<API, 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,11 +1,11 @@
 import { noopFn } from '@nmtjs/common';
-import { EventEmitter, ProtocolError, } from '@nmtjs/protocol/client';
+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 extends EventEmitter {
+export class BaseClient {
     transport;
     options;
     _;
@@ -13,7 +13,6 @@ export class BaseClient extends EventEmitter {
     auth;
     reconnectTimeout = DEFAULT_RECONNECT_TIMEOUT;
     constructor(transport, options) {
-        super();
         this.transport = transport;
         this.options = options;
         if (this.options.autoreconnect) {
@@ -33,8 +32,8 @@ export class BaseClient extends EventEmitter {
             });
         }
     }
-    async _call(namespace, procedure, payload, options) {
-        const call = await this.transport.call(namespace, procedure, payload, options, this.transformer);
+    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 }))

package/dist/runtime.d.ts

@@ -1,16 +1,21 @@
-import type { TAnyAPIContract } from '@nmtjs/contract';
+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 contract: TAnyAPIContract;
-    constructor(contract: TAnyAPIContract);
-    decodeEvent(namespace: string, event: string, payload: any): unknown;
-    decodeRPC(namespace: string, procedure: string, payload: any): unknown;
-    decodeRPCChunk(namespace: string, procedure: string, payload: any): unknown;
-    encodeRPC(namespace: string, procedure: string, payload: any): unknown;
+    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> extends BaseClient<APIContract, SafeCall> {
+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,31 +1,31 @@
+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 {
-    contract;
-    constructor(contract) {
+    procedures;
+    constructor(procedures) {
         super();
-        this.contract = contract;
-    }
-    decodeEvent(namespace, event, payload) {
-        const type = this.contract.namespaces[namespace].events[event].payload;
-        return type.decode(payload);
+        this.procedures = procedures;
     }
-    decodeRPC(namespace, procedure, payload) {
-        const type = this.contract.namespaces[namespace].procedures[procedure].output;
+    decodeRPC(procedure, payload) {
+        const contract = this.getProcedureContract(procedure);
+        const type = contract.output;
         if (type instanceof t.NeverType)
             return undefined;
-        return type.decode(payload);
+        return payload;
     }
-    decodeRPCChunk(namespace, procedure, payload) {
-        const type = this.contract.namespaces[namespace].procedures[procedure].stream;
+    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(namespace, procedure, payload) {
-        const type = this.contract.namespaces[namespace].procedures[procedure].input;
+    encodeRPC(procedure, payload) {
+        const contract = this.getProcedureContract(procedure);
+        const type = contract.input;
         if (type instanceof t.NeverType)
             return undefined;
         try {
@@ -33,31 +33,73 @@ export class RuntimeContractTransformer extends ProtocolBaseTransformer {
         }
         catch (error) {
             if (error instanceof NeemataTypeError) {
-                throw new ClientError(ErrorCode.ValidationError, `Invalid payload for ${namespace}.${procedure}: ${error.message}`, error.issues);
+                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.transformer = new RuntimeContractTransformer(this.contract);
-        const callers = {};
-        const namespaces = Object.entries(this.contract.namespaces);
-        for (const [namespaceKey, namespace] of namespaces) {
-            callers[namespaceKey] = {};
-            const procedures = Object.entries(namespace.procedures);
-            for (const [procedureKey, procedure] of procedures) {
-                callers[namespaceKey][procedureKey] = (payload, options) => this._call(namespace.name, procedure.name, payload, {
-                    timeout: procedure.timeout || namespace.timeout || options.timeout,
-                    ...options,
-                });
+        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];
+                }
             }
         }
-        this.callers = callers;
+        return callers;
     }
 }

package/dist/static.d.ts

@@ -1,7 +1,9 @@
 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> {
+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

@@ -5,26 +5,22 @@ export class StaticClient extends BaseClient {
     constructor(...args) {
         super(...args);
         this.transformer = new ProtocolBaseTransformer();
-        this.callers = new Proxy(Object(), {
-            get: (target, namespace) => {
-                // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`
-                // without explicitly calling a function implicitly calls .then() on target
-                // FIXME: this basically makes "then" a reserved word
-                if (namespace === 'then')
-                    return target;
-                return new Proxy(Object(), {
-                    get: (target, procedure) => {
-                        // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`
-                        // without explicitly calling a function implicitly calls .then() on target
-                        // FIXME: this basically makes "then" a reserved word
-                        if (procedure === 'then')
-                            return target;
-                        return (payload, options) => this._call(namespace, procedure, payload, {
-                            ...options,
-                            timeout: options?.timeout ?? this.options.timeout,
-                        });
-                    },
+        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,5 +1,5 @@
 import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common';
-import type { TAnyAPIContract, TAnyProcedureContract } from '@nmtjs/contract';
+import type { TAnyAPIContract, TAnyProcedureContract, TAnyRouterContract } from '@nmtjs/contract';
 import type { InputType, OutputType, ProtocolBaseClientCallOptions, ProtocolError, ProtocolServerStreamInterface } from '@nmtjs/protocol/client';
 import type { BaseTypeAny, t } from '@nmtjs/type';
 export interface StaticInputContractTypeProvider extends TypeProvider {
@@ -14,57 +14,41 @@ export interface StaticOutputContractTypeProvider extends TypeProvider {
 export interface RuntimeOutputContractTypeProvider extends TypeProvider {
     output: this['input'] extends BaseTypeAny ? t.infer.decoded.output<this['input']> : never;
 }
-export type AnyResolvedAPIContract = Record<string, {
-    procedures: Record<string, {
-        contract: TAnyProcedureContract;
-        input: any;
-        output: any;
-    }>;
-    events: Record<string, {
-        payload: any;
-    }>;
-}>;
-export type ResolveAPIContract<C extends TAnyAPIContract = TAnyAPIContract, InputTypeProvider extends TypeProvider = TypeProvider, OutputTypeProvider extends TypeProvider = TypeProvider> = {
-    [N in keyof C['namespaces']]: {
-        procedures: {
-            [P in keyof C['namespaces'][N]['procedures']]: {
-                contract: C['namespaces'][N]['procedures'][P];
-                input: InputType<CallTypeProvider<InputTypeProvider, C['namespaces'][N]['procedures'][P]['input']>>;
-                output: C['namespaces'][N]['procedures'][P]['stream'] extends undefined | t.NeverType ? OutputType<CallTypeProvider<OutputTypeProvider, C['namespaces'][N]['procedures'][P]['output']>> : {
-                    result: OutputType<CallTypeProvider<OutputTypeProvider, C['namespaces'][N]['procedures'][P]['output']>>;
-                    stream: ProtocolServerStreamInterface<CallTypeProvider<OutputTypeProvider, C['namespaces'][N]['procedures'][P]['stream']>>;
-                };
-            };
-        };
-        events: {
-            [KE in keyof C['namespaces'][N]['events']]: {
-                payload: OutputType<CallTypeProvider<OutputTypeProvider, C['namespaces'][N]['events'][KE]['payload']>>;
-            };
+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: InputType<CallTypeProvider<InputTypeProvider, T['routes'][K]['input']>>;
+        output: T['routes'][K]['stream'] extends undefined | t.NeverType ? OutputType<CallTypeProvider<OutputTypeProvider, T['routes'][K]['output']>> : {
+            result: OutputType<CallTypeProvider<OutputTypeProvider, T['routes'][K]['output']>>;
+            stream: ProtocolServerStreamInterface<CallTypeProvider<OutputTypeProvider, T['routes'][K]['stream']>>;
         };
-    };
+    } : never;
 };
-export type ResolveClientEvents<C extends AnyResolvedAPIContract = AnyResolvedAPIContract> = {
-    [N in keyof C]: {
-        [E in keyof C[N]['events'] as `${Extract<N, string>}/${Extract<E, string>}`]: [
-            C[N]['events'][E]['payload']
-        ];
-    };
-}[keyof C];
-export type ClientCallers<Resolved extends AnyResolvedAPIContract, SafeCall extends boolean> = {
-    [N in keyof Resolved]: {
-        [P in keyof Resolved[N]['procedures']]: (...args: Resolved[N]['procedures'][P]['input'] extends t.NeverType ? [data?: undefined, options?: Partial<ProtocolBaseClientCallOptions>] : undefined extends t.infer.encoded.input<Resolved[N]['procedures'][P]['contract']['input']> ? [
-            data?: Resolved[N]['procedures'][P]['input'],
-            options?: Partial<ProtocolBaseClientCallOptions>
-        ] : [
-            data: Resolved[N]['procedures'][P]['input'],
-            options?: Partial<ProtocolBaseClientCallOptions>
-        ]) => SafeCall extends true ? Promise<OneOf<[
-            {
-                output: Resolved[N]['procedures'][P]['output'];
-            },
-            {
-                error: ProtocolError;
-            }
-        ]>> : Promise<Resolved[N]['procedures'][P]['output']>;
-    };
+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.encoded.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/package.json

@@ -19,23 +19,23 @@
     }
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.13.0",
-    "@nmtjs/contract": "0.13.0",
-    "@nmtjs/common": "0.13.0",
-    "@nmtjs/protocol": "0.13.0"
+    "@nmtjs/type": "0.14.0",
+    "@nmtjs/contract": "0.14.0",
+    "@nmtjs/common": "0.14.0",
+    "@nmtjs/protocol": "0.14.0"
   },
   "devDependencies": {
-    "@nmtjs/type": "0.13.0",
-    "@nmtjs/common": "0.13.0",
-    "@nmtjs/contract": "0.13.0",
-    "@nmtjs/protocol": "0.13.0"
+    "@nmtjs/type": "0.14.0",
+    "@nmtjs/contract": "0.14.0",
+    "@nmtjs/common": "0.14.0",
+    "@nmtjs/protocol": "0.14.0"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.13.0",
+  "version": "0.14.0",
   "scripts": {
     "build": "tsc",
     "type-check": "tsc --noEmit"