@e-mc/cloud 0.0.1 → 0.0.3

package/aws-v3/index.js

@@ -1,285 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.setBucketPolicy = exports.createBucketV2 = exports.createBucket = exports.validateDatabase = exports.validateStorage = exports.createDatabaseClient = exports.createStorageClient = void 0;
-const aws_1 = require("../aws");
-const util_1 = require("../util");
-const types_1 = require("../../types");
-const module_1 = require("../../module");
-const index_1 = require("../index");
-function setCannedAcl(S3, client, Bucket, ACL, service = 'aws-v3', recursive) {
-    let Policy;
-    switch (ACL) {
-        case 1:
-            Policy = (0, aws_1.getBucketPublicReadPolicy)(Bucket);
-            break;
-        case 'private':
-            Policy = (0, aws_1.getPrivatePolicy)(Bucket);
-            break;
-        default:
-            Policy = (0, aws_1.getPublicReadPolicy)(Bucket, ACL === 'authenticated-read', ACL === 'public-read-write');
-            break;
-    }
-    return client.send(new S3.PutBucketPolicyCommand({ Bucket, Policy }))
-        .then(() => {
-        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Grant ' + ACL, Bucket], '', { ...recursive ? index_1.default.LOG_CLOUD_DELAYED : index_1.default.LOG_CLOUD_COMMAND });
-    })
-        .catch((err) => {
-        if (!recursive && err instanceof Error) {
-            if (err.name === 'OperationAborted') {
-                setTimeout(() => setCannedAcl.call(this, S3, client, Bucket, ACL, service, true), 60000 /* TIME.m */);
-                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [`Grant ${ACL} (delayed)`, err.Endpoint || Bucket], err, { ...index_1.default.LOG_CLOUD_DELAYED });
-            }
-            else {
-                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Unable to grant ' + ACL, err.Endpoint || Bucket], err, { ...index_1.default.LOG_CLOUD_WARN });
-            }
-        }
-    });
-}
-function sanitizeCredentials(credential) {
-    const result = credential.credentials || (credential.credentials = {});
-    for (const attr in credential) {
-        switch (attr) {
-            case 'accessKeyId':
-            case 'secretAccessKey':
-            case 'sessionToken':
-            case 'expiration':
-                if (typeof result !== 'function') {
-                    result[attr] = credential[attr];
-                }
-                delete credential[attr];
-                break;
-        }
-    }
-    return result;
-}
-const isNoSuchBucket = (err) => err instanceof Error && err.name === 'NoSuchBucket';
-function createStorageClient(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
-    try {
-        sanitizeCredentials(credential);
-        const expiration = credential.credentials?.expiration;
-        if (expiration && !(expiration instanceof Date)) {
-            delete credential.expiration;
-        }
-        const AWS = require(sdk);
-        return [new AWS.S3Client(credential), AWS];
-    }
-    catch (err) {
-        this.checkPackage(err, sdk.split('/')[0], { passThrough: true });
-        throw err;
-    }
-}
-exports.createStorageClient = createStorageClient;
-function createDatabaseClient(credential) {
-    try {
-        const AWS = require('@aws-sdk/lib-dynamodb');
-        const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
-        return [AWS.DynamoDBDocumentClient.from(new DynamoDBClient(credential), credential.translateConfig), AWS];
-    }
-    catch (err) {
-        this.checkPackage(err, '@aws-sdk', { passThrough: true });
-        throw err;
-    }
-}
-exports.createDatabaseClient = createDatabaseClient;
-function validateStorage(credential) {
-    const credentials = sanitizeCredentials(credential);
-    if (credential.profile || !credentials && process.env.AWS_SDK_LOAD_CONFIG === '1') {
-        const { fromIni } = require('@aws-sdk/credential-provider-ini');
-        credential.credentials = fromIni({ profile: credential.profile });
-        return true;
-    }
-    return !!credentials && (typeof credentials === 'function' || (0, aws_1.isAccessDefined)(credentials) || (0, aws_1.isEnvDefined)());
-}
-exports.validateStorage = validateStorage;
-function validateDatabase(credential, data) {
-    return (0, aws_1.isDatabaseDefined)(credential, data) && validateStorage(credential);
-}
-exports.validateDatabase = validateDatabase;
-function createBucket(credential, Bucket, publicRead, service = 'aws-v3', sdk = '@aws-sdk/client-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-v3', sdk = '@aws-sdk/client-s3') {
-    ACL = ACL === 1 ? 1 : (0, aws_1.checkBucketCannedACL)(ACL);
-    const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
-    return client.send(new AWS.HeadBucketCommand({ Bucket }))
-        .then(async () => {
-        if (ACL) {
-            await setCannedAcl.call(this, AWS, client, Bucket, ACL, service);
-        }
-        return true;
-    })
-        .catch(() => {
-        const input = { ...options, Bucket };
-        const region = credential.region;
-        if (!input.CreateBucketConfiguration && typeof region === 'string' && region !== 'us-east-1') {
-            input.CreateBucketConfiguration = { LocationConstraint: region };
-        }
-        return client.send(new AWS.CreateBucketCommand(input))
-            .then(async () => {
-            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket created" /* CMD_CLOUD.CREATE_BUCKET */, Bucket], '', { ...index_1.default.LOG_CLOUD_COMMAND });
-            if (ACL) {
-                await setCannedAcl.call(this, AWS, client, Bucket, ACL, service);
-            }
-            return true;
-        })
-            .catch(async (err) => {
-            switch (err instanceof Error && err.name) {
-                case 'BucketAlreadyExists':
-                case 'BucketAlreadyOwnedByYou':
-                    if (ACL) {
-                        await setCannedAcl.call(this, AWS, client, 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 [client, AWS] = createStorageClient.call(this, credential, service, sdk);
-    const policy = 'Policy' in options && !('ACL' in options);
-    options.Bucket = Bucket;
-    return (policy ? client.send(new AWS.PutBucketPolicyCommand(options)) : client.send(new AWS.PutBucketAclCommand(options)))
-        .then(() => {
-        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [policy ? "Bucket policy configured" /* CMD_CLOUD.POLICY_BUCKET */ : "Bucket ACL configured" /* CMD_CLOUD.ACL_BUCKET */, Bucket], '', { ...index_1.default.LOG_CLOUD_COMMAND });
-        return true;
-    })
-        .catch(err => {
-        if (!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 [client, AWS] = 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 client.send(new AWS.PutBucketWebsiteCommand({ Bucket, WebsiteConfiguration }))
-        .then(() => {
-        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket configured" /* CMD_CLOUD.CONFIGURE_BUCKET */, Bucket], WebsiteConfiguration, { ...index_1.default.LOG_CLOUD_COMMAND });
-        return true;
-    })
-        .catch(err => {
-        if (!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, sdk) {
-    return deleteObjectsV2.call(this, credential, Bucket, true, service, sdk);
-}
-exports.deleteObjects = deleteObjects;
-async function deleteObjectsV2(credential, Bucket, recursive = true, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
-    const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
-    return client.send(new AWS.ListObjectsCommand({ Bucket }))
-        .then(({ Contents }) => {
-        if (Contents?.length) {
-            let Objects = Contents.map(data => ({ Key: data.Key }));
-            if (!recursive) {
-                Objects = Objects.filter(value => value.Key.indexOf('/') === -1);
-            }
-            return client.send(new AWS.DeleteObjectsCommand({ Bucket, Delete: { Objects } }))
-                .then(data => {
-                if ((0, types_1.isArray)(data.Deleted)) {
-                    const files = data.Deleted.length + ' files';
-                    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket emptied" /* CMD_CLOUD.EMPTY_BUCKET */ + ` (${recursive ? 'recursive' : files})`, Bucket], recursive ? files : '', { ...index_1.default.LOG_CLOUD_COMMAND });
-                }
-            })
-                .catch(err => {
-                this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to empty bucket" /* ERR_CLOUD.DELETE_BUCKET */, Bucket], err, { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
-            });
-        }
-    })
-        .catch(err => {
-        if (!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 = () => client || (client = createDatabaseClient.call(this, length === 1 ? credential : { ...credential }));
-    const closeClient = () => client?.[0].destroy();
-    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) {
-            closeClient();
-            throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
-        }
-        (0, aws_1.setDatabaseEndpoint)(credential);
-        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 [db, AWS] = createClient();
-            const Key = (0, types_1.isPlainObject)(key) ? key : { [key]: id };
-            const command = { TableName: table, Key };
-            if (update) {
-                await db.send(new AWS.UpdateCommand({ ...command, ...update }));
-            }
-            const output = await db.send(new AWS.GetCommand(command));
-            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 [db, AWS] = createClient();
-            const output = await db.send(new AWS.QueryCommand(query));
-            if (output.Count && output.Items) {
-                rows = output.Items;
-            }
-        }
-        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/aws-v3/upload/index.js

@@ -1,157 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fs = require("fs");
-const stream = require("stream");
-const index_1 = require("../index");
-const util_1 = require("../../util");
-const index_2 = require("../../aws/index");
-const types_1 = require("../../../types");
-const module_1 = require("../../../module");
-const index_3 = require("../../index");
-const BUCKET_SESSION = new Set();
-const BUCKET_RESPONSE = {};
-function upload(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
-    const [client, AWS] = index_1.createStorageClient.call(this, credential, service, sdk);
-    return async (data, callback) => {
-        var _a;
-        const { bucket: Bucket, localUri } = data;
-        const { pathname = '', fileGroup, contentType, metadata, endpoint, active, publicRead, acl, admin = {}, overwrite, options } = data.upload;
-        let filename = data.upload.filename || path.basename(localUri), bucketKey;
-        const cleanup = () => {
-            BUCKET_SESSION.delete(service + Bucket);
-            if (bucketKey && bucketKey in BUCKET_RESPONSE) {
-                delete BUCKET_RESPONSE[bucketKey];
-            }
-        };
-        const errorResponse = (err) => {
-            cleanup();
-            callback(err);
-            return false;
-        };
-        if (!BUCKET_SESSION.has(service + Bucket)) {
-            const bucketAcl = admin.publicRead ? 'public-read' : admin.acl;
-            const response = BUCKET_RESPONSE[_a = bucketKey = (0, index_2.getBucketKey)(credential, Bucket, bucketAcl, service, sdk)] || (BUCKET_RESPONSE[_a] = index_1.createBucketV2.call(this, credential, Bucket, bucketAcl, admin.configBucket?.create, service, sdk));
-            if (!await response) {
-                errorResponse(null);
-                return;
-            }
-            BUCKET_SESSION.add(service + Bucket);
-        }
-        if (!overwrite) {
-            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;
-                    }
-                }
-                exists = await client.send(new AWS.HeadObjectCommand({ Bucket, Key: pathname ? module_1.default.joinPath(pathname, filename) : filename }))
-                    .then(() => true)
-                    .catch(err => {
-                    if (err instanceof Error && err.name !== 'NotFound') {
-                        filename = (0, types_1.generateUUID)() + path.extname(current);
-                        return true;
-                    }
-                    return false;
-                });
-            } while (exists && ++i);
-            if (i > 0) {
-                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["File renamed" /* CMD_CLOUD.RENAME_FILE */, current], filename, { ...index_3.default.LOG_CLOUD_WARN });
-            }
-        }
-        if (pathname) {
-            await client.send(new AWS.PutObjectCommand({ Bucket, Key: pathname, Body: Buffer.from(''), ContentLength: 0 })).catch(() => { });
-        }
-        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 objectKey = module_1.default.joinPath(pathname, Key[i]);
-            let params;
-            try {
-                params = { ...options, Bucket, Key: pathname + Key[i], Body: stream.Readable.from(Body[i]) };
-                const readable = publicRead || active && publicRead !== false && !acl;
-                if (first) {
-                    params.ContentType || (params.ContentType = ContentType[i]);
-                    if (readable) {
-                        params.ACL = 'public-read';
-                    }
-                    else if (acl) {
-                        params.ACL = acl;
-                    }
-                    if (metadata) {
-                        params.Metadata = metadata;
-                    }
-                }
-                else {
-                    params.ContentType = ContentType[i];
-                    if (!params.ACL) {
-                        if (readable) {
-                            params.ACL = 'public-read';
-                        }
-                        else if (acl) {
-                            params.ACL = acl;
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                if (first) {
-                    errorResponse(err);
-                    return;
-                }
-                if (err instanceof Error) {
-                    this.addLog(this.statusType.WARN, err.message, service + ': ' + Bucket);
-                }
-                continue;
-            }
-            // @ts-ignore
-            client.send(new AWS.PutObjectCommand(params), { abortSignal: this.signal })
-                .then(() => {
-                const url = endpoint ? module_1.default.joinPath(endpoint, objectKey) : module_1.default.joinPath(`https://${Bucket}.s3.${!credential.region || credential.region === 'us-east-1' ? 'us-east-1.' : ''}amazonaws.com`, objectKey);
-                if (first) {
-                    cleanup();
-                    callback(null, url);
-                }
-                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Upload success" /* CMD_CLOUD.UPLOAD_FILE */, url, { ...index_3.default.LOG_CLOUD_UPLOAD });
-            })
-                .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/azure/download/index.js

@@ -1,40 +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 = 'azure') {
-    const blobServiceClient = index_1.createStorageClient.call(this, credential);
-    return (data, callback) => {
-        const { bucket: Bucket, download: target } = data;
-        const Key = target.filename;
-        if (!Bucket || !Key) {
-            callback((0, types_1.errorValue)('Missing property', !Bucket ? 'Container' : 'Name'));
-            return;
-        }
-        const location = module_1.default.joinPath(Bucket, Key);
-        const blobClient = blobServiceClient.getContainerClient(Bucket);
-        blobClient.getBlockBlobClient(Key).downloadToBuffer()
-            .then(value => {
-            callback(null, value);
-            const deleteObject = target.deleteObject;
-            if (target.deleteObject) {
-                blobClient.delete((0, types_1.isPlainObject)(deleteObject) && (deleteObject.abortSignal = this.signal) ? deleteObject : undefined)
-                    .then(() => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Delete success" /* CMD_CLOUD.DELETE_FILE */, location, { ...index_2.default.LOG_CLOUD_DELETE }))
-                    .catch((err) => {
-                    if (!(err instanceof Error && err.code === 'BlobNotFound')) {
-                        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 => callback(err));
-    };
-}
-exports.default = download;
-
-if (exports.default) {
-    module.exports = exports.default;
-    module.exports.default = exports.default;
-}