libshv-js 3.0.0

package/src/rpcmessage.ts

@@ -0,0 +1,195 @@
+import {IMap, Int, MetaMap, type RpcValue, RpcValueWithMetaData} from './rpcvalue.ts';
+import {toCpon} from './cpon.ts';
+import {toChainPack} from './chainpack.ts';
+
+const TagRequestId = 8;
+const TagShvPath = 9;
+const TagMethod = 10;
+const TagCallerIds = 11;
+
+const KeyParams = 1;
+const KeyResult = 2;
+const KeyError = 3;
+
+export const ERROR_CODE = 1;
+export const ERROR_MESSAGE = 2;
+export const ERROR_DATA = 3;
+
+enum ErrorCode {
+    InvalidRequest = 1,
+    MethodNotFound = 2,
+    InvalidParams = 3,
+    InternalError = 4,
+    ParseError = 5,
+    MethodCallTimeout = 6,
+    MethodCallCancelled = 7,
+    MethodCallException = 8,
+    Unknown = 9,
+    LoginRequired = 10,
+    UserIDRequired = 11,
+    NotImplemented = 12,
+}
+
+type ErrorMap = IMap<{
+    [ERROR_CODE]: Int<ErrorCode>;
+    [ERROR_MESSAGE]?: string;
+    [ERROR_DATA]?: RpcValue;
+}>;
+
+class RpcError extends Error {
+    constructor(private readonly err_info: ErrorMap) {
+        super(err_info.value[ERROR_MESSAGE]);
+    }
+
+    data() {
+        return this.err_info.value[ERROR_DATA];
+    }
+}
+
+export class ProtocolError extends Error {}
+
+export class InvalidRequest extends RpcError {}
+export class MethodNotFound extends RpcError {}
+export class InvalidParams extends RpcError {}
+export class InternalError extends RpcError {}
+export class ParseError extends RpcError {}
+export class MethodCallTimeout extends RpcError {}
+export class MethodCallCancelled extends RpcError {}
+export class MethodCallException extends RpcError {}
+export class Unknown extends RpcError {}
+export class LoginRequired extends RpcError {}
+export class UserIDRequired extends RpcError {}
+export class NotImplemented extends RpcError {}
+
+class RpcMessage {
+    value: IMap;
+    meta: MetaMap;
+    constructor(rpc_val?: RpcValue) {
+        if (rpc_val === undefined) {
+            this.value = new IMap();
+            this.meta = new MetaMap();
+            return;
+        }
+
+        if (!(rpc_val instanceof RpcValueWithMetaData && rpc_val.value instanceof IMap)) {
+            throw new TypeError(`RpcMessage initialized with a non-IMap: ${toCpon(rpc_val)}`);
+        }
+
+        this.value = rpc_val.value;
+        this.meta = rpc_val.meta;
+    }
+
+    isValid() {
+        return this.shvPath() && (this.isRequest() || this.isResponse || this.isSignal());
+    }
+
+    isRequest(): boolean {
+        return this.requestId() !== undefined && this.method() !== undefined;
+    }
+
+    isResponse(): boolean {
+        return this.requestId() !== undefined && this.method() === undefined;
+    }
+
+    isSignal(): boolean {
+        return this.requestId() === undefined && this.method() !== undefined;
+    }
+
+    requestId(): Int | undefined {
+        return (this.meta.value[TagRequestId] as Int);
+    }
+
+    setRequestId(id: number | Int) {
+        this.meta.value[TagRequestId] = new Int(id);
+    }
+
+    callerIds(): RpcValue[] | undefined {
+        return this.meta.value[TagCallerIds] as RpcValue[];
+    }
+
+    setCallerIds(ids: RpcValue[]) {
+        this.meta.value[TagCallerIds] = ids;
+    }
+
+    shvPath(): string | undefined {
+        return (this.meta.value[TagShvPath] as string);
+    }
+
+    setShvPath(val: string) {
+        this.meta.value[TagShvPath] = val;
+    }
+
+    method(): string | undefined {
+        return (this.meta.value[TagMethod] as string);
+    }
+
+    setMethod(val: string) {
+        this.meta.value[TagMethod] = val;
+    }
+
+    params() {
+        return this.value.value[KeyParams];
+    }
+
+    setParams(params: RpcValue) {
+        this.value.value[KeyParams] = params;
+    }
+
+    resultOrError() {
+        if (this.value.value[KeyError] !== undefined) {
+            if (!(this.value.value[KeyError] instanceof IMap)) {
+                return new ProtocolError('Response had an error, but this error was not a map');
+            }
+
+            const error_map = this.value.value[KeyError];
+            if (error_map.value[ERROR_CODE] === undefined) {
+                return new ProtocolError('Response had an error, but this error did not contain at least an error code');
+            }
+
+            const ErrorType = (() => {
+                switch ((this.value.value[KeyError] as ErrorMap).value[ERROR_CODE].value) {
+                    case ErrorCode.InvalidRequest: return InvalidRequest;
+                    case ErrorCode.MethodNotFound: return MethodNotFound;
+                    case ErrorCode.InvalidParams: return InvalidParams;
+                    case ErrorCode.InternalError: return InternalError;
+                    case ErrorCode.ParseError: return ParseError;
+                    case ErrorCode.MethodCallTimeout: return MethodCallTimeout;
+                    case ErrorCode.MethodCallCancelled: return MethodCallCancelled;
+                    case ErrorCode.MethodCallException: return MethodCallException;
+                    case ErrorCode.Unknown: return Unknown;
+                    case ErrorCode.LoginRequired: return LoginRequired;
+                    case ErrorCode.UserIDRequired: return UserIDRequired;
+                    case ErrorCode.NotImplemented: return NotImplemented;
+                }
+            })();
+
+            return new ErrorType(this.value.value[KeyError] as ErrorMap);
+        }
+
+        if (this.value.value[KeyResult] !== undefined) {
+            return this.value.value[KeyResult];
+        }
+
+        return new ProtocolError('Response included neither result nor error');
+    }
+
+    setResult(result: RpcValue) {
+        this.value.value[KeyResult] = result;
+    }
+
+    setError(error: string) {
+        this.value.value[KeyError] = error;
+    }
+
+    toCpon() {
+        return toCpon(new RpcValueWithMetaData(this.value, this.meta));
+    }
+
+    toChainPack() {
+        return toChainPack(new RpcValueWithMetaData(this.value, this.meta));
+    }
+}
+
+export type RpcResponse<T = RpcValue> = T | Error;
+
+export {RpcMessage, RpcError, ErrorCode};

package/src/rpcvalue.ts

@@ -0,0 +1,111 @@
+class Int<T = number> {
+    readonly value: T;
+
+    constructor(u: T | Int<T>) {
+        if (u instanceof Int) {
+            this.value = u.value;
+            return;
+        }
+        if (!Number.isInteger(u)) {
+            throw new TypeError('Value for Int must a positive integral number');
+        }
+
+        this.value = u;
+    }
+
+    [Symbol.toPrimitive](_hint: string) {
+        return this.value;
+    }
+}
+
+class UInt {
+    readonly value: number;
+
+    constructor(u: number) {
+        if (u < 0 || !Number.isInteger(u)) {
+            throw new Error(`Invalid value '${u}' for UInt must a positive integral number`);
+        }
+
+        this.value = u;
+    }
+
+    [Symbol.toPrimitive](_hint: string) {
+        return this.value;
+    }
+
+    toString() {
+        return `${this.value.toString()}`;
+    }
+}
+
+class Double {
+    readonly value: number;
+
+    constructor(u: number) {
+        this.value = u;
+    }
+}
+
+class Decimal {
+    mantisa: number;
+    exponent: number;
+    constructor(mantisa: number, exponent: number) {
+        if (!Number.isInteger(exponent)) {
+            throw new TypeError(`Decimal: exponent must be integral (${exponent})`);
+        }
+
+        this.mantisa = mantisa;
+        this.exponent = exponent;
+    }
+}
+
+export type Null = undefined;
+export type Bool = boolean;
+export type Blob = ArrayBuffer;
+export type ShvString = string;
+export type DateTime = Date & {utc_offset?: number};
+const withOffset = (date: Date, utc_offset?: number) => {
+    const cloned_date: DateTime = new Date(date.getTime());
+    cloned_date.utc_offset = utc_offset;
+    return cloned_date;
+};
+export type List = RpcValue[];
+
+type ShvMapDefaultType = Record<string, RpcValue | undefined>;
+class ShvMap<T extends ShvMapDefaultType = ShvMapDefaultType> {
+    constructor(public value: T = {} as T) {}
+}
+
+type IMapDefaultType = Record<number, RpcValue | undefined>;
+class IMap<T extends IMapDefaultType = IMapDefaultType> {
+    constructor(public value: T = {} as T) {}
+}
+
+export type RpcValueType =
+    Null |
+    Bool |
+    Int |
+    UInt |
+    Double |
+    Decimal |
+    Blob |
+    ShvString |
+    DateTime |
+    List |
+    ShvMap |
+    IMap;
+
+class MetaMap {
+    value: Record<number | string, RpcValue | undefined>;
+    constructor(obj?: Record<number | string, RpcValue | undefined>) {
+        this.value = obj ?? {};
+    }
+}
+
+class RpcValueWithMetaData {
+    constructor(public value: RpcValueType, public meta: MetaMap) {}
+}
+
+export type RpcValue = RpcValueType | RpcValueWithMetaData;
+
+export {Decimal, Double, Int, IMap, MetaMap, RpcValueWithMetaData, ShvMap, UInt, withOffset};

package/src/ws-client.ts

@@ -0,0 +1,249 @@
+import {ChainPackReader, ChainpackProtocolType, ChainPackWriter} from './chainpack.ts';
+import {type CponReader, CponProtocolType, toCpon} from './cpon.ts';
+import {ERROR_MESSAGE, ErrorCode, ERROR_CODE, RpcError, RpcMessage, type RpcResponse, MethodCallTimeout} from './rpcmessage.ts';
+import {type RpcValue, type Null, Int, IMap, ShvMap} from './rpcvalue.ts';
+
+const DEFAULT_TIMEOUT = 5000;
+
+const dataToRpcValue = (buff: ArrayBuffer) => {
+    const rd: ChainPackReader | CponReader = new ChainPackReader(buff);
+    rd.readUIntData();
+    const proto = rd.ctx.getByte();
+    switch (proto) {
+        case ChainpackProtocolType:
+            break;
+        case CponProtocolType:
+            throw new Error('CPON protocol type is not supported anymore');
+        default:
+            throw new Error(`Unsupported protocol type ${proto}`);
+    }
+    const rpc_val = rd.read();
+    return rpc_val;
+};
+
+type SubscriptionCallback = (path: string, method: string, param?: RpcValue) => void;
+
+type RpcResponseResolver = (rpc_msg: RpcResponse) => void;
+
+type Subscription = {
+    path: string;
+    method: string;
+    callback: SubscriptionCallback;
+};
+
+type WsClientOptions = {
+    logDebug: (...args: string[]) => void;
+    mountPoint?: string;
+    user?: string;
+    password: string;
+    loginType?: 'PLAIN' | 'AZURE';
+    timeout?: number;
+    wsUri: string;
+    onConnected: () => void;
+    onRequest: (rpc_msg: RpcMessage) => void;
+};
+
+type LsResult = string[];
+export enum DirFlags {
+    Reserved = 1,
+    Getter = 2,
+    Setter = 4,
+    LargeResultHint = 8,
+    NotIdempotent = 16,
+    RequiresClientId = 32,
+}
+export const DIR_NAME = 1;
+export const DIR_FLAGS = 2;
+export const DIR_PARAM = 3;
+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]: Int<DirFlags>;
+    [DIR_PARAM]: string | Null;
+    [DIR_RESULT]: string | Null;
+    [DIR_ACCESS]: Int;
+    [DIR_SIGNALS]: ShvMap<Record<string, string | Null>>;
+    [DIR_EXTRA]: ShvMap;
+}>>;
+
+class WsClient {
+    requestId = 1;
+    rpcHandlers: Array<{
+        resolve: RpcResponseResolver;
+        timeout_handle: number;
+    }> = [];
+
+    subscriptions: Subscription[] = [];
+    websocket: WebSocket;
+
+    logDebug: WsClientOptions['logDebug'];
+    mountPoint: WsClientOptions['mountPoint'];
+    user?: WsClientOptions['user'];
+    password: WsClientOptions['password'];
+    loginType: WsClientOptions['loginType'];
+    onConnected: WsClientOptions['onConnected'];
+    onRequest: WsClientOptions['onRequest'];
+    timeout: WsClientOptions['timeout'];
+
+    constructor(options: WsClientOptions) {
+        if (typeof options !== 'object') {
+            throw new TypeError('No options object supplied');
+        }
+
+        this.logDebug = options.logDebug ?? (() => {/* nothing */});
+        this.mountPoint = options.mountPoint;
+
+        this.user = options.user ?? '';
+        this.password = options.password;
+        this.loginType = options.loginType ?? 'PLAIN';
+
+        this.websocket = new WebSocket(options.wsUri);
+        this.websocket.binaryType = 'arraybuffer';
+
+        this.onConnected = options.onConnected ?? (() => {/* nothing */});
+        this.onRequest = options.onRequest ?? (() => {/* nothing */});
+
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+
+        this.websocket.addEventListener('open', () => {
+            this.logDebug('CONNECTED');
+            this.callRpcMethod(undefined, 'hello').then(() => {
+                const params = new ShvMap({
+                    login: new ShvMap({
+                        password: this.password,
+                        type: this.loginType,
+                        user: this.user,
+                    }),
+                    options: new ShvMap({
+                        device: this.mountPoint === 'string' ? new ShvMap({mountPoint: this.mountPoint}) : undefined,
+                    }),
+                });
+                return this.callRpcMethod(undefined, 'login', params);
+            }).then(() => {
+                this.logDebug('SUCCESS: connected to shv broker');
+                this.onConnected();
+            }).catch(() => {
+                this.logDebug('FAILURE: couldn\' connected to shv broker');
+            });
+        });
+
+        this.websocket.addEventListener('close', () => {
+            this.logDebug('DISCONNECTED');
+        });
+
+        this.websocket.addEventListener('message', evt => {
+            const rpc_val = dataToRpcValue(evt.data);
+            const rpc_msg = new RpcMessage(rpc_val);
+            this.logDebug(`message received: ${rpc_msg.toCpon()}`);
+
+            if (rpc_msg.isSignal()) {
+                for (const sub of this.subscriptions) {
+                    const shv_path = rpc_msg.shvPath();
+                    const method = rpc_msg.method();
+
+                    if (shv_path?.startsWith(sub.path) && method === sub.method) {
+                        sub.callback(shv_path, method, rpc_msg.params());
+                    }
+                }
+            } else if (rpc_msg.isRequest()) {
+                this.onRequest(rpc_msg);
+            } else if (rpc_msg.isResponse()) {
+                const requestId = rpc_msg.requestId();
+                if (requestId === undefined) {
+                    throw new Error('got RpcResponse without requestId');
+                }
+
+                if (this.rpcHandlers[Number(requestId)] !== undefined) {
+                    const handler = this.rpcHandlers[Number(requestId)];
+                    clearTimeout(handler.timeout_handle);
+                    handler.resolve(rpc_msg.resultOrError());
+                    // eslint-disable-next-line @typescript-eslint/no-array-delete, @typescript-eslint/no-dynamic-delete
+                    delete this.rpcHandlers[Number(requestId)];
+                }
+            }
+        });
+
+        this.websocket.addEventListener('error', evt => {
+            console.log('WebSocket ERROR', evt);
+            this.logDebug('WebSocket ERROR');
+        });
+
+        this.websocket.addEventListener('close', evt => {
+            this.logDebug(`socket close code: ${evt.code}`);
+        });
+    }
+
+    callRpcMethod(shv_path: string | undefined, method: 'dir', params?: RpcValue): Promise<RpcResponse<DirResult>>;
+    callRpcMethod(shv_path: string | undefined, method: 'ls', params?: RpcValue): Promise<RpcResponse<LsResult>>;
+    callRpcMethod(shv_path: string | undefined, method: string, params?: RpcValue): Promise<RpcResponse>;
+    callRpcMethod(shv_path: string | undefined, method: string, params?: RpcValue) {
+        const rq = new RpcMessage();
+        const rq_id = this.requestId++;
+        rq.setRequestId(rq_id);
+        if (shv_path !== undefined) {
+            rq.setShvPath(shv_path);
+        }
+        rq.setMethod(method);
+        if (params !== undefined) {
+            rq.setParams(params);
+        }
+        this.sendRpcMessage(rq);
+
+        const promise = new Promise<RpcResponse>(resolve => {
+            this.rpcHandlers[rq_id] = {resolve, timeout_handle: self.setTimeout(() => {
+                resolve(new MethodCallTimeout(new IMap({
+                    [ERROR_CODE]: new Int(ErrorCode.MethodCallTimeout),
+                    [ERROR_MESSAGE]: `Shv call timeout after: ${this.timeout} msec.`,
+                })));
+            }, this.timeout)};
+        });
+
+        return promise;
+    }
+
+    sendRpcMessage(rpc_msg: RpcMessage) {
+        if (this.websocket && this.websocket.readyState === 1) {
+            this.logDebug('sending rpc message:', rpc_msg.toCpon());
+            const msg_data = new Uint8Array(rpc_msg.toChainPack());
+
+            const wr = new ChainPackWriter();
+            wr.writeUIntData(msg_data.length + 1);
+            const dgram = new Uint8Array(wr.ctx.length + 1 + msg_data.length);
+            let ix = 0;
+            for (let i = 0; i < wr.ctx.length; i++) {
+                dgram[ix++] = wr.ctx.data[i];
+            }
+
+            dgram[ix++] = ChainpackProtocolType;
+
+            for (const msg_datum of msg_data) {
+                dgram[ix++] = msg_datum;
+            }
+            this.logDebug(`sending ${dgram.length} bytes of data`);
+            this.websocket.send(dgram.buffer);
+        }
+    }
+
+    subscribe(path: string, method: string, callback: SubscriptionCallback) {
+        this.callRpcMethod('.broker/app', 'subscribe', new ShvMap({
+            method, path,
+        })).catch(() => {
+            this.logDebug(`Couldn't subscribe to ${path}, ${method}`);
+        });
+
+        this.subscriptions.push({
+            path,
+            method,
+            callback,
+        });
+    }
+
+    close() {
+        this.websocket.close();
+    }
+}
+
+export {WsClient};

package/test.ts

@@ -0,0 +1,107 @@
+import {toChainPack, fromChainPack} from './src/chainpack.ts';
+import {toCpon, fromCpon} from './src/cpon.ts';
+import {type DateTime} from './src/rpcvalue.ts';
+
+const checkEq = (e1: string | number, e2: string | number) => {
+    if (e1 !== e2) {
+        throw new Error(`test check error: ${e1} === ${e2}`);
+    }
+};
+for (const lst of [
+    [((2 ** 31) - 1) + 'u', null],
+    [((2 ** 32) - 1) + 'u', null], // too big for JS bitwise operations
+    [String((2 ** 31) - 1), null],
+    [String(-((2 ** 30) - 1)), null],
+    [String((2 ** 53) - 1), null], // Number.MAX_SAFE_INTEGER
+    [String(-((2 ** 53) - 1)), null], // Number.MIN_SAFE_INTEGER
+    [String((2 ** 32) - 1), null], // too big for JS bitwise operations
+    ['true', null],
+    ['false', null],
+    ['null', null],
+    ['1u', null],
+    ['134', null],
+    ['7', null],
+    ['-2', null],
+    ['0xab', '171'],
+    ['-0xCD', '-205'],
+    ['0x1a2b3c4d', '439041101'],
+    ['223.', null],
+    ['2.30', null],
+    ['12.3e-10', '123e-11'],
+    ['-0.00012', '-12e-5'],
+    ['-1234567890.', '-1234567890.'],
+    ['"foo"', null],
+    ['b"a1\\d2"', null],
+    ['x"6131d2"', 'b"a1\\d2"'],
+    ['[]', null],
+    ['[1]', null],
+    ['[1,]', '[1]'],
+    ['[1,2,3]', null],
+    ['[[]]', null],
+    ['{"foo":"bar"}', null],
+    ['{"login":{"password":"lautr","type":"PLAIN","user":"revitest"}}', null],
+    ['i{1:2}', null],
+    ['i{\n\t1: "bar",\n\t345u : "foo",\n}', 'i{1:"bar",345:"foo"}'],
+    ['[1u,{"a":1},2.30]', null],
+    ['<1:2>3', null],
+    ['[1,<7:8>9]', null],
+    ['<>1', null],
+    ['<8:3u>i{2:[[".broker",<1:2>true]]}', null],
+    ['<1:2,"foo":"bar">i{1:<7:8>9}', null],
+    ['<1:2,"foo":<5:6>"bar">[1u,{"a":1},2.30]', null],
+    ['i{1:2 // comment to end of line\n}', 'i{1:2}'],
+    [`/*comment 1*/{ /*comment 2*/
+	\t"foo"/*comment "3"*/: "bar", //comment to end of line
+	\t"baz" : 1,
+	/*
+	\tmultiline comment
+	\t"baz" : 1,
+	\t"baz" : 1, // single inside multi
+	*/
+	}`, '{"foo":"bar","baz":1}'],
+    ['<1:2>[3,<4:5>6]', null],
+    ['<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"2027-05-03T11:30:12.345+01"', null],
+]) {
+    const cpon1 = lst[0];
+    const cpon2 = lst[1] ?? cpon1!;
+
+    console.log('testing', JSON.stringify(cpon1), '\t-------->\t', cpon2);
+    const rv1 = fromCpon(cpon1!);
+    const cpn1 = toCpon(rv1);
+    checkEq(cpn1, cpon2);
+
+    const cpk1 = toChainPack(rv1);
+    const rv2 = fromChainPack(cpk1);
+    const cpn2 = toCpon(rv2);
+    checkEq(cpn1, cpn2);
+}
+// same points in time
+const v1 = fromCpon('d"2017-05-03T18:30:00Z"') as DateTime;
+const v2 = fromCpon('d"2017-05-03T22:30:00+04"') as DateTime;
+const v3 = fromCpon('d"2017-05-03T11:30:00-0700"') as DateTime;
+const v4 = fromCpon('d"2017-05-03T15:00:00-0330"') as DateTime;
+checkEq(v1.getTime(), v2.getTime());
+checkEq(v2.getTime(), v3.getTime());
+checkEq(v3.getTime(), v4.getTime());
+checkEq(v4.getTime(), v1.getTime());
+
+{
+    const c1 = '{"1":"a"}';
+    const v1 = fromCpon(c1);
+    const c2 = toCpon(v1);
+    console.log(c1, 'vs.', c2);
+    checkEq(c1, c2);
+}
+
+{
+    const c1 = 'i{1:"a"}';
+    const v1 = fromCpon(c1);
+    const c2 = toCpon(v1);
+    console.log(c1, 'vs.', c2);
+    checkEq(c1, c2);
+}
+
+console.log('PASSED');