libshv-js 3.7.0 → 3.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libshv-js",
-  "version": "3.7.0",
+  "version": "3.9.0",
   "description": "Typescript implementation of libshv",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/src/chainpack.ts

@@ -416,7 +416,8 @@ class ChainPackWriter {
                 this.writeDateTime(rpcVal);
                 break;
             case rpcVal instanceof Double:
-                throw new Error('writing doubles not implemented');
+                this.writeDouble(rpcVal);
+                break;
             case typeof rpcVal === 'object':
                 switch (rpcVal[shvMapType]) {
                     case 'imap':
@@ -575,6 +576,19 @@ class ChainPackWriter {
         this.writeUIntDataHelper(bi, 'UInt');
     }
 
+    writeDouble(double: Double) {
+        this.ctx.putByte(PackingSchema.Double);
+        const buffer = new ArrayBuffer(8);
+        const view = new DataView(buffer);
+
+        view.setFloat64(0, double.value, true);
+
+        const data = new Uint8Array(buffer);
+        for (let i = 0; i < 8; i++) {
+            this.ctx.putByte(data[i]);
+        }
+    }
+
     writeList(lst: RpcValue[]) {
         this.ctx.putByte(PackingSchema.List);
         for (const element of lst) {

package/src/rpcmessage.ts

@@ -8,6 +8,7 @@ export const RPC_MESSAGE_CALLER_IDS = 11;
 export const RPC_MESSAGE_PARAMS = 1;
 export const RPC_MESSAGE_RESULT = 2;
 export const RPC_MESSAGE_ERROR = 3;
+export const RPC_MESSAGE_DELAY = 4;
 
 export const ERROR_CODE = 1;
 export const ERROR_MESSAGE = 2;
@@ -51,10 +52,13 @@ const RpcResponseMetaZod = z.metamap({
     [RPC_MESSAGE_CALLER_IDS]: z.int().or(z.array(z.int())).optional(),
     [RPC_MESSAGE_REQUEST_ID]: z.number(),
 });
+
 const RpcResponseValueZod = z.imap({
     [RPC_MESSAGE_RESULT]: z.rpcvalue(),
 }).or(z.imap({
     [RPC_MESSAGE_ERROR]: ErrorMapZod,
+})).or(z.imap({
+    [RPC_MESSAGE_DELAY]: z.double(),
 }));
 
 const RpcSignalMetaZod = z.metamap({
@@ -71,6 +75,7 @@ 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 RpcResponseValue = z.infer<typeof RpcResponseValueZod>;
 export type RpcSignal = z.infer<typeof RpcSignalZod>;
 export type RpcMessage = z.infer<typeof RpcMessageZod>;
 

package/src/ws-client.ts

@@ -1,7 +1,7 @@
 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, RPC_MESSAGE_CALLER_IDS} from './rpcmessage';
-import {type RpcValue, type Null, type Int, type IMap, type ShvMap, makeMap, makeIMap, RpcValueWithMetaData, makeMetaMap} from './rpcvalue';
+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, RPC_MESSAGE_CALLER_IDS, RpcResponseValue, RPC_MESSAGE_DELAY} from './rpcmessage';
+import {type RpcValue, type Null, type Int, type IMap, type ShvMap, makeMap, makeIMap, RpcValueWithMetaData, makeMetaMap, Double} from './rpcvalue';
 
 const DEFAULT_TIMEOUT = 5000;
 const DEFAULT_PING_INTERVAL = 30 * 1000;
@@ -58,7 +58,7 @@ type WsClientOptionsLogin = WsClientOptionsCommon & {
     onConnected: () => void;
     onConnectionFailure: (error: Error) => void;
     onDisconnected: () => void;
-    onRequest: (rpc_msg: RpcRequest) => void;
+    onRequest: (shvPath: string, method: string, param: RpcValue, delay: (progress: number) => void) => Promise<RpcValue>;
 };
 
 type WsClientOptionsWorkflows = WsClientOptionsCommon & {
@@ -95,7 +95,7 @@ type DirResult = Array<IMap<{
 }>>;
 
 class RpcError extends Error {
-    constructor(private readonly err_info: ErrorMap) {
+    constructor(readonly err_info: ErrorMap) {
         super(err_info[ERROR_MESSAGE] ?? 'Unknown RpcError');
     }
 
@@ -104,18 +104,38 @@ class RpcError 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 {}
+const makeErrInfo = (errInfoOrMsg: ErrorMap | string, code: ErrorCode) => {
+    if (typeof errInfoOrMsg === 'object') {
+        return errInfoOrMsg;
+    }
+
+    return makeIMap({
+        [ERROR_CODE]: code,
+        [ERROR_MESSAGE]: errInfoOrMsg,
+        [ERROR_DATA]: undefined,
+    });
+};
+
+const createErrorClass = (code: ErrorCode) => class extends RpcError {
+    constructor(errInfoOrMsg: ErrorMap | string) {
+        super(makeErrInfo(errInfoOrMsg, code));
+    }
+};
+
+/* eslint-disable @typescript-eslint/naming-convention */
+export const InvalidRequest = createErrorClass(ErrorCode.InvalidRequest);
+export const MethodNotFound = createErrorClass(ErrorCode.MethodNotFound);
+export const InvalidParams = createErrorClass(ErrorCode.InvalidParams);
+export const InternalError = createErrorClass(ErrorCode.InternalError);
+export const ParseError = createErrorClass(ErrorCode.ParseError);
+export const MethodCallTimeout = createErrorClass(ErrorCode.MethodCallTimeout);
+export const MethodCallCancelled = createErrorClass(ErrorCode.MethodCallCancelled);
+export const MethodCallException = createErrorClass(ErrorCode.MethodCallException);
+export const Unknown = createErrorClass(ErrorCode.Unknown);
+export const LoginRequired = createErrorClass(ErrorCode.LoginRequired);
+export const UserIDRequired = createErrorClass(ErrorCode.UserIDRequired);
+export const NotImplemented = createErrorClass(ErrorCode.NotImplemented);
+/* eslint-enable @typescript-eslint/naming-convention */
 
 class WsClient {
     private requestId = 1;
@@ -140,7 +160,7 @@ class WsClient {
         this.websocket = new WebSocket(options.wsUri);
         this.websocket.binaryType = 'arraybuffer';
 
-        this.websocket.addEventListener('message', (evt: MessageEvent<ArrayBuffer>) => {
+        this.websocket.addEventListener('message', async (evt: MessageEvent<ArrayBuffer>) => {
             const rpcVal = dataToRpcValue(evt.data);
             const rpcMsg = RpcMessageZod.parse(rpcVal);
             this.logDebug(`message received: ${toCpon(rpcMsg)}`);
@@ -156,7 +176,43 @@ class WsClient {
                 }
             } else if (isRequest(rpcMsg)) {
                 if ('onRequest' in this.options) {
-                    this.options.onRequest(rpcMsg);
+                    const respond = (value: RpcResponseValue) => {
+                        this.sendRpcMessage(new RpcValueWithMetaData(
+                            makeMetaMap({
+                                [RPC_MESSAGE_CALLER_IDS]: rpcMsg.meta[RPC_MESSAGE_CALLER_IDS],
+                                [RPC_MESSAGE_REQUEST_ID]: rpcMsg.meta[RPC_MESSAGE_REQUEST_ID],
+                            }),
+                            value,
+                        ));
+                    };
+
+                    try {
+                        const sendDelay = (progress: number) => {
+                            respond(makeIMap({
+                                [RPC_MESSAGE_DELAY]: new Double(progress),
+                            }));
+                        };
+
+                        respond(makeIMap({
+                            [RPC_MESSAGE_RESULT]: await this.options.onRequest(rpcMsg.meta[RPC_MESSAGE_SHV_PATH], rpcMsg.meta[RPC_MESSAGE_METHOD], rpcMsg.value[RPC_MESSAGE_PARAMS], sendDelay),
+                        }));
+                    } catch (error: unknown) {
+                        const sendError = (error: RpcError) => {
+                            respond(error.err_info);
+                        };
+
+                        switch (true) {
+                            case error instanceof RpcError:
+                                sendError(error);
+                                break;
+                            case error instanceof Error:
+                                sendError(new InternalError(error.message));
+                                break;
+                            default:
+                                sendError(new InternalError('Unknown error'));
+                                break;
+                        }
+                    }
                 }
             } else if (isResponse(rpcMsg)) {
                 const requestId = rpcMsg.meta[RPC_MESSAGE_REQUEST_ID];