@based/server 9.2.7 → 10.0.1

package/dist/protocol.js

@@ -1,5 +1,5 @@
 import zlib from 'node:zlib';
-const textDecoder = new TextDecoder();
+import { DECODER, ENCODER, writeUint32, writeUint24, writeUint64, readUint32, } from '@saulx/utils';
 export const COMPRESS_FROM_BYTES = 150;
 export const decodeHeader = (nr) => {
     // 4 bytes
@@ -24,22 +24,8 @@ export const decodeHeader = (nr) => {
         len,
     };
 };
-export const storeUint8 = (buff, n, start, len) => {
-    for (let index = start; index < start + len; index++) {
-        const byte = n & 0xff;
-        buff[index] = byte;
-        n = (n - byte) / 256;
-    }
-};
-export const readUint8 = (buff, start, len) => {
-    let n = 0;
-    const s = len - 1 + start;
-    for (let i = s; i >= start; i--) {
-        n = n * 256 + buff[i];
-    }
-    return n;
-};
-export const encodeHeader = (type, isDeflate, len) => {
+// add buffer
+const encodeHeader = (type, isDeflate, len, buffer, offset) => {
     // 4 bytes
     // type (3 bits)
     //   0 = functionData
@@ -54,100 +40,266 @@ export const encodeHeader = (type, isDeflate, len) => {
     // len (28 bits)
     const encodedMeta = (type << 1) + (Number(isDeflate) | 0);
     const nr = (len << 4) + encodedMeta;
-    return nr;
+    writeUint32(buffer, nr, offset);
 };
-export const valueToBuffer = (payload) => {
-    // can use a more elloborate typed response e.g. number etc in there
-    if (payload === undefined) {
-        return Buffer.from([]);
+export const CONTENT_TYPE_JSON_U8 = new Uint8Array([255]);
+export const CONTENT_TYPE_UINT8_ARRAY_U8 = new Uint8Array([254]);
+export const CONTENT_TYPE_STRING_U8 = new Uint8Array([253]);
+export const CONTENT_TYPE_UNDEFINED_U8 = new Uint8Array([252]);
+export const CONTENT_TYPE_NULL_U8 = new Uint8Array([251]);
+export const CONTENT_TYPE_VERSION_1_U8 = new Uint8Array([250]);
+const EMPTY_BUFFER = new Uint8Array([]);
+export const cacheV2toV1 = (buf) => {
+    // 12 + 8
+    const isString = buf[20] === CONTENT_TYPE_STRING_U8[0];
+    if (isString) {
+        const header = decodeHeader(readUint32(buf, 0));
+        if (!header.isDeflate) {
+            const n = new Uint8Array(buf.byteLength - 1 + 2);
+            n.set(buf.subarray(0, 20), 0);
+            encodeHeader(header.type, header.isDeflate, header.len + 1, n, 0);
+            n[20] = 34; // "
+            n.set(buf.subarray(21), 21);
+            n[n.byteLength - 1] = 34; // "
+            return n;
+        }
+        else {
+            // very heavy rly sad..
+            const valBuffer = decodePayload(buf.subarray(20), true, false);
+            const newEncoded = valueToBufferV1(valBuffer, true);
+            const len = newEncoded.buf.byteLength;
+            const n = new Uint8Array(20 + len);
+            n.set(buf.subarray(0, 20), 0);
+            encodeHeader(header.type, header.isDeflate, 20 + len, n, 0);
+            n.set(newEncoded.buf, 20);
+            return n;
+        }
+    }
+    else {
+        const header = decodeHeader(readUint32(buf, 0));
+        const n = new Uint8Array(buf.byteLength - 1);
+        n.set(buf.subarray(0, 20), 0);
+        encodeHeader(header.type, header.isDeflate, header.len - 1, n, 0);
+        n.set(buf.subarray(21), 20);
+        return n;
     }
-    // TODO: only stringify if not string...
-    return Buffer.from(JSON.stringify(payload));
 };
-export const decodePayload = (payload, isDeflate) => {
-    if (!isDeflate) {
-        return textDecoder.decode(payload);
+export const diffV2toV1 = (buf) => {
+    // totally wrong...
+    // 12 + 16
+    const n = new Uint8Array(buf.byteLength - 1);
+    n.set(buf.subarray(0, 28), 0);
+    n.set(buf.subarray(29), 28);
+    return n;
+};
+export const valueToBufferV1 = (payload, deflate) => {
+    let buf;
+    if (payload === undefined) {
+        buf = new Uint8Array([]);
     }
-    try {
-        const buffer = zlib.inflateRawSync(payload);
-        return textDecoder.decode(buffer);
+    else {
+        try {
+            buf = ENCODER.encode(JSON.stringify(payload));
+        }
+        catch (err) {
+            console.log(payload);
+            buf = ENCODER.encode(payload);
+        }
     }
-    catch (err) {
-        console.error('Error deflating payload', err);
+    if (deflate && buf.byteLength > COMPRESS_FROM_BYTES) {
+        return {
+            contentByte: CONTENT_TYPE_VERSION_1_U8,
+            buf: zlib.deflateRawSync(buf, {}),
+            deflate: true,
+        };
     }
+    return {
+        contentByte: CONTENT_TYPE_VERSION_1_U8,
+        buf,
+        deflate: false,
+    };
 };
-export const parsePayload = (payload) => {
+// pass buffer and offset
+export const valueToBuffer = (payload, deflate) => {
+    if (payload === undefined) {
+        return {
+            contentByte: CONTENT_TYPE_UNDEFINED_U8,
+            deflate: false,
+            buf: EMPTY_BUFFER,
+        };
+    }
+    if (payload === null) {
+        return {
+            contentByte: CONTENT_TYPE_NULL_U8,
+            deflate: false,
+            buf: EMPTY_BUFFER,
+        };
+    }
     if (typeof payload === 'string') {
+        const buf = ENCODER.encode(payload);
+        if (deflate && buf.byteLength > COMPRESS_FROM_BYTES) {
+            return {
+                contentByte: CONTENT_TYPE_STRING_U8,
+                buf: zlib.deflateRawSync(buf, {}),
+                deflate: true,
+            };
+        }
+        return {
+            contentByte: CONTENT_TYPE_STRING_U8,
+            buf,
+            deflate: false,
+        };
+    }
+    // mark as based db query object
+    if (payload instanceof Uint8Array) {
+        return {
+            contentByte: CONTENT_TYPE_UINT8_ARRAY_U8,
+            buf: payload,
+            deflate: false,
+        };
+    }
+    const buf = ENCODER.encode(JSON.stringify(payload));
+    if (buf.byteLength > COMPRESS_FROM_BYTES) {
+        return {
+            contentByte: CONTENT_TYPE_JSON_U8,
+            buf: zlib.deflateRawSync(buf, {}),
+            deflate: true,
+        };
+    }
+    const result = {
+        contentByte: CONTENT_TYPE_JSON_U8,
+        buf,
+        deflate: false,
+    };
+    return result;
+};
+export const decodePayloadV1 = (payload, isDeflate) => {
+    if (!payload || payload.byteLength === 0) {
+        return undefined;
+    }
+    let p;
+    if (!isDeflate) {
+        p = DECODER.decode(payload);
+    }
+    else {
+        try {
+            p = zlib.inflateRawSync(payload).toString();
+        }
+        catch (err) {
+            console.error('Error deflating payload', err);
+        }
+    }
+    if (typeof p === 'string') {
         try {
-            return JSON.parse(payload);
+            return JSON.parse(p);
         }
         catch (err) { }
     }
-    return payload;
+    return p;
+};
+export const decodePayload = (payload, isDeflate, isOldClient) => {
+    if (isOldClient) {
+        return decodePayloadV1(payload, isDeflate);
+    }
+    const contentType = payload[0];
+    if (contentType === CONTENT_TYPE_UNDEFINED_U8[0]) {
+        return undefined;
+    }
+    if (contentType === CONTENT_TYPE_UINT8_ARRAY_U8[0]) {
+        return payload.subarray(1);
+    }
+    if (contentType === CONTENT_TYPE_STRING_U8[0]) {
+        if (isDeflate) {
+            return zlib.inflateRawSync(payload.subarray(1)).toString();
+        }
+        return DECODER.decode(payload.subarray(1));
+    }
+    if (contentType === CONTENT_TYPE_JSON_U8[0]) {
+        let str;
+        if (isDeflate) {
+            str = zlib.inflateRawSync(payload.subarray(1)).toString();
+        }
+        else {
+            str = DECODER.decode(payload.subarray(1));
+        }
+        if (typeof str === 'string') {
+            try {
+                return JSON.parse(str);
+            }
+            catch (err) { }
+        }
+        return str;
+    }
+    if (contentType === CONTENT_TYPE_NULL_U8[0]) {
+        return null;
+    }
 };
 export const decodeName = (arr, start, end) => {
-    const name = new Uint8Array(arr.slice(start, end));
-    return textDecoder.decode(name);
+    return DECODER.decode(arr.subarray(start, end));
 };
-export const encodeFunctionResponse = (id, buffer) => {
+export const encodeFunctionResponse = (id, val) => {
     // Type 0
     // | 4 header | 3 id | * payload |
-    let isDeflate = false;
-    // TODO: implement for streams!
-    // chunk isChunk | isNotCunk | isLastchunk 0|1 (use 1 bye for now?)
-    const chunks = 1;
-    if (buffer.length > COMPRESS_FROM_BYTES) {
-        isDeflate = true;
-        buffer = zlib.deflateRawSync(buffer, {});
-    }
-    if (chunks === 1) {
-        const headerSize = 4;
-        const idSize = 3;
-        const msgSize = idSize + buffer.length;
-        const header = encodeHeader(0, isDeflate, msgSize);
-        // not very nessecary but ok
+    const headerSize = 4;
+    const idSize = 3;
+    const isOld = val.contentByte[0] === CONTENT_TYPE_VERSION_1_U8[0];
+    if (isOld) {
+        const msgSize = idSize + val.buf.byteLength;
         const array = new Uint8Array(headerSize + msgSize);
-        storeUint8(array, header, 0, 4);
-        storeUint8(array, id, 4, 3);
-        if (buffer.length) {
-            array.set(buffer, 7);
+        encodeHeader(0, val.deflate, msgSize, array, 0);
+        writeUint24(array, id, 4);
+        if (val.buf.byteLength) {
+            array.set(val.buf, 7);
         }
         return array;
     }
     else {
-        console.warn('chunk not implemented yet');
-        return new Uint8Array(0);
+        const msgSize = idSize + val.buf.byteLength + 1;
+        const array = new Uint8Array(headerSize + msgSize);
+        encodeHeader(0, val.deflate, msgSize, array, 0);
+        writeUint24(array, id, 4);
+        array[7] = val.contentByte[0];
+        if (val.buf.byteLength) {
+            array.set(val.buf, 8);
+        }
+        return array;
     }
 };
-export const encodeStreamFunctionResponse = (id, buffer) => {
+export const encodeStreamFunctionResponse = (id, val) => {
     // Type 7
     // | 4 header | 1 subType | 3 id | * payload |
-    let isDeflate = false;
-    // TODO: implement for streams!
-    // chunk isChunk | isNotCunk | isLastchunk 0|1 (use 1 bye for now?)
     const chunks = 1;
-    if (buffer.length > COMPRESS_FROM_BYTES) {
-        isDeflate = true;
-        buffer = zlib.deflateRawSync(buffer, {});
-    }
     if (chunks === 1) {
         const headerSize = 4;
         const idSize = 3;
         const subTypeSize = 1;
-        const msgSize = idSize + subTypeSize + buffer.length;
-        const header = encodeHeader(7, isDeflate, msgSize);
-        // not very nessecary but ok
-        const array = new Uint8Array(headerSize + msgSize);
-        storeUint8(array, header, 0, 4);
-        storeUint8(array, 1, 4, 1);
-        storeUint8(array, id, 5, 3);
-        if (buffer.length) {
-            array.set(buffer, 8);
+        const isOld = val.contentByte[0] === CONTENT_TYPE_VERSION_1_U8[0];
+        if (isOld) {
+            const msgSize = idSize + subTypeSize + val.buf.byteLength;
+            const array = new Uint8Array(headerSize + msgSize);
+            encodeHeader(7, val.deflate, msgSize, array, 0);
+            array[4] = 1;
+            writeUint24(array, id, 5);
+            if (val.buf.byteLength) {
+                array.set(val.buf, 8);
+            }
+            return array;
+        }
+        else {
+            const msgSize = idSize + subTypeSize + val.buf.byteLength + 1;
+            const array = new Uint8Array(headerSize + msgSize);
+            encodeHeader(7, val.deflate, msgSize, array, 0);
+            array[4] = 1;
+            writeUint24(array, id, 5);
+            array[8] = val.contentByte[0];
+            if (val.buf.byteLength) {
+                array.set(val.buf, 9);
+            }
+            return array;
         }
-        return array;
     }
     else {
-        console.warn('chunk not implemented yet');
+        console.warn('Stream response to chunks not implemented yet');
         return new Uint8Array(0);
     }
 };
@@ -158,114 +310,149 @@ export const encodeStreamFunctionChunkResponse = (id, seqId, code = 0, maxChunkS
     if (maxChunkSize) {
         msgSize += 3;
     }
-    const header = encodeHeader(7, false, msgSize);
     const array = new Uint8Array(4 + msgSize);
-    storeUint8(array, header, 0, 4);
-    storeUint8(array, 2, 4, 1);
-    storeUint8(array, id, 5, 3);
-    storeUint8(array, seqId, 8, 1);
-    storeUint8(array, code, 9, 1);
+    encodeHeader(7, false, msgSize, array, 0);
+    array[4] = 2;
+    writeUint24(array, id, 5);
+    array[8] = seqId;
+    array[9] = code;
     if (maxChunkSize) {
-        storeUint8(array, maxChunkSize, 10, 3);
+        writeUint24(array, maxChunkSize, 10);
     }
     return array;
 };
 export const encodeGetResponse = (id) => {
     // Type 4
     // | 4 header | 8 id |
-    const header = encodeHeader(3, false, 8);
     const array = new Uint8Array(12);
-    storeUint8(array, header, 0, 4);
-    storeUint8(array, id, 4, 8);
+    encodeHeader(3, false, 8, array, 0);
+    writeUint64(array, id, 4);
     return array;
 };
 export const updateId = (payload, id) => {
-    const prevId = payload.slice(4, 12);
-    storeUint8(payload, id, 4, 8);
+    const prevId = payload.slice(4, 12); // does this actually copy! CHECK
+    writeUint64(payload, id, 4);
     return prevId;
 };
-export const encodeObservableResponse = (id, checksum, buffer) => {
+export const encodeObservableResponse = (id, checksum, val) => {
     // Type 1 (full data)
     // | 4 header | 8 id | 8 checksum | * payload |
-    let isDeflate = false;
-    if (buffer.length > COMPRESS_FROM_BYTES) {
-        isDeflate = true;
-        buffer = zlib.deflateRawSync(buffer, {});
+    const isOld = val.contentByte[0] === CONTENT_TYPE_VERSION_1_U8[0];
+    if (isOld) {
+        const msgSize = 16 + val.buf.byteLength;
+        const array = new Uint8Array(4 + msgSize);
+        encodeHeader(1, val.deflate, msgSize, array, 0);
+        writeUint64(array, id, 4);
+        writeUint64(array, checksum, 12);
+        if (val.buf.byteLength) {
+            array.set(val.buf, 20);
+        }
+        return [array, val.deflate];
     }
-    const msgSize = 16 + buffer.length;
-    const header = encodeHeader(1, isDeflate, msgSize);
-    const array = new Uint8Array(4 + msgSize);
-    storeUint8(array, header, 0, 4);
-    storeUint8(array, id, 4, 8);
-    storeUint8(array, checksum, 12, 8);
-    if (buffer.length) {
-        array.set(buffer, 20);
+    else {
+        const msgSize = 16 + val.buf.byteLength + 1;
+        const array = new Uint8Array(4 + msgSize);
+        encodeHeader(1, val.deflate, msgSize, array, 0);
+        writeUint64(array, id, 4);
+        writeUint64(array, checksum, 12);
+        array[20] = val.contentByte[0];
+        if (val.buf.byteLength) {
+            array.set(val.buf, 21);
+        }
+        return [array, val.deflate];
     }
-    return [array, isDeflate];
 };
-export const encodeObservableDiffResponse = (id, checksum, previousChecksum, buffer) => {
+export const encodeObservableDiffResponse = (id, checksum, previousChecksum, val) => {
     // Type 2 (diff data)
     // | 4 header | 8 id | 8 checksum | 8 previousChecksum | * diff |
-    let isDeflate = false;
-    if (buffer.length > COMPRESS_FROM_BYTES) {
-        isDeflate = true;
-        buffer = zlib.deflateRawSync(buffer, {});
+    const isOld = val.contentByte[0] === CONTENT_TYPE_VERSION_1_U8[0];
+    if (isOld) {
+        const msgSize = 24 + val.buf.byteLength;
+        const array = new Uint8Array(4 + msgSize);
+        encodeHeader(2, val.deflate, msgSize, array, 0);
+        writeUint64(array, id, 4);
+        writeUint64(array, checksum, 12);
+        writeUint64(array, previousChecksum, 20);
+        if (val.buf.byteLength) {
+            array.set(val.buf, 28);
+        }
     }
-    const msgSize = 24 + buffer.length;
-    const header = encodeHeader(2, isDeflate, msgSize);
-    const array = new Uint8Array(4 + msgSize);
-    storeUint8(array, header, 0, 4);
-    storeUint8(array, id, 4, 8);
-    storeUint8(array, checksum, 12, 8);
-    storeUint8(array, previousChecksum, 20, 8);
-    if (buffer.length) {
-        array.set(buffer, 28);
+    else {
+        const msgSize = 24 + val.buf.byteLength + 1;
+        const array = new Uint8Array(4 + msgSize);
+        encodeHeader(2, val.deflate, msgSize, array, 0);
+        writeUint64(array, id, 4);
+        writeUint64(array, checksum, 12);
+        writeUint64(array, previousChecksum, 20);
+        array[28] = val.contentByte[0];
+        if (val.buf.byteLength) {
+            array.set(val.buf, 29);
+        }
+        return array;
     }
-    return array;
 };
-const encodeSimpleResponse = (type, buffer) => {
+const encodeSimpleResponse = (type, val) => {
     // | 4 header | * payload |
-    let isDeflate = false;
-    if (buffer.length > COMPRESS_FROM_BYTES) {
-        isDeflate = true;
-        buffer = zlib.deflateRawSync(buffer, {});
+    const isOld = val.contentByte[0] === CONTENT_TYPE_VERSION_1_U8[0];
+    if (isOld) {
+        const headerSize = 4;
+        const msgSize = val.buf.byteLength;
+        const array = new Uint8Array(headerSize + msgSize);
+        encodeHeader(type, val.deflate, msgSize, array, 0);
+        if (val.buf.byteLength) {
+            array.set(val.buf, 4);
+        }
+        return array;
     }
-    const headerSize = 4;
-    const msgSize = buffer.length;
-    const header = encodeHeader(type, isDeflate, msgSize);
-    const array = new Uint8Array(headerSize + msgSize);
-    storeUint8(array, header, 0, 4);
-    if (buffer.length) {
-        array.set(buffer, 4);
+    else {
+        const headerSize = 4;
+        const msgSize = val.buf.byteLength + 1;
+        const array = new Uint8Array(headerSize + msgSize);
+        encodeHeader(type, val.deflate, msgSize, array, 0);
+        array[4] = val.contentByte[0];
+        if (val.buf.byteLength) {
+            array.set(val.buf, 5);
+        }
+        return array;
     }
-    return array;
 };
-export const encodeAuthResponse = (buffer) => {
+export const encodeAuthResponse = (val) => {
     // Type 4
-    return encodeSimpleResponse(4, buffer);
+    return encodeSimpleResponse(4, val);
 };
-export const encodeErrorResponse = (buffer) => {
+export const encodeErrorResponse = (val) => {
     // Type 5
-    return encodeSimpleResponse(5, buffer);
+    return encodeSimpleResponse(5, val);
 };
-export const encodeChannelMessage = (id, buffer) => {
+export const encodeChannelMessage = (id, val) => {
     // Type 7.0 (fill data)
     // | 4 header | 1 subType | 8 id | * payload |
-    let isDeflate = false;
-    if (buffer.length > COMPRESS_FROM_BYTES) {
-        isDeflate = true;
-        buffer = zlib.deflateRawSync(buffer, {});
+    const isOld = val.contentByte[0] === CONTENT_TYPE_VERSION_1_U8[0];
+    if (isOld) {
+        const msgSize = 8 + val.buf.byteLength + 1;
+        const array = new Uint8Array(4 + msgSize);
+        // sub protocol 7.0
+        array[4] = 0;
+        encodeHeader(7, val.deflate, msgSize, array, 0);
+        writeUint64(array, id, 5);
+        if (val.buf.byteLength) {
+            array.set(val.buf, 13);
+        }
+        return array;
     }
-    const msgSize = 8 + buffer.length + 1;
-    const header = encodeHeader(7, isDeflate, msgSize);
-    const array = new Uint8Array(4 + msgSize);
-    storeUint8(array, 0, 4, 1);
-    storeUint8(array, header, 0, 4);
-    storeUint8(array, id, 5, 8);
-    if (buffer.length) {
-        array.set(buffer, 13);
+    else {
+        const msgSize = 8 + val.buf.byteLength + 2;
+        const array = new Uint8Array(4 + msgSize);
+        encodeHeader(7, val.deflate, msgSize, array, 0);
+        // sub protocol 7.0
+        array[4] = 0;
+        writeUint64(array, id, 5);
+        array[13] = val.contentByte[0];
+        if (val.buf.byteLength) {
+            array.set(val.buf, 14);
+        }
+        return array;
     }
-    return array;
 };
 export const encodeReload = (type, seqId) => {
     // Type 7.3 (fill data)
@@ -273,17 +460,17 @@ export const encodeReload = (type, seqId) => {
     // 1 = browser
     // 2 = non-browser
     // | 4 header | 1 subType | 1 type \ 1 seqId
-    const msgSize = 7;
-    const header = encodeHeader(7, false, msgSize);
+    const msgSize = 3;
     const array = new Uint8Array(4 + msgSize);
-    storeUint8(array, header, 0, 4);
-    storeUint8(array, 3, 4, 1);
-    storeUint8(array, type, 5, 1);
-    storeUint8(array, seqId, 6, 1);
+    encodeHeader(7, false, msgSize, array, 0);
+    array[4] = 3;
+    array[5] = type;
+    array[6] = seqId;
     return array;
 };
-export const decode = (buffer) => {
-    const header = readUint8(buffer, 0, 4);
+// FIXME
+export const decode = (buffer, isOldClient) => {
+    const header = readUint32(buffer, 0);
     const { isDeflate, len, type } = decodeHeader(header);
     if (type === 1) {
         // | 4 header | 8 id | 8 checksum | * payload |
@@ -292,7 +479,8 @@ export const decode = (buffer) => {
         }
         const start = 20;
         const end = len + 4;
-        return decodePayload(buffer.slice(start, end), isDeflate);
+        //  very wrong
+        return decodePayload(buffer.slice(start, end), isDeflate, false);
     }
 };
 //# sourceMappingURL=protocol.js.map