libshv-js 3.3.5 → 3.4.0

package/src/rpcmessage.ts

@@ -1,15 +1,13 @@
-import {type IMap, type Int, isIMap, makeIMap, makeMetaMap, type MetaMap, type RpcValue, RpcValueWithMetaData} from './rpcvalue';
-import {toCpon} from './cpon';
-import {toChainPack} from './chainpack';
+import * as z from './zod';
 
-const TagRequestId = 8;
-const TagShvPath = 9;
-const TagMethod = 10;
-const TagCallerIds = 11;
+export const RPC_MESSAGE_REQUEST_ID = 8;
+export const RPC_MESSAGE_SHV_PATH = 9;
+export const RPC_MESSAGE_METHOD = 10;
+export const RPC_MESSAGE_CALLER_IDS = 11;
 
-const KeyParams = 1;
-const KeyResult = 2;
-const KeyError = 3;
+export const RPC_MESSAGE_PARAMS = 1;
+export const RPC_MESSAGE_RESULT = 2;
+export const RPC_MESSAGE_ERROR = 3;
 
 export const ERROR_CODE = 1;
 export const ERROR_MESSAGE = 2;
@@ -30,169 +28,52 @@ enum ErrorCode {
     NotImplemented = 12,
 }
 
-export type ErrorMap = {
-    [ERROR_CODE]: ErrorCode;
-    [ERROR_MESSAGE]?: string;
-    [ERROR_DATA]?: RpcValue;
-};
-
-class RpcError extends Error {
-    constructor(private readonly err_info: ErrorMap) {
-        super(err_info[ERROR_MESSAGE] ?? 'Unknown RpcError');
-    }
-
-    data() {
-        return this.err_info[ERROR_DATA];
-    }
-}
-
-export class ProtocolError extends Error {}
-
-export class InvalidRequest extends RpcError {}
-export class MethodNotFound extends RpcError {}
-export class InvalidParams extends RpcError {}
-export class InternalError extends RpcError {}
-export class ParseError extends RpcError {}
-export class MethodCallTimeout extends RpcError {}
-export class MethodCallCancelled extends RpcError {}
-export class MethodCallException extends RpcError {}
-export class Unknown extends RpcError {}
-export class LoginRequired extends RpcError {}
-export class UserIDRequired extends RpcError {}
-export class NotImplemented extends RpcError {}
-
-class RpcMessage {
-    value: IMap;
-    meta: MetaMap;
-    constructor(rpc_val?: RpcValue) {
-        if (rpc_val === undefined) {
-            this.value = makeIMap({});
-            this.meta = makeMetaMap({});
-            return;
-        }
-
-        if (!(rpc_val instanceof RpcValueWithMetaData && isIMap(rpc_val.value))) {
-            throw new TypeError(`RpcMessage initialized with a non-IMap: ${toCpon(rpc_val)}`);
-        }
-
-        this.value = rpc_val.value;
-        this.meta = rpc_val.meta;
-    }
-
-    isValid() {
-        return this.shvPath() && (this.isRequest() || this.isResponse || this.isSignal());
-    }
-
-    isRequest(): boolean {
-        return this.requestId() !== undefined && this.method() !== undefined;
-    }
-
-    isResponse(): boolean {
-        return this.requestId() !== undefined && this.method() === undefined;
-    }
-
-    isSignal(): boolean {
-        return this.requestId() === undefined && this.method() !== undefined;
-    }
-
-    requestId(): Int | undefined {
-        return (this.meta[TagRequestId] as Int);
-    }
-
-    setRequestId(id: number) {
-        this.meta[TagRequestId] = id;
-    }
-
-    callerIds(): RpcValue[] | undefined {
-        return this.meta[TagCallerIds] as RpcValue[];
-    }
-
-    setCallerIds(ids: RpcValue[]) {
-        this.meta[TagCallerIds] = ids;
-    }
-
-    shvPath(): string | undefined {
-        return (this.meta[TagShvPath] as string);
-    }
-
-    setShvPath(val: string) {
-        this.meta[TagShvPath] = val;
-    }
-
-    method(): string | undefined {
-        return (this.meta[TagMethod] as string);
-    }
-
-    setMethod(val: string) {
-        this.meta[TagMethod] = val;
-    }
-
-    params() {
-        return this.value[KeyParams];
-    }
-
-    setParams(params: RpcValue) {
-        this.value[KeyParams] = params;
-    }
-
-    resultOrError() {
-        if (Object.hasOwn(this.value, KeyError)) {
-            if (!isIMap(this.value[KeyError])) {
-                return new ProtocolError('Response had an error, but this error was not a map');
-            }
-
-            const error_map = this.value[KeyError];
-            if (typeof error_map[ERROR_CODE] !== 'number') {
-                return new ProtocolError('Response had an error, but this error did not contain at least an error code');
-            }
-
-            const code = error_map[ERROR_CODE] as unknown;
-
-            const ErrorType = (() => {
-                switch (code) {
-                    case ErrorCode.InvalidRequest: return InvalidRequest;
-                    case ErrorCode.MethodNotFound: return MethodNotFound;
-                    case ErrorCode.InvalidParams: return InvalidParams;
-                    case ErrorCode.InternalError: return InternalError;
-                    case ErrorCode.ParseError: return ParseError;
-                    case ErrorCode.MethodCallTimeout: return MethodCallTimeout;
-                    case ErrorCode.MethodCallCancelled: return MethodCallCancelled;
-                    case ErrorCode.MethodCallException: return MethodCallException;
-                    case ErrorCode.Unknown: return Unknown;
-                    case ErrorCode.LoginRequired: return LoginRequired;
-                    case ErrorCode.UserIDRequired: return UserIDRequired;
-                    case ErrorCode.NotImplemented: return NotImplemented;
-                    default: return Unknown;
-                }
-            })();
-
-            return new ErrorType(this.value[KeyError] as unknown as ErrorMap);
-        }
-
-        if (Object.hasOwn(this.value, KeyResult)) {
-            return this.value[KeyResult];
-        }
-
-        return new ProtocolError('Response included neither result nor error');
-    }
-
-    setResult(result: RpcValue) {
-        this.value[KeyResult] = result;
-    }
-
-    setError(error: string) {
-        this.value[KeyError] = error;
-    }
-
-    toCpon() {
-        return toCpon(new RpcValueWithMetaData(this.value, this.meta));
-    }
-
-    toChainPack() {
-        return toChainPack(new RpcValueWithMetaData(this.value, this.meta));
-    }
-}
-
-export type RpcResponse<T = RpcValue> = T | Error;
-
-export {RpcMessage, RpcError, ErrorCode};
+const ErrorMapZod = z.imap({
+    [ERROR_CODE]: z.number(),
+    [ERROR_MESSAGE]: z.string().optional(),
+    [ERROR_DATA]: z.rpcvalue().optional(),
+});
+
+export type ErrorMap = z.infer<typeof ErrorMapZod>;
+
+const RpcRequestMetaZod = z.metamap({
+    [RPC_MESSAGE_REQUEST_ID]: z.number(),
+    [RPC_MESSAGE_METHOD]: z.string(),
+    [RPC_MESSAGE_SHV_PATH]: z.string(),
+});
+
+const RpcRequestValueZod = z.imap({
+    [RPC_MESSAGE_PARAMS]: z.rpcvalue().optional(),
+});
+
+const RpcResponseMetaZod = z.metamap({
+    [RPC_MESSAGE_REQUEST_ID]: z.number(),
+});
+const RpcResponseValueZod = z.imap({
+    [RPC_MESSAGE_RESULT]: z.rpcvalue(),
+}).or(z.imap({
+    [RPC_MESSAGE_ERROR]: ErrorMapZod,
+}));
+
+const RpcSignalMetaZod = z.metamap({
+    [RPC_MESSAGE_SHV_PATH]: z.string(),
+    [RPC_MESSAGE_METHOD]: z.string(),
+});
+const RpcSignalValueZod = z.imap({
+    [RPC_MESSAGE_PARAMS]: z.rpcvalue().optional(),
+});
+
+const RpcRequestZod = z.withMeta(RpcRequestMetaZod, RpcRequestValueZod);
+const RpcResponseZod = z.withMeta(RpcResponseMetaZod, RpcResponseValueZod);
+const RpcSignalZod = z.withMeta(RpcSignalMetaZod, RpcSignalValueZod);
+const RpcMessageZod = z.union([RpcRequestZod, RpcResponseZod, RpcSignalZod]);
+export type RpcRequest = z.infer<typeof RpcRequestZod>;
+export type RpcResponse = z.infer<typeof RpcResponseZod>;
+export type RpcSignal = z.infer<typeof RpcSignalZod>;
+export type RpcMessage = z.infer<typeof RpcMessageZod>;
+
+export const isSignal = (message: RpcMessage): message is RpcSignal => !(RPC_MESSAGE_REQUEST_ID in message.meta) && RPC_MESSAGE_METHOD in message.meta;
+export const isRequest = (message: RpcMessage): message is RpcRequest => RPC_MESSAGE_REQUEST_ID in message.meta && RPC_MESSAGE_METHOD in message.meta;
+export const isResponse = (message: RpcMessage): message is RpcResponse => RPC_MESSAGE_REQUEST_ID in message.meta && !(RPC_MESSAGE_METHOD in message.meta);
+
+export {RpcMessageZod, ErrorCode};

package/src/rpcvalue.ts

@@ -50,10 +50,11 @@ export type Blob = ArrayBuffer;
 export type ShvString = string;
 export type DateTime = Date & {utc_offset?: number};
 const withOffset = (date: Date, utc_offset?: number) => {
-    const cloned_date: DateTime = new Date(date.getTime());
-    cloned_date.utc_offset = utc_offset;
-    return cloned_date;
+    const clonedDate: DateTime = new Date(date.getTime());
+    clonedDate.utc_offset = utc_offset;
+    return clonedDate;
 };
+
 export type List = RpcValue[];
 
 const shvMapType = Symbol('shvMapType');
@@ -92,9 +93,11 @@ type MetaMap<T extends Record<string | number, RpcValue> = Record<string | numbe
     [shvMapType]: 'metamap';
 };
 
-const isShvMap = (x: RpcValue): x is ShvMap => typeof x === 'object' && (x as ShvMap)[shvMapType] === 'map';
+const isShvMap = (x: unknown): x is ShvMap => typeof x === 'object' && (x as ShvMap)[shvMapType] === 'map';
+
+const isIMap = (x: unknown): x is IMap => typeof x === 'object' && (x as IMap)[shvMapType] === 'imap';
 
-const isIMap = (x: RpcValue): x is IMap => typeof x === 'object' && (x as IMap)[shvMapType] === 'imap';
+const isMetaMap = (x: unknown): x is IMap => typeof x === 'object' && (x as MetaMap)[shvMapType] === 'metamap';
 
 const makeMetaMap = <T extends Record<string | number, RpcValue> = Record<string | number, RpcValue>, U extends Record<number, RpcValue> = Omit<T, typeof shvMapType>>(x: U = {} as U): MetaMap<U> => ({
     ...x,
@@ -111,10 +114,10 @@ const makeMap = <T extends Record<string, RpcValue> = Record<string, RpcValue>,
     [shvMapType]: 'map',
 });
 
-class RpcValueWithMetaData {
-    constructor(public value: RpcValueType, public meta: MetaMap) {}
+class RpcValueWithMetaData<MetaSchema extends MetaMap = MetaMap, ValueSchema extends RpcValueType = RpcValueType> {
+    constructor(public meta: MetaSchema, public value: ValueSchema) {}
 }
 
 export type RpcValue = RpcValueType | RpcValueWithMetaData;
 
-export {shvMapType, Decimal, Double, type IMap, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, makeMap, makeIMap, makeMetaMap, isIMap, isShvMap};
+export {shvMapType, Decimal, Double, type IMap, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, makeMap, makeIMap, makeMetaMap, isIMap, isMetaMap, isShvMap};

package/src/ws-client.ts

@@ -1,29 +1,33 @@
-import {ChainPackReader, ChainpackProtocolType, ChainPackWriter} from './chainpack';
-import {type CponReader, CponProtocolType} from './cpon';
-import {ERROR_MESSAGE, ErrorCode, ERROR_CODE, RpcMessage, type RpcResponse, MethodCallTimeout} from './rpcmessage';
-import {type RpcValue, type Null, type Int, type IMap, type ShvMap, makeMap, makeIMap} from './rpcvalue';
+import {ChainPackReader, CHAINPACK_PROTOCOL_TYPE, ChainPackWriter, toChainPack} from './chainpack';
+import {type CponReader, CPON_PROTOCOL_TYPE, toCpon} from './cpon';
+import {ERROR_MESSAGE, ErrorCode, ERROR_CODE, RpcMessageZod, type RpcMessage, isSignal, isRequest, type RpcRequest, isResponse, ERROR_DATA, type ErrorMap, RPC_MESSAGE_METHOD, RPC_MESSAGE_SHV_PATH, RPC_MESSAGE_REQUEST_ID, RPC_MESSAGE_PARAMS, RPC_MESSAGE_ERROR, RPC_MESSAGE_RESULT} from './rpcmessage';
+import {type RpcValue, type Null, type Int, type IMap, type ShvMap, makeMap, makeIMap, RpcValueWithMetaData, makeMetaMap} from './rpcvalue';
 
 const DEFAULT_TIMEOUT = 5000;
+const DEFAULT_PING_INTERVAL = 30 * 1000;
 
 const dataToRpcValue = (buff: ArrayBuffer) => {
     const rd: ChainPackReader | CponReader = new ChainPackReader(buff);
     rd.readUIntData();
     const proto = rd.ctx.getByte();
     switch (proto) {
-        case ChainpackProtocolType:
+        case CHAINPACK_PROTOCOL_TYPE:
             break;
-        case CponProtocolType:
+        case CPON_PROTOCOL_TYPE:
             throw new Error('CPON protocol type is not supported anymore');
         default:
             throw new Error(`Unsupported protocol type ${proto}`);
     }
-    const rpc_val = rd.read();
-    return rpc_val;
+
+    const rpcVal = rd.read();
+    return rpcVal;
 };
 
 type SubscriptionCallback = (path: string, method: string, param?: RpcValue) => void;
 
-type RpcResponseResolver = (rpc_msg: RpcResponse) => void;
+type ResultOrError<T = RpcValue> = T | Error;
+
+type RpcResponseResolver = (rpc_msg: ResultOrError) => void;
 
 type Subscription = {
     subscriber: string;
@@ -39,11 +43,12 @@ type WsClientOptions = {
     password: string;
     loginType?: 'PLAIN' | 'AZURE';
     timeout?: number;
+    pingInterval?: number;
     wsUri: string;
     onConnected: () => void;
     onConnectionFailure: (error: Error) => void;
     onDisconnected: () => void;
-    onRequest: (rpc_msg: RpcMessage) => void;
+    onRequest: (rpc_msg: RpcRequest) => void;
 };
 
 type LsResult = string[];
@@ -72,8 +77,35 @@ type DirResult = Array<IMap<{
     [DIR_EXTRA]: ShvMap;
 }>>;
 
+class RpcError extends Error {
+    constructor(private readonly err_info: ErrorMap) {
+        super(err_info[ERROR_MESSAGE] ?? 'Unknown RpcError');
+    }
+
+    data() {
+        return this.err_info[ERROR_DATA];
+    }
+}
+
+class ProtocolError extends Error {}
+
+class InvalidRequest extends RpcError {}
+class MethodNotFound extends RpcError {}
+class InvalidParams extends RpcError {}
+class InternalError extends RpcError {}
+class ParseError extends RpcError {}
+class MethodCallTimeout extends RpcError {}
+class MethodCallCancelled extends RpcError {}
+class MethodCallException extends RpcError {}
+class Unknown extends RpcError {}
+class LoginRequired extends RpcError {}
+class UserIDRequired extends RpcError {}
+class NotImplemented extends RpcError {}
+
 class WsClient {
     requestId = 1;
+    pingTimerId = -1;
+
     rpcHandlers: Array<{
         resolve: RpcResponseResolver;
         timeout_handle: number;
@@ -92,6 +124,7 @@ class WsClient {
     onDisconnected: WsClientOptions['onDisconnected'];
     onRequest: WsClientOptions['onRequest'];
     timeout: WsClientOptions['timeout'];
+    pingInterval: WsClientOptions['pingInterval'];
 
     constructor(options: WsClientOptions) {
         if (typeof options !== 'object') {
@@ -108,6 +141,7 @@ class WsClient {
         this.websocket = new WebSocket(options.wsUri);
         this.websocket.binaryType = 'arraybuffer';
 
+        this.pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
         this.onConnected = options.onConnected ?? (() => {/* nothing */});
         this.onConnectionFailure = options.onConnectionFailure ?? (() => {/* nothing */});
         this.onDisconnected = options.onDisconnected ?? (() => {/* nothing */});
@@ -121,11 +155,13 @@ class WsClient {
                 this.logDebug('FAILURE: couldn\'t perform initial handshake', error.message);
                 this.onConnectionFailure(error);
             };
+
             this.callRpcMethod(undefined, 'hello').then(response => {
                 if (response instanceof Error) {
                     handleConnectionError(response);
                     return;
                 }
+
                 const params = makeMap({
                     login: makeMap({
                         password: this.password,
@@ -142,8 +178,12 @@ class WsClient {
                     handleConnectionError(response);
                     return;
                 }
+
                 this.logDebug('SUCCESS: connected to shv broker');
                 this.onConnected();
+                this.pingTimerId = window.setInterval(() => {
+                    this.sendPing();
+                }, this.pingInterval);
             }).catch(() => {
                 this.logDebug('FAILURE: couldn\' connected to shv broker');
             });
@@ -153,34 +193,61 @@ class WsClient {
             this.logDebug('DISCONNECTED');
             this.subscriptions.length = 0;
             this.onDisconnected();
+            window.clearInterval(this.pingTimerId);
         });
 
-        this.websocket.addEventListener('message', evt => {
-            const rpc_val = dataToRpcValue(evt.data);
-            const rpc_msg = new RpcMessage(rpc_val);
-            this.logDebug(`message received: ${rpc_msg.toCpon()}`);
+        this.websocket.addEventListener('message', (evt: MessageEvent<ArrayBuffer>) => {
+            const rpcVal = dataToRpcValue(evt.data);
+            const rpcMsg = RpcMessageZod.parse(rpcVal);
+            this.logDebug(`message received: ${toCpon(rpcMsg)}`);
 
-            if (rpc_msg.isSignal()) {
+            if (isSignal(rpcMsg)) {
                 for (const sub of this.subscriptions) {
-                    const shv_path = rpc_msg.shvPath();
-                    const method = rpc_msg.method();
+                    const shvPath = rpcMsg.meta[RPC_MESSAGE_SHV_PATH];
+                    const method = rpcMsg.meta[RPC_MESSAGE_METHOD];
 
-                    if (shv_path?.startsWith(sub.path) && method === sub.method) {
-                        sub.callback(shv_path, method, rpc_msg.params());
+                    if (shvPath.startsWith(sub.path) && method === sub.method) {
+                        sub.callback(shvPath, method, rpcMsg.value[RPC_MESSAGE_PARAMS]);
                     }
                 }
-            } else if (rpc_msg.isRequest()) {
-                this.onRequest(rpc_msg);
-            } else if (rpc_msg.isResponse()) {
-                const requestId = rpc_msg.requestId();
-                if (requestId === undefined) {
-                    throw new Error('got RpcResponse without requestId');
-                }
+            } else if (isRequest(rpcMsg)) {
+                this.onRequest(rpcMsg);
+            } else if (isResponse(rpcMsg)) {
+                const requestId = rpcMsg.meta[RPC_MESSAGE_REQUEST_ID];
 
                 if (this.rpcHandlers[Number(requestId)] !== undefined) {
                     const handler = this.rpcHandlers[Number(requestId)];
                     clearTimeout(handler.timeout_handle);
-                    handler.resolve(rpc_msg.resultOrError());
+                    handler.resolve((() => {
+                        if (RPC_MESSAGE_ERROR in rpcMsg.value) {
+                            const code = rpcMsg.value[RPC_MESSAGE_ERROR][ERROR_CODE] as unknown;
+                            const ErrorTypeCtor = (() => {
+                                switch (code) {
+                                    case ErrorCode.InvalidRequest: return InvalidRequest;
+                                    case ErrorCode.MethodNotFound: return MethodNotFound;
+                                    case ErrorCode.InvalidParams: return InvalidParams;
+                                    case ErrorCode.InternalError: return InternalError;
+                                    case ErrorCode.ParseError: return ParseError;
+                                    case ErrorCode.MethodCallTimeout: return MethodCallTimeout;
+                                    case ErrorCode.MethodCallCancelled: return MethodCallCancelled;
+                                    case ErrorCode.MethodCallException: return MethodCallException;
+                                    case ErrorCode.Unknown: return Unknown;
+                                    case ErrorCode.LoginRequired: return LoginRequired;
+                                    case ErrorCode.UserIDRequired: return UserIDRequired;
+                                    case ErrorCode.NotImplemented: return NotImplemented;
+                                    default: return Unknown;
+                                }
+                            })();
+
+                            return new ErrorTypeCtor(rpcMsg.value[RPC_MESSAGE_ERROR]);
+                        }
+
+                        if (RPC_MESSAGE_RESULT in rpcMsg.value) {
+                            return rpcMsg.value[RPC_MESSAGE_RESULT];
+                        }
+
+                        return new ProtocolError('Response included neither result nor error');
+                    })());
                     // eslint-disable-next-line @typescript-eslint/no-array-delete, @typescript-eslint/no-dynamic-delete
                     delete this.rpcHandlers[Number(requestId)];
                 }
@@ -193,28 +260,29 @@ class WsClient {
         });
     }
 
-    callRpcMethod(shv_path: '.broker/currentClient', method: 'accessGrantForMethodCall', params: [string, string]): Promise<RpcResponse<string>>;
-    callRpcMethod(shv_path: string | undefined, method: 'dir', params?: RpcValue): Promise<RpcResponse<DirResult>>;
-    callRpcMethod(shv_path: string | undefined, method: 'ls', params?: RpcValue): Promise<RpcResponse<LsResult>>;
-    callRpcMethod(shv_path: string | undefined, method: string, params?: RpcValue): Promise<RpcResponse>;
-    callRpcMethod(shv_path: string | undefined, method: string, params?: RpcValue) {
-        const rq = new RpcMessage();
-        const rq_id = this.requestId++;
-        rq.setRequestId(rq_id);
-        if (shv_path !== undefined) {
-            rq.setShvPath(shv_path);
-        }
-        rq.setMethod(method);
-        if (params !== undefined) {
-            rq.setParams(params);
-        }
+    callRpcMethod(shv_path: '.broker/currentClient', method: 'accessGrantForMethodCall', params: [string, string]): Promise<ResultOrError<string>>;
+    callRpcMethod(shv_path: string | undefined, method: 'dir', params?: RpcValue): Promise<ResultOrError<DirResult>>;
+    callRpcMethod(shv_path: string | undefined, method: 'ls', params?: RpcValue): Promise<ResultOrError<LsResult>>;
+    callRpcMethod(shv_path: string | undefined, method: string, params?: RpcValue): Promise<ResultOrError>;
+    callRpcMethod(shv_path: string | undefined, method: string, params?: RpcValue): Promise<ResultOrError> {
+        const rqId = this.requestId++;
+        const rq: RpcRequest = new RpcValueWithMetaData(makeMetaMap({
+            [RPC_MESSAGE_REQUEST_ID]: rqId,
+            [RPC_MESSAGE_METHOD]: method ?? '',
+            [RPC_MESSAGE_SHV_PATH]: shv_path ?? '',
+        }), makeIMap({
+            [RPC_MESSAGE_PARAMS]: params,
+        }),
+        );
+
         this.sendRpcMessage(rq);
 
-        const promise = new Promise<RpcResponse>(resolve => {
-            this.rpcHandlers[rq_id] = {resolve, timeout_handle: self.setTimeout(() => {
+        const promise = new Promise<ResultOrError>(resolve => {
+            this.rpcHandlers[rqId] = {resolve, timeout_handle: self.setTimeout(() => {
                 resolve(new MethodCallTimeout(makeIMap({
                     [ERROR_CODE]: ErrorCode.MethodCallTimeout,
                     [ERROR_MESSAGE]: `Shv call timeout after: ${this.timeout} msec.`,
+                    [ERROR_DATA]: undefined,
                 })));
             }, this.timeout)};
         });
@@ -223,23 +291,24 @@ class WsClient {
     }
 
     sendRpcMessage(rpc_msg: RpcMessage) {
-        if (this.websocket && this.websocket.readyState === 1) {
-            this.logDebug('sending rpc message:', rpc_msg.toCpon());
-            const msg_data = new Uint8Array(rpc_msg.toChainPack());
+        if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+            this.logDebug('sending rpc message:', toCpon(rpc_msg));
+            const msgData = new Uint8Array(toChainPack(rpc_msg));
 
             const wr = new ChainPackWriter();
-            wr.writeUIntData(msg_data.length + 1);
-            const dgram = new Uint8Array(wr.ctx.length + 1 + msg_data.length);
+            wr.writeUIntData(msgData.length + 1);
+            const dgram = new Uint8Array(wr.ctx.length + 1 + msgData.length);
             let ix = 0;
             for (let i = 0; i < wr.ctx.length; i++) {
                 dgram[ix++] = wr.ctx.data[i];
             }
 
-            dgram[ix++] = ChainpackProtocolType;
+            dgram[ix++] = CHAINPACK_PROTOCOL_TYPE;
 
-            for (const msg_datum of msg_data) {
-                dgram[ix++] = msg_datum;
+            for (const msgDatum of msgData) {
+                dgram[ix++] = msgDatum;
             }
+
             this.logDebug(`sending ${dgram.length} bytes of data`);
             this.websocket.send(dgram.buffer);
         }
@@ -250,6 +319,7 @@ class WsClient {
             this.logDebug(`Already subscribed {$path}:${method} for subscriber ${subscriber}`);
             return;
         }
+
         // If this path:method has not been subscribed on the broker, do it now
         if (!this.subscriptions.some(val => val.path === path && val.method === method)) {
             this.callRpcMethod('.broker/app', 'subscribe', makeMap({
@@ -258,6 +328,7 @@ class WsClient {
                 this.logDebug(`Couldn't subscribe to ${path}, ${method}`);
             });
         }
+
         this.subscriptions.push({
             subscriber,
             path,
@@ -272,11 +343,13 @@ class WsClient {
             this.logDebug(`No such subscription ${path}:${method} for subscriber ${subscriber}`);
             return;
         }
+
         this.subscriptions.splice(idx, 1);
         // Unsubscribe on the broker only if there are no other subscriptions of this path:method
         if (this.subscriptions.some(val => val.path === path && val.method === method)) {
             return;
         }
+
         this.callRpcMethod('.broker/app', 'unsubscribe', makeMap({
             method, path,
         })).catch(() => {
@@ -284,6 +357,12 @@ class WsClient {
         });
     }
 
+    sendPing() {
+        this.callRpcMethod('.broker/app', 'ping').catch((error: unknown) => {
+            console.log('Failed to send ping:', error);
+        });
+    }
+
     accessGrantForMethodCall(path: string, method: string) {
         return this.callRpcMethod('.broker/currentClient', 'accessGrantForMethodCall', [path, method]);
     }

package/src/zod.ts

@@ -1,11 +1,35 @@
 import {z, type ZodType} from 'zod';
-import {type IMap, isIMap, isShvMap, type RpcValue, type ShvMap, UInt} from './rpcvalue';
+import {Decimal, Double, type IMap, isIMap, isMetaMap, isShvMap, type MetaMap, type RpcValue, type RpcValueType, RpcValueWithMetaData, type ShvMap, UInt} from './rpcvalue';
 
-export const map = <T extends Record<string, ZodType<any, any, any>>>(schema: T) => z.custom<ShvMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => isShvMap(data) && z.object(schema).safeParse(data).success);
+export const map = <T extends Record<string, ZodType<any, any, any>>>(schema?: T) => z.custom<ShvMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => isShvMap(data) && (schema === undefined || z.object(schema).safeParse(data).success));
 export const recmap = <T extends ZodType<any, any, any>>(schema: T) => z.custom<ShvMap<Record<string, z.infer<T>>>>((data: RpcValue) => isShvMap(data) && z.record(z.string(), schema).safeParse(data).success);
-export const imap = <T extends Record<string, ZodType<any, any, any>>>(schema: T) => z.custom<IMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => isIMap(data) && z.object(schema).safeParse(data).success);
+export const imap = <T extends Record<string, ZodType<any, any, any>>>(schema?: T) => z.custom<IMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => isIMap(data) && (schema === undefined || z.object(schema).safeParse(data).success));
+export const metamap = <T extends Record<string | number, ZodType<any, any, any>>>(schema?: T) => z.custom<MetaMap<{[K in keyof T]: z.infer<T[K]>}>>((data: RpcValue) => isMetaMap(data) && (schema === undefined || z.object(schema).safeParse(data).success));
 export const int = () => z.number();
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-arguments -- Zod needs the default argument, otherwise it'll infer as UInt<unknown>
 export const uint = () => z.instanceof(UInt<number>);
 
+const withMetaInstanceParser = z.instanceof(RpcValueWithMetaData);
+export const rpcvalue = () => z.union([
+    z.undefined(),
+    z.boolean(),
+    z.number(),
+    uint(),
+    z.instanceof(Double),
+    z.instanceof(Decimal),
+    z.instanceof(ArrayBuffer),
+    z.string(),
+    z.date(),
+    z.array(z.any()),
+    map(),
+    imap(),
+    withMetaInstanceParser,
+]);
+
+export const withMeta = <MetaSchema extends MetaMap, ValueSchema extends RpcValueType>(metaParser: ZodType<MetaSchema, any, any>, valueParser: ZodType<ValueSchema, any, any>) =>
+    z.custom<RpcValueWithMetaData<z.infer<typeof metaParser>, z.infer<typeof valueParser>>>((data: any) => withMetaInstanceParser.and(z.object({
+        meta: metaParser,
+        value: valueParser,
+    })).safeParse(data).success);
+
 export * from 'zod';