fix: 修复配额说明重复和undefined问题
- 在editStorageForm中初始化oss_storage_quota_value和oss_quota_unit - 删除重复的旧配额说明块，保留新的当前配额设置显示 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
388
backend/node_modules/@smithy/eventstream-codec/dist-cjs/index.js
generated
vendored
Normal file
388
backend/node_modules/@smithy/eventstream-codec/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,388 @@
|
||||
'use strict';
|
||||
|
||||
var crc32 = require('@aws-crypto/crc32');
|
||||
var utilHexEncoding = require('@smithy/util-hex-encoding');
|
||||
|
||||
class Int64 {
|
||||
bytes;
|
||||
constructor(bytes) {
|
||||
this.bytes = bytes;
|
||||
if (bytes.byteLength !== 8) {
|
||||
throw new Error("Int64 buffers must be exactly 8 bytes");
|
||||
}
|
||||
}
|
||||
static fromNumber(number) {
|
||||
if (number > 9_223_372_036_854_775_807 || number < -9223372036854776e3) {
|
||||
throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
|
||||
}
|
||||
const bytes = new Uint8Array(8);
|
||||
for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) {
|
||||
bytes[i] = remaining;
|
||||
}
|
||||
if (number < 0) {
|
||||
negate(bytes);
|
||||
}
|
||||
return new Int64(bytes);
|
||||
}
|
||||
valueOf() {
|
||||
const bytes = this.bytes.slice(0);
|
||||
const negative = bytes[0] & 0b10000000;
|
||||
if (negative) {
|
||||
negate(bytes);
|
||||
}
|
||||
return parseInt(utilHexEncoding.toHex(bytes), 16) * (negative ? -1 : 1);
|
||||
}
|
||||
toString() {
|
||||
return String(this.valueOf());
|
||||
}
|
||||
}
|
||||
function negate(bytes) {
|
||||
for (let i = 0; i < 8; i++) {
|
||||
bytes[i] ^= 0xff;
|
||||
}
|
||||
for (let i = 7; i > -1; i--) {
|
||||
bytes[i]++;
|
||||
if (bytes[i] !== 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
class HeaderMarshaller {
|
||||
toUtf8;
|
||||
fromUtf8;
|
||||
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(utilHexEncoding.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: `${utilHexEncoding.toHex(uuidBytes.subarray(0, 4))}-${utilHexEncoding.toHex(uuidBytes.subarray(4, 6))}-${utilHexEncoding.toHex(uuidBytes.subarray(6, 8))}-${utilHexEncoding.toHex(uuidBytes.subarray(8, 10))}-${utilHexEncoding.toHex(uuidBytes.subarray(10))}`,
|
||||
};
|
||||
break;
|
||||
default:
|
||||
throw new Error(`Unrecognized header type tag`);
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
}
|
||||
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}$/;
|
||||
|
||||
const PRELUDE_MEMBER_LENGTH = 4;
|
||||
const PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
|
||||
const CHECKSUM_LENGTH = 4;
|
||||
const MINIMUM_MESSAGE_LENGTH = PRELUDE_LENGTH + CHECKSUM_LENGTH * 2;
|
||||
function splitMessage({ byteLength, byteOffset, buffer }) {
|
||||
if (byteLength < MINIMUM_MESSAGE_LENGTH) {
|
||||
throw new Error("Provided message too short to accommodate event stream message overhead");
|
||||
}
|
||||
const view = new DataView(buffer, byteOffset, byteLength);
|
||||
const messageLength = view.getUint32(0, false);
|
||||
if (byteLength !== messageLength) {
|
||||
throw new Error("Reported message length does not match received message length");
|
||||
}
|
||||
const headerLength = view.getUint32(PRELUDE_MEMBER_LENGTH, false);
|
||||
const expectedPreludeChecksum = view.getUint32(PRELUDE_LENGTH, false);
|
||||
const expectedMessageChecksum = view.getUint32(byteLength - CHECKSUM_LENGTH, false);
|
||||
const checksummer = new crc32.Crc32().update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
|
||||
if (expectedPreludeChecksum !== checksummer.digest()) {
|
||||
throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digest()})`);
|
||||
}
|
||||
checksummer.update(new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH)));
|
||||
if (expectedMessageChecksum !== checksummer.digest()) {
|
||||
throw new Error(`The message checksum (${checksummer.digest()}) did not match the expected value of ${expectedMessageChecksum}`);
|
||||
}
|
||||
return {
|
||||
headers: new DataView(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH, headerLength),
|
||||
body: new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH + headerLength, messageLength - headerLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH + CHECKSUM_LENGTH)),
|
||||
};
|
||||
}
|
||||
|
||||
class EventStreamCodec {
|
||||
headerMarshaller;
|
||||
messageBuffer;
|
||||
isEndOfStream;
|
||||
constructor(toUtf8, fromUtf8) {
|
||||
this.headerMarshaller = new HeaderMarshaller(toUtf8, fromUtf8);
|
||||
this.messageBuffer = [];
|
||||
this.isEndOfStream = false;
|
||||
}
|
||||
feed(message) {
|
||||
this.messageBuffer.push(this.decode(message));
|
||||
}
|
||||
endOfStream() {
|
||||
this.isEndOfStream = true;
|
||||
}
|
||||
getMessage() {
|
||||
const message = this.messageBuffer.pop();
|
||||
const isEndOfStream = this.isEndOfStream;
|
||||
return {
|
||||
getMessage() {
|
||||
return message;
|
||||
},
|
||||
isEndOfStream() {
|
||||
return isEndOfStream;
|
||||
},
|
||||
};
|
||||
}
|
||||
getAvailableMessages() {
|
||||
const messages = this.messageBuffer;
|
||||
this.messageBuffer = [];
|
||||
const isEndOfStream = this.isEndOfStream;
|
||||
return {
|
||||
getMessages() {
|
||||
return messages;
|
||||
},
|
||||
isEndOfStream() {
|
||||
return isEndOfStream;
|
||||
},
|
||||
};
|
||||
}
|
||||
encode({ headers: rawHeaders, body }) {
|
||||
const headers = this.headerMarshaller.format(rawHeaders);
|
||||
const length = headers.byteLength + body.byteLength + 16;
|
||||
const out = new Uint8Array(length);
|
||||
const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
|
||||
const checksum = new crc32.Crc32();
|
||||
view.setUint32(0, length, false);
|
||||
view.setUint32(4, headers.byteLength, false);
|
||||
view.setUint32(8, checksum.update(out.subarray(0, 8)).digest(), false);
|
||||
out.set(headers, 12);
|
||||
out.set(body, headers.byteLength + 12);
|
||||
view.setUint32(length - 4, checksum.update(out.subarray(8, length - 4)).digest(), false);
|
||||
return out;
|
||||
}
|
||||
decode(message) {
|
||||
const { headers, body } = splitMessage(message);
|
||||
return { headers: this.headerMarshaller.parse(headers), body };
|
||||
}
|
||||
formatHeaders(rawHeaders) {
|
||||
return this.headerMarshaller.format(rawHeaders);
|
||||
}
|
||||
}
|
||||
|
||||
class MessageDecoderStream {
|
||||
options;
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
}
|
||||
[Symbol.asyncIterator]() {
|
||||
return this.asyncIterator();
|
||||
}
|
||||
async *asyncIterator() {
|
||||
for await (const bytes of this.options.inputStream) {
|
||||
const decoded = this.options.decoder.decode(bytes);
|
||||
yield decoded;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class MessageEncoderStream {
|
||||
options;
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
}
|
||||
[Symbol.asyncIterator]() {
|
||||
return this.asyncIterator();
|
||||
}
|
||||
async *asyncIterator() {
|
||||
for await (const msg of this.options.messageStream) {
|
||||
const encoded = this.options.encoder.encode(msg);
|
||||
yield encoded;
|
||||
}
|
||||
if (this.options.includeEndFrame) {
|
||||
yield new Uint8Array(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class SmithyMessageDecoderStream {
|
||||
options;
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
}
|
||||
[Symbol.asyncIterator]() {
|
||||
return this.asyncIterator();
|
||||
}
|
||||
async *asyncIterator() {
|
||||
for await (const message of this.options.messageStream) {
|
||||
const deserialized = await this.options.deserializer(message);
|
||||
if (deserialized === undefined)
|
||||
continue;
|
||||
yield deserialized;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class SmithyMessageEncoderStream {
|
||||
options;
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
}
|
||||
[Symbol.asyncIterator]() {
|
||||
return this.asyncIterator();
|
||||
}
|
||||
async *asyncIterator() {
|
||||
for await (const chunk of this.options.inputStream) {
|
||||
const payloadBuf = this.options.serializer(chunk);
|
||||
yield payloadBuf;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
exports.EventStreamCodec = EventStreamCodec;
|
||||
exports.HeaderMarshaller = HeaderMarshaller;
|
||||
exports.Int64 = Int64;
|
||||
exports.MessageDecoderStream = MessageDecoderStream;
|
||||
exports.MessageEncoderStream = MessageEncoderStream;
|
||||
exports.SmithyMessageDecoderStream = SmithyMessageDecoderStream;
|
||||
exports.SmithyMessageEncoderStream = SmithyMessageEncoderStream;
|
||||
Reference in New Issue
Block a user