@cumulus/hyrax-metadata-updates
Version:
Update granule metadata with hooks to OPeNDAP URL
1,088 lines (1,054 loc) • 8.6 MB
JavaScript
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/cma.js"
/*!**************************************************************************!*\
!*** ../../node_modules/@cumulus/cumulus-message-adapter-js/dist/cma.js ***!
\**************************************************************************/
(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.generateCMASpawnArguments = generateCMASpawnArguments;
exports.invokeCumulusMessageAdapter = invokeCumulusMessageAdapter;
exports.runCumulusTask = runCumulusTask;
const lookpath_1 = __webpack_require__(/*! lookpath */ "../../node_modules/lookpath/lib/index.js");
const readline = __importStar(__webpack_require__(/*! readline */ "readline"));
const child_process_1 = __importDefault(__webpack_require__(/*! child_process */ "child_process"));
const message_1 = __webpack_require__(/*! ./message */ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/message.js");
const typeGuards_1 = __webpack_require__(/*! ./typeGuards */ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/typeGuards.js");
/**
* An error to be thrown when invocation of the cumulus-message-adapter fails
*/
class CumulusMessageAdapterExecutionError extends Error {
// eslint-disable-next-line require-jsdoc
constructor(message) {
super(message);
this.name = 'CumulusMessageAdapterExecutionError';
}
}
/**
* Generates CMA command line arguments
*
* @param {string} command - the action to be performed by the message-adapter
* @returns {Promise.<Array>} - Returns arguments used to spawn the CMA
*/
async function generateCMASpawnArguments(command) {
var _a;
const adapterDir = (_a = process.env.CUMULUS_MESSAGE_ADAPTER_DIR) !== null && _a !== void 0 ? _a : './cumulus-message-adapter';
const systemPython = await (0, lookpath_1.lookpath)('python');
if (systemPython && process.env.USE_CMA_BINARY !== 'true') {
return [systemPython, [`${adapterDir}`, command], { env: { ...process.env, PYTHONUTF8: 1 } }];
}
// If there is no system python, attempt use of pre-packaged CMA binary
return [`${adapterDir}/cma_bin/cma`, [command], { env: { ...process.env, PYTHONUTF8: 1 } }];
}
/**
* Invoke the cumulus-message-adapter
*
* @returns {Promise<Object>} cumulusMessageAdapterObject - Returns an Object with a
* childprocess and a stderror buffer
* @returns {Object} cumulusMessageAdapterObject.cmaProcess - A CMA childProcess Object
* @returns {Object} cumulusMessageAdapterObject.errorObj - A Object with the property
* 'stderrBuffer' to make the encapsulated
* error event storage outside this method
*/
async function invokeCumulusMessageAdapter() {
const spawnArguments = await generateCMASpawnArguments('stream');
const errorObj = { stderrBuffer: '' };
const statusObj = { close: false };
try {
const cmaProcess = child_process_1.default.spawn(...spawnArguments);
cmaProcess.on('error', () => {
console.log(`CMA (on error) StdErr: \n ${errorObj.stderrBuffer}`);
});
cmaProcess.stdin.setDefaultEncoding('utf8');
cmaProcess.stdout.setEncoding('utf8');
cmaProcess.stderr.setEncoding('utf8');
cmaProcess.on('close', (code, signal) => {
if (code !== 0) {
console.log(`CMA Exit Code: ${code}`);
console.log(`CMA Exit Signal: ${signal}`);
console.log(`CMA Process Kill: ${cmaProcess.killed}`);
console.log(`CMA StdErr: \n ${errorObj.stderrBuffer}\n`);
}
statusObj.close = true;
});
cmaProcess.stdin.on('error', (error) => {
console.log(`CMA stdin on error: ${error.message}`);
});
cmaProcess.stderr.on('data', (data) => {
errorObj.stderrBuffer += String(data);
});
return { cmaProcess, errorObj, statusObj };
}
catch (error) {
const shortMessage = error instanceof Error && 'shortMessage' in error
? error.shortMessage
: '';
const message = error instanceof Error ? error.message : String(error);
const msg = `CMA process failed (${shortMessage})\n
Trace: ${message}}\n\n\n
STDERR: ${errorObj.stderrBuffer}`;
throw new CumulusMessageAdapterExecutionError(msg);
}
}
/**
* Conditionally set environment variable when targeted value is not undefined.
*
* @param {string} VARNAME - environment variable name
* @param {string | undefined} value - value to set variable to if not undefined
* @returns {undefined} - none
*/
function safeSetEnv(VARNAME, value) {
if (value !== undefined)
process.env[VARNAME] = value;
}
/**
* Set environment variables to be used in logging based on the Cumulus event
* message and context that runCumulusTask was invoked.
*
* @param {Object} cumulusMessage - cumulus event message
* @param {Object} context - lambda context object.
* @returns {undefined} - no return values
*/
function setCumulusEnvironment(cumulusMessage, context) {
safeSetEnv('EXECUTIONS', (0, message_1.getExecutions)(cumulusMessage));
safeSetEnv('SENDER', context.functionName);
safeSetEnv('TASKVERSION', context.functionVersion);
safeSetEnv('STACKNAME', (0, message_1.getStackName)(cumulusMessage));
safeSetEnv('GRANULES', JSON.stringify((0, message_1.getMessageGranules)(cumulusMessage)));
safeSetEnv('PARENTARN', (0, message_1.getParentArn)(cumulusMessage));
safeSetEnv('ASYNCOPERATIONID', (0, message_1.getAsyncOperationId)(cumulusMessage));
}
/**
* Read the CMA output/results after sending a command
*
* @param {Object} readLine - configured readline object
* @param {*} errorObj - cma errorObject with stderr string buffer
* @returns {Promise<Object>} - Promise that resolves to a parsed JSON object
* from the CMA output
*/
async function getCmaOutput(readLine, errorObj) {
return new Promise((resolve, reject) => {
let buffer = '';
readLine.resume();
readLine.on('line', (input) => {
if (input.endsWith('<EOC>')) {
readLine.pause();
readLine.removeAllListeners('line');
const endInput = input.replace('<EOC>', '');
buffer += endInput;
resolve(JSON.parse(buffer));
}
else {
buffer += input;
}
});
readLine.on('close', () => {
reject(new CumulusMessageAdapterExecutionError(errorObj.stderrBuffer));
});
});
}
/**
* Build a nested Cumulus event and pass it to a tasks's business function
*
* @param {Function} TaskFunction - the function containing the business logic of the task
* @param {Object} cumulusMessage - either a full Cumulus Message or a Cumulus Remote Messag
* or a workflow configured CMAMessage
* containing a Cumulus Message in it's event
* @param {Object} context - an AWS Lambda context
* @param {string} schemas - Location of schema files, defaults to null.
* @returns {Promise<Object>} - The response from the call to createNextEvent
*/
async function runCumulusTask(TaskFunction, cumulusMessage, context, schemas = null) {
const { cmaProcess, errorObj, statusObj } = await invokeCumulusMessageAdapter();
const cmaStdin = cmaProcess.stdin;
const rl = readline.createInterface({
input: cmaProcess.stdout,
});
let lambdaTimer;
let runningTask = false;
if (typeof context.getRemainingTimeInMillis === 'function') {
lambdaTimer = setTimeout(() => {
console.log('Lambda timing out, writing CMA stderr to cloudwatch logs');
console.log(`CMA (on start task timeout) StdErr: \n ${errorObj.stderrBuffer}`);
}, context.getRemainingTimeInMillis() - 5 * 100);
}
else {
console.log('Info: No CMA timeout buffer dump set, as lambda is not running as a lambda');
lambdaTimer = setTimeout(() => {
}, 0);
}
try {
cmaStdin.write('loadAndUpdateRemoteEvent\n');
cmaStdin.write(JSON.stringify({
event: cumulusMessage,
context,
schemas,
}));
cmaStdin.write('\n<EOC>\n');
const loadAndUpdateRemoteEventOutput = await getCmaOutput(rl, errorObj);
if (!(0, typeGuards_1.isCumulusMessageWithAssignedPayload)(loadAndUpdateRemoteEventOutput)) {
throw new Error(`Invalid output typing received from
loadAndUpdateRemoteEvent ${JSON.stringify(loadAndUpdateRemoteEventOutput)}`);
}
setCumulusEnvironment(loadAndUpdateRemoteEventOutput, context);
cmaStdin.write('loadNestedEvent\n');
cmaStdin.write(JSON.stringify({
event: loadAndUpdateRemoteEventOutput,
schemas,
context,
}));
cmaStdin.write('\n<EOC>\n');
const loadNestedEventOutput = await getCmaOutput(rl, errorObj);
if (!(0, typeGuards_1.isLoadNestedEventInput)(loadNestedEventOutput)) {
throw new Error(`Invalid output typing received from
loadNestedEvent ${JSON.stringify(loadNestedEventOutput)}`);
}
console.log('Starting task function');
runningTask = true;
const taskOutput = await TaskFunction(loadNestedEventOutput, context);
runningTask = false;
console.log('Starting task function finished');
cmaStdin.write('createNextEvent\n');
cmaStdin.write(JSON.stringify({
event: loadAndUpdateRemoteEventOutput,
handler_response: taskOutput,
message_config: loadNestedEventOutput.messageConfig,
schemas,
}));
cmaStdin.write('\n<EOC>\n');
const createNextEventOutput = await getCmaOutput(rl, errorObj);
cmaStdin.write('<EXIT>\n');
if ((0, typeGuards_1.isLoadNestedEventInput)(createNextEventOutput)) {
throw new Error(`Invalid typing received from
createNextEventOutput: ${JSON.stringify(createNextEventOutput)}`);
}
const returnVal = createNextEventOutput;
return returnVal;
}
catch (error) {
try {
if (!runningTask) {
cmaStdin.write('\n');
}
cmaStdin.write('<EXIT>\n');
if (!cmaProcess.kill('SIGTERM')) {
cmaProcess.kill('SIGKILL');
}
}
catch (e) {
console.log(`CMA process failed to kill on task failure: ${JSON.stringify(e)}`);
}
const errorName = error instanceof Error && 'name' in error ? error.name : undefined;
if ((errorName === null || errorName === void 0 ? void 0 : errorName.includes('WorkflowError')) && (!(0, typeGuards_1.isCMAMessage)(cumulusMessage))) {
return {
...cumulusMessage, payload: null, exception: errorName,
};
}
// Wait for .close process event to complete before throwing
let waitIterations = 0;
while (!statusObj.close && waitIterations < 20) {
console.log('Waiting up to 2 seconds for CMA child process to exit');
// eslint-disable-next-line no-await-in-loop
await new Promise((r) => setTimeout(r, 100));
waitIterations += 1;
}
throw error;
}
finally {
clearTimeout(lambdaTimer);
}
}
//# sourceMappingURL=cma.js.map
/***/ },
/***/ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/index.js"
/*!****************************************************************************!*\
!*** ../../node_modules/@cumulus/cumulus-message-adapter-js/dist/index.js ***!
\****************************************************************************/
(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.runCumulusTask = exports.invokeCumulusMessageAdapter = exports.generateCMASpawnArguments = void 0;
var cma_1 = __webpack_require__(/*! ./cma */ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/cma.js");
Object.defineProperty(exports, "generateCMASpawnArguments", ({ enumerable: true, get: function () { return cma_1.generateCMASpawnArguments; } }));
Object.defineProperty(exports, "invokeCumulusMessageAdapter", ({ enumerable: true, get: function () { return cma_1.invokeCumulusMessageAdapter; } }));
Object.defineProperty(exports, "runCumulusTask", ({ enumerable: true, get: function () { return cma_1.runCumulusTask; } }));
__exportStar(__webpack_require__(/*! ./types */ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/types.js"), exports);
//# sourceMappingURL=index.js.map
/***/ },
/***/ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/message.js"
/*!******************************************************************************!*\
!*** ../../node_modules/@cumulus/cumulus-message-adapter-js/dist/message.js ***!
\******************************************************************************/
(__unused_webpack_module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getAsyncOperationId = exports.getExecutions = exports.getParentArn = exports.getStackName = exports.getMessageGranules = void 0;
const GRANULE_LOG_LIMIT = 500;
/**
* Get granules from execution message.
* Uses the order of precedence as defined by the cumulus/common/message
* description.
*
* @param {Object} message - a Cumulus message
* @param {integer} granuleLimit - number of granules to limit the log to
* including, to avoid environment variable truncation
* @returns {Array<string>} - An array of granule ids
*/
const getMessageGranules = (message, granuleLimit = GRANULE_LOG_LIMIT) => {
var _a, _b;
const granules = ((_a = message === null || message === void 0 ? void 0 : message.payload) === null || _a === void 0 ? void 0 : _a.granules) || ((_b = message === null || message === void 0 ? void 0 : message.meta) === null || _b === void 0 ? void 0 : _b.input_granules);
if (granules) {
return granules.slice(0, granuleLimit)
.map((granule) => granule.granuleId);
}
return [];
};
exports.getMessageGranules = getMessageGranules;
/**
* Get the stackname pulled from the meta of the event.
*
* @param {Object} message - A cumulus event message.
* @returns {string | undefined} - The cumulus stack name.
*/
const getStackName = (message) => { var _a; return (_a = message === null || message === void 0 ? void 0 : message.meta) === null || _a === void 0 ? void 0 : _a.stack; };
exports.getStackName = getStackName;
/**
* Gets parent arn from execution message.
*
* @param {Object} message - An execution message.
* @returns {string | undefined} - the parent execution.
*/
const getParentArn = (message) => { var _a; return (_a = message === null || message === void 0 ? void 0 : message.cumulus_meta) === null || _a === void 0 ? void 0 : _a.parentExecutionArn; };
exports.getParentArn = getParentArn;
/**
* Get current execution name from Cumulus message.
*
* @param {Object} message - Cumulus message.
* @returns {string | undefined} current execution name.
*/
const getExecutions = (message) => { var _a; return (_a = message === null || message === void 0 ? void 0 : message.cumulus_meta) === null || _a === void 0 ? void 0 : _a.execution_name; };
exports.getExecutions = getExecutions;
/**
* Get current async operation id from Cumulus message.
*
* @param {Object} message - Cumulus message.
* @returns {string} asyncOperationId or null
*/
const getAsyncOperationId = (message) => { var _a; return (_a = message === null || message === void 0 ? void 0 : message.cumulus_meta) === null || _a === void 0 ? void 0 : _a.asyncOperationId; };
exports.getAsyncOperationId = getAsyncOperationId;
//# sourceMappingURL=message.js.map
/***/ },
/***/ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/typeGuards.js"
/*!*********************************************************************************!*\
!*** ../../node_modules/@cumulus/cumulus-message-adapter-js/dist/typeGuards.js ***!
\*********************************************************************************/
(__unused_webpack_module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.isCumulusMessageWithAssignedPayload = isCumulusMessageWithAssignedPayload;
exports.isLoadNestedEventInput = isLoadNestedEventInput;
exports.isCMAMessage = isCMAMessage;
// eslint-disable-next-line require-jsdoc
function isCumulusMessageWithAssignedPayload(message) {
return ((message === null || message === void 0 ? void 0 : message.payload) !== undefined
&& (message === null || message === void 0 ? void 0 : message.input) === undefined
&& (message === null || message === void 0 ? void 0 : message.config) === undefined);
}
// eslint-disable-next-line require-jsdoc
function isLoadNestedEventInput(message) {
return (message.input !== undefined
&& message.config !== undefined);
}
// eslint-disable-next-line require-jsdoc
function isCMAMessage(message) {
return (message.cma !== undefined);
}
//# sourceMappingURL=typeGuards.js.map
/***/ },
/***/ "../../node_modules/@cumulus/cumulus-message-adapter-js/dist/types.js"
/*!****************************************************************************!*\
!*** ../../node_modules/@cumulus/cumulus-message-adapter-js/dist/types.js ***!
\****************************************************************************/
(__unused_webpack_module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
//# sourceMappingURL=types.js.map
/***/ },
/***/ "../../node_modules/@sindresorhus/is/dist/index.js"
/*!*********************************************************!*\
!*** ../../node_modules/@sindresorhus/is/dist/index.js ***!
\*********************************************************/
(module, exports) {
"use strict";
/// <reference lib="es2018"/>
/// <reference lib="dom"/>
/// <reference types="node"/>
Object.defineProperty(exports, "__esModule", ({ value: true }));
const typedArrayTypeNames = [
'Int8Array',
'Uint8Array',
'Uint8ClampedArray',
'Int16Array',
'Uint16Array',
'Int32Array',
'Uint32Array',
'Float32Array',
'Float64Array',
'BigInt64Array',
'BigUint64Array'
];
function isTypedArrayName(name) {
return typedArrayTypeNames.includes(name);
}
const objectTypeNames = [
'Function',
'Generator',
'AsyncGenerator',
'GeneratorFunction',
'AsyncGeneratorFunction',
'AsyncFunction',
'Observable',
'Array',
'Buffer',
'Blob',
'Object',
'RegExp',
'Date',
'Error',
'Map',
'Set',
'WeakMap',
'WeakSet',
'ArrayBuffer',
'SharedArrayBuffer',
'DataView',
'Promise',
'URL',
'FormData',
'URLSearchParams',
'HTMLElement',
...typedArrayTypeNames
];
function isObjectTypeName(name) {
return objectTypeNames.includes(name);
}
const primitiveTypeNames = [
'null',
'undefined',
'string',
'number',
'bigint',
'boolean',
'symbol'
];
function isPrimitiveTypeName(name) {
return primitiveTypeNames.includes(name);
}
// eslint-disable-next-line @typescript-eslint/ban-types
function isOfType(type) {
return (value) => typeof value === type;
}
const { toString } = Object.prototype;
const getObjectType = (value) => {
const objectTypeName = toString.call(value).slice(8, -1);
if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) {
return 'HTMLElement';
}
if (isObjectTypeName(objectTypeName)) {
return objectTypeName;
}
return undefined;
};
const isObjectOfType = (type) => (value) => getObjectType(value) === type;
function is(value) {
if (value === null) {
return 'null';
}
switch (typeof value) {
case 'undefined':
return 'undefined';
case 'string':
return 'string';
case 'number':
return 'number';
case 'boolean':
return 'boolean';
case 'function':
return 'Function';
case 'bigint':
return 'bigint';
case 'symbol':
return 'symbol';
default:
}
if (is.observable(value)) {
return 'Observable';
}
if (is.array(value)) {
return 'Array';
}
if (is.buffer(value)) {
return 'Buffer';
}
const tagType = getObjectType(value);
if (tagType) {
return tagType;
}
if (value instanceof String || value instanceof Boolean || value instanceof Number) {
throw new TypeError('Please don\'t use object wrappers for primitive types');
}
return 'Object';
}
is.undefined = isOfType('undefined');
is.string = isOfType('string');
const isNumberType = isOfType('number');
is.number = (value) => isNumberType(value) && !is.nan(value);
is.bigint = isOfType('bigint');
// eslint-disable-next-line @typescript-eslint/ban-types
is.function_ = isOfType('function');
is.null_ = (value) => value === null;
is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
is.boolean = (value) => value === true || value === false;
is.symbol = isOfType('symbol');
is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
is.array = (value, assertion) => {
if (!Array.isArray(value)) {
return false;
}
if (!is.function_(assertion)) {
return true;
}
return value.every(assertion);
};
is.buffer = (value) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = value) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.isBuffer) === null || _c === void 0 ? void 0 : _c.call(_b, value)) !== null && _d !== void 0 ? _d : false; };
is.blob = (value) => isObjectOfType('Blob')(value);
is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
is.iterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.iterator]); };
is.asyncIterable = (value) => { var _a; return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a[Symbol.asyncIterator]); };
is.generator = (value) => { var _a, _b; return is.iterable(value) && is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.next) && is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.throw); };
is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
is.nativePromise = (value) => isObjectOfType('Promise')(value);
const hasPromiseAPI = (value) => {
var _a, _b;
return is.function_((_a = value) === null || _a === void 0 ? void 0 : _a.then) &&
is.function_((_b = value) === null || _b === void 0 ? void 0 : _b.catch);
};
is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
is.generatorFunction = isObjectOfType('GeneratorFunction');
is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction';
// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
is.regExp = isObjectOfType('RegExp');
is.date = isObjectOfType('Date');
is.error = isObjectOfType('Error');
is.map = (value) => isObjectOfType('Map')(value);
is.set = (value) => isObjectOfType('Set')(value);
is.weakMap = (value) => isObjectOfType('WeakMap')(value);
is.weakSet = (value) => isObjectOfType('WeakSet')(value);
is.int8Array = isObjectOfType('Int8Array');
is.uint8Array = isObjectOfType('Uint8Array');
is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
is.int16Array = isObjectOfType('Int16Array');
is.uint16Array = isObjectOfType('Uint16Array');
is.int32Array = isObjectOfType('Int32Array');
is.uint32Array = isObjectOfType('Uint32Array');
is.float32Array = isObjectOfType('Float32Array');
is.float64Array = isObjectOfType('Float64Array');
is.bigInt64Array = isObjectOfType('BigInt64Array');
is.bigUint64Array = isObjectOfType('BigUint64Array');
is.arrayBuffer = isObjectOfType('ArrayBuffer');
is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
is.dataView = isObjectOfType('DataView');
is.enumCase = (value, targetEnum) => Object.values(targetEnum).includes(value);
is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype;
is.urlInstance = (value) => isObjectOfType('URL')(value);
is.urlString = (value) => {
if (!is.string(value)) {
return false;
}
try {
new URL(value); // eslint-disable-line no-new
return true;
}
catch (_a) {
return false;
}
};
// Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);`
is.truthy = (value) => Boolean(value);
// Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);`
is.falsy = (value) => !value;
is.nan = (value) => Number.isNaN(value);
is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value);
is.integer = (value) => Number.isInteger(value);
is.safeInteger = (value) => Number.isSafeInteger(value);
is.plainObject = (value) => {
// From: https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
if (toString.call(value) !== '[object Object]') {
return false;
}
const prototype = Object.getPrototypeOf(value);
return prototype === null || prototype === Object.getPrototypeOf({});
};
is.typedArray = (value) => isTypedArrayName(getObjectType(value));
const isValidLength = (value) => is.safeInteger(value) && value >= 0;
is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
is.inRange = (value, range) => {
if (is.number(range)) {
return value >= Math.min(0, range) && value <= Math.max(range, 0);
}
if (is.array(range) && range.length === 2) {
return value >= Math.min(...range) && value <= Math.max(...range);
}
throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
};
const NODE_TYPE_ELEMENT = 1;
const DOM_PROPERTIES_TO_CHECK = [
'innerHTML',
'ownerDocument',
'style',
'attributes',
'nodeValue'
];
is.domElement = (value) => {
return is.object(value) &&
value.nodeType === NODE_TYPE_ELEMENT &&
is.string(value.nodeName) &&
!is.plainObject(value) &&
DOM_PROPERTIES_TO_CHECK.every(property => property in value);
};
is.observable = (value) => {
var _a, _b, _c, _d;
if (!value) {
return false;
}
// eslint-disable-next-line no-use-extend-native/no-use-extend-native
if (value === ((_b = (_a = value)[Symbol.observable]) === null || _b === void 0 ? void 0 : _b.call(_a))) {
return true;
}
if (value === ((_d = (_c = value)['@@observable']) === null || _d === void 0 ? void 0 : _d.call(_c))) {
return true;
}
return false;
};
is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value);
is.infinite = (value) => value === Infinity || value === -Infinity;
const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder;
is.evenInteger = isAbsoluteMod2(0);
is.oddInteger = isAbsoluteMod2(1);
is.emptyArray = (value) => is.array(value) && value.length === 0;
is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
is.emptyString = (value) => is.string(value) && value.length === 0;
const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value);
is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
// TODO: Use `not ''` when the `not` operator is available.
is.nonEmptyString = (value) => is.string(value) && value.length > 0;
// TODO: Use `not ''` when the `not` operator is available.
is.nonEmptyStringAndNotWhitespace = (value) => is.string(value) && !is.emptyStringOrWhitespace(value);
is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
// TODO: Use `not` operator here to remove `Map` and `Set` from type guard:
// - https://github.com/Microsoft/TypeScript/pull/29317
is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
is.emptySet = (value) => is.set(value) && value.size === 0;
is.nonEmptySet = (value) => is.set(value) && value.size > 0;
is.emptyMap = (value) => is.map(value) && value.size === 0;
is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
// `PropertyKey` is any value that can be used as an object key (string, number, or symbol)
is.propertyKey = (value) => is.any([is.string, is.number, is.symbol], value);
is.formData = (value) => isObjectOfType('FormData')(value);
is.urlSearchParams = (value) => isObjectOfType('URLSearchParams')(value);
const predicateOnArray = (method, predicate, values) => {
if (!is.function_(predicate)) {
throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
}
if (values.length === 0) {
throw new TypeError('Invalid number of values');
}
return method.call(values, predicate);
};
is.any = (predicate, ...values) => {
const predicates = is.array(predicate) ? predicate : [predicate];
return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values));
};
is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
const assertType = (condition, description, value, options = {}) => {
if (!condition) {
const { multipleValues } = options;
const valuesMessage = multipleValues ?
`received values of types ${[
...new Set(value.map(singleValue => `\`${is(singleValue)}\``))
].join(', ')}` :
`received value of type \`${is(value)}\``;
throw new TypeError(`Expected value which is \`${description}\`, ${valuesMessage}.`);
}
};
exports.assert = {
// Unknowns.
undefined: (value) => assertType(is.undefined(value), 'undefined', value),
string: (value) => assertType(is.string(value), 'string', value),
number: (value) => assertType(is.number(value), 'number', value),
bigint: (value) => assertType(is.bigint(value), 'bigint', value),
// eslint-disable-next-line @typescript-eslint/ban-types
function_: (value) => assertType(is.function_(value), 'Function', value),
null_: (value) => assertType(is.null_(value), 'null', value),
class_: (value) => assertType(is.class_(value), "Class" /* class_ */, value),
boolean: (value) => assertType(is.boolean(value), 'boolean', value),
symbol: (value) => assertType(is.symbol(value), 'symbol', value),
numericString: (value) => assertType(is.numericString(value), "string with a number" /* numericString */, value),
array: (value, assertion) => {
const assert = assertType;
assert(is.array(value), 'Array', value);
if (assertion) {
value.forEach(assertion);
}
},
buffer: (value) => assertType(is.buffer(value), 'Buffer', value),
blob: (value) => assertType(is.blob(value), 'Blob', value),
nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), "null or undefined" /* nullOrUndefined */, value),
object: (value) => assertType(is.object(value), 'Object', value),
iterable: (value) => assertType(is.iterable(value), "Iterable" /* iterable */, value),
asyncIterable: (value) => assertType(is.asyncIterable(value), "AsyncIterable" /* asyncIterable */, value),
generator: (value) => assertType(is.generator(value), 'Generator', value),
asyncGenerator: (value) => assertType(is.asyncGenerator(value), 'AsyncGenerator', value),
nativePromise: (value) => assertType(is.nativePromise(value), "native Promise" /* nativePromise */, value),
promise: (value) => assertType(is.promise(value), 'Promise', value),
generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
// eslint-disable-next-line @typescript-eslint/ban-types
asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value),
// eslint-disable-next-line @typescript-eslint/ban-types
boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value),
regExp: (value) => assertType(is.regExp(value), 'RegExp', value),
date: (value) => assertType(is.date(value), 'Date', value),
error: (value) => assertType(is.error(value), 'Error', value),
map: (value) => assertType(is.map(value), 'Map', value),
set: (value) => assertType(is.set(value), 'Set', value),
weakMap: (value) => assertType(is.weakMap(value), 'WeakMap', value),
weakSet: (value) => assertType(is.weakSet(value), 'WeakSet', value),
int8Array: (value) => assertType(is.int8Array(value), 'Int8Array', value),
uint8Array: (value) => assertType(is.uint8Array(value), 'Uint8Array', value),
uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value),
int16Array: (value) => assertType(is.int16Array(value), 'Int16Array', value),
uint16Array: (value) => assertType(is.uint16Array(value), 'Uint16Array', value),
int32Array: (value) => assertType(is.int32Array(value), 'Int32Array', value),
uint32Array: (value) => assertType(is.uint32Array(value), 'Uint32Array', value),
float32Array: (value) => assertType(is.float32Array(value), 'Float32Array', value),
float64Array: (value) => assertType(is.float64Array(value), 'Float64Array', value),
bigInt64Array: (value) => assertType(is.bigInt64Array(value), 'BigInt64Array', value),
bigUint64Array: (value) => assertType(is.bigUint64Array(value), 'BigUint64Array', value),
arrayBuffer: (value) => assertType(is.arrayBuffer(value), 'ArrayBuffer', value),
sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value),
dataView: (value) => assertType(is.dataView(value), 'DataView', value),
enumCase: (value, targetEnum) => assertType(is.enumCase(value, targetEnum), 'EnumCase', value),
urlInstance: (value) => assertType(is.urlInstance(value), 'URL', value),
urlString: (value) => assertType(is.urlString(value), "string with a URL" /* urlString */, value),
truthy: (value) => assertType(is.truthy(value), "truthy" /* truthy */, value),
falsy: (value) => assertType(is.falsy(value), "falsy" /* falsy */, value),
nan: (value) => assertType(is.nan(value), "NaN" /* nan */, value),
primitive: (value) => assertType(is.primitive(value), "primitive" /* primitive */, value),
integer: (value) => assertType(is.integer(value), "integer" /* integer */, value),
safeInteger: (value) => assertType(is.safeInteger(value), "integer" /* safeInteger */, value),
plainObject: (value) => assertType(is.plainObject(value), "plain object" /* plainObject */, value),
typedArray: (value) => assertType(is.typedArray(value), "TypedArray" /* typedArray */, value),
arrayLike: (value) => assertType(is.arrayLike(value), "array-like" /* arrayLike */, value),
domElement: (value) => assertType(is.domElement(value), "HTMLElement" /* domElement */, value),
observable: (value) => assertType(is.observable(value), 'Observable', value),
nodeStream: (value) => assertType(is.nodeStream(value), "Node.js Stream" /* nodeStream */, value),
infinite: (value) => assertType(is.infinite(value), "infinite number" /* infinite */, value),
emptyArray: (value) => assertType(is.emptyArray(value), "empty array" /* emptyArray */, value),
nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), "non-empty array" /* nonEmptyArray */, value),
emptyString: (value) => assertType(is.emptyString(value), "empty string" /* emptyString */, value),
emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), "empty string or whitespace" /* emptyStringOrWhitespace */, value),
nonEmptyString: (value) => assertType(is.nonEmptyString(value), "non-empty string" /* nonEmptyString */, value),
nonEmptyStringAndNotWhitespace: (value) => assertType(is.nonEmptyStringAndNotWhitespace(value), "non-empty string and not whitespace" /* nonEmptyStringAndNotWhitespace */, value),
emptyObject: (value) => assertType(is.emptyObject(value), "empty object" /* emptyObject */, value),
nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), "non-empty object" /* nonEmptyObject */, value),
emptySet: (value) => assertType(is.emptySet(value), "empty set" /* emptySet */, value),
nonEmptySet: (value) => assertType(is.nonEmptySet(value), "non-empty set" /* nonEmptySet */, value),
emptyMap: (value) => assertType(is.emptyMap(value), "empty map" /* emptyMap */, value),
nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), "non-empty map" /* nonEmptyMap */, value),
propertyKey: (value) => assertType(is.propertyKey(value), 'PropertyKey', value),
formData: (value) => assertType(is.formData(value), 'FormData', value),
urlSearchParams: (value) => assertType(is.urlSearchParams(value), 'URLSearchParams', value),
// Numbers.
evenInteger: (value) => assertType(is.evenInteger(value), "even integer" /* evenInteger */, value),
oddInteger: (value) => assertType(is.oddInteger(value), "odd integer" /* oddInteger */, value),
// Two arguments.
directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), "T" /* directInstanceOf */, instance),
inRange: (value, range) => assertType(is.inRange(value, range), "in range" /* inRange */, value),
// Variadic functions.
any: (predicate, ...values) => {
return assertType(is.any(predicate, ...values), "predicate returns truthy for any value" /* any */, values, { multipleValues: true });
},
all: (predicate, ...values) => assertType(is.all(predicate, ...values), "predicate returns truthy for all values" /* all */, values, { multipleValues: true })
};
// Some few keywords are reserved, but we'll populate them for Node.js users
// See https://github.com/Microsoft/TypeScript/issues/2536
Object.defineProperties(is, {
class: {
value: is.class_
},
function: {
value: is.function_
},
null: {
value: is.null_
}
});
Object.defineProperties(exports.assert, {
class: {
value: exports.assert.class_
},
function: {
value: exports.assert.function_
},
null: {
value: exports.assert.null_
}
});
exports["default"] = is;
// For CommonJS default export support
module.exports = is;
module.exports["default"] = is;
module.exports.assert = exports.assert;
/***/ },
/***/ "../../node_modules/@szmarczak/http-timer/dist/source/index.js"
/*!*********************************************************************!*\
!*** ../../node_modules/@szmarczak/http-timer/dist/source/index.js ***!
\*********************************************************************/
(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
const defer_to_connect_1 = __webpack_require__(/*! defer-to-connect */ "../../node_modules/defer-to-connect/dist/source/index.js");
const util_1 = __webpack_require__(/*! util */ "util");
const nodejsMajorVersion = Number(process.versions.node.split('.')[0]);
const timer = (request) => {
if (request.timings) {
return request.timings;
}
const timings = {
start: Date.now(),
socket: undefined,
lookup: undefined,
connect: undefined,
secureConnect: undefined,
upload: undefined,
response: undefined,
end: undefined,
error: undefined,
abort: undefined,
phases: {
wait: undefined,
dns: undefined,
tcp: undefined,
tls: undefined,
request: undefined,
firstByte: undefined,
download: undefined,
total: undefined
}
};
request.timings = timings;
const handleError = (origin) => {
const emit = origin.emit.bind(origin);
origin.emit = (event, ...args) => {
// Catches the `error` event
if (event === 'error') {
timings.error = Date.now();
timings.phases.total = timings.error - timings.start;
origin.emit = emit;
}
// Saves the original behavior
return emit(event, ...args);
};
};
handleError(request);
const onAbort = () => {
timings.abort = Date.now();
// Let the `end` response event be responsible for setting the total phase,
// unless the Node.js major version is >= 13.
if (!timings.response || nodejsMajorVersion >= 13) {
timings.phases.total = Date.now() - timings.start;
}
};
request.prependOnceListener('abort', onAbort);
const onSocket = (socket) => {
timings.socket = Date.now();
timings.phases.wait = timings.socket - timings.start;
if (util_1.types.isProxy(socket)) {
return;
}
const lookupListener = () => {
timings.lookup = Date.now();
timings.phases.dns = timings.lookup - timings.socket;
};
socket.prependOnceListener('lookup', lookupListener);
defer_to_connect_1.default(socket, {
connect: () => {
timings.connect = Date.now();
if (timings.lookup === undefined) {
socket.removeListener('lookup', lookupListener);
timings.lookup = timings.connect;
timings.phases.dns = timings.lookup - timings.socket;
}
timings.phases.tcp = timings.connect - timings.lookup;
// This callback is called before flushing any data,
// so we don't need to set `timings.phases.request` here.
},
secureConnect: () => {
timings.secureConnect = Date.now();
timings.phases.tls = timings.secureConnect - timings.connect;
}
});
};
if (request.socket) {
onSocket(request.socket);
}
else {
request.prependOnceListener('socket', onSocket);
}
const onUpload = () => {
var _a;
timings.upload = Date.now();
timings.phases.request = timings.upload - ((_a = timings.secureConnect) !== null && _a !== void 0 ? _a : timings.connect);
};
const writableFinished = () => {
if (typeof request.writableFinished === 'boolean') {
return request.writableFinished;
}
// Node.js doesn't have `request.writableFinished` property
return request.finished && request.outputSize === 0 && (!request.socket || request.socket.writableLength === 0);
};
if (writableFinished()) {
onUpload();
}
else {
request.prependOnceListener('finish', onUpload);
}
request.prependOnceListener('response', (response) => {
timings.response = Date.now();
timings.phases.firstByte = timings.response - timings.upload;
response.timings = timings;
handleError(response);
response.prependOnceListener('end', () => {
timings.end = Date.now();
timings.phases.download = timings.end - timings.response;
timings.phases.total = timings.end - timings.start;
});
response.prependOnceListener('aborted', onAbort);
});
return timings;
};
exports["default"] = timer;
// For CommonJS default export support
module.exports = timer;
module.exports["default"] = timer;
/***/ },
/***/ "../../packages/aws-client/S3.js"
/*!***************************************!*\
!*** ../../packages/aws-client/S3.js ***!
\***************************************/
(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
/**
* @module S3
*/
var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = {
enumerable: true,
get: function () {
return m[k];
}
};
}
Object.defineProperty(o, k2, desc);
} : function (o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {
Object.defineProperty(o, "default", {
enumerable: true,
value: v
});
} : function (o, v) {
o["default"] = v;
});
var __importStar = this && this.__importStar || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __importDefault = this && this.__importDefault || function (mod) {
return mod && mod.__esModule ? mod : {
"default": mod
};
};
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.moveObject = exports.copyObject = exports.multipartCopyObject = exports.createS3Buckets = exports.createBucket = exports.getFileBucketAndKey = exports.validateS3ObjectChecksum = exports.calculateObjectHash = exports.deleteS3Buckets = exports.recursivelyDeleteS3Bucket = exports.listS3ObjectsV2Batch = exports.listS3ObjectsV2 = exports.listS3Objects = exports.uploadS3FileStream = exports.uploadS3Files = exports.deleteS3Files = exports.fileExists = exports.putJsonS3Object = exports.getJsonS3Object = exports.getTextObject = exports.getObjectStreamContents = exports.getObjectStreamBuffers = exports.getS3Object = exports.waitForObject = exports.getObject = exports.s3PutObjectTagging = exports.s3GetObjectTagging = exports.getObjectSize = exports.downloadS3File = exports.getObjectReadStream = exports.streamS3Upload = exports.promiseS3Upload = exports.s3CopyObject = exports.putFile = exports.s3PutObject = exports.waitForObjectToExist = exports.s3ObjectExists = exports.headObject = exports.deleteS3Objects = exports.deleteS3Object = exports.s3TagSetToQueryString = exports.buildS3Uri = exports.parseS3Uri = exports.s3Join = void 0;
const fs_1 = __importDefault(__webpack_require__(/*! fs */ "fs"));
const isBoolean_1 = __importDefault(__webpack_require__(/*! lodash/isBoolean */ "../../node_modules/lodash/isBoolean.js"));
const path_1 = __importDefault(__webpack_require__(/*! path */ "path"));
const p_map_1 = __importDefault(__webpack_require__(/*! p-map */ "../../packages/aws-client/node_modules/p-map/index.js"));
const p_retry_1 = __importDefault(__webpack_require__(/*! p-retry */ "../../node_modules/p-retry/index.js"));
const p_wait_for_1 = __importDefault(__webpack_require__(/*! p-wait-for */ "../../