firebase-tools 9.19.0 → 9.23.0

package/lib/commands/functions-config-export.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const clc = require("cli-color");
+const requireInteractive_1 = require("../requireInteractive");
+const command_1 = require("../command");
+const error_1 = require("../error");
+const iam_1 = require("../gcp/iam");
+const logger_1 = require("../logger");
+const prompt_1 = require("../prompt");
+const requirePermissions_1 = require("../requirePermissions");
+const utils_1 = require("../utils");
+const functional_1 = require("../functional");
+const configExport = require("../functions/runtimeConfigExport");
+const requireConfig = require("../requireConfig");
+const REQUIRED_PERMISSIONS = [
+    "runtimeconfig.configs.list",
+    "runtimeconfig.configs.get",
+    "runtimeconfig.variables.list",
+    "runtimeconfig.variables.get",
+];
+const RESERVED_PROJECT_ALIAS = ["local"];
+const MAX_ATTEMPTS = 3;
+function checkReservedAliases(pInfos) {
+    for (const pInfo of pInfos) {
+        if (pInfo.alias && RESERVED_PROJECT_ALIAS.includes(pInfo.alias)) {
+            utils_1.logWarning(`Project alias (${clc.bold(pInfo.alias)}) is reserved for internal use. ` +
+                `Saving exported config in .env.${pInfo.projectId} instead.`);
+            delete pInfo.alias;
+        }
+    }
+}
+async function checkRequiredPermission(pInfos) {
+    pInfos = pInfos.filter((pInfo) => !pInfo.config);
+    const testPermissions = pInfos.map((pInfo) => iam_1.testIamPermissions(pInfo.projectId, REQUIRED_PERMISSIONS));
+    const results = await Promise.all(testPermissions);
+    for (const [pInfo, result] of functional_1.zip(pInfos, results)) {
+        if (result.passed) {
+            throw new error_1.FirebaseError(`Unexpectedly failed to fetch runtime config for project ${pInfo.projectId}`);
+        }
+        utils_1.logWarning("You are missing the following permissions to read functions config on project " +
+            `${clc.bold(pInfo.projectId)}:\n\t${result.missing.join("\n\t")}`);
+        const confirm = await prompt_1.promptOnce({
+            type: "confirm",
+            name: "skip",
+            default: true,
+            message: `Continue without importing configs from project ${pInfo.projectId}?`,
+        });
+        if (!confirm) {
+            throw new error_1.FirebaseError("Command aborted!");
+        }
+    }
+}
+async function promptForPrefix(errMsg) {
+    utils_1.logWarning("The following configs keys could not be exported as environment variables:\n");
+    utils_1.logWarning(errMsg);
+    return await prompt_1.promptOnce({
+        type: "input",
+        name: "prefix",
+        default: "CONFIG_",
+        message: "Enter a PREFIX to rename invalid environment variable keys:",
+    }, {});
+}
+function fromEntries(itr) {
+    const obj = {};
+    for (const [k, v] of itr) {
+        obj[k] = v;
+    }
+    return obj;
+}
+exports.default = new command_1.Command("functions:config:export")
+    .description("Export environment config as environment variables in dotenv format")
+    .before(requirePermissions_1.requirePermissions, [
+    "runtimeconfig.configs.list",
+    "runtimeconfig.configs.get",
+    "runtimeconfig.variables.list",
+    "runtimeconfig.variables.get",
+])
+    .before(requireConfig)
+    .before(requireInteractive_1.default)
+    .action(async (options) => {
+    let pInfos = configExport.getProjectInfos(options);
+    checkReservedAliases(pInfos);
+    utils_1.logBullet("Importing functions configs from projects [" +
+        pInfos.map(({ projectId }) => `${clc.bold(projectId)}`).join(", ") +
+        "]");
+    await configExport.hydrateConfigs(pInfos);
+    await checkRequiredPermission(pInfos);
+    pInfos = pInfos.filter((pInfo) => pInfo.config);
+    logger_1.logger.debug(`Loaded function configs: ${JSON.stringify(pInfos)}`);
+    utils_1.logBullet(`Importing configs from projects: [${pInfos.map((p) => p.projectId).join(", ")}]`);
+    let attempts = 0;
+    let prefix = "";
+    while (true) {
+        if (attempts >= MAX_ATTEMPTS) {
+            throw new error_1.FirebaseError("Exceeded max attempts to fix invalid config keys.");
+        }
+        const errMsg = configExport.hydrateEnvs(pInfos, prefix);
+        if (errMsg.length == 0) {
+            break;
+        }
+        prefix = await promptForPrefix(errMsg);
+        attempts += 1;
+    }
+    const header = `# Exported firebase functions:config:export command on ${new Date().toLocaleDateString()}`;
+    const dotEnvs = pInfos.map((pInfo) => configExport.toDotenvFormat(pInfo.envs, header));
+    const filenames = pInfos.map(configExport.generateDotenvFilename);
+    const filesToWrite = fromEntries(functional_1.zip(filenames, dotEnvs));
+    filesToWrite[".env.local"] = `${header}\n# .env.local file contains environment variables for the Functions Emulator.\n`;
+    filesToWrite[".env"] = `${header}# .env file contains environment variables that applies to all projects.\n`;
+    const functionsDir = options.config.get("functions.source", ".");
+    for (const [filename, content] of Object.entries(filesToWrite)) {
+        await options.config.askWriteProjectFile(path.join(functionsDir, filename), content);
+    }
+});

package/lib/commands/functions-delete.js

@@ -1,15 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("../command");
 const clc = require("cli-color");
 const functionsConfig = require("../functionsConfig");
-const functionsDelete_1 = require("../functionsDelete");
+const command_1 = require("../command");
+const error_1 = require("../error");
 const projectUtils_1 = require("../projectUtils");
 const prompt_1 = require("../prompt");
-const helper = require("../deploy/functions/functionsDeployHelper");
+const functional_1 = require("../functional");
 const requirePermissions_1 = require("../requirePermissions");
+const helper = require("../deploy/functions/functionsDeployHelper");
 const utils = require("../utils");
 const backend = require("../deploy/functions/backend");
+const planner = require("../deploy/functions/release/planner");
+const fabricator = require("../deploy/functions/release/fabricator");
+const executor = require("../deploy/functions/release/executor");
+const reporter = require("../deploy/functions/release/reporter");
+const containerCleaner = require("../deploy/functions/containerCleaner");
 exports.default = new command_1.Command("functions:delete [filters...]")
     .description("delete one or more Cloud Functions by name or group name.")
     .option("--region <region>", "Specify region of the function to be deleted. " +
@@ -22,35 +28,29 @@ exports.default = new command_1.Command("functions:delete [filters...]")
     }
     const context = {
         projectId: projectUtils_1.needProjectId(options),
+        filters: filters.map((f) => f.split(".")),
     };
-    const filterChunks = filters.map((filter) => {
-        return filter.split(".");
-    });
     const [config, existingBackend] = await Promise.all([
         functionsConfig.getFirebaseConfig(options),
         backend.existingBackend(context),
     ]);
     await backend.checkAvailability(context, backend.empty());
     const appEngineLocation = functionsConfig.getAppEngineLocation(config);
-    const functionsToDelete = existingBackend.cloudFunctions.filter((fn) => {
-        const regionMatches = options.region ? fn.region === options.region : true;
-        const nameMatches = helper.functionMatchesAnyGroup(fn, filterChunks);
-        return regionMatches && nameMatches;
-    });
-    if (functionsToDelete.length === 0) {
-        return utils.reject(`The specified filters do not match any existing functions in project ${clc.bold(context.projectId)}.`, { exit: 1 });
+    if (options.region) {
+        existingBackend.endpoints = { [options.region]: existingBackend.endpoints[options.region] };
     }
-    const schedulesToDelete = existingBackend.schedules.filter((schedule) => {
-        functionsToDelete.some(backend.sameFunctionName(schedule.targetService));
+    const plan = planner.createDeploymentPlan(backend.empty(), existingBackend, {
+        filters: context.filters,
+        deleteAll: true,
     });
-    const topicsToDelete = existingBackend.topics.filter((topic) => {
-        functionsToDelete.some(backend.sameFunctionName(topic.targetService));
-    });
-    const deleteList = functionsToDelete
-        .map((func) => {
-        return "\t" + helper.getFunctionLabel(func);
-    })
-        .join("\n");
+    const allEpToDelete = Object.values(plan)
+        .map((changes) => changes.endpointsToDelete)
+        .reduce(functional_1.reduceFlat, [])
+        .sort(backend.compareFunctions);
+    if (allEpToDelete.length === 0) {
+        throw new error_1.FirebaseError(`The specified filters do not match any existing functions in project ${clc.bold(context.projectId)}.`);
+    }
+    const deleteList = allEpToDelete.map((func) => `\t${helper.getFunctionLabel(func)}`).join("\n");
     const confirmDeletion = await prompt_1.promptOnce({
         type: "confirm",
         name: "force",
@@ -60,7 +60,29 @@ exports.default = new command_1.Command("functions:delete [filters...]")
             "\n  Are you sure?",
     }, options);
     if (!confirmDeletion) {
-        return utils.reject("Command aborted.", { exit: 1 });
+        throw new error_1.FirebaseError("Command aborted.");
+    }
+    const functionExecutor = new executor.QueueExecutor({
+        retries: 30,
+        backoff: 20000,
+        concurrency: 40,
+        maxBackoff: 40000,
+    });
+    try {
+        const fab = new fabricator.Fabricator({
+            functionExecutor,
+            executor: new executor.QueueExecutor({}),
+            appEngineLocation,
+        });
+        const summary = await fab.applyPlan(plan);
+        await reporter.logAndTrackDeployStats(summary);
+        reporter.printErrors(summary);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Failed to delete functions", {
+            original: err,
+            exit: 1,
+        });
     }
-    return await functionsDelete_1.deleteFunctions(functionsToDelete, schedulesToDelete, topicsToDelete, appEngineLocation);
+    await containerCleaner.cleanupBuildImages([], allEpToDelete);
 });

package/lib/commands/functions-list.js

@@ -5,7 +5,6 @@ const error_1 = require("../error");
 const projectUtils_1 = require("../projectUtils");
 const requirePermissions_1 = require("../requirePermissions");
 const backend = require("../deploy/functions/backend");
-const listFunctions_1 = require("../functions/listFunctions");
 const previews_1 = require("../previews");
 const logger_1 = require("../logger");
 const Table = require("cli-table");
@@ -17,7 +16,8 @@ exports.default = new command_1.Command("functions:list")
         const context = {
             projectId: projectUtils_1.needProjectId(options),
         };
-        const functionList = await listFunctions_1.listFunctions(context);
+        const existing = await backend.existingBackend(context);
+        const endpointsList = backend.allEndpoints(existing).sort(backend.compareFunctions);
         const table = previews_1.previews.functionsv2
             ? new Table({
                 head: ["Function", "Version", "Trigger", "Location", "Memory", "Runtime"],
@@ -27,26 +27,26 @@ exports.default = new command_1.Command("functions:list")
                 head: ["Function", "Trigger", "Location", "Memory", "Runtime"],
                 style: { head: ["yellow"] },
             });
-        for (const fnSpec of functionList.functions) {
-            const trigger = backend.isEventTrigger(fnSpec.trigger) ? fnSpec.trigger.eventType : "https";
-            const availableMemoryMb = fnSpec.availableMemoryMb || "---";
+        for (const endpoint of endpointsList) {
+            const trigger = backend.endpointTriggerType(endpoint);
+            const availableMemoryMb = endpoint.availableMemoryMb || "---";
             const entry = previews_1.previews.functionsv2
                 ? [
-                    fnSpec.entryPoint,
-                    fnSpec.platform === "gcfv2" ? "v2" : "v1",
+                    endpoint.id,
+                    endpoint.platform === "gcfv2" ? "v2" : "v1",
                     trigger,
-                    fnSpec.region,
+                    endpoint.region,
                     availableMemoryMb,
-                    fnSpec.runtime,
+                    endpoint.runtime,
                 ]
-                : [fnSpec.entryPoint, trigger, fnSpec.region, availableMemoryMb, fnSpec.runtime];
+                : [endpoint.id, trigger, endpoint.region, availableMemoryMb, endpoint.runtime];
             table.push(entry);
         }
         logger_1.logger.info(table.toString());
-        return functionList;
+        return endpointsList;
     }
     catch (err) {
-        throw new error_1.FirebaseError(`Failed to list functions ${err.message}`, {
+        throw new error_1.FirebaseError("Failed to list functions", {
             exit: 1,
             original: err,
         });

package/lib/commands/index.js

@@ -26,6 +26,9 @@ module.exports = function (client) {
     client.auth = {};
     client.auth.export = loadCommand("auth-export");
     client.auth.upload = loadCommand("auth-import");
+    client.crashlytics = {};
+    client.crashlytics.symbols = {};
+    client.crashlytics.symbols.upload = loadCommand("crashlytics-symbols-upload");
     client.database = {};
     client.database.get = loadCommand("database-get");
     client.database.instances = {};
@@ -58,6 +61,7 @@ module.exports = function (client) {
     client.ext = loadCommand("ext");
     client.ext.configure = loadCommand("ext-configure");
     client.ext.info = loadCommand("ext-info");
+    client.ext.export = loadCommand("ext-export");
     client.ext.install = loadCommand("ext-install");
     client.ext.list = loadCommand("ext-list");
     client.ext.uninstall = loadCommand("ext-uninstall");
@@ -74,6 +78,8 @@ module.exports = function (client) {
         client.ext.dev.emulators = {};
         client.ext.dev.emulators.start = loadCommand("ext-dev-emulators-start");
         client.ext.dev.emulators.exec = loadCommand("ext-dev-emulators-exec");
+        client.ext.dev.deprecate = loadCommand("ext-dev-deprecate");
+        client.ext.dev.undeprecate = loadCommand("ext-dev-undeprecate");
         client.ext.dev.unpublish = loadCommand("ext-dev-unpublish");
         client.ext.dev.publish = loadCommand("ext-dev-publish");
         client.ext.dev.delete = loadCommand("ext-dev-extension-delete");
@@ -84,6 +90,9 @@ module.exports = function (client) {
     client.functions = {};
     client.functions.config = {};
     client.functions.config.clone = loadCommand("functions-config-clone");
+    if (previews.dotenv) {
+        client.functions.config.export = loadCommand("functions-config-export");
+    }
     client.functions.config.get = loadCommand("functions-config-get");
     client.functions.config.set = loadCommand("functions-config-set");
     client.functions.config.unset = loadCommand("functions-config-unset");

package/lib/commands/init.js

@@ -155,6 +155,9 @@ module.exports = new Command("init [feature]")
         if (allAccounts.length > 1) {
             setup.features.unshift("account");
         }
+        if (setup.features.includes("hosting") && setup.features.includes("hosting:github")) {
+            setup.features = setup.features.filter((f) => f != "hosting:github");
+        }
         return init(setup, config, options);
     })
         .then(function () {

package/lib/config.js

@@ -144,10 +144,10 @@ class Config {
         fs.ensureFileSync(this.path(p));
         fs.writeFileSync(this.path(p), content, "utf8");
     }
-    askWriteProjectFile(p, content) {
+    askWriteProjectFile(p, content, force) {
         const writeTo = this.path(p);
         let next;
-        if (fsutils.fileExistsSync(writeTo)) {
+        if (fsutils.fileExistsSync(writeTo) && !force) {
             next = prompt_1.promptOnce({
                 type: "confirm",
                 message: "File " + clc.underline(p) + " already exists. Overwrite?",
@@ -203,6 +203,7 @@ Config.FILENAME = "firebase.json";
 Config.MATERIALIZE_TARGETS = [
     "database",
     "emulators",
+    "extensions",
     "firestore",
     "functions",
     "hosting",

package/lib/deploy/extensions/args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/deploy/extensions/deploy.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = void 0;
+const tasks = require("./tasks");
+const queue_1 = require("../../throttler/queue");
+const error_1 = require("../../error");
+const errors_1 = require("./errors");
+const projectUtils_1 = require("../../projectUtils");
+const provisioningHelper_1 = require("../../extensions/provisioningHelper");
+const secrets_1 = require("./secrets");
+const validate_1 = require("./validate");
+async function deploy(context, options, payload) {
+    var _a, _b, _c, _d, _e, _f;
+    const projectId = projectUtils_1.needProjectId(options);
+    await validate_1.checkBilling(projectId, options.nonInteractive);
+    await provisioningHelper_1.bulkCheckProductsProvisioned(projectId, [
+        ...((_a = payload.instancesToCreate) !== null && _a !== void 0 ? _a : []),
+        ...((_b = payload.instancesToUpdate) !== null && _b !== void 0 ? _b : []),
+        ...((_c = payload.instancesToConfigure) !== null && _c !== void 0 ? _c : []),
+    ]);
+    await secrets_1.handleSecretParams(payload, context.have, options.nonInteractive);
+    const errorHandler = new errors_1.ErrorHandler();
+    const validationQueue = new queue_1.default({
+        retries: 5,
+        concurrency: 5,
+        handler: tasks.extensionsDeploymentHandler(errorHandler),
+    });
+    for (const create of (_d = payload.instancesToCreate) !== null && _d !== void 0 ? _d : []) {
+        const task = tasks.createExtensionInstanceTask(projectId, create, true);
+        void validationQueue.run(task);
+    }
+    for (const update of (_e = payload.instancesToUpdate) !== null && _e !== void 0 ? _e : []) {
+        const task = tasks.updateExtensionInstanceTask(projectId, update, true);
+        void validationQueue.run(task);
+    }
+    for (const configure of (_f = payload.instancesToConfigure) !== null && _f !== void 0 ? _f : []) {
+        const task = tasks.configureExtensionInstanceTask(projectId, configure, true);
+        void validationQueue.run(task);
+    }
+    const validationPromise = validationQueue.wait();
+    validationQueue.process();
+    validationQueue.close();
+    await validationPromise;
+    if (errorHandler.hasErrors()) {
+        errorHandler.print();
+        throw new error_1.FirebaseError(`Extensions deployment failed validation. No changes have been made to the Extension instances on ${projectId}`);
+    }
+}
+exports.deploy = deploy;

package/lib/deploy/extensions/deploymentSummary.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletesSummary = exports.configuresSummary = exports.updatesSummary = exports.createsSummary = exports.humanReadable = void 0;
+const clc = require("cli-color");
+const refs = require("../../extensions/refs");
+exports.humanReadable = (dep) => `${clc.bold(dep.instanceId)} (${dep.ref ? `${refs.toExtensionVersionRef(dep.ref)}` : `Installed from local source`})`;
+const humanReadableUpdate = (from, to) => {
+    var _a, _b, _c, _d, _e;
+    if (((_a = from.ref) === null || _a === void 0 ? void 0 : _a.publisherId) == ((_b = to.ref) === null || _b === void 0 ? void 0 : _b.publisherId) &&
+        ((_c = from.ref) === null || _c === void 0 ? void 0 : _c.extensionId) == ((_d = to.ref) === null || _d === void 0 ? void 0 : _d.extensionId)) {
+        return `\t${clc.bold(from.instanceId)} (${refs.toExtensionVersionRef(from.ref)} => ${(_e = to.ref) === null || _e === void 0 ? void 0 : _e.version})`;
+    }
+    else {
+        const fromRef = from.ref
+            ? `${refs.toExtensionVersionRef(from.ref)}`
+            : `Installed from local source`;
+        return `\t${clc.bold(from.instanceId)} (${fromRef} => ${refs.toExtensionVersionRef(to.ref)})`;
+    }
+};
+function createsSummary(toCreate) {
+    const instancesToCreate = toCreate.map((s) => `\t${exports.humanReadable(s)}`).join("\n");
+    return toCreate.length
+        ? `The following extension instances will be created:\n${instancesToCreate}\n`
+        : "";
+}
+exports.createsSummary = createsSummary;
+function updatesSummary(toUpdate, have) {
+    const instancesToUpdate = toUpdate
+        .map((to) => {
+        const from = have.find((exists) => exists.instanceId == to.instanceId);
+        return humanReadableUpdate(from, to);
+    })
+        .join("\n");
+    return toUpdate.length
+        ? `The following extension instances will be updated:\n${instancesToUpdate}\n`
+        : "";
+}
+exports.updatesSummary = updatesSummary;
+function configuresSummary(toConfigure) {
+    const instancesToConfigure = toConfigure.map((s) => `\t${exports.humanReadable(s)}`).join("\n");
+    return toConfigure.length
+        ? `The following extension instances will be configured:\n${instancesToConfigure}\n`
+        : "";
+}
+exports.configuresSummary = configuresSummary;
+function deletesSummary(toDelete) {
+    const instancesToDelete = toDelete.map((s) => `\t${exports.humanReadable(s)}`).join("\n");
+    return toDelete.length
+        ? `The following extension instances are not listed in 'firebase.json':\n${instancesToDelete}\n`
+        : "";
+}
+exports.deletesSummary = deletesSummary;

package/lib/deploy/extensions/errors.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = void 0;
+const clc = require("cli-color");
+const logger_1 = require("../../logger");
+class ErrorHandler {
+    constructor() {
+        this.errors = [];
+    }
+    record(instanceId, type, message) {
+        this.errors.push({
+            instanceId,
+            type,
+            message: message,
+        });
+    }
+    print() {
+        logger_1.logger.info("");
+        logger_1.logger.info("Extensions deploy had errors:");
+        logger_1.logger.info("");
+        for (const err of this.errors) {
+            logger_1.logger.info(`- ${err.type} ${clc.bold(err.instanceId)}`);
+            logger_1.logger.info(err.message);
+            logger_1.logger.info("");
+        }
+    }
+    hasErrors() {
+        return this.errors.length > 0;
+    }
+}
+exports.ErrorHandler = ErrorHandler;

package/lib/deploy/extensions/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var prepare_1 = require("./prepare");
+Object.defineProperty(exports, "prepare", { enumerable: true, get: function () { return prepare_1.prepare; } });
+var deploy_1 = require("./deploy");
+Object.defineProperty(exports, "deploy", { enumerable: true, get: function () { return deploy_1.deploy; } });
+var release_1 = require("./release");
+Object.defineProperty(exports, "release", { enumerable: true, get: function () { return release_1.release; } });

package/lib/deploy/extensions/params.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readParams = void 0;
+const path = require("path");
+const logger_1 = require("../../logger");
+const paramHelper_1 = require("../../extensions/paramHelper");
+const error_1 = require("../../error");
+const ENV_DIRECTORY = "extensions";
+function readParams(args) {
+    const filesToCheck = [
+        `${args.instanceId}.env`,
+        ...args.aliases.map((alias) => `${args.instanceId}.env.${alias}`),
+        `${args.instanceId}.env.${args.projectNumber}`,
+        `${args.instanceId}.env.${args.projectId}`,
+    ];
+    let noFilesFound = true;
+    const combinedParams = {};
+    for (const fileToCheck of filesToCheck) {
+        try {
+            const params = readParamsFile(args.projectDir, fileToCheck);
+            logger_1.logger.debug(`Successfully read params from ${fileToCheck}`);
+            noFilesFound = false;
+            Object.assign(combinedParams, params);
+        }
+        catch (err) {
+            logger_1.logger.debug(`${err}`);
+        }
+    }
+    if (noFilesFound) {
+        throw new error_1.FirebaseError(`No params file found for ${args.instanceId}`);
+    }
+    return combinedParams;
+}
+exports.readParams = readParams;
+function readParamsFile(projectDir, fileName) {
+    const paramPath = path.join(projectDir, ENV_DIRECTORY, fileName);
+    const params = paramHelper_1.readEnvFile(paramPath);
+    return params;
+}

package/lib/deploy/extensions/planner.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVersion = exports.want = exports.have = exports.getExtension = exports.getExtensionVersion = void 0;
+const semver = require("semver");
+const error_1 = require("../../error");
+const extensionsApi = require("../../extensions/extensionsApi");
+const extensionsHelper_1 = require("../../extensions/extensionsHelper");
+const refs = require("../../extensions/refs");
+const params_1 = require("./params");
+const logger_1 = require("../../logger");
+async function getExtensionVersion(i) {
+    if (!i.extensionVersion) {
+        if (!i.ref) {
+            throw new error_1.FirebaseError(`Can't get ExtensionVersion for ${i.instanceId} because it has no ref`);
+        }
+        i.extensionVersion = await extensionsApi.getExtensionVersion(refs.toExtensionVersionRef(i.ref));
+    }
+    return i.extensionVersion;
+}
+exports.getExtensionVersion = getExtensionVersion;
+async function getExtension(i) {
+    if (!i.ref) {
+        throw new error_1.FirebaseError(`Can't get Extensionfor ${i.instanceId} because it has no ref`);
+    }
+    if (!i.extension) {
+        i.extension = await extensionsApi.getExtension(refs.toExtensionRef(i.ref));
+    }
+    return i.extension;
+}
+exports.getExtension = getExtension;
+async function have(projectId) {
+    const instances = await extensionsApi.listInstances(projectId);
+    return instances.map((i) => {
+        const dep = {
+            instanceId: i.name.split("/").pop(),
+            params: i.config.params,
+        };
+        if (i.config.extensionRef) {
+            const ref = refs.parse(i.config.extensionRef);
+            dep.ref = ref;
+            dep.ref.version = i.config.extensionVersion;
+        }
+        return dep;
+    });
+}
+exports.have = have;
+async function want(args) {
+    const instanceSpecs = [];
+    const errors = [];
+    for (const e of Object.entries(args.extensions)) {
+        try {
+            const instanceId = e[0];
+            const ref = refs.parse(e[1]);
+            ref.version = await resolveVersion(ref);
+            const params = params_1.readParams({
+                projectDir: args.projectDir,
+                instanceId,
+                projectId: args.projectId,
+                projectNumber: args.projectNumber,
+                aliases: args.aliases,
+            });
+            const autoPopulatedParams = await extensionsHelper_1.getFirebaseProjectParams(args.projectId);
+            const subbedParams = extensionsHelper_1.substituteParams(params, autoPopulatedParams);
+            instanceSpecs.push({
+                instanceId,
+                ref,
+                params: subbedParams,
+            });
+        }
+        catch (err) {
+            logger_1.logger.debug(`Got error reading extensions entry ${e}: ${err}`);
+            errors.push(err);
+        }
+    }
+    if (errors.length) {
+        const messages = errors.map((err) => `- ${err.message}`).join("\n");
+        throw new error_1.FirebaseError(`Errors while reading 'extensions' in 'firebase.json'\n${messages}`);
+    }
+    return instanceSpecs;
+}
+exports.want = want;
+async function resolveVersion(ref) {
+    if (!ref.version || ref.version == "latest") {
+        return "latest";
+    }
+    const extensionRef = refs.toExtensionRef(ref);
+    const versions = await extensionsApi.listExtensionVersions(extensionRef);
+    const maxSatisfying = semver.maxSatisfying(versions.map((ev) => ev.spec.version), ref.version);
+    if (!maxSatisfying) {
+        throw new error_1.FirebaseError(`No version of ${extensionRef} matches requested version ${ref.version}`);
+    }
+    return maxSatisfying;
+}
+exports.resolveVersion = resolveVersion;