firebase-tools 14.12.1 → 14.14.0

package/lib/dataconnect/schemaMigration.js

@@ -16,97 +16,121 @@ const utils_1 = require("../utils");
 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) {
-    await (0, connect_1.setupIAMUsers)(instanceId, databaseId, options);
-    const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, options);
-    if (schemaInfo.setupStatus !== permissionsSetup_1.SchemaSetupStatus.BrownField &&
-        schemaInfo.setupStatus !== permissionsSetup_1.SchemaSetupStatus.GreenField) {
-        return await (0, permissionsSetup_1.setupSQLPermissions)(instanceId, databaseId, schemaInfo, options, true);
+    try {
+        await (0, connect_1.setupIAMUsers)(instanceId, options);
+        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, 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}`);
+        }
     }
-    else {
-        logger_1.logger.debug(`Detected schema "${schemaInfo.name}" is setup in ${schemaInfo.setupStatus} mode. Skipping Setup.`);
+    catch (err) {
+        throw new error_1.FirebaseError(`Cannot setup Postgres SQL permissions of Cloud SQL database ${instanceId}:${databaseId}\n${err}`);
     }
-    return schemaInfo.setupStatus;
 }
 async function diffSchema(options, schema, schemaValidation) {
-    (0, utils_1.logLabeledBullet)("dataconnect", `generating required schema changes...`);
+    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 diffs = [];
-    await setupSchemaIfNecessary(instanceId, databaseId, options);
-    let validationMode = schemaValidation !== null && schemaValidation !== void 0 ? schemaValidation : "COMPATIBLE";
-    setSchemaValidationMode(schema, validationMode);
+    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) {
-    (0, utils_1.logLabeledBullet)("dataconnect", `generating required schema changes...`);
+    var _a;
     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);
-    await (0, connect_1.setupIAMUsers)(instanceId, databaseId, options);
-    let diffs = [];
+    const existingInstance = await cloudSqlAdminClient.getInstance(projectId, instanceId);
+    if (existingInstance.state === "PENDING_CREATE") {
+        const postgresql = (_a = schema.datasources.find((d) => d.postgresql)) === null || _a === void 0 ? void 0 : _a.postgresql;
+        if (!postgresql) {
+            throw new error_1.FirebaseError(`Cannot find Postgres datasource in the schema to deploy: ${serviceName}/schemas/${types_1.SCHEMA_ID}.\nIts datasources: ${JSON.stringify(schema.datasources)}`);
+        }
+        postgresql.schemaValidation = "NONE";
+        postgresql.schemaMigration = undefined;
+        await (0, client_1.upsertSchema)(schema, validateOnly);
+        postgresql.schemaValidation = undefined;
+        postgresql.schemaMigration = "MIGRATE_COMPATIBLE";
+        await (0, client_1.upsertSchema)(schema, validateOnly, true);
+        (0, utils_1.logLabeledWarning)("dataconnect", `Skip SQL schema migration because Cloud SQL is still being created`);
+        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.logLabeledBullet)("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) {
@@ -115,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({
@@ -150,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,
@@ -169,22 +197,13 @@ exports.migrateSchema = migrateSchema;
 async function grantRoleToUserInSchema(options, schema) {
     const role = options.role;
     const email = options.email;
-    const { instanceId, 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 (0, connect_1.setupIAMUsers)(instanceId, databaseId, options);
-    const userIsCSQLAdmin = await (0, cloudsqladmin_1.iamUserIsCSQLAdmin)(options);
-    if (!userIsCSQLAdmin) {
-        throw new error_1.FirebaseError(`Only users with 'roles/cloudsql.admin' can grant SQL roles. If you do not have this role, ask your database administrator to run this command or manually grant ${fdcSqlRole} to ${user}`);
-    }
+    const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
     const schemaSetupStatus = await setupSchemaIfNecessary(instanceId, databaseId, options);
-    if (schemaSetupStatus !== permissionsSetup_1.SchemaSetupStatus.GreenField &&
-        fdcSqlRole === (0, permissions_1.firebaseowner)(databaseId, permissions_1.DEFAULT_SCHEMA)) {
-        throw new error_1.FirebaseError(`Owner rule isn't available in brownfield databases. If you would like Data Connect to manage and own your database schema, run 'firebase dataconnect:sql:setup'`);
+    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) {
@@ -207,15 +226,15 @@ function setSchemaValidationMode(schema, schemaValidation) {
     }
 }
 function getIdentifiers(schema) {
-    var _a, _b;
+    var _a, _b, _c;
     const postgresDatasource = schema.datasources.find((d) => d.postgresql);
     const databaseId = (_a = postgresDatasource === null || postgresDatasource === void 0 ? void 0 : postgresDatasource.postgresql) === null || _a === void 0 ? void 0 : _a.database;
     if (!databaseId) {
-        throw new error_1.FirebaseError("Service does not have a postgres datasource, cannot migrate");
+        throw new error_1.FirebaseError("Data Connect schema must have a postgres datasource with a database name.");
     }
-    const instanceName = (_b = postgresDatasource === null || postgresDatasource === void 0 ? void 0 : postgresDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.cloudSql.instance;
+    const instanceName = (_c = (_b = postgresDatasource === null || postgresDatasource === void 0 ? void 0 : postgresDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.cloudSql) === null || _c === void 0 ? void 0 : _c.instance;
     if (!instanceName) {
-        throw new error_1.FirebaseError("tried to migrate schema but instance name was not provided in dataconnect.yaml");
+        throw new error_1.FirebaseError("Data Connect schema must have a postgres datasource with a CloudSQL instance.");
     }
     const instanceId = instanceName.split("/").pop();
     const serviceName = schema.name.replace(`/schemas/${types_1.SCHEMA_ID}`, "");
@@ -235,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;
@@ -248,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) {
@@ -266,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");
@@ -344,17 +369,27 @@ 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, instanceId, databaseId, linkIfNotConnected) {
+async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, linkIfNotConnected) {
+    var _a, _b, _c, _d;
     let currentSchema = await (0, client_1.getSchema)(serviceName);
-    if (!currentSchema) {
+    let postgresql = (_b = (_a = currentSchema === null || currentSchema === void 0 ? void 0 : currentSchema.datasources) === null || _a === void 0 ? void 0 : _a.find((d) => d.postgresql)) === null || _b === void 0 ? void 0 : _b.postgresql;
+    if ((currentSchema === null || currentSchema === void 0 ? void 0 : currentSchema.reconciling) &&
+        (postgresql === null || postgresql === void 0 ? void 0 : postgresql.ephemeral) &&
+        ((_c = postgresql === null || postgresql === void 0 ? void 0 : postgresql.cloudSql) === null || _c === void 0 ? void 0 : _c.instance) &&
+        (postgresql === null || postgresql === void 0 ? void 0 : postgresql.schemaValidation) === "NONE") {
+        const [, , , , , serviceId] = serviceName.split("/");
+        const [, projectId, , , , instanceId] = postgresql.cloudSql.instance.split("/");
+        throw new error_1.FirebaseError(`While checking the service ${serviceId}, ` + (0, provisionCloudSql_1.cloudSQLBeingCreated)(projectId, instanceId));
+    }
+    if (!currentSchema || !postgresql) {
         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...`);
+        (0, utils_1.logLabeledBullet)("dataconnect", `Linking the Cloud SQL instance...`);
         currentSchema = {
             name: `${serviceName}/schemas/${types_1.SCHEMA_ID}`,
             source: {
@@ -362,84 +397,95 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, datab
             },
             datasources: [
                 {
-                    postgresql: {
-                        database: databaseId,
-                        schemaValidation: "NONE",
-                        cloudSql: {
-                            instance: instanceId,
-                        },
-                    },
+                    postgresql: { ephemeral: true },
                 },
             ],
         };
     }
-    const postgresDatasource = currentSchema.datasources.find((d) => d.postgresql);
-    const postgresql = postgresDatasource === null || postgresDatasource === void 0 ? void 0 : postgresDatasource.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 (!postgresql) {
+        postgresql = currentSchema.datasources[0].postgresql;
+    }
+    let alreadyConnected = !postgresql.ephemeral || false;
+    if (((_d = postgresql.cloudSql) === null || _d === void 0 ? void 0 : _d.instance) && postgresql.cloudSql.instance !== instanceName) {
+        alreadyConnected = false;
+        (0, utils_1.logLabeledWarning)("dataconnect", `Switching connected Cloud SQL instance\n From ${postgresql.cloudSql.instance}\n To ${instanceName}`);
     }
-    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.database && postgresql.database !== databaseId) {
+        alreadyConnected = false;
+        (0, utils_1.logLabeledWarning)("dataconnect", `Switching connected Postgres database from ${postgresql.database} to ${databaseId}`);
     }
-    if (!postgresql || postgresql.schemaValidation !== "NONE") {
+    if (alreadyConnected) {
         return;
     }
-    postgresql.schemaValidation = "STRICT";
     try {
+        postgresql.schemaValidation = "STRICT";
+        postgresql.database = databaseId;
+        postgresql.cloudSql = { instance: instanceName };
         await (0, client_1.upsertSchema)(currentSchema, false);
     }
     catch (err) {
         if ((err === null || err === void 0 ? void 0 : err.status) >= 500) {
             throw err;
         }
-        logger_1.logger.debug(err);
+        logger_1.logger.debug(`Failed to ensure service is connected to Cloud SQL: ${err.message}`);
     }
 }
 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");
-                }
-                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");
+                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;
                 }
-                (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;
@@ -447,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/deploy.js

@@ -33,12 +33,12 @@ async function default_1(context, options) {
         utils.logLabeledSuccess("dataconnect", `Created service ${s.serviceName}`);
     }));
     if (servicesToDelete.length) {
+        const serviceToDeleteList = servicesToDelete.map((s) => " - " + s.name).join("\n");
         if (await (0, prompt_1.confirm)({
-            force: options.force,
+            force: false,
             nonInteractive: options.nonInteractive,
-            message: `The following services exist on ${projectId} but are not listed in your 'firebase.json'\n${servicesToDelete
-                .map((s) => s.name)
-                .join("\n")}\nWould you like to delete these services?`,
+            message: `The following services exist on ${projectId} but are not listed in your 'firebase.json'\n${serviceToDeleteList}\nWould you like to delete these services?`,
+            default: false,
         })) {
             await Promise.all(servicesToDelete.map(async (s) => {
                 await client.deleteService(s.name);
@@ -52,22 +52,20 @@ async function default_1(context, options) {
         return !filters || (filters === null || filters === void 0 ? void 0 : filters.some((f) => si.dataConnectYaml.serviceId === f.serviceId));
     })
         .map(async (s) => {
-        var _a, _b;
+        var _a, _b, _c;
         const postgresDatasource = s.schema.datasources.find((d) => d.postgresql);
         if (postgresDatasource) {
-            const instanceId = (_a = postgresDatasource.postgresql) === null || _a === void 0 ? void 0 : _a.cloudSql.instance.split("/").pop();
-            const databaseId = (_b = postgresDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.database;
+            const instanceId = (_b = (_a = postgresDatasource.postgresql) === null || _a === void 0 ? void 0 : _a.cloudSql) === null || _b === void 0 ? void 0 : _b.instance.split("/").pop();
+            const databaseId = (_c = postgresDatasource.postgresql) === null || _c === void 0 ? void 0 : _c.database;
             if (!instanceId || !databaseId) {
                 return Promise.resolve();
             }
-            const enableGoogleMlIntegration = (0, types_1.requiresVector)(s.deploymentMetadata);
-            return (0, provisionCloudSql_1.provisionCloudSql)({
+            return (0, provisionCloudSql_1.setupCloudSql)({
                 projectId,
                 location: (0, names_1.parseServiceName)(s.serviceName).location,
                 instanceId,
                 databaseId,
-                enableGoogleMlIntegration,
-                waitForCreation: true,
+                requireGoogleMlIntegration: (0, types_1.requiresVector)(s.deploymentMetadata),
             });
         }
     }));