firebase-tools 15.9.1 → 15.10.0

package/lib/emulator/hubExport.js

@@ -19,6 +19,7 @@ class HubExport {
         this.projectId = projectId;
         this.options = options;
         this.exportPath = options.path;
+        this.exportTargets = options.targets ?? [...types_1.IMPORT_EXPORT_EMULATORS];
         this.tmpDir = fs.mkdtempSync(`firebase-export-${new Date().getTime()}`);
     }
     static readMetadata(exportPath) {
@@ -36,14 +37,14 @@ class HubExport {
         }
     }
     async exportAll() {
-        const toExport = types_1.ALL_EMULATORS.filter(shouldExport);
+        const toExport = types_1.ALL_EMULATORS.filter(shouldExport).filter((e) => this.exportTargets.includes(e));
         if (toExport.length === 0) {
             throw new error_1.FirebaseError("No running emulators support import/export.");
         }
         const metadata = {
             version: hub_1.EmulatorHub.CLI_VERSION,
         };
-        if (shouldExport(types_1.Emulators.FIRESTORE)) {
+        if (shouldExport(types_1.Emulators.FIRESTORE) && toExport.includes(types_1.Emulators.FIRESTORE)) {
             metadata.firestore = {
                 version: (0, downloadableEmulators_1.getDownloadDetails)(types_1.Emulators.FIRESTORE).version,
                 path: "firestore_export",
@@ -51,28 +52,28 @@ class HubExport {
             };
             await this.exportFirestore(metadata);
         }
-        if (shouldExport(types_1.Emulators.DATABASE)) {
+        if (shouldExport(types_1.Emulators.DATABASE) && toExport.includes(types_1.Emulators.DATABASE)) {
             metadata.database = {
                 version: (0, downloadableEmulators_1.getDownloadDetails)(types_1.Emulators.DATABASE).version,
                 path: "database_export",
             };
             await this.exportDatabase(metadata);
         }
-        if (shouldExport(types_1.Emulators.AUTH)) {
+        if (shouldExport(types_1.Emulators.AUTH) && toExport.includes(types_1.Emulators.AUTH)) {
             metadata.auth = {
                 version: hub_1.EmulatorHub.CLI_VERSION,
                 path: "auth_export",
             };
             await this.exportAuth(metadata);
         }
-        if (shouldExport(types_1.Emulators.STORAGE)) {
+        if (shouldExport(types_1.Emulators.STORAGE) && toExport.includes(types_1.Emulators.STORAGE)) {
             metadata.storage = {
                 version: hub_1.EmulatorHub.CLI_VERSION,
                 path: "storage_export",
             };
             await this.exportStorage(metadata);
         }
-        if (shouldExport(types_1.Emulators.DATACONNECT)) {
+        if (shouldExport(types_1.Emulators.DATACONNECT) && toExport.includes(types_1.Emulators.DATACONNECT)) {
             metadata.dataconnect = {
                 version: hub_1.EmulatorHub.CLI_VERSION,
                 path: "dataconnect_export",

package/lib/experiments.js

@@ -104,6 +104,11 @@ exports.ALL_EXPERIMENTS = experiments({
         default: true,
         public: false,
     },
+    apphostinglocalbuilds: {
+        shortDescription: "Enable App Hosting local builds",
+        default: false,
+        public: false,
+    },
     dataconnect: {
         shortDescription: "Deprecated. Previosuly, enabled Data Connect related features.",
         fullDescription: "Deprecated. Previously, enabled Data Connect related features.",
@@ -145,11 +150,6 @@ exports.ALL_EXPERIMENTS = experiments({
         default: true,
         public: false,
     },
-    studioexport: {
-        shortDescription: "Enable the experimental studio:export command.",
-        default: false,
-        public: false,
-    },
 });
 function isValidExperiment(name) {
     return Object.keys(exports.ALL_EXPERIMENTS).includes(name);

package/lib/firebase_studio/migrate.js

@@ -7,13 +7,88 @@ const fs = require("fs/promises");
 const path = require("path");
 const child_process_1 = require("child_process");
 const logger_1 = require("../logger");
-const error_1 = require("../error");
 const prompt = require("../prompt");
 const apphosting = require("../gcp/apphosting");
 const utils = require("../utils");
 const templates_1 = require("../templates");
+const track = require("../track");
 const secrets_1 = require("../apphosting/secrets");
 const env = require("../functions/env");
+const error_1 = require("../error");
+const os = require("os");
+async function setupAntigravityMcpServer(rootPath) {
+    const mcpConfigDir = path.join(os.homedir(), ".gemini", "antigravity");
+    const mcpConfigPath = path.join(mcpConfigDir, "mcp_config.json");
+    let mcpConfig = { mcpServers: {} };
+    try {
+        await fs.mkdir(mcpConfigDir, { recursive: true });
+        const content = await fs
+            .readFile(mcpConfigPath, "utf-8")
+            .catch((err) => {
+            if (err.code === "ENOENT") {
+                return null;
+            }
+            throw err;
+        });
+        if (content) {
+            mcpConfig = JSON.parse(content);
+            if (!mcpConfig.mcpServers) {
+                mcpConfig.mcpServers = {};
+            }
+        }
+        if (mcpConfig.mcpServers["firebase"]) {
+            logger_1.logger.info("ℹ️ Firebase MCP server already configured in Antigravity, skipping.");
+            return;
+        }
+        mcpConfig.mcpServers["firebase"] = {
+            command: "npx",
+            args: ["-y", "firebase-tools@latest", "mcp", "--dir", path.resolve(rootPath)],
+        };
+        await fs.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+        logger_1.logger.info(`✅ Configured Firebase MCP server in ${mcpConfigPath}`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        utils.logWarning(`Could not configure Antigravity MCP server: ${message}`);
+    }
+}
+async function detectAppType(rootPath) {
+    try {
+        await fs.access(path.join(rootPath, "pubspec.yaml"));
+        return "FLUTTER";
+    }
+    catch {
+    }
+    try {
+        await fs.access(path.join(rootPath, "angular.json"));
+        return "ANGULAR";
+    }
+    catch {
+    }
+    try {
+        const packageJsonPath = path.join(rootPath, "package.json");
+        const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
+        const packageJson = JSON.parse(packageJsonContent);
+        const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        if (deps.next) {
+            return "NEXT_JS";
+        }
+        if (deps["@angular/core"]) {
+            return "ANGULAR";
+        }
+    }
+    catch {
+    }
+    for (const configFile of ["next.config.js", "next.config.mjs"]) {
+        try {
+            await fs.access(path.join(rootPath, configFile));
+            return "NEXT_JS";
+        }
+        catch {
+        }
+    }
+    return "OTHER";
+}
 async function downloadGitHubDir(apiUrl, localPath) {
     const response = await fetch(apiUrl);
     if (!response.ok) {
@@ -35,6 +110,10 @@ async function downloadGitHubDir(apiUrl, localPath) {
         }
     }
 }
+const isValidFirebaseProjectId = (projectId) => {
+    const projectIdRegex = /^[a-z][a-z0-9-]{4,28}[a-z0-9]$/;
+    return projectIdRegex.test(projectId);
+};
 async function extractMetadata(rootPath, overrideProjectId) {
     const metadataPath = path.join(rootPath, "metadata.json");
     let metadata = {};
@@ -45,6 +124,8 @@ async function extractMetadata(rootPath, overrideProjectId) {
     catch (err) {
         logger_1.logger.debug(`Could not read metadata.json at ${metadataPath}: ${err}`);
     }
+    logger_1.logger.debug(`overrideProjectId ${overrideProjectId}`);
+    logger_1.logger.debug(`metadata.projectId ${metadata.projectId}`);
     let projectId = overrideProjectId || metadata.projectId;
     if (!projectId) {
         try {
@@ -57,10 +138,15 @@ async function extractMetadata(rootPath, overrideProjectId) {
         }
     }
     if (projectId) {
-        logger_1.logger.info(`✅ Detected Firebase Project: ${projectId}`);
+        if (!isValidFirebaseProjectId(projectId)) {
+            throw new error_1.FirebaseError(`Invalid project ID: ${projectId}.`, {
+                exit: 1,
+            });
+        }
+        logger_1.logger.info(`✅ Using Firebase Project: ${projectId}`);
     }
     else {
-        logger_1.logger.info(`✅ Failed to determine the Firebase Project ID`);
+        logger_1.logger.info(`❌ Failed to determine the Firebase Project ID. You can set a project later with 'firebase use <project-id>' or by setting the '--project' flag.`);
     }
     let appName = "firebase-studio-export";
     let blueprintContent = "";
@@ -90,15 +176,15 @@ async function updateReadme(rootPath, blueprintContent, appName) {
     await fs.writeFile(readmePath, newReadme);
     logger_1.logger.info("✅ Updated README.md with project details and origin info");
 }
-async function injectAgyContext(rootPath, projectId, appName) {
-    const agentDir = path.join(rootPath, ".agent");
+async function injectAntigravityContext(rootPath, projectId, appName) {
+    const agentDir = path.join(rootPath, ".agents");
     const rulesDir = path.join(agentDir, "rules");
     const workflowsDir = path.join(agentDir, "workflows");
     const skillsDir = path.join(agentDir, "skills");
     await fs.mkdir(rulesDir, { recursive: true });
     await fs.mkdir(workflowsDir, { recursive: true });
     await fs.mkdir(skillsDir, { recursive: true });
-    logger_1.logger.info("⏳ Fetching AGY skills from firebase/agent-skills...");
+    logger_1.logger.info("⏳ Fetching Antigravity skills from firebase/agent-skills...");
     try {
         const skillsResponse = await fetch("https://api.github.com/repos/firebase/agent-skills/contents/skills");
         if (!skillsResponse.ok) {
@@ -120,44 +206,58 @@ async function injectAgyContext(rootPath, projectId, appName) {
         logger_1.logger.info(`✅ Downloaded Firebase skills`);
     }
     catch (err) {
-        utils.logWarning(`Could not download AGY skills, skipping. ${err}`);
-    }
-    logger_1.logger.info("⏳ Fetching Genkit skill...");
-    try {
-        const genkitSkillDir = path.join(skillsDir, "developing-genkit-js");
-        await downloadGitHubDir("https://api.github.com/repos/genkit-ai/skills/contents/skills/developing-genkit-js?ref=main", genkitSkillDir);
-        logger_1.logger.info(`✅ Downloaded Genkit skill`);
-    }
-    catch (err) {
-        utils.logWarning(`Could not download Genkit skill, skipping. ${err}`);
+        utils.logWarning(`Could not download Antigravity skills, skipping. ${err}`);
     }
     const systemInstructionsTemplate = await (0, templates_1.readTemplate)("firebase-studio-export/system_instructions_template.md");
     const systemInstructions = systemInstructionsTemplate
         .replace("${projectId}", projectId || "None")
         .replace("${appName}", appName);
     await fs.writeFile(path.join(rulesDir, "migration-context.md"), systemInstructions);
-    logger_1.logger.info("✅ Injected AGY rules");
+    logger_1.logger.info("✅ Injected Antigravity rules");
     try {
         const startupWorkflow = await (0, templates_1.readTemplate)("firebase-studio-export/workflows/startup_workflow.md");
         await fs.writeFile(path.join(workflowsDir, "startup.md"), startupWorkflow);
-        logger_1.logger.info("✅ Created AGY startup workflow");
+        logger_1.logger.info("✅ Created Antigravity startup workflow");
     }
     catch (err) {
-        logger_1.logger.debug(`Could not read or write startup workflow: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not read or write startup workflow: ${message}`);
     }
 }
-async function assertSystemState(startAgy) {
-    if (startAgy === false) {
-        return;
+async function getAgyCommand(startAgy) {
+    if (!startAgy) {
+        return undefined;
+    }
+    const commands = ["agy", "antigravity"];
+    for (const cmd of commands) {
+        if (utils.commandExistsSync(cmd)) {
+            logger_1.logger.info(`✅ Antigravity IDE detected`);
+            return cmd;
+        }
     }
-    try {
-        (0, child_process_1.execSync)("agy --version", { stdio: "ignore" });
-        logger_1.logger.info("✅ Antigravity IDE CLI (agy) detected");
+    if (process.platform === "darwin") {
+        const macPath = "/Applications/Antigravity.app/Contents/Resources/app/bin/agy";
+        try {
+            await fs.access(macPath);
+            logger_1.logger.info(`✅ Antigravity IDE detected at ${macPath}`);
+            return macPath;
+        }
+        catch {
+        }
     }
-    catch (err) {
-        const downloadLink = "https://antigravity.google/download";
-        throw new error_1.FirebaseError(`Antigravity IDE CLI (agy) not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`, { exit: 1 });
+    if (process.platform === "win32") {
+        const winPath = path.join(process.env.LOCALAPPDATA || "", "Programs", "Antigravity", "bin", "agy.exe");
+        try {
+            await fs.access(winPath);
+            logger_1.logger.info(`✅ Antigravity IDE CLI detected at ${winPath}`);
+            return winPath;
+        }
+        catch {
+        }
     }
+    const downloadLink = "https://antigravity.google/download";
+    logger_1.logger.info(`⚠️ Antigravity IDE not found in your PATH. To ensure a seamless migration, please download and install Antigravity: ${downloadLink}`);
+    return undefined;
 }
 async function createFirebaseConfigs(rootPath, projectId) {
     if (!projectId) {
@@ -196,7 +296,8 @@ async function createFirebaseConfigs(rootPath, projectId) {
             }
         }
         catch (err) {
-            utils.logWarning(`Could not fetch backends from Firebase CLI, using default "studio". ${err}`);
+            const message = err instanceof Error ? err.message : String(err);
+            utils.logWarning(`Could not fetch backends from Firebase CLI, using default "studio". ${message}`);
         }
         const firebaseJson = {
             apphosting: {
@@ -204,7 +305,7 @@ async function createFirebaseConfigs(rootPath, projectId) {
                 ignore: [
                     "node_modules",
                     ".git",
-                    ".agent",
+                    ".agents",
                     ".idx",
                     "firebase-debug.log",
                     "firebase-debug.*.log",
@@ -216,7 +317,7 @@ async function createFirebaseConfigs(rootPath, projectId) {
         logger_1.logger.info(`✅ Created firebase.json with backendId: ${backendId}`);
     }
 }
-async function writeAgyConfigs(rootPath) {
+async function writeAntigravityConfigs(rootPath) {
     const vscodeDir = path.join(rootPath, ".vscode");
     await fs.mkdir(vscodeDir, { recursive: true });
     const tasksJson = {
@@ -239,7 +340,8 @@ async function writeAgyConfigs(rootPath) {
         settings = JSON.parse(settingsContent);
     }
     catch (err) {
-        logger_1.logger.debug(`Could not read ${settingsPath}: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not read ${settingsPath}: ${message}`);
     }
     const cleanSettings = {};
     for (const [key, value] of Object.entries(settings)) {
@@ -270,14 +372,6 @@ async function writeAgyConfigs(rootPath) {
 }
 async function cleanupUnusedFiles(rootPath) {
     const docsDir = path.join(rootPath, "docs");
-    const blueprintPath = path.join(docsDir, "blueprint.md");
-    try {
-        await fs.unlink(blueprintPath);
-        logger_1.logger.info("✅ Cleaned up docs/blueprint.md");
-    }
-    catch (err) {
-        logger_1.logger.debug(`Could not delete ${blueprintPath}: ${err}`);
-    }
     try {
         const files = await fs.readdir(docsDir);
         if (files.length === 0) {
@@ -286,15 +380,8 @@ async function cleanupUnusedFiles(rootPath) {
         }
     }
     catch (err) {
-        logger_1.logger.debug(`Could not remove ${docsDir}: ${err}`);
-    }
-    const metadataPath = path.join(rootPath, "metadata.json");
-    try {
-        await fs.unlink(metadataPath);
-        logger_1.logger.info("✅ Cleaned up metadata.json");
-    }
-    catch (err) {
-        logger_1.logger.debug(`Could not delete ${metadataPath}: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not remove ${docsDir}: ${message}`);
     }
     const modifiedPath = path.join(rootPath, ".modified");
     try {
@@ -302,7 +389,8 @@ async function cleanupUnusedFiles(rootPath) {
         logger_1.logger.info("✅ Cleaned up .modified");
     }
     catch (err) {
-        logger_1.logger.debug(`Could not delete ${modifiedPath}: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger_1.logger.debug(`Could not delete ${modifiedPath}: ${message}`);
     }
 }
 async function uploadSecrets(rootPath, projectId) {
@@ -330,49 +418,57 @@ async function uploadSecrets(rootPath, projectId) {
         }
     }
     catch (err) {
-        utils.logWarning(`Failed to upload GEMINI_API_KEY secret: ${err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        utils.logWarning(`Failed to upload GEMINI_API_KEY secret: ${message}`);
     }
 }
-async function askToOpenAntigravity(rootPath, appName, startAgy) {
-    if (startAgy === false) {
-        logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
+async function askToOpenAntigravity(rootPath, appName, startAntigravity) {
+    const agyCommand = await getAgyCommand(startAntigravity);
+    logger_1.logger.info(`\n🎉 Your Firebase Studio project "${appName}" is now ready for Antigravity!`);
+    logger_1.logger.info("Antigravity is Google's agentic IDE, where you can collaborate with AI agents to build, test, and deploy your application.");
+    logger_1.logger.info("\nWhat to do next inside Antigravity:");
+    logger_1.logger.info("  1.  Review the README.md: It has been updated with specifics about this migrated project.");
+    logger_1.logger.info("  2.  Open the Agent Chat: Use the side panel or press Cmd+L (Ctrl+L on Windows/Linux). This is your main interface with the AI.");
+    logger_1.logger.info("\nFile any bugs at https://github.com/firebase/firebase-tools/issues");
+    if (!startAntigravity || !agyCommand) {
         return;
     }
     const answer = await prompt.confirm({
-        message: `Migration complete for ${appName}! Would you like to open it in Antigravity now?`,
+        message: "Would you like to open it in Antigravity now?",
         default: true,
     });
     if (answer) {
         logger_1.logger.info(`⏳ Opening ${appName} in Antigravity...`);
         try {
-            const agyProcess = (0, child_process_1.spawn)("agy", ["."], {
+            const antigravityProcess = (0, child_process_1.spawn)(agyCommand, ["."], {
                 cwd: rootPath,
                 stdio: "ignore",
                 detached: true,
+                shell: process.platform === "win32",
             });
-            agyProcess.unref();
+            antigravityProcess.unref();
         }
         catch (err) {
             utils.logWarning("Could not open Antigravity IDE automatically. Please open it manually.");
         }
     }
-    else {
-        logger_1.logger.info('\n👉 Next steps: Open this folder in Antigravity and run the "Initial Project Setup" workflow.');
-    }
 }
-async function migrate(rootPath, options = { startAgy: true }) {
+async function migrate(rootPath, options = { startAntigravity: true }) {
+    const appType = await detectAppType(rootPath);
+    void track.trackGA4("firebase_studio_migrate", { app_type: appType, result: "started" });
     logger_1.logger.info("🚀 Starting Firebase Studio to Antigravity migration...");
-    await assertSystemState(options.startAgy);
     const { projectId, appName, blueprintContent } = await extractMetadata(rootPath, options.project);
     await updateReadme(rootPath, blueprintContent, appName);
     await createFirebaseConfigs(rootPath, projectId);
     await uploadSecrets(rootPath, projectId);
-    await injectAgyContext(rootPath, projectId, appName);
-    await writeAgyConfigs(rootPath);
+    await injectAntigravityContext(rootPath, projectId, appName);
+    await writeAntigravityConfigs(rootPath);
+    await setupAntigravityMcpServer(rootPath);
     await cleanupUnusedFiles(rootPath);
     const currentFolderName = path.basename(rootPath);
     if (currentFolderName === "download") {
-        logger_1.logger.info(`\n💡 Tip: You might want to rename this folder to "${appName.toLowerCase().replace(/\s+/g, "-")}"`);
+        logger_1.logger.info(`\n💡 Tip: You may want to rename this folder to "${appName.toLowerCase().replace(/\s+/g, "-")}"`);
     }
-    await askToOpenAntigravity(rootPath, appName, options.startAgy);
+    await track.trackGA4("firebase_studio_migrate", { app_type: appType, result: "success" });
+    await askToOpenAntigravity(rootPath, appName, options.startAntigravity);
 }

package/lib/gcp/cloudfunctionsv2.js

@@ -187,12 +187,22 @@ function functionFromEndpoint(endpoint) {
         return String(cpu);
     });
     if (endpoint.vpc) {
-        proto.renameIfPresent(gcfFunction.serviceConfig, endpoint.vpc, "vpcConnector", "connector");
-        proto.renameIfPresent(gcfFunction.serviceConfig, endpoint.vpc, "vpcConnectorEgressSettings", "egressSettings");
+        if (endpoint.vpc.connector) {
+            gcfFunction.serviceConfig.vpcConnector = endpoint.vpc.connector;
+            gcfFunction.serviceConfig.vpcConnectorEgressSettings = endpoint.vpc.egressSettings || null;
+        }
+        else if (endpoint.vpc.networkInterfaces) {
+            gcfFunction.serviceConfig.directVpcNetworkInterface = endpoint.vpc.networkInterfaces;
+            gcfFunction.serviceConfig.directVpcEgress = endpoint.vpc.egressSettings
+                ? `VPC_EGRESS_${endpoint.vpc.egressSettings}`
+                : null;
+        }
     }
     else if (endpoint.vpc === null) {
         gcfFunction.serviceConfig.vpcConnector = null;
         gcfFunction.serviceConfig.vpcConnectorEgressSettings = null;
+        gcfFunction.serviceConfig.directVpcNetworkInterface = null;
+        gcfFunction.serviceConfig.directVpcEgress = null;
     }
     if (backend.isEventTriggered(endpoint)) {
         gcfFunction.eventTrigger = {
@@ -384,6 +394,17 @@ function endpointFromFunction(gcfFunction) {
             endpoint.vpc = { connector: gcfFunction.serviceConfig.vpcConnector };
             proto.renameIfPresent(endpoint.vpc, gcfFunction.serviceConfig, "egressSettings", "vpcConnectorEgressSettings");
         }
+        else if (gcfFunction.serviceConfig.directVpcNetworkInterface) {
+            endpoint.vpc = { networkInterfaces: gcfFunction.serviceConfig.directVpcNetworkInterface };
+            if (gcfFunction.serviceConfig.directVpcEgress) {
+                if (!gcfFunction.serviceConfig.directVpcEgress.startsWith("VPC_EGRESS_")) {
+                    throw new error_1.FirebaseError(`Unexpected VPC egress setting: ${gcfFunction.serviceConfig.directVpcEgress}`);
+                }
+                if (gcfFunction.serviceConfig.directVpcEgress !== "VPC_EGRESS_UNSPECIFIED") {
+                    endpoint.vpc.egressSettings = gcfFunction.serviceConfig.directVpcEgress.substring("VPC_EGRESS_".length);
+                }
+            }
+        }
         const serviceName = gcfFunction.serviceConfig.service;
         if (!serviceName) {
             logger_1.logger.debug("Got a v2 function without a service name." +

package/lib/gcp/cloudsql/permissionsSetup.js

@@ -125,9 +125,9 @@ async function setupSQLPermissions(instanceId, databaseId, schemaInfo, options,
 }
 async function greenFieldSchemaSetup(instanceId, databaseId, schema, options) {
     const revokes = [];
-    if (await checkSQLRoleIsGranted(options, instanceId, databaseId, "cloudsqlsuperuser", (0, permissions_1.firebaseowner)(databaseId))) {
+    if (await checkSQLRoleIsGranted(options, instanceId, databaseId, "cloudsqlsuperuser", (0, permissions_1.firebaseowner)(databaseId, schema))) {
         logger_1.logger.warn("Detected cloudsqlsuperuser was previously given to firebase owner, revoking to improve database security.");
-        revokes.push(`REVOKE "cloudsqlsuperuser" FROM "${(0, permissions_1.firebaseowner)(databaseId)}"`);
+        revokes.push(`REVOKE "cloudsqlsuperuser" FROM "${(0, permissions_1.firebaseowner)(databaseId, schema)}"`);
     }
     const user = (await (0, connect_1.getIAMUser)(options)).user;
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
@@ -222,10 +222,10 @@ async function brownfieldSqlSetup(instanceId, databaseId, schemaInfo, options, s
     ];
     await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, brownfieldSetupCmds, silent, true);
 }
-async function grantRoleTo(options, instanceId, databaseId, role, email) {
+async function grantRoleTo(options, instanceId, databaseId, role, email, schema = permissions_1.DEFAULT_SCHEMA) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const { user, mode } = (0, connect_2.toDatabaseUser)(email);
     await cloudSqlAdminClient.createUser(projectId, instanceId, mode, user);
-    const fdcSqlRole = exports.fdcSqlRoleMap[role](databaseId);
+    const fdcSqlRole = exports.fdcSqlRoleMap[role](databaseId, schema);
     await (0, connect_1.executeSqlCmdsAsSuperUser)(options, instanceId, databaseId, [`GRANT "${fdcSqlRole}" TO "${user}"`], false);
 }