602 lines
61 KiB
JavaScript
602 lines
61 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.calculateEvenSplits = calculateEvenSplits;
|
|
exports.extractMetadata = extractMetadata;
|
|
exports.getContentLength = getContentLength;
|
|
exports.getEncryptionHeaders = getEncryptionHeaders;
|
|
exports.getScope = getScope;
|
|
exports.getSourceVersionId = getSourceVersionId;
|
|
exports.getVersionId = getVersionId;
|
|
exports.hashBinary = hashBinary;
|
|
exports.insertContentType = insertContentType;
|
|
exports.isAmazonEndpoint = isAmazonEndpoint;
|
|
exports.isAmzHeader = isAmzHeader;
|
|
exports.isBoolean = isBoolean;
|
|
exports.isDefined = isDefined;
|
|
exports.isEmpty = isEmpty;
|
|
exports.isEmptyObject = isEmptyObject;
|
|
exports.isFunction = isFunction;
|
|
exports.isNumber = isNumber;
|
|
exports.isObject = isObject;
|
|
exports.isReadableStream = isReadableStream;
|
|
exports.isStorageClassHeader = isStorageClassHeader;
|
|
exports.isString = isString;
|
|
exports.isSupportedHeader = isSupportedHeader;
|
|
exports.isValidBucketName = isValidBucketName;
|
|
exports.isValidDate = isValidDate;
|
|
exports.isValidDomain = isValidDomain;
|
|
exports.isValidEndpoint = isValidEndpoint;
|
|
exports.isValidIP = isValidIP;
|
|
exports.isValidObjectName = isValidObjectName;
|
|
exports.isValidPort = isValidPort;
|
|
exports.isValidPrefix = isValidPrefix;
|
|
exports.isVirtualHostStyle = isVirtualHostStyle;
|
|
exports.makeDateLong = makeDateLong;
|
|
exports.makeDateShort = makeDateShort;
|
|
exports.parseXml = parseXml;
|
|
exports.partsRequired = partsRequired;
|
|
exports.pipesetup = pipesetup;
|
|
exports.prependXAMZMeta = prependXAMZMeta;
|
|
exports.probeContentType = probeContentType;
|
|
exports.readableStream = readableStream;
|
|
exports.sanitizeETag = sanitizeETag;
|
|
exports.sanitizeObjectKey = sanitizeObjectKey;
|
|
exports.sanitizeSize = sanitizeSize;
|
|
exports.toArray = toArray;
|
|
exports.toMd5 = toMd5;
|
|
exports.toSha256 = toSha256;
|
|
exports.uriEscape = uriEscape;
|
|
exports.uriResourceEscape = uriResourceEscape;
|
|
var crypto = _interopRequireWildcard(require("crypto"), true);
|
|
var stream = _interopRequireWildcard(require("stream"), true);
|
|
var _fastXmlParser = require("fast-xml-parser");
|
|
var _ipaddr = require("ipaddr.js");
|
|
var _lodash = require("lodash");
|
|
var mime = _interopRequireWildcard(require("mime-types"), true);
|
|
var _async = require("./async.js");
|
|
var _type = require("./type.js");
|
|
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
/*
|
|
* MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
const MetaDataHeaderPrefix = 'x-amz-meta-';
|
|
function hashBinary(buf, enableSHA256) {
|
|
let sha256sum = '';
|
|
if (enableSHA256) {
|
|
sha256sum = crypto.createHash('sha256').update(buf).digest('hex');
|
|
}
|
|
const md5sum = crypto.createHash('md5').update(buf).digest('base64');
|
|
return {
|
|
md5sum,
|
|
sha256sum
|
|
};
|
|
}
|
|
|
|
// S3 percent-encodes some extra non-standard characters in a URI . So comply with S3.
|
|
const encodeAsHex = c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
|
|
function uriEscape(uriStr) {
|
|
return encodeURIComponent(uriStr).replace(/[!'()*]/g, encodeAsHex);
|
|
}
|
|
function uriResourceEscape(string) {
|
|
return uriEscape(string).replace(/%2F/g, '/');
|
|
}
|
|
function getScope(region, date, serviceName = 's3') {
|
|
return `${makeDateShort(date)}/${region}/${serviceName}/aws4_request`;
|
|
}
|
|
|
|
/**
|
|
* isAmazonEndpoint - true if endpoint is 's3.amazonaws.com' or 's3.cn-north-1.amazonaws.com.cn'
|
|
*/
|
|
function isAmazonEndpoint(endpoint) {
|
|
return endpoint === 's3.amazonaws.com' || endpoint === 's3.cn-north-1.amazonaws.com.cn';
|
|
}
|
|
|
|
/**
|
|
* isVirtualHostStyle - verify if bucket name is support with virtual
|
|
* hosts. bucketNames with periods should be always treated as path
|
|
* style if the protocol is 'https:', this is due to SSL wildcard
|
|
* limitation. For all other buckets and Amazon S3 endpoint we will
|
|
* default to virtual host style.
|
|
*/
|
|
function isVirtualHostStyle(endpoint, protocol, bucket, pathStyle) {
|
|
if (protocol === 'https:' && bucket.includes('.')) {
|
|
return false;
|
|
}
|
|
return isAmazonEndpoint(endpoint) || !pathStyle;
|
|
}
|
|
function isValidIP(ip) {
|
|
return _ipaddr.isValid(ip);
|
|
}
|
|
|
|
/**
|
|
* @returns if endpoint is valid domain.
|
|
*/
|
|
function isValidEndpoint(endpoint) {
|
|
return isValidDomain(endpoint) || isValidIP(endpoint);
|
|
}
|
|
|
|
/**
|
|
* @returns if input host is a valid domain.
|
|
*/
|
|
function isValidDomain(host) {
|
|
if (!isString(host)) {
|
|
return false;
|
|
}
|
|
// See RFC 1035, RFC 3696.
|
|
if (host.length === 0 || host.length > 255) {
|
|
return false;
|
|
}
|
|
// Host cannot start or end with a '-'
|
|
if (host[0] === '-' || host.slice(-1) === '-') {
|
|
return false;
|
|
}
|
|
// Host cannot start or end with a '_'
|
|
if (host[0] === '_' || host.slice(-1) === '_') {
|
|
return false;
|
|
}
|
|
// Host cannot start with a '.'
|
|
if (host[0] === '.') {
|
|
return false;
|
|
}
|
|
const nonAlphaNumerics = '`~!@#$%^&*()+={}[]|\\"\';:><?/';
|
|
// All non alphanumeric characters are invalid.
|
|
for (const char of nonAlphaNumerics) {
|
|
if (host.includes(char)) {
|
|
return false;
|
|
}
|
|
}
|
|
// No need to regexp match, since the list is non-exhaustive.
|
|
// We let it be valid and fail later.
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Probes contentType using file extensions.
|
|
*
|
|
* @example
|
|
* ```
|
|
* // return 'image/png'
|
|
* probeContentType('file.png')
|
|
* ```
|
|
*/
|
|
function probeContentType(path) {
|
|
let contentType = mime.lookup(path);
|
|
if (!contentType) {
|
|
contentType = 'application/octet-stream';
|
|
}
|
|
return contentType;
|
|
}
|
|
|
|
/**
|
|
* is input port valid.
|
|
*/
|
|
function isValidPort(port) {
|
|
// Convert string port to number if needed
|
|
const portNum = typeof port === 'string' ? parseInt(port, 10) : port;
|
|
|
|
// verify if port is a valid number
|
|
if (!isNumber(portNum) || isNaN(portNum)) {
|
|
return false;
|
|
}
|
|
|
|
// port `0` is valid and special case
|
|
return 0 <= portNum && portNum <= 65535;
|
|
}
|
|
function isValidBucketName(bucket) {
|
|
if (!isString(bucket)) {
|
|
return false;
|
|
}
|
|
|
|
// bucket length should be less than and no more than 63
|
|
// characters long.
|
|
if (bucket.length < 3 || bucket.length > 63) {
|
|
return false;
|
|
}
|
|
// bucket with successive periods is invalid.
|
|
if (bucket.includes('..')) {
|
|
return false;
|
|
}
|
|
// bucket cannot have ip address style.
|
|
if (/[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/.test(bucket)) {
|
|
return false;
|
|
}
|
|
// bucket should begin with alphabet/number and end with alphabet/number,
|
|
// with alphabet/number/.- in the middle.
|
|
if (/^[a-z0-9][a-z0-9.-]+[a-z0-9]$/.test(bucket)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* check if objectName is a valid object name
|
|
*/
|
|
function isValidObjectName(objectName) {
|
|
if (!isValidPrefix(objectName)) {
|
|
return false;
|
|
}
|
|
return objectName.length !== 0;
|
|
}
|
|
|
|
/**
|
|
* check if prefix is valid
|
|
*/
|
|
function isValidPrefix(prefix) {
|
|
if (!isString(prefix)) {
|
|
return false;
|
|
}
|
|
if (prefix.length > 1024) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* check if typeof arg number
|
|
*/
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
|
|
/**
|
|
* check if typeof arg function
|
|
*/
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
|
|
/**
|
|
* check if typeof arg string
|
|
*/
|
|
function isString(arg) {
|
|
return typeof arg === 'string';
|
|
}
|
|
|
|
/**
|
|
* check if typeof arg object
|
|
*/
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg !== null;
|
|
}
|
|
|
|
/**
|
|
* check if object is readable stream
|
|
*/
|
|
function isReadableStream(arg) {
|
|
// eslint-disable-next-line @typescript-eslint/unbound-method
|
|
return isObject(arg) && isFunction(arg._read);
|
|
}
|
|
|
|
/**
|
|
* check if arg is boolean
|
|
*/
|
|
function isBoolean(arg) {
|
|
return typeof arg === 'boolean';
|
|
}
|
|
function isEmpty(o) {
|
|
return _lodash.isEmpty(o);
|
|
}
|
|
function isEmptyObject(o) {
|
|
return Object.values(o).filter(x => x !== undefined).length !== 0;
|
|
}
|
|
function isDefined(o) {
|
|
return o !== null && o !== undefined;
|
|
}
|
|
|
|
/**
|
|
* check if arg is a valid date
|
|
*/
|
|
function isValidDate(arg) {
|
|
// @ts-expect-error checknew Date(Math.NaN)
|
|
return arg instanceof Date && !isNaN(arg);
|
|
}
|
|
|
|
/**
|
|
* Create a Date string with format: 'YYYYMMDDTHHmmss' + Z
|
|
*/
|
|
function makeDateLong(date) {
|
|
date = date || new Date();
|
|
|
|
// Gives format like: '2017-08-07T16:28:59.889Z'
|
|
const s = date.toISOString();
|
|
return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 13) + s.slice(14, 16) + s.slice(17, 19) + 'Z';
|
|
}
|
|
|
|
/**
|
|
* Create a Date string with format: 'YYYYMMDD'
|
|
*/
|
|
function makeDateShort(date) {
|
|
date = date || new Date();
|
|
|
|
// Gives format like: '2017-08-07T16:28:59.889Z'
|
|
const s = date.toISOString();
|
|
return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 10);
|
|
}
|
|
|
|
/**
|
|
* pipesetup sets up pipe() from left to right os streams array
|
|
* pipesetup will also make sure that error emitted at any of the upstream Stream
|
|
* will be emitted at the last stream. This makes error handling simple
|
|
*/
|
|
function pipesetup(...streams) {
|
|
// @ts-expect-error ts can't narrow this
|
|
return streams.reduce((src, dst) => {
|
|
src.on('error', err => dst.emit('error', err));
|
|
return src.pipe(dst);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* return a Readable stream that emits data
|
|
*/
|
|
function readableStream(data) {
|
|
const s = new stream.Readable();
|
|
s._read = () => {};
|
|
s.push(data);
|
|
s.push(null);
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* Process metadata to insert appropriate value to `content-type` attribute
|
|
*/
|
|
function insertContentType(metaData, filePath) {
|
|
// check if content-type attribute present in metaData
|
|
for (const key in metaData) {
|
|
if (key.toLowerCase() === 'content-type') {
|
|
return metaData;
|
|
}
|
|
}
|
|
|
|
// if `content-type` attribute is not present in metadata, then infer it from the extension in filePath
|
|
return {
|
|
...metaData,
|
|
'content-type': probeContentType(filePath)
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Function prepends metadata with the appropriate prefix if it is not already on
|
|
*/
|
|
function prependXAMZMeta(metaData) {
|
|
if (!metaData) {
|
|
return {};
|
|
}
|
|
return _lodash.mapKeys(metaData, (value, key) => {
|
|
if (isAmzHeader(key) || isSupportedHeader(key) || isStorageClassHeader(key)) {
|
|
return key;
|
|
}
|
|
return MetaDataHeaderPrefix + key;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks if it is a valid header according to the AmazonS3 API
|
|
*/
|
|
function isAmzHeader(key) {
|
|
const temp = key.toLowerCase();
|
|
return temp.startsWith(MetaDataHeaderPrefix) || temp === 'x-amz-acl' || temp.startsWith('x-amz-server-side-encryption-') || temp === 'x-amz-server-side-encryption';
|
|
}
|
|
|
|
/**
|
|
* Checks if it is a supported Header
|
|
*/
|
|
function isSupportedHeader(key) {
|
|
const supported_headers = ['content-type', 'cache-control', 'content-encoding', 'content-disposition', 'content-language', 'x-amz-website-redirect-location', 'if-none-match', 'if-match'];
|
|
return supported_headers.includes(key.toLowerCase());
|
|
}
|
|
|
|
/**
|
|
* Checks if it is a storage header
|
|
*/
|
|
function isStorageClassHeader(key) {
|
|
return key.toLowerCase() === 'x-amz-storage-class';
|
|
}
|
|
function extractMetadata(headers) {
|
|
return _lodash.mapKeys(_lodash.pickBy(headers, (value, key) => isSupportedHeader(key) || isStorageClassHeader(key) || isAmzHeader(key)), (value, key) => {
|
|
const lower = key.toLowerCase();
|
|
if (lower.startsWith(MetaDataHeaderPrefix)) {
|
|
return lower.slice(MetaDataHeaderPrefix.length);
|
|
}
|
|
return key;
|
|
});
|
|
}
|
|
function getVersionId(headers = {}) {
|
|
return headers['x-amz-version-id'] || null;
|
|
}
|
|
function getSourceVersionId(headers = {}) {
|
|
return headers['x-amz-copy-source-version-id'] || null;
|
|
}
|
|
function sanitizeETag(etag = '') {
|
|
const replaceChars = {
|
|
'"': '',
|
|
'"': '',
|
|
'"': '',
|
|
'"': '',
|
|
'"': ''
|
|
};
|
|
return etag.replace(/^("|"|")|("|"|")$/g, m => replaceChars[m]);
|
|
}
|
|
function toMd5(payload) {
|
|
// use string from browser and buffer from nodejs
|
|
// browser support is tested only against minio server
|
|
return crypto.createHash('md5').update(Buffer.from(payload)).digest().toString('base64');
|
|
}
|
|
function toSha256(payload) {
|
|
return crypto.createHash('sha256').update(payload).digest('hex');
|
|
}
|
|
|
|
/**
|
|
* toArray returns a single element array with param being the element,
|
|
* if param is just a string, and returns 'param' back if it is an array
|
|
* So, it makes sure param is always an array
|
|
*/
|
|
function toArray(param) {
|
|
if (!Array.isArray(param)) {
|
|
return [param];
|
|
}
|
|
return param;
|
|
}
|
|
function sanitizeObjectKey(objectName) {
|
|
// + symbol characters are not decoded as spaces in JS. so replace them first and decode to get the correct result.
|
|
const asStrName = (objectName ? objectName.toString() : '').replace(/\+/g, ' ');
|
|
return decodeURIComponent(asStrName);
|
|
}
|
|
function sanitizeSize(size) {
|
|
return size ? Number.parseInt(size) : undefined;
|
|
}
|
|
const PART_CONSTRAINTS = {
|
|
// absMinPartSize - absolute minimum part size (5 MiB)
|
|
ABS_MIN_PART_SIZE: 1024 * 1024 * 5,
|
|
// MIN_PART_SIZE - minimum part size 16MiB per object after which
|
|
MIN_PART_SIZE: 1024 * 1024 * 16,
|
|
// MAX_PARTS_COUNT - maximum number of parts for a single multipart session.
|
|
MAX_PARTS_COUNT: 10000,
|
|
// MAX_PART_SIZE - maximum part size 5GiB for a single multipart upload
|
|
// operation.
|
|
MAX_PART_SIZE: 1024 * 1024 * 1024 * 5,
|
|
// MAX_SINGLE_PUT_OBJECT_SIZE - maximum size 5GiB of object per PUT
|
|
// operation.
|
|
MAX_SINGLE_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 5,
|
|
// MAX_MULTIPART_PUT_OBJECT_SIZE - maximum size 5TiB of object for
|
|
// Multipart operation.
|
|
MAX_MULTIPART_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 1024 * 5
|
|
};
|
|
exports.PART_CONSTRAINTS = PART_CONSTRAINTS;
|
|
const GENERIC_SSE_HEADER = 'X-Amz-Server-Side-Encryption';
|
|
const ENCRYPTION_HEADERS = {
|
|
// sseGenericHeader is the AWS SSE header used for SSE-S3 and SSE-KMS.
|
|
sseGenericHeader: GENERIC_SSE_HEADER,
|
|
// sseKmsKeyID is the AWS SSE-KMS key id.
|
|
sseKmsKeyID: GENERIC_SSE_HEADER + '-Aws-Kms-Key-Id'
|
|
};
|
|
|
|
/**
|
|
* Return Encryption headers
|
|
* @param encConfig
|
|
* @returns an object with key value pairs that can be used in headers.
|
|
*/
|
|
function getEncryptionHeaders(encConfig) {
|
|
const encType = encConfig.type;
|
|
if (!isEmpty(encType)) {
|
|
if (encType === _type.ENCRYPTION_TYPES.SSEC) {
|
|
return {
|
|
[ENCRYPTION_HEADERS.sseGenericHeader]: 'AES256'
|
|
};
|
|
} else if (encType === _type.ENCRYPTION_TYPES.KMS) {
|
|
return {
|
|
[ENCRYPTION_HEADERS.sseGenericHeader]: encConfig.SSEAlgorithm,
|
|
[ENCRYPTION_HEADERS.sseKmsKeyID]: encConfig.KMSMasterKeyID
|
|
};
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
function partsRequired(size) {
|
|
const maxPartSize = PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE / (PART_CONSTRAINTS.MAX_PARTS_COUNT - 1);
|
|
let requiredPartSize = size / maxPartSize;
|
|
if (size % maxPartSize > 0) {
|
|
requiredPartSize++;
|
|
}
|
|
requiredPartSize = Math.trunc(requiredPartSize);
|
|
return requiredPartSize;
|
|
}
|
|
|
|
/**
|
|
* calculateEvenSplits - computes splits for a source and returns
|
|
* start and end index slices. Splits happen evenly to be sure that no
|
|
* part is less than 5MiB, as that could fail the multipart request if
|
|
* it is not the last part.
|
|
*/
|
|
function calculateEvenSplits(size, objInfo) {
|
|
if (size === 0) {
|
|
return null;
|
|
}
|
|
const reqParts = partsRequired(size);
|
|
const startIndexParts = [];
|
|
const endIndexParts = [];
|
|
let start = objInfo.Start;
|
|
if (isEmpty(start) || start === -1) {
|
|
start = 0;
|
|
}
|
|
const divisorValue = Math.trunc(size / reqParts);
|
|
const reminderValue = size % reqParts;
|
|
let nextStart = start;
|
|
for (let i = 0; i < reqParts; i++) {
|
|
let curPartSize = divisorValue;
|
|
if (i < reminderValue) {
|
|
curPartSize++;
|
|
}
|
|
const currentStart = nextStart;
|
|
const currentEnd = currentStart + curPartSize - 1;
|
|
nextStart = currentEnd + 1;
|
|
startIndexParts.push(currentStart);
|
|
endIndexParts.push(currentEnd);
|
|
}
|
|
return {
|
|
startIndex: startIndexParts,
|
|
endIndex: endIndexParts,
|
|
objInfo: objInfo
|
|
};
|
|
}
|
|
const fxp = new _fastXmlParser.XMLParser({
|
|
numberParseOptions: {
|
|
eNotation: false,
|
|
hex: true,
|
|
leadingZeros: true
|
|
}
|
|
});
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
function parseXml(xml) {
|
|
const result = fxp.parse(xml);
|
|
if (result.Error) {
|
|
throw result.Error;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* get content size of object content to upload
|
|
*/
|
|
async function getContentLength(s) {
|
|
// use length property of string | Buffer
|
|
if (typeof s === 'string' || Buffer.isBuffer(s)) {
|
|
return s.length;
|
|
}
|
|
|
|
// property of `fs.ReadStream`
|
|
const filePath = s.path;
|
|
if (filePath && typeof filePath === 'string') {
|
|
const stat = await _async.fsp.lstat(filePath);
|
|
return stat.size;
|
|
}
|
|
|
|
// property of `fs.ReadStream`
|
|
const fd = s.fd;
|
|
if (fd && typeof fd === 'number') {
|
|
const stat = await (0, _async.fstat)(fd);
|
|
return stat.size;
|
|
}
|
|
return null;
|
|
}
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["crypto","_interopRequireWildcard","require","stream","_fastXmlParser","_ipaddr","_lodash","mime","_async","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","MetaDataHeaderPrefix","hashBinary","buf","enableSHA256","sha256sum","createHash","update","digest","md5sum","encodeAsHex","c","charCodeAt","toString","toUpperCase","uriEscape","uriStr","encodeURIComponent","replace","uriResourceEscape","string","getScope","region","date","serviceName","makeDateShort","isAmazonEndpoint","endpoint","isVirtualHostStyle","protocol","bucket","pathStyle","includes","isValidIP","ip","ipaddr","isValid","isValidEndpoint","isValidDomain","host","isString","length","slice","nonAlphaNumerics","char","probeContentType","path","contentType","lookup","isValidPort","port","portNum","parseInt","isNumber","isNaN","isValidBucketName","test","isValidObjectName","objectName","isValidPrefix","prefix","arg","isFunction","isObject","isReadableStream","_read","isBoolean","isEmpty","o","_","isEmptyObject","values","filter","x","undefined","isDefined","isValidDate","Date","makeDateLong","s","toISOString","pipesetup","streams","reduce","src","dst","on","err","emit","pipe","readableStream","data","Readable","push","insertContentType","metaData","filePath","toLowerCase","prependXAMZMeta","mapKeys","value","isAmzHeader","isSupportedHeader","isStorageClassHeader","temp","startsWith","supported_headers","extractMetadata","headers","pickBy","lower","getVersionId","getSourceVersionId","sanitizeETag","etag","replaceChars","m","toMd5","payload","Buffer","from","toSha256","toArray","param","Array","isArray","sanitizeObjectKey","asStrName","decodeURIComponent","sanitizeSize","size","Number","PART_CONSTRAINTS","ABS_MIN_PART_SIZE","MIN_PART_SIZE","MAX_PARTS_COUNT","MAX_PART_SIZE","MAX_SINGLE_PUT_OBJECT_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","exports","GENERIC_SSE_HEADER","ENCRYPTION_HEADERS","sseGenericHeader","sseKmsKeyID","getEncryptionHeaders","encConfig","encType","type","ENCRYPTION_TYPES","SSEC","KMS","SSEAlgorithm","KMSMasterKeyID","partsRequired","maxPartSize","requiredPartSize","Math","trunc","calculateEvenSplits","objInfo","reqParts","startIndexParts","endIndexParts","start","Start","divisorValue","reminderValue","nextStart","i","curPartSize","currentStart","currentEnd","startIndex","endIndex","fxp","XMLParser","numberParseOptions","eNotation","hex","leadingZeros","parseXml","xml","result","parse","Error","getContentLength","isBuffer","stat","fsp","lstat","fd","fstat"],"sources":["helper.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as crypto from 'node:crypto'\nimport * as stream from 'node:stream'\n\nimport { XMLParser } from 'fast-xml-parser'\nimport ipaddr from 'ipaddr.js'\nimport _ from 'lodash'\nimport * as mime from 'mime-types'\n\nimport { fsp, fstat } from './async.ts'\nimport type { Binary, Encryption, ObjectMetaData, RequestHeaders, ResponseHeader } from './type.ts'\nimport { ENCRYPTION_TYPES } from './type.ts'\n\nconst MetaDataHeaderPrefix = 'x-amz-meta-'\n\nexport function hashBinary(buf: Buffer, enableSHA256: boolean) {\n  let sha256sum = ''\n  if (enableSHA256) {\n    sha256sum = crypto.createHash('sha256').update(buf).digest('hex')\n  }\n  const md5sum = crypto.createHash('md5').update(buf).digest('base64')\n\n  return { md5sum, sha256sum }\n}\n\n// S3 percent-encodes some extra non-standard characters in a URI . So comply with S3.\nconst encodeAsHex = (c: string) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`\nexport function uriEscape(uriStr: string): string {\n  return encodeURIComponent(uriStr).replace(/[!'()*]/g, encodeAsHex)\n}\n\nexport function uriResourceEscape(string: string) {\n  return uriEscape(string).replace(/%2F/g, '/')\n}\n\nexport function getScope(region: string, date: Date, serviceName = 's3') {\n  return `${makeDateShort(date)}/${region}/${serviceName}/aws4_request`\n}\n\n/**\n * isAmazonEndpoint - true if endpoint is 's3.amazonaws.com' or 's3.cn-north-1.amazonaws.com.cn'\n */\nexport function isAmazonEndpoint(endpoint: string) {\n  return endpoint === 's3.amazonaws.com' || endpoint === 's3.cn-north-1.amazonaws.com.cn'\n}\n\n/**\n * isVirtualHostStyle - verify if bucket name is support with virtual\n * hosts. bucketNames with periods should be always treated as path\n * style if the protocol is 'https:', this is due to SSL wildcard\n * limitation. For all other buckets and Amazon S3 endpoint we will\n * default to virtual host style.\n */\nexport function isVirtualHostStyle(endpoint: string, protocol: string, bucket: string, pathStyle: boolean) {\n  if (protocol === 'https:' && bucket.includes('.')) {\n    return false\n  }\n  return isAmazonEndpoint(endpoint) || !pathStyle\n}\n\nexport function isValidIP(ip: string) {\n  return ipaddr.isValid(ip)\n}\n\n/**\n * @returns if endpoint is valid domain.\n */\nexport function isValidEndpoint(endpoint: string) {\n  return isValidDomain(endpoint) || isValidIP(endpoint)\n}\n\n/**\n * @returns if input host is a valid domain.\n */\nexport function isValidDomain(host: string) {\n  if (!isString(host)) {\n    return false\n  }\n  // See RFC 1035, RFC 3696.\n  if (host.length === 0 || host.length > 255) {\n    return false\n  }\n  // Host cannot start or end with a '-'\n  if (host[0] === '-' || host.slice(-1) === '-') {\n    return false\n  }\n  // Host cannot start or end with a '_'\n  if (host[0] === '_' || host.slice(-1) === '_') {\n    return false\n  }\n  // Host cannot start with a '.'\n  if (host[0] === '.') {\n    return false\n  }\n\n  const nonAlphaNumerics = '`~!@#$%^&*()+={}[]|\\\\\"\\';:><?/'\n  // All non alphanumeric characters are invalid.\n  for (const char of nonAlphaNumerics) {\n    if (host.includes(char)) {\n      return false\n    }\n  }\n  // No need to regexp match, since the list is non-exhaustive.\n  // We let it be valid and fail later.\n  return true\n}\n\n/**\n * Probes contentType using file extensions.\n *\n * @example\n * ```\n * // return 'image/png'\n * probeContentType('file.png')\n * ```\n */\nexport function probeContentType(path: string) {\n  let contentType = mime.lookup(path)\n  if (!contentType) {\n    contentType = 'application/octet-stream'\n  }\n  return contentType\n}\n\n/**\n * is input port valid.\n */\nexport function isValidPort(port: unknown): port is number {\n  // Convert string port to number if needed\n  const portNum = typeof port === 'string' ? parseInt(port, 10) : port\n\n  // verify if port is a valid number\n  if (!isNumber(portNum) || isNaN(portNum)) {\n    return false\n  }\n\n  // port `0` is valid and special case\n  return 0 <= portNum && portNum <= 65535\n}\n\nexport function isValidBucketName(bucket: unknown) {\n  if (!isString(bucket)) {\n    return false\n  }\n\n  // bucket length should be less than and no more than 63\n  // characters long.\n  if (bucket.length < 3 || bucket.length > 63) {\n    return false\n  }\n  // bucket with successive periods is invalid.\n  if (bucket.includes('..')) {\n    return false\n  }\n  // bucket cannot have ip address style.\n  if (/[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+/.test(bucket)) {\n    return false\n  }\n  // bucket should begin with alphabet/number and end with alphabet/number,\n  // with alphabet/number/.- in the middle.\n  if (/^[a-z0-9][a-z0-9.-]+[a-z0-9]$/.test(bucket)) {\n    return true\n  }\n  return false\n}\n\n/**\n * check if objectName is a valid object name\n */\nexport function isValidObjectName(objectName: unknown) {\n  if (!isValidPrefix(objectName)) {\n    return false\n  }\n\n  return objectName.length !== 0\n}\n\n/**\n * check if prefix is valid\n */\nexport function isValidPrefix(prefix: unknown): prefix is string {\n  if (!isString(prefix)) {\n    return false\n  }\n  if (prefix.length > 1024) {\n    return false\n  }\n  return true\n}\n\n/**\n * check if typeof arg number\n */\nexport function isNumber(arg: unknown): arg is number {\n  return typeof arg === 'number'\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyFunction = (...args: any[]) => any\n\n/**\n * check if typeof arg function\n */\nexport function isFunction(arg: unknown): arg is AnyFunction {\n  return typeof arg === 'function'\n}\n\n/**\n * check if typeof arg string\n */\nexport function isString(arg: unknown): arg is string {\n  return typeof arg === 'string'\n}\n\n/**\n * check if typeof arg object\n */\nexport function isObject(arg: unknown): arg is object {\n  return typeof arg === 'object' && arg !== null\n}\n\n/**\n * check if object is readable stream\n */\nexport function isReadableStream(arg: unknown): arg is stream.Readable {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  return isObject(arg) && isFunction((arg as stream.Readable)._read)\n}\n\n/**\n * check if arg is boolean\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean'\n}\n\nexport function isEmpty(o: unknown): o is null | undefined {\n  return _.isEmpty(o)\n}\n\nexport function isEmptyObject(o: Record<string, unknown>): boolean {\n  return Object.values(o).filter((x) => x !== undefined).length !== 0\n}\n\nexport function isDefined<T>(o: T): o is Exclude<T, null | undefined> {\n  return o !== null && o !== undefined\n}\n\n/**\n * check if arg is a valid date\n */\nexport function isValidDate(arg: unknown): arg is Date {\n  // @ts-expect-error checknew Date(Math.NaN)\n  return arg instanceof Date && !isNaN(arg)\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDDTHHmmss' + Z\n */\nexport function makeDateLong(date?: Date): string {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 13) + s.slice(14, 16) + s.slice(17, 19) + 'Z'\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDD'\n */\nexport function makeDateShort(date?: Date) {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 10)\n}\n\n/**\n * pipesetup sets up pipe() from left to right os streams array\n * pipesetup will also make sure that error emitted at any of the upstream Stream\n * will be emitted at the last stream. This makes error handling simple\n */\nexport function pipesetup(...streams: [stream.Readable, ...stream.Duplex[], stream.Writable]) {\n  // @ts-expect-error ts can't narrow this\n  return streams.reduce((src: stream.Readable, dst: stream.Writable) => {\n    src.on('error', (err) => dst.emit('error', err))\n    return src.pipe(dst)\n  })\n}\n\n/**\n * return a Readable stream that emits data\n */\nexport function readableStream(data: unknown): stream.Readable {\n  const s = new stream.Readable()\n  s._read = () => {}\n  s.push(data)\n  s.push(null)\n  return s\n}\n\n/**\n * Process metadata to insert appropriate value to `content-type` attribute\n */\nexport function insertContentType(metaData: ObjectMetaData, filePath: string): ObjectMetaData {\n  // check if content-type attribute present in metaData\n  for (const key in metaData) {\n    if (key.toLowerCase() === 'content-type') {\n      return metaData\n    }\n  }\n\n  // if `content-type` attribute is not present in metadata, then infer it from the extension in filePath\n  return {\n    ...metaData,\n    'content-type': probeContentType(filePath),\n  }\n}\n\n/**\n * Function prepends metadata with the appropriate prefix if it is not already on\n */\nexport function prependXAMZMeta(metaData?: ObjectMetaData): RequestHeaders {\n  if (!metaData) {\n    return {}\n  }\n\n  return _.mapKeys(metaData, (value, key) => {\n    if (isAmzHeader(key) || isSupportedHeader(key) || isStorageClassHeader(key)) {\n      return key\n    }\n\n    return MetaDataHeaderPrefix + key\n  })\n}\n\n/**\n * Checks if it is a valid header according to the AmazonS3 API\n */\nexport function isAmzHeader(key: string) {\n  const temp = key.toLowerCase()\n  return (\n    temp.startsWith(MetaDataHeaderPrefix) ||\n    temp === 'x-amz-acl' ||\n    temp.startsWith('x-amz-server-side-encryption-') ||\n    temp === 'x-amz-server-side-encryption'\n  )\n}\n\n/**\n * Checks if it is a supported Header\n */\nexport function isSupportedHeader(key: string) {\n  const supported_headers = [\n    'content-type',\n    'cache-control',\n    'content-encoding',\n    'content-disposition',\n    'content-language',\n    'x-amz-website-redirect-location',\n    'if-none-match',\n    'if-match',\n  ]\n  return supported_headers.includes(key.toLowerCase())\n}\n\n/**\n * Checks if it is a storage header\n */\nexport function isStorageClassHeader(key: string) {\n  return key.toLowerCase() === 'x-amz-storage-class'\n}\n\nexport function extractMetadata(headers: ResponseHeader) {\n  return _.mapKeys(\n    _.pickBy(headers, (value, key) => isSupportedHeader(key) || isStorageClassHeader(key) || isAmzHeader(key)),\n    (value, key) => {\n      const lower = key.toLowerCase()\n      if (lower.startsWith(MetaDataHeaderPrefix)) {\n        return lower.slice(MetaDataHeaderPrefix.length)\n      }\n\n      return key\n    },\n  )\n}\n\nexport function getVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-version-id'] || null\n}\n\nexport function getSourceVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-copy-source-version-id'] || null\n}\n\nexport function sanitizeETag(etag = ''): string {\n  const replaceChars: Record<string, string> = {\n    '\"': '',\n    '&quot;': '',\n    '&#34;': '',\n    '&QUOT;': '',\n    '&#x00022': '',\n  }\n  return etag.replace(/^(\"|&quot;|&#34;)|(\"|&quot;|&#34;)$/g, (m) => replaceChars[m] as string)\n}\n\nexport function toMd5(payload: Binary): string {\n  // use string from browser and buffer from nodejs\n  // browser support is tested only against minio server\n  return crypto.createHash('md5').update(Buffer.from(payload)).digest().toString('base64')\n}\n\nexport function toSha256(payload: Binary): string {\n  return crypto.createHash('sha256').update(payload).digest('hex')\n}\n\n/**\n * toArray returns a single element array with param being the element,\n * if param is just a string, and returns 'param' back if it is an array\n * So, it makes sure param is always an array\n */\nexport function toArray<T = unknown>(param: T | T[]): Array<T> {\n  if (!Array.isArray(param)) {\n    return [param] as T[]\n  }\n  return param\n}\n\nexport function sanitizeObjectKey(objectName: string): string {\n  // + symbol characters are not decoded as spaces in JS. so replace them first and decode to get the correct result.\n  const asStrName = (objectName ? objectName.toString() : '').replace(/\\+/g, ' ')\n  return decodeURIComponent(asStrName)\n}\n\nexport function sanitizeSize(size?: string): number | undefined {\n  return size ? Number.parseInt(size) : undefined\n}\n\nexport const PART_CONSTRAINTS = {\n  // absMinPartSize - absolute minimum part size (5 MiB)\n  ABS_MIN_PART_SIZE: 1024 * 1024 * 5,\n  // MIN_PART_SIZE - minimum part size 16MiB per object after which\n  MIN_PART_SIZE: 1024 * 1024 * 16,\n  // MAX_PARTS_COUNT - maximum number of parts for a single multipart session.\n  MAX_PARTS_COUNT: 10000,\n  // MAX_PART_SIZE - maximum part size 5GiB for a single multipart upload\n  // operation.\n  MAX_PART_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_SINGLE_PUT_OBJECT_SIZE - maximum size 5GiB of object per PUT\n  // operation.\n  MAX_SINGLE_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_MULTIPART_PUT_OBJECT_SIZE - maximum size 5TiB of object for\n  // Multipart operation.\n  MAX_MULTIPART_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 1024 * 5,\n}\n\nconst GENERIC_SSE_HEADER = 'X-Amz-Server-Side-Encryption'\n\nconst ENCRYPTION_HEADERS = {\n  // sseGenericHeader is the AWS SSE header used for SSE-S3 and SSE-KMS.\n  sseGenericHeader: GENERIC_SSE_HEADER,\n  // sseKmsKeyID is the AWS SSE-KMS key id.\n  sseKmsKeyID: GENERIC_SSE_HEADER + '-Aws-Kms-Key-Id',\n} as const\n\n/**\n * Return Encryption headers\n * @param encConfig\n * @returns an object with key value pairs that can be used in headers.\n */\nexport function getEncryptionHeaders(encConfig: Encryption): RequestHeaders {\n  const encType = encConfig.type\n\n  if (!isEmpty(encType)) {\n    if (encType === ENCRYPTION_TYPES.SSEC) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: 'AES256',\n      }\n    } else if (encType === ENCRYPTION_TYPES.KMS) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: encConfig.SSEAlgorithm,\n        [ENCRYPTION_HEADERS.sseKmsKeyID]: encConfig.KMSMasterKeyID,\n      }\n    }\n  }\n\n  return {}\n}\n\nexport function partsRequired(size: number): number {\n  const maxPartSize = PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE / (PART_CONSTRAINTS.MAX_PARTS_COUNT - 1)\n  let requiredPartSize = size / maxPartSize\n  if (size % maxPartSize > 0) {\n    requiredPartSize++\n  }\n  requiredPartSize = Math.trunc(requiredPartSize)\n  return requiredPartSize\n}\n\n/**\n * calculateEvenSplits - computes splits for a source and returns\n * start and end index slices. Splits happen evenly to be sure that no\n * part is less than 5MiB, as that could fail the multipart request if\n * it is not the last part.\n */\nexport function calculateEvenSplits<T extends { Start?: number }>(\n  size: number,\n  objInfo: T,\n): {\n  startIndex: number[]\n  objInfo: T\n  endIndex: number[]\n} | null {\n  if (size === 0) {\n    return null\n  }\n  const reqParts = partsRequired(size)\n  const startIndexParts: number[] = []\n  const endIndexParts: number[] = []\n\n  let start = objInfo.Start\n  if (isEmpty(start) || start === -1) {\n    start = 0\n  }\n  const divisorValue = Math.trunc(size / reqParts)\n\n  const reminderValue = size % reqParts\n\n  let nextStart = start\n\n  for (let i = 0; i < reqParts; i++) {\n    let curPartSize = divisorValue\n    if (i < reminderValue) {\n      curPartSize++\n    }\n\n    const currentStart = nextStart\n    const currentEnd = currentStart + curPartSize - 1\n    nextStart = currentEnd + 1\n\n    startIndexParts.push(currentStart)\n    endIndexParts.push(currentEnd)\n  }\n\n  return { startIndex: startIndexParts, endIndex: endIndexParts, objInfo: objInfo }\n}\nconst fxp = new XMLParser({ numberParseOptions: { eNotation: false, hex: true, leadingZeros: true } })\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function parseXml(xml: string): any {\n  const result = fxp.parse(xml)\n  if (result.Error) {\n    throw result.Error\n  }\n\n  return result\n}\n\n/**\n * get content size of object content to upload\n */\nexport async function getContentLength(s: stream.Readable | Buffer | string): Promise<number | null> {\n  // use length property of string | Buffer\n  if (typeof s === 'string' || Buffer.isBuffer(s)) {\n    return s.length\n  }\n\n  // property of `fs.ReadStream`\n  const filePath = (s as unknown as Record<string, unknown>).path as string | undefined\n  if (filePath && typeof filePath === 'string') {\n    const stat = await fsp.lstat(filePath)\n    return stat.size\n  }\n\n  // property of `fs.ReadStream`\n  const fd = (s as unknown as Record<string, unknown>).fd as number | null | undefined\n  if (fd && typeof fd === 'number') {\n    const stat = await fstat(fd)\n    return stat.size\n  }\n\n  return null\n}\n"],"mappings":"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"}
|