firebase-tools/lib/extensions/export.js

Command-Line Interface for Firebase

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parameterizeProject = parameterizeProject;
exports.setSecretParamsToLatest = setSecretParamsToLatest;
exports.displayExportInfo = displayExportInfo;
exports.functionsEnvFromInstance = functionsEnvFromInstance;
exports.ejectSecretsFromInstance = ejectSecretsFromInstance;
const planner_1 = require("../deploy/extensions/planner");
const deploymentSummary_1 = require("../deploy/extensions/deploymentSummary");
const logger_1 = require("../logger");
const secretManager_1 = require("../gcp/secretManager");
const secretsUtils_1 = require("./secretsUtils");
const secrets_1 = require("../deploy/extensions/secrets");
const error_1 = require("../error");
function parameterizeProject(projectId, projectNumber, spec) {
    const newParams = {};
    for (const [key, val] of Object.entries(spec.params)) {
        const p1 = val.replace(projectId, "${param:PROJECT_ID}");
        const p2 = p1.replace(projectNumber, "${param:PROJECT_NUMBER}");
        newParams[key] = p2;
    }
    const newSpec = { ...spec };
    newSpec.params = newParams;
    return newSpec;
}
async function setSecretParamsToLatest(spec) {
    const newParams = { ...spec.params };
    const extensionVersion = await (0, planner_1.getExtensionVersion)(spec);
    const activeSecrets = (0, secretsUtils_1.getActiveSecrets)(extensionVersion.spec, newParams);
    for (const [key, val] of Object.entries(newParams)) {
        if (activeSecrets.includes(val)) {
            const parsed = (0, secretManager_1.parseSecretVersionResourceName)(val);
            parsed.versionId = "latest";
            newParams[key] = (0, secretManager_1.toSecretVersionResourceName)(parsed);
        }
    }
    return { ...spec, params: newParams };
}
function displayExportInfo(withRef, withoutRef) {
    logger_1.logger.info("The following Extension instances will be saved locally:");
    logger_1.logger.info("");
    displaySpecs(withRef);
    if (withoutRef.length) {
        logger_1.logger.info(`Your project also has the following instances installed from local sources. These will not be saved to firebase.json:`);
        for (const spec of withoutRef) {
            logger_1.logger.info(spec.instanceId);
        }
    }
}
function displaySpecs(specs) {
    for (let i = 0; i < specs.length; i++) {
        const spec = specs[i];
        logger_1.logger.info(`${i + 1}. ${(0, deploymentSummary_1.humanReadable)(spec)}`);
        logger_1.logger.info(`Configuration will be written to 'extensions/${spec.instanceId}.env'`);
        for (const p of Object.entries(spec.params)) {
            logger_1.logger.info(`\t${p[0]}=${p[1]}`);
        }
        if (spec.allowedEventTypes?.length) {
            logger_1.logger.info(`\tALLOWED_EVENTS=${spec.allowedEventTypes}`);
        }
        if (spec.eventarcChannel) {
            logger_1.logger.info(`\tEVENTARC_CHANNEL=${spec.eventarcChannel}`);
        }
        logger_1.logger.info("");
    }
}
function functionsEnvFromInstance(instance) {
    const liveParams = instance.config?.params || {};
    const liveSystemParams = instance.config?.systemParams || {};
    const specParams = instance.config?.source?.spec?.params || {};
    const specSystemParams = instance.config?.source?.spec?.systemParams || {};
    const envs = {};
    specParams.forEach((specParam) => {
        if (specParam.type === "SECRET") {
            const renamed = "FIREBASE_SECRET_REF_" + specParam.param;
            envs[renamed] = liveParams[specParam.param];
        }
        else if (specParam.param in liveParams) {
            envs[specParam.param] = liveParams[specParam.param];
        }
        else {
            envs[specParam.param] = specParam.default ?? "";
        }
    });
    for (const [sysParamName, sysParamValue] of Object.entries(liveSystemParams)) {
        let renamed = sysParamName
            .replace(/^firebaseextensions\.v1beta\.(v2)?function\//, "EXT_MIGRATED_SYSTEM_")
            .toUpperCase();
        if (renamed === "EXT_MIGRATED_SYSTEM_LOCATION") {
            renamed = "DEFAULT_FUNCTION_REGION";
        }
        envs[renamed] = sysParamValue;
    }
    for (const specSystemParam of Object.values(specSystemParams)) {
        if (specSystemParam.param in liveSystemParams) {
            continue;
        }
        if ("default" in specSystemParam) {
            const renamed = specSystemParam.param
                .replace(/^firebaseextensions\.v1beta\.(v2)?function\//, "EXT_MIGRATED_SYSTEM_")
                .toUpperCase();
            envs[renamed] = specSystemParam.default ?? "";
        }
    }
    if (typeof instance.config.allowedEventTypes !== "undefined") {
        envs["EXT_SELECTED_EVENTS"] = instance.config.allowedEventTypes.toString();
    }
    if (typeof instance.config.eventarcChannel !== "undefined") {
        envs["EVENTARC_CHANNEL"] = instance.config.eventarcChannel;
    }
    return envs;
}
async function ejectSecretsFromInstance(instance) {
    const secretsChanged = [];
    const liveParams = instance.config?.params || {};
    for (const specParam of instance.config?.source?.spec?.params ?? []) {
        if (specParam.type !== "SECRET") {
            continue;
        }
        const secretName = specParam.param;
        const resourceName = liveParams[secretName];
        if (!resourceName) {
            throw new error_1.FirebaseError(`Secret ${secretName} was defined in the extension spec, but is missing in live deployed secrets.`, { exit: 1 });
        }
        const match = resourceName.match(secretManager_1.SECRET_VERSION_NAME_REGEX);
        if (!match?.groups) {
            throw new error_1.FirebaseError(`Invalid secret version resource name [${resourceName}].`);
        }
        const projectId = match.groups.project;
        const secretId = match.groups.secret;
        await (0, secrets_1.transferSecretToKits)(projectId, secretId);
        secretsChanged.push(`${projectId}/${secretId}`);
    }
    return secretsChanged;
}