libshv-js 3.12.1 → 3.13.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "libshv-js",
-  "version": "3.12.1",
+  "version": "3.13.0",
   "description": "Typescript implementation of libshv",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "lint": "eslint --format unix src/",
-    "fix": "npm run lint -- --fix"
+    "fix": "npm run lint -- --fix",
+    "typecheck": "tsc --noEmit"
   },
   "author": "Elektroline",
   "repository": {

package/src/rpcmessage.ts

@@ -4,6 +4,7 @@ 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;
+export const RPC_MESSAGE_ACCESS_LEVEL = 17;
 
 export const RPC_MESSAGE_PARAMS = 1;
 export const RPC_MESSAGE_RESULT = 2;
@@ -43,6 +44,7 @@ const RpcRequestMetaZod = z.metamap({
     [RPC_MESSAGE_REQUEST_ID]: z.number(),
     [RPC_MESSAGE_METHOD]: z.string(),
     [RPC_MESSAGE_SHV_PATH]: z.string(),
+    [RPC_MESSAGE_ACCESS_LEVEL]: z.int().gte(0).lte(63).optional(),
 });
 
 const RpcRequestValueZod = z.imap({

package/src/ws-client.ts

@@ -1,6 +1,6 @@
 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, RpcResponseValue, RPC_MESSAGE_DELAY, RPC_MESSAGE_ABORT, RpcSignal, RpcResponse} from './rpcmessage';
+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, RPC_MESSAGE_ABORT, RpcSignal, RpcResponse, RPC_MESSAGE_ACCESS_LEVEL} from './rpcmessage';
 import {type RpcValue, type Null, type Int, type IMap, type ShvMap, makeMap, makeIMap, RpcValueWithMetaData, makeMetaMap, Double} from './rpcvalue';
 
 const DEFAULT_TIMEOUT = 5000;
@@ -60,6 +60,14 @@ export class RequestHandler {
     }
 }
 
+type RequestHandlerParams = {
+    shvPath: string;
+    method: string;
+    param: RpcValue;
+    accessLevel: number;
+    delay: (progress: number) => void;
+};
+
 type WsClientOptionsLogin = WsClientOptionsCommon & {
     mountPoint?: string;
     login: Login;
@@ -68,7 +76,7 @@ type WsClientOptionsLogin = WsClientOptionsCommon & {
     onConnected: () => void;
     onConnectionFailure: (error: Error) => void;
     onDisconnected: () => void;
-    onRequest: (shvPath: string, method: string, param: RpcValue, delay: (progress: number) => void) => RpcValue | Promise<RpcValue> | RequestHandler;
+    onRequest: (request: RequestHandlerParams) => RpcValue | Promise<RpcValue> | RequestHandler;
 };
 
 type WsClientOptionsWorkflows = WsClientOptionsCommon & {
@@ -94,7 +102,7 @@ export const DIR_RESULT = 4;
 export const DIR_ACCESS = 5;
 export const DIR_SIGNALS = 6;
 export const DIR_EXTRA = 63;
-type DirResult = Array<IMap<{
+export type DirResult = Array<IMap<{
     [DIR_NAME]: string;
     [DIR_FLAGS]: DirFlags;
     [DIR_PARAM]: string | Null;
@@ -187,7 +195,7 @@ class WsClient {
         delayCallback?: (progress: number) => void;
         timeout_handle: ReturnType<typeof globalThis.setTimeout>;
     }> = [];
-    private requestHandlers: RequestHandler[] = [];
+    private requestHandlers = new Map<number, RequestHandler>();
     private abortedRequests = new Set<number>();
     private readonly subscriptions: Subscription[] = [];
     private readonly websocket: WebSocket;
@@ -236,7 +244,7 @@ class WsClient {
                 };
 
                 if (RPC_MESSAGE_ABORT in request.value) {
-                    const requestHandler = this.requestHandlers[requestId];
+                    const requestHandler = this.requestHandlers.get(requestId);
 
                     if (request.value[RPC_MESSAGE_ABORT] === true && requestHandler?.options.onAbort !== undefined) {
                         this.abortedRequests.add(requestId);
@@ -252,9 +260,22 @@ class WsClient {
                 }
 
                 try {
-                    let result = this.options.onRequest(request.meta[RPC_MESSAGE_SHV_PATH], request.meta[RPC_MESSAGE_METHOD], request.value[RPC_MESSAGE_PARAMS], sendDelay);
+                    const shvPath = request.meta[RPC_MESSAGE_SHV_PATH];
+                    const method = request.meta[RPC_MESSAGE_METHOD];
+                    const accessLevel = request.meta[RPC_MESSAGE_ACCESS_LEVEL];
+                    if (accessLevel === undefined) {
+                        throw new MethodNotFound(`Unknown method ${method} on path ${shvPath}`);
+                    }
+
+                    let result = this.options.onRequest({
+                        shvPath,
+                        method,
+                        param: request.value[RPC_MESSAGE_PARAMS],
+                        accessLevel,
+                        delay: sendDelay,
+                    });
                     if (result instanceof RequestHandler) {
-                        this.requestHandlers[requestId] = result;
+                        this.requestHandlers.set(requestId, result);
                         result = result.options.result;
                     }
 
@@ -269,8 +290,7 @@ class WsClient {
                     }
 
                     if (requestId in this.requestHandlers) {
-                        // eslint-disable-next-line @typescript-eslint/no-array-delete
-                        delete this.requestHandlers[requestId];
+                        this.requestHandlers.delete(requestId);
                     }
                 } catch (error: unknown) {
                     const sendError = (error: RpcError) => {

package/src/zod.ts

@@ -29,7 +29,6 @@ export const map = <T extends Record<string, ZodType<any>>>(schema: T) => implMa
 export const imap = <T extends Record<number, ZodType<any>>>(schema: T) => implMakeMapParser(isIMap, 'imap', 'IMap', z.object(schema));
 export const metamap = <T extends Record<string | number, ZodType<any>>>(schema: T) => implMakeMapParser(isMetaMap, 'metamap', 'MetaMap', z.object(schema));
 export const recmap = <T extends ZodType<any>>(schema: T) => implMakeMapParser(val => isShvMap(val) || isIMap(val), 'map', 'ShvMap', z.record(z.any(), schema));
-export const int = () => z.number();
 
 export const uint = () => z.instanceof(UInt<number>);
 export const double = () => z.instanceof(Double);