libshv-js 3.9.1 → 3.11.0

package/.github/workflows/test.yml

@@ -28,3 +28,4 @@ jobs:
         run: |
           node test.js
           node test_json.js
+          node test_zod.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libshv-js",
-  "version": "3.9.1",
+  "version": "3.11.0",
   "description": "Typescript implementation of libshv",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -28,7 +28,7 @@
     "./zod.ts": "./src/zod.ts"
   },
   "dependencies": {
-    "zod": "^3.24.2"
+    "zod": "^3.25.67"
   },
   "devDependencies": {
     "@typescript-eslint/parser": "^8.27.0",

package/src/rpcvalue.ts

@@ -102,6 +102,25 @@ const isIMap = (x: unknown): x is IMap => typeof x === 'object' && (x as IMap)[s
 
 const isMetaMap = (x: unknown): x is IMap => typeof x === 'object' && (x as MetaMap)[shvMapType] === 'metamap';
 
+export const typeName = (x: unknown): string => {
+    switch (true) {
+        case x === undefined: return 'Null';
+        case typeof x === 'boolean': return 'Bool';
+        case typeof x === 'string': return 'String';
+        case x instanceof ArrayBuffer: return 'Blob';
+        case x instanceof UInt: return 'UInt';
+        case typeof x === 'number': return 'Int';
+        case x instanceof Double: return 'Double';
+        case x instanceof Decimal: return 'Decimal';
+        case Array.isArray(x): return 'List';
+        case x instanceof Date: return 'Date';
+        case isShvMap(x): return 'ShvMap';
+        case isIMap(x): return 'IMap';
+        case isMetaMap(x): return 'MetaMap';
+        default: return '<unknown type>';
+    }
+};
+
 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,
     [shvMapType]: 'metamap',

package/src/ws-client.ts

@@ -58,7 +58,7 @@ type WsClientOptionsLogin = WsClientOptionsCommon & {
     onConnected: () => void;
     onConnectionFailure: (error: Error) => void;
     onDisconnected: () => void;
-    onRequest: (shvPath: string, method: string, param: RpcValue, delay: (progress: number) => void) => Promise<RpcValue>;
+    onRequest: (shvPath: string, method: string, param: RpcValue, delay: (progress: number) => void) => RpcValue | Promise<RpcValue>;
 };
 
 type WsClientOptionsWorkflows = WsClientOptionsCommon & {
@@ -162,6 +162,7 @@ class WsClient {
 
         this.websocket.addEventListener('message', async (evt: MessageEvent<ArrayBuffer>) => {
             const rpcVal = dataToRpcValue(evt.data);
+
             const rpcMsg = RpcMessageZod.parse(rpcVal);
             this.logDebug(`message received: ${toCpon(rpcMsg)}`);
 
@@ -193,12 +194,15 @@ class WsClient {
                             }));
                         };
 
+                        const result = this.options.onRequest(rpcMsg.meta[RPC_MESSAGE_SHV_PATH], rpcMsg.meta[RPC_MESSAGE_METHOD], rpcMsg.value[RPC_MESSAGE_PARAMS], sendDelay);
                         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),
+                            [RPC_MESSAGE_RESULT]: result instanceof Promise ? await result : result,
                         }));
                     } catch (error: unknown) {
                         const sendError = (error: RpcError) => {
-                            respond(error.err_info);
+                            respond(makeIMap({
+                                [RPC_MESSAGE_ERROR]: error.err_info,
+                            }));
                         };
 
                         switch (true) {

package/src/zod.ts

@@ -1,21 +1,44 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import {z, type ZodType} from 'zod';
-import {Decimal, Double, type IMap, isIMap, isMetaMap, isShvMap, type MetaMap, type RpcValue, type RpcValueType, RpcValueWithMetaData, type ShvMap, UInt} from './rpcvalue';
+import {z, type ZodType} from 'zod/v4';
+import {Decimal, Double, isIMap, isMetaMap, isShvMap, type MetaMap, RpcValue, type RpcValueType, RpcValueWithMetaData, shvMapType, typeName, 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) && (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) && (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));
+const implMakeMapParser = <MapBrand extends string, ObjectParser extends ZodType<object>>(mapValidator: (val: unknown) => boolean, _mapBrand: MapBrand, mapName: string, objectParser: ObjectParser) => z.custom<z.infer<ObjectParser> & {[shvMapType]: MapBrand}>().check(ctx => {
+    if (!mapValidator(ctx.value)) {
+        ctx.issues.push({
+            expected: 'map',
+            code: 'invalid_type',
+            input: ctx.value,
+            message: `Invalid input: expected ${mapName}, received ${typeName(ctx.value)}`,
+        });
+        return;
+    }
+
+    // For record, Zod finds out map brand, and calls the record's value parser with the value. There's no way to detect
+    // it, because Zod does not supply the parser with the key. To prevent this, remove the key before passing the value
+    // to Zod. This unfortunately means that we need to copy the whole object. :/
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const {[shvMapType]: zodMustNotHaveThis, ...rest} = {...ctx.value};
+    const parsedObject = objectParser.safeParse(rest);
+
+    if (!parsedObject.success) {
+        ctx.issues = parsedObject.error.issues;
+    }
+});
+
+export const map = <T extends Record<string, ZodType<any>>>(schema: T) => implMakeMapParser(isShvMap, 'map', 'ShvMap', z.object(schema));
+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);
 export const decimal = () => z.instanceof(Decimal);
 export const blob = () => z.instanceof(ArrayBuffer);
-export const list = () => z.array(z.lazy(rpcvalue));
+export const list: () => z.ZodArray<z.ZodLazy<z.ZodType<RpcValue>>> = () => z.array(z.lazy<z.ZodType<RpcValue>>(rpcvalue));
 
 const withMetaInstanceParser = z.instanceof(RpcValueWithMetaData);
-export const rpcvalue: () => ZodType<RpcValue, any, any> = () => z.union([
+export const rpcvalue: () => ZodType<RpcValue> = () => z.lazy(() => z.union([
     z.undefined(),
     z.boolean(),
     z.number(),
@@ -26,15 +49,48 @@ export const rpcvalue: () => ZodType<RpcValue, any, any> = () => z.union([
     z.string(),
     z.date(),
     list(),
-    map(),
-    imap(),
+    recmap(rpcvalue()),
     withMetaInstanceParser,
-]);
+]) as z.ZodType<RpcValue>);
+
+export const withMeta = <MetaSchema extends MetaMap, ValueSchema extends RpcValueType>(metaParser: ZodType<MetaSchema>, valueParser: ZodType<ValueSchema>) =>
+    z.custom<RpcValueWithMetaData<z.infer<typeof metaParser>, z.infer<typeof valueParser>>>().check(ctx => {
+        if (!withMetaInstanceParser.safeParse(ctx.value).success) {
+            ctx.issues.push({
+                expected: 'map',
+                code: 'invalid_type',
+                input: ctx.value,
+                message: 'Invalid input: expected a value with metadata, got a value with no metadata}',
+            });
+            return;
+        }
+
+        const parsedMeta = metaParser.safeParse(ctx.value.meta);
+        if (!parsedMeta.success) {
+            ctx.issues = [
+                {
+                    expected: 'map',
+                    code: 'invalid_type',
+                    input: ctx.value,
+                    message: 'Wrong RpcValueWithMetaData meta',
+                },
+                ...parsedMeta.error.issues,
+            ];
+            return;
+        }
 
-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);
+        const parsedValue = valueParser.safeParse(ctx.value.value);
+        if (!parsedValue.success) {
+            ctx.issues = [
+                {
+                    expected: 'map',
+                    code: 'invalid_type',
+                    input: ctx.value,
+                    message: 'Wrong RpcValueWithMetaData value',
+                },
+                ...parsedValue.error.issues,
+            ];
+        }
+    });
 
-export * from 'zod';
+export * from 'zod/v4';

package/test_zod.ts

@@ -0,0 +1,24 @@
+import { fromCpon } from './src/cpon';
+import { makeIMap, makeMap, makeMetaMap } from './src/rpcvalue';
+import * as z from './src/zod';
+
+z.map({ ok: z.boolean(), })
+	.parse(makeMap({ok: true}))
+	.ok;
+z.imap({ 1: z.boolean(), })
+	.parse(makeIMap({1: true}))[1];
+
+{
+	const x = z.metamap({1: z.boolean(), ok: z.boolean()})
+		.parse(makeMetaMap({1: true, ok: true}))
+	x.ok;
+	x[1];
+}
+
+const SiteInfoZod = z.recmap(z.map({
+    optKey: z.map({
+    }).optional(),
+}));
+
+const lol = fromCpon(`{"key": {}}`);
+SiteInfoZod.parse(lol);