@nmtjs/client 0.12.5 → 0.12.7

package/dist/common.d.ts

@@ -0,0 +1,32 @@
+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 { 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>> {
+    readonly transport: ProtocolTransport;
+    readonly options: {
+        timeout: number;
+        autoreconnect?: boolean;
+        safe?: SafeCall;
+    };
+    _: {
+        api: API;
+        safe: SafeCall;
+    };
+    protected abstract transformer: ProtocolBaseTransformer;
+    protected callers: ClientCallers<API, SafeCall>;
+    protected auth: any;
+    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>;
+    setAuth(auth: any): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/common.js

@@ -1,41 +1,45 @@
-import { EventEmitter, ProtocolError } from "@nmtjs/protocol/client";
-export { ErrorCode, ProtocolBlob, TransportType } from "@nmtjs/protocol";
+import { EventEmitter, ProtocolError, } from '@nmtjs/protocol/client';
+export { ErrorCode, ProtocolBlob, TransportType, } from '@nmtjs/protocol';
 export * from "./types.js";
-export class ClientError extends ProtocolError {}
+export class ClientError extends ProtocolError {
+}
 export class BaseClient extends EventEmitter {
-	_;
-	callers;
-	auth;
-	constructor(transport, options) {
-		super();
-		this.transport = transport;
-		this.options = options;
-		if (this.options.autoreconnect) {
-			this.transport.on("disconnected", () => setTimeout(this.connect.bind(this), 1e3));
-		}
-	}
-	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();
-	}
+    transport;
+    options;
+    _;
+    callers;
+    auth;
+    constructor(transport, options) {
+        super();
+        this.transport = transport;
+        this.options = options;
+        if (this.options.autoreconnect) {
+            this.transport.on('disconnected', () => setTimeout(this.connect.bind(this), 1000));
+        }
+    }
+    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/runtime.d.ts

@@ -0,0 +1,16 @@
+import type { TAnyAPIContract } from '@nmtjs/contract';
+import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
+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;
+}
+export declare class RuntimeClient<APIContract extends TAnyAPIContract, SafeCall extends boolean> extends BaseClient<APIContract, SafeCall> {
+    contract: APIContract;
+    protected transformer: RuntimeContractTransformer;
+    constructor(contract: APIContract, ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>);
+}

package/dist/runtime.js

@@ -1,60 +1,63 @@
-import { ErrorCode } from "@nmtjs/protocol";
-import { ProtocolBaseTransformer } from "@nmtjs/protocol/client";
-import { NeemataTypeError, t } from "@nmtjs/type";
+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) {
-		super();
-		this.contract = contract;
-	}
-	decodeEvent(namespace, 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;
-		if (type instanceof t.NeverType) return undefined;
-		return type.decode(payload);
-	}
-	decodeRPCChunk(namespace, procedure, payload) {
-		const type = this.contract.namespaces[namespace].procedures[procedure].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;
-		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 ${namespace}.${procedure}: ${error.message}`, error.issues);
-			}
-			throw error;
-		}
-	}
+    contract;
+    constructor(contract) {
+        super();
+        this.contract = contract;
+    }
+    decodeEvent(namespace, 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;
+        if (type instanceof t.NeverType)
+            return undefined;
+        return type.decode(payload);
+    }
+    decodeRPCChunk(namespace, procedure, payload) {
+        const type = this.contract.namespaces[namespace].procedures[procedure].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;
+        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 ${namespace}.${procedure}: ${error.message}`, error.issues);
+            }
+            throw error;
+        }
+    }
 }
 export class RuntimeClient extends BaseClient {
-	transformer;
-	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.callers = callers;
-	}
+    contract;
+    transformer;
+    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.callers = callers;
+    }
 }
-
-//# sourceMappingURL=runtime.js.map

package/dist/static.d.ts

@@ -0,0 +1,7 @@
+import type { TAnyAPIContract } from '@nmtjs/contract';
+import { ProtocolBaseTransformer } from '@nmtjs/protocol/client';
+import { BaseClient } from './common.ts';
+export declare class StaticClient<APIContract extends TAnyAPIContract, SafeCall extends boolean = false> extends BaseClient<APIContract, SafeCall> {
+    protected transformer: ProtocolBaseTransformer;
+    constructor(...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>);
+}

package/dist/static.js

@@ -1,21 +1,31 @@
-import { ProtocolBaseTransformer } from "@nmtjs/protocol/client";
+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,
-					timeout: options?.timeout ?? this.options.timeout
-				});
-			} });
-		} });
-	}
+    transformer;
+    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,
+                        });
+                    },
+                });
+            },
+        });
+    }
 }
-
-//# sourceMappingURL=static.js.map

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common';
+import type { TAnyAPIContract, TAnyProcedureContract } 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 {
+    output: this['input'] extends BaseTypeAny ? t.infer.encoded.input<this['input']> : never;
+}
+export interface RuntimeInputContractTypeProvider extends TypeProvider {
+    output: this['input'] extends BaseTypeAny ? t.infer.decoded.input<this['input']> : never;
+}
+export interface StaticOutputContractTypeProvider extends TypeProvider {
+    output: this['input'] extends BaseTypeAny ? t.infer.encoded.output<this['input']> : never;
+}
+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 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']>;
+    };
+};

package/dist/types.js

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

package/package.json

@@ -3,39 +3,41 @@
   "type": "module",
   "exports": {
     ".": {
+      "types": "./dist/common.d.ts",
       "import": "./dist/common.js",
-      "types": "./src/common.ts"
+      "module-sync": "./dist/common.js"
     },
     "./runtime": {
+      "types": "./dist/runtime.d.ts",
       "import": "./dist/runtime.js",
-      "types": "./src/runtime.ts"
+      "module-sync": "./dist/runtime.js"
     },
     "./static": {
+      "types": "./dist/static.d.ts",
       "import": "./dist/static.js",
-      "types": "./src/static.ts"
+      "module-sync": "./dist/static.js"
     }
   },
   "peerDependencies": {
-    "@nmtjs/type": "0.12.5",
-    "@nmtjs/contract": "0.12.5",
-    "@nmtjs/common": "0.12.5",
-    "@nmtjs/protocol": "0.12.5"
+    "@nmtjs/type": "0.12.7",
+    "@nmtjs/contract": "0.12.7",
+    "@nmtjs/common": "0.12.7",
+    "@nmtjs/protocol": "0.12.7"
   },
   "devDependencies": {
-    "@nmtjs/contract": "0.12.5",
-    "@nmtjs/common": "0.12.5",
-    "@nmtjs/type": "0.12.5",
-    "@nmtjs/protocol": "0.12.5"
+    "@nmtjs/contract": "0.12.7",
+    "@nmtjs/type": "0.12.7",
+    "@nmtjs/common": "0.12.7",
+    "@nmtjs/protocol": "0.12.7"
   },
   "files": [
-    "src",
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.12.5",
+  "version": "0.12.7",
   "scripts": {
-    "build": "neemata-build --root=./src './**/*.ts'",
+    "build": "tsc",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/common.js.map

@@ -1 +0,0 @@
-{"mappings":"AACA,SACE,cAGA,qBAEK,wBAAwB;AAS/B,SACE,WACA,cAEA,qBACK;AACP,cAAc;AAEd,OAAO,MAAM,oBAAoB,cAAc,CAAE;AAEjD,OAAO,MAAe,mBAYZ,aAAuC;CAC/C;CAMA,AAAU;CACV,AAAU;CAEV,YACWA,WACAC,SAKT;AACA,SAAO;OAPE;OACA;AAQT,MAAI,KAAK,QAAQ,eAAe;AAC9B,QAAK,UAAU,GAAG,gBAAgB,MAChC,WAAW,KAAK,QAAQ,KAAK,KAAK,EAAE,IAAK,CAC1C;EACF;CACF;CAED,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: {\n      timeout: number\n      autoreconnect?: boolean\n      safe?: SafeCall\n    }","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 {\n  ErrorCode,\n  ProtocolBlob,\n  type ProtocolBlobMetadata,\n  TransportType,\n} from '@nmtjs/protocol'\nexport * from './types.ts'\n\nexport class ClientError extends ProtocolError {}\n\nexport abstract class BaseClient<\n  APIContract extends TAnyAPIContract = TAnyAPIContract,\n  SafeCall extends boolean = false,\n  API extends ResolveAPIContract<\n    APIContract,\n    RuntimeInputContractTypeProvider,\n    RuntimeOutputContractTypeProvider\n  > = ResolveAPIContract<\n    APIContract,\n    RuntimeInputContractTypeProvider,\n    RuntimeOutputContractTypeProvider\n  >,\n> extends EventEmitter<ResolveClientEvents<API>> {\n  _!: {\n    api: API\n    safe: SafeCall\n  }\n\n  protected abstract transformer: ProtocolBaseTransformer\n  protected callers!: ClientCallers<API, SafeCall>\n  protected auth: any\n\n  constructor(\n    readonly transport: ProtocolTransport,\n    readonly options: {\n      timeout: number\n      autoreconnect?: boolean\n      safe?: SafeCall\n    },\n  ) {\n    super()\n\n    if (this.options.autoreconnect) {\n      this.transport.on('disconnected', () =>\n        setTimeout(this.connect.bind(this), 1000),\n      )\n    }\n  }\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.map

@@ -1 +0,0 @@
-{"mappings":"AACA,SAAS,iBAAiB,iBAAiB;AAC3C,SAAS,+BAA+B,wBAAwB;AAChE,SAAS,kBAAkB,SAAS,aAAa;AACjD,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,EAAE,UAAW,QAAO;AACxC,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,eAAeF,WAAmBG,WAAmBD,SAAc;EACjE,MAAM,OACJ,KAAK,SAAS,WAAW,WAAW,WAAW,WAAW;AAC5D,OAAK,QAAQ,gBAAgB,EAAE,UAAW,QAAO;AACjD,SAAO,KAAK,OAAO,QAAQ;CAC5B;CAED,UAAUF,WAAmBG,WAAmBD,SAAc;EAC5D,MAAM,OAAO,KAAK,SAAS,WAAW,WAAW,WAAW,WAAW;AACvE,MAAI,gBAAgB,EAAE,UAAW,QAAO;AACxC,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;EACvD,MAAMC,UAAe,CAAE;EACvB,MAAM,aAAa,OAAO,QAAQ,KAAK,SAAS,WAAW;AAC3D,OAAK,MAAM,CAAC,cAAc,UAAU,IAAI,YAAY;AAClD,WAAQ,gBAAgB,CAAE;GAE1B,MAAM,aAAa,OAAO,QAAQ,UAAU,WAAW;AAEvD,QAAK,MAAM,CAAC,cAAc,UAAU,IAAI,YAAY;AAClD,YAAQ,cAAc,gBAAgB,CAAC,SAAS,YAC9C,KAAK,MAAM,UAAU,MAAM,UAAU,MAAM,SAAS;KAClD,SAAS,UAAU,WAAW,UAAU,WAAW,QAAQ;KAC3D,GAAG;IACJ,EAAC;GACL;EACF;AACD,OAAK,UAAU;CAChB;AACF","names":["contract: TAnyAPIContract","namespace: string","event: string","payload: any","procedure: string","contract: APIContract","callers: any"],"sources":["../src/runtime.ts"],"sourcesContent":["import type { TAnyAPIContract } from '@nmtjs/contract'\nimport { ErrorCode } from '@nmtjs/protocol'\nimport { ProtocolBaseTransformer } from '@nmtjs/protocol/client'\nimport { NeemataTypeError, t } 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 t.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 || type instanceof t.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 t.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    const callers: any = {}\n    const namespaces = Object.entries(this.contract.namespaces)\n    for (const [namespaceKey, namespace] of namespaces) {\n      callers[namespaceKey] = {} as any\n\n      const procedures = Object.entries(namespace.procedures)\n\n      for (const [procedureKey, procedure] of procedures) {\n        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    this.callers = callers\n  }\n}\n"],"version":3,"file":"runtime.js"}

package/dist/static.js.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"mappings":"","names":[],"sources":["../src/types.ts"],"sourcesContent":["import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common'\nimport type { TAnyAPIContract, TAnyProcedureContract } from '@nmtjs/contract'\nimport type {\n  InputType,\n  OutputType,\n  ProtocolBaseClientCallOptions,\n  ProtocolError,\n  ProtocolServerStreamInterface,\n} from '@nmtjs/protocol/client'\nimport type { BaseTypeAny, 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 AnyResolvedAPIContract = Record<\n  string,\n  {\n    procedures: Record<\n      string,\n      {\n        contract: TAnyProcedureContract\n        input: any\n        output: any\n      }\n    >\n    events: Record<\n      string,\n      {\n        payload: any\n      }\n    >\n  }\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']]: {\n    procedures: {\n      [P in keyof C['namespaces'][N]['procedures']]: {\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\n          | undefined\n          | t.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']]: {\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 AnyResolvedAPIContract = AnyResolvedAPIContract,\n> = {\n  [N in keyof C]: {\n    [E in keyof C[N]['events'] as `${Extract<N, string>}/${Extract<E, string>}`]: [\n      C[N]['events'][E]['payload'],\n    ]\n  }\n}[keyof C]\n\nexport type ClientCallers<\n  Resolved extends AnyResolvedAPIContract,\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 t.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                output: Resolved[N]['procedures'][P]['output']\n              },\n              { error: ProtocolError },\n            ]\n          >\n        >\n      : Promise<Resolved[N]['procedures'][P]['output']>\n  }\n}\n"],"version":3,"file":"types.js"}

package/src/common.ts

@@ -1,105 +0,0 @@
-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 {
-  ErrorCode,
-  ProtocolBlob,
-  type ProtocolBlobMetadata,
-  TransportType,
-} from '@nmtjs/protocol'
-export * from './types.ts'
-
-export class ClientError extends ProtocolError {}
-
-export 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>> {
-  _!: {
-    api: API
-    safe: SafeCall
-  }
-
-  protected abstract transformer: ProtocolBaseTransformer
-  protected callers!: ClientCallers<API, SafeCall>
-  protected auth: any
-
-  constructor(
-    readonly transport: ProtocolTransport,
-    readonly options: {
-      timeout: number
-      autoreconnect?: boolean
-      safe?: SafeCall
-    },
-  ) {
-    super()
-
-    if (this.options.autoreconnect) {
-      this.transport.on('disconnected', () =>
-        setTimeout(this.connect.bind(this), 1000),
-      )
-    }
-  }
-
-  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,83 +0,0 @@
-import type { TAnyAPIContract } 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.ts'
-
-export class RuntimeContractTransformer extends ProtocolBaseTransformer {
-  protected contract: TAnyAPIContract
-
-  constructor(contract: TAnyAPIContract) {
-    super()
-
-    this.contract = contract
-  }
-
-  decodeEvent(namespace: string, event: string, payload: any) {
-    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
-    if (type instanceof t.NeverType) return undefined
-    return type.decode(payload)
-  }
-
-  decodeRPCChunk(namespace: string, procedure: string, payload: any) {
-    const type =
-      this.contract.namespaces[namespace].procedures[procedure].stream
-    if (!type || type instanceof t.NeverType) return undefined
-    return type.decode(payload)
-  }
-
-  encodeRPC(namespace: string, procedure: string, payload: any) {
-    const type = this.contract.namespaces[namespace].procedures[procedure].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 ${namespace}.${procedure}: ${error.message}`,
-          error.issues,
-        )
-      }
-      throw error
-    }
-  }
-}
-
-export class RuntimeClient<
-  APIContract extends TAnyAPIContract,
-  SafeCall extends boolean,
-> extends BaseClient<APIContract, SafeCall> {
-  protected transformer: RuntimeContractTransformer
-
-  constructor(
-    public contract: APIContract,
-    ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>
-  ) {
-    super(...args)
-
-    this.transformer = new RuntimeContractTransformer(this.contract)
-    const callers: any = {}
-    const namespaces = Object.entries(this.contract.namespaces)
-    for (const [namespaceKey, namespace] of namespaces) {
-      callers[namespaceKey] = {} as any
-
-      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.callers = callers
-  }
-}

package/src/static.ts

@@ -1,40 +0,0 @@
-import type { TAnyAPIContract } from '@nmtjs/contract'
-import { ProtocolBaseTransformer } from '@nmtjs/protocol/client'
-import { BaseClient } from './common.ts'
-
-export class StaticClient<
-  APIContract extends TAnyAPIContract,
-  SafeCall extends boolean = false,
-> extends BaseClient<APIContract, SafeCall> {
-  protected transformer: ProtocolBaseTransformer
-
-  constructor(
-    ...args: ConstructorParameters<typeof BaseClient<APIContract, SafeCall>>
-  ) {
-    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 as string, procedure as string, payload, {
-                ...options,
-                timeout: options?.timeout ?? this.options.timeout,
-              })
-          },
-        })
-      },
-    })
-  }
-}

package/src/types.ts

@@ -1,151 +0,0 @@
-import type { CallTypeProvider, OneOf, TypeProvider } from '@nmtjs/common'
-import type { TAnyAPIContract, TAnyProcedureContract } 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 {
-  output: this['input'] extends BaseTypeAny
-    ? t.infer.encoded.input<this['input']>
-    : never
-}
-
-export interface RuntimeInputContractTypeProvider extends TypeProvider {
-  output: this['input'] extends BaseTypeAny
-    ? t.infer.decoded.input<this['input']>
-    : never
-}
-
-export interface StaticOutputContractTypeProvider extends TypeProvider {
-  output: this['input'] extends BaseTypeAny
-    ? t.infer.encoded.output<this['input']>
-    : never
-}
-
-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 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']>
-  }
-}