firebase-tools 13.7.5 → 13.8.0

package/lib/dataconnect/provisionCloudSql.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkInstanceConfig = exports.installRequiredExtensions = exports.REQUIRED_EXTENSIONS_COMMANDS = exports.provisionCloudSql = void 0;
+const cloudSqlAdminClient = require("../gcp/cloudsql/cloudsqladmin");
+const connect_1 = require("../gcp/cloudsql/connect");
+const utils = require("../utils");
+const checkIam_1 = require("./checkIam");
+const GOOGLE_ML_INTEGRATION_ROLE = "roles/aiplatform.user";
+const freeTrial_1 = require("./freeTrial");
+const error_1 = require("../error");
+async function provisionCloudSql(args) {
+    let connectionName;
+    const { projectId, locationId, instanceId, databaseId, enableGoogleMlIntegration, silent } = args;
+    try {
+        const existingInstance = await cloudSqlAdminClient.getInstance(projectId, instanceId);
+        silent || utils.logLabeledBullet("dataconnect", `Found existing instance ${instanceId}.`);
+        connectionName = (existingInstance === null || existingInstance === void 0 ? void 0 : existingInstance.connectionName) || "";
+        if (!checkInstanceConfig(existingInstance, enableGoogleMlIntegration)) {
+            silent ||
+                utils.logLabeledBullet("dataconnect", `Instance ${instanceId} settings not compatible with Firebase Data Connect.` +
+                    `Updating instance to enable Cloud IAM authentication and public IP. This may take a few minutes...`);
+            await cloudSqlAdminClient.updateInstanceForDataConnect(existingInstance, enableGoogleMlIntegration);
+            silent || utils.logLabeledBullet("dataconnect", "Instance updated");
+        }
+    }
+    catch (err) {
+        if (err.status !== 404) {
+            throw err;
+        }
+        const freeTrialInstanceId = await (0, freeTrial_1.checkForFreeTrialInstance)(projectId);
+        if (freeTrialInstanceId) {
+            (0, freeTrial_1.printFreeTrialUnavailable)(projectId, freeTrialInstanceId);
+            throw new error_1.FirebaseError("Free trial unavailable.");
+        }
+        silent ||
+            utils.logLabeledBullet("dataconnect", `CloudSQL instance '${instanceId}' not found, creating it. This instance is provided under the terms of the Data Connect free trial ${(0, freeTrial_1.freeTrialTermsLink)()}`);
+        silent || utils.logLabeledBullet("dataconnect", `This may take while...`);
+        const newInstance = await cloudSqlAdminClient.createInstance(projectId, locationId, instanceId, enableGoogleMlIntegration);
+        silent || utils.logLabeledBullet("dataconnect", "Instance created");
+        connectionName = (newInstance === null || newInstance === void 0 ? void 0 : newInstance.connectionName) || "";
+    }
+    try {
+        await cloudSqlAdminClient.getDatabase(projectId, instanceId, databaseId);
+        silent || utils.logLabeledBullet("dataconnect", `Found existing database ${databaseId}.`);
+    }
+    catch (err) {
+        silent ||
+            utils.logLabeledBullet("dataconnect", `Database ${databaseId} not found, creating it now...`);
+        await cloudSqlAdminClient.createDatabase(projectId, instanceId, databaseId);
+        silent || utils.logLabeledBullet("dataconnect", `Database ${databaseId} created.`);
+    }
+    if (enableGoogleMlIntegration) {
+        await (0, checkIam_1.grantRolesToCloudSqlServiceAccount)(projectId, instanceId, [GOOGLE_ML_INTEGRATION_ROLE]);
+    }
+    return connectionName;
+}
+exports.provisionCloudSql = provisionCloudSql;
+exports.REQUIRED_EXTENSIONS_COMMANDS = [
+    `CREATE SCHEMA IF NOT EXISTS "public"`,
+    `CREATE EXTENSION IF NOT EXISTS "uuid-ossp" with SCHEMA public`,
+    `CREATE EXTENSION IF NOT EXISTS "vector" with SCHEMA public`,
+    `CREATE EXTENSION IF NOT EXISTS "google_ml_integration" with SCHEMA public CASCADE`,
+];
+async function installRequiredExtensions(projectId, instanceId, databaseId, username) {
+    await (0, connect_1.execute)(exports.REQUIRED_EXTENSIONS_COMMANDS, {
+        projectId,
+        instanceId,
+        databaseId,
+        username,
+        silent: true,
+    });
+}
+exports.installRequiredExtensions = installRequiredExtensions;
+function checkInstanceConfig(instance, requireGoogleMlIntegration) {
+    var _a, _b, _c, _d;
+    const settings = instance.settings;
+    if (!((_a = settings.ipConfiguration) === null || _a === void 0 ? void 0 : _a.ipv4Enabled)) {
+        return false;
+    }
+    if (requireGoogleMlIntegration) {
+        if (!settings.enableGoogleMlIntegration) {
+            return false;
+        }
+        if (!((_b = settings.databaseFlags) === null || _b === void 0 ? void 0 : _b.some((f) => f.name === "cloudsql.enable_google_ml_integration" && f.value === "on"))) {
+            return false;
+        }
+    }
+    const isIamEnabled = (_d = (_c = settings.databaseFlags) === null || _c === void 0 ? void 0 : _c.some((f) => f.name === "cloudsql.iam_authentication" && f.value === "on")) !== null && _d !== void 0 ? _d : false;
+    return isIamEnabled;
+}
+exports.checkInstanceConfig = checkInstanceConfig;

package/lib/dataconnect/schemaMigration.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateSchema = exports.diffSchema = void 0;
+const clc = require("colorette");
+const sql_formatter_1 = require("sql-formatter");
+const client_1 = require("./client");
+const connect_1 = require("../gcp/cloudsql/connect");
+const prompt_1 = require("../prompt");
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const provisionCloudSql_1 = require("./provisionCloudSql");
+const projectUtils_1 = require("../projectUtils");
+const utils_1 = require("../utils");
+const IMCOMPATIBLE_SCHEMA_ERROR_TYPESTRING = "type.googleapis.com/google.firebase.dataconnect.v1main.IncompatibleSqlSchemaError";
+async function diffSchema(schema) {
+    var _a, _b;
+    const dbName = (_a = schema.primaryDatasource.postgresql) === null || _a === void 0 ? void 0 : _a.database;
+    const instanceName = (_b = schema.primaryDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.cloudSql.instance;
+    if (!instanceName || !dbName) {
+        throw new error_1.FirebaseError(`tried to diff schema but ${instanceName} was undefined`);
+    }
+    try {
+        await (0, client_1.upsertSchema)(schema, true);
+    }
+    catch (err) {
+        const incompatible = getIncompatibleSchemaError(err);
+        if (incompatible) {
+            displaySchemaChanges(incompatible);
+            return incompatible.diffs;
+        }
+        throw err;
+    }
+    logger_1.logger.debug(`Schema was up to date for ${instanceName}:${dbName}`);
+    return [];
+}
+exports.diffSchema = diffSchema;
+async function migrateSchema(options, schema, allowNonInteractiveMigration) {
+    var _a, _b;
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const databaseId = (_a = schema.primaryDatasource.postgresql) === null || _a === void 0 ? void 0 : _a.database;
+    if (!databaseId) {
+        throw new error_1.FirebaseError("Schema is missing primaryDatasource.postgresql?.database, cannot migrate");
+    }
+    const instanceId = (_b = schema.primaryDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.cloudSql.instance.split("/").pop();
+    if (!instanceId) {
+        throw new error_1.FirebaseError(`tried to migrate schema but ${instanceId} was undefined`);
+    }
+    const iamUser = await (0, connect_1.setupIAMUser)(instanceId, databaseId, options);
+    try {
+        await (0, client_1.upsertSchema)(schema, true);
+    }
+    catch (err) {
+        const incompatible = getIncompatibleSchemaError(err);
+        if (incompatible) {
+            const choice = await promptForSchemaMigration(options, databaseId, incompatible, allowNonInteractiveMigration);
+            const commandsToExecute = incompatible.diffs
+                .filter((d) => {
+                switch (choice) {
+                    case "all":
+                        return true;
+                    case "safe":
+                        return !d.destructive;
+                    case "none":
+                        return false;
+                }
+            })
+                .map((d) => d.sql);
+            if (commandsToExecute.length) {
+                await (0, connect_1.execute)([
+                    ...provisionCloudSql_1.REQUIRED_EXTENSIONS_COMMANDS,
+                    ...commandsToExecute,
+                    `GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA "public" TO PUBLIC`,
+                ], {
+                    projectId,
+                    instanceId,
+                    databaseId,
+                    username: iamUser,
+                });
+                return incompatible.diffs;
+            }
+        }
+        throw err;
+    }
+    logger_1.logger.debug(`Schema was up to date for ${instanceId}:${databaseId}`);
+    return [];
+}
+exports.migrateSchema = migrateSchema;
+async function promptForSchemaMigration(options, databaseName, err, allowNonInteractiveMigration) {
+    displaySchemaChanges(err);
+    if (!options.nonInteractive) {
+        const choices = err.destructive
+            ? [
+                { name: "Execute all changes (including destructive changes)", value: "all" },
+                { name: "Execute only safe changes", value: "safe" },
+                { name: "Abort changes", value: "none" },
+            ]
+            : [
+                { name: "Execute changes", value: "safe" },
+                { name: "Abort changes", value: "none" },
+            ];
+        return await (0, prompt_1.promptOnce)({
+            message: `Would you like to execute these changes against ${databaseName}?`,
+            type: "list",
+            choices,
+        });
+    }
+    else if (!allowNonInteractiveMigration) {
+        logger_1.logger.error("Your database schema is incompatible with your Data Connect schema. Run `firebase dataconnect:sql:migrate` to migrate your database schema");
+        return "none";
+    }
+    else if (options.force) {
+        return "all";
+    }
+    else if (!err.destructive) {
+        return "safe";
+    }
+    else {
+        logger_1.logger.error("This schema migration includes potentially destructive changes. If you'd like to execute it anyway, rerun this command with --force");
+        return "none";
+    }
+}
+function displaySchemaChanges(error) {
+    const message = "Your new schema is incompatible with the schema of your CloudSQL database. " +
+        "The following SQL statements will migrate your database schema to match your new Data Connect schema.\n" +
+        error.diffs.map(toString).join("\n");
+    (0, utils_1.logLabeledWarning)("dataconnect", message);
+}
+function toString(diff) {
+    return `\/** ${diff.destructive ? clc.red("Destructive: ") : ""}${diff.description}*\/\n${(0, sql_formatter_1.format)(diff.sql, { language: "postgresql" })}`;
+}
+function getIncompatibleSchemaError(err) {
+    var _a;
+    const original = (_a = err.context) === null || _a === void 0 ? void 0 : _a.body.error;
+    const details = original.details;
+    const incompatibles = details.filter((d) => d["@type"] === IMCOMPATIBLE_SCHEMA_ERROR_TYPESTRING);
+    return incompatibles[0];
+}

package/lib/dataconnect/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDatasource = exports.requiresVector = exports.SCHEMA_ID = void 0;
+exports.SCHEMA_ID = "main";
+function requiresVector(dm) {
+    var _a, _b, _c, _d;
+    return (_d = (_c = (_b = (_a = dm === null || dm === void 0 ? void 0 : dm.primaryDataSource) === null || _a === void 0 ? void 0 : _a.postgres) === null || _b === void 0 ? void 0 : _b.requiredExtensions) === null || _c === void 0 ? void 0 : _c.includes("vector")) !== null && _d !== void 0 ? _d : false;
+}
+exports.requiresVector = requiresVector;
+function toDatasource(projectId, locationId, ds) {
+    if (ds.postgresql) {
+        return {
+            postgresql: {
+                database: ds.postgresql.database,
+                cloudSql: {
+                    instance: `projects/${projectId}/locations/${locationId}/instances/${ds.postgresql.cloudSql.instanceId}`,
+                },
+            },
+        };
+    }
+    return {};
+}
+exports.toDatasource = toDatasource;

package/lib/deploy/dataconnect/deploy.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client = require("../../dataconnect/client");
+const utils = require("../../utils");
+const types_1 = require("../../dataconnect/types");
+const projectUtils_1 = require("../../projectUtils");
+const provisionCloudSql_1 = require("../../dataconnect/provisionCloudSql");
+const names_1 = require("../../dataconnect/names");
+const prompt_1 = require("../../prompt");
+const api_1 = require("../../api");
+const ensureApiEnabled = require("../../ensureApiEnabled");
+async function default_1(context, options) {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const serviceInfos = context.dataconnect.serviceInfos;
+    const services = await client.listAllServices(projectId);
+    const filters = context.dataconnect.filters;
+    if (serviceInfos.some((si) => {
+        return (0, types_1.requiresVector)(si.deploymentMetadata);
+    })) {
+        await ensureApiEnabled.ensure(projectId, (0, api_1.vertexAIOrigin)(), "dataconnect");
+    }
+    const servicesToCreate = serviceInfos
+        .filter((si) => !services.some((s) => matches(si, s)))
+        .filter((si) => {
+        return !filters || (filters === null || filters === void 0 ? void 0 : filters.some((f) => si.dataConnectYaml.serviceId === f.serviceId));
+    });
+    const servicesToDelete = filters
+        ? []
+        : services.filter((s) => !serviceInfos.some((si) => matches(si, s)));
+    await Promise.all(servicesToCreate.map(async (s) => {
+        const { projectId, locationId, serviceId } = splitName(s.serviceName);
+        await client.createService(projectId, locationId, serviceId);
+        utils.logLabeledSuccess("dataconnect", `Created service ${s.serviceName}`);
+    }));
+    if (servicesToDelete.length) {
+        if (await (0, prompt_1.confirm)({
+            force: options.force,
+            nonInteractive: options.nonInteractive,
+            message: `The following services exist on ${projectId} but are not listed in your 'firebase.json'\n${servicesToDelete
+                .map((s) => s.name)
+                .join("\n")}\nWould you like to delete these services?`,
+        })) {
+            await Promise.all(servicesToDelete.map(async (s) => {
+                const { projectId, locationId, serviceId } = splitName(s.name);
+                await client.deleteService(projectId, locationId, serviceId);
+                utils.logLabeledSuccess("dataconnect", `Deleted service ${s.name}`);
+            }));
+        }
+    }
+    utils.logLabeledBullet("dataconnect", "Checking for CloudSQL resources...");
+    await Promise.all(serviceInfos
+        .filter((si) => {
+        return !filters || (filters === null || filters === void 0 ? void 0 : filters.some((f) => si.dataConnectYaml.serviceId === f.serviceId));
+    })
+        .map(async (s) => {
+        var _a, _b;
+        const instanceId = (_a = s.schema.primaryDatasource.postgresql) === null || _a === void 0 ? void 0 : _a.cloudSql.instance.split("/").pop();
+        const databaseId = (_b = s.schema.primaryDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.database;
+        if (!instanceId || !databaseId) {
+            return Promise.resolve();
+        }
+        const enableGoogleMlIntegration = (0, types_1.requiresVector)(s.deploymentMetadata);
+        return (0, provisionCloudSql_1.provisionCloudSql)({
+            projectId,
+            locationId: (0, names_1.parseServiceName)(s.serviceName).location,
+            instanceId,
+            databaseId,
+            enableGoogleMlIntegration,
+        });
+    }));
+    return;
+}
+exports.default = default_1;
+function matches(si, s) {
+    return si.serviceName === s.name;
+}
+function splitName(serviceName) {
+    const parts = serviceName.split("/");
+    return {
+        projectId: parts[1],
+        locationId: parts[3],
+        serviceId: parts[5],
+    };
+}

package/lib/deploy/dataconnect/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.deploy = exports.prepare = void 0;
+const prepare_1 = require("./prepare");
+exports.prepare = prepare_1.default;
+const deploy_1 = require("./deploy");
+exports.deploy = deploy_1.default;
+const release_1 = require("./release");
+exports.release = release_1.default;

package/lib/deploy/dataconnect/prepare.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const load_1 = require("../../dataconnect/load");
+const fileUtils_1 = require("../../dataconnect/fileUtils");
+const logger_1 = require("../../logger");
+const utils = require("../../utils");
+const projectUtils_1 = require("../../projectUtils");
+const filters_1 = require("../../dataconnect/filters");
+const build_1 = require("../../dataconnect/build");
+const ensureApis_1 = require("../../dataconnect/ensureApis");
+async function default_1(context, options) {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    await (0, ensureApis_1.ensureApis)(projectId);
+    const serviceCfgs = (0, fileUtils_1.readFirebaseJson)(options.config);
+    utils.logLabeledBullet("dataconnect", `Preparing to deploy`);
+    const filters = (0, filters_1.getResourceFilters)(options);
+    const serviceInfos = await Promise.all(serviceCfgs.map((c) => (0, load_1.load)(projectId, c.location, path.join(options.cwd || process.cwd(), c.source))));
+    for (const si of serviceInfos) {
+        si.deploymentMetadata = await (0, build_1.build)(options, si.sourceDirectory);
+    }
+    context.dataconnect = {
+        serviceInfos,
+        filters,
+    };
+    utils.logLabeledBullet("dataconnect", `Successfully prepared schema and connectors`);
+    logger_1.logger.debug(JSON.stringify(context.dataconnect, null, 2));
+    return;
+}
+exports.default = default_1;

package/lib/deploy/dataconnect/release.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils = require("../../utils");
+const client_1 = require("../../dataconnect/client");
+const prompts_1 = require("../../dataconnect/prompts");
+const error_1 = require("../../error");
+const schemaMigration_1 = require("../../dataconnect/schemaMigration");
+async function default_1(context, options) {
+    const serviceInfos = context.dataconnect.serviceInfos;
+    const filters = context.dataconnect.filters;
+    const wantSchemas = serviceInfos
+        .filter((si) => {
+        return (!filters ||
+            filters.some((f) => {
+                return f.serviceId === si.dataConnectYaml.serviceId && (f.schemaOnly || f.fullService);
+            }));
+    })
+        .map((s) => s.schema);
+    if (wantSchemas.length) {
+        utils.logLabeledBullet("dataconnect", "Checking if database schemas match Data Connect schemas...");
+        for (const s of wantSchemas) {
+            await (0, schemaMigration_1.migrateSchema)(options, s, false);
+        }
+        utils.logLabeledBullet("dataconnect", "Releasing schemas...");
+        const schemaPromises = await Promise.allSettled(wantSchemas.map((s) => (0, client_1.upsertSchema)(s)));
+        const failedSchemas = schemaPromises.filter((p) => p.status === "rejected");
+        if (failedSchemas.length) {
+            throw new error_1.FirebaseError(`Errors while updating your schemas:\n ${failedSchemas.map((f) => f.reason).join("\n")}`);
+        }
+        utils.logLabeledBullet("dataconnect", "Schemas released.");
+    }
+    let wantConnectors = [];
+    wantConnectors = wantConnectors.concat(...serviceInfos.map((si) => si.connectorInfo
+        .filter((c) => {
+        return (!filters ||
+            filters.some((f) => {
+                return (f.serviceId === si.dataConnectYaml.serviceId &&
+                    (f.connectorId === c.connectorYaml.connectorId || f.fullService));
+            }));
+    })
+        .map((c) => c.connector)));
+    const haveConnectors = await have(serviceInfos);
+    const connectorsToDelete = filters
+        ? []
+        : haveConnectors.filter((h) => !wantConnectors.some((w) => w.name === h.name));
+    if (wantConnectors.length) {
+        utils.logLabeledBullet("dataconnect", "Releasing connectors...");
+        await Promise.all(wantConnectors.map(async (c) => {
+            await (0, client_1.upsertConnector)(c);
+            utils.logLabeledSuccess("dataconnect", `Deployed connector ${c.name}`);
+        }));
+        for (const c of connectorsToDelete) {
+            await (0, prompts_1.promptDeleteConnector)(options, c.name);
+        }
+        utils.logLabeledBullet("dataconnect", "Connectors released.");
+    }
+    utils.logLabeledSuccess("dataconnect", "Deploy complete!");
+    return;
+}
+exports.default = default_1;
+async function have(serviceInfos) {
+    let connectors = [];
+    for (const si of serviceInfos) {
+        connectors = connectors.concat(await (0, client_1.listConnectors)(si.serviceName));
+    }
+    return connectors;
+}

package/lib/deploy/functions/checkIam.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureServiceAgentRoles = exports.mergeBindings = exports.obtainDefaultComputeServiceAgentBindings = exports.obtainPubSubServiceAgentBindings = exports.checkHttpIam = exports.checkServiceAccountIam = exports.EVENTARC_EVENT_RECEIVER_ROLE = exports.RUN_INVOKER_ROLE = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
+exports.ensureServiceAgentRoles = exports.obtainDefaultComputeServiceAgentBindings = exports.obtainPubSubServiceAgentBindings = exports.checkHttpIam = exports.checkServiceAccountIam = exports.EVENTARC_EVENT_RECEIVER_ROLE = exports.RUN_INVOKER_ROLE = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
 const colorette_1 = require("colorette");
 const logger_1 = require("../../logger");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
@@ -102,36 +102,6 @@ function obtainDefaultComputeServiceAgentBindings(projectNumber) {
     return [runInvokerBinding, eventarcEventReceiverBinding];
 }
 exports.obtainDefaultComputeServiceAgentBindings = obtainDefaultComputeServiceAgentBindings;
-function mergeBindings(policy, requiredBindings) {
-    let updated = false;
-    for (const requiredBinding of requiredBindings) {
-        const match = policy.bindings.find((b) => b.role === requiredBinding.role);
-        if (!match) {
-            updated = true;
-            policy.bindings.push(requiredBinding);
-            continue;
-        }
-        for (const requiredMember of requiredBinding.members) {
-            if (!match.members.find((m) => m === requiredMember)) {
-                updated = true;
-                match.members.push(requiredMember);
-            }
-        }
-    }
-    return updated;
-}
-exports.mergeBindings = mergeBindings;
-function printManualIamConfig(requiredBindings, projectId) {
-    utils.logLabeledBullet("functions", "Failed to verify the project has the correct IAM bindings for a successful deployment.", "warn");
-    utils.logLabeledBullet("functions", "You can either re-run `firebase deploy` as a project owner or manually run the following set of `gcloud` commands:", "warn");
-    for (const binding of requiredBindings) {
-        for (const member of binding.members) {
-            utils.logLabeledBullet("functions", `\`gcloud projects add-iam-policy-binding ${projectId} ` +
-                `--member=${member} ` +
-                `--role=${binding.role}\``, "warn");
-        }
-    }
-}
 async function ensureServiceAgentRoles(projectId, projectNumber, want, have) {
     const wantServices = backend.allEndpoints(want).reduce(reduceEventsToServices, []);
     const haveServices = backend.allEndpoints(have).reduce(reduceEventsToServices, []);
@@ -157,13 +127,13 @@ async function ensureServiceAgentRoles(projectId, projectNumber, want, have) {
         policy = await (0, resourceManager_1.getIamPolicy)(projectNumber);
     }
     catch (err) {
-        printManualIamConfig(requiredBindings, projectId);
+        iam.printManualIamConfig(requiredBindings, projectId, "functions");
         utils.logLabeledBullet("functions", "Could not verify the necessary IAM configuration for the following newly-integrated services: " +
             `${newServices.map((service) => service.api).join(", ")}` +
             ". Deployment may fail.", "warn");
         return;
     }
-    const hasUpdatedBindings = mergeBindings(policy, requiredBindings);
+    const hasUpdatedBindings = iam.mergeBindings(policy, requiredBindings);
     if (!hasUpdatedBindings) {
         return;
     }
@@ -171,7 +141,7 @@ async function ensureServiceAgentRoles(projectId, projectNumber, want, have) {
         await (0, resourceManager_1.setIamPolicy)(projectNumber, policy, "bindings");
     }
     catch (err) {
-        printManualIamConfig(requiredBindings, projectId);
+        iam.printManualIamConfig(requiredBindings, projectId, "functions");
         throw new error_1.FirebaseError("We failed to modify the IAM policy for the project. The functions " +
             "deployment requires specific roles to be granted to service agents," +
             " otherwise the deployment will fail.", { original: err });

package/lib/deploy/index.js

@@ -19,6 +19,7 @@ const FunctionsTarget = require("./functions");
 const StorageTarget = require("./storage");
 const RemoteConfigTarget = require("./remoteconfig");
 const ExtensionsTarget = require("./extensions");
+const DataConnectTarget = require("./dataconnect");
 const frameworks_1 = require("../frameworks");
 const prepare_1 = require("./hosting/prepare");
 const github_1 = require("../init/features/hosting/github");
@@ -32,6 +33,7 @@ const TARGETS = {
     storage: StorageTarget,
     remoteconfig: RemoteConfigTarget,
     extensions: ExtensionsTarget,
+    dataconnect: DataConnectTarget,
 };
 const chain = async function (fns, context, options, payload) {
     for (const latest of fns) {

package/lib/downloadUtils.js

@@ -7,9 +7,9 @@ const ProgressBar = require("progress");
 const tmp = require("tmp");
 const apiv2_1 = require("./apiv2");
 const error_1 = require("./error");
-async function downloadToTmp(remoteUrl) {
+async function downloadToTmp(remoteUrl, auth = false) {
     const u = new url_1.URL(remoteUrl);
-    const c = new apiv2_1.Client({ urlPrefix: u.origin, auth: false });
+    const c = new apiv2_1.Client({ urlPrefix: u.origin, auth });
     const tmpfile = tmp.fileSync();
     const writeStream = fs.createWriteStream(tmpfile.name);
     const res = await c.request({

package/lib/emulator/constants.js

@@ -14,6 +14,7 @@ exports.DEFAULT_PORTS = {
     auth: 9099,
     storage: 9199,
     eventarc: 9299,
+    dataconnect: 9399,
 };
 exports.FIND_AVAILBLE_PORT_BY_DEFAULT = {
     ui: true,
@@ -28,6 +29,7 @@ exports.FIND_AVAILBLE_PORT_BY_DEFAULT = {
     storage: false,
     extensions: false,
     eventarc: true,
+    dataconnect: true,
 };
 exports.EMULATOR_DESCRIPTION = {
     ui: "Emulator UI",
@@ -42,6 +44,7 @@ exports.EMULATOR_DESCRIPTION = {
     storage: "Storage Emulator",
     extensions: "Extensions Emulator",
     eventarc: "Eventarc Emulator",
+    dataconnect: "Data Connect Emulator",
 };
 exports.DEFAULT_HOST = "localhost";
 class Constants {