firebase-tools 9.19.0 → 9.20.0

package/lib/functions/runtimeConfigExport.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDotenvFilename = exports.toDotenvFormat = exports.hydrateEnvs = exports.configToEnv = exports.convertKey = exports.hydrateConfigs = exports.getProjectInfos = void 0;
+const clc = require("cli-color");
+const env = require("./env");
+const functionsConfig = require("../functionsConfig");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+const projectUtils_1 = require("../projectUtils");
+const rc_1 = require("../rc");
+const utils_1 = require("../utils");
+const functional_1 = require("../functional");
+function getProjectInfos(options) {
+    const result = {};
+    const rc = rc_1.loadRC(options);
+    if (rc.projects) {
+        for (const [alias, projectId] of Object.entries(rc.projects)) {
+            if (Object.keys(result).includes(projectId)) {
+                utils_1.logWarning(`Multiple aliases found for ${clc.bold(projectId)}. ` +
+                    `Preferring alias (${clc.bold(result[projectId])}) over (${clc.bold(alias)}).`);
+                continue;
+            }
+            result[projectId] = alias;
+        }
+    }
+    const projectId = projectUtils_1.getProjectId(options);
+    if (projectId && !Object.keys(result).includes(projectId)) {
+        result[projectId] = projectId;
+    }
+    return Object.entries(result).map(([k, v]) => {
+        const result = { projectId: k };
+        if (k !== v) {
+            result.alias = v;
+        }
+        return result;
+    });
+}
+exports.getProjectInfos = getProjectInfos;
+async function hydrateConfigs(pInfos) {
+    const hydrate = pInfos.map((info) => {
+        return functionsConfig
+            .materializeAll(info.projectId)
+            .then((config) => {
+            info.config = config;
+            return;
+        })
+            .catch((err) => {
+            logger_1.logger.debug(`Failed to fetch runtime config for project ${info.projectId}: ${err.message}`);
+        });
+    });
+    await Promise.all(hydrate);
+}
+exports.hydrateConfigs = hydrateConfigs;
+function convertKey(configKey, prefix) {
+    const baseKey = configKey
+        .toUpperCase()
+        .replace(/\./g, "_")
+        .replace(/-/g, "_");
+    let envKey = baseKey;
+    try {
+        env.validateKey(envKey);
+    }
+    catch (err) {
+        if (err instanceof env.KeyValidationError) {
+            envKey = prefix + envKey;
+            env.validateKey(envKey);
+        }
+    }
+    return envKey;
+}
+exports.convertKey = convertKey;
+function configToEnv(configs, prefix) {
+    const success = [];
+    const errors = [];
+    for (const [configKey, value] of functional_1.flatten(configs)) {
+        try {
+            const envKey = convertKey(configKey, prefix);
+            success.push({ origKey: configKey, newKey: envKey, value: value });
+        }
+        catch (err) {
+            if (err instanceof env.KeyValidationError) {
+                errors.push({
+                    origKey: configKey,
+                    newKey: err.key,
+                    err: err.message,
+                    value: value,
+                });
+            }
+            else {
+                throw new error_1.FirebaseError("Unexpected error while converting config", {
+                    exit: 2,
+                    original: err,
+                });
+            }
+        }
+    }
+    return { success, errors };
+}
+exports.configToEnv = configToEnv;
+function hydrateEnvs(pInfos, prefix) {
+    let errMsg = "";
+    for (const pInfo of pInfos) {
+        const { success, errors } = configToEnv(pInfo.config, prefix);
+        if (errors.length > 0) {
+            const msg = `${pInfo.projectId} ` +
+                `${pInfo.alias ? "(" + pInfo.alias + ")" : ""}:\n` +
+                errors.map((err) => `\t${err.origKey} => ${clc.bold(err.newKey)} (${err.err})`).join("\n") +
+                "\n";
+            errMsg += msg;
+        }
+        else {
+            pInfo.envs = success;
+        }
+    }
+    return errMsg;
+}
+exports.hydrateEnvs = hydrateEnvs;
+function escape(s) {
+    const result = s
+        .replace("\n", "\\n")
+        .replace("\r", "\\r")
+        .replace("\t", "\\t")
+        .replace("\v", "\\v");
+    return result.replace(/(['"])/g, "\\$1");
+}
+function toDotenvFormat(envs, header = "") {
+    const lines = envs.map(({ newKey, value }) => `${newKey}="${escape(value)}"`);
+    const maxLineLen = Math.max(...lines.map((l) => l.length));
+    return (`${header}\n` +
+        lines.map((line, idx) => `${line.padEnd(maxLineLen)} # from ${envs[idx].origKey}`).join("\n"));
+}
+exports.toDotenvFormat = toDotenvFormat;
+function generateDotenvFilename(pInfo) {
+    var _a;
+    return `.env.${(_a = pInfo.alias) !== null && _a !== void 0 ? _a : pInfo.projectId}`;
+}
+exports.generateDotenvFilename = generateDotenvFilename;

package/lib/gcp/cloudfunctions.js

@@ -198,9 +198,11 @@ async function list(projectId, region) {
         };
     }
     catch (err) {
-        logger_1.logger.debug("[functions] failed to list functions for " + projectId);
+        logger_1.logger.debug(`[functions] failed to list functions for ${projectId}`);
         logger_1.logger.debug(`[functions] ${err === null || err === void 0 ? void 0 : err.message}`);
-        return Promise.reject(err === null || err === void 0 ? void 0 : err.message);
+        throw new error_1.FirebaseError(`Failed to list functions for ${projectId}`, {
+            original: err,
+        });
     }
 }
 async function listFunctions(projectId, region) {

package/lib/gcp/cloudfunctionsv2.js

@@ -143,6 +143,9 @@ function functionFromSpec(cloudFunction, source) {
         gcfFunction.eventTrigger = {
             eventType: cloudFunction.trigger.eventType,
         };
+        if (cloudFunction.trigger.region) {
+            gcfFunction.eventTrigger.triggerRegion = cloudFunction.trigger.region;
+        }
         if (gcfFunction.eventTrigger.eventType === exports.PUBSUB_PUBLISH_EVENT) {
             gcfFunction.eventTrigger.pubsubTopic = cloudFunction.trigger.eventFilters.resource;
         }
@@ -169,6 +172,9 @@ function specFromFunction(gcfFunction) {
             eventFilters: {},
             retry: false,
         };
+        if (gcfFunction.eventTrigger.triggerRegion) {
+            trigger.region = gcfFunction.eventTrigger.triggerRegion;
+        }
         if (gcfFunction.eventTrigger.pubsubTopic) {
             trigger.eventFilters.resource = gcfFunction.eventTrigger.pubsubTopic;
         }

package/lib/gcp/secretManager.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grantServiceAgentRole = exports.addVersion = exports.createSecret = exports.parseSecretResourceName = exports.secretExists = exports.getSecretLabels = exports.getSecret = exports.listSecrets = void 0;
+const api = require("../api");
+async function listSecrets(projectId) {
+    const listRes = await api.request("GET", `/v1beta1/projects/${projectId}/secrets`, {
+        auth: true,
+        origin: api.secretManagerOrigin,
+    });
+    return listRes.body.secrets.map((s) => parseSecretResourceName(s.name));
+}
+exports.listSecrets = listSecrets;
+async function getSecret(projectId, name) {
+    const getRes = await api.request("GET", `/v1beta1/projects/${projectId}/secrets/${name}`, {
+        auth: true,
+        origin: api.secretManagerOrigin,
+    });
+    return parseSecretResourceName(getRes.body.name);
+}
+exports.getSecret = getSecret;
+async function getSecretLabels(projectId, name) {
+    const getRes = await api.request("GET", `/v1beta1/projects/${projectId}/secrets/${name}`, {
+        auth: true,
+        origin: api.secretManagerOrigin,
+    });
+    return getRes.body.labels;
+}
+exports.getSecretLabels = getSecretLabels;
+async function secretExists(projectId, name) {
+    try {
+        await getSecret(projectId, name);
+        return true;
+    }
+    catch (err) {
+        if (err.status === 404) {
+            return false;
+        }
+        throw err;
+    }
+}
+exports.secretExists = secretExists;
+function parseSecretResourceName(resourceName) {
+    const nameTokens = resourceName.split("/");
+    return {
+        projectId: nameTokens[1],
+        name: nameTokens[3],
+    };
+}
+exports.parseSecretResourceName = parseSecretResourceName;
+async function createSecret(projectId, name, labels) {
+    const createRes = await api.request("POST", `/v1beta1/projects/${projectId}/secrets?secretId=${name}`, {
+        auth: true,
+        origin: api.secretManagerOrigin,
+        data: {
+            replication: {
+                automatic: {},
+            },
+            labels,
+        },
+    });
+    return parseSecretResourceName(createRes.body.name);
+}
+exports.createSecret = createSecret;
+async function addVersion(secret, payloadData) {
+    const res = await api.request("POST", `/v1beta1/projects/${secret.projectId}/secrets/${secret.name}:addVersion`, {
+        auth: true,
+        origin: api.secretManagerOrigin,
+        data: {
+            payload: {
+                data: Buffer.from(payloadData).toString("base64"),
+            },
+        },
+    });
+    const nameTokens = res.body.name.split("/");
+    return {
+        secret: {
+            projectId: nameTokens[1],
+            name: nameTokens[3],
+        },
+        versionId: nameTokens[5],
+    };
+}
+exports.addVersion = addVersion;
+async function grantServiceAgentRole(secret, serviceAccountEmail, role) {
+    const getPolicyRes = await api.request("GET", `/v1beta1/projects/${secret.projectId}/secrets/${secret.name}:getIamPolicy`, {
+        auth: true,
+        origin: api.secretManagerOrigin,
+    });
+    const bindings = getPolicyRes.body.bindings || [];
+    if (bindings.find((b) => b.role == role &&
+        b.members.find((m) => m == `serviceAccount:${serviceAccountEmail}`))) {
+        return;
+    }
+    bindings.push({
+        role: role,
+        members: [`serviceAccount:${serviceAccountEmail}`],
+    });
+    await api.request("POST", `/v1beta1/projects/${secret.projectId}/secrets/${secret.name}:setIamPolicy`, {
+        auth: true,
+        origin: api.secretManagerOrigin,
+        data: {
+            policy: {
+                bindings,
+            },
+            updateMask: {
+                paths: "bindings",
+            },
+        },
+    });
+}
+exports.grantServiceAgentRole = grantServiceAgentRole;

package/lib/gcp/storage.js

@@ -61,9 +61,25 @@ function _deleteObject(location) {
         origin: api.storageOrigin,
     });
 }
+async function _getBucket(bucketName) {
+    try {
+        const result = await api.request("GET", `/storage/v1/b/${bucketName}`, {
+            auth: true,
+            origin: api.storageOrigin,
+        });
+        return result.body;
+    }
+    catch (err) {
+        logger.debug(err);
+        throw new FirebaseError("Failed to obtain the storage bucket", {
+            original: err,
+        });
+    }
+}
 module.exports = {
     getDefaultBucket: _getDefaultBucket,
     deleteObject: _deleteObject,
     upload: _uploadSource,
     uploadObject: _uploadObject,
+    getBucket: _getBucket,
 };

package/lib/previews.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.previews = void 0;
 const lodash_1 = require("lodash");
 const configstore_1 = require("./configstore");
-exports.previews = Object.assign({ rtdbrules: false, ext: false, extdev: false, rtdbmanagement: false, functionsv2: false, golang: false, deletegcfartifacts: false, dotenv: false }, configstore_1.configstore.get("previews"));
+exports.previews = Object.assign({ rtdbrules: false, ext: false, extdev: false, rtdbmanagement: false, functionsv2: false, golang: false, deletegcfartifacts: false, dotenv: false, crashlyticsSymbolsUpload: false }, configstore_1.configstore.get("previews"));
 if (process.env.FIREBASE_CLI_PREVIEWS) {
     process.env.FIREBASE_CLI_PREVIEWS.split(",").forEach((feature) => {
         if (lodash_1.has(exports.previews, feature)) {

package/lib/requireInteractive.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = require("./error");
+function requireInteractive(options) {
+    if (options.nonInteractive) {
+        return Promise.reject(new error_1.FirebaseError("This command cannot run in non-interactive mode", {
+            exit: 1,
+        }));
+    }
+    return Promise.resolve();
+}
+exports.default = requireInteractive;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "9.19.0",
+  "version": "9.20.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {