@litert/televoke 0.4.7 → 1.0.0-1

package/src/lib/shared/Encodings/v2/EncoderV2.ts

@@ -0,0 +1,284 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import { v2 } from '..';
+import * as CS from './Constants.v2';
+import type * as dEnc2 from './Encoding.v2.decl';
+
+function writePacketHeader(ret: Buffer, command: CS.ECommand, type: CS.EPacketType, seq: number): void {
+
+    ret.writeUInt8(command, 0);
+    ret.writeUInt8(type, 1);
+    const low = seq % 0x1_0000_0000;
+    const high = (seq - low) / 0x1_0000_0000;
+    ret.writeUInt16LE(high, 2);
+    ret.writeUInt32LE(low, 4);
+}
+
+interface IPacketEncoder {
+
+    /**
+     * Encode the given packet.
+     *
+     * @param packet    The packet to encode.
+     */
+    encode(packet: dEnc2.ICommandPacket): Array<string | Buffer>;
+}
+class ErrorResponseEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IErrorResponsePacket): v2.IDataChunkArray {
+
+        const errorMsg = `${packet.ct.name}:${packet.ct.message}`;
+
+        const msgLen = Buffer.byteLength(errorMsg);
+
+        const buf = Buffer.allocUnsafe(CS.HEADER_SIZE + 2 + msgLen);
+
+        writePacketHeader(buf, packet.cmd, packet.typ, packet.seq);
+
+        buf.writeUInt16LE(msgLen, CS.HEADER_SIZE);
+        buf.write(errorMsg, CS.HEADER_SIZE + 2);
+
+        return [buf];
+    }
+}
+
+class VoidResponseEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.ISuccessResponsePacket): v2.IDataChunkArray {
+
+        const buf = Buffer.allocUnsafe(CS.HEADER_SIZE);
+
+        writePacketHeader(buf, packet.cmd, packet.typ, packet.seq);
+
+        return [buf];
+    }
+}
+
+class ApiRequestEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IApiRequestPacket): v2.IDataChunkArray {
+
+        const apiNameLen = Buffer.byteLength(packet.ct.name);
+
+        const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2 + 4 + apiNameLen);
+
+        writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
+        leadSeg.writeUInt16LE(apiNameLen, CS.HEADER_SIZE);
+        leadSeg.write(packet.ct.name, CS.HEADER_SIZE + 2);
+
+        if (Array.isArray(packet.ct.body)) {
+
+            let bodyLen = 0;
+
+            for (const p of packet.ct.body) {
+
+                bodyLen += Buffer.byteLength(p);
+            }
+
+            leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE + 2 + apiNameLen);
+
+            return [leadSeg, ...packet.ct.body];
+        }
+
+        leadSeg.writeUInt32LE(Buffer.byteLength(packet.ct.body), CS.HEADER_SIZE + 2 + apiNameLen);
+
+        return [leadSeg, packet.ct.body];
+    }
+}
+
+class BinaryChunkRequestEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IBinaryChunkRequestPacket): v2.IDataChunkArray {
+
+        const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 12);
+
+        writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
+        leadSeg.writeUInt32LE(packet.ct.streamId, CS.HEADER_SIZE);
+        leadSeg.writeUInt32LE(packet.ct.index, CS.HEADER_SIZE + 4);
+
+        if (Array.isArray(packet.ct.body)) {
+
+            let bodyLen = 0;
+
+            for (const p of packet.ct.body) {
+
+                bodyLen += Buffer.byteLength(p);
+            }
+
+            leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE + 8);
+
+            return [leadSeg, ...packet.ct.body];
+        }
+
+        leadSeg.writeUInt32LE(Buffer.byteLength(packet.ct.body), CS.HEADER_SIZE + 8);
+
+        return [leadSeg, packet.ct.body];
+    }
+}
+
+class PingRequestEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IPingRequestPacket): v2.IDataChunkArray {
+
+        const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2);
+
+        writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
+
+        if (Array.isArray(packet.ct)) {
+
+            let bodyLen = 0;
+
+            for (const p of packet.ct) {
+
+                bodyLen += Buffer.byteLength(p);
+            }
+
+            leadSeg.writeUInt16LE(bodyLen, CS.HEADER_SIZE);
+
+            return [leadSeg, ...packet.ct];
+        }
+
+        leadSeg.writeUInt16LE(Buffer.byteLength(packet.ct), CS.HEADER_SIZE);
+
+        return [leadSeg, packet.ct];
+    }
+}
+
+class CloseRequestEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.ICloseRequestPacket): v2.IDataChunkArray {
+
+        const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE);
+
+        writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
+
+        return [leadSeg];
+    }
+}
+
+class PushMessageRequestEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IPushMessageRequestPacket): v2.IDataChunkArray {
+
+        const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2);
+
+        writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
+
+        if (Array.isArray(packet.ct)) {
+
+            let bodyLen = 0;
+
+            for (const p of packet.ct) {
+
+                bodyLen += Buffer.byteLength(p);
+            }
+
+            leadSeg.writeUInt16LE(bodyLen, CS.HEADER_SIZE);
+
+            return [leadSeg, ...packet.ct];
+        }
+
+        leadSeg.writeUInt16LE(Buffer.byteLength(packet.ct), CS.HEADER_SIZE);
+
+        return [leadSeg, packet.ct];
+    }
+}
+
+class ApiResponseEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IApiResponsePacket): v2.IDataChunkArray {
+
+        const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 4);
+
+        writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
+
+        if (Array.isArray(packet.ct)) {
+
+            let bodyLen = 0;
+
+            for (const p of packet.ct) {
+
+                bodyLen += Buffer.byteLength(p);
+            }
+
+            leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE);
+
+            return [leadSeg, ...packet.ct];
+        }
+
+        leadSeg.writeUInt32LE(Buffer.byteLength(packet.ct), CS.HEADER_SIZE);
+
+        return [leadSeg, packet.ct];
+    }
+}
+
+class PingResponseEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IPingResponsePacket): v2.IDataChunkArray {
+
+        const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2);
+
+        writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
+
+        if (Array.isArray(packet.ct)) {
+
+            let bodyLen = 0;
+
+            for (const p of packet.ct) {
+
+                bodyLen += Buffer.byteLength(p);
+            }
+
+            leadSeg.writeUInt16LE(bodyLen, CS.HEADER_SIZE);
+
+            return [leadSeg, ...packet.ct];
+        }
+
+        leadSeg.writeUInt16LE(Buffer.byteLength(packet.ct), CS.HEADER_SIZE);
+
+        return [leadSeg, packet.ct];
+    }
+}
+
+const encoders: Record<number, IPacketEncoder> = {
+
+    [CS.EPacketType.REQUEST * 0x100 + CS.ECommand.API_CALL]: new ApiRequestEncoder(),
+    [CS.EPacketType.REQUEST * 0x100 + CS.ECommand.BINARY_CHUNK]: new BinaryChunkRequestEncoder(),
+    [CS.EPacketType.REQUEST * 0x100 + CS.ECommand.CLOSE]: new CloseRequestEncoder(),
+    [CS.EPacketType.REQUEST * 0x100 + CS.ECommand.PING]: new PingRequestEncoder(),
+    [CS.EPacketType.REQUEST * 0x100 + CS.ECommand.PUSH_MESSAGE]: new PushMessageRequestEncoder(),
+
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.API_CALL]: new ApiResponseEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.BINARY_CHUNK]: new VoidResponseEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.CLOSE]: new VoidResponseEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.PING]: new PingResponseEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.PUSH_MESSAGE]: new VoidResponseEncoder(),
+
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.API_CALL]: new ErrorResponseEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.BINARY_CHUNK]: new ErrorResponseEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.CLOSE]: new ErrorResponseEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.PING]: new ErrorResponseEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.PUSH_MESSAGE]: new ErrorResponseEncoder(),
+};
+
+export class TvEncoderV2 {
+
+    public encode(packet: dEnc2.ICommandPacket): Array<Buffer | string> {
+
+        return encoders[packet.typ * 0x100 + packet.cmd].encode(packet);
+    }
+}

package/src/lib/shared/Encodings/v2/Encoding.v2.decl.ts

@@ -0,0 +1,138 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import type * as CS from './Constants.v2';
+import type { TelevokeError } from '../../Errors';
+
+export type IDataChunkArray = Array<string | Buffer>;
+
+export type IDataChunkField = string | Buffer | IDataChunkArray;
+
+export interface ICommandPacket {
+
+    /**
+     * The command of this packet.
+     */
+    readonly cmd: CS.ECommand;
+
+    /**
+     * The type of this packet.
+     */
+    readonly typ: CS.EPacketType;
+
+    /**
+     * The sequence number of this packet.
+     */
+    readonly seq: number;
+
+    /**
+     * The content of this packet.
+     */
+    readonly ct: unknown;
+}
+
+export interface IRequestPacket extends ICommandPacket {
+
+    readonly typ: CS.EPacketType.REQUEST;
+}
+
+export interface IErrorResponsePacket extends ICommandPacket {
+
+    readonly typ: CS.EPacketType.ERROR_RESPONSE;
+
+    readonly ct: TelevokeError;
+}
+
+export interface ISuccessResponsePacket extends ICommandPacket {
+
+    readonly typ: CS.EPacketType.SUCCESS_RESPONSE;
+}
+
+export interface IApiRequestPacket extends IRequestPacket {
+
+    readonly cmd: CS.ECommand.API_CALL;
+
+    readonly ct: {
+
+        /**
+         * The name of the API to be invoked.
+         */
+        readonly name: string;
+
+        /**
+         * The arguments of the API to be invoked.
+         */
+        readonly body: IDataChunkField;
+    };
+}
+
+export interface IPingRequestPacket extends IRequestPacket {
+
+    readonly cmd: CS.ECommand.PING;
+
+    readonly ct: IDataChunkField;
+}
+
+export interface IPushMessageRequestPacket extends IRequestPacket {
+
+    readonly cmd: CS.ECommand.PUSH_MESSAGE;
+
+    readonly ct: IDataChunkField;
+}
+
+export interface ICloseRequestPacket extends IRequestPacket {
+
+    readonly cmd: CS.ECommand.CLOSE;
+
+    readonly ct: null;
+}
+
+export interface IBinaryChunkRequestPacket extends IRequestPacket {
+
+    readonly cmd: CS.ECommand.BINARY_CHUNK;
+
+    readonly ct: {
+
+        /**
+         * The stream ID of this chunk should be sent to.
+         */
+        readonly streamId: number;
+
+        /**
+         * The index of this chunk in the stream.
+         */
+        readonly index: number;
+
+        /**
+         * The chunk data.
+         */
+        readonly body: IDataChunkField;
+    };
+}
+
+export interface IApiResponsePacket extends ISuccessResponsePacket {
+
+    readonly cmd: CS.ECommand.API_CALL;
+
+    readonly ct: IDataChunkField;
+}
+
+export interface IPingResponsePacket extends ISuccessResponsePacket {
+
+    readonly cmd: CS.ECommand.PING;
+
+    readonly ct: IDataChunkField;
+}

package/src/lib/shared/Encodings/v2/index.ts

@@ -0,0 +1,20 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+export * from './Constants.v2';
+export * from './EncoderV2';
+export * from './DecoderV2';
+export type * from './Encoding.v2.decl';

package/src/lib/shared/Errors.ts

@@ -0,0 +1,95 @@
+/**
+* Copyright 2023 Angus.Fenying <fenying@litert.org>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   https://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import * as Constants from './Constants';
+
+/**
+ * The base class of all Televoke errors.
+ */
+export abstract class TelevokeError extends Error {
+
+    public constructor(
+        name: string,
+        message: string,
+        public readonly origin: unknown = null
+    ) {
+
+        super(message);
+        this.name = name;
+    }
+}
+
+export class ProtocolError extends TelevokeError {
+
+    public constructor(
+        message: string,
+        origin: unknown,
+    ) {
+
+        super(Constants.PROTOCOL_ERROR_NAMESPACE, message, origin);
+    }
+}
+
+function defineProtocolError<T extends string>(name: T): Record<T, new (
+    data?: unknown,
+    origin?: unknown
+) => ProtocolError> {
+
+    return {
+
+        [name]: class extends ProtocolError {
+
+            public constructor(public readonly data: unknown = null, origin: unknown = null) {
+
+                super(name, origin);
+            }
+        },
+    } as any;
+}
+
+const errorCtors = {
+
+    ...defineProtocolError('incomplete_packet'),
+    ...defineProtocolError('invalid_packet'),
+    ...defineProtocolError('invalid_response'),
+    ...defineProtocolError('channel_inactive'),
+    ...defineProtocolError('channel_closed'),
+    ...defineProtocolError('api_not_found'),
+    ...defineProtocolError('cmd_not_impl'),
+    ...defineProtocolError('network_error'),
+    ...defineProtocolError('stream_not_found'),
+    ...defineProtocolError('stream_aborted'),
+    ...defineProtocolError('stream_closed'),
+    ...defineProtocolError('stream_index_mismatch'),
+    ...defineProtocolError('system_busy'),
+    ...defineProtocolError('timeout'),
+    ...defineProtocolError('unknown'),
+
+    ['app_error']: class AppError extends TelevokeError {
+
+        public constructor(message: string, origin: unknown = null) {
+
+            super(Constants.APP_ERROR_NAMESPACE, message, origin);
+        }
+    }
+};
+
+export class TvErrorResponse {
+
+    public constructor(public readonly data: unknown) {}
+}
+
+export const errors: Readonly<typeof errorCtors> = errorCtors as any;