@nmtjs/client 0.8.1 → 0.9.0

package/dist/common.js

@@ -1,4 +1,38 @@
-import { ProtocolError } from "@nmtjs/protocol/client";
+import { EventEmitter, ProtocolError } from "@nmtjs/protocol/client";
 export * from "./types.js";
 export class ClientError extends ProtocolError {}
 export { ErrorCode, ProtocolBlob, TransportType } from "@nmtjs/protocol/common";
+export class BaseClient extends EventEmitter {
+	_;
+	auth;
+	constructor(transport, options) {
+		super();
+		this.transport = transport;
+		this.options = options;
+	}
+	callers = {};
+	async _call(namespace, procedure, payload, options) {
+		const call = await this.transport.call(namespace, 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();
+	}
+}
+
+//# sourceMappingURL=common.js.map

package/dist/common.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,qBAAqB,wBAAwB;AAEtD,cAAc;AAEd,OAAO,MAAM,oBAAoB,cAAc,CAAE;AAEjD,SACE,WACA,cAEA,qBACK","names":[],"sources":["src/common.ts"],"sourcesContent":["import { ProtocolError } from '@nmtjs/protocol/client'\n\nexport * from './types.ts'\n\nexport class ClientError extends ProtocolError {}\n\nexport {\n  ErrorCode,\n  ProtocolBlob,\n  type ProtocolBlobMetadata,\n  TransportType,\n} from '@nmtjs/protocol/common'\n"],"version":3}
+{"mappings":"AACA,SACE,cAGA,qBAEK,wBAAwB;AAS/B,cAAc;AAEd,OAAO,MAAM,oBAAoB,cAAc,CAAE;AAEjD,SACE,WACA,cAEA,qBACK;AAEP,OAAO,MAAe,mBAGZ,aAQR;CACA;CAUA,AAAU;CAEV,YACYA,WACAC,SACV;AACA,SAAO;OAHG;OACA;CAGX;CAED,AAAU,UAAU,CAAE;CAEtB,MAAgB,MACdC,WACAC,WACAC,SACAC,SACA;EACA,MAAM,OAAO,MAAM,KAAK,UAAU,KAChC,WACA,WACA,SACA,SACA,KAAK,YACN;AACD,MAAI,KAAK,QAAQ,MAAM;AACrB,UAAO,MAAM,KAAK,QACf,KAAK,CAAC,YAAY,EAAE,OAAQ,GAAE,CAC9B,MAAM,CAAC,WAAW,EAAE,MAAO,GAAE;EACjC,OAAM;AACL,UAAO,MAAM,KAAK,QAAQ,MAAM,CAAC,UAAU;AACzC,UAAM;GACP,EAAC;EACH;CACF;CAED,IAAI,OAAO;AACT,SAAO,KAAK;CACb;CAED,QAAQC,MAAW;AACjB,OAAK,OAAO;CACb;CAED,UAAU;AACR,SAAO,KAAK,UAAU,QAAQ,KAAK,MAAM,KAAK,YAAY;CAC3D;CAED,aAAa;AACX,SAAO,KAAK,UAAU,YAAY;CACnC;AACF","names":["transport: ProtocolTransport","options: { timeout: number; safe?: SafeCall }","namespace: string","procedure: string","payload: any","options: ProtocolBaseClientCallOptions","auth: any"],"sources":["../src/common.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport {\n  EventEmitter,\n  type ProtocolBaseClientCallOptions,\n  type ProtocolBaseTransformer,\n  ProtocolError,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  RuntimeInputContractTypeProvider,\n  RuntimeOutputContractTypeProvider,\n} from './types.ts'\n\nexport * from './types.ts'\n\nexport class ClientError extends ProtocolError {}\n\nexport {\n  ErrorCode,\n  ProtocolBlob,\n  type ProtocolBlobMetadata,\n  TransportType,\n} from '@nmtjs/protocol/common'\n\nexport abstract class BaseClient<\n  APIContract extends TAnyAPIContract = TAnyAPIContract,\n  SafeCall extends boolean = false,\n> extends EventEmitter<\n  ResolveClientEvents<\n    ResolveAPIContract<\n      APIContract,\n      RuntimeInputContractTypeProvider,\n      RuntimeOutputContractTypeProvider\n    >\n  >\n> {\n  _!: {\n    api: ResolveAPIContract<\n      APIContract,\n      RuntimeInputContractTypeProvider,\n      RuntimeOutputContractTypeProvider\n    >\n    safe: SafeCall\n  }\n\n  protected abstract transformer: ProtocolBaseTransformer\n  protected auth: any\n\n  constructor(\n    protected transport: ProtocolTransport,\n    protected options: { timeout: number; safe?: SafeCall },\n  ) {\n    super()\n  }\n\n  protected callers = {} as ClientCallers<this['_']['api'], this['_']['safe']>\n\n  protected async _call(\n    namespace: string,\n    procedure: string,\n    payload: any,\n    options: ProtocolBaseClientCallOptions,\n  ) {\n    const call = await this.transport.call(\n      namespace,\n      procedure,\n      payload,\n      options,\n      this.transformer,\n    )\n    if (this.options.safe) {\n      return await call.promise\n        .then((result) => ({ result }))\n        .catch((error) => ({ error }))\n    } else {\n      return await call.promise.catch((error) => {\n        throw error\n      })\n    }\n  }\n\n  get call() {\n    return this.callers\n  }\n\n  setAuth(auth: any) {\n    this.auth = auth\n  }\n\n  connect() {\n    return this.transport.connect(this.auth, this.transformer)\n  }\n\n  disconnect() {\n    return this.transport.disconnect()\n  }\n}\n"],"version":3,"file":"common.js"}

package/dist/runtime.js

@@ -1,29 +1,29 @@
-import { ProtocolBaseClient, ProtocolBaseTransformer } from "@nmtjs/protocol/client";
+import { ProtocolBaseTransformer } from "@nmtjs/protocol/client";
 import { ErrorCode } from "@nmtjs/protocol/common";
 import { NeemataTypeError, NeverType } from "@nmtjs/type";
-import { ClientError } from "./common.js";
+import { BaseClient, ClientError } from "./common.js";
 export class RuntimeContractTransformer extends ProtocolBaseTransformer {
-	#contract;
+	contract;
 	constructor(contract) {
 		super();
-		this.#contract = contract;
+		this.contract = contract;
 	}
 	decodeEvent(namespace, event, payload) {
-		const type = this.#contract.namespaces[namespace].events[event].payload;
+		const type = this.contract.namespaces[namespace].events[event].payload;
 		return type.decode(payload);
 	}
 	decodeRPC(namespace, procedure, payload) {
-		const type = this.#contract.namespaces[namespace].procedures[procedure].output;
+		const type = this.contract.namespaces[namespace].procedures[procedure].output;
 		if (type instanceof NeverType) return undefined;
 		return type.decode(payload);
 	}
 	decodeRPCChunk(namespace, procedure, payload) {
-		const type = this.#contract.namespaces[namespace].procedures[procedure].stream;
+		const type = this.contract.namespaces[namespace].procedures[procedure].stream;
 		if (type instanceof NeverType) return undefined;
 		return type.decode(payload);
 	}
 	encodeRPC(namespace, procedure, payload) {
-		const type = this.#contract.namespaces[namespace].procedures[procedure].input;
+		const type = this.contract.namespaces[namespace].procedures[procedure].input;
 		if (type instanceof NeverType) return undefined;
 		try {
 			return type.encode(payload);
@@ -35,28 +35,24 @@ export class RuntimeContractTransformer extends ProtocolBaseTransformer {
 		}
 	}
 }
-export class RuntimeClient extends ProtocolBaseClient {
-	_;
-	#callers = {};
-	constructor(contract, options) {
-		super({
-			...options,
-			transformer: new RuntimeContractTransformer(contract)
-		});
-		const callers = {};
-		for (const [namespaceKey, namespace] of Object.entries(contract.namespaces)) {
-			namespace.procedures;
-			callers[namespaceKey] = {};
-			for (const [procedureKey, procedure] of Object.entries(namespace.procedures)) {
-				callers[namespaceKey][procedureKey] = (payload, options) => this._call(namespace.name, procedure.name, payload, {
-					timeout: namespace.timeout,
+export class RuntimeClient extends BaseClient {
+	transformer;
+	constructor(contract, ...args) {
+		super(...args);
+		this.contract = contract;
+		this.transformer = new RuntimeContractTransformer(this.contract);
+		const namespaces = Object.entries(this.contract.namespaces);
+		for (const [namespaceKey, namespace] of namespaces) {
+			this.callers[namespaceKey] = {};
+			const procedures = Object.entries(namespace.procedures);
+			for (const [procedureKey, procedure] of procedures) {
+				this.callers[namespaceKey][procedureKey] = (payload, options) => this._call(namespace.name, procedure.name, payload, {
+					timeout: procedure.timeout || namespace.timeout || options.timeout,
 					...options
 				});
 			}
 		}
-		this.#callers = callers;
-	}
-	get call() {
-		return this.#callers;
 	}
 }
+
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -1 +1 @@
-{"mappings":"AAEA,SACE,oBACA,+BAEK,wBAAwB;AAC/B,SAAS,iBAAiB,wBAAwB;AAClD,SAA2B,kBAAkB,iBAAiB,aAAa;AAC3E,SAAS,mBAAmB,aAAa;AASzC,OAAO,MAAM,mCAAmC,wBAAwB;CACtE;CAEA,YAAYA,UAA2B;AACrC,SAAO;AAEP,OAAKC,YAAY;CAClB;CAED,YAAYC,WAAmBC,OAAeC,SAAc;EAC1D,MAAM,OAAO,KAAKH,UAAU,WAAW,WAAW,OAAO,OAAO;AAChE,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,UAAUC,WAAmBG,WAAmBD,SAAc;EAC5D,MAAM,OACJ,KAAKH,UAAU,WAAW,WAAW,WAAW,WAAW;AAC7D,MAAI,gBAAgB,UAAW,QAAO;AACtC,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,eAAeC,WAAmBG,WAAmBD,SAAc;EACjE,MAAM,OACJ,KAAKH,UAAU,WAAW,WAAW,WAAW,WAAW;AAC7D,MAAI,gBAAgB,UAAW,QAAO;AACtC,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,UAAUC,WAAmBG,WAAmBD,SAAc;EAC5D,MAAM,OACJ,KAAKH,UAAU,WAAW,WAAW,WAAW,WAAW;AAC7D,MAAI,gBAAgB,UAAW,QAAO;AACtC,MAAI;AACF,UAAO,KAAK,OAAO,QAAQ;EAC5B,SAAQ,OAAO;AACd,OAAI,iBAAiB,kBAAkB;AACrC,UAAM,IAAI,YACR,UAAU,kBACT,sBAAsB,UAAU,GAAG,UAAU,IAAI,MAAM,QAAQ,GAChE,MAAM;GAET;AACD,SAAM;EACP;CACF;AACF;AAED,OAAO,MAAM,sBAWH,mBAA6D;CACrE;CACA,WAAW,CAAE;CAEb,YACEK,UACAC,SAKA;AACA,QAAM;GACJ,GAAG;GACH,aAAa,IAAI,2BAA2B;EAC7C,EAAC;EAEF,MAAM,UAAU,CAAE;AAElB,OAAK,MAAM,CAAC,cAAc,UAAU,IAAI,OAAO,QAC7C,SAAS,WACV,EAAE;AACD,aAAU;AAEV,WAAQ,gBAAgB,CAAE;AAE1B,QAAK,MAAM,CAAC,cAAc,UAAU,IAAI,OAAO,QAC7C,UAAU,WACX,EAAE;AACD,YAAQ,cAAc,gBAAgB,CAAC,SAAS,YAC9C,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM,SAAS;KAClD,SAAS,UAAU;KACnB,GAAG;IACJ,EAAC;GACL;EACF;AACD,OAAKC,WAAW;CACjB;CAED,IAAI,OAAO;AACT,SAAO,KAAKA;CACb;AACF","names":["contract: TAnyAPIContract","#contract","namespace: string","event: string","payload: any","procedure: string","contract: APIContract","options: {\n      transport: ProtocolTransport\n      format: BaseClientFormat\n      timeout?: number\n    }","#callers"],"sources":["src/runtime.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport type { BaseClientFormat } from '@nmtjs/protocol/client'\nimport {\n  ProtocolBaseClient,\n  ProtocolBaseTransformer,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\nimport { ErrorCode } from '@nmtjs/protocol/common'\nimport { type BaseTypeAny, NeemataTypeError, NeverType } from '@nmtjs/type'\nimport { ClientError } from './common.ts'\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  RuntimeInputContractTypeProvider,\n  RuntimeOutputContractTypeProvider,\n} from './types.ts'\n\nexport class RuntimeContractTransformer extends ProtocolBaseTransformer {\n  #contract: TAnyAPIContract\n\n  constructor(contract: TAnyAPIContract) {\n    super()\n\n    this.#contract = contract\n  }\n\n  decodeEvent(namespace: string, event: string, payload: any) {\n    const type = this.#contract.namespaces[namespace].events[event].payload\n    return type.decode(payload)\n  }\n\n  decodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].output\n    if (type instanceof NeverType) return undefined\n    return type.decode(payload)\n  }\n\n  decodeRPCChunk(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].stream\n    if (type instanceof NeverType) return undefined\n    return type.decode(payload)\n  }\n\n  encodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.#contract.namespaces[namespace].procedures[procedure].input\n    if (type instanceof NeverType) return undefined\n    try {\n      return type.encode(payload)\n    } catch (error) {\n      if (error instanceof NeemataTypeError) {\n        throw new ClientError(\n          ErrorCode.ValidationError,\n          `Invalid payload for ${namespace}.${procedure}: ${error.message}`,\n          error.issues,\n        )\n      }\n      throw error\n    }\n  }\n}\n\nexport class RuntimeClient<\n  APIContract extends TAnyAPIContract,\n  ResolvedAPIContract extends ResolveAPIContract<\n    APIContract,\n    RuntimeInputContractTypeProvider,\n    RuntimeOutputContractTypeProvider\n  > = ResolveAPIContract<\n    APIContract,\n    RuntimeInputContractTypeProvider,\n    RuntimeOutputContractTypeProvider\n  >,\n> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {\n  _!: ResolvedAPIContract\n  #callers = {} as ClientCallers<ResolvedAPIContract>\n\n  constructor(\n    contract: APIContract,\n    options: {\n      transport: ProtocolTransport\n      format: BaseClientFormat\n      timeout?: number\n    },\n  ) {\n    super({\n      ...options,\n      transformer: new RuntimeContractTransformer(contract),\n    })\n\n    const callers = {} as any\n\n    for (const [namespaceKey, namespace] of Object.entries(\n      contract.namespaces,\n    )) {\n      namespace.procedures\n\n      callers[namespaceKey] = {} as any\n\n      for (const [procedureKey, procedure] of Object.entries(\n        namespace.procedures,\n      )) {\n        callers[namespaceKey][procedureKey] = (payload, options) =>\n          this._call(namespace.name, procedure.name, payload, {\n            timeout: namespace.timeout,\n            ...options,\n          })\n      }\n    }\n    this.#callers = callers\n  }\n\n  get call() {\n    return this.#callers\n  }\n}\n"],"version":3}
+{"mappings":"AACA,SAAS,+BAA+B,wBAAwB;AAChE,SAAS,iBAAiB,wBAAwB;AAClD,SAAS,kBAAkB,iBAAiB,aAAa;AACzD,SAAS,YAAY,mBAAmB,aAAa;AAErD,OAAO,MAAM,mCAAmC,wBAAwB;CACtE,AAAU;CAEV,YAAYA,UAA2B;AACrC,SAAO;AAEP,OAAK,WAAW;CACjB;CAED,YAAYC,WAAmBC,OAAeC,SAAc;EAC1D,MAAM,OAAO,KAAK,SAAS,WAAW,WAAW,OAAO,OAAO;AAC/D,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,UAAUF,WAAmBG,WAAmBD,SAAc;EAC5D,MAAM,OACJ,KAAK,SAAS,WAAW,WAAW,WAAW,WAAW;AAC5D,MAAI,gBAAgB,UAAW,QAAO;AACtC,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,eAAeF,WAAmBG,WAAmBD,SAAc;EACjE,MAAM,OACJ,KAAK,SAAS,WAAW,WAAW,WAAW,WAAW;AAC5D,MAAI,gBAAgB,UAAW,QAAO;AACtC,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,UAAUF,WAAmBG,WAAmBD,SAAc;EAC5D,MAAM,OAAO,KAAK,SAAS,WAAW,WAAW,WAAW,WAAW;AACvE,MAAI,gBAAgB,UAAW,QAAO;AACtC,MAAI;AACF,UAAO,KAAK,OAAO,QAAQ;EAC5B,SAAQ,OAAO;AACd,OAAI,iBAAiB,kBAAkB;AACrC,UAAM,IAAI,YACR,UAAU,kBACT,sBAAsB,UAAU,GAAG,UAAU,IAAI,MAAM,QAAQ,GAChE,MAAM;GAET;AACD,SAAM;EACP;CACF;AACF;AAED,OAAO,MAAM,sBAGH,WAAkC;CAC1C,AAAU;CAEV,YACSE,UACP,GAAG,MACH;AACA,QAAM,GAAG,KAAK;OAHP;AAKP,OAAK,cAAc,IAAI,2BAA2B,KAAK;EAEvD,MAAM,aAAa,OAAO,QAAQ,KAAK,SAAS,WAAW;AAC3D,OAAK,MAAM,CAAC,cAAc,UAAU,IAAI,YAAY;AAClD,QAAK,QAAQ,gBAAgB,CAAE;GAE/B,MAAM,aAAa,OAAO,QAAQ,UAAU,WAAW;AAEvD,QAAK,MAAM,CAAC,cAAc,UAAU,IAAI,YAAY;AAClD,SAAK,QAAQ,cAAc,gBAAgB,CAAC,SAAS,YACnD,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM,SAAS;KAClD,SAAS,UAAU,WAAW,UAAU,WAAW,QAAQ;KAC3D,GAAG;IACJ,EAAC;GACL;EACF;CACF;AACF","names":["contract: TAnyAPIContract","namespace: string","event: string","payload: any","procedure: string","contract: APIContract"],"sources":["../src/runtime.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport { ProtocolBaseTransformer } from '@nmtjs/protocol/client'\nimport { ErrorCode } from '@nmtjs/protocol/common'\nimport { NeemataTypeError, NeverType } from '@nmtjs/type'\nimport { BaseClient, ClientError } from './common.ts'\n\nexport class RuntimeContractTransformer extends ProtocolBaseTransformer {\n  protected contract: TAnyAPIContract\n\n  constructor(contract: TAnyAPIContract) {\n    super()\n\n    this.contract = contract\n  }\n\n  decodeEvent(namespace: string, event: string, payload: any) {\n    const type = this.contract.namespaces[namespace].events[event].payload\n    return type.decode(payload)\n  }\n\n  decodeRPC(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.contract.namespaces[namespace].procedures[procedure].output\n    if (type instanceof NeverType) return undefined\n    return type.decode(payload)\n  }\n\n  decodeRPCChunk(namespace: string, procedure: string, payload: any) {\n    const type =\n      this.contract.namespaces[namespace].procedures[procedure].stream\n    if (type instanceof NeverType) return undefined\n    return type.decode(payload)\n  }\n\n  encodeRPC(namespace: string, procedure: string, payload: any) {\n    const type = this.contract.namespaces[namespace].procedures[procedure].input\n    if (type instanceof NeverType) return undefined\n    try {\n      return type.encode(payload)\n    } catch (error) {\n      if (error instanceof NeemataTypeError) {\n        throw new ClientError(\n          ErrorCode.ValidationError,\n          `Invalid payload for ${namespace}.${procedure}: ${error.message}`,\n          error.issues,\n        )\n      }\n      throw error\n    }\n  }\n}\n\nexport class RuntimeClient<\n  APIContract extends TAnyAPIContract,\n  SafeCall extends boolean,\n> extends BaseClient<APIContract, SafeCall> {\n  protected transformer: RuntimeContractTransformer\n\n  constructor(\n    public contract: APIContract,\n    ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>\n  ) {\n    super(...args)\n\n    this.transformer = new RuntimeContractTransformer(this.contract)\n\n    const namespaces = Object.entries(this.contract.namespaces)\n    for (const [namespaceKey, namespace] of namespaces) {\n      this.callers[namespaceKey] = {} as any\n\n      const procedures = Object.entries(namespace.procedures)\n\n      for (const [procedureKey, procedure] of procedures) {\n        this.callers[namespaceKey][procedureKey] = (payload, options) =>\n          this._call(namespace.name, procedure.name, payload, {\n            timeout: procedure.timeout || namespace.timeout || options.timeout,\n            ...options,\n          })\n      }\n    }\n  }\n}\n"],"version":3,"file":"runtime.js"}

package/dist/static.js

@@ -1,18 +1,21 @@
-import { ProtocolBaseClient } from "@nmtjs/protocol/client";
-export class StaticClient extends ProtocolBaseClient {
-	_;
-	#callers;
-	constructor(options) {
-		super(options);
-		this.#callers = new Proxy(Object(), { get: (target, namespace) => {
+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 = new Proxy(Object(), { get: (target, namespace) => {
 			if (namespace === "then") return target;
 			return new Proxy(Object(), { get: (target, procedure) => {
 				if (procedure === "then") return target;
-				return (payload, options) => this._call(namespace, procedure, payload, options);
+				return (payload, options) => this._call(namespace, procedure, payload, {
+					...options,
+					timeout: options?.timeout ?? this.options.timeout
+				});
 			} });
 		} });
 	}
-	get call() {
-		return this.#callers;
-	}
 }
+
+//# sourceMappingURL=static.js.map

package/dist/static.js.map

@@ -1 +1 @@
-{"mappings":"AACA,SAEE,0BAEK,wBAAwB;AAU/B,OAAO,MAAM,qBAWH,mBAA6D;CACrE;CAEA;CAEA,YAAYA,SAIT;AACD,QAAM,QAAQ;AAEd,OAAKC,WAAW,IAAI,MAAM,QAAQ,EAAE,EAClC,KAAK,CAAC,QAAQ,cAAc;AAI1B,OAAI,cAAc,OAAQ,QAAO;AACjC,UAAO,IAAI,MAAM,QAAQ,EAAE,EACzB,KAAK,CAAC,QAAQ,cAAc;AAI1B,QAAI,cAAc,OAAQ,QAAO;AACjC,WAAO,CAAC,SAAS,YACf,KAAK,MACH,WACA,WACA,SACA,QACD;GACJ,EACF;EACF,EACF;CACF;CAED,IAAI,OAAO;AACT,SAAO,KAAKA;CACb;AACF","names":["options: {\n    transport: ProtocolTransport\n    format: BaseClientFormat\n    timeout?: number\n  }","#callers"],"sources":["src/static.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport {\n  type BaseClientFormat,\n  ProtocolBaseClient,\n  type ProtocolTransport,\n} from '@nmtjs/protocol/client'\n\nimport type {\n  ClientCallers,\n  ResolveAPIContract,\n  ResolveClientEvents,\n  StaticInputContractTypeProvider,\n  StaticOutputContractTypeProvider,\n} from './types.ts'\n\nexport class StaticClient<\n  APIContract extends TAnyAPIContract,\n  ResolvedAPIContract extends ResolveAPIContract<\n    APIContract,\n    StaticInputContractTypeProvider,\n    StaticOutputContractTypeProvider\n  > = ResolveAPIContract<\n    APIContract,\n    StaticInputContractTypeProvider,\n    StaticOutputContractTypeProvider\n  >,\n> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {\n  _!: ResolvedAPIContract\n\n  #callers: ClientCallers<ResolvedAPIContract>\n\n  constructor(options: {\n    transport: ProtocolTransport\n    format: BaseClientFormat\n    timeout?: number\n  }) {\n    super(options)\n\n    this.#callers = new Proxy(Object(), {\n      get: (target, namespace) => {\n        // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n        // without explicitly calling a function implicitly calls .then() on target\n        // FIXME: this basically makes \"then\" a reserved word\n        if (namespace === 'then') return target\n        return new Proxy(Object(), {\n          get: (target, procedure) => {\n            // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n            // without explicitly calling a function implicitly calls .then() on target\n            // FIXME: this basically makes \"then\" a reserved word\n            if (procedure === 'then') return target\n            return (payload, options) =>\n              this._call(\n                namespace as string,\n                procedure as string,\n                payload,\n                options,\n              )\n          },\n        })\n      },\n    })\n  }\n\n  get call() {\n    return this.#callers\n  }\n}\n"],"version":3}
+{"mappings":"AACA,SAAS,+BAA+B,wBAAwB;AAChE,SAAS,kBAAkB,aAAa;AAExC,OAAO,MAAM,qBAGH,WAAkC;CAC1C,AAAU;CAEV,YACE,GAAG,MACH;AACA,QAAM,GAAG,KAAK;AAEd,OAAK,cAAc,IAAI;AAEvB,OAAK,UAAU,IAAI,MAAM,QAAQ,EAAE,EACjC,KAAK,CAAC,QAAQ,cAAc;AAI1B,OAAI,cAAc,OAAQ,QAAO;AACjC,UAAO,IAAI,MAAM,QAAQ,EAAE,EACzB,KAAK,CAAC,QAAQ,cAAc;AAI1B,QAAI,cAAc,OAAQ,QAAO;AACjC,WAAO,CAAC,SAAS,YACf,KAAK,MAAM,WAAqB,WAAqB,SAAS;KAC5D,GAAG;KACH,SAAS,SAAS,WAAW,KAAK,QAAQ;IAC3C,EAAC;GACL,EACF;EACF,EACF;CACF;AACF","names":[],"sources":["../src/static.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport { ProtocolBaseTransformer } from '@nmtjs/protocol/client'\nimport { BaseClient } from './common.ts'\n\nexport class StaticClient<\n  APIContract extends TAnyAPIContract,\n  SafeCall extends boolean = false,\n> extends BaseClient<APIContract, SafeCall> {\n  protected transformer: ProtocolBaseTransformer\n\n  constructor(\n    ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>\n  ) {\n    super(...args)\n\n    this.transformer = new ProtocolBaseTransformer()\n\n    this.callers = new Proxy(Object(), {\n      get: (target, namespace) => {\n        // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n        // without explicitly calling a function implicitly calls .then() on target\n        // FIXME: this basically makes \"then\" a reserved word\n        if (namespace === 'then') return target\n        return new Proxy(Object(), {\n          get: (target, procedure) => {\n            // `await client.call.namespaceName` or `await client.call.namespaceName.procedureName`\n            // without explicitly calling a function implicitly calls .then() on target\n            // FIXME: this basically makes \"then\" a reserved word\n            if (procedure === 'then') return target\n            return (payload, options) =>\n              this._call(namespace as string, procedure as string, payload, {\n                ...options,\n                timeout: options?.timeout ?? this.options.timeout,\n              })\n          },\n        })\n      },\n    })\n  }\n}\n"],"version":3,"file":"static.js"}

package/dist/types.js

@@ -1 +1,3 @@
 export {};
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"mappings":"","names":[],"sources":["src/types.ts"],"sourcesContent":["import type { CallTypeProvider, TypeProvider } from '@nmtjs/common'\nimport type { TAnyAPIContract } from '@nmtjs/contract'\nimport type {\n  ProtocolBaseClientCallOptions,\n  ProtocolServerStreamInterface,\n} from '@nmtjs/protocol/client'\nimport type { InputType, OutputType } from '@nmtjs/protocol/common'\nimport type { BaseTypeAny, NeverType, t } from '@nmtjs/type'\n\nexport interface StaticInputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.encoded.input<this['input']>\n    : never\n}\n\nexport interface RuntimeInputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.decoded.input<this['input']>\n    : never\n}\n\nexport interface StaticOutputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.encoded.output<this['input']>\n    : never\n}\n\nexport interface RuntimeOutputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.decoded.output<this['input']>\n    : never\n}\n\nexport type ResolveAPIContract<\n  C extends TAnyAPIContract = TAnyAPIContract,\n  InputTypeProvider extends TypeProvider = TypeProvider,\n  OutputTypeProvider extends TypeProvider = TypeProvider,\n> = {\n  [N in keyof C['namespaces'] as C['namespaces'][N]['name']]: {\n    procedures: {\n      [P in keyof C['namespaces'][N]['procedures'] as C['namespaces'][N]['procedures'][P]['name']]: {\n        contract: C['namespaces'][N]['procedures'][P]\n        input: InputType<\n          CallTypeProvider<\n            InputTypeProvider,\n            C['namespaces'][N]['procedures'][P]['input']\n          >\n        >\n        output: C['namespaces'][N]['procedures'][P]['stream'] extends NeverType\n          ? OutputType<\n              CallTypeProvider<\n                OutputTypeProvider,\n                C['namespaces'][N]['procedures'][P]['output']\n              >\n            >\n          : {\n              response: OutputType<\n                CallTypeProvider<\n                  OutputTypeProvider,\n                  C['namespaces'][N]['procedures'][P]['output']\n                >\n              >\n              stream: ProtocolServerStreamInterface<\n                CallTypeProvider<\n                  OutputTypeProvider,\n                  C['namespaces'][N]['procedures'][P]['stream']\n                >\n              >\n            }\n      }\n    }\n    events: {\n      [KE in keyof C['namespaces'][N]['events'] as C['namespaces'][N]['events'][KE]['name']]: {\n        payload: OutputType<\n          CallTypeProvider<\n            OutputTypeProvider,\n            C['namespaces'][N]['events'][KE]['payload']\n          >\n        >\n      }\n    }\n  }\n}\n\nexport type ResolveClientEvents<\n  C extends ResolveAPIContract = ResolveAPIContract,\n> = {\n  [N in keyof C]: {\n    [KE in keyof C[N]['events']]: C[N]['events'][KE]['payload']\n  }\n}\n\nexport type ClientCallers<Resolved extends ResolveAPIContract> = {\n  [N in keyof Resolved]: {\n    [P in keyof Resolved[N]['procedures']]: (\n      ...args: Resolved[N]['procedures'][P]['input'] extends NeverType\n        ? [options?: ProtocolBaseClientCallOptions]\n        : undefined extends t.infer.encoded.input<\n              Resolved[N]['procedures'][P]['contract']['input']\n            >\n          ? [\n              data?: Resolved[N]['procedures'][P]['input'],\n              options?: ProtocolBaseClientCallOptions,\n            ]\n          : [\n              data: Resolved[N]['procedures'][P]['input'],\n              options?: ProtocolBaseClientCallOptions,\n            ]\n    ) => Promise<Resolved[N]['procedures'][P]['output']>\n  }\n}\n"],"version":3}
+{"mappings":"","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common'\nimport type { TAnyAPIContract } from '@nmtjs/contract'\nimport type {\n  ProtocolBaseClientCallOptions,\n  ProtocolError,\n  ProtocolServerStreamInterface,\n} from '@nmtjs/protocol/client'\nimport type { InputType, OutputType } from '@nmtjs/protocol/client'\nimport type { BaseTypeAny, NeverType, t } from '@nmtjs/type'\n\nexport interface StaticInputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.encoded.input<this['input']>\n    : never\n}\n\nexport interface RuntimeInputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.decoded.input<this['input']>\n    : never\n}\n\nexport interface StaticOutputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.encoded.output<this['input']>\n    : never\n}\n\nexport interface RuntimeOutputContractTypeProvider extends TypeProvider {\n  output: this['input'] extends BaseTypeAny\n    ? t.infer.decoded.output<this['input']>\n    : never\n}\n\nexport type ResolveAPIContract<\n  C extends TAnyAPIContract = TAnyAPIContract,\n  InputTypeProvider extends TypeProvider = TypeProvider,\n  OutputTypeProvider extends TypeProvider = TypeProvider,\n> = {\n  [N in keyof C['namespaces'] as C['namespaces'][N]['name']]: {\n    procedures: {\n      [P in keyof C['namespaces'][N]['procedures'] as C['namespaces'][N]['procedures'][P]['name']]: {\n        contract: C['namespaces'][N]['procedures'][P]\n        input: InputType<\n          CallTypeProvider<\n            InputTypeProvider,\n            C['namespaces'][N]['procedures'][P]['input']\n          >\n        >\n        output: C['namespaces'][N]['procedures'][P]['stream'] extends NeverType\n          ? OutputType<\n              CallTypeProvider<\n                OutputTypeProvider,\n                C['namespaces'][N]['procedures'][P]['output']\n              >\n            >\n          : {\n              result: OutputType<\n                CallTypeProvider<\n                  OutputTypeProvider,\n                  C['namespaces'][N]['procedures'][P]['output']\n                >\n              >\n              stream: ProtocolServerStreamInterface<\n                CallTypeProvider<\n                  OutputTypeProvider,\n                  C['namespaces'][N]['procedures'][P]['stream']\n                >\n              >\n            }\n      }\n    }\n    events: {\n      [KE in keyof C['namespaces'][N]['events'] as C['namespaces'][N]['events'][KE]['name']]: {\n        payload: OutputType<\n          CallTypeProvider<\n            OutputTypeProvider,\n            C['namespaces'][N]['events'][KE]['payload']\n          >\n        >\n      }\n    }\n  }\n}\n\nexport type ResolveClientEvents<\n  C extends ResolveAPIContract = ResolveAPIContract,\n> = {\n  [N in keyof C]: {\n    [KE in keyof C[N]['events'] as `${Extract<N, string>}/${Extract<KE, string>}`]: [\n      C[N]['events'][KE]['payload'],\n    ]\n  }\n}[keyof C]\n\nexport type ClientCallers<\n  Resolved extends ResolveAPIContract,\n  SafeCall extends boolean,\n> = {\n  [N in keyof Resolved]: {\n    [P in keyof Resolved[N]['procedures']]: (\n      ...args: Resolved[N]['procedures'][P]['input'] extends NeverType\n        ? [data?: undefined, options?: Partial<ProtocolBaseClientCallOptions>]\n        : undefined extends t.infer.encoded.input<\n              Resolved[N]['procedures'][P]['contract']['input']\n            >\n          ? [\n              data?: Resolved[N]['procedures'][P]['input'],\n              options?: Partial<ProtocolBaseClientCallOptions>,\n            ]\n          : [\n              data: Resolved[N]['procedures'][P]['input'],\n              options?: Partial<ProtocolBaseClientCallOptions>,\n            ]\n    ) => SafeCall extends true\n      ? Promise<\n          OneOf<\n            [\n              {\n                error?: undefined\n                output: Resolved[N]['procedures'][P]['output']\n              },\n              { error: ProtocolError; output?: undefined },\n            ]\n          >\n        >\n      : Promise<Resolved[N]['procedures'][P]['output']>\n  }\n}\n"],"version":3,"file":"types.js"}

package/package.json

@@ -16,16 +16,16 @@
     }
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.8.1",
-    "@nmtjs/protocol": "0.8.1",
-    "@nmtjs/contract": "0.8.1",
-    "@nmtjs/common": "0.8.1"
+    "@nmtjs/type": "0.9.0",
+    "@nmtjs/common": "0.9.0",
+    "@nmtjs/contract": "0.9.0",
+    "@nmtjs/protocol": "0.9.0"
   },
   "devDependencies": {
-    "@nmtjs/type": "0.8.1",
-    "@nmtjs/common": "0.8.1",
-    "@nmtjs/contract": "0.8.1",
-    "@nmtjs/protocol": "0.8.1"
+    "@nmtjs/type": "0.9.0",
+    "@nmtjs/common": "0.9.0",
+    "@nmtjs/contract": "0.9.0",
+    "@nmtjs/protocol": "0.9.0"
   },
   "files": [
     "src",
@@ -33,7 +33,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.8.1",
+  "version": "0.9.0",
   "scripts": {
     "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/common.ts

@@ -1,4 +1,18 @@
-import { ProtocolError } from '@nmtjs/protocol/client'
+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'
 
 export * from './types.ts'
 
@@ -10,3 +24,77 @@ export {
   type ProtocolBlobMetadata,
   TransportType,
 } from '@nmtjs/protocol/common'
+
+export abstract class BaseClient<
+  APIContract extends TAnyAPIContract = TAnyAPIContract,
+  SafeCall extends boolean = false,
+> extends EventEmitter<
+  ResolveClientEvents<
+    ResolveAPIContract<
+      APIContract,
+      RuntimeInputContractTypeProvider,
+      RuntimeOutputContractTypeProvider
+    >
+  >
+> {
+  _!: {
+    api: ResolveAPIContract<
+      APIContract,
+      RuntimeInputContractTypeProvider,
+      RuntimeOutputContractTypeProvider
+    >
+    safe: SafeCall
+  }
+
+  protected abstract transformer: ProtocolBaseTransformer
+  protected auth: any
+
+  constructor(
+    protected transport: ProtocolTransport,
+    protected options: { timeout: number; safe?: SafeCall },
+  ) {
+    super()
+  }
+
+  protected callers = {} as ClientCallers<this['_']['api'], this['_']['safe']>
+
+  protected async _call(
+    namespace: string,
+    procedure: string,
+    payload: any,
+    options: ProtocolBaseClientCallOptions,
+  ) {
+    const call = await this.transport.call(
+      namespace,
+      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: any) {
+    this.auth = auth
+  }
+
+  connect() {
+    return this.transport.connect(this.auth, this.transformer)
+  }
+
+  disconnect() {
+    return this.transport.disconnect()
+  }
+}

package/src/runtime.ts

@@ -1,52 +1,39 @@
 import type { TAnyAPIContract } from '@nmtjs/contract'
-import type { BaseClientFormat } from '@nmtjs/protocol/client'
-import {
-  ProtocolBaseClient,
-  ProtocolBaseTransformer,
-  type ProtocolTransport,
-} from '@nmtjs/protocol/client'
+import { ProtocolBaseTransformer } from '@nmtjs/protocol/client'
 import { ErrorCode } from '@nmtjs/protocol/common'
-import { type BaseTypeAny, NeemataTypeError, NeverType } from '@nmtjs/type'
-import { ClientError } from './common.ts'
-import type {
-  ClientCallers,
-  ResolveAPIContract,
-  ResolveClientEvents,
-  RuntimeInputContractTypeProvider,
-  RuntimeOutputContractTypeProvider,
-} from './types.ts'
+import { NeemataTypeError, NeverType } from '@nmtjs/type'
+import { BaseClient, ClientError } from './common.ts'
 
 export class RuntimeContractTransformer extends ProtocolBaseTransformer {
-  #contract: TAnyAPIContract
+  protected contract: TAnyAPIContract
 
   constructor(contract: TAnyAPIContract) {
     super()
 
-    this.#contract = contract
+    this.contract = contract
   }
 
   decodeEvent(namespace: string, event: string, payload: any) {
-    const type = this.#contract.namespaces[namespace].events[event].payload
+    const type = this.contract.namespaces[namespace].events[event].payload
     return type.decode(payload)
   }
 
   decodeRPC(namespace: string, procedure: string, payload: any) {
     const type =
-      this.#contract.namespaces[namespace].procedures[procedure].output
+      this.contract.namespaces[namespace].procedures[procedure].output
     if (type instanceof NeverType) return undefined
     return type.decode(payload)
   }
 
   decodeRPCChunk(namespace: string, procedure: string, payload: any) {
     const type =
-      this.#contract.namespaces[namespace].procedures[procedure].stream
+      this.contract.namespaces[namespace].procedures[procedure].stream
     if (type instanceof NeverType) return undefined
     return type.decode(payload)
   }
 
   encodeRPC(namespace: string, procedure: string, payload: any) {
-    const type =
-      this.#contract.namespaces[namespace].procedures[procedure].input
+    const type = this.contract.namespaces[namespace].procedures[procedure].input
     if (type instanceof NeverType) return undefined
     try {
       return type.encode(payload)
@@ -65,55 +52,31 @@ export class RuntimeContractTransformer extends ProtocolBaseTransformer {
 
 export class RuntimeClient<
   APIContract extends TAnyAPIContract,
-  ResolvedAPIContract extends ResolveAPIContract<
-    APIContract,
-    RuntimeInputContractTypeProvider,
-    RuntimeOutputContractTypeProvider
-  > = ResolveAPIContract<
-    APIContract,
-    RuntimeInputContractTypeProvider,
-    RuntimeOutputContractTypeProvider
-  >,
-> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {
-  _!: ResolvedAPIContract
-  #callers = {} as ClientCallers<ResolvedAPIContract>
+  SafeCall extends boolean,
+> extends BaseClient<APIContract, SafeCall> {
+  protected transformer: RuntimeContractTransformer
 
   constructor(
-    contract: APIContract,
-    options: {
-      transport: ProtocolTransport
-      format: BaseClientFormat
-      timeout?: number
-    },
+    public contract: APIContract,
+    ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>
   ) {
-    super({
-      ...options,
-      transformer: new RuntimeContractTransformer(contract),
-    })
+    super(...args)
 
-    const callers = {} as any
+    this.transformer = new RuntimeContractTransformer(this.contract)
 
-    for (const [namespaceKey, namespace] of Object.entries(
-      contract.namespaces,
-    )) {
-      namespace.procedures
+    const namespaces = Object.entries(this.contract.namespaces)
+    for (const [namespaceKey, namespace] of namespaces) {
+      this.callers[namespaceKey] = {} as any
 
-      callers[namespaceKey] = {} as any
+      const procedures = Object.entries(namespace.procedures)
 
-      for (const [procedureKey, procedure] of Object.entries(
-        namespace.procedures,
-      )) {
-        callers[namespaceKey][procedureKey] = (payload, options) =>
+      for (const [procedureKey, procedure] of procedures) {
+        this.callers[namespaceKey][procedureKey] = (payload, options) =>
           this._call(namespace.name, procedure.name, payload, {
-            timeout: namespace.timeout,
+            timeout: procedure.timeout || namespace.timeout || options.timeout,
             ...options,
           })
       }
     }
-    this.#callers = callers
-  }
-
-  get call() {
-    return this.#callers
   }
 }

package/src/static.ts

@@ -1,42 +1,21 @@
 import type { TAnyAPIContract } from '@nmtjs/contract'
-import {
-  type BaseClientFormat,
-  ProtocolBaseClient,
-  type ProtocolTransport,
-} from '@nmtjs/protocol/client'
-
-import type {
-  ClientCallers,
-  ResolveAPIContract,
-  ResolveClientEvents,
-  StaticInputContractTypeProvider,
-  StaticOutputContractTypeProvider,
-} from './types.ts'
+import { ProtocolBaseTransformer } from '@nmtjs/protocol/client'
+import { BaseClient } from './common.ts'
 
 export class StaticClient<
   APIContract extends TAnyAPIContract,
-  ResolvedAPIContract extends ResolveAPIContract<
-    APIContract,
-    StaticInputContractTypeProvider,
-    StaticOutputContractTypeProvider
-  > = ResolveAPIContract<
-    APIContract,
-    StaticInputContractTypeProvider,
-    StaticOutputContractTypeProvider
-  >,
-> extends ProtocolBaseClient<ResolveClientEvents<ResolvedAPIContract>> {
-  _!: ResolvedAPIContract
+  SafeCall extends boolean = false,
+> extends BaseClient<APIContract, SafeCall> {
+  protected transformer: ProtocolBaseTransformer
 
-  #callers: ClientCallers<ResolvedAPIContract>
+  constructor(
+    ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>
+  ) {
+    super(...args)
 
-  constructor(options: {
-    transport: ProtocolTransport
-    format: BaseClientFormat
-    timeout?: number
-  }) {
-    super(options)
+    this.transformer = new ProtocolBaseTransformer()
 
-    this.#callers = new Proxy(Object(), {
+    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
@@ -49,19 +28,13 @@ export class StaticClient<
             // FIXME: this basically makes "then" a reserved word
             if (procedure === 'then') return target
             return (payload, options) =>
-              this._call(
-                namespace as string,
-                procedure as string,
-                payload,
-                options,
-              )
+              this._call(namespace as string, procedure as string, payload, {
+                ...options,
+                timeout: options?.timeout ?? this.options.timeout,
+              })
           },
         })
       },
     })
   }
-
-  get call() {
-    return this.#callers
-  }
 }

package/src/types.ts

@@ -1,10 +1,11 @@
-import type { CallTypeProvider, TypeProvider } from '@nmtjs/common'
+import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common'
 import type { TAnyAPIContract } from '@nmtjs/contract'
 import type {
   ProtocolBaseClientCallOptions,
+  ProtocolError,
   ProtocolServerStreamInterface,
 } from '@nmtjs/protocol/client'
-import type { InputType, OutputType } from '@nmtjs/protocol/common'
+import type { InputType, OutputType } from '@nmtjs/protocol/client'
 import type { BaseTypeAny, NeverType, t } from '@nmtjs/type'
 
 export interface StaticInputContractTypeProvider extends TypeProvider {
@@ -54,7 +55,7 @@ export type ResolveAPIContract<
               >
             >
           : {
-              response: OutputType<
+              result: OutputType<
                 CallTypeProvider<
                   OutputTypeProvider,
                   C['namespaces'][N]['procedures'][P]['output']
@@ -86,26 +87,43 @@ export type ResolveClientEvents<
   C extends ResolveAPIContract = ResolveAPIContract,
 > = {
   [N in keyof C]: {
-    [KE in keyof C[N]['events']]: C[N]['events'][KE]['payload']
+    [KE in keyof C[N]['events'] as `${Extract<N, string>}/${Extract<KE, string>}`]: [
+      C[N]['events'][KE]['payload'],
+    ]
   }
-}
+}[keyof C]
 
-export type ClientCallers<Resolved extends ResolveAPIContract> = {
+export type ClientCallers<
+  Resolved extends ResolveAPIContract,
+  SafeCall extends boolean,
+> = {
   [N in keyof Resolved]: {
     [P in keyof Resolved[N]['procedures']]: (
       ...args: Resolved[N]['procedures'][P]['input'] extends NeverType
-        ? [options?: ProtocolBaseClientCallOptions]
+        ? [data?: undefined, options?: Partial<ProtocolBaseClientCallOptions>]
         : undefined extends t.infer.encoded.input<
               Resolved[N]['procedures'][P]['contract']['input']
             >
           ? [
               data?: Resolved[N]['procedures'][P]['input'],
-              options?: ProtocolBaseClientCallOptions,
+              options?: Partial<ProtocolBaseClientCallOptions>,
             ]
           : [
               data: Resolved[N]['procedures'][P]['input'],
-              options?: ProtocolBaseClientCallOptions,
+              options?: Partial<ProtocolBaseClientCallOptions>,
+            ]
+    ) => SafeCall extends true
+      ? Promise<
+          OneOf<
+            [
+              {
+                error?: undefined
+                output: Resolved[N]['procedures'][P]['output']
+              },
+              { error: ProtocolError; output?: undefined },
             ]
-    ) => Promise<Resolved[N]['procedures'][P]['output']>
+          >
+        >
+      : Promise<Resolved[N]['procedures'][P]['output']>
   }
 }