libshv-js 3.12.2 → 3.14.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "libshv-js",
-  "version": "3.12.2",
+  "version": "3.14.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,7 +1,9 @@
+import {accessLevelFromAccessString} from './access';
 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';
+import * as z from './zod';
 
 const DEFAULT_TIMEOUT = 5000;
 const DEFAULT_PING_INTERVAL = 30 * 1000;
@@ -60,6 +62,29 @@ export class RequestHandler {
     }
 }
 
+export const LsParamZod = z.undefined().or(z.string());
+export const DirParamZod = z.undefined().or(z.boolean()).or(z.string());
+type DirParam = z.infer<typeof DirParamZod>;
+
+export type DirEntry = IMap<{
+    [DIR_NAME]: string;
+    [DIR_FLAGS]: DirFlags;
+    [DIR_PARAM]: string | Null;
+    [DIR_RESULT]: string | Null;
+    [DIR_ACCESS]: Int;
+    [DIR_SIGNALS]: ShvMap<Record<string, string | Null>>;
+    [DIR_EXTRA]: ShvMap;
+}>;
+
+export type DirResult = DirEntry[];
+
+export type MethodHandler = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paramParser: z.ZodType<any>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handler: (shvPath: string, method: string, params: any, delay: (progress: number) => void) => Promise<RpcValue> | RpcValue | RequestHandler,
+};
+
 type WsClientOptionsLogin = WsClientOptionsCommon & {
     mountPoint?: string;
     login: Login;
@@ -68,7 +93,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: (shvPath: string) => Array<{entry: DirEntry} & MethodHandler> | undefined;
 };
 
 type WsClientOptionsWorkflows = WsClientOptionsCommon & {
@@ -94,15 +119,6 @@ export const DIR_RESULT = 4;
 export const DIR_ACCESS = 5;
 export const DIR_SIGNALS = 6;
 export const DIR_EXTRA = 63;
-type DirResult = Array<IMap<{
-    [DIR_NAME]: string;
-    [DIR_FLAGS]: DirFlags;
-    [DIR_PARAM]: string | Null;
-    [DIR_RESULT]: string | Null;
-    [DIR_ACCESS]: Int;
-    [DIR_SIGNALS]: ShvMap<Record<string, string | Null>>;
-    [DIR_EXTRA]: ShvMap;
-}>>;
 
 class RpcError extends Error {
     constructor(readonly err_info: ErrorMap) {
@@ -216,6 +232,7 @@ class WsClient {
             }
         };
 
+        // eslint-disable-next-line complexity
         const handleRequest = async (request: RpcRequest) => {
             if ('onRequest' in this.options) {
                 const requestId = request.meta[RPC_MESSAGE_REQUEST_ID];
@@ -252,7 +269,78 @@ 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 methodName = request.meta[RPC_MESSAGE_METHOD];
+                    const unhandledMethod = () => {
+                        throw new MethodNotFound(`No such path '${shvPath}' or method '${methodName}' or insufficient access rights.`);
+                    };
+
+                    const accessLevel = request.meta[RPC_MESSAGE_ACCESS_LEVEL];
+                    if (accessLevel === undefined) {
+                        unhandledMethod();
+                        return;
+                    }
+
+                    const methods = this.options.onRequest(shvPath);
+                    if (methods === undefined) {
+                        unhandledMethod();
+                        return;
+                    }
+
+                    const methodDefinition = ((): {entry: DirEntry} & MethodHandler | undefined => {
+                        const dirEntry = makeIMap({
+                            [DIR_NAME]: 'dir',
+                            [DIR_FLAGS]: 0,
+                            [DIR_PARAM]: '',
+                            [DIR_RESULT]: '',
+                            [DIR_ACCESS]: accessLevelFromAccessString('rd'),
+                            [DIR_SIGNALS]: makeMap({}),
+                            [DIR_EXTRA]: makeMap({}),
+                        });
+                        switch (methodName) {
+                            case 'dir':
+                                return {
+                                    entry: dirEntry,
+                                    paramParser: DirParamZod,
+                                    handler(_shvPath, _method, param: DirParam) {
+                                        const methodsResult = [dirEntry, ...methods.map(method => method.entry)];
+                                        switch (true) {
+                                            case typeof param === 'string':
+                                                return methodsResult.find(method => method[DIR_NAME] === param) ?? false;
+                                            case typeof param === 'boolean':
+                                            case param === undefined:
+                                                console.log('methodsResult', '=', methodsResult);
+                                                return methodsResult;
+                                        }
+                                    },
+                                };
+                            default:
+                                return methods.find(method => method.entry[DIR_NAME] === methodName);
+                        }
+                    })();
+
+                    if (methodDefinition === undefined) {
+                        unhandledMethod();
+                        return;
+                    }
+
+                    if (accessLevel < methodDefinition.entry[DIR_ACCESS]) {
+                        unhandledMethod();
+                        return;
+                    }
+
+                    const requestParam = request.value[RPC_MESSAGE_PARAMS];
+                    const parsedParam = methodDefinition.paramParser.safeParse(requestParam);
+                    if (!parsedParam.success) {
+                        throw new InvalidParams(`Unexpected param for method ${methodName} on path ${shvPath}: ${toCpon(requestParam)}`);
+                    }
+
+                    let result = methodDefinition.handler(
+                        shvPath,
+                        methodName,
+                        parsedParam.data,
+                        sendDelay,
+                    );
                     if (result instanceof RequestHandler) {
                         this.requestHandlers.set(requestId, result);
                         result = result.options.result;

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);