firebase-tools 14.13.0 → 14.14.0

package/lib/dataconnect/errors.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInvalidConnectors = exports.getIncompatibleSchemaError = void 0;
+exports.getGQLErrors = exports.getInvalidConnectors = exports.getIncompatibleSchemaError = void 0;
+const graphqlError_1 = require("./graphqlError");
 const INCOMPATIBLE_SCHEMA_ERROR_TYPESTRING = "IncompatibleSqlSchemaError";
 const PRECONDITION_ERROR_TYPESTRING = "type.googleapis.com/google.rpc.PreconditionFailure";
 const INCOMPATIBLE_CONNECTOR_TYPE = "INCOMPATIBLE_CONNECTOR";
@@ -31,6 +32,11 @@ function getInvalidConnectors(err) {
     return invalidConns;
 }
 exports.getInvalidConnectors = getInvalidConnectors;
+function getGQLErrors(err) {
+    const gqlErrs = errorDetails(err, "GraphqlError");
+    return gqlErrs.map(graphqlError_1.prettify).join("\n");
+}
+exports.getGQLErrors = getGQLErrors;
 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);

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/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");
@@ -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) {

package/lib/emulator/functionsEmulator.js

@@ -329,6 +329,7 @@ class FunctionsEmulator {
                 projectId: this.args.projectId,
                 projectAlias: this.args.projectAlias,
                 isEmulator: true,
+                configDir: emulatableBackend.configDir,
             };
             const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
             const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
@@ -879,6 +880,7 @@ class FunctionsEmulator {
     getUserEnvs(backend) {
         const projectInfo = {
             functionsSource: backend.functionsDir,
+            configDir: backend.configDir,
             projectId: this.args.projectId,
             projectAlias: this.args.projectAlias,
             isEmulator: true,

package/lib/functions/env.js

@@ -140,7 +140,7 @@ function parseStrict(data) {
     return envs;
 }
 exports.parseStrict = parseStrict;
-function findEnvfiles(functionsSource, projectId, projectAlias, isEmulator) {
+function findEnvfiles(configDir, projectId, projectAlias, isEmulator) {
     const files = [".env"];
     files.push(`.env.${projectId}`);
     if (projectAlias) {
@@ -150,26 +150,28 @@ function findEnvfiles(functionsSource, projectId, projectAlias, isEmulator) {
         files.push(FUNCTIONS_EMULATOR_DOTENV);
     }
     return files
-        .map((f) => path.join(functionsSource, f))
+        .map((f) => path.join(configDir, f))
         .filter(fs.existsSync)
         .map((p) => path.basename(p));
 }
-function hasUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
-    return findEnvfiles(functionsSource, projectId, projectAlias, isEmulator).length > 0;
+function hasUserEnvs(opts) {
+    const configDir = opts.configDir || opts.functionsSource;
+    return findEnvfiles(configDir, opts.projectId, opts.projectAlias, opts.isEmulator).length > 0;
 }
 exports.hasUserEnvs = hasUserEnvs;
 function writeUserEnvs(toWrite, envOpts) {
     if (Object.keys(toWrite).length === 0) {
         return;
     }
-    const { functionsSource, projectId, projectAlias, isEmulator } = envOpts;
-    const allEnvFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);
+    const { projectId, projectAlias, isEmulator } = envOpts;
+    const configDir = envOpts.configDir || envOpts.functionsSource;
+    const allEnvFiles = findEnvfiles(configDir, projectId, projectAlias, isEmulator);
     const targetEnvFile = envOpts.isEmulator
         ? FUNCTIONS_EMULATOR_DOTENV
         : `.env.${envOpts.projectId}`;
     const targetEnvFileExists = allEnvFiles.includes(targetEnvFile);
     if (!targetEnvFileExists) {
-        fs.writeFileSync(path.join(envOpts.functionsSource, targetEnvFile), "", { flag: "wx" });
+        fs.writeFileSync(path.join(configDir, targetEnvFile), "", { flag: "wx" });
         (0, utils_1.logBullet)(clc.yellow(clc.bold("functions: ")) +
             `Created new local file ${targetEnvFile} to store param values. We suggest explicitly adding or excluding this file from version control.`);
     }
@@ -186,7 +188,7 @@ function writeUserEnvs(toWrite, envOpts) {
     for (const k of Object.keys(toWrite)) {
         lines += formatUserEnvForWrite(k, toWrite[k]);
     }
-    fs.appendFileSync(path.join(functionsSource, targetEnvFile), lines);
+    fs.appendFileSync(path.join(configDir, targetEnvFile), lines);
 }
 exports.writeUserEnvs = writeUserEnvs;
 function checkForDuplicateKeys(isEmulator, keys, fullEnv, envsWithoutLocal) {
@@ -210,22 +212,24 @@ function formatUserEnvForWrite(key, value) {
     }
     return `${key}=${escapedValue}\n`;
 }
-function loadUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
+function loadUserEnvs(opts) {
     var _a;
-    const envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);
+    const configDir = opts.configDir || opts.functionsSource;
+    const envFiles = findEnvfiles(configDir, opts.projectId, opts.projectAlias, opts.isEmulator);
     if (envFiles.length === 0) {
         return {};
     }
-    if (projectAlias) {
-        if (envFiles.includes(`.env.${projectId}`) && envFiles.includes(`.env.${projectAlias}`)) {
-            throw new error_1.FirebaseError(`Can't have both dotenv files with projectId (env.${projectId}) ` +
-                `and projectAlias (.env.${projectAlias}) as extensions.`);
+    if (opts.projectAlias) {
+        if (envFiles.includes(`.env.${opts.projectId}`) &&
+            envFiles.includes(`.env.${opts.projectAlias}`)) {
+            throw new error_1.FirebaseError(`Can't have both dotenv files with projectId (env.${opts.projectId}) ` +
+                `and projectAlias (.env.${opts.projectAlias}) as extensions.`);
         }
     }
     let envs = {};
     for (const f of envFiles) {
         try {
-            const data = fs.readFileSync(path.join(functionsSource, f), "utf8");
+            const data = fs.readFileSync(path.join(configDir, f), "utf8");
             envs = Object.assign(Object.assign({}, envs), parseStrict(data));
         }
         catch (err) {

package/lib/gcp/cloudsql/connect.js

@@ -72,7 +72,7 @@ async function execute(sqlStatements, opts) {
         sqlStatements.push("COMMIT;");
     }
     for (const s of sqlStatements) {
-        logFn(`Executing: '${s}'`);
+        logFn(`> ${s}`);
         try {
             results.push(await conn.query(s));
         }
@@ -84,6 +84,7 @@ async function execute(sqlStatements, opts) {
         }
     }
     await cleanUpFn();
+    logFn(``);
     return results;
 }
 exports.execute = execute;

package/lib/gcp/cloudsql/permissionsSetup.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.brownfieldSqlSetup = exports.setupBrownfieldAsGreenfield = exports.getSchemaMetadata = exports.greenFieldSchemaSetup = exports.setupSQLPermissions = exports.checkSQLRoleIsGranted = exports.fdcSqlRoleMap = exports.SchemaSetupStatus = void 0;
+exports.grantRoleTo = exports.brownfieldSqlSetup = exports.setupBrownfieldAsGreenfield = exports.getSchemaMetadata = exports.greenFieldSchemaSetup = exports.setupSQLPermissions = exports.checkSQLRoleIsGranted = exports.fdcSqlRoleMap = exports.SchemaSetupStatus = void 0;
 const clc = require("colorette");
 const permissions_1 = require("./permissions");
 const cloudsqladmin_1 = require("./cloudsqladmin");
@@ -12,6 +12,7 @@ const connect_1 = require("./connect");
 const lodash_1 = require("lodash");
 const connect_2 = require("./connect");
 const utils = require("../../utils");
+const cloudSqlAdminClient = require("./cloudsqladmin");
 var SchemaSetupStatus;
 (function (SchemaSetupStatus) {
     SchemaSetupStatus["NotSetup"] = "not-setup";
@@ -220,3 +221,11 @@ async function brownfieldSqlSetup(instanceId, databaseId, schemaInfo, options, s
     await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, brownfieldSetupCmds, silent, true);
 }
 exports.brownfieldSqlSetup = brownfieldSqlSetup;
+async function grantRoleTo(options, instanceId, databaseId, role, email) {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const { user, mode } = (0, connect_2.toDatabaseUser)(email);
+    await cloudSqlAdminClient.createUser(projectId, instanceId, mode, user);
+    const fdcSqlRole = exports.fdcSqlRoleMap[role](databaseId);
+    await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, [`GRANT "${fdcSqlRole}" TO "${user}"`], false);
+}
+exports.grantRoleTo = grantRoleTo;

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

@@ -154,7 +154,7 @@ async function actuateWithInfo(setup, config, info, options) {
                 path: "./example",
                 files: [
                     {
-                        path: "queries",
+                        path: "queries.gql",
                         content: operationGql,
                     },
                 ],

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

@@ -135,7 +135,7 @@ async function generateSdkYaml(targetPlatform, connectorYaml, connectorDir, appD
     if (targetPlatform === types_1.Platform.IOS) {
         const swiftSdk = {
             outputDir: path.relative(connectorDir, path.join(appDir, `dataconnect-generated/swift`)),
-            package: (0, lodash_1.upperFirst)((0, lodash_1.camelCase)(connectorYaml.connectorId)) + "Connector",
+            package: "DataConnectGenerated",
         };
         connectorYaml.generate.swiftSdk = swiftSdk;
     }
@@ -144,7 +144,7 @@ async function generateSdkYaml(targetPlatform, connectorYaml, connectorDir, appD
         const packageJsonDir = path.relative(connectorDir, appDir);
         const javascriptSdk = {
             outputDir: path.relative(connectorDir, path.join(appDir, `dataconnect-generated/js/${pkg}`)),
-            package: `@firebasegen/${pkg}`,
+            package: `@dataconnect/generated`,
             packageJsonDir,
         };
         const packageJson = await (0, fileUtils_1.resolvePackageJson)(appDir);
@@ -161,14 +161,14 @@ async function generateSdkYaml(targetPlatform, connectorYaml, connectorDir, appD
         const pkg = `${(0, lodash_1.snakeCase)(connectorYaml.connectorId)}_connector`;
         const dartSdk = {
             outputDir: path.relative(connectorDir, path.join(appDir, `dataconnect-generated/dart/${pkg}`)),
-            package: pkg,
+            package: "dataconnect_generated",
         };
         connectorYaml.generate.dartSdk = dartSdk;
     }
     if (targetPlatform === types_1.Platform.ANDROID) {
         const kotlinSdk = {
             outputDir: path.relative(connectorDir, path.join(appDir, `dataconnect-generated/kotlin`)),
-            package: `connectors.${(0, lodash_1.snakeCase)(connectorYaml.connectorId)}`,
+            package: `com.google.firebase.dataconnect.generated`,
         };
         for (const candidateSubdir of ["app/src/main/java", "app/src/main/kotlin"]) {
             const candidateDir = path.join(appDir, candidateSubdir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "14.13.0",
+  "version": "14.14.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {

package/schema/firebase-config.json

@@ -247,6 +247,9 @@
                 "codebase": {
                     "type": "string"
                 },
+                "configDir": {
+                    "type": "string"
+                },
                 "ignore": {
                     "items": {
                         "type": "string"