@e-mc/cloud 0.0.1

package/index.js

@@ -0,0 +1,832 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const types_1 = require("../types");
+const core_1 = require("../core");
+const util_1 = require("./util");
+const SERVICE_CLIENT = {};
+const SERVICE_UPLOAD = {};
+const SERVICE_DOWNLOAD = {};
+function setUploadFilename(upload, filename) {
+    filename = Cloud.toPosix(filename.replace(/^\.*[\\/]+/, ''));
+    const index = filename.lastIndexOf('/');
+    if (index !== -1) {
+        const directory = filename.substring(0, index + 1);
+        upload.pathname = upload.pathname ? Cloud.joinPath(upload.pathname, directory) : directory;
+        filename = filename.substring(index + 1);
+    }
+    return upload.filename = filename;
+}
+function hasSameBucket({ upload, service, bucket }, other) {
+    const endpoint = upload.endpoint;
+    return (service && other.service || endpoint && endpoint === other.upload.endpoint) && bucket === other.bucket;
+}
+function getFiles(file, data) {
+    const grouped = file.localUri ? [file.localUri] : [];
+    if (data.all) {
+        const individual = new Set();
+        if (!file.cloudUrl) {
+            file.transforms?.forEach(value => individual.add(value));
+        }
+        file.torrentFiles?.forEach(value => individual.add(value));
+        if (file.descendants) {
+            grouped.push(...file.descendants);
+        }
+        return [grouped, Array.from(individual)];
+    }
+    return [grouped];
+}
+const errorObject = (err, service, value) => err instanceof Error ? err : typeof err === 'string' ? new Error(err) : (0, util_1.formatError)(service, value);
+const assignFilename = (value) => (0, types_1.generateUUID)() + (path.extname(value) || '');
+class Cloud extends core_1.ClientDb {
+    constructor() {
+        super(...arguments);
+        this._moduleName = 'cloud';
+        this._threadable = true;
+        this.uploaded = [];
+        this.downloaded = [];
+    }
+    static async finalize(instance) {
+        var _a, _b;
+        if (instance.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        Cloud.sanitizeAssets(this.assets);
+        const localStorage = new Map();
+        const bucketGroup = (0, types_1.generateUUID)();
+        const state = { host: this, instance, bucketGroup, localStorage };
+        const bucketDelete = {};
+        const bucketPolicy = {};
+        const rawFiles = [];
+        const startTime = process.hrtime();
+        let tasks = [], downloadMap;
+        if (await instance.commit()) {
+            instance.writeTimeElapsed(instance.moduleName, "Transactions were committed" /* VAL_MESSAGE.COMMIT_TRANSACTION */, startTime, { type: 64 /* LOG_TYPE.CLOUD */, ...Cloud.LOG_STYLE_SUCCESS });
+        }
+        for (const { instance: document } of this.Document) {
+            document.cloudInit?.(state);
+        }
+        for (const item of this.assets) {
+            const cloudStorage = item.cloudStorage;
+            if ((0, types_1.isArray)(cloudStorage) && !(0, types_1.ignoreFlag)(item.flags)) {
+                if (item.invalid) {
+                    cloudStorage.forEach(storage => instance.formatMessage(64 /* LOG_TYPE.CLOUD */, storage.service, ["Upload failed" /* ERR_CLOUD.UPLOAD_FAIL */, storage.bucket], (0, types_1.errorValue)("File not found" /* ERR_MESSAGE.NOTFOUND_FILE */, item.uri || item.filename || "Unknown" /* ERR_MESSAGE.UNKNOWN */), { ...Cloud.LOG_CLOUD_WARN }));
+                    continue;
+                }
+                ignore: {
+                    if (item.localUri || item.torrentFiles) {
+                        for (const { instance: document } of this.Document) {
+                            if (document.cloudObject?.(state, item)) {
+                                break ignore;
+                            }
+                        }
+                        if (item.compress) {
+                            tasks.push(this.compressFile(item));
+                        }
+                        rawFiles.push(item);
+                    }
+                }
+                for (const storage of cloudStorage) {
+                    const { admin, bucket } = storage;
+                    if (admin && bucket && instance.hasCredential('storage', storage)) {
+                        const policy = admin.configBucket?.policy;
+                        if (admin.emptyBucket) {
+                            const service = bucketDelete[_a = storage.service] || (bucketDelete[_a] = {});
+                            const items = service[bucket];
+                            if (!items) {
+                                service[bucket] = [instance.getCredential(storage), admin.recursive];
+                            }
+                            else if (admin.recursive === false) {
+                                items[1] = false;
+                            }
+                        }
+                        if (policy) {
+                            const service = bucketPolicy[_b = storage.service] || (bucketPolicy[_b] = {});
+                            service[bucket] = [storage.service, instance.getCredential(storage), bucket, policy];
+                        }
+                    }
+                }
+            }
+        }
+        if (tasks.length) {
+            await instance.allSettled(tasks, ['Compress files', instance.moduleName]);
+            if (instance.aborted) {
+                return Promise.reject((0, types_1.createAbortError)());
+            }
+            tasks = [];
+        }
+        for (const service in bucketDelete) {
+            const map = bucketDelete[service];
+            for (const bucket in map) {
+                const [credential, recursive] = map[bucket];
+                tasks.push(instance.deleteObjects(service, credential, bucket, recursive).catch(err => instance.writeFail(["Unable to empty bucket" /* ERR_CLOUD.DELETE_BUCKET */, service + ': ' + bucket], err, { type: 64 /* LOG_TYPE.CLOUD */, startTime })));
+            }
+        }
+        if (tasks.length) {
+            await instance.allSettled(tasks, ['Empty bucket', instance.moduleName]);
+            if (instance.aborted) {
+                return Promise.reject((0, types_1.createAbortError)());
+            }
+            tasks = [];
+        }
+        rawFiles.forEach(item => tasks.push(...Cloud.uploadAsset(state, item)));
+        if (tasks.length) {
+            await instance.allSettled(tasks, ['Upload raw assets', instance.moduleName]);
+            if (instance.aborted) {
+                return Promise.reject((0, types_1.createAbortError)());
+            }
+            tasks = [];
+        }
+        for (const service in bucketPolicy) {
+            const map = bucketPolicy[service];
+            for (const bucket in map) {
+                const params = map[bucket];
+                tasks.push(instance.setBucketPolicy(...params).catch(err => instance.writeFail(["Unable to update bucket policy" /* ERR_CLOUD.POLICY_BUCKET */, params[0] + ': ' + params[2]], err, { type: 64 /* LOG_TYPE.CLOUD */, startTime })));
+            }
+        }
+        if (tasks.length) {
+            await instance.allSettled(tasks, ['Configure bucket', instance.moduleName]);
+            if (instance.aborted) {
+                return Promise.reject((0, types_1.createAbortError)());
+            }
+            tasks = [];
+        }
+        for (const { instance: document } of this.Document) {
+            if (document.cloudFinalize) {
+                await document.cloudFinalize(state).catch(err => document.writeFail(["Handled rejection" /* ERR_MESSAGE.HANDLED_REJECTION */, document.moduleName], err, { type: 64 /* LOG_TYPE.CLOUD */, startTime }));
+                if (document.aborted) {
+                    return Promise.reject((0, types_1.createAbortError)());
+                }
+            }
+        }
+        for (const [item, data] of localStorage) {
+            getFiles(item, data).forEach(group => group.forEach(value => this.deleteFile(value, { emptyDir: true })));
+        }
+        for (const item of this.assets) {
+            const cloudStorage = item.cloudStorage;
+            if ((0, types_1.isArray)(cloudStorage) && !(0, types_1.ignoreFlag)(item.flags)) {
+                for (const data of cloudStorage) {
+                    if (!instance.hasStorage('download', data)) {
+                        continue;
+                    }
+                    const download = data.download;
+                    const { pathname, filename, waitStatus, overwrite } = download;
+                    let active = download.active;
+                    if (!filename) {
+                        continue;
+                    }
+                    const localUri = item.localUri;
+                    let downloadUri;
+                    if (pathname && path.isAbsolute(pathname)) {
+                        downloadUri = path.join(pathname, filename);
+                        if (!Cloud.isPath(downloadUri) && !this.canWrite(pathname)) {
+                            instance.writeFail(["Unable to download file" /* ERR_MESSAGE.DOWNLOAD_FILE */, filename], (0, types_1.errorValue)("Unsupported access" /* ERR_MESSAGE.UNSUPPORTED_ACCESS */, pathname), { type: 64 /* LOG_TYPE.CLOUD */, fatal: !!active, startTime });
+                            continue;
+                        }
+                    }
+                    else {
+                        downloadUri = pathname ? path.join(this.baseDirectory, pathname.replace(/^([A-Z]:)?[\\/]+/i, ''), filename) : path.join(data.admin?.preservePath && localUri ? path.dirname(localUri) : this.baseDirectory, filename);
+                    }
+                    const destDir = path.dirname(downloadUri);
+                    if (Cloud.isPath(downloadUri)) {
+                        if (!active && !overwrite) {
+                            continue;
+                        }
+                        active = true;
+                    }
+                    else if (!Cloud.createDir(destDir)) {
+                        continue;
+                    }
+                    else if (active) {
+                        if (localUri && path.extname(localUri) === path.extname(downloadUri)) {
+                            downloadUri = localUri;
+                        }
+                        else {
+                            active = false;
+                        }
+                    }
+                    const location = data.service + data.bucket + filename;
+                    let pending = (downloadMap || (downloadMap = {}))[location];
+                    if (pending) {
+                        pending.add(downloadUri);
+                    }
+                    else {
+                        pending = new Set([downloadUri]);
+                        download.admin = data.admin;
+                        const task = instance.downloadObject(data.service, instance.getCredential(data), data.bucket, download, (value) => {
+                            let result;
+                            if (value && !instance.aborted) {
+                                const items = Array.from(pending);
+                                for (let i = 0, length = items.length, size, copy; i < length; ++i) {
+                                    const destUri = items[i];
+                                    try {
+                                        if (typeof value === 'string') {
+                                            if (!copy && i === length - 1) {
+                                                fs.renameSync(value, destUri);
+                                            }
+                                            else {
+                                                fs.copyFileSync(value, destUri);
+                                            }
+                                            size = this.addDownload(destUri);
+                                        }
+                                        else {
+                                            fs.writeFileSync(destUri, value);
+                                            this.addDownload(size = value.length);
+                                        }
+                                        this.add(destUri);
+                                        this.formatMessage(64 /* LOG_TYPE.CLOUD */, data.service, ["Download success" /* CMD_CLOUD.DOWNLOAD_FILE */, (0, types_1.formatSize)(size)], destUri, { ...Cloud.LOG_CLOUD_DOWNLOAD });
+                                        result || (result = destUri);
+                                    }
+                                    catch (err) {
+                                        if (!copy && core_1.ClientDb.isErrorCode(err, 'EXDEV')) {
+                                            copy = true;
+                                            --i;
+                                        }
+                                        else {
+                                            instance.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(destUri)], err, { type: 32 /* LOG_TYPE.FILE */, fatal: !!active, startTime });
+                                        }
+                                    }
+                                }
+                            }
+                            return Promise.resolve(result);
+                        })
+                            .catch(err => instance.writeFail(["Download failed" /* ERR_CLOUD.DOWNLOAD_FAIL */, path.basename(downloadUri)], err, { type: 64 /* LOG_TYPE.CLOUD */, startTime }));
+                        if (active || waitStatus || this.archiving) {
+                            tasks.push(task);
+                        }
+                        downloadMap[location] = pending;
+                    }
+                }
+            }
+        }
+        if (tasks.length) {
+            return instance.allSettled(tasks, ['Download objects', instance.moduleName]);
+        }
+    }
+    static uploadAsset(state, file, contentType = file.mimeType, ignoreProcess) {
+        if (typeof contentType === 'boolean') {
+            ignoreProcess = contentType;
+            contentType = file.mimeType;
+        }
+        const { host, instance } = state;
+        if (instance.aborted) {
+            return [];
+        }
+        const tasks = [];
+        for (const storage of file.cloudStorage) {
+            if (!instance.hasStorage('upload', storage)) {
+                continue;
+            }
+            const upload = storage.upload;
+            const active = storage === instance.getStorage('upload', file.cloudStorage);
+            if (active && upload.localStorage === false) {
+                state.localStorage.set(file, upload);
+            }
+            const callback = async (value) => {
+                if (value && !ignoreProcess) {
+                    for (const { instance: document } of host.Document) {
+                        if (document.cloudUpload && await document.cloudUpload(state, file, value, active)) {
+                            return;
+                        }
+                    }
+                }
+            };
+            const task = new Promise(resolve => {
+                const { service, bucket = state.bucketGroup, admin } = storage;
+                const credential = instance.getCredential(storage, true);
+                const uploading = [];
+                getFiles(file, upload).forEach((group, index) => {
+                    let fileGroup;
+                    if (index === 0 && group.length > 1) {
+                        switch (service) {
+                            case 'gcp':
+                            case 'gcloud':
+                                fileGroup = group.slice(1).filter(value => this.isPath(value)).map(value => [value, path.extname(value), value]);
+                                break;
+                            default:
+                                fileGroup = [];
+                                for (let i = 1; i < group.length; ++i) {
+                                    const value = group[i];
+                                    try {
+                                        if (fs.existsSync(value)) {
+                                            fileGroup.push([fs.readFileSync(value), path.extname(value), value]);
+                                        }
+                                    }
+                                    catch (err) {
+                                        instance.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(value)], err, { type: 32 /* LOG_TYPE.FILE */, fatal: false });
+                                    }
+                                }
+                                break;
+                        }
+                        group = [group[0]];
+                    }
+                    for (const localUri of group) {
+                        const exists = this.isPath(localUri);
+                        if (!exists || !instance.canRead(localUri, { ownPermissionOnly: true })) {
+                            instance.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(localUri)], (0, types_1.errorValue)(exists ? "Not permitted to read file" /* ERR_MESSAGE.UNSUPPORTED_READ */ : "File not found" /* ERR_MESSAGE.NOTFOUND_FILE */, localUri), { type: 64 /* LOG_TYPE.CLOUD */, fatal: index === 0 });
+                            continue;
+                        }
+                        let buffer, filename;
+                        if (index === 0) {
+                            if (file.cloudUrl) {
+                                filename = path.basename(file.cloudUrl);
+                            }
+                            else if (upload.filename) {
+                                filename = upload.filename;
+                            }
+                            else if (upload.overwrite) {
+                                filename = path.basename(localUri);
+                            }
+                            buffer = file.sourceUTF8 ? Buffer.from(file.sourceUTF8, file.encoding) : host.getBuffer(file);
+                        }
+                        else {
+                            contentType = this.lookupMime(path.basename(localUri)) || file.mimeType;
+                        }
+                        const options = { ...upload, buffer, filename, fileGroup, admin };
+                        if (index > 0 || !options.contentType) {
+                            options.contentType = contentType;
+                        }
+                        uploading.push(instance.uploadObject(service, { ...credential }, bucket, options, localUri, callback)
+                            .catch(err => instance.writeFail(["Upload failed" /* ERR_CLOUD.UPLOAD_FAIL */, path.basename(localUri)], err, { type: 64 /* LOG_TYPE.CLOUD */, fatal: index === 0 })));
+                    }
+                });
+                instance.allSettled(uploading, [`Upload file "${contentType || "Unknown" /* ERR_MESSAGE.UNKNOWN */}"`, storage.service + ': ' + path.basename(file.localUri)]).then(() => resolve());
+            });
+            if (active) {
+                tasks.push(task);
+            }
+        }
+        return tasks;
+    }
+    static sanitizeAssets(assets) {
+        const storage = [];
+        for (const item of assets) {
+            const cloudStorage = item.cloudStorage;
+            if ((0, types_1.isArray)(cloudStorage) && !(0, types_1.ignoreFlag)(item.flags)) {
+                for (const data of cloudStorage) {
+                    const upload = data.upload;
+                    if (upload) {
+                        if (upload.filename) {
+                            setUploadFilename(upload, this.toPosix(upload.filename));
+                        }
+                        const pathname = upload.pathname || data.admin?.preservePath && item.pathname;
+                        if (pathname) {
+                            upload.pathname = this.toPosix(pathname).replace(/^\/+/, '') + '/';
+                        }
+                    }
+                }
+                storage.push(item);
+            }
+        }
+        const nameIndex = {};
+        const length = storage.length;
+        for (let i = length - 1; i > 0; --i) {
+            const current = storage[i];
+            for (const data of current.cloudStorage) {
+                const trailing = data.upload;
+                if (!trailing) {
+                    continue;
+                }
+                renamed: {
+                    const basename = trailing.filename;
+                    const filename = basename || current.filename;
+                    const trailingFolder = trailing.pathname || '';
+                    const trailingName = this.joinPath(trailingFolder, filename);
+                    for (let j = 0; j < length - 1; ++j) {
+                        const previous = storage[j];
+                        if (current === previous) {
+                            continue;
+                        }
+                        for (const other of previous.cloudStorage) {
+                            const leading = other.upload;
+                            if (leading && hasSameBucket(data, other)) {
+                                const leadingFolder = leading.pathname || '';
+                                const renameTrailing = (value) => {
+                                    const location = trailingFolder + value;
+                                    nameIndex[location] || (nameIndex[location] = 1);
+                                    const index = value.indexOf('.');
+                                    trailing.filename = (index !== -1 ? value.substring(0, index) : value) + '_' + nameIndex[location]++ + (index !== -1 ? value.substring(index) : '');
+                                };
+                                if (basename && basename === leading.filename && leadingFolder === trailingFolder) {
+                                    renameTrailing(basename);
+                                    break renamed;
+                                }
+                                const leadingName = this.joinPath(leadingFolder, leading.filename || previous.filename);
+                                if (trailingName === leadingName) {
+                                    if (!trailing.overwrite || leading.overwrite) {
+                                        renameTrailing(filename);
+                                        break renamed;
+                                    }
+                                    leading.filename = assignFilename(leading.filename || previous.filename);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return assets;
+    }
+    setQueryResult(service, credential, queryString, result, sessionKey) {
+        if (!Array.isArray(result)) {
+            result = typeof result === 'object' ? [result] : [];
+        }
+        else if (result.includes(undefined)) {
+            result = result.filter(item => typeof item === 'object');
+        }
+        return super.setQueryResult(service, credential, queryString, result, sessionKey);
+    }
+    createBucket(service, credential, bucket, publicRead, options) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        try {
+            const client = this.getClient(service);
+            try {
+                if (publicRead === undefined || typeof publicRead === 'boolean') {
+                    const handler = client.createBucket?.bind(this);
+                    if (handler) {
+                        return handler.call(this, credential, bucket, publicRead);
+                    }
+                }
+                else {
+                    const handler = client.createBucketV2?.bind(this);
+                    if (handler) {
+                        return handler.call(this, credential, bucket, publicRead, options);
+                    }
+                }
+                return Promise.reject((0, util_1.formatError)(service, "Create bucket not supported" /* ERR_CLOUD.CREATE_BUCKET_SUPPORT */));
+            }
+            catch (err) {
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Unable to create bucket" /* ERR_CLOUD.CREATE_BUCKET */, bucket], err, { ...Cloud.LOG_CLOUD_WARN });
+                return Promise.reject(err);
+            }
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    setBucketPolicy(service, credential, bucket, options) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        try {
+            const handler = this.getClient(service).setBucketPolicy?.bind(this);
+            if (handler) {
+                try {
+                    return handler.call(this, credential, bucket, options);
+                }
+                catch (err) {
+                    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Unable to update bucket policy" /* ERR_CLOUD.POLICY_BUCKET */, bucket], err, { ...Cloud.LOG_CLOUD_WARN });
+                    return Promise.reject(err);
+                }
+            }
+            return Promise.reject((0, util_1.formatError)(service, "Bucket policy not supported" /* ERR_CLOUD.BUCKET_POLICY_SUPPORT */));
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    setBucketWebsite(service, credential, bucket, options) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        try {
+            const handler = this.getClient(service).setBucketWebsite?.bind(this);
+            if (handler) {
+                try {
+                    return handler.call(this, credential, bucket, options);
+                }
+                catch (err) {
+                    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Unable to configure bucket" /* ERR_CLOUD.CONFIGURE_BUCKET */, bucket], err, { ...Cloud.LOG_CLOUD_WARN });
+                    return Promise.reject(err);
+                }
+            }
+            return Promise.reject((0, util_1.formatError)(service, "Set bucket website not supported" /* ERR_CLOUD.BUCKET_WEBSITE_SUPPORT */));
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    deleteObjects(service, credential, bucket, recursive = true) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        try {
+            const errorResponse = (err) => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Unable to empty bucket" /* ERR_CLOUD.DELETE_BUCKET */, bucket], err, { ...Cloud.LOG_CLOUD_WARN });
+            const client = this.getClient(service);
+            const handlerV2 = client.deleteObjectsV2?.bind(this);
+            if (handlerV2) {
+                return handlerV2.call(this, credential, bucket, recursive, service).catch(err => errorResponse(err));
+            }
+            const handlerV1 = client.deleteObjects?.bind(this);
+            if (handlerV1) {
+                return handlerV1.call(this, credential, bucket, service, undefined, recursive).catch(err => errorResponse(err));
+            }
+            return Promise.reject((0, util_1.formatError)(service, "Delete objects not supported" /* ERR_CLOUD.DELETE_OBJECTS_SUPPORT */));
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    uploadObject(service, credential, bucket, upload, localUri, beforeResolve) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        let handler;
+        try {
+            handler = this.getUploadHandler(service, credential).bind(this);
+        }
+        catch (err) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Upload function not supported" /* ERR_CLOUD.UPLOAD_SUPPORT */, bucket], localUri, { ...Cloud.LOG_CLOUD_WARN });
+            return Promise.reject(err);
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                handler({ bucket, upload, buffer: upload.buffer || fs.readFileSync(localUri), localUri }, async (err, value) => {
+                    if (err) {
+                        reject(errorObject(err, service, "Upload failed" /* ERR_CLOUD.UPLOAD_FAIL */));
+                    }
+                    else if (value) {
+                        if (beforeResolve) {
+                            await beforeResolve(value);
+                        }
+                        this.addLog(types_1.STATUS_TYPE.INFO, service + ' -> upload -> ' + value);
+                        resolve(value);
+                    }
+                    else {
+                        reject((0, util_1.formatError)(service, "Upload failed" /* ERR_CLOUD.UPLOAD_FAIL */));
+                    }
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    downloadObject(service, credential, bucket, download, beforeResolve) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        if ((service === 'gcp' || service === 'gcloud') && (0, types_1.isPlainObject)(credential)) {
+            credential.storageBucket || (credential.storageBucket = bucket);
+        }
+        let handler;
+        try {
+            handler = this.getDownloadHandler(service, credential).bind(this);
+        }
+        catch (err) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Download function not supported" /* ERR_CLOUD.DOWNLOAD_SUPPORT */, bucket], Cloud.joinPath(download.pathname, download.filename), { ...Cloud.LOG_CLOUD_WARN });
+            return Promise.reject(err);
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                handler({ bucket, download }, async (err, value) => {
+                    if (err) {
+                        reject(errorObject(err, service, "Download failed" /* ERR_CLOUD.DOWNLOAD_FAIL */));
+                    }
+                    else if (value) {
+                        if (beforeResolve) {
+                            const output = await beforeResolve(value);
+                            if ((0, types_1.isString)(output)) {
+                                value = output;
+                            }
+                        }
+                        if (typeof value === 'string' && path.isAbsolute(value)) {
+                            this.addLog(types_1.STATUS_TYPE.INFO, service + ' -> download -> ' + value);
+                            this.downloaded.push(value);
+                        }
+                        resolve(value);
+                    }
+                    else {
+                        reject((0, util_1.formatError)(service, "Download failed" /* ERR_CLOUD.DOWNLOAD_FAIL */));
+                    }
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    async getDatabaseRows(item, ignoreErrors, sessionKey) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        if (typeof ignoreErrors === 'string') {
+            sessionKey = ignoreErrors;
+            ignoreErrors = false;
+        }
+        const service = item.service;
+        if (this.hasCredential('database', item)) {
+            const host = SERVICE_CLIENT[service];
+            if (host?.executeQuery) {
+                const credential = this.getCredential(item);
+                if (item.options && this.hasCoerce(service, 'options', null, credential)) {
+                    (0, types_1.coerceObject)(item.options);
+                }
+                if (ignoreErrors) {
+                    return host.executeQuery.call(this, credential, item, sessionKey);
+                }
+                try {
+                    return await host.executeQuery.call(this, credential, item, sessionKey);
+                }
+                catch (err) {
+                    this.formatFail(64 /* LOG_TYPE.CLOUD */, service, "Unable to execute query" /* ERR_DB.EXEC_QUERY */, err, { ...Cloud.LOG_CLOUD_FAIL });
+                    return Promise.reject(err);
+                }
+            }
+            return Promise.reject((0, util_1.formatError)(service, "Execute query not supported" /* ERR_CLOUD.EXECUTE_QUERY_SUPPORT */));
+        }
+        return Promise.reject((0, util_1.formatError)(service, "Invalid credentials" /* ERR_DB.CREDENTIALS */));
+    }
+    async getDatabaseBatchRows(batch, ignoreErrors, sessionKey) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        if (typeof ignoreErrors === 'string') {
+            sessionKey = ignoreErrors;
+            ignoreErrors = false;
+        }
+        const data = batch[0];
+        const service = data.service;
+        if (this.hasCredential('database', data)) {
+            const host = SERVICE_CLIENT[service];
+            if (host?.executeBatchQuery) {
+                const credential = this.getCredential(data);
+                if (this.hasCoerce(service, 'options', null, credential)) {
+                    batch.forEach(item => item.options && (0, types_1.coerceObject)(item.options));
+                }
+                if (ignoreErrors) {
+                    return host.executeBatchQuery.call(this, credential, batch, sessionKey);
+                }
+                try {
+                    return await host.executeBatchQuery.call(this, credential, batch, sessionKey);
+                }
+                catch (err) {
+                    this.formatFail(64 /* LOG_TYPE.CLOUD */, service, "Unable to execute query" /* ERR_DB.EXEC_QUERY */, err, { ...Cloud.LOG_CLOUD_FAIL });
+                    return Promise.reject(err);
+                }
+            }
+            return Promise.reject((0, util_1.formatError)(service, "Execute query not supported" /* ERR_CLOUD.EXECUTE_QUERY_SUPPORT */));
+        }
+        return Promise.reject((0, util_1.formatError)(service, "Invalid credentials" /* ERR_DB.CREDENTIALS */));
+    }
+    getCredential(item, unused) {
+        let credential = item.credential, stored;
+        if (typeof credential === 'string') {
+            const settings = this.getSettings(item.service);
+            if ((0, types_1.isPlainObject)(settings)) {
+                credential = settings[credential];
+                stored = true;
+            }
+        }
+        if ((0, types_1.isPlainObject)(credential)) {
+            item.credential = credential;
+            if (this.settingsOf(item.service, 'coerce', 'credential') === true) {
+                (0, types_1.coerceObject)(credential, stored);
+            }
+            return unused ? credential : { ...credential };
+        }
+        return {};
+    }
+    getSettings(service) {
+        const settings = this.module;
+        switch (service) {
+            case 'az':
+                return settings.az || settings.azure;
+            case 'azure':
+                return settings.azure || settings.az;
+            case 'gcp':
+                return settings.gcp || settings.gcloud;
+            case 'gcloud':
+                return settings.gcloud || settings.gcp;
+            default:
+                return settings[service];
+        }
+    }
+    getStorage(action, data) {
+        if ((0, types_1.isArray)(data)) {
+            for (const item of data) {
+                const service = this.hasStorage(action, item);
+                if (service && service.active) { // eslint-disable-line @typescript-eslint/prefer-optional-chain
+                    return item;
+                }
+            }
+        }
+    }
+    hasStorage(action, storage) {
+        switch (action) {
+            case 'upload':
+                break;
+            case 'download':
+                if (!storage.bucket) {
+                    return false;
+                }
+                break;
+            default:
+                return false;
+        }
+        const result = storage[action];
+        return result && this.hasCredential('storage', storage) ? result : false;
+    }
+    hasCredential(feature, data, credential = this.getCredential(data, true)) {
+        var _a;
+        try {
+            const client = SERVICE_CLIENT[_a = data.service] || (SERVICE_CLIENT[_a] = require(this.resolveService(data.service)));
+            switch (feature) {
+                case 'storage':
+                    return typeof client.validateStorage === 'function' && client.validateStorage(credential, data);
+                case 'database':
+                    return typeof client.validateDatabase === 'function' && client.validateDatabase(credential, data);
+            }
+        }
+        catch (err) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, data.service, "Cloud provider not found" /* ERR_CLOUD.PROVIDER_NOTFOUND */, err, { ...Cloud.LOG_CLOUD_FAIL });
+        }
+        return false;
+    }
+    getUploadHandler(service, credential) {
+        return (SERVICE_UPLOAD[service] || (SERVICE_UPLOAD[service] = require(this.resolveService(service, 'upload')))).call(this, credential, service);
+    }
+    getDownloadHandler(service, credential) {
+        return (SERVICE_DOWNLOAD[service] || (SERVICE_DOWNLOAD[service] = require(this.resolveService(service, 'download')))).call(this, credential, service);
+    }
+    resolveService(service, folder) {
+        let result, sep = path.sep;
+        if (service[0] === '@') {
+            result = service;
+            folder || (folder = 'client');
+            sep = '/';
+        }
+        else {
+            switch (service) {
+                case 'az':
+                    service = 'azure';
+                    break;
+                case 'gcloud':
+                    service = 'gcp';
+                    break;
+            }
+            if (!Cloud.isDir(result = path.join(__dirname, service))) {
+                result = service;
+                sep = '/';
+            }
+        }
+        return result + (folder ? sep + folder : '');
+    }
+    settingsOf(service, name, component) {
+        const settings = this.settings;
+        let options;
+        switch (service) {
+            case 'az':
+                options = settings.az ?? settings.azure;
+                break;
+            case 'azure':
+                options = settings.azure ?? settings.az;
+                break;
+            case 'gcp':
+                options = settings.gcp ?? settings.gcloud;
+                break;
+            case 'gcloud':
+                options = settings.gcloud ?? settings.gcp;
+                break;
+            default:
+                options = settings[service];
+                break;
+        }
+        const result = options?.[name];
+        return component ? (0, types_1.isObject)(result) ? result[component] : undefined : result;
+    }
+    commit() {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        const items = this.pending.filter(item => !item.document).map(data => {
+            data.ignoreCache ?? (data.ignoreCache = true);
+            return this.getDatabaseRows(data, true);
+        });
+        return items.length === 0 ? Promise.resolve(false) : this.allSettled(items, ["Execute unassigned queries" /* CMD_DB.EXEC_QUERYUNASSIGNED */, this.moduleName]).then(result => result.length > 0).catch(() => false);
+    }
+    getClient(service) {
+        try {
+            return SERVICE_CLIENT[service] || (SERVICE_CLIENT[service] = require(this.resolveService(service)));
+        }
+        catch {
+            throw (0, util_1.formatError)(service, "Cloud provider not found" /* ERR_CLOUD.PROVIDER_NOTFOUND */);
+        }
+    }
+}
+Cloud.LOG_CLOUD_FAIL = core_1.ClientDb.LOG_STYLE_FAIL;
+Cloud.LOG_CLOUD_COMMAND = Object.freeze({ titleColor: 'blue' });
+Cloud.LOG_CLOUD_WARN = Object.freeze({ titleColor: 'yellow' });
+Cloud.LOG_CLOUD_UPLOAD = Object.freeze({ titleColor: 'green' });
+Cloud.LOG_CLOUD_DOWNLOAD = Object.freeze({ titleColor: 'cyan' });
+Cloud.LOG_CLOUD_DELETE = Object.freeze({ titleColor: 'grey' });
+Cloud.LOG_CLOUD_DELAYED = Object.freeze({ titleColor: 'grey' });
+exports.default = Cloud;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}