libshv-js 3.4.1 → 3.5.0

package/.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
     name: CPON/Chainpack conversions
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Install dependencies
         run: npm install
@@ -25,4 +25,6 @@ jobs:
         run: npx tsc
 
       - name: Run tests
-        run: node test.js
+        run: |
+          node test.js
+          node test_json.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libshv-js",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "description": "Typescript implementation of libshv",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -21,6 +21,7 @@
     "./chainpack.ts": "./src/chainpack.ts",
     "./cpcontext.ts": "./src/cpcontext.ts",
     "./cpon.ts": "./src/cpon.ts",
+    "./json.ts": "./src/json.ts",
     "./rpcmessage.ts": "./src/rpcmessage.ts",
     "./rpcvalue.ts": "./src/rpcvalue.ts",
     "./ws-client.ts": "./src/ws-client.ts",

package/src/chainpack.ts

@@ -178,7 +178,7 @@ class ChainPackReader {
 
                 msec += SHV_EPOCH_MSEC;
                 msec -= offset * 60_000;
-                return withOffset(new Date(msec), offset);
+                return withOffset(new Date(msec), offset ?? undefined);
             }
 
             case PackingSchema.Map: {
@@ -559,14 +559,14 @@ class ChainPackWriter {
         }
 
         let bi = BigInt(msecs);
-        if (dt.utc_offset !== undefined) {
+        if (dt.utc_offset !== undefined && dt.utc_offset !== 0) {
             bi <<= 7n;
             bi |= BigInt((dt.utc_offset / 15) & 0x7F);
         }
 
         bi <<= 2n;
 
-        if (dt.utc_offset !== undefined) {
+        if (dt.utc_offset !== undefined && dt.utc_offset !== 0) {
             bi |= 1n;
         }
 

package/src/cpon.ts

@@ -2,6 +2,33 @@
 import {type RpcValue, type RpcValueType, type DateTime, type List, Decimal, Double, type IMap, type Int, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, shvMapType, isShvMap, isIMap} from './rpcvalue';
 import {PackContext, UnpackContext} from './cpcontext';
 
+export const stringifyDate = (dt: DateTime) => {
+    const epochMsec = dt.getTime();
+    let utcOffset = dt.utc_offset;
+    const localMsec = epochMsec + (60_000 * (utcOffset ?? 0));
+    let res = new Date(localMsec).toISOString();
+    const rtrim = (localMsec % 1000) ? 1 : 5;
+    res = res.slice(0, Math.max(0, res.length - rtrim));
+
+    if (utcOffset === undefined || utcOffset === 0) {
+        res += 'Z';
+    } else {
+        if (utcOffset < 0) {
+            res += '-';
+            utcOffset = -utcOffset;
+        } else {
+            res += '+';
+        }
+
+        res += (Math.trunc(utcOffset / 60)).toString().padStart(2, '0');
+        if (utcOffset % 60) {
+            res += (utcOffset % 60).toString().padStart(2, '0');
+        }
+    }
+
+    return res;
+};
+
 const hexify = (byte: number) => {
     if (byte < 10) {
         return 48 + byte;
@@ -222,6 +249,25 @@ class CponReader {
     }
 
     readDateTime() {
+        this.ctx.getByte(); // eat '"'
+        let b = this.ctx.peekByte();
+        if (b === '"'.codePointAt(0)) {
+            // d"" invalid data time
+            this.ctx.getByte();
+            throw new TypeError('Malformed empty date separator in DateTime');
+        }
+
+        const date = this.readDateTimeInner();
+
+        b = this.ctx.getByte();
+        if (b !== '"'.codePointAt(0)) {
+            throw new TypeError('DateTime literal should be terminated by \'"\'.');
+        }
+
+        return date;
+    }
+
+    readDateTimeInner() {
         let year = 0;
         let month = 0;
         let day = 1;
@@ -231,17 +277,9 @@ class CponReader {
         let msec = 0;
         let utcOffset = 0;
 
-        this.ctx.getByte(); // eat '"'
-        let b = this.ctx.peekByte();
-        if (b === '"'.codePointAt(0)) {
-            // d"" invalid data time
-            this.ctx.getByte();
-            throw new TypeError('Malformed empty date separator in DateTime');
-        }
-
         year = Number(this.readInt());
 
-        b = this.ctx.getByte();
+        let b = this.ctx.getByte();
         if (b !== '-'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
@@ -307,15 +345,10 @@ class CponReader {
             }
         }
 
-        b = this.ctx.getByte();
-        if (b !== '"'.codePointAt(0)) {
-            throw new TypeError('DateTime literal should be terminated by \'"\'.');
-        }
-
         // let epoch_sec = CponReader.timegm(year, month, mday, hour, min, sec);
         let epochMsec = Date.UTC(year, month - 1, day, hour, min, sec, msec);
         epochMsec -= utcOffset * 60_000;
-        return withOffset(new Date(epochMsec), utcOffset);
+        return withOffset(new Date(epochMsec), utcOffset ?? undefined);
     }
 
     readCString() {
@@ -775,41 +808,8 @@ class CponWriter {
     }
 
     writeDateTime(dt: DateTime) {
-        if (!dt) {
-            this.ctx.writeStringUtf8('d""');
-            return;
-        }
-
-        const epochMsec = dt.getTime();
-        let utcOffset = dt.utc_offset;
-        const localMsec = epochMsec + (60_000 * (utcOffset ?? 0));
-        let s = new Date(localMsec).toISOString();
-        const rtrim = (localMsec % 1000) ? 1 : 5;
         this.ctx.writeStringUtf8('d"');
-        for (let i = 0; i < s.length - rtrim; i++) {
-            this.ctx.putByte(s.codePointAt(i)!);
-        }
-
-        if (utcOffset === undefined || utcOffset === 0) {
-            this.ctx.writeStringUtf8('Z');
-        } else {
-            if (utcOffset < 0) {
-                this.ctx.writeStringUtf8('-');
-                utcOffset = -utcOffset;
-            } else {
-                this.ctx.writeStringUtf8('+');
-            }
-
-            s = (Math.trunc(utcOffset / 60)).toString().padStart(2, '0');
-            if (utcOffset % 60) {
-                s += (utcOffset % 60).toString().padStart(2, '0');
-            }
-
-            for (let i = 0; i < s.length; i++) {
-                this.ctx.putByte(s.codePointAt(i)!);
-            }
-        }
-
+        this.ctx.writeStringUtf8(stringifyDate(dt));
         this.ctx.writeStringUtf8('"');
     }
 
@@ -835,10 +835,6 @@ class CponWriter {
         this.doIndentIfNotOneliner(map);
         let first = true;
         for (const [key, value] of Object.entries<RpcValue>(map)) {
-            if (value === undefined) {
-                continue;
-            }
-
             if (!first) {
                 this.ctx.putByte(','.codePointAt(0)!);
                 this.doIndentIfNotOneliner(map);

package/src/json.ts

@@ -0,0 +1,136 @@
+import {UnpackContext} from './cpcontext';
+import {CponReader, stringifyDate} from './cpon';
+import {Decimal, Double, isIMap, isShvMap, makeIMap, makeMap, makeMetaMap, RpcValueWithMetaData, UInt, type RpcValue} from './rpcvalue';
+
+// eslint-disable-next-line @typescript-eslint/ban-types -- Zod needs the default argument, otherwise it'll infer as UInt<unknown>
+const decodeMap = (x: object) => makeMap(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, decodeValueJson(value)])));
+
+const decodeValueJson = (x: unknown): RpcValue => {
+    switch (true) {
+        case Array.isArray(x): {
+            const list = x as unknown[];
+            const handleType = (typeName: unknown, typeValue: unknown) => {
+                switch (true) {
+                    case typeName === 'Blob': {
+                        if (typeof typeValue !== 'string' || typeValue.length % 2 !== 0) {
+                            throw new TypeError(`Invalid JSON-encoded Blob: '${JSON.stringify(typeValue)}'`);
+                        }
+
+                        const buffer = new ArrayBuffer(typeValue.length / 2);
+                        const array = new Uint8Array(buffer);
+
+                        // I can assume even length because of the previous check.
+                        for (let i = 0; i < typeValue.length / 2; i++) {
+                            array[i] = Number.parseInt(typeValue.slice(i * 2, (i * 2) + 2), 16);
+                        }
+
+                        return buffer;
+                    }
+
+                    case typeName === 'IMap':
+                        if (typeof typeValue !== 'object' || typeValue === null) {
+                            throw new TypeError(`Invalid JSON-encoded IMap: '${JSON.stringify(typeValue)}'`);
+                        }
+
+                        if (Object.keys(typeValue).some(key => !/^-?\d+$/.test(key))) {
+                            throw new TypeError(`Invalid JSON-encoded IMap (non-Int key): '${JSON.stringify(typeValue)}'`);
+                        }
+
+                        return makeIMap(decodeMap(typeValue));
+                    case typeName === 'DateTime':
+                        if (typeof typeValue !== 'string') {
+                            throw new TypeError(`Invalid JSON-encoded DateTime: '${JSON.stringify(typeValue)}'`);
+                        }
+
+                        // Kinda lame that I'm encoding the datetime string, but this is the easiest way right now.
+                        return new CponReader(new UnpackContext(new TextEncoder().encode(typeValue).buffer)).readDateTimeInner();
+                    default:
+                        throw new TypeError(`Invalid JSON-encoded type name: '${JSON.stringify(typeName)}'`);
+                }
+            };
+
+            switch (true) {
+                case list.length === 3 && list[0] === JSON_TAG_TYPE:
+                    return handleType(list[1], list[2]);
+                case list.length === 3 && list[0] === JSON_TAG_META:
+                case list.length === 5 && list[0] === JSON_TAG_META && list[2] === JSON_TAG_TYPE: {
+                    if (typeof list[1] !== 'object' || list[1] === null) {
+                        throw new TypeError(`Invalid JSON-encoded MetaData: '${JSON.stringify(list[1])}'`);
+                    }
+
+                    const value = (() => {
+                        if (list.length === 3) {
+                            const decoded = decodeValueJson(list[2]);
+                            if (decoded instanceof RpcValueWithMetaData) {
+                                throw new TypeError('Logic error: got RpcValueWithMetaData as the value in JSON-encoded RpcValueWithMetaData, please report this bug to the maintainer.');
+                            }
+
+                            return decoded;
+                        }
+
+                        return handleType(list[3], list[4]);
+                    })();
+
+                    return new RpcValueWithMetaData(makeMetaMap(decodeMap(list[1])), value);
+                }
+
+                default:
+                    return list.map(value => decodeValueJson(value));
+            }
+        }
+
+        case x === null:
+            return undefined;
+        case typeof x === 'object':
+            return decodeMap(x);
+        case typeof x === 'number':
+        case typeof x === 'boolean':
+        case typeof x === 'string':
+            return x;
+        default:
+            throw new Error(`Unknown JSON-encoded value: ${JSON.stringify(x)}`);
+    }
+};
+
+export const fromJson = (str: string): RpcValue | Error => decodeValueJson(JSON.parse(str));
+
+const JSON_TAG_META = '!shvMeta';
+const JSON_TAG_TYPE = '!shvType';
+
+const encodeValueJson = (x: RpcValue): unknown => {
+    switch (true) {
+        case x instanceof RpcValueWithMetaData: {
+            const res = [JSON_TAG_META, encodeValueJson(makeMap(x.meta))] as const;
+            const encoded = encodeValueJson(x.value);
+            if (Array.isArray(encoded) && encoded[0] === JSON_TAG_TYPE) {
+                return [...res, ...encoded as unknown[]];
+            }
+
+            return [...res, encoded];
+        }
+
+        case Array.isArray(x):
+            return x.map(value => encodeValueJson(value));
+        case isShvMap(x): {
+            const map = x as Record<string, RpcValue>;
+            return Object.fromEntries(Object.entries(map).map(([key, value]) => [key, encodeValueJson(value)] as const));
+        }
+
+        case isIMap(x):
+            return [JSON_TAG_TYPE, 'IMap', encodeValueJson(makeMap(x))];
+        case x instanceof ArrayBuffer:
+            return [JSON_TAG_TYPE, 'Blob', new Uint8Array(x).reduce((acc, v) => acc + v.toString(16).padStart(2, '0'), '')];
+        case x instanceof Date:
+            return [JSON_TAG_TYPE, 'DateTime', stringifyDate(x)];
+        case x === undefined:
+            return null;
+        case x instanceof Decimal:
+        case x instanceof UInt:
+        case x instanceof Double:
+            throw new TypeError('Decimal/Double/UInt not supported in JSON');
+        default:
+            return x;
+    }
+};
+
+export const toJson = (value: RpcValue): string | Error => JSON.stringify(encodeValueJson(value));

package/src/zod.ts

@@ -11,9 +11,10 @@ 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));
 
 const withMetaInstanceParser = z.instanceof(RpcValueWithMetaData);
-export const rpcvalue = () => z.union([
+export const rpcvalue: () => ZodType<RpcValue, any, any> = () => z.union([
     z.undefined(),
     z.boolean(),
     z.number(),
@@ -23,7 +24,7 @@ export const rpcvalue = () => z.union([
     blob(),
     z.string(),
     z.date(),
-    z.array(z.any()),
+    list(),
     map(),
     imap(),
     withMetaInstanceParser,

package/test.ts

@@ -64,6 +64,7 @@ for (const lst of [
     ['<4:"svete">i{2:<4:"svete">[0,1]}', null],
     ['d"2019-05-03T11:30:00-0700"', 'd"2019-05-03T11:30:00-07"'],
     ['d"2018-02-02T00:00:00Z"', null],
+    ['d"2024-10-30T16:30:57.890Z"', null],
     ['d"2027-05-03T11:30:12.345+01"', null],
 ]) {
     const cpon1 = lst[0];

package/test_json.ts

@@ -0,0 +1,44 @@
+import { toCpon } from "./src/cpon";
+import { fromJson, toJson } from "./src/json";
+import {makeIMap, makeMap, makeMetaMap, RpcValue, RpcValueWithMetaData, withOffset} from "./src/rpcvalue";
+
+const testJsonRoundTrip = (json: string, expected: RpcValue) => {
+	const parsed = fromJson(json);
+	if (parsed instanceof Error) {
+		throw parsed;
+	}
+	const parsedCpon = toCpon(parsed);
+	const expectedCpon = toCpon(expected);
+	if (parsedCpon !== expectedCpon) {
+		throw new Error(`Assertion error:\nExpected: '${expectedCpon}'\nActual: '${parsedCpon}'`);
+	}
+
+	const serializedJson = toJson(expected);
+	if (serializedJson !== json.replaceAll(' ', '')) {
+		throw new Error(`Assertion error:\nExpected: '${json}'\nActual: '${serializedJson}'`);
+	}
+
+};
+
+const MINUTE = 1;
+const HOUR = 60 * MINUTE;
+
+const tests = [
+	['{}', makeMap({})],
+	['{"null-field": null}', makeMap({"null-field": undefined})],
+	['["!shvType", "Blob", ""]', new Uint8Array().buffer],
+	['["!shvType", "Blob", "6162a1"]', new Uint8Array([0x61, 0x62, 0xa1]).buffer],
+	['["!shvType", "IMap", {}]', makeIMap({})],
+	['["!shvType", "IMap", {"1": 2}]', makeIMap({1: 2})],
+	['["!shvType", "IMap", {"1": 2, "2": "foo"}]', makeIMap({1: 2, 2: "foo"})],
+	['["!shvType", "DateTime", "2021-11-08T01:02:03+05"]', withOffset(new Date("2021-11-08T01:02:03+05:00"), 5 * HOUR)],
+	['["!shvType", "DateTime", "2021-11-08T01:02:03-0815"]', withOffset(new Date("2021-11-08T01:02:03-08:15"), -8 * HOUR - 15 * MINUTE)],
+	['["!shvType", "DateTime", "2021-11-08T01:02:03.456-0815"]', withOffset(new Date("2021-11-08T01:02:03.456-08:15"), -8 * HOUR - 15 * MINUTE)],
+	['["!shvMeta", {"1":2}, 42]', new RpcValueWithMetaData(makeMetaMap({1: 2}), 42)],
+	['["!shvMeta", {"1":2}, "!shvType", "IMap", {"42": 7}]', new RpcValueWithMetaData(makeMetaMap({1: 2}), makeIMap({42: 7}))],
+	['["!shvMeta", {"1": 2, "foo": "bar"}, [1,2,3]]', new RpcValueWithMetaData(makeMetaMap({1: 2, "foo": "bar"}), [1, 2, 3])],
+] as const;
+
+tests.forEach(([inputJson, expectedRpcValue]) => testJsonRoundTrip(inputJson, expectedRpcValue));
+
+console.log('OK');