firebase-tools 13.23.0 → 13.24.0

package/lib/apphosting/backend.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackendForAmbiguousLocation = exports.getBackendForLocation = exports.promptLocation = exports.deleteBackendAndPoll = exports.setDefaultTrafficPolicy = exports.createBackend = exports.ensureAppHostingComputeServiceAccount = exports.createGitRepoLink = exports.doSetup = void 0;
+const clc = require("colorette");
+const poller = require("../operation-poller");
+const apphosting = require("../gcp/apphosting");
+const githubConnections = require("./githubConnections");
+const utils_1 = require("../utils");
+const api_1 = require("../api");
+const apphosting_1 = require("../gcp/apphosting");
+const resourceManager_1 = require("../gcp/resourceManager");
+const iam = require("../gcp/iam");
+const error_1 = require("../error");
+const prompt_1 = require("../prompt");
+const constants_1 = require("./constants");
+const ensureApiEnabled_1 = require("../ensureApiEnabled");
+const deploymentTool = require("../deploymentTool");
+const app_1 = require("./app");
+const ora = require("ora");
+const node_fetch_1 = require("node-fetch");
+const rollout_1 = require("./rollout");
+const DEFAULT_COMPUTE_SERVICE_ACCOUNT_NAME = "firebase-app-hosting-compute";
+const apphostingPollerOptions = {
+    apiOrigin: (0, api_1.apphostingOrigin)(),
+    apiVersion: apphosting_1.API_VERSION,
+    masterTimeout: 25 * 60 * 1000,
+    maxBackoff: 10000,
+};
+async function tlsReady(url) {
+    var _a;
+    try {
+        await (0, node_fetch_1.default)(url);
+        return true;
+    }
+    catch (err) {
+        const maybeNodeError = err;
+        if (/HANDSHAKE_FAILURE/.test((_a = maybeNodeError === null || maybeNodeError === void 0 ? void 0 : maybeNodeError.cause) === null || _a === void 0 ? void 0 : _a.code) ||
+            "EPROTO" === (maybeNodeError === null || maybeNodeError === void 0 ? void 0 : maybeNodeError.code)) {
+            return false;
+        }
+        return true;
+    }
+}
+async function awaitTlsReady(url) {
+    let ready;
+    do {
+        ready = await tlsReady(url);
+        if (!ready) {
+            await (0, utils_1.sleep)(1000);
+        }
+    } while (!ready);
+}
+async function doSetup(projectId, webAppName, location, serviceAccount) {
+    await Promise.all([
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.developerConnectOrigin)(), "apphosting", true),
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.cloudbuildOrigin)(), "apphosting", true),
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.secretManagerOrigin)(), "apphosting", true),
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.cloudRunApiOrigin)(), "apphosting", true),
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.artifactRegistryDomain)(), "apphosting", true),
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.iamOrigin)(), "apphosting", true),
+    ]);
+    await ensureAppHostingComputeServiceAccount(projectId, serviceAccount);
+    const allowedLocations = (await apphosting.listLocations(projectId)).map((loc) => loc.locationId);
+    if (location) {
+        if (!allowedLocations.includes(location)) {
+            throw new error_1.FirebaseError(`Invalid location ${location}. Valid choices are ${allowedLocations.join(", ")}`);
+        }
+    }
+    location =
+        location || (await promptLocation(projectId, "Select a location to host your backend:\n"));
+    const gitRepositoryLink = await githubConnections.linkGitHubRepository(projectId, location);
+    const rootDir = await (0, prompt_1.promptOnce)({
+        name: "rootDir",
+        type: "input",
+        default: "/",
+        message: "Specify your app's root directory relative to your repository",
+    });
+    const branch = await githubConnections.promptGitHubBranch(gitRepositoryLink);
+    (0, utils_1.logSuccess)(`Repo linked successfully!\n`);
+    (0, utils_1.logBullet)(`${clc.yellow("===")} Set up your backend`);
+    const backendId = await promptNewBackendId(projectId, location, {
+        name: "backendId",
+        type: "input",
+        default: "my-web-app",
+        message: "Provide a name for your backend [1-30 characters]",
+    });
+    (0, utils_1.logSuccess)(`Name set to ${backendId}\n`);
+    const webApp = await app_1.webApps.getOrCreateWebApp(projectId, webAppName, backendId);
+    if (!webApp) {
+        (0, utils_1.logWarning)(`Firebase web app not set`);
+    }
+    const createBackendSpinner = ora("Creating your new backend...").start();
+    const backend = await createBackend(projectId, location, backendId, gitRepositoryLink, serviceAccount, webApp === null || webApp === void 0 ? void 0 : webApp.id, rootDir);
+    createBackendSpinner.succeed(`Successfully created backend!\n\t${backend.name}\n`);
+    await setDefaultTrafficPolicy(projectId, location, backendId, branch);
+    const confirmRollout = await (0, prompt_1.promptOnce)({
+        type: "confirm",
+        name: "rollout",
+        default: true,
+        message: "Do you want to deploy now?",
+    });
+    if (!confirmRollout) {
+        (0, utils_1.logSuccess)(`Your backend will be deployed at:\n\thttps://${backend.uri}`);
+        return;
+    }
+    const url = `https://${backend.uri}`;
+    (0, utils_1.logBullet)(`You may also track this rollout at:\n\t${(0, api_1.consoleOrigin)()}/project/${projectId}/apphosting`);
+    const createRolloutSpinner = ora("Starting a new rollout; this may take a few minutes. It's safe to exit now.").start();
+    await (0, rollout_1.orchestrateRollout)({
+        projectId,
+        location,
+        backendId,
+        buildInput: {
+            source: {
+                codebase: {
+                    branch,
+                },
+            },
+        },
+        isFirstRollout: true,
+    });
+    createRolloutSpinner.succeed("Rollout complete");
+    if (!(await tlsReady(url))) {
+        const tlsSpinner = ora("Finalizing your backend's TLS certificate; this may take a few minutes.").start();
+        await awaitTlsReady(url);
+        tlsSpinner.succeed("TLS certificate ready");
+    }
+    (0, utils_1.logSuccess)(`Your backend is now deployed at:\n\thttps://${backend.uri}`);
+}
+exports.doSetup = doSetup;
+async function createGitRepoLink(projectId, location, connectionId) {
+    await Promise.all([
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.developerConnectOrigin)(), "apphosting", true),
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.secretManagerOrigin)(), "apphosting", true),
+        (0, ensureApiEnabled_1.ensure)(projectId, (0, api_1.iamOrigin)(), "apphosting", true),
+    ]);
+    const allowedLocations = (await apphosting.listLocations(projectId)).map((loc) => loc.locationId);
+    if (location) {
+        if (!allowedLocations.includes(location)) {
+            throw new error_1.FirebaseError(`Invalid location ${location}. Valid choices are ${allowedLocations.join(", ")}`);
+        }
+    }
+    location =
+        location ||
+            (await promptLocation(projectId, "Select a location for your GitRepoLink's connection:\n"));
+    await githubConnections.linkGitHubRepository(projectId, location, connectionId);
+}
+exports.createGitRepoLink = createGitRepoLink;
+async function ensureAppHostingComputeServiceAccount(projectId, serviceAccount) {
+    const sa = serviceAccount || defaultComputeServiceAccountEmail(projectId);
+    const name = `projects/${projectId}/serviceAccounts/${sa}`;
+    try {
+        await iam.testResourceIamPermissions((0, api_1.iamOrigin)(), "v1", name, ["iam.serviceAccounts.actAs"], `projects/${projectId}`);
+    }
+    catch (err) {
+        if (!(err instanceof error_1.FirebaseError)) {
+            throw err;
+        }
+        if (err.status === 404) {
+            await provisionDefaultComputeServiceAccount(projectId);
+        }
+        else if (err.status === 403) {
+            throw new error_1.FirebaseError(`Failed to create backend due to missing delegation permissions for ${sa}. Make sure you have the iam.serviceAccounts.actAs permission.`, { original: err });
+        }
+    }
+}
+exports.ensureAppHostingComputeServiceAccount = ensureAppHostingComputeServiceAccount;
+async function promptNewBackendId(projectId, location, prompt) {
+    while (true) {
+        const backendId = await (0, prompt_1.promptOnce)(prompt);
+        try {
+            await apphosting.getBackend(projectId, location, backendId);
+        }
+        catch (err) {
+            if (err.status === 404) {
+                return backendId;
+            }
+            throw new error_1.FirebaseError(`Failed to check if backend with id ${backendId} already exists in ${location}`, { original: err });
+        }
+        (0, utils_1.logWarning)(`Backend with id ${backendId} already exists in ${location}`);
+    }
+}
+function defaultComputeServiceAccountEmail(projectId) {
+    return `${DEFAULT_COMPUTE_SERVICE_ACCOUNT_NAME}@${projectId}.iam.gserviceaccount.com`;
+}
+async function createBackend(projectId, location, backendId, repository, serviceAccount, webAppId, rootDir = "/") {
+    const defaultServiceAccount = defaultComputeServiceAccountEmail(projectId);
+    const backendReqBody = {
+        servingLocality: "GLOBAL_ACCESS",
+        codebase: {
+            repository: `${repository.name}`,
+            rootDirectory: rootDir,
+        },
+        labels: deploymentTool.labels(),
+        serviceAccount: serviceAccount || defaultServiceAccount,
+        appId: webAppId,
+    };
+    async function createBackendAndPoll() {
+        const op = await apphosting.createBackend(projectId, location, backendReqBody, backendId);
+        return await poller.pollOperation(Object.assign(Object.assign({}, apphostingPollerOptions), { pollerName: `create-${projectId}-${location}-${backendId}`, operationResourceName: op.name }));
+    }
+    return await createBackendAndPoll();
+}
+exports.createBackend = createBackend;
+async function provisionDefaultComputeServiceAccount(projectId) {
+    try {
+        await iam.createServiceAccount(projectId, DEFAULT_COMPUTE_SERVICE_ACCOUNT_NAME, "Default service account used to run builds and deploys for Firebase App Hosting", "Firebase App Hosting compute service account");
+    }
+    catch (err) {
+        if (err.status !== 409) {
+            throw err;
+        }
+    }
+    await (0, resourceManager_1.addServiceAccountToRoles)(projectId, defaultComputeServiceAccountEmail(projectId), [
+        "roles/firebaseapphosting.computeRunner",
+        "roles/firebase.sdkAdminServiceAgent",
+        "roles/developerconnect.readTokenAccessor",
+    ], true);
+}
+async function setDefaultTrafficPolicy(projectId, location, backendId, codebaseBranch) {
+    const traffic = {
+        rolloutPolicy: {
+            codebaseBranch: codebaseBranch,
+        },
+    };
+    const op = await apphosting.updateTraffic(projectId, location, backendId, traffic);
+    await poller.pollOperation(Object.assign(Object.assign({}, apphostingPollerOptions), { pollerName: `updateTraffic-${projectId}-${location}-${backendId}`, operationResourceName: op.name }));
+}
+exports.setDefaultTrafficPolicy = setDefaultTrafficPolicy;
+async function deleteBackendAndPoll(projectId, location, backendId) {
+    const op = await apphosting.deleteBackend(projectId, location, backendId);
+    await poller.pollOperation(Object.assign(Object.assign({}, apphostingPollerOptions), { pollerName: `delete-${projectId}-${location}-${backendId}`, operationResourceName: op.name }));
+}
+exports.deleteBackendAndPoll = deleteBackendAndPoll;
+async function promptLocation(projectId, prompt = "Please select a location:") {
+    const allowedLocations = (await apphosting.listLocations(projectId)).map((loc) => loc.locationId);
+    if (allowedLocations.length === 1) {
+        return allowedLocations[0];
+    }
+    const location = (await (0, prompt_1.promptOnce)({
+        name: "location",
+        type: "list",
+        default: constants_1.DEFAULT_LOCATION,
+        message: prompt,
+        choices: allowedLocations,
+    }));
+    (0, utils_1.logSuccess)(`Location set to ${location}.\n`);
+    return location;
+}
+exports.promptLocation = promptLocation;
+async function getBackendForLocation(projectId, location, backendId) {
+    try {
+        return await apphosting.getBackend(projectId, location, backendId);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`No backend named "${backendId}" found in ${location}.`, {
+            original: err,
+        });
+    }
+}
+exports.getBackendForLocation = getBackendForLocation;
+async function getBackendForAmbiguousLocation(projectId, backendId, locationDisambugationPrompt, force) {
+    let { unreachable, backends } = await apphosting.listBackends(projectId, "-");
+    if (unreachable && unreachable.length !== 0) {
+        (0, utils_1.logWarning)(`The following locations are currently unreachable: ${unreachable}.\n` +
+            "If your backend is in one of these regions, please try again later.");
+    }
+    backends = backends.filter((backend) => apphosting.parseBackendName(backend.name).id === backendId);
+    if (backends.length === 0) {
+        throw new error_1.FirebaseError(`No backend named "${backendId}" found.`);
+    }
+    if (backends.length === 1) {
+        return backends[0];
+    }
+    if (force) {
+        throw new error_1.FirebaseError(`Multiple backends found with ID ${backendId}. Please specify the region of your target backend.`);
+    }
+    const backendsByLocation = new Map();
+    backends.forEach((backend) => backendsByLocation.set(apphosting.parseBackendName(backend.name).location, backend));
+    const location = await (0, prompt_1.promptOnce)({
+        name: "location",
+        type: "list",
+        message: locationDisambugationPrompt,
+        choices: [...backendsByLocation.keys()],
+    });
+    return backendsByLocation.get(location);
+}
+exports.getBackendForAmbiguousLocation = getBackendForAmbiguousLocation;

package/lib/apphosting/config.js

@@ -1,15 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeAddSecretToYaml = exports.upsertEnv = exports.findEnv = exports.store = exports.load = exports.yamlPath = void 0;
+exports.loadConfigForEnvironment = exports.maybeAddSecretToYaml = exports.upsertEnv = exports.findEnv = exports.store = exports.load = exports.discoverConfigsAtBackendRoot = exports.discoverBackendRoot = exports.APPHOSTING_YAML_FILE_REGEX = exports.APPHOSTING_LOCAL_YAML_FILE = exports.APPHOSTING_BASE_YAML_FILE = void 0;
 const path_1 = require("path");
 const fs_1 = require("fs");
 const yaml = require("yaml");
 const fs = require("../fsutils");
 const prompt = require("../prompt");
 const dialogs = require("./secrets/dialogs");
-function yamlPath(cwd) {
+const yaml_1 = require("./yaml");
+const error_1 = require("../error");
+exports.APPHOSTING_BASE_YAML_FILE = "apphosting.yaml";
+exports.APPHOSTING_LOCAL_YAML_FILE = "apphosting.local.yaml";
+exports.APPHOSTING_YAML_FILE_REGEX = /^apphosting(\.[a-z0-9_]+)?\.yaml$/;
+function discoverBackendRoot(cwd) {
     let dir = cwd;
-    while (!fs.fileExistsSync((0, path_1.resolve)(dir, "apphosting.yaml"))) {
+    while (!fs.fileExistsSync((0, path_1.resolve)(dir, exports.APPHOSTING_BASE_YAML_FILE))) {
         if (fs.fileExistsSync((0, path_1.resolve)(dir, "firebase.json"))) {
             return null;
         }
@@ -19,9 +24,23 @@ function yamlPath(cwd) {
         }
         dir = parent;
     }
-    return (0, path_1.resolve)(dir, "apphosting.yaml");
+    return dir;
+}
+exports.discoverBackendRoot = discoverBackendRoot;
+function discoverConfigsAtBackendRoot(cwd) {
+    const backendRoot = discoverBackendRoot(cwd);
+    if (!backendRoot) {
+        throw new error_1.FirebaseError("Unable to find your project's root, ensure the apphosting.yaml config is initialized. Try 'firebase init apphosting'");
+    }
+    return listAppHostingFilesInPath(backendRoot);
+}
+exports.discoverConfigsAtBackendRoot = discoverConfigsAtBackendRoot;
+function listAppHostingFilesInPath(path) {
+    return fs
+        .listFiles(path)
+        .filter((file) => exports.APPHOSTING_YAML_FILE_REGEX.test(file))
+        .map((file) => (0, path_1.join)(path, file));
 }
-exports.yamlPath = yamlPath;
 function load(yamlPath) {
     const raw = fs.readFile(yamlPath);
     return yaml.parseDocument(raw);
@@ -62,9 +81,11 @@ function upsertEnv(document, env) {
 exports.upsertEnv = upsertEnv;
 async function maybeAddSecretToYaml(secretName) {
     const dynamicDispatch = exports;
-    let path = dynamicDispatch.yamlPath(process.cwd());
+    const backendRoot = dynamicDispatch.discoverBackendRoot(process.cwd());
+    let path;
     let projectYaml;
-    if (path) {
+    if (backendRoot) {
+        path = (0, path_1.join)(backendRoot, exports.APPHOSTING_BASE_YAML_FILE);
         projectYaml = dynamicDispatch.load(path);
     }
     else {
@@ -85,7 +106,7 @@ async function maybeAddSecretToYaml(secretName) {
             message: "It looks like you don't have an apphosting.yaml yet. Where would you like to store it?",
             default: process.cwd(),
         });
-        path = (0, path_1.join)(path, "apphosting.yaml");
+        path = (0, path_1.join)(path, exports.APPHOSTING_BASE_YAML_FILE);
     }
     const envName = await dialogs.envVarForSecret(secretName);
     dynamicDispatch.upsertEnv(projectYaml, {
@@ -95,3 +116,13 @@ async function maybeAddSecretToYaml(secretName) {
     dynamicDispatch.store(path, projectYaml);
 }
 exports.maybeAddSecretToYaml = maybeAddSecretToYaml;
+async function loadConfigForEnvironment(envYamlPath, baseYamlPath) {
+    const envYamlConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(envYamlPath);
+    if (baseYamlPath) {
+        const baseConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(baseYamlPath);
+        baseConfig.merge(envYamlConfig);
+        return baseConfig;
+    }
+    return envYamlConfig;
+}
+exports.loadConfigForEnvironment = loadConfigForEnvironment;

package/lib/apphosting/githubConnections.js

@@ -264,19 +264,25 @@ async function promptCloneUri(projectId, connection) {
     return cloneUri;
 }
 async function promptGitHubBranch(repoLink) {
+    var _a;
     const branches = await devConnect.listAllBranches(repoLink.name);
-    while (true) {
-        const branch = await (0, prompt_1.promptOnce)({
-            name: "branch",
-            type: "input",
-            default: "main",
-            message: "Pick a branch for continuous deployment",
-        });
-        if (branches.has(branch)) {
-            return branch;
-        }
-        utils.logWarning(`The branch "${branch}" does not exist on "${extractRepoSlugFromUri(repoLink.cloneUri)}". Please enter a valid branch for this repo.`);
-    }
+    const branch = await (0, prompt_1.promptOnce)({
+        type: "autocomplete",
+        name: "branch",
+        message: "Pick a branch for continuous deployment",
+        source: (_, input = "") => {
+            return new Promise((resolve) => resolve([
+                ...fuzzy.filter(input, Array.from(branches)).map((result) => {
+                    return {
+                        name: result.original,
+                        value: result.original,
+                    };
+                }),
+            ]));
+        },
+    });
+    utils.logWarning(`The branch "${branch}" does not exist on "${(_a = extractRepoSlugFromUri(repoLink.cloneUri)) !== null && _a !== void 0 ? _a : ""}". Please enter a valid branch for this repo.`);
+    return branch;
 }
 exports.promptGitHubBranch = promptGitHubBranch;
 async function ensureSecretManagerAdminGrant(projectId) {