firebase-tools 13.17.0 → 13.18.0

package/lib/commands/dataconnect-services-list.js

@@ -36,14 +36,15 @@ exports.command = new command_1.Command("dataconnect:services:list")
     for (const service of services) {
         const schema = (_a = (await client.getSchema(service.name))) !== null && _a !== void 0 ? _a : {
             name: "",
-            primaryDatasource: {},
+            datasources: [{}],
             source: { files: [] },
         };
         const connectors = await client.listConnectors(service.name);
         const serviceName = names.parseServiceName(service.name);
-        const instanceName = (_c = (_b = schema === null || schema === void 0 ? void 0 : schema.primaryDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.cloudSql.instance) !== null && _c !== void 0 ? _c : "";
+        const postgresDatasource = schema === null || schema === void 0 ? void 0 : schema.datasources.find((d) => d.postgresql);
+        const instanceName = (_c = (_b = postgresDatasource === null || postgresDatasource === void 0 ? void 0 : postgresDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.cloudSql.instance) !== null && _c !== void 0 ? _c : "";
         const instanceId = instanceName.split("/").pop();
-        const dbId = (_e = (_d = schema === null || schema === void 0 ? void 0 : schema.primaryDatasource.postgresql) === null || _d === void 0 ? void 0 : _d.database) !== null && _e !== void 0 ? _e : "";
+        const dbId = (_e = (_d = postgresDatasource === null || postgresDatasource === void 0 ? void 0 : postgresDatasource.postgresql) === null || _d === void 0 ? void 0 : _d.database) !== null && _e !== void 0 ? _e : "";
         const dbName = `CloudSQL Instance: ${instanceId}\nDatabase: ${dbId}`;
         table.push([
             serviceName.serviceId,

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const projectUtils_1 = require("../projectUtils");
+const ensureApis_1 = require("../dataconnect/ensureApis");
+const requirePermissions_1 = require("../requirePermissions");
+const fileUtils_1 = require("../dataconnect/fileUtils");
+const schemaMigration_1 = require("../dataconnect/schemaMigration");
+const requireAuth_1 = require("../requireAuth");
+const error_1 = require("../error");
+const permissions_1 = require("../gcp/cloudsql/permissions");
+const allowedRoles = Object.keys(permissions_1.fdcSqlRoleMap);
+exports.command = new command_1.Command("dataconnect:sql:grant [serviceId]")
+    .description("Grants the SQL role <role> to the provided user or service account <email>.")
+    .option("-R, --role <role>", "The SQL role to grant. One of: owner, writer, or reader.")
+    .option("-E, --email <email>", "The email of the user or service account we would like to grant the role to.")
+    .before(requirePermissions_1.requirePermissions, ["firebasedataconnect.services.list"])
+    .before(requireAuth_1.requireAuth)
+    .action(async (serviceId, options) => {
+    const role = options.role;
+    const email = options.email;
+    if (!role) {
+        throw new error_1.FirebaseError("-R, --role <role> is required. Run the command with -h for more info.");
+    }
+    if (!email) {
+        throw new error_1.FirebaseError("-E, --email <email> is required. Run the command with -h for more info.");
+    }
+    if (!allowedRoles.includes(role.toLowerCase())) {
+        throw new error_1.FirebaseError(`Role should be one of ${allowedRoles.join(" | ")}.`);
+    }
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    await (0, ensureApis_1.ensureApis)(projectId);
+    const serviceInfo = await (0, fileUtils_1.pickService)(projectId, options.config, serviceId);
+    await (0, schemaMigration_1.grantRoleToUserInSchema)(options, serviceInfo.schema);
+    return { projectId, serviceId };
+});

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

@@ -21,7 +21,7 @@ exports.command = new command_1.Command("dataconnect:sql:migrate [serviceId]")
     .before(requireAuth_1.requireAuth)
     .withForce("Execute any required database changes without prompting")
     .action(async (serviceId, options) => {
-    var _a;
+    var _a, _b;
     const projectId = (0, projectUtils_1.needProjectId)(options);
     await (0, ensureApis_1.ensureApis)(projectId);
     const serviceInfo = await (0, fileUtils_1.pickService)(projectId, options.config, serviceId);
@@ -33,6 +33,7 @@ exports.command = new command_1.Command("dataconnect:sql:migrate [serviceId]")
         options,
         schema: serviceInfo.schema,
         validateOnly: true,
+        schemaValidation: (_b = serviceInfo.dataConnectYaml.schema.datasource.postgresql) === null || _b === void 0 ? void 0 : _b.schemaValidation,
     });
     if (diffs.length) {
         (0, utils_1.logLabeledSuccess)("dataconnect", `Database schema sucessfully migrated! Run 'firebase deploy' to deploy your new schema to your Data Connect service.`);

package/lib/commands/deploy.js

@@ -86,6 +86,8 @@ exports.command = new command_1.Command("deploy")
     "For data connect, can specify filters with colons to deploy only a service, connector, or schema" +
     '(e.g. "--only dataconnect:serviceId,dataconnect:serviceId:connectorId,dataconnect:serviceId:schema"). ')
     .option("--except <targets>", 'deploy to all targets except specified (e.g. "database")')
+    .option("--dry-run", "Perform a dry run of your deployment. Validates your changes and builds your code without deploying any changes to your project. " +
+    "In order to provide better validation, this may still enable APIs on the target project.")
     .before(requireConfig_1.requireConfig)
     .before((options) => {
     options.filteredTargets = (0, filterTargets_1.filterTargets)(options, exports.VALID_DEPLOY_TARGETS);

package/lib/commands/index.js

@@ -207,6 +207,7 @@ function load(client) {
     client.dataconnect.sql = {};
     client.dataconnect.sql.diff = loadCommand("dataconnect-sql-diff");
     client.dataconnect.sql.migrate = loadCommand("dataconnect-sql-migrate");
+    client.dataconnect.sql.grant = loadCommand("dataconnect-sql-grant");
     client.dataconnect.sdk = {};
     client.dataconnect.sdk.generate = loadCommand("dataconnect-sdk-generate");
     client.target = loadCommand("target");

package/lib/dataconnect/client.js

@@ -5,7 +5,7 @@ const api_1 = require("../api");
 const apiv2_1 = require("../apiv2");
 const operationPoller = require("../operation-poller");
 const types = require("./types");
-const DATACONNECT_API_VERSION = "v1alpha";
+const DATACONNECT_API_VERSION = "v1beta";
 const PAGE_SIZE_MAX = 100;
 const dataconnectClient = () => new apiv2_1.Client({
     urlPrefix: (0, api_1.dataconnectOrigin)(),

package/lib/dataconnect/dataplaneClient.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeGraphQL = void 0;
 const api_1 = require("../api");
 const apiv2_1 = require("../apiv2");
-const DATACONNECT_API_VERSION = "v1alpha";
+const DATACONNECT_API_VERSION = "v1beta";
 const dataconnectDataplaneClient = () => new apiv2_1.Client({
     urlPrefix: (0, api_1.dataconnectOrigin)(),
     apiVersion: DATACONNECT_API_VERSION,

package/lib/dataconnect/ensureApis.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureApis = void 0;
+exports.ensureSparkApis = exports.ensureApis = void 0;
 const api = require("../api");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
 async function ensureApis(projectId) {
@@ -10,3 +10,9 @@ async function ensureApis(projectId) {
     await (0, ensureApiEnabled_1.ensure)(projectId, api.computeOrigin(), prefix);
 }
 exports.ensureApis = ensureApis;
+async function ensureSparkApis(projectId) {
+    const prefix = "dataconnect";
+    await (0, ensureApiEnabled_1.ensure)(projectId, api.dataconnectOrigin(), prefix);
+    await (0, ensureApiEnabled_1.ensure)(projectId, api.cloudSQLAdminOrigin(), prefix);
+}
+exports.ensureSparkApis = ensureSparkApis;

package/lib/dataconnect/load.js

@@ -30,7 +30,9 @@ async function load(projectId, config, sourceDirectory) {
         sourceDirectory: resolvedDir,
         schema: {
             name: `${serviceName}/schemas/${types_1.SCHEMA_ID}`,
-            primaryDatasource: (0, types_1.toDatasource)(projectId, dataConnectYaml.location, dataConnectYaml.schema.datasource),
+            datasources: [
+                (0, types_1.toDatasource)(projectId, dataConnectYaml.location, dataConnectYaml.schema.datasource),
+            ],
             source: {
                 files: schemaGQLs,
             },

package/lib/dataconnect/provisionCloudSql.js

@@ -11,19 +11,22 @@ const freeTrial_1 = require("./freeTrial");
 const error_1 = require("../error");
 async function provisionCloudSql(args) {
     let connectionName = "";
-    const { projectId, locationId, instanceId, databaseId, enableGoogleMlIntegration, waitForCreation, silent, } = args;
+    const { projectId, locationId, instanceId, databaseId, enableGoogleMlIntegration, waitForCreation, silent, dryRun, } = args;
     try {
         const existingInstance = await cloudSqlAdminClient.getInstance(projectId, instanceId);
         silent || utils.logLabeledBullet("dataconnect", `Found existing instance ${instanceId}.`);
         connectionName = (existingInstance === null || existingInstance === void 0 ? void 0 : existingInstance.connectionName) || "";
         const why = getUpdateReason(existingInstance, enableGoogleMlIntegration);
         if (why) {
+            const cta = dryRun
+                ? `It will be updated on your next deploy.`
+                : `Updating instance. This may take a few minutes...`;
             silent ||
-                utils.logLabeledBullet("dataconnect", `Instance ${instanceId} settings not compatible with Firebase Data Connect. ` +
-                    `Updating instance. This may take a few minutes...` +
-                    why);
-            await (0, utils_1.promiseWithSpinner)(() => cloudSqlAdminClient.updateInstanceForDataConnect(existingInstance, enableGoogleMlIntegration), "Updating your instance...");
-            silent || utils.logLabeledBullet("dataconnect", "Instance updated");
+                utils.logLabeledBullet("dataconnect", `Instance ${instanceId} settings not compatible with Firebase Data Connect. ` + cta + why);
+            if (!dryRun) {
+                await (0, utils_1.promiseWithSpinner)(() => cloudSqlAdminClient.updateInstanceForDataConnect(existingInstance, enableGoogleMlIntegration), "Updating your instance...");
+                silent || utils.logLabeledBullet("dataconnect", "Instance updated");
+            }
         }
     }
     catch (err) {
@@ -35,19 +38,23 @@ async function provisionCloudSql(args) {
             (0, freeTrial_1.printFreeTrialUnavailable)(projectId, freeTrialInstanceId);
             throw new error_1.FirebaseError("Free trial unavailable.");
         }
+        const cta = dryRun ? "It will be created on your next deploy" : "Creating it now.";
         silent ||
-            utils.logLabeledBullet("dataconnect", `CloudSQL instance '${instanceId}' not found, creating it.` +
+            utils.logLabeledBullet("dataconnect", `CloudSQL instance '${instanceId}' not found.` +
+                cta +
                 `\nThis instance is provided under the terms of the Data Connect free trial ${(0, freeTrial_1.freeTrialTermsLink)()}` +
                 `\nMonitor the progress at ${cloudSqlAdminClient.instanceConsoleLink(projectId, instanceId)}`);
-        const newInstance = await (0, utils_1.promiseWithSpinner)(() => cloudSqlAdminClient.createInstance(projectId, locationId, instanceId, enableGoogleMlIntegration, waitForCreation), "Creating your instance...");
-        if (newInstance) {
-            silent || utils.logLabeledBullet("dataconnect", "Instance created");
-            connectionName = (newInstance === null || newInstance === void 0 ? void 0 : newInstance.connectionName) || "";
-        }
-        else {
-            silent ||
-                utils.logLabeledBullet("dataconnect", "Cloud SQL instance creation started - it should be ready shortly. Database and users will be created on your next deploy.");
-            return connectionName;
+        if (!dryRun) {
+            const newInstance = await (0, utils_1.promiseWithSpinner)(() => cloudSqlAdminClient.createInstance(projectId, locationId, instanceId, enableGoogleMlIntegration, waitForCreation), "Creating your instance...");
+            if (newInstance) {
+                silent || utils.logLabeledBullet("dataconnect", "Instance created");
+                connectionName = (newInstance === null || newInstance === void 0 ? void 0 : newInstance.connectionName) || "";
+            }
+            else {
+                silent ||
+                    utils.logLabeledBullet("dataconnect", "Cloud SQL instance creation started - it should be ready shortly. Database and users will be created on your next deploy.");
+                return connectionName;
+            }
         }
     }
     try {
@@ -56,17 +63,23 @@ async function provisionCloudSql(args) {
     }
     catch (err) {
         if (err.status === 404) {
-            silent ||
-                utils.logLabeledBullet("dataconnect", `Database ${databaseId} not found, creating it now...`);
-            await cloudSqlAdminClient.createDatabase(projectId, instanceId, databaseId);
-            silent || utils.logLabeledBullet("dataconnect", `Database ${databaseId} created.`);
+            if (dryRun) {
+                silent ||
+                    utils.logLabeledBullet("dataconnect", `Database ${databaseId} not found. It will be created on your next deploy.`);
+            }
+            else {
+                silent ||
+                    utils.logLabeledBullet("dataconnect", `Database ${databaseId} not found, creating it now...`);
+                await cloudSqlAdminClient.createDatabase(projectId, instanceId, databaseId);
+                silent || utils.logLabeledBullet("dataconnect", `Database ${databaseId} created.`);
+            }
         }
         else {
             logger_1.logger.debug(`Unexpected error from CloudSQL: ${err}`);
             silent || utils.logLabeledWarning("dataconnect", `Database ${databaseId} is not accessible.`);
         }
     }
-    if (enableGoogleMlIntegration) {
+    if (enableGoogleMlIntegration && !dryRun) {
         await (0, checkIam_1.grantRolesToCloudSqlServiceAccount)(projectId, instanceId, [GOOGLE_ML_INTEGRATION_ROLE]);
     }
     return connectionName;

package/lib/dataconnect/schemaMigration.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrateSchema = exports.diffSchema = void 0;
+exports.grantRoleToUserInSchema = exports.migrateSchema = exports.diffSchema = void 0;
 const clc = require("colorette");
 const sql_formatter_1 = require("sql-formatter");
 const types_1 = require("./types");
 const client_1 = require("./client");
 const connect_1 = require("../gcp/cloudsql/connect");
 const permissions_1 = require("../gcp/cloudsql/permissions");
+const cloudSqlAdminClient = require("../gcp/cloudsql/cloudsqladmin");
+const projectUtils_1 = require("../projectUtils");
 const prompt_1 = require("../prompt");
 const logger_1 = require("../logger");
 const error_1 = require("../error");
@@ -17,15 +19,9 @@ async function diffSchema(schema, schemaValidation) {
     const { serviceName, instanceName, databaseId } = getIdentifiers(schema);
     await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
     let diffs = [];
-    let validationMode = "STRICT";
-    if (experiments.isEnabled("fdccompatiblemode")) {
-        if (!schemaValidation) {
-            validationMode = "COMPATIBLE";
-        }
-        else {
-            validationMode = schemaValidation;
-        }
-    }
+    let validationMode = experiments.isEnabled("fdccompatiblemode")
+        ? schemaValidation !== null && schemaValidation !== void 0 ? schemaValidation : "COMPATIBLE"
+        : "STRICT";
     setSchemaValidationMode(schema, validationMode);
     try {
         if (!schemaValidation && experiments.isEnabled("fdccompatiblemode")) {
@@ -56,33 +52,31 @@ async function diffSchema(schema, schemaValidation) {
             diffs = incompatible.diffs;
         }
     }
-    if (experiments.isEnabled("fdccompatiblemode")) {
-        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`);
+    if (experiments.isEnabled("fdccompatiblemode") && !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;
             }
-            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;
+            const incompatible = errors.getIncompatibleSchemaError(err);
+            if (incompatible) {
+                if (!diffsEqual(diffs, incompatible.diffs)) {
+                    if (diffs.length === 0) {
+                        displaySchemaChanges(incompatible, "STRICT_AFTER_COMPATIBLE", instanceName, databaseId);
                     }
                     else {
-                        (0, utils_1.logLabeledSuccess)("dataconnect", `no additional optional changes`);
+                        displaySchemaChanges(incompatible, validationMode, instanceName, databaseId);
                     }
+                    diffs = incompatible.diffs;
+                }
+                else {
+                    (0, utils_1.logLabeledSuccess)("dataconnect", `no additional optional changes`);
                 }
             }
         }
@@ -91,10 +85,13 @@ async function diffSchema(schema, schemaValidation) {
 }
 exports.diffSchema = diffSchema;
 async function migrateSchema(args) {
-    const { options, schema, validateOnly } = args;
+    const { options, schema, validateOnly, schemaValidation } = args;
     const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
     await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, true);
-    const validationMode = experiments.isEnabled("fdccompatiblemode") ? "COMPATIBLE" : "STRICT";
+    let diffs = [];
+    let validationMode = experiments.isEnabled("fdccompatiblemode")
+        ? schemaValidation !== null && schemaValidation !== void 0 ? schemaValidation : "COMPATIBLE"
+        : "STRICT";
     setSchemaValidationMode(schema, validationMode);
     try {
         await (0, client_1.upsertSchema)(schema, validateOnly);
@@ -111,7 +108,6 @@ async function migrateSchema(args) {
         }
         const migrationMode = await promptForSchemaMigration(options, instanceName, databaseId, incompatible, validateOnly, validationMode);
         const shouldDeleteInvalidConnectors = await promptForInvalidConnectorError(options, serviceName, invalidConnectors, validateOnly);
-        let diffs = [];
         if (incompatible) {
             diffs = await handleIncompatibleSchemaError({
                 options,
@@ -127,11 +123,54 @@ async function migrateSchema(args) {
         if (!validateOnly) {
             await (0, client_1.upsertSchema)(schema, validateOnly);
         }
-        return diffs;
     }
-    return [];
+    if (experiments.isEnabled("fdccompatiblemode") && !schemaValidation) {
+        validationMode = "STRICT";
+        setSchemaValidationMode(schema, validationMode);
+        try {
+            await (0, client_1.upsertSchema)(schema, validateOnly);
+        }
+        catch (err) {
+            if (err.status !== 400) {
+                throw err;
+            }
+            const incompatible = errors.getIncompatibleSchemaError(err);
+            const invalidConnectors = errors.getInvalidConnectors(err);
+            if (!incompatible && !invalidConnectors.length) {
+                throw err;
+            }
+            const migrationMode = await promptForSchemaMigration(options, instanceName, databaseId, incompatible, validateOnly, "STRICT_AFTER_COMPATIBLE");
+            if (incompatible) {
+                const maybeDiffs = await handleIncompatibleSchemaError({
+                    options,
+                    databaseId,
+                    instanceId,
+                    incompatibleSchemaError: incompatible,
+                    choice: migrationMode,
+                });
+                diffs = diffs.concat(maybeDiffs);
+            }
+        }
+    }
+    return diffs;
 }
 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 = permissions_1.fdcSqlRoleMap[role](databaseId);
+    const userIsCSQLAdmin = await (0, permissions_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}`);
+    }
+    await (0, connect_1.setupIAMUsers)(instanceId, databaseId, options);
+    await cloudSqlAdminClient.createUser(projectId, instanceId, mode, user);
+    await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, [`GRANT "${fdcSqlRole}" TO "${user}"`], false);
+}
+exports.grantRoleToUserInSchema = grantRoleToUserInSchema;
 function diffsEqual(x, y) {
     if (x.length !== y.length) {
         return false;
@@ -146,17 +185,21 @@ function diffsEqual(x, y) {
     return true;
 }
 function setSchemaValidationMode(schema, schemaValidation) {
-    if (experiments.isEnabled("fdccompatiblemode") && schema.primaryDatasource.postgresql) {
-        schema.primaryDatasource.postgresql.schemaValidation = schemaValidation;
+    if (experiments.isEnabled("fdccompatiblemode")) {
+        const postgresDatasource = schema.datasources.find((d) => d.postgresql);
+        if (postgresDatasource === null || postgresDatasource === void 0 ? void 0 : postgresDatasource.postgresql) {
+            postgresDatasource.postgresql.schemaValidation = schemaValidation;
+        }
     }
 }
 function getIdentifiers(schema) {
     var _a, _b;
-    const databaseId = (_a = schema.primaryDatasource.postgresql) === null || _a === void 0 ? void 0 : _a.database;
+    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("Schema is missing primaryDatasource.postgresql?.database, cannot migrate");
+        throw new error_1.FirebaseError("Service does not have a postgres datasource, cannot migrate");
     }
-    const instanceName = (_b = schema.primaryDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.cloudSql.instance;
+    const instanceName = (_b = postgresDatasource === null || postgresDatasource === void 0 ? void 0 : postgresDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.cloudSql.instance;
     if (!instanceName) {
         throw new error_1.FirebaseError("tried to migrate schema but instance name was not provided in dataconnect.yaml");
     }
@@ -218,28 +261,38 @@ async function handleIncompatibleSchemaError(args) {
     }
     return [];
 }
-async function promptForSchemaMigration(options, instanceName, databaseId, err, validateOnly, schemaValidation) {
+async function promptForSchemaMigration(options, instanceName, databaseId, err, validateOnly, validationMode) {
     if (!err) {
         return "none";
     }
-    displaySchemaChanges(err, schemaValidation, instanceName, databaseId);
+    if (validationMode === "STRICT_AFTER_COMPATIBLE" && (options.nonInteractive || options.force)) {
+        return "none";
+    }
+    displaySchemaChanges(err, validationMode, instanceName, databaseId);
     if (!options.nonInteractive) {
         if (validateOnly && options.force) {
             return "all";
         }
-        const choices = err.destructive
-            ? [
-                { name: "Execute all changes (including destructive changes)", value: "all" },
-                { name: "Abort changes", value: "none" },
-            ]
-            : [
-                { name: "Execute changes", value: "all" },
-                { name: "Abort changes", value: "none" },
-            ];
+        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";
+        }
+        if (err.destructive) {
+            executeChangePrompt = executeChangePrompt + " (including destructive changes)";
+        }
+        const choices = [
+            { name: executeChangePrompt, value: "all" },
+            { name: "Abort changes", value: "none" },
+        ];
+        const defaultValue = validationMode === "STRICT_AFTER_COMPATIBLE" ? "none" : "all";
         return await (0, prompt_1.promptOnce)({
-            message: `Would you like to execute these changes against ${databaseId}?`,
+            message: message,
             type: "list",
             choices,
+            default: defaultValue,
         });
     }
     if (!validateOnly) {
@@ -261,10 +314,7 @@ async function promptForInvalidConnectorError(options, serviceName, invalidConne
     }
     displayInvalidConnectors(invalidConnectors);
     if (validateOnly) {
-        if (options.force) {
-            return false;
-        }
-        throw new error_1.FirebaseError(`Command aborted. If you'd like to migrate it anyway, you may override with --force.`);
+        return false;
     }
     if (options.force) {
         return true;
@@ -297,17 +347,20 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, datab
             source: {
                 files: [],
             },
-            primaryDatasource: {
-                postgresql: {
-                    database: databaseId,
-                    cloudSql: {
-                        instance: instanceId,
+            datasources: [
+                {
+                    postgresql: {
+                        database: databaseId,
+                        cloudSql: {
+                            instance: instanceId,
+                        },
                     },
                 },
-            },
+            ],
         };
     }
-    const postgresql = currentSchema.primaryDatasource.postgresql;
+    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}`);
     }
@@ -328,22 +381,22 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceId, datab
         logger_1.logger.debug(err);
     }
 }
-function displaySchemaChanges(error, schemaValidation, instanceName, databaseId) {
+function displaySchemaChanges(error, validationMode, instanceName, databaseId) {
     switch (error.violationType) {
         case "INCOMPATIBLE_SCHEMA":
             {
                 let message;
-                if (schemaValidation === "COMPATIBLE") {
+                if (validationMode === "COMPATIBLE") {
                     message =
-                        "Your new application schema is incompatible with the schema of your PostgreSQL database " +
+                        "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 (schemaValidation === "STRICT_AFTER_COMPATIBLE") {
+                else if (validationMode === "STRICT_AFTER_COMPATIBLE") {
                     message =
                         "Your new application schema is compatible with the schema of your PostgreSQL database " +
                             databaseId +
@@ -355,11 +408,11 @@ function displaySchemaChanges(error, schemaValidation, instanceName, databaseId)
                 }
                 else {
                     message =
-                        "Your new application schema does not match the schema of your PostgreSQL database " +
+                        "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");
                 }

package/lib/deploy/dataconnect/deploy.js

@@ -44,20 +44,23 @@ async function default_1(context, options) {
     })
         .map(async (s) => {
         var _a, _b;
-        const instanceId = (_a = s.schema.primaryDatasource.postgresql) === null || _a === void 0 ? void 0 : _a.cloudSql.instance.split("/").pop();
-        const databaseId = (_b = s.schema.primaryDatasource.postgresql) === null || _b === void 0 ? void 0 : _b.database;
-        if (!instanceId || !databaseId) {
-            return Promise.resolve();
+        const 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;
+            if (!instanceId || !databaseId) {
+                return Promise.resolve();
+            }
+            const enableGoogleMlIntegration = (0, types_1.requiresVector)(s.deploymentMetadata);
+            return (0, provisionCloudSql_1.provisionCloudSql)({
+                projectId,
+                locationId: (0, names_1.parseServiceName)(s.serviceName).location,
+                instanceId,
+                databaseId,
+                enableGoogleMlIntegration,
+                waitForCreation: true,
+            });
         }
-        const enableGoogleMlIntegration = (0, types_1.requiresVector)(s.deploymentMetadata);
-        return (0, provisionCloudSql_1.provisionCloudSql)({
-            projectId,
-            locationId: (0, names_1.parseServiceName)(s.serviceName).location,
-            instanceId,
-            databaseId,
-            enableGoogleMlIntegration,
-            waitForCreation: true,
-        });
     }));
     return;
 }