firebase-tools 13.17.0 → 13.19.0

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;
 }

package/lib/deploy/dataconnect/prepare.js

@@ -11,8 +11,13 @@ const build_1 = require("../../dataconnect/build");
 const ensureApis_1 = require("../../dataconnect/ensureApis");
 const requireTosAcceptance_1 = require("../../requireTosAcceptance");
 const firedata_1 = require("../../gcp/firedata");
+const provisionCloudSql_1 = require("../../dataconnect/provisionCloudSql");
+const names_1 = require("../../dataconnect/names");
 const error_1 = require("../../error");
+const types_1 = require("../../dataconnect/types");
+const schemaMigration_1 = require("../../dataconnect/schemaMigration");
 async function default_1(context, options) {
+    var _a;
     const projectId = (0, projectUtils_1.needProjectId)(options);
     await (0, ensureApis_1.ensureApis)(projectId);
     await (0, requireTosAcceptance_1.requireTosAcceptance)(firedata_1.DATA_CONNECT_TOS_ID)(options);
@@ -41,6 +46,37 @@ async function default_1(context, options) {
         filters,
     };
     utils.logLabeledBullet("dataconnect", `Successfully prepared schema and connectors`);
+    if (options.dryRun) {
+        for (const si of serviceInfos) {
+            await (0, schemaMigration_1.diffSchema)(si.schema, (_a = si.dataConnectYaml.schema.datasource.postgresql) === null || _a === void 0 ? void 0 : _a.schemaValidation);
+        }
+        utils.logLabeledBullet("dataconnect", "Checking for CloudSQL resources...");
+        await Promise.all(serviceInfos
+            .filter((si) => {
+            return !filters || (filters === null || filters === void 0 ? void 0 : filters.some((f) => si.dataConnectYaml.serviceId === f.serviceId));
+        })
+            .map(async (s) => {
+            var _a, _b;
+            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,
+                    dryRun: options.dryRun,
+                });
+            }
+        }));
+    }
     logger_1.logger.debug(JSON.stringify(context.dataconnect, null, 2));
     return;
 }

package/lib/deploy/dataconnect/release.js

@@ -14,14 +14,21 @@ async function default_1(context, options) {
                 return f.serviceId === si.dataConnectYaml.serviceId && (f.schemaOnly || f.fullService);
             }));
     })
-        .map((s) => s.schema);
+        .map((s) => {
+        var _a;
+        return ({
+            schema: s.schema,
+            validationMode: (_a = s.dataConnectYaml.schema.datasource.postgresql) === null || _a === void 0 ? void 0 : _a.schemaValidation,
+        });
+    });
     if (wantSchemas.length) {
         utils.logLabeledBullet("dataconnect", "Releasing Data Connect schemas...");
         for (const s of wantSchemas) {
             await (0, schemaMigration_1.migrateSchema)({
                 options,
-                schema: s,
+                schema: s.schema,
                 validateOnly: false,
+                schemaValidation: s.validationMode,
             });
         }
         utils.logLabeledBullet("dataconnect", "Schemas released.");

package/lib/deploy/extensions/deploymentSummary.js

@@ -47,10 +47,11 @@ function configuresSummary(toConfigure) {
         : "";
 }
 exports.configuresSummary = configuresSummary;
-function deletesSummary(toDelete) {
+function deletesSummary(toDelete, isDynamic) {
     const instancesToDelete = toDelete.map((s) => `\t${(0, exports.humanReadable)(s)}`).join("\n");
+    const definedLocation = isDynamic ? "your local source code" : "'firebase.json'";
     return toDelete.length
-        ? `The following extension instances are not listed in 'firebase.json':\n${instancesToDelete}\n`
+        ? `The following extension instances are found in your project but do not exist in ${definedLocation}:\n${instancesToDelete}\n`
         : "";
 }
 exports.deletesSummary = deletesSummary;

package/lib/deploy/extensions/planner.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVersion = exports.want = exports.wantDynamic = exports.have = exports.getExtensionSpec = exports.getExtension = exports.getExtensionVersion = void 0;
+exports.resolveVersion = exports.want = exports.wantDynamic = exports.have = exports.haveDynamic = exports.getExtensionSpec = exports.getExtension = exports.getExtensionVersion = void 0;
 const semver = require("semver");
 const extensionsApi = require("../../extensions/extensionsApi");
 const refs = require("../../extensions/refs");
@@ -49,9 +49,33 @@ async function getExtensionSpec(i) {
     return i.extensionSpec;
 }
 exports.getExtensionSpec = getExtensionSpec;
+async function haveDynamic(projectId) {
+    return (await extensionsApi.listInstances(projectId))
+        .filter((i) => { var _a; return ((_a = i.labels) === null || _a === void 0 ? void 0 : _a.createdBy) === "SDK"; })
+        .map((i) => {
+        var _a;
+        const dep = {
+            instanceId: i.name.split("/").pop(),
+            params: i.config.params,
+            systemParams: (_a = i.config.systemParams) !== null && _a !== void 0 ? _a : {},
+            allowedEventTypes: i.config.allowedEventTypes,
+            eventarcChannel: i.config.eventarcChannel,
+            etag: i.etag,
+            labels: i.labels,
+        };
+        if (i.config.extensionRef) {
+            const ref = refs.parse(i.config.extensionRef);
+            dep.ref = ref;
+            dep.ref.version = i.config.extensionVersion;
+        }
+        return dep;
+    });
+}
+exports.haveDynamic = haveDynamic;
 async function have(projectId) {
-    const instances = await extensionsApi.listInstances(projectId);
-    return instances.map((i) => {
+    return (await extensionsApi.listInstances(projectId))
+        .filter((i) => { var _a; return !(((_a = i.labels) === null || _a === void 0 ? void 0 : _a.createdBy) === "SDK"); })
+        .map((i) => {
         var _a;
         const dep = {
             instanceId: i.name.split("/").pop(),
@@ -61,6 +85,9 @@ async function have(projectId) {
             eventarcChannel: i.config.eventarcChannel,
             etag: i.etag,
         };
+        if (i.labels) {
+            dep.labels = i.labels;
+        }
         if (i.config.extensionRef) {
             const ref = refs.parse(i.config.extensionRef);
             dep.ref = ref;
@@ -97,6 +124,7 @@ async function wantDynamic(args) {
                 systemParams,
                 allowedEventTypes,
                 eventarcChannel,
+                labels: ext.labels,
             });
         }
         else if (ext.ref) {
@@ -107,6 +135,7 @@ async function wantDynamic(args) {
                 systemParams,
                 allowedEventTypes,
                 eventarcChannel,
+                labels: ext.labels,
             });
         }
     }