firebase-tools 13.9.0 → 13.10.1

package/lib/commands/dataconnect-sdk-generate.js

@@ -20,16 +20,12 @@ exports.command = new command_1.Command("dataconnect:sdk:generate")
             configDir = path.resolve(path.join(cwd), configDir);
         }
         const serviceInfo = await (0, load_1.load)(projectId, service.location, configDir);
-        const args = {
-            projectId,
-            configDir,
-            auto_download: true,
-            rc: options.rc,
-            locationId: service.location,
-        };
-        const dataconnectEmulator = new dataconnectEmulator_1.DataConnectEmulator(args);
         for (const conn of serviceInfo.connectorInfo) {
-            const output = await dataconnectEmulator.generate(conn.connectorYaml.connectorId);
+            const output = await dataconnectEmulator_1.DataConnectEmulator.generate({
+                configDir,
+                locationId: service.location,
+                connectorId: conn.connectorYaml.connectorId,
+            });
             logger_1.logger.info(output);
             logger_1.logger.info(`Generated SDKs for ${conn.connectorYaml.connectorId}`);
         }

package/lib/commands/dataconnect-sql-migrate.js

@@ -33,7 +33,6 @@ exports.command = new command_1.Command("dataconnect:sql:migrate [serviceId]")
     const diffs = await (0, schemaMigration_1.migrateSchema)({
         options,
         schema: serviceInfo.schema,
-        allowNonInteractiveMigration: true,
         validateOnly: true,
     });
     if (diffs.length) {

package/lib/dataconnect/build.js

@@ -5,19 +5,11 @@ const dataconnectEmulator_1 = require("../emulator/dataconnectEmulator");
 const error_1 = require("../error");
 const graphqlError_1 = require("./graphqlError");
 async function build(options, configDir) {
-    var _a, _b, _c;
-    const projectId = (_a = options.project) !== null && _a !== void 0 ? _a : "demo-test";
-    const args = {
-        projectId,
-        configDir,
-        auto_download: true,
-        rc: options.rc,
-    };
-    const dataconnectEmulator = new dataconnectEmulator_1.DataConnectEmulator(args);
-    const buildResult = await dataconnectEmulator.build();
-    if ((_b = buildResult === null || buildResult === void 0 ? void 0 : buildResult.errors) === null || _b === void 0 ? void 0 : _b.length) {
+    var _a, _b;
+    const buildResult = await dataconnectEmulator_1.DataConnectEmulator.build({ configDir });
+    if ((_a = buildResult === null || buildResult === void 0 ? void 0 : buildResult.errors) === null || _a === void 0 ? void 0 : _a.length) {
         throw new error_1.FirebaseError(`There are errors in your schema and connector files:\n${buildResult.errors.map(graphqlError_1.prettify).join("\n")}`);
     }
-    return (_c = buildResult === null || buildResult === void 0 ? void 0 : buildResult.metadata) !== null && _c !== void 0 ? _c : {};
+    return (_b = buildResult === null || buildResult === void 0 ? void 0 : buildResult.metadata) !== null && _b !== void 0 ? _b : {};
 }
 exports.build = build;

package/lib/dataconnect/client.js

@@ -56,7 +56,7 @@ async function createService(projectId, locationId, serviceId) {
 }
 exports.createService = createService;
 async function deleteService(projectId, locationId, serviceId) {
-    const op = await dataconnectClient().delete(`projects/${projectId}/locations/${locationId}/services/${serviceId}?force=true`);
+    const op = await dataconnectClient().delete(`projects/${projectId}/locations/${locationId}/services/${serviceId}`);
     const pollRes = await operationPoller.pollOperation({
         apiOrigin: (0, api_1.dataconnectOrigin)(),
         apiVersion: DATACONNECT_API_VERSION,

package/lib/dataconnect/errors.js

@@ -5,27 +5,35 @@ const INCOMPATIBLE_SCHEMA_ERROR_TYPESTRING = "IncompatibleSqlSchemaError";
 const PRECONDITION_ERROR_TYPESTRING = "type.googleapis.com/google.rpc.PreconditionFailure";
 const INCOMPATIBLE_CONNECTOR_TYPE = "INCOMPATIBLE_CONNECTOR";
 function getIncompatibleSchemaError(err) {
-    var _a, _b;
-    const original = ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) || err.orignal;
-    if (!original) {
-        throw err;
+    const incompatibles = errorDetails(err, INCOMPATIBLE_SCHEMA_ERROR_TYPESTRING);
+    if (incompatibles.length === 0) {
+        return undefined;
     }
-    const details = original.details;
-    const incompatibles = details.filter((d) => { var _a; return (_a = d["@type"]) === null || _a === void 0 ? void 0 : _a.includes(INCOMPATIBLE_SCHEMA_ERROR_TYPESTRING); });
-    return incompatibles[0];
+    const incompatible = incompatibles[0];
+    const preconditionErrs = errorDetails(err, PRECONDITION_ERROR_TYPESTRING);
+    const violationTypes = (incompatible.violationType = preconditionErrs
+        .flatMap((preCondErr) => preCondErr.violations)
+        .flatMap((viol) => viol.type)
+        .filter((type) => type === "INACCESSIBLE_SCHEMA" || type === "INCOMPATIBLE_SCHEMA"));
+    incompatible.violationType = violationTypes[0];
+    return incompatible;
 }
 exports.getIncompatibleSchemaError = getIncompatibleSchemaError;
 function getInvalidConnectors(err) {
-    var _a, _b, _c, _d;
+    var _a, _b;
+    const preconditionErrs = errorDetails(err, PRECONDITION_ERROR_TYPESTRING);
     const invalidConns = [];
-    const original = ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) || (err === null || err === void 0 ? void 0 : err.orignal);
-    const details = original === null || original === void 0 ? void 0 : original.details;
-    const preconditionErrs = details === null || details === void 0 ? void 0 : details.filter((d) => { var _a; return (_a = d["@type"]) === null || _a === void 0 ? void 0 : _a.includes(PRECONDITION_ERROR_TYPESTRING); });
     for (const preconditionErr of preconditionErrs) {
-        const incompatibleConnViolation = (_c = preconditionErr === null || preconditionErr === void 0 ? void 0 : preconditionErr.violations) === null || _c === void 0 ? void 0 : _c.filter((v) => v.type === INCOMPATIBLE_CONNECTOR_TYPE);
-        const newConns = (_d = incompatibleConnViolation === null || incompatibleConnViolation === void 0 ? void 0 : incompatibleConnViolation.map((i) => i.subject)) !== null && _d !== void 0 ? _d : [];
+        const incompatibleConnViolation = (_a = preconditionErr === null || preconditionErr === void 0 ? void 0 : preconditionErr.violations) === null || _a === void 0 ? void 0 : _a.filter((v) => v.type === INCOMPATIBLE_CONNECTOR_TYPE);
+        const newConns = (_b = incompatibleConnViolation === null || incompatibleConnViolation === void 0 ? void 0 : incompatibleConnViolation.map((i) => i.subject)) !== null && _b !== void 0 ? _b : [];
         invalidConns.push(...newConns);
     }
     return invalidConns;
 }
 exports.getInvalidConnectors = getInvalidConnectors;
+function errorDetails(err, ofType) {
+    var _a, _b;
+    const original = ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.error) || (err === null || err === void 0 ? void 0 : err.original);
+    const details = original === null || original === void 0 ? void 0 : original.details;
+    return (details === null || details === void 0 ? void 0 : details.filter((d) => { var _a; return (_a = d["@type"]) === null || _a === void 0 ? void 0 : _a.includes(ofType); })) || [];
+}

package/lib/dataconnect/provisionCloudSql.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkInstanceConfig = exports.provisionCloudSql = void 0;
+exports.getUpdateReason = exports.provisionCloudSql = void 0;
 const cloudSqlAdminClient = require("../gcp/cloudsql/cloudsqladmin");
 const utils = require("../utils");
 const checkIam_1 = require("./checkIam");
@@ -15,10 +15,12 @@ async function provisionCloudSql(args) {
         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)) {
+        const why = getUpdateReason(existingInstance, enableGoogleMlIntegration);
+        if (why) {
             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...`);
+                    `Updating instance. This may take a few minutes...` +
+                    why);
             await (0, utils_1.promiseWithSpinner)(() => cloudSqlAdminClient.updateInstanceForDataConnect(existingInstance, enableGoogleMlIntegration), "Updating your instance...");
             silent || utils.logLabeledBullet("dataconnect", "Instance updated");
         }
@@ -44,10 +46,15 @@ async function provisionCloudSql(args) {
         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 (err.status === 404) {
+            silent ||
+                utils.logLabeledBullet("dataconnect", `Database ${databaseId} not found, creating it now...`);
+            await cloudSqlAdminClient.createDatabase(projectId, instanceId, databaseId);
+            silent || utils.logLabeledBullet("dataconnect", `Database ${databaseId} created.`);
+        }
+        else {
+            silent || utils.logLabeledWarning("dataconnect", `Database ${databaseId} is not accessible.`);
+        }
     }
     if (enableGoogleMlIntegration) {
         await (0, checkIam_1.grantRolesToCloudSqlServiceAccount)(projectId, instanceId, [GOOGLE_ML_INTEGRATION_ROLE]);
@@ -55,21 +62,25 @@ async function provisionCloudSql(args) {
     return connectionName;
 }
 exports.provisionCloudSql = provisionCloudSql;
-function checkInstanceConfig(instance, requireGoogleMlIntegration) {
+function getUpdateReason(instance, requireGoogleMlIntegration) {
     var _a, _b, _c, _d;
+    let reason = "";
     const settings = instance.settings;
     if (!((_a = settings.ipConfiguration) === null || _a === void 0 ? void 0 : _a.ipv4Enabled)) {
-        return false;
+        reason += "\n - to enable public IP.";
     }
     if (requireGoogleMlIntegration) {
         if (!settings.enableGoogleMlIntegration) {
-            return false;
+            reason += "\n - to enable Google ML integration.";
         }
         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;
+            reason += "\n - to enable Google ML integration database flag.";
         }
     }
     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;
+    if (!isIamEnabled) {
+        reason += "\n - to enable IAM authentication database flag.";
+    }
+    return reason;
 }
-exports.checkInstanceConfig = checkInstanceConfig;
+exports.getUpdateReason = getUpdateReason;

package/lib/dataconnect/schemaMigration.js

@@ -14,50 +14,50 @@ const utils_1 = require("../utils");
 const errors = require("./errors");
 async function diffSchema(schema) {
     const { serviceName, instanceName, databaseId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
     try {
         await (0, client_1.upsertSchema)(schema, true);
+        (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema is up to date.`);
     }
     catch (err) {
+        if (err.status !== 400) {
+            throw err;
+        }
         const invalidConnectors = errors.getInvalidConnectors(err);
+        const incompatible = errors.getIncompatibleSchemaError(err);
+        if (!incompatible && !invalidConnectors.length) {
+            throw err;
+        }
         if (invalidConnectors.length) {
             displayInvalidConnectors(invalidConnectors);
         }
-        const incompatible = errors.getIncompatibleSchemaError(err);
         if (incompatible) {
             displaySchemaChanges(incompatible);
             return incompatible.diffs;
         }
     }
-    (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema is up to date.`);
     return [];
 }
 exports.diffSchema = diffSchema;
 async function migrateSchema(args) {
-    const { options, schema, allowNonInteractiveMigration, validateOnly } = args;
+    const { options, schema, validateOnly } = args;
     const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, true);
     try {
         await (0, client_1.upsertSchema)(schema, validateOnly);
         logger_1.logger.debug(`Database schema was up to date for ${instanceId}:${databaseId}`);
     }
     catch (err) {
+        if (err.status !== 400) {
+            throw err;
+        }
         const incompatible = errors.getIncompatibleSchemaError(err);
         const invalidConnectors = errors.getInvalidConnectors(err);
         if (!incompatible && !invalidConnectors.length) {
             throw err;
         }
-        const shouldDeleteInvalidConnectors = await promptForInvalidConnectorError(options, invalidConnectors, validateOnly);
-        if (!shouldDeleteInvalidConnectors && invalidConnectors.length) {
-            const cmd = suggestedCommand(serviceName, invalidConnectors);
-            throw new error_1.FirebaseError(`Command aborted. Try deploying compatible connectors first with ${clc.bold(cmd)}`);
-        }
-        const migrationMode = incompatible
-            ? await promptForSchemaMigration(options, databaseId, incompatible, allowNonInteractiveMigration)
-            : "none";
-        if (migrationMode === "none" && incompatible) {
-            throw new error_1.FirebaseError("Command aborted.");
-        }
+        const migrationMode = await promptForSchemaMigration(options, databaseId, incompatible, validateOnly);
+        const shouldDeleteInvalidConnectors = await promptForInvalidConnectorError(options, serviceName, invalidConnectors, validateOnly);
         let diffs = [];
         if (incompatible) {
             diffs = await handleIncompatibleSchemaError({
@@ -68,10 +68,12 @@ async function migrateSchema(args) {
                 choice: migrationMode,
             });
         }
-        if (invalidConnectors.length) {
+        if (shouldDeleteInvalidConnectors) {
             await deleteInvalidConnectors(invalidConnectors);
         }
-        await (0, client_1.upsertSchema)(schema, validateOnly);
+        if (!validateOnly) {
+            await (0, client_1.upsertSchema)(schema, validateOnly);
+        }
         return diffs;
     }
     return [];
@@ -136,16 +138,22 @@ async function handleIncompatibleSchemaError(args) {
     }
     return [];
 }
-async function promptForSchemaMigration(options, databaseName, err, allowNonInteractiveMigration) {
+async function promptForSchemaMigration(options, databaseName, err, validateOnly) {
+    if (!err) {
+        return "none";
+    }
     displaySchemaChanges(err);
     if (!options.nonInteractive) {
+        if (validateOnly && options.force) {
+            return "all";
+        }
         const choices = err.destructive
             ? [
                 { name: "Execute all changes (including destructive changes)", value: "all" },
                 { name: "Abort changes", value: "none" },
             ]
             : [
-                { name: "Execute changes", value: "safe" },
+                { name: "Execute changes", value: "all" },
                 { name: "Abort changes", value: "none" },
             ];
         return await (0, prompt_1.promptOnce)({
@@ -154,35 +162,39 @@ async function promptForSchemaMigration(options, databaseName, err, allowNonInte
             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";
+    if (!validateOnly) {
+        throw new error_1.FirebaseError("Command aborted. Your database schema is incompatible with your Data Connect schema. Run `firebase dataconnect:sql:migrate` to migrate your database schema");
     }
     else if (options.force) {
         return "all";
     }
     else if (!err.destructive) {
-        return "safe";
+        return "all";
     }
     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";
+        throw new error_1.FirebaseError("Command aborted. This schema migration includes potentially destructive changes. If you'd like to execute it anyway, rerun this command with --force");
     }
 }
-async function promptForInvalidConnectorError(options, invalidConnectors, validateOnly) {
+async function promptForInvalidConnectorError(options, serviceName, invalidConnectors, validateOnly) {
     if (!invalidConnectors.length) {
         return false;
     }
     displayInvalidConnectors(invalidConnectors);
     if (validateOnly) {
-        return false;
+        if (options.force) {
+            return false;
+        }
+        throw new error_1.FirebaseError(`Command aborted. If you'd like to migrate it anyway, you may override with --force.`);
     }
-    else if (options.force ||
-        (!options.nonInteractive &&
-            (await (0, prompt_1.confirm)(Object.assign(Object.assign({}, options), { message: "Would you like to delete and recreate these connectors?" }))))) {
+    if (options.force) {
         return true;
     }
-    return false;
+    if (!options.nonInteractive &&
+        (await (0, prompt_1.confirm)(Object.assign(Object.assign({}, options), { message: `Would you like to delete and recreate these connectors? This will cause ${clc.red(`downtime.`)}.` })))) {
+        return true;
+    }
+    const cmd = suggestedCommand(serviceName, invalidConnectors);
+    throw new error_1.FirebaseError(`Command aborted. Try deploying those connectors first with ${clc.bold(cmd)}`);
 }
 async function deleteInvalidConnectors(invalidConnectors) {
     return Promise.all(invalidConnectors.map(client_1.deleteConnector));
@@ -190,39 +202,48 @@ async function deleteInvalidConnectors(invalidConnectors) {
 function displayInvalidConnectors(invalidConnectors) {
     const connectorIds = invalidConnectors.map((i) => i.split("/").pop()).join(", ");
     (0, utils_1.logLabeledWarning)("dataconnect", `The schema you are deploying is incompatible with the following existing connectors: ${connectorIds}.`);
-    (0, utils_1.logLabeledWarning)("dataconnect", `This is a ${clc.red("breaking")} change and will cause a brief downtime.`);
+    (0, utils_1.logLabeledWarning)("dataconnect", `This is a ${clc.red("breaking")} change and may break existing apps.`);
 }
-async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, databaseId) {
+async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, databaseId, linkIfNotConnected) {
     let currentSchema;
     try {
         currentSchema = await (0, client_1.getSchema)(serviceName);
     }
     catch (err) {
-        if (err.status === 404) {
-            currentSchema = {
-                name: `${serviceName}/schemas/${types_1.SCHEMA_ID}`,
-                source: {
-                    files: [],
-                },
-                primaryDatasource: {
-                    postgresql: {
-                        database: databaseId,
-                        cloudSql: {
-                            instance: instanceId,
-                        },
-                    },
-                },
-            };
-        }
-        else {
+        if (err.status !== 404) {
             throw err;
         }
+        if (!linkIfNotConnected) {
+            (0, utils_1.logLabeledWarning)("dataconnect", `Not yet linked to the Cloud SQL instance.`);
+            return;
+        }
+        (0, utils_1.logLabeledBullet)("dataconnect", `Linking the Cloud SQL instance...`);
+        currentSchema = {
+            name: `${serviceName}/schemas/${types_1.SCHEMA_ID}`,
+            source: {
+                files: [],
+            },
+            primaryDatasource: {
+                postgresql: {
+                    database: databaseId,
+                    cloudSql: {
+                        instance: instanceId,
+                    },
+                },
+            },
+        };
+    }
+    const postgresql = currentSchema.primaryDatasource.postgresql;
+    if ((postgresql === null || postgresql === void 0 ? void 0 : postgresql.cloudSql.instance) !== instanceId) {
+        (0, utils_1.logLabeledWarning)("dataconnect", `Switching connected Cloud SQL instance\nFrom ${postgresql === null || postgresql === void 0 ? void 0 : postgresql.cloudSql.instance}\nTo ${instanceId}`);
     }
-    if (!currentSchema.primaryDatasource.postgresql ||
-        currentSchema.primaryDatasource.postgresql.schemaValidation === "STRICT") {
+    if ((postgresql === null || postgresql === void 0 ? void 0 : postgresql.database) !== databaseId) {
+        (0, utils_1.logLabeledWarning)("dataconnect", `Switching connected Postgres database from ${postgresql === null || postgresql === void 0 ? void 0 : postgresql.database} to ${databaseId}`);
+    }
+    if (!postgresql || postgresql.schemaValidation === "STRICT") {
         return;
     }
-    currentSchema.primaryDatasource.postgresql.schemaValidation = "STRICT";
+    postgresql.schemaValidation = "STRICT";
     try {
         await (0, client_1.upsertSchema)(currentSchema, false);
     }
@@ -234,10 +255,27 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, datab
     }
 }
 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);
+    switch (error.violationType) {
+        case "INCOMPATIBLE_SCHEMA":
+            {
+                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);
+            }
+            break;
+        case "INACCESSIBLE_SCHEMA":
+            {
+                const message = "Cannot access your CloudSQL database to validate schema. " +
+                    "The following SQL statements can setup a new database schema.\n" +
+                    error.diffs.map(toString).join("\n");
+                (0, utils_1.logLabeledWarning)("dataconnect", message);
+                (0, utils_1.logLabeledWarning)("dataconnect", "Some SQL resources may already exist.");
+            }
+            break;
+        default:
+            throw new error_1.FirebaseError(`Unknown schema violation type: ${error.violationType}, IncompatibleSqlSchemaError: ${error}`);
+    }
 }
 function toString(diff) {
     return `\/** ${diff.destructive ? clc.red("Destructive: ") : ""}${diff.description}*\/\n${(0, sql_formatter_1.format)(diff.sql, { language: "postgresql" })}`;

package/lib/deploy/dataconnect/release.js

@@ -21,7 +21,6 @@ async function default_1(context, options) {
             await (0, schemaMigration_1.migrateSchema)({
                 options,
                 schema: s,
-                allowNonInteractiveMigration: false,
                 validateOnly: false,
             });
         }

package/lib/deploy/functions/runtimes/discovery/index.js

@@ -11,6 +11,7 @@ const api = require("../../.../../../../api");
 const v1alpha1 = require("./v1alpha1");
 const error_1 = require("../../../../error");
 exports.readFileAsync = (0, util_1.promisify)(fs.readFile);
+const TIMEOUT_OVERRIDE_ENV_VAR = "FUNCTIONS_DISCOVERY_TIMEOUT";
 function yamlToBuild(yaml, project, region, runtime) {
     try {
         if (!yaml.specVersion) {
@@ -50,7 +51,7 @@ async function detectFromPort(port, project, runtime, timeout = 10000) {
     const timedOut = new Promise((resolve, reject) => {
         setTimeout(() => {
             reject(new error_1.FirebaseError("User code failed to load. Cannot determine backend specification"));
-        }, timeout);
+        }, +(process.env[TIMEOUT_OVERRIDE_ENV_VAR] || 0) * 1000 || timeout);
     });
     while (true) {
         try {

package/lib/emulator/controller.js

@@ -518,7 +518,6 @@ async function startAll(options, showUI = true, runningTestScript = false) {
         await startEmulator(pubsubEmulator);
     }
     if (listenForEmulator.dataconnect) {
-        const dataConnectAddr = legacyGetFirstAddr(types_1.Emulators.DATACONNECT);
         const config = (0, fileUtils_1.readFirebaseJson)(options.config);
         if (!config.length) {
             throw new error_1.FirebaseError("No Data Connect service found in firebase.json");
@@ -532,8 +531,7 @@ async function startAll(options, showUI = true, runningTestScript = false) {
             configDir = path.resolve(path.join(cwd), configDir);
         }
         const dataConnectEmulator = new dataconnectEmulator_1.DataConnectEmulator({
-            host: dataConnectAddr.host,
-            port: dataConnectAddr.port,
+            listen: listenForEmulator.dataconnect,
             projectId,
             auto_download: true,
             configDir,

package/lib/emulator/dataconnectEmulator.js

@@ -9,16 +9,15 @@ const types_1 = require("./types");
 const error_1 = require("../error");
 const emulatorLogger_1 = require("./emulatorLogger");
 const types_2 = require("../dataconnect/types");
-const grpcDefaultPort = 9510;
+const portUtils_1 = require("./portUtils");
 class DataConnectEmulator {
     constructor(args) {
         this.args = args;
         this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.DATACONNECT);
     }
     async start() {
-        const port = this.args.port || constants_1.Constants.getDefaultPort(types_1.Emulators.DATACONNECT);
         this.logger.log("DEBUG", `Using Postgres connection string: ${this.getLocalConectionString()}`);
-        const info = await this.build();
+        const info = await DataConnectEmulator.build({ configDir: this.args.configDir });
         if ((0, types_2.requiresVector)(info.metadata)) {
             if (constants_1.Constants.isDemoProject(this.args.projectId)) {
                 this.logger.logLabeled("WARN", "Data Connect", "Detected a 'demo-' project, but vector embeddings require a real project. Operations that use vector_embed will fail.");
@@ -27,7 +26,7 @@ class DataConnectEmulator {
                 this.logger.logLabeled("WARN", "Data Connect", "Operations that use vector_embed will make calls to production Vertex AI");
             }
         }
-        return (0, downloadableEmulators_1.start)(types_1.Emulators.DATACONNECT, Object.assign(Object.assign({}, this.args), { http_port: port, grpc_port: grpcDefaultPort, config_dir: this.args.configDir, local_connection_string: this.getLocalConectionString(), project_id: this.args.projectId, service_location: this.args.locationId }));
+        return (0, downloadableEmulators_1.start)(types_1.Emulators.DATACONNECT, Object.assign(Object.assign({}, this.args), { listen: (0, portUtils_1.listenSpecsToString)(this.args.listen), config_dir: this.args.configDir, local_connection_string: this.getLocalConectionString(), project_id: this.args.projectId, service_location: this.args.locationId }));
     }
     connect() {
         return Promise.resolve();
@@ -36,12 +35,11 @@ class DataConnectEmulator {
         return (0, downloadableEmulators_1.stop)(types_1.Emulators.DATACONNECT);
     }
     getInfo() {
-        const host = this.args.host || constants_1.Constants.getDefaultHost();
-        const port = this.args.port || constants_1.Constants.getDefaultPort(types_1.Emulators.DATACONNECT);
         return {
             name: this.getName(),
-            host,
-            port,
+            listen: this.args.listen,
+            host: this.args.listen[0].address,
+            port: this.args.listen[0].port,
             pid: (0, downloadableEmulators_1.getPID)(types_1.Emulators.DATACONNECT),
             timeout: 10000,
         };
@@ -49,25 +47,32 @@ class DataConnectEmulator {
     getName() {
         return types_1.Emulators.DATACONNECT;
     }
-    async generate(connectorId) {
+    static async generate(args) {
         const commandInfo = await (0, downloadableEmulators_1.downloadIfNecessary)(types_1.Emulators.DATACONNECT);
         const cmd = [
             "generate",
-            `--service_location=${this.args.locationId}`,
-            `--config_dir=${this.args.configDir}`,
-            `--connector_id=${connectorId}`,
+            `--service_location=${args.locationId}`,
+            `--config_dir=${args.configDir}`,
+            `--connector_id=${args.connectorId}`,
         ];
         const res = childProcess.spawnSync(commandInfo.binary, cmd, { encoding: "utf-8" });
         if (res.error) {
-            throw new error_1.FirebaseError(`Error starting up Data Connect emulator: ${res.error}`);
+            throw new error_1.FirebaseError(`Error starting up Data Connect generate: ${res.error.message}`, {
+                original: res.error,
+            });
         }
         return res.stdout;
     }
-    async build() {
+    static async build(args) {
         var _a;
         const commandInfo = await (0, downloadableEmulators_1.downloadIfNecessary)(types_1.Emulators.DATACONNECT);
-        const cmd = ["build", `--config_dir=${this.args.configDir}`];
+        const cmd = ["build", `--config_dir=${args.configDir}`];
         const res = childProcess.spawnSync(commandInfo.binary, cmd, { encoding: "utf-8" });
+        if (res.error) {
+            throw new error_1.FirebaseError(`Error starting up Data Connect build: ${res.error.message}`, {
+                original: res.error,
+            });
+        }
         if (res.stderr) {
             throw new error_1.FirebaseError(`Unable to build your Data Connect schema and connectors: ${res.stderr}`);
         }

package/lib/emulator/downloadableEmulators.js

@@ -35,9 +35,9 @@ const EMULATOR_UPDATE_DETAILS = {
     ui: experiments.isEnabled("emulatoruisnapshot")
         ? { version: "SNAPSHOT", expectedSize: -1, expectedChecksum: "" }
         : {
-            version: "1.11.8",
-            expectedSize: 3523907,
-            expectedChecksum: "49f6dc1911dda9d10df62a6c09aaf9a0",
+            version: "1.12.1",
+            expectedSize: 3498269,
+            expectedChecksum: "a7f4398a00e5ca22abdcd78dc3877d00",
         },
     pubsub: {
         version: "0.8.2",
@@ -46,14 +46,14 @@ const EMULATOR_UPDATE_DETAILS = {
     },
     dataconnect: process.platform === "darwin"
         ? {
-            version: "1.1.17",
-            expectedSize: 25602224,
-            expectedChecksum: "1f9e3dd040a0ac4d1cb4d9dde4a3c0b0",
+            version: "1.1.18",
+            expectedSize: 25836736,
+            expectedChecksum: "28a760826968c86cff7e2137b7a487cf",
         }
         : {
             version: "1.1.17",
-            expectedSize: 23036912,
-            expectedChecksum: "a0ec0517108f842ed06fea14fe7c7e56",
+            expectedSize: 23247120,
+            expectedChecksum: "ff2d10655fd0ad16c0fd07e1ca6dac3e",
         },
 };
 exports.DownloadDetails = {
@@ -232,7 +232,13 @@ const Commands = {
     dataconnect: {
         binary: getExecPath(types_1.Emulators.DATACONNECT),
         args: ["dev"],
-        optionalArgs: ["http_port", "grpc_port", "config_dir", "local_connection_string", "project_id"],
+        optionalArgs: [
+            "listen",
+            "config_dir",
+            "local_connection_string",
+            "project_id",
+            "service_location",
+        ],
         joinArgs: true,
         shell: true,
     },

package/lib/emulator/portUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveHostAndAssignPorts = exports.waitForPortUsed = exports.checkListenable = void 0;
+exports.listenSpecsToString = exports.resolveHostAndAssignPorts = exports.waitForPortUsed = exports.checkListenable = void 0;
 const clc = require("colorette");
 const tcpport = require("tcp-port-used");
 const node_net_1 = require("node:net");
@@ -146,7 +146,7 @@ const EMULATOR_CAN_LISTEN_ON_PRIMARY_ONLY = {
     firestore: true,
     "firestore.websocket": true,
     pubsub: true,
-    dataconnect: true,
+    dataconnect: false,
     hub: false,
     ui: false,
     auth: true,
@@ -321,3 +321,12 @@ function listenSpec(lookup, port) {
         port: port,
     };
 }
+function listenSpecsToString(specs) {
+    return specs
+        .map((spec) => {
+        const host = spec.family === "IPv4" ? spec.address : `[${spec.address}]`;
+        return `${host}:${spec.port}`;
+    })
+        .join(",");
+}
+exports.listenSpecsToString = listenSpecsToString;

package/lib/frameworks/next/utils.js

@@ -231,7 +231,6 @@ async function getProductionDistDirFiles(sourceDir, distDir) {
         cwd: (0, path_1.join)(sourceDir, distDir),
         nodir: true,
         absolute: false,
-        realpath: utils_2.IS_WINDOWS,
     }, (err, matches) => {
         if (err)
             reject(err);

package/lib/gcp/cloudsql/cloudsqladmin.js

@@ -42,6 +42,8 @@ async function createInstance(projectId, location, instanceId, enableGoogleMlInt
             userLabels: { "firebase-data-connect": "ft" },
             insightsConfig: {
                 queryInsightsEnabled: true,
+                queryPlansPerMinute: 5,
+                queryStringLength: 1024,
             },
         },
     });

package/lib/gcp/cloudsql/connect.js

@@ -16,7 +16,7 @@ async function execute(sqlStatements, opts) {
     const user = await cloudSqlAdminClient.getUser(opts.projectId, opts.instanceId, opts.username);
     const connectionName = instance.connectionName;
     if (!connectionName) {
-        throw new error_1.FirebaseError(`Could not get instance conection string for ${opts.instanceId}:${opts.databaseId}`);
+        throw new error_1.FirebaseError(`Could not get instance connection string for ${opts.instanceId}:${opts.databaseId}`);
     }
     let connector;
     let pool;
@@ -30,7 +30,7 @@ async function execute(sqlStatements, opts) {
                 ipType: cloud_sql_connector_1.IpAddressTypes.PUBLIC,
                 authType: cloud_sql_connector_1.AuthTypes.IAM,
             });
-            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, database: opts.databaseId, max: 1 }));
+            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, database: opts.databaseId }));
             break;
         }
         case "CLOUD_IAM_SERVICE_ACCOUNT": {
@@ -40,7 +40,7 @@ async function execute(sqlStatements, opts) {
                 ipType: cloud_sql_connector_1.IpAddressTypes.PUBLIC,
                 authType: cloud_sql_connector_1.AuthTypes.IAM,
             });
-            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, database: opts.databaseId, max: 1 }));
+            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, database: opts.databaseId }));
             break;
         }
         default: {
@@ -54,19 +54,22 @@ async function execute(sqlStatements, opts) {
                 instanceConnectionName: connectionName,
                 ipType: cloud_sql_connector_1.IpAddressTypes.PUBLIC,
             });
-            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, password: opts.password, database: opts.databaseId, max: 1 }));
+            pool = new pg.Pool(Object.assign(Object.assign({}, clientOpts), { user: opts.username, password: opts.password, database: opts.databaseId }));
             break;
         }
     }
+    const conn = await pool.connect();
+    logFn(`Logged in as ${opts.username}`);
     for (const s of sqlStatements) {
-        logFn(`Executing: '${s}' as ${opts.username}`);
+        logFn(`Executing: '${s}'`);
         try {
-            await pool.query(s);
+            await conn.query(s);
         }
         catch (err) {
             throw new error_1.FirebaseError(`Error executing ${err}`);
         }
     }
+    conn.release();
     await pool.end();
     connector.close();
 }

package/lib/init/features/dataconnect/index.js

@@ -45,7 +45,7 @@ async function doSetup(setup, config) {
         }
         if (instances.length) {
             cloudSqlInstanceId = await (0, prompt_1.promptOnce)({
-                message: `Which CloudSSQL instance would you like to use?`,
+                message: `Which CloudSQL instance would you like to use?`,
                 type: "list",
                 choices,
             });

package/lib/requireAuth.js

@@ -20,6 +20,9 @@ function getAuthClient(config) {
     return authClient;
 }
 async function autoAuth(options, authScopes) {
+    if (process.env.MONOSPACE_ENV) {
+        throw new error_1.FirebaseError("autoAuth not yet implemented for IDX. Please run 'firebase login'");
+    }
     const client = getAuthClient({ scopes: authScopes, projectId: options.project });
     const token = await client.getAccessToken();
     token !== null ? apiv2.setAccessToken(token) : false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "13.9.0",
+  "version": "13.10.1",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {
@@ -59,7 +59,7 @@
   },
   "dependencies": {
     "@google-cloud/cloud-sql-connector": "^1.2.3",
-    "@google-cloud/pubsub": "^3.0.1",
+    "@google-cloud/pubsub": "^4.4.0",
     "abort-controller": "^3.0.0",
     "ajv": "^6.12.6",
     "archiver": "^5.0.0",