@e-mc/cloud 0.0.1

package/minio/download/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+function download(credential, service) {
+    const minio = index_1.createStorageClient.call(this, credential);
+    return (data, callback) => {
+        const { bucket: bucketName, download: target } = data;
+        const { filename, versionId } = target;
+        if (!bucketName || !filename) {
+            callback((0, types_1.errorValue)('Missing property', !bucketName ? 'Bucket' : 'Key'));
+            return;
+        }
+        minio.getObject(bucketName, filename, { versionId }, (error, result) => {
+            if (!error) {
+                (0, util_1.readableAsBuffer)(result).then(buffer => callback(null, buffer)).catch(err => callback(err));
+                const deleteObject = target.deleteObject;
+                if (deleteObject) {
+                    minio.removeObject(bucketName, filename, (0, types_1.isPlainObject)(deleteObject) ? deleteObject : { versionId }, err => {
+                        const location = module_1.default.joinPath(bucketName, filename);
+                        if (!err) {
+                            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Delete success" /* CMD_CLOUD.DELETE_FILE */, location, { ...index_2.default.LOG_CLOUD_DELETE });
+                        }
+                        else {
+                            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Delete failed" /* ERR_CLOUD.DELETE_FAIL */, location], err, { ...index_2.default.LOG_CLOUD_FAIL, fatal: !!target.active });
+                        }
+                    });
+                }
+            }
+            else {
+                callback(error);
+            }
+        });
+    };
+}
+exports.default = download;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/minio/index.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketPolicy = exports.createBucketV2 = exports.createBucket = exports.createStorageClient = exports.validateStorage = void 0;
+const types_1 = require("../../types");
+const module_1 = require("../../module");
+const index_1 = require("../index");
+function createAWSPolicy(bucket, Sid) {
+    const Resource = [`arn:aws:s3:::${bucket}/*`, `arn:aws:s3:::${bucket}`];
+    let Action;
+    switch (Sid) {
+        case 'readonly':
+            Action = ["s3:GetBucketLocation", "s3:GetObject"];
+            break;
+        case 'writeonly':
+            Action = ["s3:PutObject"];
+            Resource.pop();
+            break;
+        case 'readwrite':
+            Action = ["s3:GetBucketLocation", "s3:GetObject", "s3:PutObject"];
+            break;
+        case 'public-read':
+            Action = ["s3:GetObject", "s3:GetObjectVersion"];
+            Resource.pop();
+            break;
+    }
+    return JSON.stringify({
+        "Version": "2012-10-17",
+        "Statement": [{
+                "Sid": Sid,
+                "Effect": "Allow",
+                "Principal": {
+                    "AWS": ["*"]
+                },
+                "Action": Action,
+                "Resource": Resource
+            }]
+    });
+}
+function validateStorage(credential, data) {
+    if (typeof credential.port === 'string') {
+        credential.port = parseInt(credential.port) || 0;
+    }
+    if (!credential.endPoint && module_1.default.enabled("process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */)) {
+        credential.endPoint = process.env.MINIO_ENDPOINT;
+    }
+    const upload = data?.upload;
+    if (upload && !upload.endpoint && data.bucket) {
+        const { endPoint, port = 0, useSSL } = credential;
+        if (endPoint) {
+            upload.endpoint = (useSSL === false ? 'http' : 'https') + '://' + credential.endPoint + (port > 0 ? ':' + port : '') + '/' + data.bucket;
+        }
+    }
+    if (credential.accessKey && credential.secretKey) {
+        return true;
+    }
+    if (module_1.default.enabled("process.env.apply" /* KEY_NAME.PROCESS_ENV_APPLY */) && (credential.accessKey = process.env.MINIO_ACCESS_KEY) && (credential.secretKey = process.env.MINIO_SECRET_KEY)) {
+        credential.sessionToken || (credential.sessionToken = process.env.MINIO_SESSION_TOKEN);
+        return true;
+    }
+    return false;
+}
+exports.validateStorage = validateStorage;
+function createStorageClient(credential) {
+    try {
+        const { Client } = require('minio');
+        credential.endPoint || (credential.endPoint = 'localhost');
+        return new Client(credential);
+    }
+    catch (err) {
+        this.checkPackage(err, 'minio', { passThrough: true });
+        throw err;
+    }
+}
+exports.createStorageClient = createStorageClient;
+async function createBucket(credential, bucketName, publicRead) {
+    return createBucketV2.call(this, credential, bucketName, publicRead ? 'public-read' : undefined);
+}
+exports.createBucket = createBucket;
+async function createBucketV2(credential, bucketName, policy) {
+    const minio = createStorageClient.call(this, credential);
+    const errorMesssage = (err) => this.formatFail(64 /* LOG_TYPE.CLOUD */, "minio" /* MINIO.SERVICE */, ["Unable to create bucket" /* ERR_CLOUD.CREATE_BUCKET */, bucketName], err, { ...index_1.default.LOG_CLOUD_FAIL });
+    return minio.bucketExists(bucketName)
+        .then(exists => {
+        if (!exists) {
+            return minio.makeBucket(bucketName, credential.region || "us-east-1" /* MINIO.REGION */)
+                .then(() => {
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, "minio" /* MINIO.SERVICE */, ["Bucket created" /* CMD_CLOUD.CREATE_BUCKET */, bucketName], '', { ...index_1.default.LOG_CLOUD_COMMAND });
+                if (policy) {
+                    setBucketPolicy.call(this, credential, bucketName, policy);
+                }
+                return true;
+            })
+                .catch(err => {
+                errorMesssage(err);
+                return false;
+            });
+        }
+        if (policy) {
+            setBucketPolicy.call(this, credential, bucketName, policy);
+        }
+        return true;
+    })
+        .catch(err => {
+        errorMesssage(err);
+        return false;
+    });
+}
+exports.createBucketV2 = createBucketV2;
+async function setBucketPolicy(credential, bucketName, bucketPolicy) {
+    if ((0, types_1.isObject)(bucketPolicy)) {
+        bucketPolicy = JSON.stringify(bucketPolicy);
+    }
+    if (!(0, types_1.isString)(bucketPolicy)) {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, "minio" /* MINIO.SERVICE */, ["Invalid bucket policy" /* ERR_CLOUD.POLICY_INVALID */, bucketName], '', { ...index_1.default.LOG_CLOUD_WARN });
+        return false;
+    }
+    const minio = createStorageClient.call(this, credential);
+    return minio.bucketExists(bucketName)
+        .then(exists => {
+        if (exists) {
+            switch (bucketPolicy) {
+                case 'readonly':
+                case 'readwrite':
+                case 'writeonly':
+                case 'public-read':
+                    bucketPolicy = createAWSPolicy(bucketName, bucketPolicy);
+                    break;
+            }
+            return minio.setBucketPolicy(bucketName, bucketPolicy)
+                .then(() => {
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, "minio" /* MINIO.SERVICE */, ["Bucket policy configured" /* CMD_CLOUD.POLICY_BUCKET */, bucketName], '', { ...index_1.default.LOG_CLOUD_COMMAND });
+                return true;
+            })
+                .catch(err => {
+                this.formatFail(64 /* LOG_TYPE.CLOUD */, "minio" /* MINIO.SERVICE */, ["Unable to update bucket policy" /* ERR_CLOUD.POLICY_BUCKET */, bucketName], err, { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
+                return false;
+            });
+        }
+        return false;
+    })
+        .catch(err => {
+        this.formatFail(64 /* LOG_TYPE.CLOUD */, "minio" /* MINIO.SERVICE */, ["Unknown" /* ERR_MESSAGE.UNKNOWN */, bucketName], err, { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
+        return false;
+    });
+}
+exports.setBucketPolicy = setBucketPolicy;
+function deleteObjects(credential, bucketName) {
+    return deleteObjectsV2.call(this, credential, bucketName, true);
+}
+exports.deleteObjects = deleteObjects;
+async function deleteObjectsV2(credential, bucketName, recursive = true) {
+    const minio = createStorageClient.call(this, credential);
+    return new Promise((resolve, reject) => {
+        minio.bucketExists(bucketName)
+            .then(exists => {
+            if (exists) {
+                const stream = minio.listObjectsV2(bucketName, '', recursive);
+                const items = [];
+                stream.on('data', item => {
+                    items.push(item);
+                });
+                stream.on('end', () => {
+                    minio.removeObjects(bucketName, items.map(item => item.name), err => {
+                        if (!err) {
+                            this.formatMessage(64 /* LOG_TYPE.CLOUD */, "minio" /* MINIO.SERVICE */, ["Bucket emptied" /* CMD_CLOUD.EMPTY_BUCKET */ + ` (${items.length} files)`, bucketName], '', { ...index_1.default.LOG_CLOUD_COMMAND });
+                            resolve();
+                        }
+                        else {
+                            reject(err);
+                        }
+                    });
+                });
+                stream.on('error', err => reject(err));
+            }
+            else {
+                resolve();
+            }
+        })
+            .catch(err => reject(err));
+    });
+}
+exports.deleteObjectsV2 = deleteObjectsV2;

package/minio/upload/index.js

@@ -0,0 +1,135 @@
+"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) {
+    const minio = index_1.createStorageClient.call(this, credential);
+    return async (data, callback) => {
+        var _a;
+        const { bucket: bucketName, localUri } = data;
+        const { pathname = '', fileGroup, contentType, metadata = {}, endpoint, active, acl, publicRead, admin = {}, overwrite, options } = data.upload;
+        let filename = data.upload.filename || path.basename(localUri), bucketKey;
+        const cleanup = () => {
+            BUCKET_SESSION.delete(bucketName);
+            if (bucketKey) {
+                delete BUCKET_RESPONSE[bucketKey];
+            }
+        };
+        const errorResponse = (err) => {
+            cleanup();
+            callback(err);
+        };
+        if (!BUCKET_SESSION.has(bucketName)) {
+            const bucketAcl = admin.publicRead ? 'public-read' : admin.acl;
+            const response = BUCKET_RESPONSE[_a = bucketKey = getBucketKey(credential, bucketName, bucketAcl)] || (BUCKET_RESPONSE[_a] = index_1.createBucketV2.call(this, credential, bucketName, bucketAcl));
+            if (!await response) {
+                errorResponse(null);
+                return;
+            }
+            BUCKET_SESSION.add(bucketName);
+        }
+        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 minio.statObject(bucketName, pathname ? module_1.default.joinPath(pathname, filename) : filename)
+                    .then(() => true)
+                    .catch((err) => {
+                    if (err instanceof Error && err.code !== '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_2.default.LOG_CLOUD_WARN });
+            }
+        }
+        const Key = [filename];
+        const Body = [data.buffer];
+        const ContentType = [contentType];
+        const addLog = (err) => err instanceof Error && this.addLog(this.statusType.WARN, err.message, service + ': ' + bucketName);
+        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 objectName = pathname + Key[i];
+            const type = ContentType[i] || module_1.default.lookupMime(Key[i]) || 'application/octet-stream';
+            const params = first && metadata ? { ...metadata } : { ...options };
+            const readable = publicRead || active && publicRead !== false && !acl;
+            if (first) {
+                params['Content-Type'] || (params['Content-Type'] = type);
+                if (readable) {
+                    params['x-amz-acl'] = 'public-read';
+                }
+                else if (acl) {
+                    params['x-amz-acl'] = acl;
+                }
+            }
+            else {
+                params['Content-Type'] = type;
+                if (!params['x-amz-acl']) {
+                    if (readable) {
+                        params['x-amz-acl'] = 'public-read';
+                    }
+                    else if (acl) {
+                        params['x-amz-acl'] = acl;
+                    }
+                }
+            }
+            minio.putObject(bucketName, objectName, Body[i], Buffer.byteLength(Body[i]), params, err => {
+                if (!err) {
+                    const url = module_1.default.joinPath(endpoint || module_1.default.joinPath("http://localhost:9000" /* MINIO.SERVER */, bucketName), objectName);
+                    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);
+                    }
+                }
+                else if (first) {
+                    errorResponse(err);
+                }
+                else {
+                    addLog(err);
+                }
+            });
+        }
+    };
+}
+exports.default = upload;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/oci/download/index.js

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

package/oci/index.js

@@ -0,0 +1,183 @@
+"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.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.accessKeyId && credential.secretAccessKey && (credential.region && credential.namespace || credential.endpoint));
+}
+exports.validateStorage = validateStorage;
+function validateDatabase(credential, data) {
+    return !!(data.table && (credential.password && (credential.user || credential.username) && (credential.connectString || credential.connectionString) || credential.poolAlias));
+}
+exports.validateDatabase = validateDatabase;
+function setStorageCredential(credential) {
+    if (credential.endpoint) {
+        credential.region || (credential.region = /([^.]+)\.oraclecloud\.com$/.exec(credential.endpoint)?.[1]);
+    }
+    else {
+        credential.endpoint || (credential.endpoint = `https://${credential.namespace}.compat.objectstorage.${credential.region}.oraclecloud.com`);
+    }
+    credential.s3ForcePathStyle = true;
+    credential.signatureVersion = 'v4';
+}
+exports.setStorageCredential = setStorageCredential;
+function createDatabaseClient(credential) {
+    try {
+        if (credential.username) {
+            credential.user || (credential.user = credential.username);
+            delete credential.username;
+        }
+        const { getConnection } = require('oracledb');
+        return getConnection(credential);
+    }
+    catch (err) {
+        this.checkPackage(err, 'oracledb', { 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, 'oci');
+}
+exports.createBucket = createBucket;
+function createBucketV2(credential, bucket, ACL, options) {
+    return aws_1.createBucketV2.call(this, credential, bucket, ACL, options, 'oci');
+}
+exports.createBucketV2 = createBucketV2;
+function setBucketPolicy(credential, bucket, options) {
+    return aws_1.setBucketPolicy.call(this, credential, bucket, options, 'oci');
+}
+exports.setBucketPolicy = setBucketPolicy;
+function setBucketWebsite(credential, bucket, options) {
+    return aws_1.setBucketWebsite.call(this, credential, bucket, options, 'oci');
+}
+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, 'oci');
+}
+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 = () => createDatabaseClient.call(this, length === 1 ? credential : { ...credential });
+    const closeClient = () => client?.close();
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { service, table, id, query, ignoreCache } = item;
+        if (!table) {
+            closeClient();
+            throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+        }
+        const renewCache = ignoreCache === 0;
+        const getCache = (value) => {
+            if (ignoreCache === 1) {
+                return;
+            }
+            cacheValue.renewCache = renewCache;
+            return this.getQueryResult(service, credential, value, cacheValue);
+        };
+        let rows, queryString = caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache ? table + '_' : '';
+        invalid: {
+            if (id) {
+                const update = item.update;
+                if (queryString) {
+                    queryString += id;
+                    if (!update && (rows = getCache(queryString))) {
+                        result[i] = rows;
+                        continue;
+                    }
+                }
+                const db = await (client || (client = await createClient())).getSodaDatabase().openCollection(table);
+                if (!db) {
+                    closeClient();
+                    throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+                }
+                const row = db.find().key(id);
+                let document = await row.getOne();
+                if (document) {
+                    rows = [document.getContent()];
+                }
+                if (update) {
+                    const failed = (message, fatal) => {
+                        if (fatal) {
+                            item.transactionFail = true;
+                        }
+                        else {
+                            delete item.update;
+                        }
+                        this.addLog(types_1.STATUS_TYPE.WARN, service + `-> ${message} (_id=${id})`);
+                    };
+                    if (rows) {
+                        const status = await row.replaceOne({ ...rows[0], ...update });
+                        if (status.replaced) {
+                            rows = undefined;
+                            if (document = await row.getOne()) {
+                                rows = [document.getContent()];
+                            }
+                            else {
+                                failed('Update success (GET failed)');
+                            }
+                        }
+                        else {
+                            failed('Update failed');
+                        }
+                    }
+                    else {
+                        failed('Row does not exist', true);
+                        break invalid;
+                    }
+                }
+            }
+            else if (query) {
+                const maxRows = typeof item.limit === 'number' ? Math.max(item.limit, 0) : undefined;
+                if ((0, types_1.isPlainObject)(query)) {
+                    if (queryString && (rows = getCache(queryString += module_1.default.asString(query, true) + (maxRows ? maxRows : '')))) {
+                        result[i] = rows;
+                        continue;
+                    }
+                    const db = await (client || (client = await createClient())).getSodaDatabase().openCollection(table);
+                    if (!db) {
+                        closeClient();
+                        throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+                    }
+                    let operation = db.find().filter(query);
+                    if (maxRows) {
+                        operation = operation.limit(maxRows);
+                    }
+                    rows = (await operation.getDocuments()).map(doc => doc.getContent());
+                }
+                else {
+                    const { params, options } = item;
+                    if (queryString && (rows = getCache(queryString += query + module_1.default.asString(params, true) + module_1.default.asString(options, true) + (maxRows ? maxRows : '')))) {
+                        result[i] = rows;
+                        continue;
+                    }
+                    ({ rows } = await (client || (client = await createClient())).execute(query, params || [], { ...options, outFormat: 4002 /* OUT_FORMAT.OBJECT */, maxRows, resultSet: false, autoCommit: true }));
+                }
+            }
+            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/oci/upload/index.js

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

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@e-mc/cloud",
+  "version": "0.0.1",
+  "description": "Cloud constructor for e-mc.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/e-mc.git",
+    "directory": "src/cloud"
+  },
+  "keywords": [
+    "squared",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "BSD 3-Clause",
+  "homepage": "https://github.com/anpham6/e-mc#readme",
+  "dependencies": {
+    "@e-mc/core": "0.0.1",
+    "@e-mc/db": "0.0.1"
+  }
+}

package/types.d.ts

@@ -0,0 +1,29 @@
+import type { ICloud, IFileManager, IModule, IScopeOrigin } from '../types/lib';
+import type { BucketWebsiteOptions, CloudAsset, CloudDatabase, CloudService, CloudStorageUpload, DownloadData, UploadData } from '../types/lib/cloud';
+import type { BatchQueryResult, QueryResult } from '../types/lib/db';
+
+export interface ICloudServiceClient<T extends CloudDatabase = CloudDatabase> {
+    validateStorage?(credential: unknown, data?: CloudService): boolean;
+    validateDatabase?(credential: unknown, data?: CloudService): boolean;
+    createStorageClient?<U>(this: IModule, credential: unknown, service?: string): U;
+    createDatabaseClient?<U>(this: IModule, credential: unknown, data?: CloudService): U;
+    createBucket?(this: IModule, credential: unknown, bucket: string, publicRead?: boolean, service?: string, sdk?: string): Promise<boolean>;
+    createBucketV2?(this: IModule, credential: unknown, bucket: string, acl?: unknown, options?: unknown, service?: string, sdk?: string): Promise<boolean>;
+    setBucketPolicy?(this: IModule, credential: unknown, bucket: string, options: unknown, service?: string, sdk?: string): Promise<boolean>;
+    setBucketWebsite?(this: IModule, credential: unknown, bucket: string, options: BucketWebsiteOptions, service?: string, sdk?: string): Promise<boolean>;
+    deleteObjects?(this: IModule, credential: unknown, bucket: string, service?: string, sdk?: string, recursive?: boolean): Promise<void>;
+    deleteObjectsV2?(this: IModule, credential: unknown, bucket: string, recursive?: boolean, service?: string, sdk?: string): Promise<void>;
+    executeQuery?(this: ICloud, credential: unknown, data: T, sessionKey?: string): Promise<QueryResult>;
+    executeBatchQuery?(this: ICloud, credential: unknown, batch: T[], sessionKey?: string): Promise<BatchQueryResult>;
+}
+
+export interface CloudScopeOrigin<T extends IFileManager<U>, U extends CloudAsset = CloudAsset, V extends ICloud = ICloud> extends Required<IScopeOrigin<T, V>> {
+    bucketGroup: string;
+    localStorage: Map<U, CloudStorageUpload>;
+}
+
+export type ServiceHost<T> = (this: IModule, credential: unknown, service?: string, sdk?: string) => T;
+export type UploadCallback = (data: UploadData, callback: (err: unknown, value?: string) => void) => void;
+export type DownloadCallback = (data: DownloadData, callback: (err: unknown, value?: Null<BufferContent>) => void) => void;
+export type UploadHost = ServiceHost<UploadCallback>;
+export type DownloadHost = ServiceHost<DownloadCallback>;

package/util.d.ts

@@ -0,0 +1,12 @@
+import type { Readable } from 'stream';
+
+declare namespace util {
+    function readableAsBuffer(stream: Readable): Promise<Buffer | null>;
+    function generateFilename(filename: string): (i: number) => [string, boolean];
+    function getBasicAuth(auth: AuthValue): string;
+    function getBasicAuth(username: unknown, password?: unknown): string;
+    function hasBasicAuth(value: string): boolean;
+    function formatError(title: string | { service: string; }, message: string, hint?: string): Error;
+}
+
+export = util;