@e-mc/cloud 0.0.1 → 0.0.3

package/gcp/index.js

@@ -1,801 +0,0 @@
-"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("../util");
-const types_1 = require("../../types");
-const module_1 = require("../../module");
-const index_1 = require("../index");
-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.query && !data.table) {
-                const { BigQuery } = require(packageName = '@google-cloud/bigquery');
-                return new BigQuery(credential);
-            }
-            if (product === 'datastore' || !product && data.keys) {
-                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" /* CMD_CLOUD.CREATE_BUCKET */, bucket], '', { ...index_1.default.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, { ...index_1.default.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 */), { ...index_1.default.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_1.default.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], { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
-        return false;
-    }
-    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket ACL configured" /* CMD_CLOUD.ACL_BUCKET */, bucket], (0, types_1.isString)(acl) ? acl : '', { ...index_1.default.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" /* CMD_CLOUD.CONFIGURE_BUCKET */, bucket], website, { ...index_1.default.LOG_CLOUD_COMMAND });
-        return true;
-    })
-        .catch(err => {
-        this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to configure bucket" /* ERR_CLOUD.CONFIGURE_BUCKET */, bucket], err, { ...index_1.default.LOG_CLOUD_FAIL, fatal: false });
-        return false;
-    });
-}
-exports.setBucketWebsite = setBucketWebsite;
-function deleteObjects(credential, Bucket, service) {
-    return deleteObjectsV2.call(this, credential, Bucket, true, service);
-}
-exports.deleteObjects = deleteObjects;
-async function deleteObjectsV2(credential, bucket, recursive = true, service = '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_1.default.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" /* CMD_CLOUD.EMPTY_BUCKET */ + ' (recursive)', bucket, { ...index_1.default.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, { ...index_1.default.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], { ...index_1.default.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" /* CMD_CLOUD.EMPTY_BUCKET */ + ` (${recursive ? 'recursive' : files})`, bucket], recursive ? files : '', { ...index_1.default.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_1.default.asString(columns, true) : '') : '') + module_1.default.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_1.default.asString(columns, true) : '') + module_1.default.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 && query) {
-            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_1.default.asString(orderBy, true) : module_1.default.asString(item.params, true) + module_1.default.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 (!Array.isArray(items)) {
-                            continue;
-                        }
-                        const method = items[0];
-                        const args = items.slice(1);
-                        switch (typeof method === 'string' && method.toLowerCase()) {
-                            case 'orderbychild':
-                                constraints.push(sort.orderByChild(args[0]));
-                                break;
-                            case 'orderbykey':
-                                constraints.push(sort.orderByKey());
-                                break;
-                            case 'orderbyvalue':
-                                constraints.push(sort.orderByValue());
-                                break;
-                            case 'limittofirst':
-                                constraints.push(sort.limitToFirst(limiter = +args[0]));
-                                break;
-                            case 'limittolast':
-                                constraints.push(sort.limitToLast(limiter = +args[0]));
-                                break;
-                            case 'startat':
-                                constraints.push(sort.startAt(args[0], args[1]));
-                                break;
-                            case 'startafter':
-                                constraints.push(sort.startAfter(args[0], args[1]));
-                                break;
-                            case 'endat':
-                                constraints.push(sort.endAt(args[0], args[1]));
-                                break;
-                            case 'endbefore':
-                                constraints.push(sort.endBefore(args[0], args[1]));
-                                break;
-                            case 'equalto':
-                                constraints.push(sort.equalTo(args[0], args[1]));
-                                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 && keys) {
-            if (!keys) {
-                closeClient();
-                throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
-            }
-            if (cached && (rows = getCache(queryString = module_1.default.asString(keys, true) + module_1.default.asString(item.options, true) + limit))) {
-                result[i] = rows;
-                continue;
-            }
-            const db = createClient(item, 2 /* DB.DATASTORE */);
-            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 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_1.default.asString(query, true) + module_1.default.asString(orderBy, true) + limit))) {
-                    result[i] = rows;
-                    continue;
-                }
-                let db = createClient(item, 3 /* DB.FIRESTORE */).collection(table);
-                for (const where of query) {
-                    if (where.length === 3) {
-                        db = db.where(where[0], where[1], where[2]);
-                    }
-                }
-                if (Array.isArray(orderBy)) {
-                    for (const order of orderBy) {
-                        if (Array.isArray(order) && typeof order[0] === 'string') {
-                            db = db.orderBy(order[0], order[1] === 'desc' || order[1] === 'asc' ? order[1] : undefined);
-                        }
-                    }
-                }
-                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" /* CMD_CLOUD.PUBLIC_READ */, pathname, { ...index_1.default.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, { ...index_1.default.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], { ...index_1.default.LOG_CLOUD_WARN });
-        }
-        else if (requested && (bucket || pathname)) {
-            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [(revoke ? 'Revoke' : 'Grant') + ' ' + value, bucket?.name], pathname, { ...index_1.default.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_1.default.isPath(pathname = path.resolve(pathname)) || (pathname = process.env.GOOGLE_APPLICATION_CREDENTIALS) && module_1.default.isPath(pathname = path.resolve(pathname))) {
-            const projectId = require(pathname).project_id;
-            if ((0, types_1.isString)(projectId)) {
-                return projectId;
-            }
-        }
-    }
-    catch {
-    }
-    return '';
-}
-exports.getProjectId = getProjectId;