@e-mc/cloud 0.0.2 → 0.0.4

package/index.js

@@ -768,6 +768,7 @@ class Cloud extends core_1.ClientDb {
                     break;
             }
             switch (service) {
+                case 'atlas':
                 case 'aws':
                 case 'aws-v3':
                 case 'azure':
@@ -776,7 +777,6 @@ class Cloud extends core_1.ClientDb {
                 case 'minio':
                 case 'oci':
                     result = '@e-mc2/' + service;
-                    folder || (folder = 'client');
                     break;
                 default:
                     result = service;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@e-mc/cloud",
-  "version": "0.0.2",
-  "description": "Cloud constructor for e-mc.",
+  "version": "0.0.4",
+  "description": "Cloud constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
   "publishConfig": {
@@ -20,7 +20,7 @@
   "license": "BSD 3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/core": "0.0.2",
-    "@e-mc/db": "0.0.2"
+    "@e-mc/core": "0.0.4",
+    "@e-mc/db": "0.0.4"
   }
 }

package/atlas/index.js

@@ -1,193 +0,0 @@
-"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

@@ -1,44 +0,0 @@
-"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" /* VAL_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

@@ -1,381 +0,0 @@
-"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" /* VAL_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" /* VAL_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" /* VAL_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" /* VAL_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;