@e-mc/cloud 0.0.1

package/azure/index.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.createBucketV2 = exports.createBucket = exports.createDatabaseClient = exports.createStorageClient = exports.validateDatabase = exports.validateStorage = void 0;
+const path = require("path");
+const types_1 = require("../../types");
+const util_1 = require("../util");
+const module_1 = require("../../module");
+const index_1 = require("../index");
+function validateStorage(credential) {
+    const env = process.env;
+    if (credential.accountName && credential.accountKey || credential.connectionString || credential.sharedAccessSignature || env.AZURE_TENANT_ID && env.AZURE_CLIENT_ID && env.AZURE_CLIENT_SECRET && (credential.accountName || env.AZURE_STORAGE_ACCOUNT)) {
+        return true;
+    }
+    return module_1.default.enabled("process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */) && !!((credential.connectionString = env.AZURE_STORAGE_CONNECTION_STRING) || (credential.sharedAccessSignature = env.AZURE_STORAGE_SAS_TOKEN) || (credential.accountName = env.AZURE_STORAGE_ACCOUNT) && (credential.accountKey = env.AZURE_STORAGE_KEY));
+}
+exports.validateStorage = validateStorage;
+function validateDatabase(credential, data) {
+    return !!(data.name && data.table && (credential.endpoint && credential.key || module_1.default.enabled("process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */) && (credential.endpoint = process.env.AZURE_COSMOS_ENDPOINT) && (credential.key = process.env.AZURE_COSMOS_KEY)));
+}
+exports.validateDatabase = validateDatabase;
+function createStorageClient(credential) {
+    let packageName = '';
+    try {
+        const { BlobServiceClient, StorageSharedKeyCredential } = require(packageName = '@azure/storage-blob');
+        const { accountName, accountKey, connectionString, sharedAccessSignature } = credential;
+        if (connectionString) {
+            credential.accountName || (credential.accountName = /AccountName=([^;]+);/.exec(connectionString)?.[1]);
+            return BlobServiceClient.fromConnectionString(connectionString);
+        }
+        if (sharedAccessSignature) {
+            credential.accountName || (credential.accountName = /^https:\/\/([a-z\d]+)\./.exec(sharedAccessSignature)?.[1]);
+            return new BlobServiceClient(sharedAccessSignature);
+        }
+        let azureCredential;
+        if (accountName && accountKey) {
+            azureCredential = new StorageSharedKeyCredential(accountName, accountKey);
+        }
+        else {
+            const { DefaultAzureCredential } = require(packageName = '@azure/identity');
+            azureCredential = new DefaultAzureCredential();
+        }
+        return new BlobServiceClient(`https://${accountName || process.env.AZURE_STORAGE_ACCOUNT}.blob.core.windows.net`, azureCredential);
+    }
+    catch (err) {
+        this.checkPackage(err, packageName, { passThrough: true });
+        throw err;
+    }
+}
+exports.createStorageClient = createStorageClient;
+function createDatabaseClient(credential) {
+    try {
+        const { CosmosClient } = require('@azure/cosmos');
+        return new CosmosClient(credential);
+    }
+    catch (err) {
+        this.checkPackage(err, '@azure/cosmos', { passThrough: true });
+        throw err;
+    }
+}
+exports.createDatabaseClient = createDatabaseClient;
+async function createBucket(credential, bucket, publicRead, service = 'azure') {
+    return createBucketV2.call(this, credential, bucket, publicRead ? 'blob' : 'container', undefined, service);
+}
+exports.createBucket = createBucket;
+async function createBucketV2(credential, bucket, access, options, service = 'azure') {
+    switch (access) {
+        case 'blob':
+        case 'container':
+            break;
+        default:
+            access = undefined;
+            break;
+    }
+    const containerClient = createStorageClient.call(this, credential).getContainerClient(bucket);
+    const setAccessPolicy = () => containerClient.setAccessPolicy(access).catch(err => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Unable to configure container" /* ERR_AZURE.CONFIGURE_CONTAINER */, bucket], err, { ...index_1.default.LOG_CLOUD_WARN }));
+    if (await containerClient.exists().catch(() => false)) {
+        if (access) {
+            await setAccessPolicy();
+        }
+        return true;
+    }
+    options = { ...options };
+    if (access) {
+        options.access = access;
+    }
+    options.abortSignal = this.signal;
+    return containerClient.create(options)
+        .then(response => {
+        if (response.errorCode) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Container created with errors', bucket], (0, types_1.errorMessage)("Error code" /* ERR_MESSAGE.ERROR_CODE */, response.errorCode), { ...index_1.default.LOG_CLOUD_WARN });
+        }
+        else {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Container created', bucket], response.requestId, { ...index_1.default.LOG_CLOUD_COMMAND });
+        }
+        return true;
+    })
+        .catch(async (err) => {
+        if (err instanceof Error && err.code === 'ContainerAlreadyExists') {
+            if (access) {
+                await setAccessPolicy();
+            }
+            return true;
+        }
+        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to create container" /* ERR_AZURE.CREATE_CONTAINER */, bucket], err, { ...index_1.default.LOG_CLOUD_FAIL });
+        return false;
+    });
+}
+exports.createBucketV2 = createBucketV2;
+function setBucketWebsite(credential, bucket, options, service = 'azure') {
+    const staticWebsite = { enabled: true };
+    if ((0, types_1.isString)(options.indexPage)) {
+        staticWebsite.indexDocument = path.basename(options.indexPage);
+    }
+    if ((0, types_1.isString)(options.indexPath)) {
+        staticWebsite.defaultIndexDocumentPath = module_1.default.joinPath(bucket, options.indexPath);
+    }
+    if ((0, types_1.isString)(options.errorPath)) {
+        staticWebsite.errorDocument404Path = module_1.default.joinPath(bucket, options.errorPath);
+    }
+    return createStorageClient.call(this, credential).setProperties({ staticWebsite })
+        .then(() => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket configured" /* CMD_CLOUD.CONFIGURE_BUCKET */, bucket], options, { ...index_1.default.LOG_CLOUD_COMMAND });
+        return true;
+    })
+        .catch(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) {
+    return deleteObjectsV2.call(this, credential, Bucket, true, service);
+}
+exports.deleteObjects = deleteObjects;
+async function deleteObjectsV2(credential, bucket, recursive = true, service = 'azure') {
+    const containerClient = createStorageClient.call(this, credential).getContainerClient(bucket);
+    if (await containerClient.exists().catch(() => false)) {
+        try {
+            const tasks = [];
+            let fileCount = 0;
+            for await (const blob of containerClient.listBlobsFlat({ includeUncommitedBlobs: true })) {
+                if (!recursive && blob.name.indexOf('/') !== -1) {
+                    continue;
+                }
+                tasks.push(containerClient.deleteBlob(blob.name, { versionId: blob.versionId }).catch(() => { --fileCount; }));
+            }
+            fileCount = tasks.length;
+            return this.allSettled(tasks, ["Unable to delete blob" /* ERR_AZURE.DELETE_BLOB */, bucket], 64 /* LOG_TYPE.CLOUD */).then(() => {
+                const files = fileCount + ' files';
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [`Container emptied (${recursive ? 'recursive' : files})`, bucket], recursive ? files : '', { ...index_1.default.LOG_CLOUD_COMMAND });
+            });
+        }
+        catch (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 = (name, table) => {
+        client || (client = createDatabaseClient.call(this, length === 1 ? credential : { ...credential }));
+        return client.database(name).container(table);
+    };
+    const closeClient = () => client?.dispose();
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { service, name, table, id, query, storedProcedureId, partitionKey, params, limit = 0, update, ignoreCache } = item;
+        if (!name || !table) {
+            closeClient();
+            throw (0, util_1.formatError)(item, name ? "Missing database table" /* ERR_DB.TABLE */ : "Missing database name" /* ERR_DB.NAME */);
+        }
+        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 ? name + '_' + table + '_' : '';
+        if (storedProcedureId && params) {
+            const { options } = item;
+            if (queryString && (rows = getCache(queryString += (partitionKey || '') + '_' + storedProcedureId + module_1.default.asString(params, true) + module_1.default.asString(options, true)))) {
+                result[i] = rows;
+                continue;
+            }
+            const { statusCode, resource } = await createClient(name, table).scripts.storedProcedure(storedProcedureId).execute(partitionKey, params, options);
+            if (statusCode === 200 /* HTTP_STATUS.OK */) {
+                rows = Array.isArray(resource) ? resource : [resource];
+            }
+        }
+        else if (id) {
+            const { options } = item;
+            if (queryString) {
+                queryString += (partitionKey || '') + '_' + id + module_1.default.asString(options, true);
+                if (!update && (rows = getCache(queryString))) {
+                    result[i] = rows;
+                    continue;
+                }
+            }
+            const db = createClient(name, table).item(id, partitionKey);
+            const { statusCode, resource } = update ? await db.patch(update, options) : await db.read(options); // eslint-disable-line import/namespace
+            if (statusCode === 200 /* HTTP_STATUS.OK */) {
+                rows = [resource];
+            }
+        }
+        else if (query) {
+            let { options } = item;
+            if (limit > 0) {
+                (options || (options = {})).maxItemCount = limit;
+            }
+            if (queryString && (rows = getCache(queryString += module_1.default.asString(query, true) + module_1.default.asString(options, true)))) {
+                result[i] = rows;
+                continue;
+            }
+            rows = (await createClient(name, table).items.query(query, options).fetchAll()).resources;
+        }
+        else {
+            closeClient();
+            throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
+        }
+        result[i] = this.setQueryResult(service, credential, queryString, rows, cacheValue);
+    }
+    closeClient();
+    return result;
+}
+exports.executeBatchQuery = executeBatchQuery;

package/azure/upload/index.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const index_1 = require("../index");
+const util_1 = require("../../util");
+const types_1 = require("../../../types");
+const module_1 = require("../../../module");
+const index_2 = require("../../index");
+const BUCKET_SESSION = new Set();
+const BUCKET_RESPONSE = {};
+const getBucketKey = (credential, bucket, acl = '') => module_1.default.asString(credential, true) + bucket + '_' + acl;
+function upload(credential, service = 'azure') {
+    const blobServiceClient = index_1.createStorageClient.call(this, credential);
+    return async (data, callback) => {
+        var _a, _b;
+        const { bucket, localUri } = data;
+        const { pathname = '', fileGroup, contentType, metadata, endpoint, admin = {}, overwrite, options } = data.upload;
+        const containerClient = blobServiceClient.getContainerClient(bucket);
+        let filename = data.upload.filename || path.basename(localUri), bucketKey;
+        const cleanup = () => {
+            BUCKET_SESSION.delete(bucket);
+            if (bucketKey) {
+                delete BUCKET_RESPONSE[bucketKey];
+            }
+        };
+        const errorResponse = (err) => {
+            cleanup();
+            callback(err);
+        };
+        if (!BUCKET_SESSION.has(bucket)) {
+            const bucketAcl = admin.publicRead ? 'blob' : admin.acl;
+            const response = BUCKET_RESPONSE[_a = bucketKey = getBucketKey(credential, bucket, bucketAcl)] || (BUCKET_RESPONSE[_a] = index_1.createBucketV2.call(this, credential, bucket, bucketAcl, admin.configBucket?.create));
+            if (!await response) {
+                errorResponse(null);
+                return;
+            }
+            BUCKET_SESSION.add(bucket);
+        }
+        if (!overwrite) {
+            try {
+                const current = filename;
+                const next = (0, util_1.generateFilename)(filename);
+                let i = 0, exists;
+                do {
+                    if (i > 0) {
+                        [filename, exists] = next(i);
+                        if (!exists) {
+                            break;
+                        }
+                    }
+                    const name = pathname ? module_1.default.joinPath(pathname, filename) : filename;
+                    for await (const blob of containerClient.listBlobsFlat({ includeUncommitedBlobs: true })) {
+                        if (blob.name === name) {
+                            exists = true;
+                            break;
+                        }
+                    }
+                } while (exists && ++i);
+                if (i > 0) {
+                    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["File renamed" /* CMD_CLOUD.RENAME_FILE */, current], filename, { ...index_2.default.LOG_CLOUD_WARN });
+                }
+            }
+            catch (err) {
+                errorResponse(err);
+                return;
+            }
+        }
+        const Key = [filename];
+        const Body = [data.buffer];
+        const ContentType = [contentType];
+        const addLog = (err) => err instanceof Error && this.addLog(this.statusType.WARN, err.message, service + ': ' + bucket);
+        if (fileGroup) {
+            for (const [content, ext, localFile] of fileGroup) {
+                try {
+                    Body.push(typeof content === 'string' ? fs.readFileSync(content) : content);
+                    Key.push(ext === '.map' && localFile ? path.basename(localFile) : filename + ext);
+                }
+                catch (err) {
+                    addLog(err);
+                }
+            }
+        }
+        for (let i = 0; i < Key.length; ++i) {
+            const first = i === 0;
+            if (this.aborted) {
+                if (first) {
+                    errorResponse((0, types_1.createAbortError)());
+                }
+                return;
+            }
+            const blobName = module_1.default.joinPath(pathname, Key[i]);
+            const params = { ...options, abortSignal: this.signal };
+            if (first && metadata) {
+                params.metadata = metadata;
+            }
+            (_b = (params.blobHTTPHeaders || (params.blobHTTPHeaders = {}))).blobContentType || (_b.blobContentType = ContentType[i]);
+            containerClient.getBlockBlobClient(blobName).upload(Body[i], Body[i].byteLength, params)
+                .then(result => {
+                let requestUrl = result._response.request.url;
+                const url = endpoint ? module_1.default.joinPath(endpoint, blobName) : module_1.default.isFile(requestUrl = decodeURIComponent(requestUrl), 'http/s') ? requestUrl : module_1.default.joinPath(`https://${credential.accountName}.blob.core.windows.net`, bucket, blobName);
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Upload success" /* CMD_CLOUD.UPLOAD_FILE */, url, { ...index_2.default.LOG_CLOUD_UPLOAD });
+                if (first) {
+                    cleanup();
+                    callback(null, url);
+                }
+            })
+                .catch(err => {
+                if (first) {
+                    errorResponse(err);
+                }
+                else {
+                    addLog(err);
+                }
+            });
+        }
+    };
+}
+exports.default = upload;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/gcp/download/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const https = require("https");
+const index_1 = require("../index");
+const types_1 = require("../../../types");
+const module_1 = require("../../../module");
+const index_2 = require("../../index");
+function download(credential, service = 'gcp') {
+    const storage = index_1.createStorageClient.call(this, credential);
+    return (data, callback) => {
+        const { bucket: Bucket, download: target } = data;
+        const Key = target.filename;
+        const firebase = (0, index_1.isFirebaseApp)(credential, true, true);
+        let tempDir;
+        const downloadResponse = (err, url) => {
+            callback(err, url);
+            if (tempDir) {
+                queueMicrotask(() => module_1.default.removeDir(tempDir));
+            }
+        };
+        if (!Bucket || !Key) {
+            downloadResponse((0, types_1.errorValue)('Missing property', !Bucket ? 'Bucket' : 'Key'));
+            return;
+        }
+        if (!(tempDir = this.getTempDir({ uuidDir: true }))) {
+            downloadResponse(new Error("Unable to create temp directory" /* ERR_CLOUD.TEMP_DIR */));
+            return;
+        }
+        const location = module_1.default.joinPath(Bucket, Key);
+        const destination = path.join(tempDir, path.basename(Key));
+        const deleteMessage = () => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Delete success" /* CMD_CLOUD.DELETE_FILE */, location, { ...index_2.default.LOG_CLOUD_DELETE });
+        if (firebase) {
+            const { ref, getDownloadURL, deleteObject } = require('@firebase/storage');
+            const objectRef = ref(storage, Key);
+            getDownloadURL(objectRef).then(url => {
+                https.get(url, res => {
+                    const statusCode = res.statusCode;
+                    if (statusCode >= 200 && statusCode < 300) {
+                        res.on('error', err => downloadResponse(err));
+                        res.pipe(fs.createWriteStream(destination)
+                            .on('finish', () => {
+                            downloadResponse(null, destination);
+                            if (target.deleteObject) {
+                                deleteObject(objectRef)
+                                    .then(() => deleteMessage())
+                                    .catch(err => this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Delete failed" /* ERR_CLOUD.DELETE_FAIL */, location], err, { ...index_2.default.LOG_CLOUD_FAIL, fatal: !!target.active }));
+                            }
+                        })
+                            .on('error', err => downloadResponse(err)));
+                    }
+                    else {
+                        downloadResponse((0, types_1.errorMessage)(statusCode, 'Invalid HTTP request', location));
+                    }
+                });
+            });
+        }
+        else {
+            const bucket = storage.bucket(Bucket);
+            const file = bucket.file(Key, { generation: target.versionId });
+            file.download({ destination })
+                .then(() => {
+                downloadResponse(null, destination);
+                const deleteObject = target.deleteObject;
+                if (deleteObject) {
+                    file.delete((0, types_1.isPlainObject)(deleteObject) ? deleteObject : { ignoreNotFound: true }, err => {
+                        if (!err) {
+                            deleteMessage();
+                        }
+                        else {
+                            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Delete failed" /* ERR_CLOUD.DELETE_FAIL */, location], err, { ...index_2.default.LOG_CLOUD_FAIL, fatal: !!target.active });
+                        }
+                    });
+                }
+            })
+                .catch(err => downloadResponse(err));
+        }
+    };
+}
+exports.default = download;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}