firebase-tools 14.13.0 → 14.15.0

package/lib/dataconnect/schemaMigration.js

@@ -17,6 +17,7 @@ const cloudsqladmin_1 = require("../gcp/cloudsql/cloudsqladmin");
 const cloudSqlAdminClient = require("../gcp/cloudsql/cloudsqladmin");
 const errors = require("./errors");
 const provisionCloudSql_1 = require("./provisionCloudSql");
+const requireAuth_1 = require("../requireAuth");
 async function setupSchemaIfNecessary(instanceId, databaseId, options) {
     try {
         await (0, connect_1.setupIAMUsers)(instanceId, options);
@@ -24,87 +25,89 @@ async function setupSchemaIfNecessary(instanceId, databaseId, options) {
         switch (schemaInfo.setupStatus) {
             case permissionsSetup_1.SchemaSetupStatus.BrownField:
             case permissionsSetup_1.SchemaSetupStatus.GreenField:
+                logger_1.logger.debug(`Cloud SQL Database ${instanceId}:${databaseId} is already set up in ${schemaInfo.setupStatus}`);
                 return schemaInfo.setupStatus;
             case permissionsSetup_1.SchemaSetupStatus.NotSetup:
             case permissionsSetup_1.SchemaSetupStatus.NotFound:
+                (0, utils_1.logLabeledBullet)("dataconnect", "Setting up Cloud SQL Database SQL permissions...");
                 return await (0, permissionsSetup_1.setupSQLPermissions)(instanceId, databaseId, schemaInfo, options, true);
             default:
                 throw new error_1.FirebaseError(`Unexpected schema setup status: ${schemaInfo.setupStatus}`);
         }
     }
     catch (err) {
-        throw new error_1.FirebaseError(`Cannot setup SQL schema permissions of ${instanceId}:${databaseId}\n${err}`);
+        throw new error_1.FirebaseError(`Cannot setup Postgres SQL permissions of Cloud SQL database ${instanceId}:${databaseId}\n${err}`);
     }
 }
 async function diffSchema(options, schema, schemaValidation) {
-    (0, utils_1.logLabeledBullet)("dataconnect", `Generating SQL schema migrations...`);
+    let validationMode = schemaValidation !== null && schemaValidation !== void 0 ? schemaValidation : "STRICT";
+    setSchemaValidationMode(schema, validationMode);
+    displayStartSchemaDiff(validationMode);
     const { serviceName, instanceName, databaseId, instanceId } = getIdentifiers(schema);
     await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
-    let validationMode = schemaValidation !== null && schemaValidation !== void 0 ? schemaValidation : "COMPATIBLE";
-    setSchemaValidationMode(schema, validationMode);
-    let diffs = [];
+    let incompatible = undefined;
     try {
         await (0, client_1.upsertSchema)(schema, true);
-        if (validationMode === "STRICT") {
-            (0, utils_1.logLabeledSuccess)("dataconnect", `database schema of ${instanceId}:${databaseId} is up to date.`);
-        }
-        else {
-            (0, utils_1.logLabeledSuccess)("dataconnect", `database schema of ${instanceId}:${databaseId} is compatible.`);
-        }
+        displayNoSchemaDiff(instanceId, databaseId, validationMode);
     }
     catch (err) {
         if ((err === null || err === void 0 ? void 0 : err.status) !== 400) {
             throw err;
         }
+        incompatible = errors.getIncompatibleSchemaError(err);
         const invalidConnectors = errors.getInvalidConnectors(err);
-        const incompatible = errors.getIncompatibleSchemaError(err);
         if (!incompatible && !invalidConnectors.length) {
+            const gqlErrs = errors.getGQLErrors(err);
+            if (gqlErrs) {
+                throw new error_1.FirebaseError(`There are errors in your schema files:\n${gqlErrs}`);
+            }
             throw err;
         }
         if (invalidConnectors.length) {
             displayInvalidConnectors(invalidConnectors);
         }
-        if (incompatible) {
-            displaySchemaChanges(incompatible, validationMode, instanceName, databaseId);
-            diffs = incompatible.diffs;
-        }
     }
-    if (!schemaValidation) {
-        validationMode = "STRICT";
-        setSchemaValidationMode(schema, validationMode);
-        try {
-            (0, utils_1.logLabeledBullet)("dataconnect", `generating schema changes, including optional changes...`);
-            await (0, client_1.upsertSchema)(schema, true);
-            (0, utils_1.logLabeledSuccess)("dataconnect", `no additional optional changes`);
-        }
-        catch (err) {
-            if ((err === null || err === void 0 ? void 0 : err.status) !== 400) {
-                throw err;
-            }
-            const incompatible = errors.getIncompatibleSchemaError(err);
-            if (incompatible) {
-                if (!diffsEqual(diffs, incompatible.diffs)) {
-                    if (diffs.length === 0) {
-                        displaySchemaChanges(incompatible, "STRICT_AFTER_COMPATIBLE", instanceName, databaseId);
-                    }
-                    else {
-                        displaySchemaChanges(incompatible, validationMode, instanceName, databaseId);
-                    }
-                    diffs = incompatible.diffs;
-                }
-                else {
-                    (0, utils_1.logLabeledSuccess)("dataconnect", `no additional optional changes`);
-                }
-            }
+    if (!incompatible) {
+        return [];
+    }
+    if (schemaValidation) {
+        displaySchemaChanges(incompatible, validationMode);
+        return incompatible.diffs;
+    }
+    const strictIncompatible = incompatible;
+    let compatibleIncompatible = undefined;
+    validationMode = "COMPATIBLE";
+    setSchemaValidationMode(schema, validationMode);
+    try {
+        displayStartSchemaDiff(validationMode);
+        await (0, client_1.upsertSchema)(schema, true);
+        displayNoSchemaDiff(instanceId, databaseId, validationMode);
+    }
+    catch (err) {
+        if ((err === null || err === void 0 ? void 0 : err.status) !== 400) {
+            throw err;
         }
+        compatibleIncompatible = errors.getIncompatibleSchemaError(err);
     }
-    return diffs;
+    if (!compatibleIncompatible) {
+        displaySchemaChanges(strictIncompatible, "STRICT");
+    }
+    else if (diffsEqual(strictIncompatible.diffs, compatibleIncompatible.diffs)) {
+        displaySchemaChanges(strictIncompatible, "STRICT");
+    }
+    else {
+        displaySchemaChanges(compatibleIncompatible, "COMPATIBLE");
+        displaySchemaChanges(strictIncompatible, "STRICT_AFTER_COMPATIBLE");
+    }
+    return incompatible.diffs;
 }
 exports.diffSchema = diffSchema;
 async function migrateSchema(args) {
     var _a;
-    (0, utils_1.logLabeledBullet)("dataconnect", `Generating SQL schema migrations...`);
     const { options, schema, validateOnly, schemaValidation } = args;
+    let validationMode = schemaValidation !== null && schemaValidation !== void 0 ? schemaValidation : "COMPATIBLE";
+    setSchemaValidationMode(schema, validationMode);
+    displayStartSchemaDiff(validationMode);
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
     await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, true);
@@ -124,12 +127,10 @@ async function migrateSchema(args) {
         return [];
     }
     await setupSchemaIfNecessary(instanceId, databaseId, options);
-    let validationMode = schemaValidation !== null && schemaValidation !== void 0 ? schemaValidation : "COMPATIBLE";
-    setSchemaValidationMode(schema, validationMode);
     let diffs = [];
     try {
         await (0, client_1.upsertSchema)(schema, validateOnly);
-        (0, utils_1.logLabeledSuccess)("dataconnect", `database schema of ${instanceId}:${databaseId} is up to date.`);
+        displayNoSchemaDiff(instanceId, databaseId, validationMode);
     }
     catch (err) {
         if ((err === null || err === void 0 ? void 0 : err.status) !== 400) {
@@ -138,9 +139,13 @@ async function migrateSchema(args) {
         const incompatible = errors.getIncompatibleSchemaError(err);
         const invalidConnectors = errors.getInvalidConnectors(err);
         if (!incompatible && !invalidConnectors.length) {
+            const gqlErrs = errors.getGQLErrors(err);
+            if (gqlErrs) {
+                throw new error_1.FirebaseError(`There are errors in your schema files:\n${gqlErrs}`);
+            }
             throw err;
         }
-        const migrationMode = await promptForSchemaMigration(options, instanceName, databaseId, incompatible, validateOnly, validationMode);
+        const migrationMode = await promptForSchemaMigration(options, instanceId, databaseId, incompatible, validateOnly, validationMode);
         const shouldDeleteInvalidConnectors = await promptForInvalidConnectorError(options, serviceName, invalidConnectors, validateOnly);
         if (incompatible) {
             diffs = await handleIncompatibleSchemaError({
@@ -173,7 +178,7 @@ async function migrateSchema(args) {
             if (!incompatible && !invalidConnectors.length) {
                 throw err;
             }
-            const migrationMode = await promptForSchemaMigration(options, instanceName, databaseId, incompatible, validateOnly, "STRICT_AFTER_COMPATIBLE");
+            const migrationMode = await promptForSchemaMigration(options, instanceId, databaseId, incompatible, validateOnly, "STRICT_AFTER_COMPATIBLE");
             if (incompatible) {
                 const maybeDiffs = await handleIncompatibleSchemaError({
                     options,
@@ -193,16 +198,12 @@ async function grantRoleToUserInSchema(options, schema) {
     const role = options.role;
     const email = options.email;
     const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
-    const projectId = (0, projectUtils_1.needProjectId)(options);
-    const { user, mode } = (0, connect_1.toDatabaseUser)(email);
-    const fdcSqlRole = permissionsSetup_1.fdcSqlRoleMap[role](databaseId);
     await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
     const schemaSetupStatus = await setupSchemaIfNecessary(instanceId, databaseId, options);
     if (schemaSetupStatus !== permissionsSetup_1.SchemaSetupStatus.GreenField && role === "owner") {
         throw new error_1.FirebaseError(`Owner rule isn't available in ${schemaSetupStatus} databases. If you would like Data Connect to manage and own your database schema, run 'firebase dataconnect:sql:setup'`);
     }
-    await cloudSqlAdminClient.createUser(projectId, instanceId, mode, user);
-    await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, [`GRANT "${fdcSqlRole}" TO "${user}"`], false);
+    await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, role, email);
 }
 exports.grantRoleToUserInSchema = grantRoleToUserInSchema;
 function diffsEqual(x, y) {
@@ -253,11 +254,7 @@ function suggestedCommand(serviceName, invalidConnectorNames) {
 }
 async function handleIncompatibleSchemaError(args) {
     const { incompatibleSchemaError, options, instanceId, databaseId, choice } = args;
-    if (incompatibleSchemaError.destructive && choice === "safe") {
-        throw new error_1.FirebaseError("This schema migration includes potentially destructive changes. If you'd like to execute it anyway, rerun this command with --force");
-    }
-    const commandsToExecute = incompatibleSchemaError.diffs
-        .filter((d) => {
+    const commandsToExecute = incompatibleSchemaError.diffs.filter((d) => {
         switch (choice) {
             case "all":
                 return true;
@@ -266,16 +263,15 @@ async function handleIncompatibleSchemaError(args) {
             case "none":
                 return false;
         }
-    })
-        .map((d) => d.sql);
+    });
     if (commandsToExecute.length) {
-        const commandsToExecuteBySuperUser = commandsToExecute.filter((sql) => sql.startsWith("CREATE EXTENSION") || sql.startsWith("CREATE SCHEMA"));
-        const commandsToExecuteByOwner = commandsToExecute.filter((sql) => !commandsToExecuteBySuperUser.includes(sql));
+        const commandsToExecuteBySuperUser = commandsToExecute.filter(requireSuperUser);
+        const commandsToExecuteByOwner = commandsToExecute.filter((sql) => !requireSuperUser(sql));
         const userIsCSQLAdmin = await (0, cloudsqladmin_1.iamUserIsCSQLAdmin)(options);
         if (!userIsCSQLAdmin && commandsToExecuteBySuperUser.length) {
             throw new error_1.FirebaseError(`Some SQL commands required for this migration require Admin permissions.\n 
         Please ask a user with 'roles/cloudsql.admin' to apply the following commands.\n
-        ${commandsToExecuteBySuperUser.join("\n")}`);
+        ${diffsToString(commandsToExecuteBySuperUser)}`);
         }
         const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, options);
         if (schemaInfo.setupStatus !== permissionsSetup_1.SchemaSetupStatus.GreenField) {
@@ -284,56 +280,67 @@ async function handleIncompatibleSchemaError(args) {
                 `If you would like Data Connect to manage your database schema, run 'firebase dataconnect:sql:setup'`);
         }
         if (!(await (0, permissionsSetup_1.checkSQLRoleIsGranted)(options, instanceId, databaseId, (0, permissions_1.firebaseowner)(databaseId), (await (0, connect_1.getIAMUser)(options)).user))) {
-            throw new error_1.FirebaseError(`Command aborted. Only users granted firebaseowner SQL role can run migrations.`);
+            if (!userIsCSQLAdmin) {
+                throw new error_1.FirebaseError(`Command aborted. Only users granted firebaseowner SQL role can run migrations.`);
+            }
+            const account = (await (0, requireAuth_1.requireAuth)(options));
+            (0, utils_1.logLabeledBullet)("dataconnect", `Granting firebaseowner role to myself ${account}...`);
+            await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, "owner", account);
         }
         if (commandsToExecuteBySuperUser.length) {
-            logger_1.logger.info(`The diffs require CloudSQL superuser permissions, attempting to apply changes as superuser.`);
-            await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, commandsToExecuteBySuperUser, false);
+            (0, utils_1.logLabeledBullet)("dataconnect", `Executing admin SQL commands as superuser...`);
+            await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, commandsToExecuteBySuperUser.map((d) => d.sql), false);
         }
         if (commandsToExecuteByOwner.length) {
-            await (0, connect_1.executeSqlCmdsAsIamUser)(options, instanceId, databaseId, [`SET ROLE "${(0, permissions_1.firebaseowner)(databaseId)}"`, ...commandsToExecuteByOwner], false);
+            await (0, connect_1.executeSqlCmdsAsIamUser)(options, instanceId, databaseId, [`SET ROLE "${(0, permissions_1.firebaseowner)(databaseId)}"`, ...commandsToExecuteByOwner.map((d) => d.sql)], false);
             return incompatibleSchemaError.diffs;
         }
     }
     return [];
 }
-async function promptForSchemaMigration(options, instanceName, databaseId, err, validateOnly, validationMode) {
+async function promptForSchemaMigration(options, instanceId, databaseId, err, validateOnly, validationMode) {
     if (!err) {
         return "none";
     }
-    if (validationMode === "STRICT_AFTER_COMPATIBLE" && (options.nonInteractive || options.force)) {
-        return "none";
-    }
-    displaySchemaChanges(err, validationMode, instanceName, databaseId);
+    const defaultChoice = validationMode === "STRICT_AFTER_COMPATIBLE" ? "none" : "all";
+    displaySchemaChanges(err, validationMode);
     if (!options.nonInteractive) {
         if (validateOnly && options.force) {
-            return "all";
+            return defaultChoice;
+        }
+        let choices = [
+            { name: "Execute all", value: "all" },
+        ];
+        if (err.destructive) {
+            choices = [{ name: `Execute all ${clc.red("(including destructive)")}`, value: "all" }];
+            if (err.diffs.some((d) => !d.destructive)) {
+                choices.push({ name: "Execute safe only", value: "safe" });
+            }
         }
-        const message = validationMode === "STRICT_AFTER_COMPATIBLE"
-            ? `Would you like to execute these optional changes against ${databaseId} in your CloudSQL instance ${instanceName}?`
-            : `Would you like to execute these changes against ${databaseId} in your CloudSQL instance ${instanceName}?`;
-        let executeChangePrompt = "Execute changes";
         if (validationMode === "STRICT_AFTER_COMPATIBLE") {
-            executeChangePrompt = "Execute optional changes";
+            choices.push({ name: "Skip them", value: "none" });
         }
-        if (err.destructive) {
-            executeChangePrompt = executeChangePrompt + " (including destructive changes)";
+        else {
+            choices.push({ name: "Abort", value: "abort" });
         }
-        const choices = [
-            { name: executeChangePrompt, value: "all" },
-            { name: "Abort changes", value: "none" },
-        ];
-        const defaultValue = validationMode === "STRICT_AFTER_COMPATIBLE" ? "none" : "all";
-        return await (0, prompt_1.select)({ message, choices, default: defaultValue });
+        const ans = await (0, prompt_1.select)({
+            message: `Do you want to execute these SQL against ${instanceId}:${databaseId}?`,
+            choices: choices,
+            default: defaultChoice,
+        });
+        if (ans === "abort") {
+            throw new error_1.FirebaseError("Command aborted.");
+        }
+        return ans;
     }
     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";
+        return defaultChoice;
     }
     else if (!err.destructive) {
-        return "all";
+        return defaultChoice;
     }
     else {
         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");
@@ -362,7 +369,7 @@ 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", `The schema you are deploying is incompatible with the following existing connectors: ${clc.bold(connectorIds)}.`);
     (0, utils_1.logLabeledWarning)("dataconnect", `This is a ${clc.red("breaking")} change and may break existing apps.`);
 }
 async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, linkIfNotConnected) {
@@ -424,50 +431,61 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, dat
     }
 }
 exports.ensureServiceIsConnectedToCloudSql = ensureServiceIsConnectedToCloudSql;
-function displaySchemaChanges(error, validationMode, instanceName, databaseId) {
+function displayStartSchemaDiff(validationMode) {
+    switch (validationMode) {
+        case "COMPATIBLE":
+            (0, utils_1.logLabeledBullet)("dataconnect", `Generating SQL schema migrations to be compatible...`);
+            break;
+        case "STRICT":
+            (0, utils_1.logLabeledBullet)("dataconnect", `Generating SQL schema migrations to match exactly...`);
+            break;
+    }
+}
+function displayNoSchemaDiff(instanceId, databaseId, validationMode) {
+    switch (validationMode) {
+        case "COMPATIBLE":
+            (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema of ${instanceId}:${databaseId} is compatible with Data Connect Schema.`);
+            break;
+        case "STRICT":
+            (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema of ${instanceId}:${databaseId} matches Data Connect Schema exactly.`);
+            break;
+    }
+}
+function displaySchemaChanges(error, validationMode) {
     switch (error.violationType) {
         case "INCOMPATIBLE_SCHEMA":
             {
-                let message;
-                if (validationMode === "COMPATIBLE") {
-                    message =
-                        "Your PostgreSQL database " +
-                            databaseId +
-                            " in your CloudSQL instance " +
-                            instanceName +
-                            " must be migrated in order to be compatible with your application schema. " +
-                            "The following SQL statements will migrate your database schema to be compatible with your new Data Connect schema.\n" +
-                            error.diffs.map(toString).join("\n");
+                switch (validationMode) {
+                    case "COMPATIBLE":
+                        (0, utils_1.logLabeledWarning)("dataconnect", `PostgreSQL schema is incompatible with the Data Connect Schema.
+Those SQL statements will migrate it to be compatible:
+
+${diffsToString(error.diffs)}
+`);
+                        break;
+                    case "STRICT_AFTER_COMPATIBLE":
+                        (0, utils_1.logLabeledBullet)("dataconnect", `PostgreSQL schema contains unused SQL objects not part of the Data Connect Schema.
+Those SQL statements will migrate it to match exactly:
+
+${diffsToString(error.diffs)}
+`);
+                        break;
+                    case "STRICT":
+                        (0, utils_1.logLabeledWarning)("dataconnect", `PostgreSQL schema does not match the Data Connect Schema.
+Those SQL statements will migrate it to match exactly:
+
+${diffsToString(error.diffs)}
+`);
+                        break;
                 }
-                else if (validationMode === "STRICT_AFTER_COMPATIBLE") {
-                    message =
-                        "Your new application schema is compatible with the schema of your PostgreSQL database " +
-                            databaseId +
-                            " in your CloudSQL instance " +
-                            instanceName +
-                            ", but contains unused tables or columns. " +
-                            "The following optional SQL statements will migrate your database schema to match your new Data Connect schema.\n" +
-                            error.diffs.map(toString).join("\n");
-                }
-                else {
-                    message =
-                        "Your PostgreSQL database " +
-                            databaseId +
-                            " in your CloudSQL instance " +
-                            instanceName +
-                            " must be migrated in order to match your application schema. " +
-                            "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", `Cannot access CloudSQL database to validate schema.
+Here is the complete expected SQL schema:
+${diffsToString(error.diffs)}
+`);
                 (0, utils_1.logLabeledWarning)("dataconnect", "Some SQL resources may already exist.");
             }
             break;
@@ -475,6 +493,12 @@ function displaySchemaChanges(error, validationMode, instanceName, databaseId) {
             throw new error_1.FirebaseError(`Unknown schema violation type: ${error.violationType}, IncompatibleSqlSchemaError: ${error}`);
     }
 }
-function toString(diff) {
+function requireSuperUser(diff) {
+    return diff.sql.startsWith("CREATE EXTENSION") || diff.sql.startsWith("CREATE SCHEMA");
+}
+function diffsToString(diffs) {
+    return diffs.map(diffToString).join("\n\n");
+}
+function diffToString(diff) {
     return `\/** ${diff.destructive ? clc.red("Destructive: ") : ""}${diff.description}*\/\n${(0, sql_formatter_1.format)(diff.sql, { language: "postgresql" })}`;
 }

package/lib/deploy/dataconnect/prepare.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const clc = require("colorette");
 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");
@@ -26,9 +25,8 @@ async function default_1(context, options) {
     }
     await (0, ensureApis_1.ensureApis)(projectId);
     await (0, requireTosAcceptance_1.requireTosAcceptance)(firedata_1.DATA_CONNECT_TOS_ID)(options);
-    const serviceCfgs = (0, fileUtils_1.readFirebaseJson)(options.config);
     const filters = (0, filters_1.getResourceFilters)(options);
-    const serviceInfos = await Promise.all(serviceCfgs.map((c) => (0, load_1.load)(projectId, options.config, c.source)));
+    const serviceInfos = await (0, load_1.loadAll)(projectId, options.config);
     for (const si of serviceInfos) {
         si.deploymentMetadata = await (0, build_1.build)(options, si.sourceDirectory, options.dryRun);
     }

package/lib/deploy/dataconnect/release.js

@@ -6,6 +6,7 @@ const prompts_1 = require("../../dataconnect/prompts");
 const schemaMigration_1 = require("../../dataconnect/schemaMigration");
 const projectUtils_1 = require("../../projectUtils");
 const names_1 = require("../../dataconnect/names");
+const logger_1 = require("../../logger");
 async function default_1(context, options) {
     const project = (0, projectUtils_1.needProjectId)(options);
     const serviceInfos = context.dataconnect.serviceInfos;
@@ -24,19 +25,7 @@ async function default_1(context, options) {
             validationMode: (_d = (_c = (_b = (_a = s.dataConnectYaml) === null || _a === void 0 ? void 0 : _a.schema) === null || _b === void 0 ? void 0 : _b.datasource) === null || _c === void 0 ? void 0 : _c.postgresql) === null || _d === void 0 ? void 0 : _d.schemaValidation,
         });
     });
-    if (wantSchemas.length) {
-        for (const s of wantSchemas) {
-            await (0, schemaMigration_1.migrateSchema)({
-                options,
-                schema: s.schema,
-                validateOnly: false,
-                schemaValidation: s.validationMode,
-            });
-            utils.logLabeledSuccess("dataconnect", `Migrated schema ${s.schema.name}`);
-        }
-    }
-    let wantConnectors = [];
-    wantConnectors = wantConnectors.concat(...serviceInfos.map((si) => si.connectorInfo
+    const wantConnectors = serviceInfos.flatMap((si) => si.connectorInfo
         .filter((c) => {
         return (!filters ||
             filters.some((f) => {
@@ -44,22 +33,39 @@ async function default_1(context, options) {
                     (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) {
-        await Promise.all(wantConnectors.map(async (c) => {
+        .map((c) => c.connector));
+    const remainingConnectors = await Promise.all(wantConnectors.map(async (c) => {
+        try {
             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);
         }
+        catch (err) {
+            logger_1.logger.debug("Error pre-deploying connector", c.name, err);
+            return c;
+        }
+        utils.logLabeledSuccess("dataconnect", `Deployed connector ${c.name}`);
+        return undefined;
+    }));
+    for (const s of wantSchemas) {
+        await (0, schemaMigration_1.migrateSchema)({
+            options,
+            schema: s.schema,
+            validateOnly: false,
+            schemaValidation: s.validationMode,
+        });
+        utils.logLabeledSuccess("dataconnect", `Migrated schema ${s.schema.name}`);
     }
-    else {
-        utils.logLabeledBullet("dataconnect", "No connectors to deploy.");
+    await Promise.all(remainingConnectors.map(async (c) => {
+        if (c) {
+            await (0, client_1.upsertConnector)(c);
+            utils.logLabeledSuccess("dataconnect", `Deployed connector ${c.name}`);
+        }
+    }));
+    const allConnectors = await deployedConnectors(serviceInfos);
+    const connectorsToDelete = filters
+        ? []
+        : allConnectors.filter((h) => !wantConnectors.some((w) => w.name === h.name));
+    for (const c of connectorsToDelete) {
+        await (0, prompts_1.promptDeleteConnector)(options, c.name);
     }
     let consolePath = "/dataconnect";
     if (serviceInfos.length === 1) {
@@ -73,7 +79,7 @@ async function default_1(context, options) {
     return;
 }
 exports.default = default_1;
-async function have(serviceInfos) {
+async function deployedConnectors(serviceInfos) {
     let connectors = [];
     for (const si of serviceInfos) {
         connectors = connectors.concat(await (0, client_1.listConnectors)(si.serviceName));

package/lib/deploy/functions/prepare.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureAllRequiredAPIsEnabled = exports.warnIfNewGenkitFunctionIsMissingSecrets = exports.loadCodebases = exports.resolveCpuAndConcurrency = exports.inferBlockingDetails = exports.updateEndpointTargetedStatus = exports.inferDetailsFromExisting = exports.prepare = exports.EVENTARC_SOURCE_ENV = void 0;
 const clc = require("colorette");
+const proto = require("../../gcp/proto");
 const backend = require("./backend");
 const build = require("./build");
 const ensureApiEnabled = require("../../ensureApiEnabled");
@@ -76,6 +77,7 @@ async function prepare(context, options, payload) {
             projectId: projectId,
             projectAlias: options.projectAlias,
         };
+        proto.convertIfPresent(userEnvOpt, config, "configDir", (cd) => options.config.path(cd));
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
         const { backend: wantBackend, envs: resolvedEnvs } = await build.resolveBackend({

package/lib/emulator/controller.js

@@ -5,6 +5,7 @@ const clc = require("colorette");
 const fs = require("fs");
 const path = require("path");
 const fsConfig = require("../firestore/fsConfig");
+const proto = require("../gcp/proto");
 const logger_1 = require("../logger");
 const track_1 = require("../track");
 const utils = require("../utils");
@@ -43,7 +44,7 @@ const firestoreEmulator_1 = require("./firestoreEmulator");
 const hostingEmulator_1 = require("./hostingEmulator");
 const pubsubEmulator_1 = require("./pubsubEmulator");
 const storage_1 = require("./storage");
-const fileUtils_1 = require("../dataconnect/fileUtils");
+const load_1 = require("../dataconnect/load");
 const tasksEmulator_1 = require("./tasksEmulator");
 const apphosting_1 = require("./apphosting");
 const webhook_1 = require("../dataconnect/webhook");
@@ -344,7 +345,7 @@ async function startAll(options, showUI = true, runningTestScript = false) {
             if (runtime && !(0, supported_1.isRuntime)(runtime)) {
                 throw new error_1.FirebaseError(`Cannot load functions from ${functionsDir} because it has invalid runtime ${runtime}`);
             }
-            emulatableBackends.push({
+            const backend = {
                 functionsDir,
                 runtime,
                 codebase: cfg.codebase,
@@ -353,7 +354,9 @@ async function startAll(options, showUI = true, runningTestScript = false) {
                 secretEnv: [],
                 predefinedTriggers: options.extDevTriggers,
                 ignore: cfg.ignore,
-            });
+            };
+            proto.convertIfPresent(backend, cfg, "configDir", (cd) => path.join(projectDir, cd));
+            emulatableBackends.push(backend);
         }
     }
     if (extensionEmulator) {
@@ -556,7 +559,7 @@ async function startAll(options, showUI = true, runningTestScript = false) {
         await startEmulator(pubsubEmulator);
     }
     if (listenForEmulator.dataconnect) {
-        const config = (0, fileUtils_1.readFirebaseJson)(options.config);
+        const config = (0, load_1.readFirebaseJson)(options.config);
         if (!config.length) {
             throw new error_1.FirebaseError("No Data Connect service found in firebase.json");
         }