@litert/televoke 1.2.0 → 1.3.0

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

@@ -36,6 +36,8 @@ interface IDecodeContext {
 
 const B8 = Buffer.allocUnsafe(8);
 const B4 = Buffer.allocUnsafe(4);
+const B_API_CALL_REQ_EXT_HEADER = Buffer.allocUnsafe(CSv2.API_CALL_REQ_EXT_HEADER_SIZE);
+const B_API_CALL_RESP_EXT_HEADER = Buffer.allocUnsafe(CSv2.API_CALL_RESP_EXT_HEADER_SIZE);
 const B2 = Buffer.allocUnsafe(2);
 
 interface IPacketDecoder {
@@ -43,6 +45,45 @@ interface IPacketDecoder {
     decode(ctx: IDecodeContext): dEnc2.ICommandPacket;
 }
 
+function skipBytes(bytes: number, ctx: IDecodeContext): void {
+
+    let readBytes = 0;
+
+    while (readBytes < bytes) {
+
+        if (ctx.chIndex === ctx.chunks.length) {
+
+            throw new errors.incomplete_packet();
+        }
+
+        const c = ctx.chunks[ctx.chIndex];
+        const cLen = c.byteLength;
+        let cOff = ctx.chOffset;
+
+        do {
+
+            readBytes++;
+            cOff++;
+        }
+        while (cOff < cLen && readBytes < bytes);
+
+        if (cOff === cLen) {
+
+            ctx.chIndex++;
+            ctx.chOffset = 0;
+        }
+        else {
+
+            ctx.chOffset = cOff;
+        }
+
+        if (readBytes === bytes) {
+
+            break;
+        }
+    }
+}
+
 function readSmallBytes(bytes: number, buf: Buffer, ctx: IDecodeContext): Buffer {
 
     let readBytes = 0;
@@ -209,25 +250,67 @@ class TvErrorResponseDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.ERROR_RESPONSE,
             'seq': ctx.seq,
             'ct': err,
-        } satisfies dEnc2.IErrorResponsePacket;
+        } satisfies dEnc2.IErrorReplyPacket;
     }
 }
 
 class TvApiRequestDecoder implements IPacketDecoder {
 
+    private _decodeExtPart(
+        ctx: IDecodeContext,
+        ctOut: dEnc2.IApiRequestPacketDecoded['ct']
+    ): dEnc2.IApiRequestPacketDecoded['ct'] {
+
+        if (ctx.chIndex >= ctx.chunks.length) {
+
+            ctOut.bodyEnc = CSv2.DEFAULT_API_ARGS_ENCODING;
+            return ctOut;
+        }
+
+        const hdrBuf = readSmallBytes(B_API_CALL_REQ_EXT_HEADER.byteLength, B_API_CALL_REQ_EXT_HEADER, ctx);
+        const hdrLen = hdrBuf.readUInt32LE(CSv2.EApiCallReqExtHeaderFieldOffset.LENGTH);
+        const bodyEnc = hdrBuf.readUInt32LE(CSv2.EApiCallReqExtHeaderFieldOffset.BODY_ENC);
+        const chkQty = hdrBuf.readUInt32LE(CSv2.EApiCallReqExtHeaderFieldOffset.BIN_CHUNK_QTY);
+
+        if (!chkQty) {
+
+            ctOut.bodyEnc = bodyEnc;
+            return ctOut;
+        }
+
+        if (hdrLen > B_API_CALL_REQ_EXT_HEADER.length) {
+
+            skipBytes(hdrLen - B_API_CALL_REQ_EXT_HEADER.length, ctx);
+        }
+
+        const binChunks: Buffer[][] = [];
+
+        for (let i = 0; i < chkQty; ++i) {
+
+            binChunks.push(readVarBuffer(ctx));
+        }
+
+        ctOut.bodyEnc = bodyEnc;
+        ctOut.binChunks = binChunks;
+
+        return ctOut;
+    }
+
     public decode(ctx: IDecodeContext): dEnc2.ICommandPacket {
 
         const name = readVarString(ctx);
 
+        const body = readVarBuffer(ctx);
+
         return {
             'cmd': CSv2.ECommand.API_CALL,
             'typ': CSv2.EPacketType.REQUEST,
             'seq': ctx.seq,
-            'ct': {
+            'ct': this._decodeExtPart(ctx, {
                 'name': name,
-                'body': readVarBuffer(ctx),
-            }
-        } satisfies dEnc2.IApiRequestPacket;
+                'body': body,
+            })
+        } satisfies dEnc2.IApiRequestPacketDecoded;
     }
 }
 
@@ -240,7 +323,7 @@ class TvPingRequestDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.REQUEST,
             'seq': ctx.seq,
             'ct': readVarBuffer16(ctx)
-        } satisfies dEnc2.IPingRequestPacket;
+        } satisfies dEnc2.IPingRequestPacketDecoded;
     }
 }
 
@@ -253,7 +336,7 @@ class TvPushMessageRequestDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.REQUEST,
             'seq': ctx.seq,
             'ct': readVarBuffer(ctx)
-        } satisfies dEnc2.IPushMessageRequestPacket;
+        } satisfies dEnc2.IPushMessageRequestPacketDecoded;
     }
 }
 
@@ -272,7 +355,7 @@ class TvBinaryChunkRequestDecoder implements IPacketDecoder {
                 'index': chunkIndex,
                 'body': readVarBuffer(ctx),
             }
-        } satisfies dEnc2.IBinaryChunkRequestPacket;
+        } satisfies dEnc2.IBinaryChunkRequestPacketDecoded;
     }
 }
 
@@ -298,20 +381,59 @@ class TvVoidResponseDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.SUCCESS_RESPONSE,
             'seq': ctx.seq,
             'ct': null
-        } satisfies dEnc2.ISuccessResponsePacket;
+        } satisfies dEnc2.IOkReplyPacket;
     }
 }
 
-class TvApiResponseDecoder implements IPacketDecoder {
+class TvApiReplyDecoder implements IPacketDecoder {
+
+    private _decodeExtPart(
+        ctx: IDecodeContext,
+        ctOut: dEnc2.IApiReplyPacketDecoded['ct'],
+
+    ): dEnc2.IApiReplyPacketDecoded['ct'] {
+
+        if (ctx.chIndex >= ctx.chunks.length) {
+
+            return ctOut;
+        }
+
+        const MIN_EXT_HEADER_LEN = CSv2.API_CALL_RESP_EXT_HEADER_SIZE;
+        const extHdr = readSmallBytes(MIN_EXT_HEADER_LEN, B_API_CALL_RESP_EXT_HEADER, ctx);
+        const extHdrLen = extHdr.readUInt32LE(CSv2.EApiCallRespExtHeaderFieldOffset.LENGTH);
+        const extBinChunkQty = extHdr.readUInt32LE(CSv2.EApiCallRespExtHeaderFieldOffset.BIN_CHUNK_QTY);
+
+        if (!extBinChunkQty) {
+
+            return ctOut;
+        }
+
+        if (extHdrLen > MIN_EXT_HEADER_LEN) {
+
+            skipBytes(extHdrLen - MIN_EXT_HEADER_LEN, ctx);
+        }
+
+        const extBinChunks: Buffer[][] = [];
+
+        for (let i = 0; i < extBinChunkQty; ++i) {
+
+            extBinChunks.push(readVarBuffer(ctx));
+        }
+
+        ctOut.binChunks = extBinChunks;
+
+        return ctOut;
+    }
 
     public decode(ctx: IDecodeContext): dEnc2.ICommandPacket {
 
+        const body = readVarBuffer(ctx);
         return {
             'cmd': CSv2.ECommand.API_CALL,
             'typ': CSv2.EPacketType.SUCCESS_RESPONSE,
             'seq': ctx.seq,
-            'ct': readVarBuffer(ctx)
-        } satisfies dEnc2.IApiResponsePacket;
+            'ct': this._decodeExtPart(ctx, { body })
+        } satisfies dEnc2.IApiReplyPacketDecoded;
     }
 }
 
@@ -324,7 +446,7 @@ class TvPingResponseDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.SUCCESS_RESPONSE,
             'seq': ctx.seq,
             'ct': readVarBuffer16(ctx)
-        } satisfies dEnc2.IPingResponsePacket;
+        } satisfies dEnc2.IPingReplyPacketDecoded;
     }
 }
 
@@ -345,7 +467,7 @@ const packetDecoders: Record<number, IPacketDecoder> = {
     [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.PUSH_MESSAGE]: new TvVoidResponseDecoder(),
     [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.CLOSE]: new TvVoidResponseDecoder(),
     [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.BINARY_CHUNK]: new TvVoidResponseDecoder(),
-    [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.API_CALL]: new TvApiResponseDecoder(),
+    [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.API_CALL]: new TvApiReplyDecoder(),
     [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.PING]: new TvPingResponseDecoder(),
 };
 

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

@@ -37,9 +37,10 @@ interface IPacketEncoder {
      */
     encode(packet: dEnc2.ICommandPacket): Array<string | Buffer>;
 }
-class ErrorResponseEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IErrorResponsePacket): v2.IDataChunkArray {
+class ErrorReplyEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IErrorReplyPacket): v2.IBinLikeArray {
 
         const errorMsg = `${packet.ct.name}:${packet.ct.message}`;
 
@@ -56,9 +57,9 @@ class ErrorResponseEncoder implements IPacketEncoder {
     }
 }
 
-class VoidResponseEncoder implements IPacketEncoder {
+class VoidReplyEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.ISuccessResponsePacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IOkReplyPacket): v2.IBinLikeArray {
 
         const buf = Buffer.allocUnsafe(CS.HEADER_SIZE);
 
@@ -70,13 +71,68 @@ class VoidResponseEncoder implements IPacketEncoder {
 
 class ApiRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IApiRequestPacket): v2.IDataChunkArray {
+    private _createExtPart(
+        out: dEnc2.IBinLikeArray,
+        argsBodyEncoding: number = CS.DEFAULT_API_ARGS_ENCODING,
+        binChunks?: dEnc2.IEncBinItem[],
+    ): dEnc2.IBinLikeArray {
+
+        const header = Buffer.allocUnsafe(CS.API_CALL_REQ_EXT_HEADER_SIZE);
+
+        out.push(header);
+
+        header.writeUInt32LE(CS.API_CALL_REQ_EXT_HEADER_SIZE, CS.EApiCallReqExtHeaderFieldOffset.LENGTH);
+        header.writeUInt32LE(argsBodyEncoding, CS.EApiCallReqExtHeaderFieldOffset.BODY_ENC);
+        header.writeUInt32LE(binChunks?.length ?? 0, CS.EApiCallReqExtHeaderFieldOffset.BIN_CHUNK_QTY);
+
+        if (!binChunks?.length) {
+
+            return out;
+        }
+
+        for (const chunk of binChunks) {
+
+            let chunkLen = 0;
+
+            if (!chunk.length) {
+
+                const lenBuf = Buffer.allocUnsafe(4);
+                lenBuf.writeUInt32LE(chunkLen, 0);
+                out.push(lenBuf);
+                continue;
+            }
+
+            const lenBuf = Buffer.allocUnsafe(4);
+
+            if (Array.isArray(chunk)) {
+
+                for (const p of chunk) {
+
+                    chunkLen += p instanceof Buffer ? p.length : Buffer.byteLength(p);
+                }
+
+                lenBuf.writeUInt32LE(chunkLen, 0);
+                out.push(lenBuf);
+                out.push(...chunk);
+            }
+            else {
+
+                lenBuf.writeUInt32LE(Buffer.byteLength(chunk), 0);
+                out.push(lenBuf, chunk);
+            }
+        }
+
+        return out;
+    }
+
+    public encode(packet: dEnc2.IApiRequestPacketEncoding): v2.IBinLikeArray {
 
         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);
 
@@ -91,18 +147,24 @@ class ApiRequestEncoder implements IPacketEncoder {
 
             leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE + 2 + apiNameLen);
 
-            return [leadSeg, ...packet.ct.body];
+            return this._createExtPart([
+                leadSeg,
+                ...packet.ct.body
+            ], packet.ct.bodyEnc, packet.ct.binChunks);
         }
 
         leadSeg.writeUInt32LE(Buffer.byteLength(packet.ct.body), CS.HEADER_SIZE + 2 + apiNameLen);
 
-        return [leadSeg, packet.ct.body];
+        return this._createExtPart([
+            leadSeg,
+            packet.ct.body
+        ], packet.ct.bodyEnc, packet.ct.binChunks);
     }
 }
 
 class BinaryChunkRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IBinaryChunkRequestPacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IBinaryChunkRequestPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 12);
 
@@ -132,7 +194,7 @@ class BinaryChunkRequestEncoder implements IPacketEncoder {
 
 class PingRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IPingRequestPacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IPingRequestPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2);
 
@@ -160,7 +222,7 @@ class PingRequestEncoder implements IPacketEncoder {
 
 class CloseRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.ICloseRequestPacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.ICloseRequestPacket): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE);
 
@@ -172,7 +234,7 @@ class CloseRequestEncoder implements IPacketEncoder {
 
 class PushMessageRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IPushMessageRequestPacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IPushMessageRequestPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 4);
 
@@ -198,37 +260,99 @@ class PushMessageRequestEncoder implements IPacketEncoder {
     }
 }
 
-class ApiResponseEncoder implements IPacketEncoder {
+class ApiReplyEncoder implements IPacketEncoder {
+
+    private _createExtPart(
+        out: dEnc2.IBinLikeArray,
+        binChunks?: dEnc2.IEncBinItem[],
+    ): dEnc2.IBinLikeArray {
+
+        const header = Buffer.allocUnsafe(CS.API_CALL_RESP_EXT_HEADER_SIZE);
+        out.push(header);
+
+        header.writeUInt32LE(CS.API_CALL_RESP_EXT_HEADER_SIZE, CS.EApiCallRespExtHeaderFieldOffset.LENGTH);
+        header.writeUInt32LE(binChunks?.length ?? 0, CS.EApiCallRespExtHeaderFieldOffset.BIN_CHUNK_QTY);
+
+        if (!binChunks?.length) {
+
+            return out;
+        }
+
+        for (const chunk of binChunks) {
+
+            let chunkLen = 0;
+
+            if (!chunk.length) {
+
+                const lenBuf = Buffer.allocUnsafe(4);
+                lenBuf.writeUInt32LE(chunkLen, 0);
+                out.push(lenBuf);
+                continue;
+            }
 
-    public encode(packet: dEnc2.IApiResponsePacket): v2.IDataChunkArray {
+            const lenBuf = Buffer.allocUnsafe(4);
+
+            if (Array.isArray(chunk)) {
+
+                for (const p of chunk) {
+
+                    chunkLen += p instanceof Buffer ? p.length : Buffer.byteLength(p);
+                }
+
+                lenBuf.writeUInt32LE(chunkLen, 0);
+                out.push(lenBuf);
+                out.push(...chunk);
+            }
+            else {
+
+                lenBuf.writeUInt32LE(Buffer.byteLength(chunk), 0);
+                out.push(lenBuf, chunk);
+            }
+        }
+
+        return out;
+    }
+
+    public encode(packet: dEnc2.IApiReplyPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 4);
 
         writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
 
-        if (Array.isArray(packet.ct)) {
+        let bodyLen = 0;
 
-            let bodyLen = 0;
+        if (Array.isArray(packet.ct.body)) {
 
-            for (const p of packet.ct) {
+            for (const p of packet.ct.body) {
 
-                bodyLen += Buffer.byteLength(p);
+                bodyLen += p instanceof Buffer ? p.byteLength : Buffer.byteLength(p);
             }
+        }
+        else {
 
-            leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE);
+            bodyLen = packet.ct.body instanceof Buffer ? packet.ct.body.byteLength : Buffer.byteLength(packet.ct.body);
+        }
 
-            return [leadSeg, ...packet.ct];
+        leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE);
+
+        const ret: v2.IBinLikeArray = [leadSeg];
+
+        if (Array.isArray(packet.ct.body)) {
+
+            ret.push(...packet.ct.body);
         }
+        else {
 
-        leadSeg.writeUInt32LE(Buffer.byteLength(packet.ct), CS.HEADER_SIZE);
+            ret.push(packet.ct.body);
+        }
 
-        return [leadSeg, packet.ct];
+        return this._createExtPart(ret, packet.ct.binChunks);
     }
 }
 
-class PingResponseEncoder implements IPacketEncoder {
+class PingReplyEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IPingResponsePacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IPingReplyPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2);
 
@@ -262,22 +386,22 @@ const encoders: Record<number, IPacketEncoder> = {
     [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(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.API_CALL]: new ApiReplyEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.BINARY_CHUNK]: new VoidReplyEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.CLOSE]: new VoidReplyEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.PING]: new PingReplyEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.PUSH_MESSAGE]: new VoidReplyEncoder(),
+
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.API_CALL]: new ErrorReplyEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.BINARY_CHUNK]: new ErrorReplyEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.CLOSE]: new ErrorReplyEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.PING]: new ErrorReplyEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.PUSH_MESSAGE]: new ErrorReplyEncoder(),
 };
 
 export class TvEncoderV2 {
 
-    public encode(packet: dEnc2.ICommandPacket): Array<Buffer | string> {
+    public encode(packet: dEnc2.ICommandPacket): v2.IBinLikeArray {
 
         return encoders[packet.typ * 0x100 + packet.cmd].encode(packet);
     }