182 lines
7.7 KiB
JavaScript
182 lines
7.7 KiB
JavaScript
import { fromHex, toHex } from "@smithy/util-hex-encoding";
|
|
import { Int64 } from "./Int64";
|
|
export class HeaderMarshaller {
|
|
constructor(toUtf8, fromUtf8) {
|
|
this.toUtf8 = toUtf8;
|
|
this.fromUtf8 = fromUtf8;
|
|
}
|
|
format(headers) {
|
|
const chunks = [];
|
|
for (const headerName of Object.keys(headers)) {
|
|
const bytes = this.fromUtf8(headerName);
|
|
chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
|
|
}
|
|
const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
|
|
let position = 0;
|
|
for (const chunk of chunks) {
|
|
out.set(chunk, position);
|
|
position += chunk.byteLength;
|
|
}
|
|
return out;
|
|
}
|
|
formatHeaderValue(header) {
|
|
switch (header.type) {
|
|
case "boolean":
|
|
return Uint8Array.from([header.value ? 0 : 1]);
|
|
case "byte":
|
|
return Uint8Array.from([2, header.value]);
|
|
case "short":
|
|
const shortView = new DataView(new ArrayBuffer(3));
|
|
shortView.setUint8(0, 3);
|
|
shortView.setInt16(1, header.value, false);
|
|
return new Uint8Array(shortView.buffer);
|
|
case "integer":
|
|
const intView = new DataView(new ArrayBuffer(5));
|
|
intView.setUint8(0, 4);
|
|
intView.setInt32(1, header.value, false);
|
|
return new Uint8Array(intView.buffer);
|
|
case "long":
|
|
const longBytes = new Uint8Array(9);
|
|
longBytes[0] = 5;
|
|
longBytes.set(header.value.bytes, 1);
|
|
return longBytes;
|
|
case "binary":
|
|
const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
|
|
binView.setUint8(0, 6);
|
|
binView.setUint16(1, header.value.byteLength, false);
|
|
const binBytes = new Uint8Array(binView.buffer);
|
|
binBytes.set(header.value, 3);
|
|
return binBytes;
|
|
case "string":
|
|
const utf8Bytes = this.fromUtf8(header.value);
|
|
const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
|
|
strView.setUint8(0, 7);
|
|
strView.setUint16(1, utf8Bytes.byteLength, false);
|
|
const strBytes = new Uint8Array(strView.buffer);
|
|
strBytes.set(utf8Bytes, 3);
|
|
return strBytes;
|
|
case "timestamp":
|
|
const tsBytes = new Uint8Array(9);
|
|
tsBytes[0] = 8;
|
|
tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
|
|
return tsBytes;
|
|
case "uuid":
|
|
if (!UUID_PATTERN.test(header.value)) {
|
|
throw new Error(`Invalid UUID received: ${header.value}`);
|
|
}
|
|
const uuidBytes = new Uint8Array(17);
|
|
uuidBytes[0] = 9;
|
|
uuidBytes.set(fromHex(header.value.replace(/\-/g, "")), 1);
|
|
return uuidBytes;
|
|
}
|
|
}
|
|
parse(headers) {
|
|
const out = {};
|
|
let position = 0;
|
|
while (position < headers.byteLength) {
|
|
const nameLength = headers.getUint8(position++);
|
|
const name = this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, nameLength));
|
|
position += nameLength;
|
|
switch (headers.getUint8(position++)) {
|
|
case 0:
|
|
out[name] = {
|
|
type: BOOLEAN_TAG,
|
|
value: true,
|
|
};
|
|
break;
|
|
case 1:
|
|
out[name] = {
|
|
type: BOOLEAN_TAG,
|
|
value: false,
|
|
};
|
|
break;
|
|
case 2:
|
|
out[name] = {
|
|
type: BYTE_TAG,
|
|
value: headers.getInt8(position++),
|
|
};
|
|
break;
|
|
case 3:
|
|
out[name] = {
|
|
type: SHORT_TAG,
|
|
value: headers.getInt16(position, false),
|
|
};
|
|
position += 2;
|
|
break;
|
|
case 4:
|
|
out[name] = {
|
|
type: INT_TAG,
|
|
value: headers.getInt32(position, false),
|
|
};
|
|
position += 4;
|
|
break;
|
|
case 5:
|
|
out[name] = {
|
|
type: LONG_TAG,
|
|
value: new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)),
|
|
};
|
|
position += 8;
|
|
break;
|
|
case 6:
|
|
const binaryLength = headers.getUint16(position, false);
|
|
position += 2;
|
|
out[name] = {
|
|
type: BINARY_TAG,
|
|
value: new Uint8Array(headers.buffer, headers.byteOffset + position, binaryLength),
|
|
};
|
|
position += binaryLength;
|
|
break;
|
|
case 7:
|
|
const stringLength = headers.getUint16(position, false);
|
|
position += 2;
|
|
out[name] = {
|
|
type: STRING_TAG,
|
|
value: this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, stringLength)),
|
|
};
|
|
position += stringLength;
|
|
break;
|
|
case 8:
|
|
out[name] = {
|
|
type: TIMESTAMP_TAG,
|
|
value: new Date(new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)).valueOf()),
|
|
};
|
|
position += 8;
|
|
break;
|
|
case 9:
|
|
const uuidBytes = new Uint8Array(headers.buffer, headers.byteOffset + position, 16);
|
|
position += 16;
|
|
out[name] = {
|
|
type: UUID_TAG,
|
|
value: `${toHex(uuidBytes.subarray(0, 4))}-${toHex(uuidBytes.subarray(4, 6))}-${toHex(uuidBytes.subarray(6, 8))}-${toHex(uuidBytes.subarray(8, 10))}-${toHex(uuidBytes.subarray(10))}`,
|
|
};
|
|
break;
|
|
default:
|
|
throw new Error(`Unrecognized header type tag`);
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
}
|
|
var HEADER_VALUE_TYPE;
|
|
(function (HEADER_VALUE_TYPE) {
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolTrue"] = 0] = "boolTrue";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolFalse"] = 1] = "boolFalse";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byte"] = 2] = "byte";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["short"] = 3] = "short";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["integer"] = 4] = "integer";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["long"] = 5] = "long";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byteArray"] = 6] = "byteArray";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["string"] = 7] = "string";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["timestamp"] = 8] = "timestamp";
|
|
HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["uuid"] = 9] = "uuid";
|
|
})(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
|
|
const BOOLEAN_TAG = "boolean";
|
|
const BYTE_TAG = "byte";
|
|
const SHORT_TAG = "short";
|
|
const INT_TAG = "integer";
|
|
const LONG_TAG = "long";
|
|
const BINARY_TAG = "binary";
|
|
const STRING_TAG = "string";
|
|
const TIMESTAMP_TAG = "timestamp";
|
|
const UUID_TAG = "uuid";
|
|
const UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
|