@e-mc/cloud 0.0.1

package/gcp/upload/index.js

@@ -0,0 +1,234 @@
+"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 = 'gcp') {
+    const storage = index_1.createStorageClient.call(this, credential);
+    return async (data, callback) => {
+        var _a;
+        const firebase = (0, index_1.isFirebaseApp)(credential, true, true);
+        const { 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), bucketClient, bucketKey, listFiles;
+        const uploadResponse = (err, url) => {
+            if (!firebase) {
+                BUCKET_SESSION.delete(bucket);
+                if (bucketKey) {
+                    delete BUCKET_RESPONSE[bucketKey];
+                }
+            }
+            callback(err, url);
+        };
+        if (firebase) {
+            const { ref, listAll } = require('@firebase/storage');
+            bucketClient = ref(storage, bucket);
+            if (!overwrite) {
+                try {
+                    listFiles = (await listAll(bucketClient)).items.map(item => item.fullPath);
+                }
+                catch (err) {
+                    uploadResponse(err);
+                    return;
+                }
+            }
+        }
+        else {
+            if (!BUCKET_SESSION.has(bucket)) {
+                const bucketAcl = admin.publicRead ? 'publicRead' : 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 || (0, index_1.createBucketRequest)(credential)));
+                if (!await response) {
+                    uploadResponse(null);
+                    return;
+                }
+                BUCKET_SESSION.add(bucket);
+            }
+            bucketClient = storage.bucket(bucket);
+        }
+        if (!overwrite && (!listFiles || listFiles.length)) {
+            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;
+                if (firebase) {
+                    exists = listFiles.includes(name);
+                }
+                else {
+                    [exists] = await bucketClient.file(name).exists();
+                }
+            } 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 });
+            }
+        }
+        const Key = [filename];
+        const Body = [data.buffer];
+        const ContentType = [contentType];
+        const getURL = (value) => endpoint ? module_1.default.joinPath(endpoint, value) : module_1.default.joinPath("https://storage.googleapis.com" /* STRINGS.BASE_URL */, bucket, value);
+        const addLog = (err) => err instanceof Error && this.addLog(this.statusType.WARN, err.message, service + ': ' + bucket);
+        if (fileGroup) {
+            for (const [content, ext, localFile] of fileGroup) {
+                Key.push(ext === '.map' && localFile ? path.basename(localFile) : filename + ext);
+                Body.push(content);
+            }
+        }
+        for (let i = 0; i < Key.length; ++i) {
+            const first = i === 0;
+            if (this.aborted) {
+                if (first) {
+                    uploadResponse((0, types_1.createAbortError)());
+                }
+                return;
+            }
+            if (firebase) {
+                const { ref, uploadBytes } = require('@firebase/storage');
+                if (!Buffer.isBuffer(Body[i])) {
+                    try {
+                        Body[i] = fs.readFileSync(Body[i]);
+                    }
+                    catch (err) {
+                        if (first) {
+                            uploadResponse(err);
+                            return;
+                        }
+                        addLog(err);
+                        continue;
+                    }
+                }
+                const params = { ...options };
+                if (first) {
+                    params.contentType || (params.contentType = ContentType[i]);
+                    if (metadata) {
+                        params.customMetadata = metadata;
+                    }
+                }
+                else {
+                    params.contentType = ContentType[i];
+                }
+                const destination = pathname ? module_1.default.joinPath(pathname, Key[i]) : Key[i];
+                uploadBytes(ref(bucketClient, destination), Body[i], params)
+                    .then(() => {
+                    const url = getURL(destination);
+                    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Upload success" /* CMD_CLOUD.UPLOAD_FILE */, url, { ...index_2.default.LOG_CLOUD_UPLOAD });
+                    if (first) {
+                        uploadResponse(null, url);
+                    }
+                })
+                    .catch(err => {
+                    if (first) {
+                        uploadResponse(err);
+                    }
+                    else {
+                        addLog(err);
+                    }
+                });
+            }
+            else {
+                let outputUri, tempDir;
+                try {
+                    const output = Body[i];
+                    if (Buffer.isBuffer(output) || path.basename(output) !== Key[i]) {
+                        if (!(tempDir = this.getTempDir({ uuidDir: true }))) {
+                            throw new Error("Unable to create temp directory" /* ERR_CLOUD.TEMP_DIR */);
+                        }
+                        outputUri = path.join(tempDir, Key[i]);
+                        if (typeof output === 'string') {
+                            fs.copyFileSync(output, outputUri);
+                        }
+                        else {
+                            fs.writeFileSync(outputUri, output);
+                        }
+                    }
+                    else {
+                        outputUri = output;
+                    }
+                }
+                catch (err) {
+                    if (first) {
+                        uploadResponse(err);
+                        return;
+                    }
+                    addLog(err);
+                    continue;
+                }
+                const params = { ...options };
+                const readable = publicRead || active && publicRead !== false && publicRead !== 0 && !acl;
+                let ACL, revoke, predefined;
+                if (first) {
+                    params.contentType || (params.contentType = ContentType[i]);
+                    if (readable) {
+                        ACL = 'publicRead';
+                    }
+                    else {
+                        predefined = true;
+                    }
+                    if (metadata) {
+                        params.metadata = metadata;
+                    }
+                }
+                else {
+                    params.contentType = ContentType[i];
+                    if (!params.predefinedAcl) {
+                        if (readable) {
+                            ACL = 'publicRead';
+                        }
+                        else {
+                            predefined = true;
+                        }
+                    }
+                }
+                if (predefined) {
+                    if (publicRead === 0) {
+                        ACL = 'publicRead';
+                        revoke = true;
+                    }
+                    if (acl && (!revoke || acl !== ACL)) {
+                        params.predefinedAcl = acl;
+                    }
+                }
+                params.destination = pathname ? module_1.default.joinPath(pathname, path.basename(outputUri)) : undefined;
+                bucketClient.upload(outputUri, params, (err, file) => {
+                    if (file) {
+                        const url = getURL(file.name);
+                        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Upload success" /* CMD_CLOUD.UPLOAD_FILE */, url, { ...index_2.default.LOG_CLOUD_UPLOAD });
+                        if (first) {
+                            uploadResponse(null, url);
+                        }
+                        if (ACL) {
+                            index_1.setPredefinedAcl.call(this, file.acl, ACL, file.bucket, file.name, revoke || file.metadata, true);
+                        }
+                    }
+                    else if (first) {
+                        uploadResponse(err);
+                    }
+                    else {
+                        addLog(err);
+                    }
+                    if (tempDir) {
+                        queueMicrotask(() => module_1.default.removeDir(tempDir));
+                    }
+                });
+            }
+        }
+    };
+}
+exports.default = upload;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/ibm/download/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+function download(credential, service = 'ibm') {
+    (0, index_1.setStorageCredential)(credential);
+    return require('../../aws/download').call(this, credential, service, 'ibm-cos-sdk/clients/s3');
+}
+exports.default = download;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/ibm/index.js

@@ -0,0 +1,229 @@
+"use strict";
+/// <reference lib="dom" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.setBucketPolicy = exports.createBucketV2 = exports.createBucket = exports.createDatabaseClient = exports.setStorageCredential = exports.validateDatabase = exports.validateStorage = void 0;
+const types_1 = require("../../types");
+const aws_1 = require("../aws");
+const util_1 = require("../util");
+const module_1 = require("../../module");
+function validateStorage(credential) {
+    return !!(credential.apiKeyId && credential.serviceInstanceId && (credential.region || credential.endpoint));
+}
+exports.validateStorage = validateStorage;
+function validateDatabase(credential, data) {
+    if (credential.url && (credential.username && credential.password || credential.apikey)) {
+        return (0, types_1.isString)(data.table);
+    }
+    const serviceName = credential.serviceName || 'CLOUDANT';
+    if (process.env[serviceName + '_URL'] && (process.env[serviceName + '_APIKEY'] || process.env[serviceName + '_USERNAME'] && process.env[serviceName + '_PASSWORD'])) {
+        return (0, types_1.isString)(data.table);
+    }
+    return false;
+}
+exports.validateDatabase = validateDatabase;
+function setStorageCredential(credential) {
+    if (credential.endpoint) {
+        credential.region || (credential.region = /([^.]+)\.cloud-object-storage\.appdomain\.cloud\b/.exec(credential.endpoint)?.[1]);
+    }
+    else if (credential.region) {
+        credential.endpoint || (credential.endpoint = `https://s3.${credential.region}.cloud-object-storage.appdomain.cloud`);
+    }
+    credential.ibmAuthEndpoint = 'https://iam.cloud.ibm.com/identity/token';
+    credential.signatureVersion = 'iam';
+}
+exports.setStorageCredential = setStorageCredential;
+function createDatabaseClient(credential) {
+    try {
+        const Cloudant = require('@ibm-cloud/cloudant/cloudant/v1');
+        const { BasicAuthenticator, IamAuthenticator } = require('ibm-cloud-sdk-core');
+        const { url: serviceUrl, apikey, username, password, serviceName = 'CLOUDANT' } = credential;
+        let authenticator;
+        if (apikey) {
+            authenticator = new IamAuthenticator({ apikey });
+        }
+        else if (username && password) {
+            authenticator = new BasicAuthenticator({ username, password });
+        }
+        if (authenticator) {
+            return Cloudant.newInstance({ ...credential, serviceUrl, authenticator });
+        }
+        return Cloudant.newInstance({ ...credential, serviceUrl, serviceName });
+    }
+    catch (err) {
+        this.checkPackage(err, '@ibm-cloud/cloudant', { passThrough: true });
+        throw err;
+    }
+}
+exports.createDatabaseClient = createDatabaseClient;
+function createBucket(credential, bucket, publicRead) {
+    return aws_1.createBucketV2.call(this, credential, bucket, publicRead ? 'public-read' : undefined, undefined, 'ibm', 'ibm-cos-sdk/clients/s3');
+}
+exports.createBucket = createBucket;
+function createBucketV2(credential, bucket, ACL, options) {
+    return aws_1.createBucketV2.call(this, credential, bucket, ACL, options, 'ibm', 'ibm-cos-sdk/clients/s3');
+}
+exports.createBucketV2 = createBucketV2;
+function setBucketPolicy(credential, bucket, options) {
+    return aws_1.setBucketPolicy.call(this, credential, bucket, options, 'ibm', 'ibm-cos-sdk/clients/s3');
+}
+exports.setBucketPolicy = setBucketPolicy;
+function setBucketWebsite(credential, bucket, options) {
+    return aws_1.setBucketWebsite.call(this, credential, bucket, options, 'ibm', 'ibm-cos-sdk/clients/s3');
+}
+exports.setBucketWebsite = setBucketWebsite;
+function deleteObjects(credential, bucket) {
+    return deleteObjectsV2.call(this, credential, bucket, true);
+}
+exports.deleteObjects = deleteObjects;
+function deleteObjectsV2(credential, bucket, recursive = true) {
+    setStorageCredential(credential);
+    return aws_1.deleteObjectsV2.call(this, credential, bucket, recursive, 'ibm', 'ibm-cos-sdk/clients/s3');
+}
+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) {
+    var _a;
+    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 }));
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { service, table: db, id: docId, query, limit = 0, update, ignoreCache } = item;
+        if (!db) {
+            throw (0, util_1.formatError)(item, "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 ? db + '_' : '';
+        if (docId) {
+            const doc = update && update.document;
+            if (queryString) {
+                queryString += docId;
+                if (!doc && (rows = getCache(queryString))) {
+                    result[i] = rows;
+                    continue;
+                }
+            }
+            client = createClient();
+            let { status, result: document } = await client.getDocument({ db, docId });
+            if (status === 200 /* HTTP_STATUS.OK */) {
+                rows = [document];
+            }
+            if (doc) {
+                let _rev = doc._rev;
+                const failed = (message, fatal) => {
+                    if (fatal) {
+                        item.transactionFail = true;
+                    }
+                    else {
+                        delete item.update;
+                    }
+                    this.addLog(types_1.STATUS_TYPE.WARN, service + ` -> ${message} (_id=${docId};_rev=${_rev || "Unknown" /* ERR_MESSAGE.UNKNOWN */})`);
+                };
+                if (rows) {
+                    try {
+                        _rev = document._rev;
+                        update.db = db;
+                        update.document = { ...document, ...doc, _id: docId, _rev };
+                        ({ status } = await client.postDocument(update));
+                        if (status === 200 /* HTTP_STATUS.OK */ || status === 202 /* HTTP_STATUS.ACCEPTED */) {
+                            rows = undefined;
+                            ({ status, result: document } = await client.getDocument({ db, docId }));
+                            if (status === 200 /* HTTP_STATUS.OK */) {
+                                rows = [document];
+                            }
+                            else {
+                                failed('Update success (GET failed)');
+                            }
+                        }
+                        else {
+                            failed('Update failed');
+                        }
+                    }
+                    catch {
+                        failed('Update failed');
+                    }
+                }
+                else {
+                    failed('Row does not exist', true);
+                }
+            }
+        }
+        else {
+            let partitionKey = item.partitionKey;
+            if (query) {
+                if ((0, types_1.isString)(partitionKey)) {
+                    (_a = query).partitionKey || (_a.partitionKey = partitionKey);
+                }
+                else {
+                    partitionKey = query.partitionKey;
+                }
+                if (queryString && (rows = getCache(queryString += module_1.default.asString(query, true) + limit))) {
+                    result[i] = rows;
+                    continue;
+                }
+                client = createClient();
+                query.db || (query.db = db);
+                if (limit > 0) {
+                    query.limit || (query.limit = limit);
+                }
+                let status;
+                if (query.selector) {
+                    let document;
+                    ({ status, result: document } = partitionKey ? await client.postPartitionFind(query) : await client.postFind(query));
+                    if (status === 200 /* HTTP_STATUS.OK */ && document.docs) {
+                        rows = document.docs;
+                    }
+                }
+                else if (query.view) {
+                    let document;
+                    ({ status, result: document } = partitionKey ? await client.postPartitionView(query) : await client.postView(query));
+                    if (status === 200 /* HTTP_STATUS.OK */ && document.rows) {
+                        rows = document.rows.map(row => row.value);
+                    }
+                }
+                else if (query.index) {
+                    let document;
+                    ({ status, result: document } = partitionKey ? await client.postPartitionSearch(query) : await client.postSearch(query));
+                    if (status === 200 /* HTTP_STATUS.OK */ && document.rows) {
+                        rows = await Promise.all(document.rows.map(row => Object.keys(row.fields).length ? Promise.resolve(row.fields) : client.getDocument({ db, docId: row.id }).then(doc => doc.result)));
+                    }
+                }
+            }
+            else if (partitionKey) {
+                if (queryString && (rows = getCache(queryString += module_1.default.asString(partitionKey, true) + limit))) {
+                    result[i] = rows;
+                    continue;
+                }
+                if (!(0, types_1.isPlainObject)(partitionKey)) {
+                    partitionKey = { db, partitionKey, includeDocs: true };
+                }
+                if (limit > 0) {
+                    partitionKey.limit = limit;
+                }
+                const { status, result: document } = await createClient().postPartitionAllDocs(partitionKey);
+                if (status === 200 /* HTTP_STATUS.OK */ && document.rows) {
+                    rows = document.rows.map(row => row.value);
+                }
+            }
+            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;

package/ibm/upload/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+function upload(credential, service = 'ibm') {
+    (0, index_1.setStorageCredential)(credential);
+    return require('../../aws/upload').call(this, credential, service, 'ibm-cos-sdk/clients/s3');
+}
+exports.default = upload;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/index.d.ts

@@ -0,0 +1,6 @@
+import type { CloudConstructor, IFileManager } from '../types/lib';
+import type { CloudAsset } from '../types/lib/cloud';
+
+declare const Cloud: CloudConstructor<IFileManager<CloudAsset>>;
+
+export = Cloud;