@e-mc/cloud 0.0.1

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2023 An Pham
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,5 @@
+### @e-mc/cloud
+
+### LICENSE
+
+BSD 3-Clause

package/atlas/index.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectId = exports.executeBatchQuery = exports.executeQuery = exports.createDatabaseClient = exports.validateDatabase = void 0;
+const types_1 = require("../../types");
+const mongodb_1 = require("../../db/mongodb");
+const util_1 = require("../util");
+const module_1 = require("../../module");
+const MONGODB_V3 = module_1.default.checkSemVer('mongodb', 1, 4);
+function sanitizeCredentials(item, credential) {
+    const { username, password } = credential;
+    if (username) {
+        const auth = password ? { username, password } : { username };
+        if (MONGODB_V3) {
+            credential.auth = password || !credential.auth || !credential.auth.password ? auth : credential.auth;
+        }
+        else {
+            credential.auth || (credential.auth = auth);
+        }
+        delete credential.username;
+    }
+    if (password) {
+        delete credential.password;
+    }
+    if (MONGODB_V3 && credential.auth) {
+        if (!(0, util_1.hasBasicAuth)(item.uri)) {
+            const auth = (0, util_1.getBasicAuth)(credential.auth);
+            if (auth) {
+                const url = item.uri.split('://');
+                item.uri = url[0] + '://' + auth + url[1];
+            }
+        }
+        delete credential.auth;
+    }
+}
+function validateDatabase(credential, data) {
+    const auth = credential.auth;
+    return !!(data.table && (auth?.username || credential.username || module_1.default.isURL(data.uri) && (0, util_1.hasBasicAuth)(data.uri)));
+}
+exports.validateDatabase = validateDatabase;
+function createDatabaseClient(credential, data) {
+    try {
+        sanitizeCredentials(data, credential);
+        const { MongoClient } = require('mongodb');
+        return new MongoClient(data.uri, credential);
+    }
+    catch (err) {
+        this.checkPackage(err, 'mongodb', { passThrough: true });
+        throw err;
+    }
+}
+exports.createDatabaseClient = createDatabaseClient;
+async function executeQuery(credential, data, sessionKey) {
+    return (await executeBatchQuery.call(this, credential, [data], sessionKey))[0] || [];
+}
+exports.executeQuery = executeQuery;
+async function executeBatchQuery(credential, batch, sessionKey) {
+    const length = batch.length;
+    const result = new Array(length);
+    const clients = {};
+    const caching = length > 0 && this.hasCache(batch[0].service, sessionKey);
+    const coercing = this.hasCoerce('atlas', 'options');
+    const cacheValue = { value: this.valueOfKey(credential, 'cache'), sessionKey };
+    const createClient = async (item, options) => {
+        var _a;
+        return clients[_a = item.uri + module_1.default.asString(options, true)] || (clients[_a] = await createDatabaseClient.call(this, options, item).connect());
+    };
+    const closeClient = () => {
+        for (const key in clients) {
+            clients[key].close();
+        }
+    };
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { service, name, table, id, aggregate, sort, client, ignoreCache } = item;
+        if (!table) {
+            closeClient();
+            throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+        }
+        let { query, update, limit = 0 } = item;
+        if (id && (!query || limit === 1)) {
+            query = getObjectId(id);
+            limit = 1;
+        }
+        const renewCache = ignoreCache === 0;
+        const options = item.options ? length === 1 && !MONGODB_V3 ? Object.assign(item.options, credential) : { ...item.options, ...credential } : length === 1 && !MONGODB_V3 ? credential : { ...credential };
+        let rows, queryString = caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache ? (name || '') + '_' + table + '_' + limit + module_1.default.asString(options, true) + (sort ? module_1.default.asString(sort, true) : '') + (client ? module_1.default.asString(client, true) : '') : '', auth, pipeline;
+        if (queryString) {
+            sanitizeCredentials(item, options);
+            auth = { uri: item.uri, options };
+        }
+        const getCache = () => {
+            if (ignoreCache === 1) {
+                return;
+            }
+            cacheValue.renewCache = renewCache;
+            return this.getQueryResult(service, auth, queryString, cacheValue);
+        };
+        const getCollection = (mongoClient) => mongoClient.db(name, client?.db).collection(table, client?.collection);
+        if (aggregate) {
+            pipeline = Array.isArray(aggregate) ? aggregate : aggregate.pipeline;
+        }
+        if (pipeline || query) {
+            if (queryString) {
+                queryString += module_1.default.asString(aggregate || query, true);
+                if ((aggregate || !update) && (rows = getCache())) {
+                    result[i] = rows;
+                    continue;
+                }
+            }
+            const collection = getCollection(await createClient(item, options));
+            if (pipeline) {
+                const aggregateOptions = aggregate?.options;
+                if (coercing) {
+                    pipeline.forEach(doc => (0, types_1.coerceObject)(doc));
+                    if (aggregateOptions) {
+                        (0, types_1.coerceObject)(aggregateOptions);
+                    }
+                }
+                const items = collection.aggregate(pipeline, aggregateOptions);
+                if (sort) {
+                    items.sort((0, mongodb_1.getSortValue)(sort, coercing)[0]);
+                }
+                if (limit > 0) {
+                    items.limit(limit);
+                }
+                rows = await items.toArray();
+            }
+            else {
+                const updateType = item.updateType;
+                const [filter, command] = (0, mongodb_1.getFilterValue)(query, coercing);
+                if (update && coercing) {
+                    (0, types_1.coerceObject)(update);
+                }
+                if ((0, types_1.isArray)(update)) {
+                    const insertOptions = item.execute?.insert;
+                    if (insertOptions) {
+                        await collection.insertMany(update, coercing ? (0, types_1.coerceObject)(insertOptions) : insertOptions);
+                    }
+                    else {
+                        await collection.insertMany(update);
+                    }
+                    update = undefined;
+                }
+                else if (updateType === 1) {
+                    update = undefined;
+                }
+                if (limit === 1) {
+                    const document = update ? await collection[updateType === 2 ? 'findOneAndReplace' : updateType === 3 ? 'findOneAndDelete' : 'findOneAndUpdate'](filter, update, command) : await collection.findOne(filter, command);
+                    rows = document ? [document] : [];
+                }
+                else {
+                    if (update) {
+                        await collection.updateMany(filter, update);
+                    }
+                    const items = collection.find(filter, command);
+                    if (sort) {
+                        items.sort(...(0, mongodb_1.getSortValue)(sort, coercing));
+                    }
+                    if (limit > 1) {
+                        items.limit(limit);
+                    }
+                    rows = await items.toArray();
+                }
+            }
+        }
+        else if (!aggregate) {
+            if (queryString && (rows = getCache())) {
+                result[i] = rows;
+                continue;
+            }
+            const items = getCollection(await createClient(item, options)).find();
+            if (sort) {
+                items.sort(...(0, mongodb_1.getSortValue)(sort, coercing));
+            }
+            if (limit > 0) {
+                items.limit(limit);
+            }
+            rows = await items.toArray();
+        }
+        else {
+            queryString = '';
+        }
+        result[i] = this.setQueryResult(service, auth, queryString, rows, cacheValue);
+    }
+    closeClient();
+    return result;
+}
+exports.executeBatchQuery = executeBatchQuery;
+function getObjectId(value) {
+    const { ObjectId } = require('mongodb');
+    return { '_id': new ObjectId(value) };
+}
+exports.getObjectId = getObjectId;

package/aws/download/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const types_1 = require("../../../types");
+const module_1 = require("../../../module");
+const index_2 = require("../../index");
+function download(credential, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    const s3 = index_1.createStorageClient.call(this, credential, service, sdk);
+    return (data, callback) => {
+        const { bucket: Bucket, download: target } = data;
+        const Key = target.filename;
+        if (!Bucket || !Key) {
+            callback((0, types_1.errorValue)('Missing property', !Bucket ? 'Bucket' : 'Key'));
+            return;
+        }
+        const location = module_1.default.joinPath(Bucket, Key);
+        const params = { Bucket, Key, VersionId: target.versionId };
+        s3.getObject(params, (err, result) => {
+            if (!err) {
+                callback(null, result.Body);
+                const deleteObject = target.deleteObject;
+                if (deleteObject) {
+                    s3.deleteObject((0, types_1.isPlainObject)(deleteObject) ? Object.assign(deleteObject, params) : params, error => {
+                        if (!error) {
+                            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Delete success" /* CMD_CLOUD.DELETE_FILE */, location, { ...index_2.default.LOG_CLOUD_DELETE });
+                        }
+                        else {
+                            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Delete failed" /* ERR_CLOUD.DELETE_FAIL */, location], error, { ...index_2.default.LOG_CLOUD_FAIL, fatal: !!target.active });
+                        }
+                    });
+                }
+            }
+            else {
+                callback(err);
+            }
+        });
+    };
+}
+exports.default = download;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/aws/index.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNoSuchBucket = exports.getBucketKey = exports.checkBucketCannedACL = exports.setDatabaseEndpoint = exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.setBucketPolicy = exports.createBucketV2 = exports.createBucket = exports.createDatabaseClient = exports.createStorageClient = exports.validateDatabase = exports.validateStorage = exports.getPrivatePolicy = exports.getBucketPublicReadPolicy = exports.getPublicReadPolicy = exports.isDatabaseDefined = exports.isEnvDefined = exports.isAccessDefined = void 0;
+const util_1 = require("../util");
+const types_1 = require("../../types");
+const module_1 = require("../../module");
+const index_1 = require("../index");
+const ACP_AUTHENTICATEDREAD = {
+    Grants: [{
+            Grantee: { Type: 'Group', URI: 'http://acs.amazonaws.com/groups/global/AuthenticatedUsers' },
+            Permission: 'READ'
+        }]
+};
+async function setCannedAcl(S3, Bucket, ACL, service = 'aws', recursive) {
+    if (service === 'oci') {
+        return;
+    }
+    const callback = (err) => {
+        if (!err) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Grant ' + ACL, Bucket], '', { ...recursive ? index_1.default.LOG_CLOUD_DELAYED : index_1.default.LOG_CLOUD_COMMAND });
+        }
+        else if (!recursive) {
+            if (err instanceof Error && err.code === 'OperationAborted') {
+                setTimeout(() => setCannedAcl.call(this, S3, Bucket, ACL, service, true), 60000 /* TIME.m */);
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [`Grant ${ACL} (delayed)`, Bucket], err, { ...index_1.default.LOG_CLOUD_DELAYED });
+            }
+            else {
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Unable to grant ' + ACL, Bucket], err, { ...index_1.default.LOG_CLOUD_WARN });
+            }
+        }
+    };
+    let promise;
+    if (service === 'ibm') {
+        if (ACL === 1) {
+            ACL = 'public-read';
+        }
+        promise = S3.putBucketAcl(ACL === 'authenticated-read' ? { Bucket, AccessControlPolicy: ACP_AUTHENTICATEDREAD } : { Bucket, ACL }).promise();
+    }
+    else {
+        switch (ACL) {
+            case 1:
+                promise = S3.putBucketPolicy({ Bucket, Policy: getBucketPublicReadPolicy(Bucket) }).promise();
+                break;
+            case 'public-read':
+                promise = S3.putBucketPolicy({ Bucket, Policy: getPublicReadPolicy(Bucket) }).promise();
+                break;
+            case 'public-read-write':
+                promise = S3.putBucketPolicy({ Bucket, Policy: getPublicReadPolicy(Bucket, false, true) }).promise();
+                break;
+            case 'authenticated-read':
+                promise = S3.putBucketPolicy({ Bucket, Policy: getPublicReadPolicy(Bucket, true) }).promise();
+                break;
+            default:
+                promise = S3.putBucketPolicy({ Bucket, Policy: getPrivatePolicy(Bucket) }).promise();
+                break;
+        }
+    }
+    return promise.then(() => callback(null)).catch(err => callback(err));
+}
+function isAccessDefined(credential) {
+    return !!(credential.accessKeyId && credential.secretAccessKey || credential.sessionToken);
+}
+exports.isAccessDefined = isAccessDefined;
+function isEnvDefined() {
+    return !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY || process.env.AWS_SESSION_TOKEN);
+}
+exports.isEnvDefined = isEnvDefined;
+function isDatabaseDefined(credential, data) {
+    return !!(data.table && (credential.region || credential.endpoint || process.env.AWS_DEFAULT_REGION));
+}
+exports.isDatabaseDefined = isDatabaseDefined;
+function getPublicReadPolicy(bucket, authenticated, write) {
+    const Action = ["s3:GetObject", "s3:GetObjectVersion"];
+    if (write) {
+        Action.push("s3:PutObject", "s3:DeleteObjectVersion");
+    }
+    return JSON.stringify({
+        "Version": "2012-10-17",
+        "Statement": [{
+                "Sid": (authenticated ? "AuthenticatedRead" : "PublicRead") + (write ? "Write" : ""),
+                "Effect": "Allow",
+                "Principal": authenticated ? { "AWS": "*" } : "*",
+                "Action": Action,
+                "Resource": [`arn:aws:s3:::${bucket}/*`]
+            }]
+    });
+}
+exports.getPublicReadPolicy = getPublicReadPolicy;
+function getBucketPublicReadPolicy(bucket) {
+    return JSON.stringify({
+        "Version": "2012-10-17",
+        "Statement": [{
+                "Sid": "BucketPublicRead",
+                "Effect": "Allow",
+                "Principal": "*",
+                "Action": ["s3:ListBucket", "s3:ListBucketVersions", "s3:ListBucketMultipartUploads"],
+                "Resource": [`arn:aws:s3:::${bucket}`]
+            }]
+    });
+}
+exports.getBucketPublicReadPolicy = getBucketPublicReadPolicy;
+function getPrivatePolicy(bucket) {
+    return JSON.stringify({
+        "Version": "2012-10-17",
+        "Statement": [{
+                "Sid": "Private",
+                "Effect": "Deny",
+                "Principal": "*",
+                "Action": "*",
+                "Resource": [`arn:aws:s3:::${bucket}`, `arn:aws:s3:::${bucket}/*`]
+            }]
+    });
+}
+exports.getPrivatePolicy = getPrivatePolicy;
+function validateStorage(credential) {
+    return !!(isAccessDefined(credential) || isEnvDefined() || credential.fromPath || credential.profile || process.env.AWS_SDK_LOAD_CONFIG === '1');
+}
+exports.validateStorage = validateStorage;
+function validateDatabase(credential, data) {
+    return isDatabaseDefined(credential, data) && validateStorage(credential);
+}
+exports.validateDatabase = validateDatabase;
+function createStorageClient(credential, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    try {
+        if (service === 'aws') {
+            const S3 = require('aws-sdk/clients/s3');
+            if (credential.fromPath) {
+                const client = new S3();
+                client.config.loadFromPath(credential.fromPath);
+                return client;
+            }
+            if (credential.profile || process.env.AWS_SDK_LOAD_CONFIG === '1' && !isAccessDefined(credential) && !isEnvDefined()) {
+                const { SharedIniFileCredentials } = require('aws-sdk');
+                credential = new SharedIniFileCredentials({ profile: credential.profile });
+            }
+            return new S3(credential);
+        }
+        const S3 = require(sdk);
+        return new S3(credential);
+    }
+    catch (err) {
+        this.checkPackage(err, sdk.split('/')[0], { passThrough: true });
+        throw err;
+    }
+}
+exports.createStorageClient = createStorageClient;
+function createDatabaseClient(credential) {
+    try {
+        let options;
+        if (credential.fromPath) {
+            const AWS = require('aws-sdk');
+            AWS.config.loadFromPath(credential.fromPath);
+        }
+        else if (credential.profile || process.env.AWS_SDK_LOAD_CONFIG === '1' && !isAccessDefined(credential) && !isEnvDefined()) {
+            const { SharedIniFileCredentials } = require('aws-sdk');
+            options = new SharedIniFileCredentials({ profile: credential.profile });
+        }
+        else {
+            options = credential;
+        }
+        const DynamoDB = require('aws-sdk/clients/dynamodb');
+        return new DynamoDB.DocumentClient(options);
+    }
+    catch (err) {
+        this.checkPackage(err, 'aws-sdk', { passThrough: true });
+        throw err;
+    }
+}
+exports.createDatabaseClient = createDatabaseClient;
+function createBucket(credential, Bucket, publicRead, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    return createBucketV2.call(this, credential, Bucket, publicRead ? 'public-read' : undefined, undefined, service, sdk);
+}
+exports.createBucket = createBucket;
+function createBucketV2(credential, Bucket, ACL, options, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    ACL = ACL === 1 ? 1 : checkBucketCannedACL(ACL);
+    const S3 = createStorageClient.call(this, credential, service, sdk);
+    return S3.headBucket({ Bucket }).promise()
+        .then(async () => {
+        if (ACL) {
+            await setCannedAcl.call(this, S3, Bucket, ACL, service);
+        }
+        return true;
+    })
+        .catch(() => {
+        const input = { ...options, Bucket };
+        const region = credential.region;
+        if (!input.CreateBucketConfiguration && typeof region === 'string' && (region !== 'us-east-1' || service !== 'aws')) {
+            input.CreateBucketConfiguration = { LocationConstraint: region };
+        }
+        return S3.createBucket(input).promise()
+            .then(async () => {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket created" /* CMD_CLOUD.CREATE_BUCKET */, Bucket], '', { ...index_1.default.LOG_CLOUD_COMMAND });
+            if (ACL) {
+                await setCannedAcl.call(this, S3, Bucket, ACL, service);
+            }
+            return true;
+        })
+            .catch(async (err) => {
+            switch (err instanceof Error && err.code) {
+                case 'BucketAlreadyExists':
+                case 'BucketAlreadyOwnedByYou':
+                    if (ACL) {
+                        await setCannedAcl.call(this, S3, Bucket, ACL, service);
+                    }
+                    return true;
+                default:
+                    this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to create bucket" /* ERR_CLOUD.CREATE_BUCKET */, Bucket], err, { ...index_1.default.LOG_CLOUD_FAIL });
+                    return false;
+            }
+        });
+    });
+}
+exports.createBucketV2 = createBucketV2;
+function setBucketPolicy(credential, Bucket, options, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    const S3 = createStorageClient.call(this, credential, service, sdk);
+    options.Bucket = Bucket;
+    if (service === 'ibm' && 'ACL' in options && options.ACL === 'authenticated-read') {
+        options.AccessControlPolicy = ACP_AUTHENTICATEDREAD;
+        delete options.ACL;
+    }
+    return ('Policy' in options && (0, types_1.isString)(options.Policy) && service !== 'ibm' ? S3.putBucketPolicy(options) : S3.putBucketAcl(options)).promise()
+        .then(() => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket policy configured" /* CMD_CLOUD.POLICY_BUCKET */, Bucket], '', { ...index_1.default.LOG_CLOUD_COMMAND });
+        return true;
+    })
+        .catch(err => {
+        if (!(0, exports.isNoSuchBucket)(err)) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to update bucket policy" /* ERR_CLOUD.POLICY_BUCKET */, Bucket], err, { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
+        }
+        return false;
+    });
+}
+exports.setBucketPolicy = setBucketPolicy;
+function setBucketWebsite(credential, Bucket, options, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    const S3 = createStorageClient.call(this, credential, service, sdk);
+    const WebsiteConfiguration = {};
+    if ((0, types_1.isString)(options.indexPage)) {
+        WebsiteConfiguration.IndexDocument = { Suffix: options.indexPage };
+    }
+    if ((0, types_1.isString)(options.errorPage)) {
+        WebsiteConfiguration.ErrorDocument = { Key: options.errorPage };
+    }
+    return S3.putBucketWebsite({ Bucket, WebsiteConfiguration }).promise()
+        .then(() => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket configured" /* CMD_CLOUD.CONFIGURE_BUCKET */, Bucket], WebsiteConfiguration, { ...index_1.default.LOG_CLOUD_COMMAND });
+        return true;
+    })
+        .catch(err => {
+        if (!(0, exports.isNoSuchBucket)(err)) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to configure bucket" /* ERR_CLOUD.CONFIGURE_BUCKET */, Bucket], err, { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
+        }
+        return false;
+    });
+}
+exports.setBucketWebsite = setBucketWebsite;
+function deleteObjects(credential, Bucket, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    return deleteObjectsV2.call(this, credential, Bucket, true, service, sdk);
+}
+exports.deleteObjects = deleteObjects;
+async function deleteObjectsV2(credential, Bucket, recursive = true, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    const S3 = createStorageClient.call(this, credential, service, sdk);
+    return S3.listObjects({ Bucket }).promise()
+        .then(({ Contents }) => {
+        if (Contents?.length) {
+            let Objects = Contents.map(data => ({ Key: data.Key }));
+            if (!recursive) {
+                Objects = Objects.filter(value => value.Key.indexOf('/') === -1);
+            }
+            return S3.deleteObjects({ Bucket, Delete: { Objects } }).promise()
+                .then(data => {
+                if ((0, types_1.isArray)(data.Deleted)) {
+                    const files = data.Deleted.length + ' files';
+                    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket emptied" /* CMD_CLOUD.EMPTY_BUCKET */ + ` (${recursive ? 'recursive' : files})`, Bucket], recursive ? files : '', { ...index_1.default.LOG_CLOUD_COMMAND });
+                }
+            })
+                .catch(err => {
+                this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to empty bucket" /* ERR_CLOUD.DELETE_BUCKET */, Bucket], err, { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
+            });
+        }
+    })
+        .catch(err => {
+        if (!(0, exports.isNoSuchBucket)(err)) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to list bucket" /* ERR_CLOUD.LIST_BUCKET */, Bucket], err, { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
+        }
+    });
+}
+exports.deleteObjectsV2 = deleteObjectsV2;
+async function executeQuery(credential, data, sessionKey) {
+    return (await executeBatchQuery.call(this, credential, [data], sessionKey))[0] || [];
+}
+exports.executeQuery = executeQuery;
+async function executeBatchQuery(credential, batch, sessionKey) {
+    const length = batch.length;
+    const result = new Array(length);
+    const caching = length > 0 && this.hasCache(batch[0].service, sessionKey);
+    const cacheValue = { value: this.valueOfKey(credential, 'cache'), sessionKey };
+    let client;
+    const createClient = () => {
+        setDatabaseEndpoint(credential);
+        return client || (client = createDatabaseClient.call(this, length === 1 ? credential : { ...credential }));
+    };
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { service, table, id = '', query, partitionKey, key = partitionKey, limit = 0, update, ignoreCache } = item;
+        if (!table) {
+            throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+        }
+        const renewCache = ignoreCache === 0;
+        const getCache = (value) => {
+            if (ignoreCache === 1) {
+                return;
+            }
+            cacheValue.renewCache = renewCache;
+            return this.getQueryResult(service, credential, value, cacheValue);
+        };
+        let rows, queryString = caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache ? table + '_' : '';
+        if (key && (id || (0, types_1.isPlainObject)(key))) {
+            if (queryString) {
+                queryString += module_1.default.asString(key, true) + id;
+                if (!update && (rows = getCache(queryString))) {
+                    result[i] = rows;
+                    continue;
+                }
+            }
+            const Key = (0, types_1.isPlainObject)(key) ? key : { [key]: id };
+            const command = { TableName: table, Key };
+            client = createClient();
+            if (update) {
+                await client.update({ ...command, ...update }).promise();
+            }
+            const output = await client.get(command).promise();
+            if (output.Item) {
+                rows = [output.Item];
+            }
+        }
+        else if ((0, types_1.isPlainObject)(query)) {
+            if (queryString && (rows = getCache(queryString += module_1.default.asString(query, true) + limit))) {
+                result[i] = rows;
+                continue;
+            }
+            query.TableName = table;
+            if (limit > 0) {
+                query.Limit = limit;
+            }
+            const output = await createClient().query(query).promise();
+            if (output.Count && output.Items) {
+                rows = output.Items;
+            }
+        }
+        else {
+            throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
+        }
+        result[i] = this.setQueryResult(service, credential, queryString, rows, cacheValue);
+    }
+    return result;
+}
+exports.executeBatchQuery = executeBatchQuery;
+function setDatabaseEndpoint(config) {
+    config.endpoint || (config.endpoint = `https://dynamodb.${(0, types_1.isString)(config.region) ? config.region : process.env.AWS_DEFAULT_REGION || 'us-east-1'}.amazonaws.com`);
+    if (!config.region && (0, types_1.isString)(config.endpoint)) {
+        const region = (/dynamodb\.([^.]+)\./i.exec(config.endpoint)?.[1] || process.env.AWS_DEFAULT_REGION)?.toLowerCase();
+        if (region && region !== 'us-east-1') {
+            config.region = region;
+        }
+    }
+}
+exports.setDatabaseEndpoint = setDatabaseEndpoint;
+function checkBucketCannedACL(value) {
+    switch (value) {
+        case 'private':
+        case 'public-read':
+        case 'public-read-write':
+        case 'authenticated-read':
+            return value;
+    }
+}
+exports.checkBucketCannedACL = checkBucketCannedACL;
+const getBucketKey = (credential, Bucket, acl, service, sdk) => module_1.default.asString(credential, true) + Bucket + '_' + (acl || '') + service + sdk;
+exports.getBucketKey = getBucketKey;
+const isNoSuchBucket = (err) => err instanceof Error && err.code === 'NoSuchBucket';
+exports.isNoSuchBucket = isNoSuchBucket;