minio
Version:
S3 Compatible Cloud Storage client
691 lines (676 loc) • 89 kB
JavaScript
import crc32 from 'buffer-crc32';
import { XMLParser } from 'fast-xml-parser';
import * as errors from "../errors.mjs";
import { SelectResults } from "../helpers.mjs";
import { isObject, parseXml, readableStream, sanitizeETag, sanitizeObjectKey, sanitizeSize, toArray } from "./helper.mjs";
import { readAsString } from "./response.mjs";
import { RETENTION_VALIDITY_UNITS } from "./type.mjs";
// parse XML response for bucket region
export function parseBucketRegion(xml) {
// return region information
return parseXml(xml).LocationConstraint;
}
const fxp = new XMLParser();
const fxpWithoutNumParser = new XMLParser({
// @ts-ignore
numberParseOptions: {
skipLike: /./
}
});
// Parse XML and return information as Javascript types
// parse error XML response
export function parseError(xml, headerInfo) {
let xmlErr = {};
const xmlObj = fxp.parse(xml);
if (xmlObj.Error) {
xmlErr = xmlObj.Error;
}
const e = new errors.S3Error();
Object.entries(xmlErr).forEach(([key, value]) => {
e[key.toLowerCase()] = value;
});
Object.entries(headerInfo).forEach(([key, value]) => {
e[key] = value;
});
return e;
}
// Generates an Error object depending on http statusCode and XML body
export async function parseResponseError(response) {
const statusCode = response.statusCode;
let code = '',
message = '';
if (statusCode === 301) {
code = 'MovedPermanently';
message = 'Moved Permanently';
} else if (statusCode === 307) {
code = 'TemporaryRedirect';
message = 'Are you using the correct endpoint URL?';
} else if (statusCode === 403) {
code = 'AccessDenied';
message = 'Valid and authorized credentials required';
} else if (statusCode === 404) {
code = 'NotFound';
message = 'Not Found';
} else if (statusCode === 405) {
code = 'MethodNotAllowed';
message = 'Method Not Allowed';
} else if (statusCode === 501) {
code = 'MethodNotAllowed';
message = 'Method Not Allowed';
} else if (statusCode === 503) {
code = 'SlowDown';
message = 'Please reduce your request rate.';
} else {
const hErrCode = response.headers['x-minio-error-code'];
const hErrDesc = response.headers['x-minio-error-desc'];
if (hErrCode && hErrDesc) {
code = hErrCode;
message = hErrDesc;
}
}
const headerInfo = {};
// A value created by S3 compatible server that uniquely identifies the request.
headerInfo.amzRequestid = response.headers['x-amz-request-id'];
// A special token that helps troubleshoot API replies and issues.
headerInfo.amzId2 = response.headers['x-amz-id-2'];
// Region where the bucket is located. This header is returned only
// in HEAD bucket and ListObjects response.
headerInfo.amzBucketRegion = response.headers['x-amz-bucket-region'];
const xmlString = await readAsString(response);
if (xmlString) {
throw parseError(xmlString, headerInfo);
}
// Message should be instantiated for each S3Errors.
const e = new errors.S3Error(message, {
cause: headerInfo
});
// S3 Error code.
e.code = code;
Object.entries(headerInfo).forEach(([key, value]) => {
// @ts-expect-error force set error properties
e[key] = value;
});
throw e;
}
/**
* parse XML response for list objects v2 with metadata in a bucket
*/
export function parseListObjectsV2WithMetadata(xml) {
const result = {
objects: [],
isTruncated: false,
nextContinuationToken: ''
};
let xmlobj = parseXml(xml);
if (!xmlobj.ListBucketResult) {
throw new errors.InvalidXMLError('Missing tag: "ListBucketResult"');
}
xmlobj = xmlobj.ListBucketResult;
if (xmlobj.IsTruncated) {
result.isTruncated = xmlobj.IsTruncated;
}
if (xmlobj.NextContinuationToken) {
result.nextContinuationToken = xmlobj.NextContinuationToken;
}
if (xmlobj.Contents) {
toArray(xmlobj.Contents).forEach(content => {
const name = sanitizeObjectKey(content.Key);
const lastModified = new Date(content.LastModified);
const etag = sanitizeETag(content.ETag);
const size = content.Size;
let tags = {};
if (content.UserTags != null) {
toArray(content.UserTags.split('&')).forEach(tag => {
const [key, value] = tag.split('=');
tags[key] = value;
});
} else {
tags = {};
}
let metadata;
if (content.UserMetadata != null) {
metadata = toArray(content.UserMetadata)[0];
} else {
metadata = null;
}
result.objects.push({
name,
lastModified,
etag,
size,
metadata,
tags
});
});
}
if (xmlobj.CommonPrefixes) {
toArray(xmlobj.CommonPrefixes).forEach(commonPrefix => {
result.objects.push({
prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]),
size: 0
});
});
}
return result;
}
// parse XML response for list parts of an in progress multipart upload
export function parseListParts(xml) {
let xmlobj = parseXml(xml);
const result = {
isTruncated: false,
parts: [],
marker: 0
};
if (!xmlobj.ListPartsResult) {
throw new errors.InvalidXMLError('Missing tag: "ListPartsResult"');
}
xmlobj = xmlobj.ListPartsResult;
if (xmlobj.IsTruncated) {
result.isTruncated = xmlobj.IsTruncated;
}
if (xmlobj.NextPartNumberMarker) {
result.marker = toArray(xmlobj.NextPartNumberMarker)[0] || '';
}
if (xmlobj.Part) {
toArray(xmlobj.Part).forEach(p => {
const part = parseInt(toArray(p.PartNumber)[0], 10);
const lastModified = new Date(p.LastModified);
const etag = p.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '');
result.parts.push({
part,
lastModified,
etag,
size: parseInt(p.Size, 10)
});
});
}
return result;
}
export function parseListBucket(xml) {
let result = [];
const listBucketResultParser = new XMLParser({
parseTagValue: true,
// Enable parsing of values
numberParseOptions: {
leadingZeros: false,
// Disable number parsing for values with leading zeros
hex: false,
// Disable hex number parsing - Invalid bucket name
skipLike: /^[0-9]+$/ // Skip number parsing if the value consists entirely of digits
},
tagValueProcessor: (tagName, tagValue = '') => {
// Ensure that the Name tag is always treated as a string
if (tagName === 'Name') {
return tagValue.toString();
}
return tagValue;
},
ignoreAttributes: false // Ensure that all attributes are parsed
});
const parsedXmlRes = listBucketResultParser.parse(xml);
if (!parsedXmlRes.ListAllMyBucketsResult) {
throw new errors.InvalidXMLError('Missing tag: "ListAllMyBucketsResult"');
}
const {
ListAllMyBucketsResult: {
Buckets = {}
} = {}
} = parsedXmlRes;
if (Buckets.Bucket) {
result = toArray(Buckets.Bucket).map((bucket = {}) => {
const {
Name: bucketName,
CreationDate
} = bucket;
const creationDate = new Date(CreationDate);
return {
name: bucketName,
creationDate
};
});
}
return result;
}
export function parseInitiateMultipart(xml) {
let xmlobj = parseXml(xml);
if (!xmlobj.InitiateMultipartUploadResult) {
throw new errors.InvalidXMLError('Missing tag: "InitiateMultipartUploadResult"');
}
xmlobj = xmlobj.InitiateMultipartUploadResult;
if (xmlobj.UploadId) {
return xmlobj.UploadId;
}
throw new errors.InvalidXMLError('Missing tag: "UploadId"');
}
export function parseReplicationConfig(xml) {
const xmlObj = parseXml(xml);
const {
Role,
Rule
} = xmlObj.ReplicationConfiguration;
return {
ReplicationConfiguration: {
role: Role,
rules: toArray(Rule)
}
};
}
export function parseObjectLegalHoldConfig(xml) {
const xmlObj = parseXml(xml);
return xmlObj.LegalHold;
}
export function parseTagging(xml) {
const xmlObj = parseXml(xml);
let result = [];
if (xmlObj.Tagging && xmlObj.Tagging.TagSet && xmlObj.Tagging.TagSet.Tag) {
const tagResult = xmlObj.Tagging.TagSet.Tag;
// if it is a single tag convert into an array so that the return value is always an array.
if (isObject(tagResult)) {
result.push(tagResult);
} else {
result = tagResult;
}
}
return result;
}
// parse XML response when a multipart upload is completed
export function parseCompleteMultipart(xml) {
const xmlobj = parseXml(xml).CompleteMultipartUploadResult;
if (xmlobj.Location) {
const location = toArray(xmlobj.Location)[0];
const bucket = toArray(xmlobj.Bucket)[0];
const key = xmlobj.Key;
const etag = xmlobj.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '');
return {
location,
bucket,
key,
etag
};
}
// Complete Multipart can return XML Error after a 200 OK response
if (xmlobj.Code && xmlobj.Message) {
const errCode = toArray(xmlobj.Code)[0];
const errMessage = toArray(xmlobj.Message)[0];
return {
errCode,
errMessage
};
}
}
// parse XML response for listing in-progress multipart uploads
export function parseListMultipart(xml) {
const result = {
prefixes: [],
uploads: [],
isTruncated: false,
nextKeyMarker: '',
nextUploadIdMarker: ''
};
let xmlobj = parseXml(xml);
if (!xmlobj.ListMultipartUploadsResult) {
throw new errors.InvalidXMLError('Missing tag: "ListMultipartUploadsResult"');
}
xmlobj = xmlobj.ListMultipartUploadsResult;
if (xmlobj.IsTruncated) {
result.isTruncated = xmlobj.IsTruncated;
}
if (xmlobj.NextKeyMarker) {
result.nextKeyMarker = xmlobj.NextKeyMarker;
}
if (xmlobj.NextUploadIdMarker) {
result.nextUploadIdMarker = xmlobj.nextUploadIdMarker || '';
}
if (xmlobj.CommonPrefixes) {
toArray(xmlobj.CommonPrefixes).forEach(prefix => {
// @ts-expect-error index check
result.prefixes.push({
prefix: sanitizeObjectKey(toArray(prefix.Prefix)[0])
});
});
}
if (xmlobj.Upload) {
toArray(xmlobj.Upload).forEach(upload => {
const uploadItem = {
key: upload.Key,
uploadId: upload.UploadId,
storageClass: upload.StorageClass,
initiated: new Date(upload.Initiated)
};
if (upload.Initiator) {
uploadItem.initiator = {
id: upload.Initiator.ID,
displayName: upload.Initiator.DisplayName
};
}
if (upload.Owner) {
uploadItem.owner = {
id: upload.Owner.ID,
displayName: upload.Owner.DisplayName
};
}
result.uploads.push(uploadItem);
});
}
return result;
}
export function parseObjectLockConfig(xml) {
const xmlObj = parseXml(xml);
let lockConfigResult = {};
if (xmlObj.ObjectLockConfiguration) {
lockConfigResult = {
objectLockEnabled: xmlObj.ObjectLockConfiguration.ObjectLockEnabled
};
let retentionResp;
if (xmlObj.ObjectLockConfiguration && xmlObj.ObjectLockConfiguration.Rule && xmlObj.ObjectLockConfiguration.Rule.DefaultRetention) {
retentionResp = xmlObj.ObjectLockConfiguration.Rule.DefaultRetention || {};
lockConfigResult.mode = retentionResp.Mode;
}
if (retentionResp) {
const isUnitYears = retentionResp.Years;
if (isUnitYears) {
lockConfigResult.validity = isUnitYears;
lockConfigResult.unit = RETENTION_VALIDITY_UNITS.YEARS;
} else {
lockConfigResult.validity = retentionResp.Days;
lockConfigResult.unit = RETENTION_VALIDITY_UNITS.DAYS;
}
}
}
return lockConfigResult;
}
export function parseBucketVersioningConfig(xml) {
const xmlObj = parseXml(xml);
return xmlObj.VersioningConfiguration;
}
// Used only in selectObjectContent API.
// extractHeaderType extracts the first half of the header message, the header type.
function extractHeaderType(stream) {
const headerNameLen = Buffer.from(stream.read(1)).readUInt8();
const headerNameWithSeparator = Buffer.from(stream.read(headerNameLen)).toString();
const splitBySeparator = (headerNameWithSeparator || '').split(':');
return splitBySeparator.length >= 1 ? splitBySeparator[1] : '';
}
function extractHeaderValue(stream) {
const bodyLen = Buffer.from(stream.read(2)).readUInt16BE();
return Buffer.from(stream.read(bodyLen)).toString();
}
export function parseSelectObjectContentResponse(res) {
const selectResults = new SelectResults({}); // will be returned
const responseStream = readableStream(res); // convert byte array to a readable responseStream
// @ts-ignore
while (responseStream._readableState.length) {
// Top level responseStream read tracker.
let msgCrcAccumulator; // accumulate from start of the message till the message crc start.
const totalByteLengthBuffer = Buffer.from(responseStream.read(4));
msgCrcAccumulator = crc32(totalByteLengthBuffer);
const headerBytesBuffer = Buffer.from(responseStream.read(4));
msgCrcAccumulator = crc32(headerBytesBuffer, msgCrcAccumulator);
const calculatedPreludeCrc = msgCrcAccumulator.readInt32BE(); // use it to check if any CRC mismatch in header itself.
const preludeCrcBuffer = Buffer.from(responseStream.read(4)); // read 4 bytes i.e 4+4 =8 + 4 = 12 ( prelude + prelude crc)
msgCrcAccumulator = crc32(preludeCrcBuffer, msgCrcAccumulator);
const totalMsgLength = totalByteLengthBuffer.readInt32BE();
const headerLength = headerBytesBuffer.readInt32BE();
const preludeCrcByteValue = preludeCrcBuffer.readInt32BE();
if (preludeCrcByteValue !== calculatedPreludeCrc) {
// Handle Header CRC mismatch Error
throw new Error(`Header Checksum Mismatch, Prelude CRC of ${preludeCrcByteValue} does not equal expected CRC of ${calculatedPreludeCrc}`);
}
const headers = {};
if (headerLength > 0) {
const headerBytes = Buffer.from(responseStream.read(headerLength));
msgCrcAccumulator = crc32(headerBytes, msgCrcAccumulator);
const headerReaderStream = readableStream(headerBytes);
// @ts-ignore
while (headerReaderStream._readableState.length) {
const headerTypeName = extractHeaderType(headerReaderStream);
headerReaderStream.read(1); // just read and ignore it.
if (headerTypeName) {
headers[headerTypeName] = extractHeaderValue(headerReaderStream);
}
}
}
let payloadStream;
const payLoadLength = totalMsgLength - headerLength - 16;
if (payLoadLength > 0) {
const payLoadBuffer = Buffer.from(responseStream.read(payLoadLength));
msgCrcAccumulator = crc32(payLoadBuffer, msgCrcAccumulator);
// read the checksum early and detect any mismatch so we can avoid unnecessary further processing.
const messageCrcByteValue = Buffer.from(responseStream.read(4)).readInt32BE();
const calculatedCrc = msgCrcAccumulator.readInt32BE();
// Handle message CRC Error
if (messageCrcByteValue !== calculatedCrc) {
throw new Error(`Message Checksum Mismatch, Message CRC of ${messageCrcByteValue} does not equal expected CRC of ${calculatedCrc}`);
}
payloadStream = readableStream(payLoadBuffer);
}
const messageType = headers['message-type'];
switch (messageType) {
case 'error':
{
const errorMessage = headers['error-code'] + ':"' + headers['error-message'] + '"';
throw new Error(errorMessage);
}
case 'event':
{
const contentType = headers['content-type'];
const eventType = headers['event-type'];
switch (eventType) {
case 'End':
{
selectResults.setResponse(res);
return selectResults;
}
case 'Records':
{
var _payloadStream;
const readData = (_payloadStream = payloadStream) === null || _payloadStream === void 0 ? void 0 : _payloadStream.read(payLoadLength);
selectResults.setRecords(readData);
break;
}
case 'Progress':
{
switch (contentType) {
case 'text/xml':
{
var _payloadStream2;
const progressData = (_payloadStream2 = payloadStream) === null || _payloadStream2 === void 0 ? void 0 : _payloadStream2.read(payLoadLength);
selectResults.setProgress(progressData.toString());
break;
}
default:
{
const errorMessage = `Unexpected content-type ${contentType} sent for event-type Progress`;
throw new Error(errorMessage);
}
}
}
break;
case 'Stats':
{
switch (contentType) {
case 'text/xml':
{
var _payloadStream3;
const statsData = (_payloadStream3 = payloadStream) === null || _payloadStream3 === void 0 ? void 0 : _payloadStream3.read(payLoadLength);
selectResults.setStats(statsData.toString());
break;
}
default:
{
const errorMessage = `Unexpected content-type ${contentType} sent for event-type Stats`;
throw new Error(errorMessage);
}
}
}
break;
default:
{
// Continuation message: Not sure if it is supported. did not find a reference or any message in response.
// It does not have a payload.
const warningMessage = `Un implemented event detected ${messageType}.`;
// eslint-disable-next-line no-console
console.warn(warningMessage);
}
}
}
}
}
}
export function parseLifecycleConfig(xml) {
const xmlObj = parseXml(xml);
return xmlObj.LifecycleConfiguration;
}
export function parseBucketEncryptionConfig(xml) {
return parseXml(xml);
}
export function parseObjectRetentionConfig(xml) {
const xmlObj = parseXml(xml);
const retentionConfig = xmlObj.Retention;
return {
mode: retentionConfig.Mode,
retainUntilDate: retentionConfig.RetainUntilDate
};
}
export function removeObjectsParser(xml) {
const xmlObj = parseXml(xml);
if (xmlObj.DeleteResult && xmlObj.DeleteResult.Error) {
// return errors as array always. as the response is object in case of single object passed in removeObjects
return toArray(xmlObj.DeleteResult.Error);
}
return [];
}
// parse XML response for copy object
export function parseCopyObject(xml) {
const result = {
etag: '',
lastModified: ''
};
let xmlobj = parseXml(xml);
if (!xmlobj.CopyObjectResult) {
throw new errors.InvalidXMLError('Missing tag: "CopyObjectResult"');
}
xmlobj = xmlobj.CopyObjectResult;
if (xmlobj.ETag) {
result.etag = xmlobj.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '');
}
if (xmlobj.LastModified) {
result.lastModified = new Date(xmlobj.LastModified);
}
return result;
}
const formatObjInfo = (content, opts = {}) => {
const {
Key,
LastModified,
ETag,
Size,
VersionId,
IsLatest
} = content;
if (!isObject(opts)) {
opts = {};
}
const name = sanitizeObjectKey(toArray(Key)[0] || '');
const lastModified = LastModified ? new Date(toArray(LastModified)[0] || '') : undefined;
const etag = sanitizeETag(toArray(ETag)[0] || '');
const size = sanitizeSize(Size || '');
return {
name,
lastModified,
etag,
size,
versionId: VersionId,
isLatest: IsLatest,
isDeleteMarker: opts.IsDeleteMarker ? opts.IsDeleteMarker : false
};
};
// parse XML response for list objects in a bucket
export function parseListObjects(xml) {
const result = {
objects: [],
isTruncated: false,
nextMarker: undefined,
versionIdMarker: undefined
};
let isTruncated = false;
let nextMarker, nextVersionKeyMarker;
const xmlobj = fxpWithoutNumParser.parse(xml);
const parseCommonPrefixesEntity = commonPrefixEntry => {
if (commonPrefixEntry) {
toArray(commonPrefixEntry).forEach(commonPrefix => {
result.objects.push({
prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0] || ''),
size: 0
});
});
}
};
const listBucketResult = xmlobj.ListBucketResult;
const listVersionsResult = xmlobj.ListVersionsResult;
if (listBucketResult) {
if (listBucketResult.IsTruncated) {
isTruncated = listBucketResult.IsTruncated;
}
if (listBucketResult.Contents) {
toArray(listBucketResult.Contents).forEach(content => {
const name = sanitizeObjectKey(toArray(content.Key)[0] || '');
const lastModified = new Date(toArray(content.LastModified)[0] || '');
const etag = sanitizeETag(toArray(content.ETag)[0] || '');
const size = sanitizeSize(content.Size || '');
result.objects.push({
name,
lastModified,
etag,
size
});
});
}
if (listBucketResult.Marker) {
nextMarker = listBucketResult.Marker;
} else if (isTruncated && result.objects.length > 0) {
var _result$objects;
nextMarker = (_result$objects = result.objects[result.objects.length - 1]) === null || _result$objects === void 0 ? void 0 : _result$objects.name;
}
if (listBucketResult.CommonPrefixes) {
parseCommonPrefixesEntity(listBucketResult.CommonPrefixes);
}
}
if (listVersionsResult) {
if (listVersionsResult.IsTruncated) {
isTruncated = listVersionsResult.IsTruncated;
}
if (listVersionsResult.Version) {
toArray(listVersionsResult.Version).forEach(content => {
result.objects.push(formatObjInfo(content));
});
}
if (listVersionsResult.DeleteMarker) {
toArray(listVersionsResult.DeleteMarker).forEach(content => {
result.objects.push(formatObjInfo(content, {
IsDeleteMarker: true
}));
});
}
if (listVersionsResult.NextKeyMarker) {
nextVersionKeyMarker = listVersionsResult.NextKeyMarker;
}
if (listVersionsResult.NextVersionIdMarker) {
result.versionIdMarker = listVersionsResult.NextVersionIdMarker;
}
if (listVersionsResult.CommonPrefixes) {
parseCommonPrefixesEntity(listVersionsResult.CommonPrefixes);
}
}
result.isTruncated = isTruncated;
if (isTruncated) {
result.nextMarker = nextVersionKeyMarker || nextMarker;
}
return result;
}
export function uploadPartParser(xml) {
const xmlObj = parseXml(xml);
const respEl = xmlObj.CopyPartResult;
return respEl;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["crc32","XMLParser","errors","SelectResults","isObject","parseXml","readableStream","sanitizeETag","sanitizeObjectKey","sanitizeSize","toArray","readAsString","RETENTION_VALIDITY_UNITS","parseBucketRegion","xml","LocationConstraint","fxp","fxpWithoutNumParser","numberParseOptions","skipLike","parseError","headerInfo","xmlErr","xmlObj","parse","Error","e","S3Error","Object","entries","forEach","key","value","toLowerCase","parseResponseError","response","statusCode","code","message","hErrCode","headers","hErrDesc","amzRequestid","amzId2","amzBucketRegion","xmlString","cause","parseListObjectsV2WithMetadata","result","objects","isTruncated","nextContinuationToken","xmlobj","ListBucketResult","InvalidXMLError","IsTruncated","NextContinuationToken","Contents","content","name","Key","lastModified","Date","LastModified","etag","ETag","size","Size","tags","UserTags","split","tag","metadata","UserMetadata","push","CommonPrefixes","commonPrefix","prefix","Prefix","parseListParts","parts","marker","ListPartsResult","NextPartNumberMarker","Part","p","part","parseInt","PartNumber","replace","parseListBucket","listBucketResultParser","parseTagValue","leadingZeros","hex","tagValueProcessor","tagName","tagValue","toString","ignoreAttributes","parsedXmlRes","ListAllMyBucketsResult","Buckets","Bucket","map","bucket","Name","bucketName","CreationDate","creationDate","parseInitiateMultipart","InitiateMultipartUploadResult","UploadId","parseReplicationConfig","Role","Rule","ReplicationConfiguration","role","rules","parseObjectLegalHoldConfig","LegalHold","parseTagging","Tagging","TagSet","Tag","tagResult","parseCompleteMultipart","CompleteMultipartUploadResult","Location","location","Code","Message","errCode","errMessage","parseListMultipart","prefixes","uploads","nextKeyMarker","nextUploadIdMarker","ListMultipartUploadsResult","NextKeyMarker","NextUploadIdMarker","Upload","upload","uploadItem","uploadId","storageClass","StorageClass","initiated","Initiated","Initiator","initiator","id","ID","displayName","DisplayName","Owner","owner","parseObjectLockConfig","lockConfigResult","ObjectLockConfiguration","objectLockEnabled","ObjectLockEnabled","retentionResp","DefaultRetention","mode","Mode","isUnitYears","Years","validity","unit","YEARS","Days","DAYS","parseBucketVersioningConfig","VersioningConfiguration","extractHeaderType","stream","headerNameLen","Buffer","from","read","readUInt8","headerNameWithSeparator","splitBySeparator","length","extractHeaderValue","bodyLen","readUInt16BE","parseSelectObjectContentResponse","res","selectResults","responseStream","_readableState","msgCrcAccumulator","totalByteLengthBuffer","headerBytesBuffer","calculatedPreludeCrc","readInt32BE","preludeCrcBuffer","totalMsgLength","headerLength","preludeCrcByteValue","headerBytes","headerReaderStream","headerTypeName","payloadStream","payLoadLength","payLoadBuffer","messageCrcByteValue","calculatedCrc","messageType","errorMessage","contentType","eventType","setResponse","_payloadStream","readData","setRecords","_payloadStream2","progressData","setProgress","_payloadStream3","statsData","setStats","warningMessage","console","warn","parseLifecycleConfig","LifecycleConfiguration","parseBucketEncryptionConfig","parseObjectRetentionConfig","retentionConfig","Retention","retainUntilDate","RetainUntilDate","removeObjectsParser","DeleteResult","parseCopyObject","CopyObjectResult","formatObjInfo","opts","VersionId","IsLatest","undefined","versionId","isLatest","isDeleteMarker","IsDeleteMarker","parseListObjects","nextMarker","versionIdMarker","nextVersionKeyMarker","parseCommonPrefixesEntity","commonPrefixEntry","listBucketResult","listVersionsResult","ListVersionsResult","Marker","_result$objects","Version","DeleteMarker","NextVersionIdMarker","uploadPartParser","respEl","CopyPartResult"],"sources":["xml-parser.ts"],"sourcesContent":["import type * as http from 'node:http'\nimport type stream from 'node:stream'\n\nimport crc32 from 'buffer-crc32'\nimport { XMLParser } from 'fast-xml-parser'\n\nimport * as errors from '../errors.ts'\nimport { SelectResults } from '../helpers.ts'\nimport { isObject, parseXml, readableStream, sanitizeETag, sanitizeObjectKey, sanitizeSize, toArray } from './helper.ts'\nimport { readAsString } from './response.ts'\nimport type {\n  BucketItemFromList,\n  BucketItemWithMetadata,\n  CommonPrefix,\n  CopyObjectResultV1,\n  ListBucketResultV1,\n  ObjectInfo,\n  ObjectLockInfo,\n  ObjectRowEntry,\n  ReplicationConfig,\n  Tags,\n} from './type.ts'\nimport { RETENTION_VALIDITY_UNITS } from './type.ts'\n\n// parse XML response for bucket region\nexport function parseBucketRegion(xml: string): string {\n  // return region information\n  return parseXml(xml).LocationConstraint\n}\n\nconst fxp = new XMLParser()\n\nconst fxpWithoutNumParser = new XMLParser({\n  // @ts-ignore\n  numberParseOptions: {\n    skipLike: /./,\n  },\n})\n\n// Parse XML and return information as Javascript types\n// parse error XML response\nexport function parseError(xml: string, headerInfo: Record<string, unknown>) {\n  let xmlErr = {}\n  const xmlObj = fxp.parse(xml)\n  if (xmlObj.Error) {\n    xmlErr = xmlObj.Error\n  }\n  const e = new errors.S3Error() as unknown as Record<string, unknown>\n  Object.entries(xmlErr).forEach(([key, value]) => {\n    e[key.toLowerCase()] = value\n  })\n  Object.entries(headerInfo).forEach(([key, value]) => {\n    e[key] = value\n  })\n  return e\n}\n\n// Generates an Error object depending on http statusCode and XML body\nexport async function parseResponseError(response: http.IncomingMessage): Promise<Record<string, string>> {\n  const statusCode = response.statusCode\n  let code = '',\n    message = ''\n  if (statusCode === 301) {\n    code = 'MovedPermanently'\n    message = 'Moved Permanently'\n  } else if (statusCode === 307) {\n    code = 'TemporaryRedirect'\n    message = 'Are you using the correct endpoint URL?'\n  } else if (statusCode === 403) {\n    code = 'AccessDenied'\n    message = 'Valid and authorized credentials required'\n  } else if (statusCode === 404) {\n    code = 'NotFound'\n    message = 'Not Found'\n  } else if (statusCode === 405) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else if (statusCode === 501) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else if (statusCode === 503) {\n    code = 'SlowDown'\n    message = 'Please reduce your request rate.'\n  } else {\n    const hErrCode = response.headers['x-minio-error-code'] as string\n    const hErrDesc = response.headers['x-minio-error-desc'] as string\n\n    if (hErrCode && hErrDesc) {\n      code = hErrCode\n      message = hErrDesc\n    }\n  }\n  const headerInfo: Record<string, string | undefined | null> = {}\n  // A value created by S3 compatible server that uniquely identifies the request.\n  headerInfo.amzRequestid = response.headers['x-amz-request-id'] as string | undefined\n  // A special token that helps troubleshoot API replies and issues.\n  headerInfo.amzId2 = response.headers['x-amz-id-2'] as string | undefined\n\n  // Region where the bucket is located. This header is returned only\n  // in HEAD bucket and ListObjects response.\n  headerInfo.amzBucketRegion = response.headers['x-amz-bucket-region'] as string | undefined\n\n  const xmlString = await readAsString(response)\n\n  if (xmlString) {\n    throw parseError(xmlString, headerInfo)\n  }\n\n  // Message should be instantiated for each S3Errors.\n  const e = new errors.S3Error(message, { cause: headerInfo })\n  // S3 Error code.\n  e.code = code\n  Object.entries(headerInfo).forEach(([key, value]) => {\n    // @ts-expect-error force set error properties\n    e[key] = value\n  })\n\n  throw e\n}\n\n/**\n * parse XML response for list objects v2 with metadata in a bucket\n */\nexport function parseListObjectsV2WithMetadata(xml: string) {\n  const result: {\n    objects: Array<BucketItemWithMetadata>\n    isTruncated: boolean\n    nextContinuationToken: string\n  } = {\n    objects: [],\n    isTruncated: false,\n    nextContinuationToken: '',\n  }\n\n  let xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      const name = sanitizeObjectKey(content.Key)\n      const lastModified = new Date(content.LastModified)\n      const etag = sanitizeETag(content.ETag)\n      const size = content.Size\n\n      let tags: Tags = {}\n      if (content.UserTags != null) {\n        toArray(content.UserTags.split('&')).forEach((tag) => {\n          const [key, value] = tag.split('=')\n          tags[key] = value\n        })\n      } else {\n        tags = {}\n      }\n\n      let metadata\n      if (content.UserMetadata != null) {\n        metadata = toArray(content.UserMetadata)[0]\n      } else {\n        metadata = null\n      }\n      result.objects.push({ name, lastModified, etag, size, metadata, tags })\n    })\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\nexport type UploadedPart = {\n  part: number\n  lastModified?: Date\n  etag: string\n  size: number\n}\n\n// parse XML response for list parts of an in progress multipart upload\nexport function parseListParts(xml: string): {\n  isTruncated: boolean\n  marker: number\n  parts: UploadedPart[]\n} {\n  let xmlobj = parseXml(xml)\n  const result: {\n    isTruncated: boolean\n    marker: number\n    parts: UploadedPart[]\n  } = {\n    isTruncated: false,\n    parts: [],\n    marker: 0,\n  }\n  if (!xmlobj.ListPartsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListPartsResult\"')\n  }\n  xmlobj = xmlobj.ListPartsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextPartNumberMarker) {\n    result.marker = toArray(xmlobj.NextPartNumberMarker)[0] || ''\n  }\n  if (xmlobj.Part) {\n    toArray(xmlobj.Part).forEach((p) => {\n      const part = parseInt(toArray(p.PartNumber)[0], 10)\n      const lastModified = new Date(p.LastModified)\n      const etag = p.ETag.replace(/^\"/g, '')\n        .replace(/\"$/g, '')\n        .replace(/^&quot;/g, '')\n        .replace(/&quot;$/g, '')\n        .replace(/^&#34;/g, '')\n        .replace(/&#34;$/g, '')\n      result.parts.push({ part, lastModified, etag, size: parseInt(p.Size, 10) })\n    })\n  }\n  return result\n}\n\nexport function parseListBucket(xml: string): BucketItemFromList[] {\n  let result: BucketItemFromList[] = []\n  const listBucketResultParser = new XMLParser({\n    parseTagValue: true, // Enable parsing of values\n    numberParseOptions: {\n      leadingZeros: false, // Disable number parsing for values with leading zeros\n      hex: false, // Disable hex number parsing - Invalid bucket name\n      skipLike: /^[0-9]+$/, // Skip number parsing if the value consists entirely of digits\n    },\n    tagValueProcessor: (tagName, tagValue = '') => {\n      // Ensure that the Name tag is always treated as a string\n      if (tagName === 'Name') {\n        return tagValue.toString()\n      }\n      return tagValue\n    },\n    ignoreAttributes: false, // Ensure that all attributes are parsed\n  })\n\n  const parsedXmlRes = listBucketResultParser.parse(xml)\n\n  if (!parsedXmlRes.ListAllMyBucketsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListAllMyBucketsResult\"')\n  }\n\n  const { ListAllMyBucketsResult: { Buckets = {} } = {} } = parsedXmlRes\n\n  if (Buckets.Bucket) {\n    result = toArray(Buckets.Bucket).map((bucket = {}) => {\n      const { Name: bucketName, CreationDate } = bucket\n      const creationDate = new Date(CreationDate)\n\n      return { name: bucketName, creationDate }\n    })\n  }\n\n  return result\n}\n\nexport function parseInitiateMultipart(xml: string): string {\n  let xmlobj = parseXml(xml)\n\n  if (!xmlobj.InitiateMultipartUploadResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"InitiateMultipartUploadResult\"')\n  }\n  xmlobj = xmlobj.InitiateMultipartUploadResult\n\n  if (xmlobj.UploadId) {\n    return xmlobj.UploadId\n  }\n  throw new errors.InvalidXMLError('Missing tag: \"UploadId\"')\n}\n\nexport function parseReplicationConfig(xml: string): ReplicationConfig {\n  const xmlObj = parseXml(xml)\n  const { Role, Rule } = xmlObj.ReplicationConfiguration\n  return {\n    ReplicationConfiguration: {\n      role: Role,\n      rules: toArray(Rule),\n    },\n  }\n}\n\nexport function parseObjectLegalHoldConfig(xml: string) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LegalHold\n}\n\nexport function parseTagging(xml: string) {\n  const xmlObj = parseXml(xml)\n  let result = []\n  if (xmlObj.Tagging && xmlObj.Tagging.TagSet && xmlObj.Tagging.TagSet.Tag) {\n    const tagResult = xmlObj.Tagging.TagSet.Tag\n    // if it is a single tag convert into an array so that the return value is always an array.\n    if (isObject(tagResult)) {\n      result.push(tagResult)\n    } else {\n      result = tagResult\n    }\n  }\n  return result\n}\n\n// parse XML response when a multipart upload is completed\nexport function parseCompleteMultipart(xml: string) {\n  const xmlobj = parseXml(xml).CompleteMultipartUploadResult\n  if (xmlobj.Location) {\n    const location = toArray(xmlobj.Location)[0]\n    const bucket = toArray(xmlobj.Bucket)[0]\n    const key = xmlobj.Key\n    const etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n\n    return { location, bucket, key, etag }\n  }\n  // Complete Multipart can return XML Error after a 200 OK response\n  if (xmlobj.Code && xmlobj.Message) {\n    const errCode = toArray(xmlobj.Code)[0]\n    const errMessage = toArray(xmlobj.Message)[0]\n    return { errCode, errMessage }\n  }\n}\n\ntype UploadID = string\n\nexport type ListMultipartResult = {\n  uploads: {\n    key: string\n    uploadId: UploadID\n    initiator?: { id: string; displayName: string }\n    owner?: { id: string; displayName: string }\n    storageClass: unknown\n    initiated: Date\n  }[]\n  prefixes: {\n    prefix: string\n  }[]\n  isTruncated: boolean\n  nextKeyMarker: string\n  nextUploadIdMarker: string\n}\n\n// parse XML response for listing in-progress multipart uploads\nexport function parseListMultipart(xml: string): ListMultipartResult {\n  const result: ListMultipartResult = {\n    prefixes: [],\n    uploads: [],\n    isTruncated: false,\n    nextKeyMarker: '',\n    nextUploadIdMarker: '',\n  }\n\n  let xmlobj = parseXml(xml)\n\n  if (!xmlobj.ListMultipartUploadsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListMultipartUploadsResult\"')\n  }\n  xmlobj = xmlobj.ListMultipartUploadsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextKeyMarker) {\n    result.nextKeyMarker = xmlobj.NextKeyMarker\n  }\n  if (xmlobj.NextUploadIdMarker) {\n    result.nextUploadIdMarker = xmlobj.nextUploadIdMarker || ''\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((prefix) => {\n      // @ts-expect-error index check\n      result.prefixes.push({ prefix: sanitizeObjectKey(toArray<string>(prefix.Prefix)[0]) })\n    })\n  }\n\n  if (xmlobj.Upload) {\n    toArray(xmlobj.Upload).forEach((upload) => {\n      const uploadItem: ListMultipartResult['uploads'][number] = {\n        key: upload.Key,\n        uploadId: upload.UploadId,\n        storageClass: upload.StorageClass,\n        initiated: new Date(upload.Initiated),\n      }\n      if (upload.Initiator) {\n        uploadItem.initiator = { id: upload.Initiator.ID, displayName: upload.Initiator.DisplayName }\n      }\n      if (upload.Owner) {\n        uploadItem.owner = { id: upload.Owner.ID, displayName: upload.Owner.DisplayName }\n      }\n      result.uploads.push(uploadItem)\n    })\n  }\n  return result\n}\n\nexport function parseObjectLockConfig(xml: string): ObjectLockInfo {\n  const xmlObj = parseXml(xml)\n  let lockConfigResult = {} as ObjectLockInfo\n  if (xmlObj.ObjectLockConfiguration) {\n    lockConfigResult = {\n      objectLockEnabled: xmlObj.ObjectLockConfiguration.ObjectLockEnabled,\n    } as ObjectLockInfo\n    let retentionResp\n    if (\n      xmlObj.ObjectLockConfiguration &&\n      xmlObj.ObjectLockConfiguration.Rule &&\n      xmlObj.ObjectLockConfiguration.Rule.DefaultRetention\n    ) {\n      retentionResp = xmlObj.ObjectLockConfiguration.Rule.DefaultRetention || {}\n      lockConfigResult.mode = retentionResp.Mode\n    }\n    if (retentionResp) {\n      const isUnitYears = retentionResp.Years\n      if (isUnitYears) {\n        lockConfigResult.validity = isUnitYears\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.YEARS\n      } else {\n        lockConfigResult.validity = retentionResp.Days\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.DAYS\n      }\n    }\n  }\n\n  return lockConfigResult\n}\n\nexport function parseBucketVersioningConfig(xml: string) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.VersioningConfiguration\n}\n\n// Used only in selectObjectContent API.\n// extractHeaderType extracts the first half of the header message, the header type.\nfunction extractHeaderType(stream: stream.Readable): string | undefined {\n  const headerNameLen = Buffer.from(stream.read(1)).readUInt8()\n  const headerNameWithSeparator = Buffer.from(stream.read(headerNameLen)).toString()\n  const splitBySeparator = (headerNameWithSeparator || '').split(':')\n  return splitBySeparator.length >= 1 ? splitBySeparator[1] : ''\n}\n\nfunction extractHeaderValue(stream: stream.Readable) {\n  const bodyLen = Buffer.from(stream.read(2)).readUInt16BE()\n  return Buffer.from(stream.read(bodyLen)).toString()\n}\n\nexport function parseSelectObjectContentResponse(res: Buffer) {\n  const selectResults = new SelectResults({}) // will be returned\n\n  const responseStream = readableStream(res) // convert byte array to a readable responseStream\n  // @ts-ignore\n  while (responseStream._readableState.length) {\n    // Top level responseStream read tracker.\n    let msgCrcAccumulator // accumulate from start of the message till the message crc start.\n\n    const totalByteLengthBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(totalByteLengthBuffer)\n\n    const headerBytesBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(headerBytesBuffer, msgCrcAccumulator)\n\n    const calculatedPreludeCrc = msgCrcAccumulator.readInt32BE() // use it to check if any CRC mismatch in header itself.\n\n    const preludeCrcBuffer = Buffer.from(responseStream.read(4)) // read 4 bytes    i.e 4+4 =8 + 4 = 12 ( prelude + prelude crc)\n    msgCrcAccumulator = crc32(preludeCrcBuffer, msgCrcAccumulator)\n\n    const totalMsgLength = totalByteLengthBuffer.readInt32BE()\n    const headerLength = headerBytesBuffer.readInt32BE()\n    const preludeCrcByteValue = preludeCrcBuffer.readInt32BE()\n\n    if (preludeCrcByteValue !== calculatedPreludeCrc) {\n      // Handle Header CRC mismatch Error\n      throw new Error(\n        `Header Checksum Mismatch, Prelude CRC of ${preludeCrcByteValue} does not equal expected CRC of ${calculatedPreludeCrc}`,\n      )\n    }\n\n    const headers: Record<string, unknown> = {}\n    if (headerLength > 0) {\n      const headerBytes = Buffer.from(responseStream.read(headerLength))\n      msgCrcAccumulator = crc32(headerBytes, msgCrcAccumulator)\n      const headerReaderStream = readableStream(headerBytes)\n      // @ts-ignore\n      while (headerReaderStream._readableState.length) {\n        const hea