@pi-r/gcp 0.0.1

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 An Pham
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+### @pi-r/gcp
+
+### LICENSE
+
+MIT

package/client/index.js

@@ -0,0 +1,830 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectId = exports.createBucketRequest = exports.setPredefinedAcl = exports.setPublicRead = exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.setBucketPolicy = exports.createBucketV2 = exports.createBucket = exports.createDatabaseClient = exports.createStorageClient = exports.validateDatabase = exports.validateStorage = exports.isFirebaseApp = void 0;
+const path = require("path");
+const util_1 = require("@e-mc/cloud/util");
+const types_1 = require("@e-mc/types");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+const FIREBASE_DB = {};
+const FIREBASE_STORAGE = {};
+const ADMIN_DB = {};
+const ADMIN_STORAGE = {};
+function getApp(credential, isDB) {
+    var _a, _b;
+    const { projectId, databaseURL, storageBucket, apiKey, authDomain } = credential;
+    if (apiKey && authDomain) {
+        const { getApps, initializeApp } = require('@firebase/app');
+        let app;
+        for (const item of getApps()) {
+            const options = item.options;
+            if (projectId === options.projectId && apiKey === options.apiKey && authDomain === options.authDomain && (!isDB || isDB && databaseURL === options.databaseURL)) {
+                app = item;
+                break;
+            }
+        }
+        if (!app) {
+            const firebaseKey = (projectId || '') + '_' + apiKey + '_' + authDomain + (isDB ? '_' + databaseURL : '');
+            app = isDB ? FIREBASE_DB[firebaseKey] || (FIREBASE_DB[firebaseKey] = initializeApp({ ...credential, databaseURL }, firebaseKey)) : FIREBASE_STORAGE[firebaseKey] || (FIREBASE_STORAGE[firebaseKey] = initializeApp({ ...credential, storageBucket }, firebaseKey));
+        }
+        if (isDB) {
+            const { getDatabase, goOnline } = require('@firebase/database');
+            const db = getDatabase(app);
+            goOnline(db);
+            return db;
+        }
+        const { getStorage } = require('@firebase/storage');
+        return getStorage(app);
+    }
+    {
+        const { getApps, initializeApp, applicationDefault } = require('firebase-admin/app');
+        let app;
+        for (const item of getApps()) {
+            if (!isDB && storageBucket && item.name === storageBucket || isDB && databaseURL && item.name === databaseURL) {
+                app = item;
+                break;
+            }
+        }
+        if (!app) {
+            app = isDB ? ADMIN_DB[_a = databaseURL || '[DEFAULT]'] || (ADMIN_DB[_a] = initializeApp({ credential: applicationDefault(), databaseURL }, databaseURL)) : ADMIN_STORAGE[_b = storageBucket || '[DEFAULT]'] || (ADMIN_STORAGE[_b] = initializeApp({ credential: applicationDefault(), storageBucket }, storageBucket));
+        }
+        credential.admin = true;
+        if (isDB) {
+            const { getDatabase } = require('firebase-admin/database');
+            return getDatabase(app);
+        }
+        const { getStorage } = require('firebase-admin/storage');
+        return getStorage(app);
+    }
+}
+async function hasBucket(client) {
+    const [exists] = await client.exists().catch(err => isErrorConflict(err) ? [true] : [false]);
+    return exists;
+}
+function updatePredefinedAcl(acl, values, metadata) {
+    const { generation, userProject } = metadata;
+    const items = [];
+    for (const target of acl.default ? [acl, acl.default] : [acl]) {
+        items.push(...values.map(async (value) => {
+            if (generation !== undefined) {
+                value.generation ?? (value.generation = +generation);
+            }
+            if (userProject) {
+                value.userProject || (value.userProject = userProject);
+            }
+            const entity = await target.get({ entity: value.entity }).catch(() => null);
+            if (entity) {
+                return (0, types_1.isString)(value.role) ? target.update(value) : target.delete(value);
+            }
+            if ((0, types_1.isString)(value.role)) {
+                return target.add(value);
+            }
+        }));
+    }
+    return Promise.allSettled(items)
+        .then(result => {
+        const errors = [];
+        for (const item of result) {
+            if (item.status === 'rejected') {
+                errors.push(item.reason);
+            }
+        }
+        return errors;
+    })
+        .catch(err => [err]);
+}
+function setUniformBucketLevel(bucket, enabled) {
+    return bucket.setMetadata({ iamConfiguration: { uniformBucketLevelAccess: { enabled } } });
+}
+const getFirebasePackageName = (credential) => credential.apiKey && credential.authDomain ? 'firebase' : 'firebase-admin';
+const hasKeyFile = (credential) => !!(credential.keyFile || credential.keyFilename || process.env.GOOGLE_APPLICATION_CREDENTIALS);
+const isErrorConflict = (err) => (err instanceof Error) && err.code === 409;
+function isFirebaseApp(credential, storage, admin) {
+    return !!(credential.apiKey && credential.authDomain && (storage || credential.databaseURL) || credential.product === 'firebase' && process.env.GOOGLE_APPLICATION_CREDENTIALS) && (!admin || !credential.admin);
+}
+exports.isFirebaseApp = isFirebaseApp;
+function validateStorage(credential) {
+    return hasKeyFile(credential) || isFirebaseApp(credential, true);
+}
+exports.validateStorage = validateStorage;
+function validateDatabase(credential, data) {
+    return hasKeyFile(credential) && !!(data.table || data.query || data.keys || data.product || data.database) || isFirebaseApp(credential);
+}
+exports.validateDatabase = validateDatabase;
+function createStorageClient(credential, bucket) {
+    let packageName = '';
+    try {
+        if (isFirebaseApp(credential, true)) {
+            if (bucket) {
+                credential.storageBucket = bucket;
+            }
+            packageName = getFirebasePackageName(credential);
+            return getApp(credential, false);
+        }
+        credential.projectId || (credential.projectId = getProjectId(credential));
+        const { Storage } = require(packageName = '@google-cloud/storage');
+        return new Storage(credential);
+    }
+    catch (err) {
+        this.checkPackage(err, packageName, { passThrough: true });
+        throw err;
+    }
+}
+exports.createStorageClient = createStorageClient;
+function createDatabaseClient(credential, data) {
+    let packageName = '';
+    try {
+        const product = data?.product;
+        if (product === 'firebase' || isFirebaseApp(credential)) {
+            packageName = getFirebasePackageName(credential);
+            return getApp(credential, true);
+        }
+        credential.projectId || (credential.projectId = getProjectId(credential));
+        if (data) {
+            if (product === 'spanner' || !product && data.name && data.database) {
+                const { Spanner } = require(packageName = '@google-cloud/spanner');
+                return new Spanner(credential);
+            }
+            if (product === 'bigtable' || !product && data.name && data.table) {
+                const { Bigtable } = require(packageName = '@google-cloud/bigtable');
+                return new Bigtable(credential);
+            }
+            if (product === 'bigquery' || !product && !data.table && typeof data.query === 'string') {
+                const { BigQuery } = require(packageName = '@google-cloud/bigquery');
+                return new BigQuery(credential);
+            }
+            if (product === 'datastore' || !product && !data.table && (data.keys || data.query)) {
+                const { Datastore } = require(packageName = '@google-cloud/datastore');
+                return new Datastore(credential);
+            }
+        }
+        const { Firestore } = require(packageName = '@google-cloud/firestore');
+        return new Firestore(credential);
+    }
+    catch (err) {
+        this.checkPackage(err, packageName, { passThrough: true });
+        throw err;
+    }
+}
+exports.createDatabaseClient = createDatabaseClient;
+async function createBucket(credential, bucket, publicRead, service = 'gcp') {
+    return createBucketV2.call(this, credential, bucket, publicRead ? 'publicRead' : undefined, createBucketRequest(credential), service);
+}
+exports.createBucket = createBucket;
+async function createBucketV2(credential, bucket, acl, options, service = 'gcp') {
+    if (isFirebaseApp(credential, true, true)) {
+        return false;
+    }
+    const storage = createStorageClient.call(this, credential, bucket);
+    if (await hasBucket(storage.bucket(bucket))) {
+        if (acl) {
+            await setBucketPolicy.call(this, credential, bucket, { acl }, service);
+        }
+        return true;
+    }
+    return storage.createBucket(bucket, options)
+        .then(async ([target]) => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket created" /* VAL_CLOUD.CREATE_BUCKET */, bucket], '', { ...Cloud.LOG_CLOUD_COMMAND });
+        if (acl) {
+            await setBucketPolicy.call(this, credential, bucket, { acl, bucket: target }, service);
+        }
+        return true;
+    })
+        .catch(async (err) => {
+        if (isErrorConflict(err)) {
+            return acl ? await setBucketPolicy.call(this, credential, bucket, { acl }, service) : true;
+        }
+        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to create bucket" /* ERR_CLOUD.CREATE_BUCKET */, bucket], err, { ...Cloud.LOG_CLOUD_FAIL });
+        return false;
+    });
+}
+exports.createBucketV2 = createBucketV2;
+async function setBucketPolicy(credential, bucket, options, service = 'gcp') {
+    if (isFirebaseApp(credential, true, true)) {
+        return false;
+    }
+    const client = createStorageClient.call(this, credential, bucket).bucket(bucket);
+    if (!await hasBucket(client)) {
+        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Bucket does not exist" /* ERR_CLOUD.EXISTS_BUCKET */, bucket], (0, util_1.formatError)(service, "Bucket does not exist" /* ERR_CLOUD.EXISTS_BUCKET */), { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+        return false;
+    }
+    const errors = [];
+    const acl = options.acl;
+    if (!Array.isArray(options.acl)) {
+        options.acl = undefined;
+        switch (acl) {
+            case 'private':
+            case 'projectPrivate':
+                await client.makePrivate(options).catch(err => !isErrorConflict(err) && errors.push(err));
+                await setPredefinedAcl.call(this, client.acl, acl, client, '', options.bucket?.metadata);
+                break;
+            case 'authenticatedRead':
+                await client.makePublic(options).catch(err => !isErrorConflict(err) && errors.push(err));
+                options = { ...options };
+                options.acl = [{ entity: 'allUsers' }, { entity: 'allAuthenticatedUsers', role: 'READER' }];
+                break;
+            case 'publicReadWrite':
+                await client.makePublic(options).catch(err => !isErrorConflict(err) && errors.push(err));
+                options = { ...options };
+                options.acl = [{ entity: 'allUsers', role: 'WRITER' }];
+                break;
+            case 'publicRead':
+                await client.makePublic(options).catch(err => !isErrorConflict(err) && errors.push(err));
+                break;
+            case 'bucketAccessUniform':
+                await setUniformBucketLevel(client, true).catch(err => errors.push(err));
+                break;
+            case 'bucketAccessACL':
+                await setUniformBucketLevel(client, false).catch(err => errors.push(err));
+                break;
+            default:
+                errors.push((0, types_1.errorValue)('Invalid ACL', Module.asString(acl) || 'empty'));
+                break;
+        }
+    }
+    if (options.acl && (options.acl = options.acl.filter(user => (0, types_1.isString)(user.entity))).length) {
+        errors.push(...await updatePredefinedAcl(client.acl, options.acl, options));
+    }
+    if (errors.length) {
+        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to update bucket policy" /* ERR_CLOUD.POLICY_BUCKET */, bucket], errors[0], { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+        return false;
+    }
+    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket ACL configured" /* VAL_CLOUD.ACL_BUCKET */, bucket], (0, types_1.isString)(acl) ? acl : '', { ...Cloud.LOG_CLOUD_COMMAND });
+    return true;
+}
+exports.setBucketPolicy = setBucketPolicy;
+function setBucketWebsite(credential, bucket, options, service = 'gcp') {
+    if (isFirebaseApp(credential, true, true)) {
+        return Promise.resolve(false);
+    }
+    const website = {};
+    if ((0, types_1.isString)(options.indexPage)) {
+        website.mainPageSuffix = options.indexPage;
+    }
+    if ((0, types_1.isString)(options.errorPage)) {
+        website.notFoundPage = options.errorPage;
+    }
+    return createStorageClient.call(this, credential, bucket).bucket(bucket).setMetadata({ website })
+        .then(() => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket configured" /* VAL_CLOUD.CONFIGURE_BUCKET */, bucket], website, { ...Cloud.LOG_CLOUD_COMMAND });
+        return true;
+    })
+        .catch(err => {
+        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to configure bucket" /* ERR_CLOUD.CONFIGURE_BUCKET */, bucket], err, { ...Cloud.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 = 'gcp') {
+    const storage = createStorageClient.call(this, credential, bucket);
+    const errors = [];
+    let promise;
+    if (isFirebaseApp(credential, true, true)) {
+        const { ref, listAll, deleteObject } = require('@firebase/storage');
+        const files = [];
+        await (async function recurse(prefix) {
+            try {
+                const { items, prefixes } = await listAll(ref(storage, prefix));
+                if (items.length) {
+                    files.push(...items.map(value => value.fullPath));
+                }
+                if (recursive && prefixes.length) {
+                    for (const { name } of prefixes) {
+                        await recurse(Module.joinPath(prefix, name));
+                    }
+                }
+            }
+            catch (err) {
+                errors.push(err);
+            }
+        })('');
+        if (files.length) {
+            promise = Promise.allSettled(files.map(value => deleteObject(ref(storage, value))));
+        }
+    }
+    else {
+        const client = storage.bucket(bucket);
+        if (await hasBucket(client)) {
+            if (recursive) {
+                return client.deleteFiles({ force: true }).then(() => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Bucket emptied" /* VAL_CLOUD.EMPTY_BUCKET */ + ' (recursive)', bucket, { ...Cloud.LOG_CLOUD_COMMAND }));
+            }
+            const tasks = [];
+            try {
+                const result = await client.getFiles();
+                for (const { name } of result[0]) {
+                    if (name.indexOf('/') === -1) {
+                        tasks.push(client.file(name).delete({ ignoreNotFound: true }).catch(err => this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Delete failed" /* ERR_CLOUD.DELETE_FAIL */, name], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false })));
+                    }
+                }
+            }
+            catch (err) {
+                errors.push(err);
+            }
+            if (tasks.length) {
+                promise = Promise.allSettled(tasks);
+            }
+        }
+    }
+    const checkErrors = () => {
+        if (errors.length) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to empty bucket" /* ERR_CLOUD.DELETE_BUCKET */ + (recursive ? ' (recursive)' : ''), errors.length + ' errors'], errors[0], { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+            return true;
+        }
+        return false;
+    };
+    if (promise) {
+        return promise.then(result => {
+            errors.push(...result.filter(item => item.status === 'rejected').map((item) => item.reason));
+            if (!checkErrors()) {
+                const files = result.length + ' files';
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket emptied" /* VAL_CLOUD.EMPTY_BUCKET */ + ` (${recursive ? 'recursive' : files})`, bucket], recursive ? files : '', { ...Cloud.LOG_CLOUD_COMMAND });
+            }
+        })
+            .catch(err => {
+            errors.push(err);
+        });
+    }
+    checkErrors();
+}
+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 clients = [];
+    const caching = length > 0 && this.hasCache(batch[0].service, sessionKey);
+    const cacheValue = { value: this.valueOfKey(credential, 'cache'), sessionKey };
+    const authItems = [];
+    const createClient = (data, type) => {
+        const client = clients[type];
+        if (client) {
+            return client;
+        }
+        const item = length === 1 ? credential : { ...credential };
+        authItems.push(item);
+        return (clients[type] = createDatabaseClient.call(this, item, data));
+    };
+    const closeClient = () => {
+        const fs = clients[3 /* DB.FIRESTORE */];
+        if (fs) {
+            fs.terminate();
+        }
+    };
+    const getFamily = (data, row, family) => {
+        const familyData = data[family];
+        for (const qualifier of Object.keys(familyData)) {
+            const items = familyData[qualifier];
+            row[qualifier] = items.length === 1 ? items[0].value : items.map(col => col.value);
+        }
+        return row;
+    };
+    const getRowData = (rowId, data) => {
+        const families = Object.keys(data);
+        const row = { '__id__': rowId };
+        if (families.length === 1) {
+            return getFamily(data, row, families[0]);
+        }
+        for (const family of families) {
+            row[family] = getFamily(data, {}, family);
+        }
+        return row;
+    };
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { service, product, name, database, table, id, query, orderBy, keys, limit = 0, update, ignoreCache } = item;
+        const renewCache = ignoreCache === 0;
+        const cached = caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache;
+        const getCache = (value) => {
+            if (ignoreCache === 1) {
+                return;
+            }
+            cacheValue.renewCache = renewCache;
+            return this.getQueryResult(service, credential, value, cacheValue);
+        };
+        let rows, queryString = '';
+        if (product === 'bigtable' || !product && name && table && !database) {
+            const { columns, options = {} } = item;
+            if ((0, types_1.isObject)(query)) {
+                options.filter = query;
+            }
+            if (!id && limit > 0) {
+                (options.gaxOptions || (options.gaxOptions = {})).maxResults = limit;
+            }
+            if (cached && (rows = getCache(queryString = name + '_' + table + '_' + (id ? id + ((0, types_1.isArray)(columns) ? '_' + Module.asString(columns, true) : '') : '') + Module.asString(options, true)))) {
+                result[i] = rows;
+                continue;
+            }
+            const db = createClient(item, 4 /* DB.BIGTABLE */).instance(name).table(table);
+            if (id) {
+                const row = db.row(id);
+                if (Array.isArray(columns)) {
+                    const [data] = await row.get(columns, options);
+                    rows = [getRowData(id, data)];
+                }
+                else {
+                    const [response] = await row.get(options);
+                    rows = [getRowData(response.id, response.data)];
+                }
+            }
+            else {
+                rows = [];
+                await new Promise((resolve, reject) => {
+                    db.createReadStream(options)
+                        .on('data', row => rows.push(getRowData(row.id, row.data)))
+                        .on('error', reject)
+                        .on('end', resolve);
+                });
+            }
+        }
+        else if (product === 'spanner' || !product && name && database && (query || table)) {
+            const columns = (0, types_1.isPlainObject)(query) && query.columns || item.columns;
+            if (!(query || table && columns)) {
+                closeClient();
+                throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
+            }
+            if (!name || !database) {
+                closeClient();
+                throw (0, util_1.formatError)(item, !name ? "Missing instance name" /* ERR_DB.INSTANCE */ : "Missing database name" /* ERR_DB.NAME */);
+            }
+            const { updateType, options = {} } = item;
+            if (cached) {
+                queryString = name + '_' + database + '_' + (table ? table + Module.asString(columns, true) : '') + Module.asString(query, true) + limit;
+                if (!update && (rows = getCache(queryString))) {
+                    result[i] = rows;
+                    continue;
+                }
+            }
+            const db = createClient(item, 5 /* DB.SPANNER */).instance(name).database(database, options.databasePool, options.databaseQuery);
+            if (table) {
+                if ((0, types_1.isPlainObject)(update)) {
+                    await db.table(table)[updateType === 1 ? 'insert' : updateType === 2 ? 'replace' : 'update'](update, options.tableUpdate);
+                }
+                const request = (0, types_1.isPlainObject)(query) ? query : { columns };
+                request.json = true;
+                request.columns || (request.columns = item.columns);
+                request.keySet = { all: true };
+                if (limit > 0) {
+                    request.limit = limit;
+                }
+                [rows] = await db.table(table).read(request, options.tableRead);
+            }
+            else {
+                if ((0, types_1.isString)(update) || (0, types_1.isPlainObject)(update) && (0, types_1.isString)(update.sql)) {
+                    await new Promise((resolve, reject) => {
+                        db.runTransaction((err, transaction) => {
+                            if (err || !transaction) {
+                                reject(err || new Error("Unknown" /* ERR_MESSAGE.UNKNOWN */));
+                            }
+                            else {
+                                transaction.runUpdate(update)
+                                    .then(() => transaction.commit().then(() => resolve()).catch(error => reject(error)))
+                                    .catch(error => reject(error));
+                            }
+                        });
+                    });
+                }
+                const request = (0, types_1.isPlainObject)(query) ? query : { sql: query };
+                request.json = true;
+                if (limit > 0) {
+                    (request.gaxOptions || (request.gaxOptions = {})).maxResults = limit;
+                }
+                [rows] = await db.run(request);
+            }
+        }
+        else if (product === 'firebase' || product === 'bigquery' || !product && !table && typeof query === 'string') {
+            if (!(0, types_1.isString)(query)) {
+                closeClient();
+                throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
+            }
+            const firebaseApp = product === 'firebase' || isFirebaseApp(credential);
+            if (cached) {
+                queryString = query + (firebaseApp ? Module.asString(orderBy, true) : Module.asString(item.params, true) + Module.asString(item.options, true) + limit);
+                if ((product === 'bigquery' || !update) && (rows = getCache(queryString))) {
+                    result[i] = rows;
+                    continue;
+                }
+            }
+            if (firebaseApp) {
+                const { ref, get, child, query: queryDB, update: updateDB } = require('@firebase/database');
+                const constraints = [];
+                let limiter = 0;
+                if ((0, types_1.isArray)(orderBy)) {
+                    const sort = require('@firebase/database');
+                    for (const items of orderBy) {
+                        if ((0, types_1.isArray)(items)) {
+                            const method = items[0];
+                            switch (method) {
+                                case 'orderByChild':
+                                    constraints.push(sort.orderByChild(items[1]));
+                                    break;
+                                case 'orderByKey':
+                                case 'orderByValue':
+                                case 'orderByPriority':
+                                    constraints.push(sort[method]());
+                                    break;
+                                case 'limitToFirst':
+                                case 'limitToLast':
+                                    constraints.push(sort[method](limiter = +items[1]));
+                                    break;
+                                case 'startAt':
+                                case 'startAfter':
+                                case 'endAt':
+                                case 'endBefore':
+                                case 'equalTo':
+                                    constraints.push(sort[method](items[1], items[2]));
+                                    break;
+                            }
+                        }
+                    }
+                }
+                const db = createClient(item, 0 /* DB.FIREBASE */);
+                if ((0, types_1.isPlainObject)(update)) {
+                    await updateDB(ref(db, query), update);
+                }
+                const snapshot = await (constraints.length ? get(queryDB(ref(db, query), ...constraints)) : get(child(ref(db), query)));
+                if (snapshot.exists()) {
+                    const val = snapshot.val();
+                    const group = limiter === 1 && Object.keys(val);
+                    rows = [group && (0, types_1.isObject)(val) && (0, types_1.isObject)(val[group[0]]) ? val[group[0]] : val];
+                }
+            }
+            else {
+                const { options = {} } = item;
+                options.query = query;
+                options.params || (options.params = item.params);
+                if (limit > 0) {
+                    options.maxResults = limit;
+                }
+                const [job] = await createClient(item, 1 /* DB.BIGQUERY */).createQueryJob(options);
+                [rows] = await job.getQueryResults();
+            }
+        }
+        else if (product === 'datastore' || !product && !table && (keys || query)) {
+            if (!keys && !Array.isArray(query)) {
+                closeClient();
+                throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
+            }
+            if (cached && (rows = getCache(queryString = Module.asString(keys || query, true) + Module.asString(item.options, true) + limit))) {
+                result[i] = rows;
+                continue;
+            }
+            const db = createClient(item, 2 /* DB.DATASTORE */);
+            if (keys) {
+                const items = !Array.isArray(keys) ? db.key(keys) : keys.map((key) => db.key(key));
+                rows = await db.get(items, item.options);
+                if (rows.length > limit) {
+                    rows = rows.slice(0, limit);
+                }
+            }
+            else {
+                const task = db.createQuery(item.kind);
+                for (const args of query) {
+                    if ((0, types_1.isArray)(args)) {
+                        const method = args[0];
+                        switch (method) {
+                            case 'end':
+                            case 'filter':
+                            case 'groupBy':
+                            case 'hasAncestor':
+                            case 'limit':
+                            case 'offset':
+                            case 'order':
+                            case 'select':
+                            case 'start':
+                                task[method].apply(task, args.slice(1)); // eslint-disable-line prefer-spread
+                                break;
+                        }
+                    }
+                }
+                if (limit > 0) {
+                    task.limit(limit);
+                }
+                [rows] = await db.runQuery(task, item.options);
+            }
+        }
+        else if (product === 'firestore' || !product && table) {
+            if (!table) {
+                closeClient();
+                throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+            }
+            if (cached) {
+                queryString = table + '_';
+            }
+            if (id) {
+                if (cached) {
+                    queryString += id;
+                    if (!update && (rows = getCache(queryString))) {
+                        result[i] = rows;
+                        continue;
+                    }
+                }
+                const db = createClient(item, 3 /* DB.FIRESTORE */).collection(table).doc(id);
+                if ((0, types_1.isPlainObject)(update)) {
+                    await db.update(update, { exists: true });
+                }
+                const data = (await db.get()).data();
+                if (data) {
+                    rows = [data];
+                }
+            }
+            else if (Array.isArray(query)) {
+                if (cached && (rows = getCache(queryString += Module.asString(query, true) + Module.asString(orderBy, true) + limit))) {
+                    result[i] = rows;
+                    continue;
+                }
+                let db = createClient(item, 3 /* DB.FIRESTORE */).collection(table);
+                for (const args of query) {
+                    if ((0, types_1.isArray)(args)) {
+                        const method = args[0];
+                        switch (method) {
+                            case 'endAt':
+                            case 'endBefore':
+                            case 'limit':
+                            case 'limitToLast':
+                            case 'offset':
+                            case 'orderBy':
+                            case 'select':
+                            case 'startAfter':
+                            case 'startAt':
+                            case 'where':
+                            case 'withConverter':
+                                db = db[method].apply(db, args.slice(1)); // eslint-disable-line prefer-spread
+                                break;
+                        }
+                    }
+                }
+                if ((0, types_1.isArray)(orderBy)) {
+                    for (const order of orderBy) {
+                        if ((0, types_1.isArray)(order)) {
+                            db = db.orderBy(order[0], order[1]);
+                        }
+                    }
+                }
+                if (limit > 0) {
+                    db = db.limit(limit);
+                }
+                rows = (await db.get()).docs.map(doc => doc.data());
+            }
+            else {
+                closeClient();
+                throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
+            }
+        }
+        else {
+            closeClient();
+            throw (0, util_1.formatError)(item, "Missing database product" /* ERR_DB.PRODUCT */);
+        }
+        result[i] = this.setQueryResult(service, credential, queryString, rows, cacheValue);
+    }
+    closeClient();
+    return result;
+}
+exports.executeBatchQuery = executeBatchQuery;
+function setPublicRead(acl, pathname, requested, service = 'gcp') {
+    acl.add({ entity: 'allUsers', role: 'READER' })
+        .then(() => {
+        if (requested) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Grant public-read" /* VAL_CLOUD.PUBLIC_READ */, pathname, { ...Cloud.LOG_CLOUD_COMMAND });
+        }
+    })
+        .catch(err => {
+        if (requested) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Unable to grant public-read" /* ERR_CLOUD.PUBLIC_READ */, pathname], err, { ...Cloud.LOG_CLOUD_WARN });
+        }
+    });
+}
+exports.setPublicRead = setPublicRead;
+async function setPredefinedAcl(target, value, bucket, pathname = '', metadata = {}, requested = true, service = 'gcp') {
+    let revoke;
+    if (metadata === true) {
+        revoke = true;
+        metadata = {};
+    }
+    let items;
+    switch (value) {
+        case 'publicRead':
+            items = [{ entity: 'allUsers', role: revoke ? undefined : 'READER' }];
+            break;
+        case 'authenticatedRead':
+            items = [{ entity: 'allUsers' }, { entity: 'allAuthenticatedUsers', role: revoke ? undefined : 'READER' }];
+            break;
+        default: {
+            const owner = metadata.owner?.entity;
+            let acl = metadata.acl;
+            if ((0, types_1.isArray)(acl)) {
+                items = [];
+            }
+            else {
+                if (bucket) {
+                    const [users] = await bucket.acl.get().catch(() => [[]]);
+                    acl = Array.isArray(users) ? users : [users];
+                }
+                else {
+                    acl = [];
+                }
+                items = [{ entity: 'allUsers' }, { entity: 'allAuthenticatedUsers' }];
+            }
+            switch (value) {
+                case 'private': {
+                    const owners = new Set(acl.filter(item => item.role === 'OWNER').map(item => item.entity));
+                    if (owner) {
+                        owners.add(owner);
+                    }
+                    if (owners.size) {
+                        for (const user of acl) {
+                            const entity = user.entity;
+                            if (!owners.has(entity)) {
+                                items.push({ entity });
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'projectPrivate':
+                    for (const user of acl) {
+                        const entity = user.entity;
+                        if (entity.startsWith('project-')) {
+                            items.push({ ...user, role: entity.startsWith('project-editors-') || entity.startsWith('project-owners-') ? 'OWNER' : 'READER' });
+                        }
+                        else {
+                            items.push({ ...user, role: undefined });
+                        }
+                    }
+                    break;
+                case 'bucketOwnerRead':
+                    if (bucket && owner) {
+                        for (const user of acl) {
+                            if (user.entity !== owner) {
+                                items.push({ entity: user.entity, role: 'READER' });
+                            }
+                        }
+                    }
+                case 'bucketOwnerFullControl':
+                    if (bucket && owner) {
+                        items.push({ entity: owner, role: 'OWNER' });
+                    }
+                    break;
+                default:
+                    return Promise.resolve();
+            }
+        }
+    }
+    return updatePredefinedAcl(target, items, metadata).then(errors => {
+        if (errors.length) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [`Unable to ${revoke ? 'revoke' : 'grant'} ` + value, bucket && pathname ? bucket.name + '/' + pathname : bucket ? bucket.name : pathname], errors[0], { ...Cloud.LOG_CLOUD_WARN });
+        }
+        else if (requested && (bucket || pathname)) {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [(revoke ? 'Revoke' : 'Grant') + ' ' + value, bucket?.name], pathname, { ...Cloud.LOG_CLOUD_COMMAND });
+        }
+    });
+}
+exports.setPredefinedAcl = setPredefinedAcl;
+function createBucketRequest(credential) {
+    const options = {};
+    for (const attr in credential) {
+        switch (attr) {
+            case 'archive':
+            case 'coldline':
+            case 'cors':
+            case 'customPlacementConfig':
+            case 'dra':
+            case 'location':
+            case 'multiRegional':
+            case 'nearline':
+            case 'regional':
+            case 'requesterPays':
+            case 'retentionPolicy':
+            case 'rpo':
+            case 'standard':
+            case 'storageClass':
+            case 'userProject':
+            case 'versioning':
+                options[attr] = credential[attr];
+                break;
+        }
+    }
+    return options;
+}
+exports.createBucketRequest = createBucketRequest;
+function getProjectId(credential) {
+    try {
+        let pathname = credential.keyFilename || credential.keyFile;
+        if (pathname && Module.isPath(pathname = path.resolve(pathname)) || (pathname = process.env.GOOGLE_APPLICATION_CREDENTIALS) && Module.isPath(pathname = path.resolve(pathname))) {
+            const projectId = require(pathname).project_id;
+            if ((0, types_1.isString)(projectId)) {
+                return projectId;
+            }
+        }
+    }
+    catch {
+    }
+    return '';
+}
+exports.getProjectId = getProjectId;

package/download/index.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const https = require("https");
+const client_1 = require("../client");
+const types_1 = require("@e-mc/types");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+function download(credential, service = 'gcp') {
+    const storage = client_1.createStorageClient.call(this, credential);
+    return (data, callback) => {
+        const { bucket: Bucket, download: target } = data;
+        const Key = target.filename;
+        const firebase = (0, client_1.isFirebaseApp)(credential, true, true);
+        let tempDir;
+        const downloadResponse = (err, url) => {
+            callback(err, url);
+            if (tempDir) {
+                queueMicrotask(() => Module.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.joinPath(Bucket, Key);
+        const destination = path.join(tempDir, path.basename(Key));
+        const deleteMessage = () => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Delete success" /* VAL_CLOUD.DELETE_FILE */, location, { ...Cloud.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, { ...Cloud.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, { ...Cloud.LOG_CLOUD_FAIL, fatal: !!target.active });
+                        }
+                    });
+                }
+            })
+                .catch(err => downloadResponse(err));
+        }
+    };
+}
+
+module.exports = download;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@pi-r/gcp",
+  "version": "0.0.1",
+  "description": "Google (GCP) cloud functions for E-mc.",
+  "main": "client/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/pi-r.git",
+    "directory": "src/cloud/gcp"
+  },
+  "keywords": [
+    "squared",
+    "e-mc",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/anpham6/pi-r#readme",
+  "dependencies": {
+    "@e-mc/cloud": "^0.4.0",
+    "@e-mc/module": "^0.4.0",
+    "@e-mc/types": "^0.4.0",
+    "@google-cloud/firestore": "^6.5.0",
+    "@google-cloud/storage": "^6.9.4"
+  }
+}

package/upload/index.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const client_1 = require("../client");
+const util_1 = require("@e-mc/cloud/util");
+const types_1 = require("@e-mc/types");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+const BUCKET_SESSION = new Set();
+const BUCKET_RESPONSE = {};
+const getBucketKey = (credential, bucket, acl = '') => Module.asString(credential, true) + bucket + '_' + acl;
+function upload(credential, service = 'gcp') {
+    const storage = client_1.createStorageClient.call(this, credential);
+    return async (data, callback) => {
+        var _a;
+        const firebase = (0, client_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] = client_1.createBucketV2.call(this, credential, bucket, bucketAcl, admin.configBucket?.create || (0, client_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.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" /* VAL_CLOUD.RENAME_FILE */, current], filename, { ...Cloud.LOG_CLOUD_WARN });
+            }
+        }
+        const Key = [filename];
+        const Body = [data.buffer];
+        const ContentType = [contentType];
+        const getURL = (value) => endpoint ? Module.joinPath(endpoint, value) : Module.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.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" /* VAL_CLOUD.UPLOAD_FILE */, url, { ...Cloud.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.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" /* VAL_CLOUD.UPLOAD_FILE */, url, { ...Cloud.LOG_CLOUD_UPLOAD });
+                        if (first) {
+                            uploadResponse(null, url);
+                        }
+                        if (ACL) {
+                            client_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.removeDir(tempDir));
+                    }
+                });
+            }
+        }
+    };
+}
+
+module.exports = upload;